Changeset 15350


Ignore:
Timestamp:
07/23/20 05:12:08 (3 years ago)
Author:
Mark Evenson
Message:

Refactor naming for coerce methods

Location:
trunk/abcl/src/org/armedbear/lisp
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/abcl/src/org/armedbear/lisp/BasicVector_ByteBuffer.java

    r15305 r15350  
    8181    for (int i = array.length; i-- > 0;) {
    8282      // Faster please!
    83       elements.put((byte)coerceLispObjectToJavaByte(array[i]));
     83      elements.put((byte)coerceToJavaByte(array[i]));
    8484    }
    8585  }
    … …  
    144144  public LispObject elt(int index) {
    145145    try {
    146       return coerceJavaByteToLispObject(elements.get(index));
     146      return coerceFromJavaByte(elements.get(index));
    147147    } catch (IndexOutOfBoundsException e) {
    148148      badIndex(index, capacity);
    … …  
    165165  public LispObject AREF(int index) {
    166166    try {
    167       return coerceJavaByteToLispObject(elements.get(index));
     167      return coerceFromJavaByte(elements.get(index));
    168168    } catch (IndexOutOfBoundsException e) {
    169169      badIndex(index, elements.limit());
    … …  
    184184  public void aset(int index, LispObject value) {
    185185    try {
    186         elements.put(index, coerceLispObjectToJavaByte(value));
     186        elements.put(index, coerceToJavaByte(value));
    187187    } catch (IndexOutOfBoundsException e) {
    188188      badIndex(index, capacity);
    … …  
    280280        LispObject list = initialContents;
    281281        for (int i = 0; i < newCapacity; i++) {
    282           newElements.put(i, coerceLispObjectToJavaByte(list.car()));
     282          newElements.put(i, coerceToJavaByte(list.car()));
    283283          list = list.cdr();
    284284        }
    285285      } else if (initialContents.vectorp()) {
    286286        for (int i = 0; i < newCapacity; i++)
    287           newElements.put(i, coerceLispObjectToJavaByte(initialContents.elt(i)));
     287          newElements.put(i, coerceToJavaByte(initialContents.elt(i)));
    288288      } else
    289289        type_error(initialContents, Symbol.SEQUENCE);

  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java

    r15143 r15350  
    6262    elements = new byte[capacity];
    6363    for (int i = array.length; i-- > 0;)
    64       elements[i] = coerceLispObjectToJavaByte(array[i]);
     64      elements[i] = coerceToJavaByte(array[i]);
    6565  }
    6666
    … …  
    128128    try
    129129      {
    130         return coerceJavaByteToLispObject(elements[index]);
     130        return coerceFromJavaByte(elements[index]);
    131131      }
    132132    catch (ArrayIndexOutOfBoundsException e)
    … …  
    157157    try
    158158      {
    159         return coerceJavaByteToLispObject(elements[index]);
     159        return coerceFromJavaByte(elements[index]);
    160160      }
    161161    catch (ArrayIndexOutOfBoundsException e)
    … …  
    184184    try
    185185      {
    186         elements[index] = coerceLispObjectToJavaByte(value);
     186        elements[index] = coerceToJavaByte(value);
    187187      }
    188188    catch (ArrayIndexOutOfBoundsException e)

  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_ByteBuffer.java

    r15305 r15350  
    106106    if (dims.length == 0) {
    107107      try {
    108         data.put(index, coerceLispObjectToJavaByte(contents));
     108        data.put(index, coerceToJavaByte(contents));
    109109      }
    110110      catch (IndexOutOfBoundsException e) {
    … …  
    212212    if (data != null) {
    213213      try {
    214         return coerceJavaByteToLispObject(data.get(index));
     214        return coerceFromJavaByte(data.get(index));
    215215      }
    216216      catch (IndexOutOfBoundsException e) {
    … …  
    226226    if (data != null) {
    227227      try {
    228         data.put(index, coerceLispObjectToJavaByte(newValue));
     228        data.put(index, coerceToJavaByte(newValue));
    229229      }
    230230      catch (IndexOutOfBoundsException e) {
    … …  
    303303        }
    304304        if (initialElement != null) {
    305           fill(newBuffer, coerceLispObjectToJavaByte(initialElement));           
     305          fill(newBuffer, coerceToJavaByte(initialElement));           
    306306        }
    307307        this.data = newBuffer;

  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java

    r15143 r15350  
    8484        if (dims.length == 0) {
    8585            try {
    86                 data[index] = coerceLispObjectToJavaByte(contents);
     86                data[index] = coerceToJavaByte(contents);
    8787            }
    8888            catch (ArrayIndexOutOfBoundsException e) {
    … …  
    190190        if (data != null) {
    191191            try {
    192                 return coerceJavaByteToLispObject(data[index]);
     192                return coerceFromJavaByte(data[index]);
    193193            }
    194194            catch (ArrayIndexOutOfBoundsException e) {
    … …  
    204204        if (data != null) {
    205205            try {
    206                 data[index] = coerceLispObjectToJavaByte(newValue);
     206                data[index] = coerceToJavaByte(newValue);
    207207            }
    208208            catch (ArrayIndexOutOfBoundsException e) {

  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_ByteBuffer.java

    r15305 r15350  
    190190    if (elements != null) {
    191191      try {
    192         return coerceJavaByteToLispObject(elements.get(index));
     192        return coerceFromJavaByte(elements.get(index));
    193193      } catch (ArrayIndexOutOfBoundsException e) {
    194194        badIndex(index, elements.limit());
    … …  
    227227    if (elements != null) {
    228228      try {
    229         elements.put(index, coerceLispObjectToJavaByte(newValue));
     229        elements.put(index, coerceToJavaByte(newValue));
    230230      } catch (IndexOutOfBoundsException e) {
    231231        badIndex(index, elements.limit());
    … …  
    317317      int i, j;
    318318      for (i = 0, j = length - 1; i < length; i++, j--) {
    319         data.put(i, coerceLispObjectToJavaByte(AREF(j)));
     319        data.put(i, coerceToJavaByte(AREF(j)));
    320320      }
    321321      elements = data;
    … …  
    392392          = Math.min(length(), array.getTotalSize() - displacement);
    393393        for (int i = 0; i < limit; i++) {
    394           elements.put(i, coerceLispObjectToJavaByte(array.AREF(displacement + i)));
     394          elements.put(i, coerceToJavaByte(array.AREF(displacement + i)));
    395395        }
    396396        capacity = minCapacity;
    … …  
    421421        LispObject list = initialContents;
    422422          for (int i = 0; i < newCapacity; i++) {
    423             newElements.put(i, coerceLispObjectToJavaByte(list.car()));
     423            newElements.put(i, coerceToJavaByte(list.car()));
    424424            list = list.cdr();
    425425          }
    426426      } else if (initialContents.vectorp()) {
    427427        for (int i = 0; i < newCapacity; i++) {
    428           newElements.put(i, coerceLispObjectToJavaByte(initialContents.elt(i)));
     428          newElements.put(i, coerceToJavaByte(initialContents.elt(i)));
    429429        }
    430430      } else {
    … …  
    443443        final int limit = Math.min(capacity, newCapacity);
    444444        for (int i = 0; i < limit; i++) {
    445           elements.put(i, coerceLispObjectToJavaByte(array.AREF(displacement + i)));
     445          elements.put(i, coerceToJavaByte(array.AREF(displacement + i)));
    446446        }
    447447      } else if (capacity != newCapacity) {
    … …  
    458458      // Initialize new elements (if applicable).
    459459      if (initialElement != null) {
    460         byte b = coerceLispObjectToJavaByte(initialElement);
     460        byte b = coerceToJavaByte(initialElement);
    461461        for (int i = capacity; i < newCapacity; i++) {
    462462          elements.put(b);

  • trunk/abcl/src/org/armedbear/lisp/ComplexVector_UnsignedByte8.java

    r15143 r15350  
    179179        if (elements != null) {
    180180            try {
    181                 return coerceJavaByteToLispObject(elements[index]);
     181                return coerceFromJavaByte(elements[index]);
    182182            }
    183183            catch (ArrayIndexOutOfBoundsException e) {
    … …  
    217217        if (elements != null) {
    218218            try {
    219                 elements[index] = coerceLispObjectToJavaByte(newValue);
     219                elements[index] = coerceToJavaByte(newValue);
    220220            }
    221221            catch (ArrayIndexOutOfBoundsException e) {
    … …  
    306306            int i, j;
    307307            for (i = 0, j = length - 1; i < length; i++, j--)
    308                 data[i] = coerceLispObjectToJavaByte(AREF(j));
     308                data[i] = coerceToJavaByte(AREF(j));
    309309            elements = data;
    310310            capacity = length;
    … …  
    374374                    Math.min(capacity, array.getTotalSize() - displacement);
    375375                for (int i = 0; i < limit; i++)
    376                     elements[i] = coerceLispObjectToJavaByte(array.AREF(displacement + i));
     376                    elements[i] = coerceToJavaByte(array.AREF(displacement + i));
    377377                capacity = minCapacity;
    378378                array = null;
    … …  
    397397                LispObject list = initialContents;
    398398                for (int i = 0; i < newCapacity; i++) {
    399                     newElements[i] = coerceLispObjectToJavaByte(list.car());
     399                    newElements[i] = coerceToJavaByte(list.car());
    400400                    list = list.cdr();
    401401                }
    402402            } else if (initialContents.vectorp()) {
    403403                for (int i = 0; i < newCapacity; i++)
    404                     newElements[i] = coerceLispObjectToJavaByte(initialContents.elt(i));
     404                    newElements[i] = coerceToJavaByte(initialContents.elt(i));
    405405            } else
    406406                type_error(initialContents, Symbol.SEQUENCE);
    … …  
    412412                final int limit = Math.min(capacity, newCapacity);
    413413                for (int i = 0; i < limit; i++)
    414                     elements[i] = coerceLispObjectToJavaByte(array.AREF(displacement + i));
     414                    elements[i] = coerceToJavaByte(array.AREF(displacement + i));
    415415            } else if (capacity != newCapacity) {
    416416                byte[] newElements = new byte[newCapacity];
    … …  
    421421            // Initialize new elements (if aapplicable).
    422422            if (initialElement != null) {
    423                 byte b = coerceLispObjectToJavaByte(initialElement);
     423                byte b = coerceToJavaByte(initialElement);
    424424                for (int i = capacity; i < newCapacity; i++)
    425425                    elements[i] = b;

  • trunk/abcl/src/org/armedbear/lisp/Lisp.java

    r15348 r15350  
    16531653  }
    16541654
    1655   public static final char coerceLispObjectToJavaChar(LispObject obj) {
     1655  // TODO rename to coerceToJavaChar
     1656  public static final char coerceToJavaChar(LispObject obj) {
    16561657    return (char)Fixnum.getValue(obj);
    16571658  }
    16581659
    1659   public static final byte coerceLispObjectToJavaByte(LispObject obj)
    1660 
    1661   {
     1660  public static final byte coerceToJavaByte(LispObject obj) {
    16621661          return (byte)Fixnum.getValue(obj);
    16631662  }
    16641663
    1665   public static final LispObject coerceJavaByteToLispObject(byte b)
    1666   {
     1664  public static final int coerceToJavaUnsignedInt(LispObject obj) {
     1665    return (int) (obj.longValue() & 0xffffffffL);
     1666  }
     1667 
     1668  public static final LispObject coerceFromJavaByte(byte b) {
    16671669    return Fixnum.constants[((int)b) & 0xff];
    16681670  }

  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_ByteBuffer.java

    r15305 r15350  
    111111    if (dims.length == 0) {
    112112      try {
    113         data.put(index, coerceLispObjectToJavaByte(contents));
     113        data.put(index, coerceToJavaByte(contents));
    114114      } catch (IndexOutOfBoundsException e) {
    115115        error(new LispError("Bad initial contents for array."));
    … …  
    206206  public LispObject AREF(int index) {
    207207    try {
    208       return coerceJavaByteToLispObject(data.get(index));
     208      return coerceFromJavaByte(data.get(index));
    209209    } catch (IndexOutOfBoundsException e) {
    210210      return error(new TypeError("Bad row major index " + index + "."));
    … …  
    215215  public void aset(int index, LispObject newValue) {
    216216    try {
    217       data.put(index, coerceLispObjectToJavaByte(newValue));
     217      data.put(index, coerceToJavaByte(newValue));
    218218    } catch (IndexOutOfBoundsException e) {
    219219      error(new TypeError("Bad row major index " + index + "."));
    … …  
    255255  public LispObject get(int[] subscripts) {
    256256    try {
    257       return coerceJavaByteToLispObject(data.get(getRowMajorIndex(subscripts)));
     257      return coerceFromJavaByte(data.get(getRowMajorIndex(subscripts)));
    258258    } catch (IndexOutOfBoundsException e) {
    259259      return error(new TypeError("Bad row major index " +
    … …  
    265265  public void set(int[] subscripts, LispObject newValue) {
    266266    try {
    267       data.put(getRowMajorIndex(subscripts),coerceLispObjectToJavaByte(newValue));
     267      data.put(getRowMajorIndex(subscripts),coerceToJavaByte(newValue));
    268268    } catch (IndexOutOfBoundsException e) {
    269269      error(new TypeError("Bad row major index " +

  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_CharBuffer.java

    r15348 r15350  
    118118    if (dims.length == 0) {
    119119      try {
    120         data.put(index, coerceLispObjectToJavaChar(contents));
     120        data.put(index, coerceToJavaChar(contents));
    121121      } catch (IndexOutOfBoundsException e) {
    122122        error(new LispError("Bad initial contents for array."));

  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java

    r15305 r15350  
    8888        if (dims.length == 0) {
    8989            try {
    90               data[index] = coerceLispObjectToJavaByte(contents); // This has to be wrong!
     90              data[index] = coerceToJavaByte(contents); // This has to be wrong!
    9191            }
    9292            catch (ArrayIndexOutOfBoundsException e) {

  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java

    r15143 r15350  
    8888        if (dims.length == 0) {
    8989            try {
    90                 data[index] = coerceLispObjectToJavaByte(contents);
     90                data[index] = coerceToJavaByte(contents);
    9191            }
    9292            catch (ArrayIndexOutOfBoundsException e) {
    … …  
    195195    {
    196196        try {
    197             return coerceJavaByteToLispObject(data[index]);
     197            return coerceFromJavaByte(data[index]);
    198198        }
    199199        catch (ArrayIndexOutOfBoundsException e) {
    … …  
    206206    {
    207207        try {
    208             data[index] = coerceLispObjectToJavaByte(newValue);
     208            data[index] = coerceToJavaByte(newValue);
    209209        }
    210210        catch (ArrayIndexOutOfBoundsException e) {
    … …  
    249249    {
    250250        try {
    251             return coerceJavaByteToLispObject(data[getRowMajorIndex(subscripts)]);
     251            return coerceFromJavaByte(data[getRowMajorIndex(subscripts)]);
    252252        }
    253253        catch (ArrayIndexOutOfBoundsException e) {
    … …  
    262262    {
    263263        try {
    264             data[getRowMajorIndex(subscripts)] = coerceLispObjectToJavaByte(newValue);
     264            data[getRowMajorIndex(subscripts)] = coerceToJavaByte(newValue);
    265265        }
    266266        catch (ArrayIndexOutOfBoundsException e) {
Note: See TracChangeset for help on using the changeset viewer.