modules/tool-classfile/src/main/java/net/multiphasicapps/classfile/InstructionJumpTargets.java

   1 // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the GNU General Public License v3+, or later.
   7 // See license.mkd for licensing and copyright information.
   8 // ---------------------------------------------------------------------------
   9
  10 package net.multiphasicapps.classfile;
  11
  12 import cc.squirreljme.runtime.cldc.debug.Debugging;
  13 import cc.squirreljme.runtime.cldc.util.SortedTreeSet;
  14 import java.lang.ref.Reference;
  15 import java.lang.ref.WeakReference;
  16 import java.util.Arrays;
  17 import java.util.Set;
  18
  19 /**
  20  * This represents the targets of jumps that an instruction may jump to.
  21  *
  22  * @since 2019/03/30
  23  */
  24 public final class InstructionJumpTargets
  25 {
  26         /** Normal jumps. */
  27         private final InstructionJumpTarget[] _normal;
  28
  29         /** Exceptional jumps. */
  30         private final InstructionJumpTarget[] _exception;
  31
  32         /** String representation. */
  33         private Reference<String> _string;
  34
  35         /** Hashcode. */
  36         private int _hash;
  37
  38         /**
  39          * Initializes empty jump targets.
  40          *
  41          * @since 2019/04/11
  42          */
  43         public InstructionJumpTargets()
  44         {
  45                 this._normal = new InstructionJumpTarget[0];
  46                 this._exception = new InstructionJumpTarget[0];
  47         }
  48
  49         /**
  50          * Initializes the jump targets.
  51          * @param __n Normal jumps.
  52          * @param __e Exceptional jumps.
  53          * @throws NullPointerException On null arguments.
  54          * @since 2019/03/30
  55          */
  56         public InstructionJumpTargets(InstructionJumpTarget[] __n,
  57                 InstructionJumpTarget[] __e)
  58                 throws NullPointerException
  59         {
  60                 if (__n == null || __e == null)
  61                         throw new NullPointerException("NARG");
  62
  63                 // Load into sorted sets
  64                 Set<InstructionJumpTarget> nrm = new SortedTreeSet<>(),
  65                         exe = new SortedTreeSet<>();
  66
  67                 // Add normals
  68                 for (InstructionJumpTarget i : __n)
  69                         if (i == null)
  70                                 throw new NullPointerException("NARG");
  71                         else
  72                                 nrm.add(i);
  73
  74                 // Add exceptional
  75                 for (InstructionJumpTarget i : __e)
  76                         if (i == null)
  77                                 throw new NullPointerException("NARG");
  78                         else
  79                                 exe.add(i);
  80
  81                 // Set
  82                 this._normal = nrm.<InstructionJumpTarget>toArray(
  83                         new InstructionJumpTarget[nrm.size()]);
  84                 this._exception = exe.<InstructionJumpTarget>toArray(
  85                         new InstructionJumpTarget[exe.size()]);
  86         }
  87
  88         /**
  89          * {@inheritDoc}
  90          * @since 2019/03/30
  91          */
  92         @Override
  93         public final boolean equals(Object __o)
  94         {
  95                 throw Debugging.todo();
  96         }
  97
  98         /**
  99          * Obtains the given jump target.
 100          *
 101          * @param __i The index.
 102          * @return The target jump target.
 103          * @since 2019/03/31
 104          */
 105         public final InstructionJumpTarget get(int __i)
 106         {
 107                 InstructionJumpTarget[] normal = this._normal;
 108                 int numnormal = normal.length;
 109
 110                 // Treat both arrays as a single part
 111                 if (__i >= numnormal)
 112                         return this._exception[__i - numnormal];
 113                 return this._normal[__i];
 114         }
 115
 116         /**
 117          * {@inheritDoc}
 118          * @since 2019/03/30
 119          */
 120         @Override
 121         public final int hashCode()
 122         {
 123                 throw Debugging.todo();
 124         }
 125
 126         /**
 127          * Checks if any of the jump targets has an address which follows the
 128          * given address.
 129          *
 130          * @param __pc The address to check.
 131          * @return True if any address in the jump targets has an address which
 132          * is higher than this address.
 133          * @since 2019/03/30
 134          */
 135         public final boolean hasLaterAddress(int __pc)
 136         {
 137                 for (int i = 0, n = this.size(); i < n; i++)
 138                         if (this.get(i).target() > __pc)
 139                                 return true;
 140
 141                 return false;
 142         }
 143
 144         /**
 145          * Checks if any of the jump targets has an address which is or follows
 146          * the given address.
 147          *
 148          * @param __pc The address to check.
 149          * @return True if any address in the jump targets has an address which
 150          * is the same or higher than this address.
 151          * @since 2019/04/11
 152          */
 153         public final boolean hasSameOrLaterAddress(int __pc)
 154         {
 155                 for (int i = 0, n = this.size(); i < n; i++)
 156                         if (this.get(i).target() >= __pc)
 157                                 return true;
 158
 159                 return false;
 160         }
 161
 162         /**
 163          * Returns if this is empty or not.
 164          *
 165          * @return If this is empty or not.
 166          * @since 2019/03/31
 167          */
 168         public final boolean isEmpty()
 169         {
 170                 return this.size() == 0;
 171         }
 172
 173         /**
 174          * Returns if this is an exception jump.
 175          *
 176          * @param __i The index to get.
 177          * @return If this is an exception index.
 178          * @since 2019/03/31
 179          */
 180         public final boolean isException(int __i)
 181         {
 182                 return __i >= this._normal.length;
 183         }
 184
 185         /**
 186          * Returns the number of jump targets.
 187          *
 188          * @return The number of jump targets.
 189          * @since 2019/03/31
 190          */
 191         public final int size()
 192         {
 193                 return this._normal.length + this._exception.length;
 194         }
 195
 196         /**
 197          * {@inheritDoc}
 198          * @since 2019/03/30
 199          */
 200         @Override
 201         public final String toString()
 202         {
 203                 Reference<String> ref = this._string;
 204                 String rv;
 205
 206                 if (ref == null || null == (rv = ref.get()))
 207                         this._string = new WeakReference<>((rv =
 208                                 "[N:" + Arrays.asList(this._normal) +
 209                                 ", E: " + Arrays.asList(this._exception) + "]"));
 210
 211                 return rv;
 212         }
 213 }
 214