Changeset 11754


Ignore:
Timestamp:
04/12/09 10:53:39 (12 years ago)
Author:
vvoutilainen
Message:

Convert using ClassCastException? to checking instanceof.
Performance tests show this approach to be faster.
Patch by Douglas R. Miles. I modified the patch to
remove tabs, so indentation may be slightly off in places.
That's something that we need to handle separately, abcl
doesn't have a clear indentation policy.

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

Legend:

Unmodified
Added
Removed
  • trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java

    r11575 r11754  
    114114    public void fill(LispObject obj) throws ConditionThrowable
    115115    {
    116         try {
     116        if (obj instanceof Fixnum) {
    117117            switch (((Fixnum)obj).value) {
    118118                case 0:
     
    135135                    return;
    136136            }
    137         }
    138         catch (ClassCastException e) {
    139137            // Fall through...
    140138        }
     
    202200    public LispObject AREF(LispObject index) throws ConditionThrowable
    203201    {
    204         try {
    205             return AREF(((Fixnum)index).value);
    206         }
    207         catch (ClassCastException e) {
    208             return error(new TypeError(index, Symbol.FIXNUM));
    209         }
     202        return AREF(Fixnum.getValue(index));
    210203    }
    211204
  • trunk/abcl/src/org/armedbear/lisp/ArithmeticError.java

    r11488 r11754  
    128128        public LispObject execute(LispObject arg) throws ConditionThrowable
    129129        {
    130             try {
     130            if (arg instanceof ArithmeticError) {
    131131                return ((ArithmeticError)arg).getOperation();
    132132            }
    133             catch (ClassCastException e) {
     133            else {
    134134                return error(new TypeError(arg, Symbol.ARITHMETIC_ERROR));
    135135            }
     
    143143        public LispObject execute(LispObject arg) throws ConditionThrowable
    144144        {
    145             try {
     145            if (arg instanceof ArithmeticError) {
    146146                return ((ArithmeticError)arg).getOperands();
    147147            }
    148             catch (ClassCastException e) {
     148            else {
    149149                return error(new TypeError(arg, Symbol.ARITHMETIC_ERROR));
    150150            }
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte16.java

    r11714 r11754  
    159159    {
    160160        try {
    161             return Fixnum.getInstance(elements[((Fixnum)index).value]);
    162         }
    163         catch (ClassCastException e) {
    164             return error(new TypeError(index, Symbol.FIXNUM));
     161            return Fixnum.getInstance(elements[Fixnum.getValue(index)]);
    165162        }
    166163        catch (ArrayIndexOutOfBoundsException e) {
     
    184181    public void aset(int index, LispObject obj) throws ConditionThrowable
    185182    {
    186         try {
     183        if (obj instanceof Fixnum) {
     184                try {
    187185            elements[index] = ((Fixnum)obj).value;
    188186        }
     
    190188            badIndex(index, capacity);
    191189        }
    192         catch (ClassCastException e) {
     190        }
     191        else {
    193192            error(new TypeError(obj, UNSIGNED_BYTE_16));
    194193        }
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte32.java

    r11714 r11754  
    175175  public LispObject AREF(LispObject index) throws ConditionThrowable
    176176  {
    177     try
    178       {
    179         return number(elements[((Fixnum)index).value]);
    180       }
    181     catch (ClassCastException e)
    182       {
    183         return type_error(index, Symbol.FIXNUM);
    184       }
    185     catch (ArrayIndexOutOfBoundsException e)
    186       {
    187         badIndex(Fixnum.getValue(index), elements.length);
     177        final int idx = Fixnum.getValue(index);
     178    try
     179      {
     180        return number(elements[idx]);
     181      }
     182    catch (ArrayIndexOutOfBoundsException e)
     183      {
     184        badIndex(idx, elements.length);
    188185        return NIL; // Not reached.
    189186      }
  • trunk/abcl/src/org/armedbear/lisp/BasicVector_UnsignedByte8.java

    r11714 r11754  
    160160  public LispObject AREF(LispObject index) throws ConditionThrowable
    161161  {
    162     try
    163       {
    164         return coerceJavaByteToLispObject(elements[((Fixnum)index).value]);
    165       }
    166     catch (ClassCastException e)
    167       {
    168         return error(new TypeError(index, Symbol.FIXNUM));
    169       }
    170     catch (ArrayIndexOutOfBoundsException e)
    171       {
    172         badIndex(Fixnum.getValue(index), elements.length);
     162          int idx = Fixnum.getValue(index);
     163    try
     164      {
     165        return coerceJavaByteToLispObject(elements[idx]);
     166      }
     167    catch (ArrayIndexOutOfBoundsException e)
     168      {
     169        badIndex(idx, elements.length);
    173170        return NIL; // Not reached.
    174171      }
  • trunk/abcl/src/org/armedbear/lisp/Bignum.java

    r11722 r11754  
    317317  public static BigInteger getValue(LispObject obj) throws ConditionThrowable
    318318  {
    319     try
     319         
     320    if (obj instanceof Bignum)
    320321      {
    321322        return ((Bignum)obj).value;
    322323      }
    323     catch (ClassCastException e)
    324       {
    325324        type_error(obj, Symbol.BIGNUM);
    326325        // Not reached.
    327326        return null;
    328       }
    329327  }
    330328
  • trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java

    r11711 r11754  
    258258        public LispObject execute(LispObject arg) throws ConditionThrowable
    259259        {
    260             try {
     260            if (arg instanceof BroadcastStream) {
    261261                BroadcastStream stream = (BroadcastStream) arg;
    262262                Stream[] streams = stream.streams;
     
    266266                return result;
    267267            }
    268             catch (ClassCastException e) {
    269                 return error(new TypeError(arg, Symbol.BROADCAST_STREAM));
    270             }
     268            return error(new TypeError(arg, Symbol.BROADCAST_STREAM));
    271269        }
    272270    };
  • trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java

    r11721 r11754  
    118118        public LispObject execute(LispObject arg) throws ConditionThrowable
    119119        {
    120             try {
     120            if (arg instanceof ByteArrayOutputStream) {
    121121                return JavaObject.getInstance(((ByteArrayOutputStream)arg).getByteArray());
    122122            }
    123             catch (ClassCastException e) {
    124                 return error(new TypeError(this, Symbol.STREAM)); //TODO
    125             }
     123            return error(new TypeError(this, Symbol.STREAM)); //TODO
    126124        }
    127125    };
  • trunk/abcl/src/org/armedbear/lisp/CharacterFunctions.java

    r11488 r11754  
    5656            throws ConditionThrowable
    5757        {
    58             try {
    59                 return ((LispCharacter)first).value == ((LispCharacter)second).value ? T : NIL;
    60             }
    61             catch (ClassCastException e) {
    62                 LispObject datum;
    63                 if (first instanceof LispCharacter)
    64                     datum = second;
    65                 else
    66                     datum = first;
    67                 return type_error(datum, Symbol.CHARACTER);
    68             }
     58            return LispCharacter.getValue(first) == LispCharacter.getValue(second) ? T : NIL;
    6959        }
    7060        @Override
     
    10292        {
    10393            final char c1, c2;
    104             try {
    105                 c1 = ((LispCharacter)first).value;
    106             }
    107             catch (ClassCastException e) {
    108                 return type_error(first, Symbol.CHARACTER);
    109             }
    110             try {
    111                 c2 = ((LispCharacter)second).value;
    112             }
    113             catch (ClassCastException e) {
    114                 return type_error(second, Symbol.CHARACTER);
    115             }
     94            c1 = LispCharacter.getValue(first);
     95            c2 = LispCharacter.getValue(second);
    11696            if (c1 == c2)
    11797                return T;
     
    239219            throws ConditionThrowable
    240220        {
    241             try {
    242                 return ((LispCharacter)first).value < ((LispCharacter)second).value ? T : NIL;
    243             }
    244             catch (ClassCastException e) {
    245                 LispObject datum;
    246                 if (first instanceof LispCharacter)
    247                     datum = second;
    248                 else
    249                     datum = first;
    250                 return type_error(datum, Symbol.CHARACTER);
    251             }
    252         }
     221            return LispCharacter.getValue(first) < LispCharacter.getValue(second) ? T : NIL;
     222       }
    253223        @Override
    254224        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    257227            char[] chars = new char[length];
    258228            for (int i = 0; i < length; i++) {
    259                 try {
    260                     chars[i] = ((LispCharacter)args[i]).value;
    261                 }
    262                 catch (ClassCastException e) {
    263                     return type_error(args[i], Symbol.CHARACTER);
    264                 }
     229                chars[i] = LispCharacter.getValue(args[i]);
    265230            }
    266231            for (int i = 1; i < length; i++) {
     
    292257            throws ConditionThrowable
    293258        {
    294             try {
    295                 return ((LispCharacter)first).value <= ((LispCharacter)second).value ? T : NIL;
    296             }
    297             catch (ClassCastException e) {
    298                 LispObject datum;
    299                 if (first instanceof LispCharacter)
    300                     datum = second;
    301                 else
    302                     datum = first;
    303                 return type_error(datum, Symbol.CHARACTER);
    304             }
     259            return LispCharacter.getValue(first) <= LispCharacter.getValue(second) ? T : NIL;
    305260        }
    306261        @Override
     
    309264            throws ConditionThrowable
    310265        {
    311             try {
    312                 if (((LispCharacter)first).value > ((LispCharacter)second).value)
    313                     return NIL;
    314                 if (((LispCharacter)second).value > ((LispCharacter)third).value)
    315                     return NIL;
    316                 return T;
    317             }
    318             catch (ClassCastException e) {
    319                 LispObject datum;
    320                 if (!(first instanceof LispCharacter))
    321                     datum = first;
    322                 else if (!(second instanceof LispCharacter))
    323                     datum = second;
    324                 else
    325                     datum = third;
    326                 return type_error(datum, Symbol.CHARACTER);
    327             }
     266            if (LispCharacter.getValue(first) > LispCharacter.getValue(second))
     267                return NIL;
     268            if (LispCharacter.getValue(second) > LispCharacter.getValue(third))
     269                return NIL;
     270            return T;
    328271        }
    329272        @Override
     
    333276            char[] chars = new char[length];
    334277            for (int i = 0; i < length; i++) {
    335                 try {
    336                     chars[i] = ((LispCharacter)args[i]).value;
    337                 }
    338                 catch (ClassCastException e) {
    339                     return type_error(args[i], Symbol.CHARACTER);
    340                 }
     278                chars[i] = LispCharacter.getValue(args[i]);
    341279            }
    342280            for (int i = 1; i < length; i++) {
  • trunk/abcl/src/org/armedbear/lisp/Closure.java

    r11711 r11754  
    138138                      }
    139139                    Debug.assertTrue(restVar == null);
    140                     try
    141                       {
    142                         restVar = (Symbol) remaining.car();
    143                       }
    144                     catch (ClassCastException e)
     140                    final LispObject remainingcar =  remaining.car();
     141                    if (remainingcar instanceof Symbol)
     142                      {
     143                        restVar = (Symbol) remainingcar;
     144                      }
     145                    else
    145146                      {
    146147                        error(new LispError(
  • trunk/abcl/src/org/armedbear/lisp/ComplexBitVector.java

    r11714 r11754  
    165165        if (index < 0 || index >= capacity)
    166166            badIndex(index, capacity);
    167         try {
     167        if (newValue instanceof Fixnum) {
    168168            switch (((Fixnum)newValue).value) {
    169169                case 0:
     
    183183            }
    184184        }
    185         catch (ClassCastException e) {
    186185            // Fall through...
    187         }
    188186        type_error(newValue, Symbol.BIT);
    189187    }
  • trunk/abcl/src/org/armedbear/lisp/ComplexString.java

    r11714 r11754  
    158158          {
    159159            LispObject obj = array.AREF(displacement + i);
    160             try
    161               {
    162                 copy[i] = ((LispCharacter)obj).value;
    163               }
    164             catch (ClassCastException e)
    165               {
    166                 type_error(obj, Symbol.CHARACTER);
    167               }
     160            copy[i] = LispCharacter.getValue(obj);
    168161          }
    169162      }
     
    427420  public void aset(int index, LispObject newValue) throws ConditionThrowable
    428421  {
    429     try
    430       {
    431         setCharAt(index, ((LispCharacter)newValue).value);
    432       }
    433     catch (ClassCastException e)
    434       {
    435         type_error(newValue, Symbol.CHARACTER);
    436       }
     422      setCharAt(index, LispCharacter.getValue(newValue));
    437423  }
    438424
     
    450436    if (chars != null)
    451437      {
    452         try
    453           {
    454             chars[fillPointer] = ((LispCharacter)element).value;
    455           }
    456         catch (ClassCastException e)
    457           {
    458             type_error(element, Symbol.CHARACTER);
    459           }
     438        chars[fillPointer] = LispCharacter.getValue(element);
    460439      }
    461440    else
     
    487466    if (chars != null)
    488467      {
    489         try
    490           {
    491             chars[fillPointer] = ((LispCharacter)element).value;
    492           }
    493         catch (ClassCastException e)
    494           {
    495             type_error(element, Symbol.CHARACTER);
    496           }
     468        chars[fillPointer] = LispCharacter.getValue(element);
    497469      }
    498470    else
  • trunk/abcl/src/org/armedbear/lisp/ConcatenatedStream.java

    r11488 r11754  
    274274        public LispObject execute(LispObject arg) throws ConditionThrowable
    275275        {
    276             try {
     276            if (arg instanceof ConcatenatedStream)
    277277                return ((ConcatenatedStream)arg).streams;
    278             }
    279             catch (ClassCastException e) {
    280                 return error(new TypeError(arg, Symbol.CONCATENATED_STREAM));
    281             }
     278            return error(new TypeError(arg, Symbol.CONCATENATED_STREAM));
    282279        }
    283280    };
  • trunk/abcl/src/org/armedbear/lisp/Cons.java

    r11714 r11754  
    282282  public final int length() throws ConditionThrowable
    283283  {
    284     int length = 0;
    285     LispObject obj = this;
    286     try
    287       {
     284    int length = 1;
     285    LispObject obj = cdr;
    288286        while (obj != NIL)
    289287          {
    290288            ++length;
    291             obj = ((Cons)obj).cdr;
    292           }
    293       }
    294     catch (ClassCastException e)
    295       {
    296         type_error(obj, Symbol.LIST);
    297       }
     289            if (obj instanceof Cons) {
     290                obj = ((Cons)obj).cdr;
     291            } else  type_error(obj, Symbol.LIST);
     292          }     
    298293    return length;
    299294  }
     
    321316  {
    322317    int index;
    323     try
     318    if (arg instanceof Fixnum)
    324319      {
    325320        index = ((Fixnum)arg).value;
    326321      }
    327     catch (ClassCastException e)
    328       {
     322    else
     323        {
    329324        if (arg instanceof Bignum)
    330325          {
     
    362357        if (i == index)
    363358          return cons.car;
    364         try
    365           {
    366             cons = (Cons) cons.cdr;
    367           }
    368         catch (ClassCastException e)
    369           {
    370             if (cons.cdr == NIL)
     359        LispObject conscdr = cons.cdr;
     360        if (conscdr instanceof Cons)
     361          {
     362            cons = (Cons) conscdr;
     363          }
     364        else
     365          {
     366            if (conscdr == NIL)
    371367              {
    372368                // Index too large.
     
    378374              {
    379375                // Dotted list.
    380                 type_error(cons.cdr, Symbol.LIST);
     376                type_error(conscdr, Symbol.LIST);
    381377              }
    382378            // Not reached.
  • trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java

    r11714 r11754  
    226226    public static double getValue(LispObject obj) throws ConditionThrowable
    227227    {
    228         try {
     228        if (obj instanceof DoubleFloat)
    229229            return ((DoubleFloat)obj).value;
    230         }
    231         catch (ClassCastException e) {
    232230            type_error(obj, Symbol.FLOAT);
    233231            // Not reached.
    234232            return 0;
    235         }
    236233    }
    237234
  • trunk/abcl/src/org/armedbear/lisp/Environment.java

    r11551 r11754  
    337337      public LispObject execute(LispObject arg) throws ConditionThrowable
    338338      {
    339         try
    340           {
    341             return ((Environment)arg).isEmpty() ? T : NIL;
    342           }
    343         catch (ClassCastException e)
    344           {
    345             return type_error(arg, Symbol.ENVIRONMENT);
    346           }
     339          return checkEnvironment(arg).isEmpty() ? T : NIL;
    347340      }
    348341    };
     
    355348      public LispObject execute(LispObject arg) throws ConditionThrowable
    356349      {
    357         try
    358           {
    359             Environment env = (Environment) arg;
     350            Environment env = checkEnvironment(arg);
    360351            LispObject result = NIL;
    361352            for (Binding binding = env.vars; binding != null; binding = binding.next)
     
    363354                result = result.push(new Cons(binding.symbol, binding.value));
    364355            return result.nreverse();
    365           }
    366         catch (ClassCastException e)
    367           {
    368             return type_error(arg, Symbol.ENVIRONMENT);
    369           }
    370356      }
    371357    };
  • trunk/abcl/src/org/armedbear/lisp/Extensions.java

    r11711 r11754  
    275275    {
    276276      AbstractString string;
    277       try {
     277      if (arg instanceof AbstractString) {
    278278        string = (AbstractString) arg;
    279       }
    280       catch (ClassCastException e) {
     279      } else
    281280        return type_error(arg, Symbol.STRING);
    282       }
    283281      String result = System.getenv(string.getStringValue());
    284282      if (result != null)
  • trunk/abcl/src/org/armedbear/lisp/FileStream.java

    r11434 r11754  
    286286        {
    287287            final Pathname pathname;
    288             try {
     288            if(first instanceof Pathname) {
    289289                pathname = (Pathname) first;
    290290            }
    291             catch (ClassCastException e) {
     291            else {
    292292                return type_error(first, Symbol.PATHNAME);
    293293            }
    294             final LispObject namestring;
    295             try {
    296                 namestring = (AbstractString) second;
    297             }
    298             catch (ClassCastException e) {
    299                 return type_error(second, Symbol.STRING);
    300             }
     294            final LispObject namestring = checkString(second);
    301295            LispObject elementType = third;
    302296            LispObject direction = fourth;
  • trunk/abcl/src/org/armedbear/lisp/Fixnum.java

    r11722 r11754  
    300300  public static int getValue(LispObject obj) throws ConditionThrowable
    301301  {
    302     try
    303       {
    304         return ((Fixnum)obj).value;
    305       }
    306     catch (ClassCastException e)
    307       {
    308         type_error(obj, Symbol.FIXNUM);
    309         // Not reached.
    310         return 0;
    311       }
     302          if (obj instanceof Fixnum) return ((Fixnum)obj).value;
     303          type_error(obj, Symbol.FIXNUM);
     304      // Not reached.
     305          return 0;
    312306  }
    313307
     
    324318  public static int getInt(LispObject obj) throws ConditionThrowable
    325319  {
    326     try
    327       {
    328         return (int) ((Fixnum)obj).value;
    329       }
    330     catch (ClassCastException e)
    331       {
    332         type_error(obj, Symbol.FIXNUM);
    333         // Not reached.
    334         return 0;
    335       }
     320          if (obj instanceof Fixnum) return ((Fixnum)obj).value;
     321          type_error(obj, Symbol.FIXNUM);
     322      // Not reached.
     323          return 0;
    336324  }
    337325
    338326  public static BigInteger getBigInteger(LispObject obj) throws ConditionThrowable
    339327  {
    340     try
    341       {
    342         return BigInteger.valueOf(((Fixnum)obj).value);
    343       }
    344     catch (ClassCastException e)
    345       {
    346         type_error(obj, Symbol.FIXNUM);
    347         // Not reached.
    348         return null;
    349       }
     328          if (obj instanceof Fixnum) return BigInteger.valueOf(((Fixnum)obj).value);
     329          type_error(obj, Symbol.FIXNUM);
     330      // Not reached.
     331          return null;
    350332  }
    351333
  • trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java

    r11488 r11754  
    8383            throws ConditionThrowable
    8484        {
    85             try {
     85            if (arg instanceof Symbol) {
    8686                Symbol name = (Symbol) arg;
    8787                ForwardReferencedClass c = new ForwardReferencedClass(name);
     
    8989                return c;
    9090            }
    91             catch (ClassCastException e) {
    9291                return error(new TypeError(arg.writeToString() +
    9392                                            " is not a valid class name."));
    94             }
    9593        }
    9694    };
  • trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java

    r11714 r11754  
    5454        throws ConditionThrowable
    5555      {
    56         final int n;
    57         try
    58           {
    59             n = ((Fixnum)size).value;
    60           }
    61         catch (ClassCastException e)
    62           {
    63             return type_error(size, Symbol.FIXNUM);
    64           }
     56        final int n = Fixnum.getValue(size);
    6557        if (test == FUNCTION_EQL || test == NIL)
    6658          return new EqlHashTable(n, rehashSize, rehashThreshold);
     
    8476        throws ConditionThrowable
    8577      {
    86         try
    87           {
    88             return ((HashTable)ht).gethash(key);
    89           }
    90         catch (ClassCastException e)
    91           {
    92             return type_error(ht, Symbol.HASH_TABLE);
    93           }
    94       }
     78          return checkHashTable(ht).gethash(key);
     79      }
     80     
    9581      @Override
    9682      public LispObject execute(LispObject key, LispObject ht,
     
    9884        throws ConditionThrowable
    9985      {
    100         try
    101           {
    102             return ((HashTable)ht).gethash(key, defaultValue);
    103           }
    104         catch (ClassCastException e)
    105           {
    106             return type_error(ht, Symbol.HASH_TABLE);
    107           }
     86          return checkHashTable(ht).gethash(key, defaultValue);
    10887      }
    10988    };
     
    11796        throws ConditionThrowable
    11897      {
    119         final HashTable ht;
    120         try
    121           {
    122             ht = (HashTable) second;
    123           }
    124         catch (ClassCastException e)
    125           {
    126             return type_error(second, Symbol.HASH_TABLE);
    127           }
     98        final HashTable ht = checkHashTable(second);
    12899        synchronized (ht)
    129100          {
     
    144115        throws ConditionThrowable
    145116      {
    146         try
    147           {
    148             return ((HashTable)ht).puthash(key, value);
    149           }
    150         catch (ClassCastException e)
    151           {
    152             return type_error(ht, Symbol.HASH_TABLE);
    153           }
     117          return checkHashTable(ht).puthash(key, value);
    154118      }
    155119      @Override
     
    158122        throws ConditionThrowable
    159123      {
    160         try
    161           {
    162             return ((HashTable)ht).puthash(key, value);
    163           }
    164         catch (ClassCastException e)
    165           {
    166             return type_error(ht, Symbol.HASH_TABLE);
    167           }
     124          return checkHashTable(ht).puthash(key, value);
    168125      }
    169126    };
     
    177134        throws ConditionThrowable
    178135      {
    179         try
    180           {
    181             return ((HashTable)ht).remhash(key);
    182           }
    183         catch (ClassCastException e)
    184           {
    185             return type_error(ht, Symbol.HASH_TABLE);
    186           }
     136            return checkHashTable(ht).remhash(key);
    187137      }
    188138    };
     
    195145      public LispObject execute(LispObject ht) throws ConditionThrowable
    196146      {
    197         try
    198           {
    199             ((HashTable)ht).clear();
    200             return ht;
    201           }
    202         catch (ClassCastException e)
    203           {
    204             return type_error(ht, Symbol.HASH_TABLE);
    205           }
     147          checkHashTable(ht).clear();
     148          return ht;
    206149      }
    207150    };
     
    214157      public LispObject execute(LispObject arg) throws ConditionThrowable
    215158      {
    216         try
    217           {
    218             return Fixnum.getInstance(((HashTable)arg).getCount());
    219           }
    220         catch (ClassCastException e)
    221           {
    222             return type_error(arg, Symbol.HASH_TABLE);
    223           }
     159          return Fixnum.getInstance(checkHashTable(arg).getCount());
    224160      }
    225161    };
     
    266202      public LispObject execute(LispObject arg) throws ConditionThrowable
    267203      {
    268         try
    269           {
    270             return ((HashTable)arg).ENTRIES();
    271           }
    272         catch (ClassCastException e)
    273           {
    274             return type_error(arg, Symbol.HASH_TABLE);
    275           }
     204          return checkHashTable(arg).ENTRIES();
    276205      }
    277206    };
     
    284213      public LispObject execute(LispObject arg) throws ConditionThrowable
    285214      {
    286         try
    287           {
    288             return ((HashTable)arg).getTest();
    289           }
    290         catch (ClassCastException e)
    291           {
    292             return type_error(arg, Symbol.HASH_TABLE);
    293           }
     215          return checkHashTable(arg).getTest();
    294216      }
    295217    };
     
    302224      public LispObject execute(LispObject arg) throws ConditionThrowable
    303225      {
    304         try
    305           {
    306             return Fixnum.getInstance(((HashTable)arg).getSize());
    307           }
    308         catch (ClassCastException e)
    309           {
    310             return type_error(arg, Symbol.HASH_TABLE);
    311           }
     226          return Fixnum.getInstance(checkHashTable(arg).getSize());
    312227      }
    313228    };
     
    320235      public LispObject execute(LispObject arg) throws ConditionThrowable
    321236      {
    322         try
    323           {
    324             return ((HashTable)arg).getRehashSize();
    325           }
    326         catch (ClassCastException e)
    327           {
    328             return type_error(arg, Symbol.HASH_TABLE);
    329           }
     237          return checkHashTable(arg).getRehashSize();
    330238      }
    331239    };
     
    338246      public LispObject execute(LispObject arg) throws ConditionThrowable
    339247      {
    340         try
    341           {
    342             return ((HashTable)arg).getRehashThreshold();
    343           }
    344         catch (ClassCastException e)
    345           {
    346             return type_error(arg, Symbol.HASH_TABLE);
    347           }
     248          return checkHashTable(arg).getRehashThreshold();
    348249      }
    349250    };
     
    357258        throws ConditionThrowable
    358259      {
    359         HashTable ht;
    360         try
    361           {
    362             ht = (HashTable) second;
    363           }
    364         catch (ClassCastException e)
    365           {
    366             return type_error(second, Symbol.HASH_TABLE);
    367           }
    368         return ht.MAPHASH(first);
    369       }
    370     };
     260        return checkHashTable(second).MAPHASH(first);
     261      }
     262    };
     263
     264protected static HashTable checkHashTable(LispObject ht) throws ConditionThrowable {
     265        if (ht instanceof HashTable) return (HashTable)ht;
     266    type_error(ht, Symbol.HASH_TABLE);   
     267        return null;
    371268}
     269}
  • trunk/abcl/src/org/armedbear/lisp/Java.java

    r11711 r11754  
    856856        // It's not a string, so it must be a JavaObject.
    857857        final JavaObject javaObject;
    858         try {
     858        if (obj instanceof JavaObject) {
    859859            javaObject = (JavaObject) obj;
    860860        }
    861         catch (ClassCastException e) {
     861        else {
    862862            type_error(obj, list(Symbol.OR, Symbol.STRING,
    863863                                       Symbol.JAVA_OBJECT));
     
    865865            return null;
    866866        }
    867         try {
    868             return (Class) javaObject.getObject();
    869         }
    870         catch (ClassCastException e) {
     867        final Object javaObjectgetObject = javaObject.getObject();
     868        if (javaObjectgetObject instanceof Class) {
     869            return (Class) javaObjectgetObject;
     870        }
    871871            error(new LispError(obj.writeToString() + " does not designate a Java class."));
    872872            return null;
    873         }
    874873    }
    875874
  • trunk/abcl/src/org/armedbear/lisp/JavaObject.java

    r11722 r11754  
    5454    public LispObject classOf()
    5555    {
    56       if(obj == null) {
    57         return BuiltInClass.JAVA_OBJECT;
    58       } else {
    59         return JavaClass.findJavaClass(obj.getClass());
    60       }
     56        if(obj == null) {
     57                return BuiltInClass.JAVA_OBJECT;
     58        } else {
     59                return JavaClass.findJavaClass(obj.getClass());
     60        }
    6161    }
    6262
     
    6969            return T;
    7070        if(type instanceof JavaClass && obj != null) {
    71           return ((JavaClass) type).getJavaClass().isAssignableFrom(obj.getClass()) ? T : NIL;
     71                return ((JavaClass) type).getJavaClass().isAssignableFrom(obj.getClass()) ? T : NIL;
    7272        }
    7373        return super.typep(type);
     
    180180        throws ConditionThrowable
    181181    {
    182         try {
    183       return ((JavaObject)o).obj;
    184         }
    185         catch (ClassCastException e) {
    186             type_error(o, Symbol.JAVA_OBJECT);
    187             // Not reached.
    188             return null;
    189         }
     182        if (o instanceof JavaObject)
     183                return ((JavaObject)o).obj;       
     184        return             // Not reached.
     185        type_error(o, Symbol.JAVA_OBJECT);       
    190186    }
    191187
     
    234230            if (!(first instanceof JavaObject))
    235231                return type_error(first, Symbol.JAVA_OBJECT);
    236             final Stream stream;
    237             try {
    238                 stream = (Stream) second;
    239             }
    240             catch (ClassCastException e) {
    241                 return type_error(second, Symbol.STREAM);
    242             }
     232            final Stream stream = checkStream(second);
    243233            final JavaObject javaObject = (JavaObject) first;
    244234            final Object obj = javaObject.getObject();
  • trunk/abcl/src/org/armedbear/lisp/Layout.java

    r11714 r11754  
    175175        throws ConditionThrowable
    176176      {
    177         try
    178           {
    179             return new Layout((LispClass)first, checkList(second),
     177          return new Layout(checkClass(first), checkList(second),
    180178                              checkList(third));
    181           }
    182         catch (ClassCastException e)
    183           {
    184             return type_error(first, Symbol.CLASS);
    185           }
    186179      }
    187180
     
    195188      public LispObject execute(LispObject arg) throws ConditionThrowable
    196189      {
    197         try
    198           {
    199             return ((Layout)arg).lispClass;
    200           }
    201         catch (ClassCastException e)
    202           {
    203             return type_error(arg, Symbol.LAYOUT);
    204           }
     190          return checkLayout(arg).lispClass;
    205191      }
    206192    };
     
    213199      public LispObject execute(LispObject arg) throws ConditionThrowable
    214200      {
    215         try
    216           {
    217             return Fixnum.getInstance(((Layout)arg).slotNames.length);
    218           }
    219         catch (ClassCastException e)
    220           {
    221             return type_error(arg, Symbol.LAYOUT);
    222           }
     201          return Fixnum.getInstance(checkLayout(arg).slotNames.length);
    223202      }
    224203    };
     
    254233        throws ConditionThrowable
    255234      {
    256         try
    257           {
    258             final LispObject slotNames[] = ((Layout)first).slotNames;
    259             for (int i = slotNames.length; i-- > 0;)
    260               {
    261                 if (slotNames[i] == second)
    262                   return Fixnum.getInstance(i);
    263               }
    264             return NIL;
    265           }
    266         catch (ClassCastException e)
    267           {
    268             return type_error(first, Symbol.LAYOUT);
    269           }
     235          final LispObject slotNames[] = checkLayout(first).slotNames;
     236          for (int i = slotNames.length; i-- > 0;)
     237            {
     238              if (slotNames[i] == second)
     239                return Fixnum.getInstance(i);
     240            }
     241          return NIL;
    270242      }
    271243    };
     
    279251        throws ConditionThrowable
    280252      {
    281         try
    282           {
    283             final LispObject slotNames[] = ((Layout)first).slotNames;
     253                final Layout layOutFirst = checkLayout(first);
     254            final LispObject slotNames[] = layOutFirst.slotNames;
    284255            final int limit = slotNames.length;
    285256            for (int i = 0; i < limit; i++)
     
    289260              }
    290261            // Reaching here, it's not an instance slot.
    291             LispObject rest = ((Layout)first).sharedSlots;
     262            LispObject rest = layOutFirst.sharedSlots;
    292263            while (rest != NIL)
    293264              {
     
    299270            return NIL;
    300271          }
    301         catch (ClassCastException e)
    302           {
    303             return type_error(first, Symbol.LAYOUT);
    304           }
    305       }
    306272    };
    307273
     
    313279      public LispObject execute(LispObject arg) throws ConditionThrowable
    314280      {
    315         final LispClass lispClass;
    316         try
    317           {
    318             lispClass = (LispClass) arg;
    319           }
    320         catch (ClassCastException e)
    321           {
    322             return type_error(arg, Symbol.CLASS);
    323           }
     281        final LispClass lispClass = checkClass(arg);
    324282        Layout oldLayout = lispClass.getClassLayout();
    325283        Layout newLayout = new Layout(oldLayout);
  • trunk/abcl/src/org/armedbear/lisp/Lisp.java

    r11750 r11754  
    563563  // Environment wrappers.
    564564  private static final boolean isSpecial(Symbol sym, Symbol[] ownSpecials,
    565           Environment env)
     565                                        Environment env)
    566566  {
    567567    if (ownSpecials != null)
    568568      {
    569   if (sym.isSpecialVariable())
    570     return true;
    571   for (Symbol special : ownSpecials)
    572     {
    573       if (sym == special)
    574         return true;
    575     }
     569        if (sym.isSpecialVariable())
     570          return true;
     571        for (Symbol special : ownSpecials)
     572          {
     573            if (sym == special)
     574              return true;
     575          }
    576576      }
    577577    return false;
    578578  }
    579579  protected static final void bindArg(Symbol[] ownSpecials,
    580               Symbol sym, LispObject value,
    581               Environment env, LispThread thread)
     580                                      Symbol sym, LispObject value,
     581                                      Environment env, LispThread thread)
    582582    throws ConditionThrowable
    583583  {
     
    759759
    760760  public static Symbol checkSymbol(LispObject obj) throws ConditionThrowable
    761   {
    762     if (obj == null)
    763       throw new NullPointerException();
    764     try
    765       {
    766         return (Symbol) obj;
    767       }
    768     catch (ClassCastException e)
    769       {
    770         type_error(obj, Symbol.SYMBOL);
    771         // Not reached.
    772         return null;
    773       }
     761  {             
     762          if (obj instanceof Symbol)     
     763                  return (Symbol) obj;         
     764          return (Symbol)// Not reached.       
     765              type_error(obj, Symbol.SYMBOL);
    774766  }
    775767
     
    785777    throws ConditionThrowable
    786778  {
    787     if (obj == null)
    788       throw new NullPointerException();
    789     try
    790       {
    791         return (AbstractArray) obj;
    792       }
    793     catch (ClassCastException e)
    794       {
     779          if (obj instanceof AbstractArray)       
     780                  return (AbstractArray) obj;         
     781          return (AbstractArray)// Not reached.       
    795782        type_error(obj, Symbol.ARRAY);
    796         // Not reached.
    797         return null;
    798       }
    799783  }
    800784
     
    802786    throws ConditionThrowable
    803787  {
    804     if (obj == null)
    805       throw new NullPointerException();
    806     try
    807       {
    808         return (AbstractVector) obj;
    809       }
    810     catch (ClassCastException e)
    811       {
     788          if (obj instanceof AbstractVector)     
     789                  return (AbstractVector) obj;         
     790          return (AbstractVector)// Not reached.       
    812791        type_error(obj, Symbol.VECTOR);
    813         // Not reached.
    814         return null;
    815       }
    816792  }
    817793
     
    1020996                            if (zipFileName.length() > 0 && zipFileName.charAt(0) == '/')
    1021997                              zipFileName = zipFileName.substring(1);
    1022         }
    1023       zipFileName = URLDecoder.decode(zipFileName, "UTF-8");
     998                          }
     999                        zipFileName = URLDecoder.decode(zipFileName, "UTF-8");
    10241000                        ZipFile zipFile = new ZipFile(zipFileName);
    10251001                        try
     
    11321108          Debug.trace("bytesRemaining = " + bytesRemaining);
    11331109
    1134   return loadCompiledFunction(bytes);
     1110        return loadCompiledFunction(bytes);
    11351111      }
    11361112    catch (Throwable t)
     
    11421118
    11431119    public static final LispObject loadCompiledFunction(byte[] bytes) throws Throwable {
    1144   Class c = (new JavaClassLoader()).loadClassFromByteArray(null, bytes, 0, bytes.length);
     1120        Class c = (new JavaClassLoader()).loadClassFromByteArray(null, bytes, 0, bytes.length);
    11451121        if (c != null) {
    1146       Class sc = c.getSuperclass();
     1122            Class sc = c.getSuperclass();
    11471123            Constructor constructor = c.getConstructor((Class[])null);
    11481124            LispObject obj = (LispObject) constructor.newInstance((Object[])null);
    11491125            if (obj instanceof Function) {
    11501126              ((Function)obj).setClassBytes(bytes);
    1151       }
     1127            }
    11521128            return obj;
    1153   } else {
    1154       return null;
    1155   }
     1129        } else {
     1130            return null;
     1131        }
    11561132    }
    11571133
     
    13261302    throws ConditionThrowable
    13271303  {
    1328     try
    1329       {
    1330         return (byte) ((Fixnum)obj).value;
    1331       }
    1332     catch (ClassCastException e)
    1333       {
    1334         type_error(obj, Symbol.FIXNUM);
    1335         // Not reached.
    1336         return 0;
    1337       }
     1304          return (byte)Fixnum.getValue(obj);
    13381305  }
    13391306
     
    13461313    throws ConditionThrowable
    13471314  {
    1348     if (obj == null)
    1349       throw new NullPointerException();
    1350     try
    1351       {
    1352         return (LispCharacter) obj;
    1353       }
    1354     catch (ClassCastException e)
    1355       {
     1315          if (obj instanceof LispCharacter)
     1316                  return (LispCharacter) obj;         
     1317          return (LispCharacter) // Not reached.       
    13561318        type_error(obj, Symbol.CHARACTER);
    1357         // Not reached.
    1358         return null;
    1359       }
    13601319  }
    13611320
     
    13631322    throws ConditionThrowable
    13641323  {
    1365     if (obj == null)
    1366       throw new NullPointerException();
    1367     try
    1368       {
    1369         return (Package) obj;
    1370       }
    1371     catch (ClassCastException e)
    1372       {
     1324          if (obj instanceof Package)     
     1325                  return (Package) obj;         
     1326          return (Package) // Not reached.       
    13731327        type_error(obj, Symbol.PACKAGE);
    1374         // Not reached.
    1375         return null;
    1376       }
    13771328  }
    13781329
     
    13801331    throws ConditionThrowable
    13811332  {
    1382     if (obj == null)
    1383       throw new NullPointerException();
    1384     try
    1385       {
    1386         return (Function) obj;
    1387       }
    1388     catch (ClassCastException e)
    1389       {
     1333          if (obj instanceof Function)   
     1334                  return (Function) obj;         
     1335          return (Function) // Not reached.       
    13901336        type_error(obj, Symbol.FUNCTION);
    1391         // Not reached.
    1392         return null;
    1393       }
    13941337  }
    13951338
     
    13971340    throws ConditionThrowable
    13981341  {
    1399     if (obj == null)
    1400       throw new NullPointerException();
    1401     try
    1402       {
    1403         return (Stream) obj;
    1404       }
    1405     catch (ClassCastException e)
    1406       {
     1342          if (obj instanceof Stream)     
     1343                  return (Stream) obj;         
     1344          return (Stream) // Not reached.       
    14071345        type_error(obj, Symbol.STREAM);
    1408         // Not reached.
    1409         return null;
    1410       }
    14111346  }
    14121347
     
    14141349    throws ConditionThrowable
    14151350  {
    1416     if (obj == null)
    1417       throw new NullPointerException();
    1418     try
    1419       {
    1420         final Stream stream = (Stream) obj;
    1421         if (stream.isCharacterInputStream())
    1422           return stream;
    1423         error(new TypeError("The value " + obj.writeToString() +
    1424                              " is not a character input stream."));
    1425         // Not reached.
    1426         return null;
    1427       }
    1428     catch (ClassCastException e)
    1429       {
    1430         type_error(obj, Symbol.STREAM);
    1431         // Not reached.
    1432         return null;
    1433       }
     1351          final Stream stream = checkStream(obj);
     1352          if (stream.isCharacterInputStream())     
     1353                  return stream;                       
     1354          return (Stream) // Not reached.                     
     1355          error(new TypeError("The value " + obj.writeToString() +
     1356                        " is not a character input stream."));
    14341357  }
    14351358
     
    14371360    throws ConditionThrowable
    14381361  {
    1439     if (obj == null)
    1440       throw new NullPointerException();
    1441     try
    1442       {
    1443         final Stream stream = (Stream) obj;
    1444         if (stream.isCharacterOutputStream())
    1445           return stream;
     1362          final Stream stream = checkStream(obj);
     1363          if (stream.isCharacterOutputStream())     
     1364                  return stream;                       
     1365        return (Stream) // Not reached.
    14461366        error(new TypeError("The value " + obj.writeToString() +
    14471367                            " is not a character output stream."));
    1448         // Not reached.
    1449         return null;
    1450       }
    1451     catch (ClassCastException e)
    1452       {
    1453         type_error(obj, Symbol.STREAM);
    1454         // Not reached.
    1455         return null;
    1456       }
    14571368  }
    14581369
     
    14601371    throws ConditionThrowable
    14611372  {
    1462     if (obj == null)
    1463       throw new NullPointerException();
    1464     try
    1465       {
    1466         final Stream stream = (Stream) obj;
    1467         if (stream.isBinaryInputStream())
    1468           return stream;
     1373          final Stream stream = checkStream(obj);
     1374          if (stream.isBinaryInputStream())     
     1375                  return stream;                       
     1376        return (Stream) // Not reached.
    14691377        error(new TypeError("The value " + obj.writeToString() +
    14701378                             " is not a binary input stream."));
    1471         // Not reached.
    1472         return null;
    1473       }
    1474     catch (ClassCastException e)
    1475       {
    1476         type_error(obj, Symbol.STREAM);
    1477         // Not reached.
    1478         return null;
    1479       }
     1379  }
     1380 
     1381  public static final Stream outSynonymOf(LispObject obj)
     1382  throws ConditionThrowable
     1383  {       
     1384          if (obj instanceof Stream)
     1385            return (Stream) obj;
     1386          if (obj == T)
     1387            return checkCharacterOutputStream(Symbol.TERMINAL_IO.symbolValue());
     1388          if (obj == NIL)
     1389            return checkCharacterOutputStream(Symbol.STANDARD_OUTPUT.symbolValue());
     1390          return (Stream)         // Not reached.
     1391          type_error(obj, Symbol.STREAM);
    14801392  }
    14811393
     
    14891401    if (obj == NIL)
    14901402      return checkCharacterInputStream(Symbol.STANDARD_INPUT.symbolValue());
    1491     type_error(obj, Symbol.STREAM);
    1492     // Not reached.
    1493     return null;
     1403          return (Stream)         // Not reached.
     1404          type_error(obj, Symbol.STREAM);
    14941405  }
    14951406
     
    14991410    if (n < 0 || n > 255)
    15001411      type_error(Fixnum.getInstance(n), UNSIGNED_BYTE_8);
    1501     try
    1502       {
    1503         ((Stream)obj)._writeByte(n);
    1504       }
    1505     catch (ClassCastException e)
    1506       {
    1507         type_error(obj, Symbol.STREAM);
    1508       }
     1412    checkStream(obj)._writeByte(n);
    15091413  }
    15101414
     
    15121416    throws ConditionThrowable
    15131417  {
    1514     if (obj == null)
    1515       throw new NullPointerException();
    1516     try
    1517       {
    1518         return (Readtable) obj;
    1519       }
    1520     catch (ClassCastException e)
    1521       {
    1522         type_error(obj, Symbol.READTABLE);
    1523         // Not reached.
    1524         return null;
    1525       }
     1418          if (obj instanceof Readtable)   
     1419                  return (Readtable) obj;         
     1420          return (Readtable)// Not reached.       
     1421          type_error(obj, Symbol.READTABLE);
     1422  }
     1423 
     1424  public final static AbstractString checkString(LispObject obj)
     1425   throws ConditionThrowable
     1426  {
     1427          if (obj instanceof AbstractString)           
     1428                  return (AbstractString) obj;                   
     1429          return (AbstractString)// Not reached.               
     1430              type_error(obj, Symbol.STRING);
     1431  }
     1432 
     1433  public final static LispClass checkClass(LispObject obj)
     1434   throws ConditionThrowable
     1435   {
     1436          if (obj instanceof LispClass)         
     1437                  return (LispClass) obj;                         
     1438          return (LispClass)// Not reached.                   
     1439                type_error(obj, Symbol.CLASS);
     1440   }   
     1441
     1442  public final static Layout checkLayout(LispObject obj)
     1443   throws ConditionThrowable
     1444  {
     1445          if (obj instanceof Layout)           
     1446                  return (Layout) obj;                   
     1447          return (Layout)// Not reached.               
     1448                type_error(obj, Symbol.LAYOUT);
    15261449  }
    15271450
     
    15291452    throws ConditionThrowable
    15301453  {
    1531     if (obj == null)
    1532       throw new NullPointerException();
    15331454    if (obj == NIL)
    15341455      obj = STANDARD_READTABLE.symbolValue();
    1535     try
    1536       {
    1537         return (Readtable) obj;
    1538       }
    1539     catch (ClassCastException e)
    1540       {
    1541         type_error(obj, Symbol.READTABLE);
    1542         // Not reached.
    1543         return null;
    1544       }
     1456    if (obj == null)
     1457        throw new NullPointerException();
     1458    return checkReadtable(obj);
    15451459  }
    15461460
     
    15481462    throws ConditionThrowable
    15491463  {
    1550     if (obj == null)
    1551       throw new NullPointerException();
    1552     try
    1553       {
    1554         return (Environment) obj;
    1555       }
    1556     catch (ClassCastException e)
    1557       {
     1464          if (obj instanceof Environment)         
     1465                  return (Environment) obj;         
     1466          return (Environment)// Not reached.       
    15581467        type_error(obj, Symbol.ENVIRONMENT);
    1559         // Not reached.
    1560         return null;
    1561       }
    15621468  }
    15631469
     
    16971603    throws ConditionThrowable
    16981604  {
    1699     LispObject list;
    1700     try
    1701       {
    1702         list = ((Symbol)symbol).getPropertyList();
    1703       }
    1704     catch (ClassCastException e)
    1705       {
    1706         return type_error(symbol, Symbol.SYMBOL);
    1707       }
     1605    LispObject list = checkSymbol(symbol).getPropertyList();
    17081606    while (list != NIL)
    17091607      {
     
    17191617    throws ConditionThrowable
    17201618  {
    1721     LispObject list;
    1722     try
    1723       {
    1724         list = ((Symbol)symbol).getPropertyList();
    1725       }
    1726     catch (ClassCastException e)
    1727       {
    1728         return type_error(symbol, Symbol.SYMBOL);
    1729       }
     1619    LispObject list = checkSymbol(symbol).getPropertyList();
    17301620    while (list != NIL)
    17311621      {
     
    20441934  {
    20451935    resetIO(new Stream(System.in, Symbol.CHARACTER, true),
    2046       new Stream(System.out, Symbol.CHARACTER, true));
     1936            new Stream(System.out, Symbol.CHARACTER, true));
    20471937  }
    20481938
  • trunk/abcl/src/org/armedbear/lisp/LispCharacter.java

    r11714 r11754  
    176176
    177177  public static char getValue(LispObject obj) throws ConditionThrowable
    178   {
    179     try
    180       {
     178  {       
     179          if (obj instanceof LispCharacter)
    181180        return ((LispCharacter)obj).value;
    182       }
    183     catch (ClassCastException e)
    184       {
    185         type_error(obj, Symbol.CHARACTER);
     181      type_error(obj, Symbol.CHARACTER);
    186182        // Not reached.
    187         return 0;
    188       }
     183      return 0;
    189184  }
    190185
     
    302297      public LispObject execute(LispObject arg) throws ConditionThrowable
    303298      {
    304         try
    305           {
    306             return Character.isWhitespace(((LispCharacter)arg).value) ? T : NIL;
    307           }
    308         catch (ClassCastException e)
    309           {
    310             return type_error(arg, Symbol.CHARACTER);
    311           }
     299          return Character.isWhitespace(LispCharacter.getValue(arg)) ? T : NIL;
    312300      }
    313301    };
     
    320308      public LispObject execute(LispObject arg) throws ConditionThrowable
    321309      {
    322         try
    323           {
    324             int n = ((LispCharacter)arg).value;
    325             return Fixnum.getInstance(n);
    326           }
    327         catch (ClassCastException e)
    328           {
    329             return type_error(arg, Symbol.CHARACTER);
    330           }
     310          int n = LispCharacter.getValue(arg);
     311          return Fixnum.getInstance(n);
    331312      }
    332313    };
     
    339320      public LispObject execute(LispObject arg) throws ConditionThrowable
    340321      {
    341         try
    342           {
    343             int n = ((LispCharacter)arg).value;
    344             return Fixnum.getInstance(n);
    345           }
    346         catch (ClassCastException e)
    347           {
    348             return type_error(arg, Symbol.CHARACTER);
    349           }
     322          int n = LispCharacter.getValue(arg);
     323          return Fixnum.getInstance(n);
    350324      }
    351325    };
     
    358332      public LispObject execute(LispObject arg) throws ConditionThrowable
    359333      {
    360         try
    361           {
    362             int n = ((Fixnum)arg).value;
    363             if (n < CHAR_MAX)
    364               return constants[n];
    365             else if (n <= Character.MAX_VALUE)
    366               return new LispCharacter((char)n);
    367           }
    368         catch (ClassCastException e)
    369           {
     334          int n = Fixnum.getValue(arg);
     335          if (n < CHAR_MAX)
     336            return constants[n];
     337          else if (n <= Character.MAX_VALUE)
     338            return new LispCharacter((char)n);
    370339              // SBCL signals a type-error here: "not of type (UNSIGNED-BYTE 8)"
    371           }
    372340        return NIL;
    373341      }
     
    428396      public LispObject execute(LispObject arg) throws ConditionThrowable
    429397      {
    430         char c;
    431         try
    432           {
    433             c = ((LispCharacter)arg).value;
    434           }
    435         catch (ClassCastException e)
    436           {
    437             return type_error(arg, Symbol.CHARACTER);
    438           }
    439         if (c < 128)
    440           return constants[LOWER_CASE_CHARS[c]];
     398          final char c = LispCharacter.getValue(arg);
     399          if (c < 128)
     400           return constants[LOWER_CASE_CHARS[c]];
    441401        return LispCharacter.getInstance(toLowerCase(c));
    442402      }
     
    451411      {
    452412        final char c;
    453         try
    454           {
    455             c = ((LispCharacter)arg).value;
    456           }
    457         catch (ClassCastException e)
    458           {
    459             return type_error(arg, Symbol.CHARACTER);
    460           }
     413        c = LispCharacter.getValue(arg);
    461414        if (c < 128)
    462415          return constants[UPPER_CASE_CHARS[c]];
     
    472425      public LispObject execute(LispObject arg) throws ConditionThrowable
    473426      {
    474         int weight;
    475         try
    476           {
    477             weight = ((Fixnum)arg).value;
    478           }
    479         catch (ClassCastException e)
    480           {
    481             if (arg instanceof Bignum)
     427          if (arg instanceof Bignum)
    482428              return NIL;
    483             return type_error(arg, Symbol.INTEGER);
    484           }
     429
     430          int weight = Fixnum.getValue(arg);
    485431        if (weight < 10)
    486           return constants['0' + weight];
     432          return constants['0'+weight];
    487433        return NIL;
    488434      }
     
    492438      {
    493439        int radix;
    494         try
    495           {
     440        if (second instanceof Fixnum)
    496441            radix = ((Fixnum)second).value;
    497           }
    498         catch (ClassCastException e)
    499           {
     442        else
    500443            radix = -1;
    501           }
     444       
    502445        if (radix < 2 || radix > 36)
    503446          return type_error(second,
    504447                                 list(Symbol.INTEGER, Fixnum.TWO,
    505448                                       Fixnum.constants[36]));
    506         int weight;
    507         try
    508           {
    509             weight = ((Fixnum)first).value;
    510           }
    511         catch (ClassCastException e)
    512           {
    513             if (first instanceof Bignum)
    514               return NIL;
    515             return type_error(first, Symbol.INTEGER);
    516           }
     449        if (first instanceof Bignum)
     450            return NIL;
     451        int weight = Fixnum.getValue(first);
    517452        if (weight >= radix)
    518453          return NIL;
     
    530465      public LispObject execute(LispObject arg) throws ConditionThrowable
    531466      {
    532         try
    533           {
    534             int n = Character.digit(((LispCharacter)arg).value, 10);
    535             return n < 0 ? NIL : Fixnum.constants[n];
    536           }
    537         catch (ClassCastException e)
    538           {
    539             return type_error(arg, Symbol.CHARACTER);
    540           }
     467          final int n = Character.digit(LispCharacter.getValue(arg), 10);
     468          return n < 0 ? NIL : Fixnum.getInstance(n);
    541469      }
    542470      @Override
     
    545473      {
    546474        char c;
    547         try
    548           {
    549             c = ((LispCharacter)first).value;
    550           }
    551         catch (ClassCastException e)
    552           {
    553             return type_error(first, Symbol.CHARACTER);
    554           }
    555         try
     475            c = LispCharacter.getValue(first);
     476        if (second instanceof Fixnum)
    556477          {
    557478            int radix = ((Fixnum)second).value;
     
    562483              }
    563484          }
    564         catch (ClassCastException e) {}
    565485        return type_error(second,
    566486                               list(Symbol.INTEGER, Fixnum.TWO,
     
    576496      public LispObject execute(LispObject arg) throws ConditionThrowable
    577497      {
    578         try
    579           {
    580             return ((LispCharacter)arg).isStandardChar() ? T : NIL;
    581           }
    582         catch (ClassCastException e)
    583           {
    584             return type_error(arg, Symbol.CHARACTER);
    585           }
     498          return checkCharacter(arg).isStandardChar() ? T : NIL;
    586499      }
    587500    };
     
    594507      public LispObject execute(LispObject arg) throws ConditionThrowable
    595508      {
    596         try
    597           {
    598             char c = ((LispCharacter)arg).value;
    599             if (c >= ' ' && c < 127)
    600               return T;
    601             return Character.isISOControl(c) ? NIL : T;
    602           }
    603         catch (ClassCastException e)
    604           {
    605             return type_error(arg, Symbol.CHARACTER);
    606           }
     509          char c = LispCharacter.getValue(arg);
     510          if (c >= ' ' && c < 127)
     511            return T;
     512          return Character.isISOControl(c) ? NIL : T;
    607513      }
    608514    };
     
    615521      public LispObject execute(LispObject arg) throws ConditionThrowable
    616522      {
    617         try
    618           {
    619             return Character.isLetter(((LispCharacter)arg).value) ? T : NIL;
    620           }
    621         catch (ClassCastException e)
    622           {
    623             return type_error(arg, Symbol.CHARACTER);
    624           }
     523          return Character.isLetter(LispCharacter.getValue(arg)) ? T : NIL;
    625524      }
    626525    };
     
    633532      public LispObject execute(LispObject arg) throws ConditionThrowable
    634533      {
    635         try
    636           {
    637             return Character.isLetterOrDigit(((LispCharacter)arg).value) ? T : NIL;
    638           }
    639         catch (ClassCastException e)
    640           {
    641             return type_error(arg, Symbol.CHARACTER);
    642           }
     534          return Character.isLetterOrDigit(LispCharacter.getValue(arg)) ? T : NIL;
    643535      }
    644536    };
  • trunk/abcl/src/org/armedbear/lisp/LispClass.java

    r11711 r11754  
    6565    throws ConditionThrowable
    6666  {
    67     final Symbol symbol;
    68     try
    69       {
    70         symbol = (Symbol) name;
    71       }
    72     catch (ClassCastException e)
    73       {
    74         return type_error(name, Symbol.SYMBOL);
    75       }
     67    final Symbol symbol = checkSymbol(name);
    7668    final LispClass c;
    7769    synchronized (map)
     
    364356        throws ConditionThrowable
    365357      {
    366         final Symbol name;
    367         try
    368           {
    369             name = (Symbol) first;
    370           }
    371         catch (ClassCastException e)
    372           {
    373             return type_error(first, Symbol.SYMBOL);
    374           }
     358        final Symbol name = checkSymbol(first);
    375359        if (second == NIL)
    376360          {
     
    378362            return second;
    379363          }
    380         final LispClass c;
    381         try
    382           {
    383             c = (LispClass) second;
    384           }
    385         catch (ClassCastException e)
    386           {
    387             return type_error(second, Symbol.CLASS);
    388           }
     364        final LispClass c = checkClass(second);
    389365        addClass(name, c);
    390366        return second;
     
    400376        throws ConditionThrowable
    401377      {
    402         final LispClass c;
    403         try
    404           {
    405             c = (LispClass) first;
    406           }
    407         catch (ClassCastException e)
    408           {
    409             return type_error(first, Symbol.CLASS);
    410           }
     378        final LispClass c = checkClass(first);
    411379        return c.subclassp(second) ? T : NIL;
    412380      }
  • trunk/abcl/src/org/armedbear/lisp/LispObject.java

    r11714 r11754  
    102102  public Object javaInstance() throws ConditionThrowable
    103103  {
    104   return this;
     104        return this;
    105105    /*return error(new LispError("The value " + writeToString() +
    106106                                " is not of primitive type."));*/
     
    452452  public LispObject AREF(LispObject index) throws ConditionThrowable
    453453  {
    454     try
    455       {
    456         return AREF(((Fixnum)index).value);
    457       }
    458     catch (ClassCastException e)
    459       {
    460         return type_error(index, Symbol.FIXNUM);
    461       }
     454      return AREF(Fixnum.getValue(index));
    462455  }
    463456
    464457  public void aset(int index, int n)
    465458    throws ConditionThrowable
    466   {
    467     aset(index, Fixnum.getInstance(n));
     459  {   
     460          aset(index, Fixnum.getInstance(n));
    468461  }
    469462
     
    477470    throws ConditionThrowable
    478471  {
    479     try
    480       {
    481         aset(((Fixnum)index).value, newValue);
    482       }
    483     catch (ClassCastException e)
    484       {
    485         type_error(index, Symbol.FIXNUM);
    486       }
     472      aset(Fixnum.getValue(index), newValue);
    487473  }
    488474
  • trunk/abcl/src/org/armedbear/lisp/LispThread.java

    r11711 r11754  
    10351035        {
    10361036            final LispThread lispThread;
    1037             try {
     1037            if (arg instanceof LispThread) {
    10381038                lispThread = (LispThread) arg;
    10391039            }
    1040             catch (ClassCastException e) {
     1040            else {
    10411041                return type_error(arg, Symbol.THREAD);
    10421042            }
     
    10521052        public LispObject execute(LispObject arg) throws ConditionThrowable
    10531053        {
    1054             try {
     1054                if (arg instanceof LispThread) {
    10551055                return ((LispThread)arg).name;
    10561056            }
    1057             catch (ClassCastException e) {
    1058                 return type_error(arg, Symbol.THREAD);
    1059             }
     1057                 return type_error(arg, Symbol.THREAD);
    10601058        }
    10611059    };
     
    11101108        {
    11111109            final LispThread thread;
    1112             try {
     1110            if (arg instanceof LispThread) {
    11131111                thread = (LispThread) arg;
    11141112            }
    1115             catch (ClassCastException e) {
     1113            else {
    11161114                return type_error(arg, Symbol.THREAD);
    11171115            }
     
    11351133                return error(new WrongNumberOfArgumentsException(this));
    11361134            final LispThread thread;
    1137             try {
     1135            if (args[0] instanceof LispThread) {
    11381136                thread = (LispThread) args[0];
    11391137            }
    1140             catch (ClassCastException e) {
     1138            else {
    11411139                return type_error(args[0], Symbol.THREAD);
    11421140            }
  • trunk/abcl/src/org/armedbear/lisp/LogicalPathname.java

    r11539 r11754  
    284284            throws ConditionThrowable
    285285        {
    286             try {
    287                 AbstractString s = (AbstractString) arg;
     286                AbstractString s = checkString(arg);
    288287                if (s.length() == 0) {
    289288                    // "The null string, "", is not a valid value for any
     
    293292                }
    294293                return canonicalizeStringComponent(s);
    295             }
    296             catch (ClassCastException e) {
    297                 return type_error(arg, Symbol.STRING);
    298             }
    299294        }
    300295    };
  • trunk/abcl/src/org/armedbear/lisp/Mutex.java

    r11488 r11754  
    120120        public LispObject execute(LispObject arg) throws ConditionThrowable
    121121        {
    122             try {
    123                 ((Mutex)arg).acquire();
    124                 return T;
    125             }
    126             catch (ClassCastException e) {
    127                 return error(new TypeError("The value " + arg.writeToString() +
    128                                             " is not a mutex."));
    129             }
    130             catch (InterruptedException e) {
    131                 return error(new LispError(
    132                     "The thread " + LispThread.currentThread().writeToString() +
    133                     " was interrupted."));
    134             }
    135         }
     122                        if (arg instanceof Mutex)
     123                                try {
     124                                        ((Mutex) arg).acquire();
     125                                        return T;
     126                                } catch (InterruptedException e) {
     127                                        return error(new LispError("The thread "
     128                                                        + LispThread.currentThread().writeToString()
     129                                                        + " was interrupted."));
     130                                }
     131                        return error(new TypeError("The value " + arg.writeToString()
     132                                        + " is not a mutex."));
     133                }
    136134    };
    137135
     
    143141        public LispObject execute(LispObject arg) throws ConditionThrowable
    144142        {
    145             try {
     143                if (arg instanceof Mutex) {
    146144                ((Mutex)arg).release();
    147145                return T;
    148146            }
    149             catch (ClassCastException e) {
    150147                return error(new TypeError("The value " + arg.writeToString() +
    151148                                            " is not a mutex."));
    152             }
    153149        }
    154150    };
  • trunk/abcl/src/org/armedbear/lisp/Nil.java

    r11726 r11754  
    169169    {
    170170        int index;
    171         try {
    172             index = ((Fixnum)arg).value;
    173         }
    174         catch (ClassCastException e) {
    175             if (arg instanceof Bignum) {
    176                 if (arg.minusp())
    177                     return error(new TypeError(arg, Symbol.UNSIGNED_BYTE));
     171                if (arg instanceof Fixnum) {
     172                        index = ((Fixnum) arg).value;
     173                } else if (arg instanceof Bignum) {
     174                        if (arg.minusp())
     175                                return error(new TypeError(arg, Symbol.UNSIGNED_BYTE));
     176                        return NIL;
     177                } else
     178                        return error(new TypeError(arg, Symbol.UNSIGNED_BYTE));
     179                if (index < 0)
     180                        error(new TypeError(arg, Symbol.UNSIGNED_BYTE));
    178181                return NIL;
    179             }
    180             return error(new TypeError(arg, Symbol.UNSIGNED_BYTE));
    181         }
    182         if (index < 0)
    183             error(new TypeError(arg, Symbol.UNSIGNED_BYTE));
    184         return NIL;
    185182    }
    186183
  • trunk/abcl/src/org/armedbear/lisp/Pathname.java

    r11711 r11754  
    759759        {
    760760            final LispThread thread = LispThread.currentThread();
    761             final AbstractString namestring;
    762             try {
    763                 namestring = (AbstractString) first;
    764             }
    765             catch (ClassCastException e) {
    766                 return type_error(first, Symbol.STRING);
    767             }
     761            final AbstractString namestring = checkString(first);
    768762            // The HOST parameter must be a string or NIL.
    769763            if (second == NIL) {
     
    781775            }
    782776            Debug.assertTrue(second != NIL);
    783             final AbstractString host;
    784             try {
    785                 host = (AbstractString) second;
    786             }
    787             catch (ClassCastException e) {
    788                 return type_error(second, Symbol.STRING);
    789             }
     777            final AbstractString host = checkString(second);
    790778            return thread.setValues(parseNamestring(namestring, host),
    791779                                    namestring.LENGTH());
  • trunk/abcl/src/org/armedbear/lisp/Primitives.java

    r11714 r11754  
    248248      public LispObject execute(LispObject arg) throws ConditionThrowable
    249249      {
    250         try
    251           {
    252             return ((AbstractArray)arg).hasFillPointer() ? T : NIL;
    253           }
    254         catch (ClassCastException e)
    255           {
    256             return type_error(arg, Symbol.ARRAY);
    257           }
    258       }
     250            return checkArray(arg).hasFillPointer() ? T : NIL;
     251          }
    259252    };
    260253
     
    444437        throws ConditionThrowable
    445438      {
    446         try
    447           {
    448             return first.elt(((Fixnum)second).value);
    449           }
    450         catch (ClassCastException e)
    451           {
    452             return type_error(second, Symbol.FIXNUM);
    453           }
     439            return first.elt(Fixnum.getValue(second));
    454440      }
    455441    };
     
    596582      {
    597583        final LispObject value;
    598         try
    599           {
    600             value = ((Symbol)arg).symbolValue();
    601           }
    602         catch (ClassCastException e)
    603           {
    604             return type_error(arg, Symbol.SYMBOL);
    605           }
     584        value = checkSymbol(arg).symbolValue();
    606585        if (value instanceof SymbolMacro)
    607586          return error(new LispError(arg.writeToString() +
     
    619598        throws ConditionThrowable
    620599      {
    621         try
    622           {
    623             return LispThread.currentThread().setSpecialVariable((Symbol)first,
     600            return LispThread.currentThread().setSpecialVariable(checkSymbol(first),
    624601                                                                 second);
    625           }
    626         catch (ClassCastException e)
    627           {
    628             return type_error(first, Symbol.SYMBOL);
    629           }
    630602      }
    631603    };
     
    799771        throws ConditionThrowable
    800772      {
    801         try
    802           {
    803             ((Stream)second)._writeString(first.writeToString());
     773            checkStream(second)._writeString(first.writeToString());
    804774            return first;
    805           }
    806         catch (ClassCastException e)
    807           {
    808             return type_error(second, Symbol.STREAM);
    809           }
    810775      }
    811776    };
     
    819784        throws ConditionThrowable
    820785      {
    821         final Stream out;
    822         try
    823           {
     786        final LispObject out;
    824787            if (second == T)
    825               out = (Stream) Symbol.TERMINAL_IO.symbolValue();
     788              out = Symbol.TERMINAL_IO.symbolValue();
    826789            else if (second == NIL)
    827               out = (Stream) Symbol.STANDARD_OUTPUT.symbolValue();
     790              out = Symbol.STANDARD_OUTPUT.symbolValue();
    828791            else
    829               out = (Stream) second;
    830           }
    831         catch (ClassCastException e)
    832           {
    833             return type_error(second, Symbol.STREAM);
    834           }
    835         out._writeString(first.writeToString());
     792              out = second;
     793        checkStream(out)._writeString(first.writeToString());
    836794        return first;
    837795      }
     
    856814      public LispObject execute(LispObject arg) throws ConditionThrowable
    857815      {
    858         try
    859           {
    860             ((Stream)arg)._writeChar('\n');
     816            checkStream(arg)._writeChar('\n');
    861817            return NIL;
    862           }
    863         catch (ClassCastException e)
    864           {
    865             return type_error(arg, Symbol.STREAM);
    866           }
    867818      }
    868819    };
     
    880831          arg = Symbol.STANDARD_OUTPUT.symbolValue();
    881832        final Stream stream;
    882         try
    883           {
    884             stream = (Stream) arg;
    885           }
    886         catch (ClassCastException e)
    887           {
    888             return type_error(arg, Symbol.STREAM);
    889           }
     833        stream = checkStream(arg);
    890834        return stream.terpri();
    891835      }
     
    905849          arg = Symbol.STANDARD_OUTPUT.symbolValue();
    906850        final Stream stream;
    907         try
    908           {
    909             stream = (Stream) arg;
    910           }
    911         catch (ClassCastException e)
    912           {
    913             return type_error(arg, Symbol.STREAM);
    914           }
     851        stream = checkStream(arg);
    915852        return stream.freshLine();
    916853      }
     
    927864      {
    928865        final Symbol symbol;
    929         try
    930           {
    931             symbol = (Symbol) arg;
    932           }
    933         catch (ClassCastException e)
    934           {
    935             return type_error(arg, Symbol.SYMBOL);
    936           }
     866        symbol = checkSymbol(arg);
    937867        // PROGV: "If too few values are supplied, the remaining symbols
    938868        // are bound and then made to have no value." So BOUNDP must
     
    974904        if (arg instanceof Symbol)
    975905          {
    976             ((Symbol)arg).setSymbolFunction(null);
     906            checkSymbol(arg).setSymbolFunction(null);
    977907            return arg;
    978908          }
     
    15061436        throws ConditionThrowable
    15071437      {
    1508         final int index;
    1509         try
    1510           {
    1511             index = ((Fixnum)first).value;
    1512           }
    1513         catch (ClassCastException e)
    1514           {
    1515             return type_error(first, Symbol.FIXNUM);
    1516           }
     1438        final int index = Fixnum.getValue(first);
    15171439        if (index < 0)
    15181440          return type_error(first,
     
    16481570            if (out instanceof Stream)
    16491571              {
    1650                 ((Stream)out)._writeString(s);
     1572                (out)._writeString(s);
    16511573                return NIL;
    16521574              }
     
    18881810      {
    18891811        final Symbol symbol;
    1890         try
    1891           {
    1892             symbol = (Symbol) first;
    1893           }
    1894         catch (ClassCastException e)
    1895           {
    1896             return type_error(first, Symbol.SYMBOL);
    1897           }
     1812            symbol = checkSymbol(first);
    18981813        if (third instanceof AbstractString)
    18991814          symbol.setDocumentation(Symbol.VARIABLE, third);
     
    19131828      {
    19141829        final Symbol symbol;
    1915         try
    1916           {
    1917             symbol = (Symbol) arg;
    1918           }
    1919         catch (ClassCastException e)
    1920           {
    1921             return type_error(arg, Symbol.SYMBOL);
    1922           }
     1830            symbol = checkSymbol(arg);
    19231831        symbol.setSpecial(true);
    19241832        return symbol;
     
    19291837      {
    19301838        final Symbol symbol;
    1931         try
    1932           {
    1933             symbol = (Symbol) first;
    1934           }
    1935         catch (ClassCastException e)
    1936           {
    1937             return type_error(first, Symbol.SYMBOL);
    1938           }
     1839            symbol = checkSymbol(first);
    19391840        symbol.initializeSpecial(second);
    19401841        return symbol;
     
    19521853      {
    19531854        final Symbol symbol;
    1954         try
    1955           {
    1956             symbol = (Symbol) first;
    1957           }
    1958         catch (ClassCastException e)
    1959           {
    1960             return type_error(first, Symbol.SYMBOL);
    1961           }
     1855            symbol = checkSymbol(first);
    19621856        if (third != NIL)
    19631857          {
     
    21422036      public LispObject execute(LispObject arg) throws ConditionThrowable
    21432037      {
    2144         try
    2145           {
    2146             return Fixnum.getInstance(((AbstractArray)arg).getRank());
    2147           }
    2148         catch (ClassCastException e)
    2149           {
    2150             return type_error(arg, Symbol.ARRAY);
    2151           }
     2038          return Fixnum.getInstance(checkArray(arg).getRank());
     2039
    21522040      }
    21532041    };
     
    21612049      public LispObject execute(LispObject arg) throws ConditionThrowable
    21622050      {
    2163         try
    2164           {
    2165             return ((AbstractArray)arg).getDimensions();
    2166           }
    2167         catch (ClassCastException e)
    2168           {
    2169             return type_error(arg, Symbol.ARRAY);
    2170           }
     2051            return checkArray(arg).getDimensions();
    21712052      }
    21722053    };
     
    21802061        throws ConditionThrowable
    21812062      {
    2182         final AbstractArray array;
    2183         try
    2184           {
    2185             array = (AbstractArray) first;
    2186           }
    2187         catch (ClassCastException e)
    2188           {
    2189             return type_error(first, Symbol.ARRAY);
    2190           }
    2191         final int n;
    2192         try
    2193           {
    2194             n = ((Fixnum)second).value;
    2195           }
    2196         catch (ClassCastException e)
    2197           {
    2198             return type_error(second, Symbol.FIXNUM);
    2199           }
    2200         return Fixnum.getInstance(array.getDimension(n));
     2063        final AbstractArray array = checkArray(first);
     2064        return Fixnum.getInstance(array.getDimension(Fixnum.getValue(second)));
    22012065      }
    22022066    };
     
    22092073      public LispObject execute(LispObject arg) throws ConditionThrowable
    22102074      {
    2211         try
    2212           {
    2213             return Fixnum.getInstance(((AbstractArray)arg).getTotalSize());
    2214           }
    2215         catch (ClassCastException e)
    2216           {
    2217             return type_error(arg, Symbol.ARRAY);
    2218           }
     2075          return Fixnum.getInstance(checkArray(arg).getTotalSize());
    22192076      }
    22202077    };
     
    22292086      public LispObject execute(LispObject arg) throws ConditionThrowable
    22302087      {
    2231         try
    2232           {
    2233             return ((AbstractArray)arg).getElementType();
    2234           }
    2235         catch (ClassCastException e)
    2236           {
    2237             return type_error(arg, Symbol.ARRAY);
    2238           }
     2088            return checkArray(arg).getElementType();
    22392089      }
    22402090    };
     
    22472097      public LispObject execute(LispObject arg) throws ConditionThrowable
    22482098      {
    2249         try
    2250           {
    2251             return ((AbstractArray)arg).isAdjustable() ? T : NIL;
    2252           }
    2253         catch (ClassCastException e)
    2254           {
    2255             return type_error(arg, Symbol.ARRAY);
    2256           }
     2099            return checkArray(arg).isAdjustable() ? T : NIL;
    22572100      }
    22582101    };
     
    22652108      public LispObject execute(LispObject arg) throws ConditionThrowable
    22662109      {
    2267         try
    2268           {
    2269             return ((AbstractArray)arg).arrayDisplacement();
    2270           }
    2271         catch (ClassCastException e)
    2272           {
    2273             return type_error(arg, Symbol.ARRAY);
    2274           }
     2110            return checkArray(arg).arrayDisplacement();
     2111
    22752112      }
    22762113    };
     
    22862123          return error(new WrongNumberOfArgumentsException(this));
    22872124        final AbstractArray array;
    2288         try
    2289           {
    2290             array = (AbstractArray) args[0];
    2291           }
    2292         catch (ClassCastException e)
    2293           {
    2294             return type_error(args[0], Symbol.ARRAY);
    2295           }
     2125                LispObject r = args[0];
     2126            array = checkArray(r);
    22962127        int rank = array.getRank();
    22972128        if (rank != args.length - 1)
     
    23322163      {
    23332164        final AbstractArray array;
    2334         try
    2335           {
    2336             array = (AbstractArray) first;
    2337           }
    2338         catch (ClassCastException e)
    2339           {
    2340             return type_error(first, Symbol.ARRAY);
    2341           }
     2165        array = checkArray(first);
    23422166        LispObject[] subscripts = second.copyToArray();
    23432167        return number(array.getRowMajorIndex(subscripts));
     
    23582182      {
    23592183        final AbstractArray array;
    2360         try
    2361           {
    2362             array = (AbstractArray) arg;
    2363           }
    2364         catch (ClassCastException e)
    2365           {
    2366             return type_error(arg, Symbol.ARRAY);
    2367           }
     2184        array = checkArray( arg);
    23682185        if (array.getRank() == 0)
    23692186          return array.AREF(0);
     
    23852202        throws ConditionThrowable
    23862203      {
    2387         final AbstractArray array;
    2388         try
    2389           {
    2390             array = (AbstractArray) first;
    2391           }
    2392         catch (ClassCastException e)
    2393           {
    2394             return type_error(first, Symbol.ARRAY);
    2395           }
    2396         final int[] subs = new int[2];
    2397         try
    2398           {
    2399             subs[0] = ((Fixnum)second).value;
    2400           }
    2401         catch (ClassCastException e)
    2402           {
    2403             return type_error(second, Symbol.FIXNUM);
    2404           }
    2405         try
    2406           {
    2407             subs[1] = ((Fixnum)third).value;
    2408           }
    2409         catch (ClassCastException e)
    2410           {
    2411             return type_error(third, Symbol.FIXNUM);
    2412           }
    2413         return array.get(subs);
     2204        return checkArray(first).get(new int[]{Fixnum.getValue(second),Fixnum.getValue(third)} );
    24142205      }
    24152206      @Override
    24162207      public LispObject execute(LispObject[] args) throws ConditionThrowable
    24172208      {
    2418         final AbstractArray array;
    2419         try
    2420           {
    2421             array = (AbstractArray) args[0];
    2422           }
    2423         catch (ClassCastException e)
    2424           {
    2425             return type_error(args[0], Symbol.ARRAY);
    2426           }
     2209        final AbstractArray array = checkArray(args[0]);
    24272210        final int[] subs = new int[args.length - 1];
    24282211        for (int i = subs.length; i-- > 0;)
    24292212          {
    2430             try
    2431               {
    2432                 subs[i] = ((Fixnum)args[i+1]).value;
    2433               }
    2434             catch (ClassCastException e)
    2435               {
    2436                 return type_error(args[i+i], Symbol.FIXNUM);
    2437               }
     2213            subs[i] = Fixnum.getValue(args[i+1]);
    24382214          }
    24392215        return array.get(subs);
     
    24522228        // Rank zero array.
    24532229        final ZeroRankArray array;
    2454         try
    2455           {
     2230          if (first instanceof ZeroRankArray){
    24562231            array = (ZeroRankArray) first;
    24572232          }
    2458         catch (ClassCastException e)
     2233          else
    24592234          {
    24602235            return error(new TypeError("The value " +
     
    24762251      public LispObject execute(LispObject[] args) throws ConditionThrowable
    24772252      {
    2478         final AbstractArray array;
    2479         try
    2480           {
    2481             array = (AbstractArray) args[0];
    2482           }
    2483         catch (ClassCastException e)
    2484           {
    2485             return type_error(args[0], Symbol.ARRAY);
    2486           }
     2253        final AbstractArray array = checkArray(args[0]);
    24872254        final int nsubs = args.length - 2;
    24882255        final int[] subs = new int[nsubs];
    24892256        for (int i = nsubs; i-- > 0;)
    2490           {
    2491             try
    2492               {
    2493                 subs[i] = ((Fixnum)args[i+1]).value;
    2494               }
    2495             catch (ClassCastException e)
    2496               {
    2497                 type_error(args[i+1], Symbol.FIXNUM);
    2498               }
    2499           }
     2257            subs[i] = Fixnum.getValue(args[i+1]);
    25002258        final LispObject newValue = args[args.length - 1];
    25012259        array.set(subs, newValue);
     
    25112269      public LispObject execute(LispObject first, LispObject second)
    25122270        throws ConditionThrowable
    2513       {
    2514         try
    2515           {
    2516             return ((AbstractArray)first).AREF(((Fixnum)second).value);
    2517           }
    2518         catch (ClassCastException e)
    2519           {
    2520             if (first instanceof AbstractArray)
    2521               return type_error(second, Symbol.FIXNUM);
    2522             else
    2523               return type_error(first, Symbol.ARRAY);
    2524           }
     2271      {         
     2272            return checkArray(first).AREF(Fixnum.getValue(second));
    25252273      }
    25262274    };
     
    25452293        throws ConditionThrowable
    25462294      {
    2547         try
    2548           {
    2549             return Fixnum.getInstance(((AbstractArray)arg).getFillPointer());
    2550           }
    2551         catch (ClassCastException e)
    2552           {
     2295          if (arg instanceof AbstractArray) {
     2296                  AbstractArray aa = (AbstractArray)arg;
     2297                  if (aa.hasFillPointer())           
     2298                          return Fixnum.getInstance(aa.getFillPointer());
     2299          }
    25532300            return type_error(arg, list(Symbol.AND, Symbol.VECTOR,
    25542301                                              list(Symbol.SATISFIES,
    25552302                                                    Symbol.ARRAY_HAS_FILL_POINTER_P)));
    2556           }
    25572303      }
    25582304    };
     
    25662312        throws ConditionThrowable
    25672313      {
    2568         try
    2569           {
     2314
     2315          if (first instanceof AbstractVector) {
    25702316            AbstractVector v = (AbstractVector) first;
    25712317            if (v.hasFillPointer())
     
    25752321            return second;
    25762322          }
    2577         catch (ClassCastException e)
    2578           {
     2323
    25792324            return type_error(first, list(Symbol.AND, Symbol.VECTOR,
    25802325                                                list(Symbol.SATISFIES,
    2581                                                       Symbol.ARRAY_HAS_FILL_POINTER_P)));
    2582           }
     2326                                                      Symbol.ARRAY_HAS_FILL_POINTER_P)));         
    25832327      }
    25842328    };
     
    25922336        throws ConditionThrowable
    25932337      {
    2594         final AbstractVector v;
    2595         try
    2596           {
    2597             v = (AbstractVector) second;
    2598           }
    2599         catch (ClassCastException e)
    2600           {
    2601             return type_error(second, Symbol.VECTOR);
    2602           }
     2338        final AbstractVector v = checkVector(second);
    26032339        int fillPointer = v.getFillPointer();
    26042340        if (fillPointer < 0)
     
    26412377      public LispObject execute(LispObject arg) throws ConditionThrowable
    26422378      {
    2643         final AbstractVector v;
    2644         try
    2645           {
    2646             v = (AbstractVector) arg;
    2647           }
    2648         catch (ClassCastException e)
    2649           {
    2650             return type_error(arg, Symbol.VECTOR);
    2651           }
     2379        final AbstractVector v = checkVector( arg);
    26522380        int fillPointer = v.getFillPointer();
    26532381        if (fillPointer < 0)
     
    29462674          {
    29472675            Cons cons;
    2948             try
    2949               {
     2676            if (list instanceof Cons)
    29502677                cons = (Cons) list;
    2951               }
    2952             catch (ClassCastException e)
    2953               {
     2678            else
    29542679                return type_error(list, Symbol.LIST);
    2955               }
    29562680            LispObject obj = thread.execute(fun, cons.car);
    29572681            if (splice == null)
     
    30512775          {
    30522776            Cons cons;
    3053             try
    3054               {
     2777            if (list instanceof Cons)
    30552778                cons = (Cons) list;
    3056               }
    3057             catch (ClassCastException e)
    3058               {
     2779            else
    30592780                return type_error(list, Symbol.LIST);
    3060               }
    30612781            thread.execute(fun, cons.car);
    30622782            list = cons.cdr;
     
    32792999        if (arg instanceof Symbol)
    32803000          {
    3281             Package pkg = Packages.findPackage(((Symbol)arg).getName());
     3001            Package pkg = Packages.findPackage(checkSymbol(arg).getName());
    32823002            return pkg != null ? pkg : NIL;
    32833003          }
     
    35613281          {
    35623282            checkRedefinition(first);
    3563             Symbol symbol = (Symbol) first;
     3283            Symbol symbol = checkSymbol(first);
    35643284            symbol.setSymbolFunction(second);
    35653285            final LispThread thread = LispThread.currentThread();
     
    36573377        throws ConditionThrowable
    36583378      {
    3659         try
    3660           {
    3661             return put((Symbol)symbol, indicator, value);
    3662           }
    3663         catch (ClassCastException e)
    3664           {
    3665             return type_error(symbol, Symbol.SYMBOL);
    3666           }
     3379            return put(checkSymbol(symbol), indicator, value);
    36673380      }
    36683381      @Override
     
    36713384        throws ConditionThrowable
    36723385      {
    3673         try
    3674           {
    3675             return put((Symbol)symbol, indicator, value);
    3676           }
    3677         catch (ClassCastException e)
    3678           {
    3679             return type_error(symbol, Symbol.SYMBOL);
    3680           }
     3386          return put(checkSymbol(symbol), indicator, value);
    36813387      }
    36823388    };
     
    38493555          return error(new WrongNumberOfArgumentsException(this));
    38503556        LispObject tag;
    3851         try
    3852           {
    3853             tag = (Symbol) args.car();
    3854           }
    3855         catch (ClassCastException e)
    3856           {
    3857             return type_error(args.car(), Symbol.SYMBOL);
    3858           }
     3557            tag = checkSymbol(args.car());
    38593558        LispObject body = ((Cons)args).cdr();
    38603559        Environment ext = new Environment(env);
     
    38923591          return error(new WrongNumberOfArgumentsException(this));
    38933592        Symbol symbol;
    3894         try
    3895           {
    3896             symbol = (Symbol) args.car();
    3897           }
    3898         catch (ClassCastException e)
    3899           {
    3900             return type_error(args.car(), Symbol.SYMBOL);
    3901           }
     3593            symbol = checkSymbol(args.car());
     3594
    39023595        LispObject block = env.lookupBlock(symbol);
    39033596        if (block == null)
     
    40873780          {
    40883781            final Symbol sym;
    4089             try
    4090               {
    4091                 sym = (Symbol) var;
    4092               }
    4093             catch (ClassCastException e)
    4094               {
    4095                 return type_error(var, Symbol.SYMBOL);
    4096               }
     3782
     3783            sym =  checkSymbol(var);
     3784
    40973785            LispObject val = i < values.length ? values[i] : NIL;
    40983786            if (specials != NIL && memq(sym, specials))
     
    44134101        throws ConditionThrowable
    44144102      {
    4415         final int start;
    4416         try
    4417           {
    4418             start = ((Fixnum)second).value;
    4419           }
    4420         catch (ClassCastException e)
    4421           {
    4422             return type_error(second, Symbol.FIXNUM);
    4423           }
     4103        final int start = Fixnum.getValue(second);
    44244104        if (start < 0)
    44254105          {
     
    44434123        throws ConditionThrowable
    44444124      {
    4445         final int start;
    4446         try
    4447           {
    4448             start = ((Fixnum)second).value;
    4449           }
    4450         catch (ClassCastException e)
    4451           {
    4452             return type_error(second, Symbol.FIXNUM);
    4453           }
     4125        final int start = Fixnum.getValue(second);
    44544126        if (start < 0)
    44554127          {
     
    48034475        throws ConditionThrowable
    48044476      {
    4805         try
    4806           {
    4807             ((AbstractVector)vector).deleteEq(item);
    4808             return vector;
    4809           }
    4810         catch (ClassCastException e)
    4811           {
    4812             return type_error(vector, Symbol.VECTOR);
    4813           }
     4477          checkVector(vector).deleteEq(item);
     4478          return vector;
    48144479      }
    48154480    };
     
    48234488        throws ConditionThrowable
    48244489      {
    4825         try
    4826           {
    4827             ((AbstractVector)vector).deleteEql(item);
    4828             return vector;
    4829           }
    4830         catch (ClassCastException e)
    4831           {
    4832             return type_error(vector, Symbol.VECTOR);
    4833           }
     4490          checkVector(vector).deleteEql(item);
     4491          return vector;
    48344492      }
    48354493    };
     
    53314989      public LispObject execute(LispObject arg) throws ConditionThrowable
    53324990      {
    5333         try
    5334           {
    5335             return ((Symbol)arg).isBuiltInFunction() ? T : NIL;
    5336           }
    5337         catch (ClassCastException e)
    5338           {
    5339             return type_error(arg, Symbol.SYMBOL);
    5340           }
     4991            return checkSymbol(arg).isBuiltInFunction() ? T : NIL;
    53414992      }
    53424993    };
     
    53715022      public LispObject execute(LispObject arg) throws ConditionThrowable
    53725023      {
    5373         try
    5374           {
    5375             return ((Symbol)arg).name;
    5376           }
    5377         catch (ClassCastException e)
    5378           {
    5379             return type_error(arg, Symbol.SYMBOL);
    5380           }
     5024          return checkSymbol(arg).name;
    53815025      }
    53825026    };
     
    53895033      public LispObject execute(LispObject arg) throws ConditionThrowable
    53905034      {
    5391         try
    5392           {
    5393             return ((Symbol)arg).getPackage();
    5394           }
    5395         catch (ClassCastException e)
    5396           {
    5397             return type_error(arg, Symbol.SYMBOL);
    5398           }
     5035          return checkSymbol(arg).getPackage();
    53995036      }
    54005037    };
     
    54075044      public LispObject execute(LispObject arg) throws ConditionThrowable
    54085045      {
    5409         try
    5410           {
    5411             LispObject function = ((Symbol)arg).getSymbolFunction();
     5046            LispObject function = checkSymbol(arg).getSymbolFunction();
    54125047            if (function != null)
    54135048              return function;
    54145049            return error(new UndefinedFunction(arg));
    5415           }
    5416         catch (ClassCastException e)
    5417           {
    5418             return type_error(arg, Symbol.SYMBOL);
    5419           }
     5050
    54205051      }
    54215052    };
     
    54295060        throws ConditionThrowable
    54305061      {
    5431         try
    5432           {
    5433             ((Symbol)first).setSymbolFunction(second);
     5062            checkSymbol(first).setSymbolFunction(second);
    54345063            return second;
    5435           }
    5436         catch (ClassCastException e)
    5437           {
    5438             return type_error(first, Symbol.SYMBOL);
    5439           }
    54405064      }
    54415065    };
     
    54485072      public LispObject execute(LispObject arg) throws ConditionThrowable
    54495073      {
    5450         try
    5451           {
    5452             return ((Symbol)arg).getPropertyList();
    5453           }
    5454         catch (ClassCastException e)
    5455           {
    5456             return type_error(arg, Symbol.SYMBOL);
    5457           }
     5074            return checkSymbol(arg).getPropertyList();
    54585075      }
    54595076    };
     
    54685085        if (arg instanceof Symbol)
    54695086          {
    5470             if (((Symbol)arg).getPackage() == PACKAGE_KEYWORD)
     5087            if (checkSymbol(arg).getPackage() == PACKAGE_KEYWORD)
    54715088              return T;
    54725089          }
     
    54985115      public LispObject execute(LispObject arg) throws ConditionThrowable
    54995116      {
    5500         try
    5501           {
    5502             ((Symbol)arg).setSymbolValue(null);
     5117            checkSymbol(arg).setSymbolValue(null);
    55035118            return arg;
    5504           }
    5505         catch (ClassCastException e)
    5506           {
    5507             return type_error(arg, Symbol.SYMBOL);
    5508           }
    55095119      }
    55105120    };
     
    55175127      public LispObject execute(LispObject arg) throws ConditionThrowable
    55185128      {
    5519         try
    5520           {
    5521             return ((LispClass)arg).symbol;
    5522           }
    5523         catch (ClassCastException e)
    5524           {
    5525             return type_error(arg, Symbol.CLASS);
    5526           }
     5129          return checkClass(arg).symbol;
    55275130      }
    55285131    };
     
    55365139        throws ConditionThrowable
    55375140      {
    5538         try
    5539           {
    5540             ((LispClass)first).symbol = checkSymbol(second);
    5541             return second;
    5542           }
    5543         catch (ClassCastException e)
    5544           {
    5545             return type_error(first, Symbol.CLASS);
    5546           }
     5141          checkClass(first).symbol = checkSymbol(second);
     5142          return second;
    55475143      }
    55485144    };
     
    55555151      public LispObject execute(LispObject arg) throws ConditionThrowable
    55565152      {
    5557         try
    5558           {
    5559             Layout layout = ((LispClass)arg).getClassLayout();
    5560             return layout != null ? layout : NIL;
    5561           }
    5562         catch (ClassCastException e)
    5563           {
    5564             return type_error(arg, Symbol.CLASS);
    5565           }
     5153          Layout layout = checkClass(arg).getClassLayout();
     5154          return layout != null ? layout : NIL;
    55665155      }
    55675156    };
     
    55755164        throws ConditionThrowable
    55765165      {
    5577         try
    5578           {
    5579             ((LispClass)first).setClassLayout((Layout)second);
     5166        if (second instanceof Layout)
     5167          {
     5168            checkClass(first).setClassLayout((Layout)second);
    55805169            return second;
    55815170          }
    5582         catch (ClassCastException e)
    5583           {
    5584             if (!(first instanceof LispClass))
    5585               return type_error(first, Symbol.CLASS);
    5586             if (!(second instanceof Layout))
    5587               return type_error(second, Symbol.LAYOUT);
    5588             // Not reached.
    5589             return NIL;
    5590           }
     5171        return type_error(second, Symbol.LAYOUT);
    55915172      }
    55925173    };
     
    55995180      public LispObject execute(LispObject arg) throws ConditionThrowable
    56005181      {
    5601         try
    5602           {
    5603             return ((LispClass)arg).getDirectSuperclasses();
    5604           }
    5605         catch (ClassCastException e)
    5606           {
    5607             return type_error(arg, Symbol.CLASS);
    5608           }
     5182            return checkClass(arg).getDirectSuperclasses();
    56095183      }
    56105184    };
     
    56185192        throws ConditionThrowable
    56195193      {
    5620         try
    5621           {
    5622             ((LispClass)first).setDirectSuperclasses(second);
     5194            checkClass(first).setDirectSuperclasses(second);
    56235195            return second;
    5624           }
    5625         catch (ClassCastException e)
    5626           {
    5627             return type_error(first, Symbol.CLASS);
    5628           }
    56295196      }
    56305197    };
     
    56375204      public LispObject execute(LispObject arg) throws ConditionThrowable
    56385205      {
    5639         try
    5640           {
    5641             return ((LispClass)arg).getDirectSubclasses();
    5642           }
    5643         catch (ClassCastException e)
    5644           {
    5645             return type_error(arg, Symbol.CLASS);
    5646           }
     5206            return checkClass(arg).getDirectSubclasses();
    56475207      }
    56485208    };
     
    56575217        throws ConditionThrowable
    56585218      {
    5659         try
    5660           {
    5661             ((LispClass)first).setDirectSubclasses(second);
    5662             return second;
    5663           }
    5664         catch (ClassCastException e)
    5665           {
    5666             return type_error(first, Symbol.CLASS);
    5667           }
     5219          checkClass(first).setDirectSubclasses(second);
     5220          return second;
    56685221      }
    56695222    };
     
    56765229      public LispObject execute(LispObject arg) throws ConditionThrowable
    56775230      {
    5678         try
    5679           {
    5680             return ((LispClass)arg).getCPL();
    5681           }
    5682         catch (ClassCastException e)
    5683           {
    5684             return type_error(arg, Symbol.CLASS);
    5685           }
     5231          return checkClass(arg).getCPL();
    56865232      }
    56875233    };
     
    56955241        throws ConditionThrowable
    56965242      {
    5697         try
    5698           {
    5699             ((LispClass)first).classPrecedenceList = second;
    5700             return second;
    5701           }
    5702         catch (ClassCastException e)
    5703           {
    5704             return type_error(first, Symbol.CLASS);
    5705           }
     5243          checkClass(first).classPrecedenceList = second;
     5244          return second;
    57065245      }
    57075246    };
     
    57155254        throws ConditionThrowable
    57165255      {
    5717         try
    5718           {
    5719             return ((LispClass)arg).directMethods;
    5720           }
    5721         catch (ClassCastException e)
    5722           {
    5723             return type_error(arg, Symbol.CLASS);
    5724           }
     5256          return checkClass(arg).directMethods;
    57255257      }
    57265258    };
     
    57345266        throws ConditionThrowable
    57355267      {
    5736         try
    5737           {
    5738             ((LispClass)first).directMethods = second;
    5739             return second;
    5740           }
    5741         catch (ClassCastException e)
    5742           {
    5743             return type_error(first, Symbol.CLASS);
    5744           }
     5268          checkClass(first).directMethods = second;
     5269          return second;
    57455270      }
    57465271    };
     
    57545279        throws ConditionThrowable
    57555280      {
    5756         try
    5757           {
    5758             return ((LispClass)arg).documentation;
    5759           }
    5760         catch (ClassCastException e)
    5761           {
    5762             return type_error(arg, Symbol.CLASS);
    5763           }
     5281          return checkClass(arg).documentation;
    57645282      }
    57655283    };
     
    57735291        throws ConditionThrowable
    57745292      {
    5775         try
    5776           {
    5777             ((LispClass)first).documentation = second;
    5778             return second;
    5779           }
    5780         catch (ClassCastException e)
    5781           {
    5782             return type_error(first, Symbol.CLASS);
    5783           }
     5293          checkClass(first).documentation = second;
     5294          return second;
    57845295      }
    57855296    };
     
    57925303      public LispObject execute(LispObject arg) throws ConditionThrowable
    57935304      {
    5794         try
    5795           {
    5796             return ((LispClass)arg).isFinalized() ? T : NIL;
    5797           }
    5798         catch (ClassCastException e)
    5799           {
    5800             return type_error(arg, Symbol.CLASS);
    5801           }
     5305            return checkClass(arg).isFinalized() ? T : NIL;
    58025306      }
    58035307    };
     
    58115315        throws ConditionThrowable
    58125316      {
    5813         try
    5814           {
    5815             ((LispClass)first).setFinalized(second != NIL);
    5816             return second;
    5817           }
    5818         catch (ClassCastException e)
    5819           {
    5820             return type_error(first, Symbol.CLASS);
    5821           }
     5317          checkClass(first).setFinalized(second != NIL);
     5318          return second;
    58225319      }
    58235320    };
     
    58425339      {
    58435340        final LispCharacter c;
    5844         try
    5845           {
    5846             c = (LispCharacter) arg;
    5847           }
    5848         catch (ClassCastException e)
    5849           {
    5850             return type_error(arg, Symbol.CHARACTER);
    5851           }
     5341        c = checkCharacter( arg);
    58525342        char[] chars = new char[1];
    58535343        chars[0] = c.value;
     
    59335423      public LispObject execute(LispObject arg) throws ConditionThrowable
    59345424      {
    5935         try
    5936           {
    5937             return ((Function)arg).getPropertyList();
    5938           }
    5939         catch (ClassCastException e)
    5940           {
    5941             return type_error(arg, Symbol.FUNCTION);
    5942           }
     5425          return checkFunction(arg).getPropertyList();
    59435426      }
    59445427    };
     
    59515434      public LispObject execute(LispObject arg) throws ConditionThrowable
    59525435      {
    5953         try
    5954           {
    5955             return PACKAGE_KEYWORD.intern(((Symbol)arg).name);
    5956           }
    5957         catch (ClassCastException e)
    5958           {
    5959             return type_error(arg, Symbol.SYMBOL);
    5960           }
     5436          return PACKAGE_KEYWORD.intern(checkSymbol(arg).name);
    59615437      }
    59625438    };
     
    59895465      }
    59905466    };
     5467   
    59915468}
  • trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java

    r11488 r11754  
    115115        public LispObject execute(LispObject arg) throws ConditionThrowable
    116116        {
    117             try {
    118                 return ((PrintNotReadable)arg).getInstanceSlotValue(Symbol.OBJECT);
    119             }
    120             catch (ClassCastException e) {
     117                if (arg instanceof PrintNotReadable) return ((PrintNotReadable)arg).getInstanceSlotValue(Symbol.OBJECT);
    121118                return type_error(arg, Symbol.PRINT_NOT_READABLE);
    122             }
     119
    123120        }
    124121    };
  • trunk/abcl/src/org/armedbear/lisp/Readtable.java

    r11711 r11754  
    552552      public LispObject execute(LispObject arg) throws ConditionThrowable
    553553      {
    554         try
    555           {
    556             return ((Readtable)arg).readtableCase;
    557           }
    558         catch (ClassCastException e)
    559           {
    560             return type_error(arg, Symbol.READTABLE);
    561           }
     554          return checkReadtable(arg).readtableCase;
    562555      }
    563556    };
     
    572565        throws ConditionThrowable
    573566      {
    574         try
    575           {
    576             Readtable readtable = (Readtable) first;
     567            final Readtable readtable = checkReadtable(first);
    577568            if (second == Keyword.UPCASE || second == Keyword.DOWNCASE ||
    578569                second == Keyword.INVERT || second == Keyword.PRESERVE)
     
    586577                                                 Keyword.DOWNCASE,
    587578                                                 Keyword.UPCASE));
    588           }
    589         catch (ClassCastException e)
    590           {
    591             return type_error(first, Symbol.READTABLE);
    592           }
    593579      }
    594580    };
  • trunk/abcl/src/org/armedbear/lisp/SimpleBitVector.java

    r11714 r11754  
    137137            badIndex(index, capacity);
    138138        final int offset = index >> 6;
    139         try {
     139        if (newValue instanceof Fixnum) {
    140140            switch (((Fixnum)newValue).value) {
    141141                case 0:
     
    147147            }
    148148        }
    149         catch (ClassCastException e) {
    150             // Fall through...
    151         }
    152         error(new TypeError(newValue, Symbol.BIT));
     149        // Fall through...
     150        type_error(newValue, Symbol.BIT);
    153151    }
    154152
  • trunk/abcl/src/org/armedbear/lisp/SimpleString.java

    r11714 r11754  
    404404    {
    405405        try {
    406             return LispCharacter.getInstance(chars[((Fixnum)index).value]);
    407         }
    408         catch (ClassCastException e) {
    409             return type_error(index, Symbol.FIXNUM);
     406            return LispCharacter.getInstance(chars[Fixnum.getValue(index)]);
    410407        }
    411408        catch (ArrayIndexOutOfBoundsException e) {
     
    419416    {
    420417        try {
    421             chars[index] = ((LispCharacter)obj).value;
    422         }
    423         catch (ArrayIndexOutOfBoundsException e) {
    424             badIndex(index, capacity);
    425         }
    426         catch (ClassCastException e) {
    427             type_error(obj, Symbol.CHARACTER);
     418            chars[index] = LispCharacter.getValue(obj);
     419        }
     420        catch (ArrayIndexOutOfBoundsException e) {
     421            badIndex(index, capacity);
    428422        }
    429423    }
  • trunk/abcl/src/org/armedbear/lisp/SimpleVector.java

    r11714 r11754  
    176176  public LispObject AREF(LispObject index) throws ConditionThrowable
    177177  {
    178     try
    179       {
    180         return data[((Fixnum)index).value];
    181       }
    182     catch (ClassCastException e)
    183       {
    184         return error(new TypeError(index, Symbol.FIXNUM));
    185       }
    186     catch (ArrayIndexOutOfBoundsException e)
    187       {
    188         badIndex(((Fixnum)index).value, data.length);
     178        int idx = Fixnum.getValue(index);
     179    try
     180      {
     181        return data[idx];
     182      }
     183    catch (ArrayIndexOutOfBoundsException e)
     184      {
     185        badIndex(idx, data.length);
    189186        return NIL; // Not reached.
    190187      }
     
    389386        throws ConditionThrowable
    390387      {
    391         try
    392           {
    393             return ((SimpleVector)first).data[((Fixnum)second).value];
    394           }
    395         catch (ClassCastException e)
    396           {
    397             if (first instanceof SimpleVector)
    398               return error(new TypeError(second, Symbol.FIXNUM));
    399             else
    400               return error(new TypeError(first, Symbol.SIMPLE_VECTOR));
    401           }
    402       }
     388                        if (first instanceof SimpleVector) {
     389                                final SimpleVector sv = (SimpleVector)first;
     390                    int index = Fixnum.getValue(second);
     391                                try {
     392                                        return sv.data[index];
     393                                } catch (ArrayIndexOutOfBoundsException e) {
     394                                        int capacity = sv.capacity;
     395                                         sv.badIndex(index, capacity);
     396                                        // Not reached.
     397                                        return NIL;
     398                                }
     399                        }
     400                        return type_error(first, Symbol.SIMPLE_VECTOR);
     401                }
    403402    };
    404403
     
    412411        throws ConditionThrowable
    413412      {
    414         try
    415           {
    416             ((SimpleVector)first).data[((Fixnum)second).value] = third;
    417             return third;
    418           }
    419         catch (ClassCastException e)
    420           {
    421             if (first instanceof SimpleVector)
    422               return error(new TypeError(second, Symbol.FIXNUM));
    423             else
    424               return error(new TypeError(first, Symbol.SIMPLE_VECTOR));
    425           }
    426         catch (ArrayIndexOutOfBoundsException e)
    427           {
    428             int index = ((Fixnum)second).value;
    429             int capacity = ((SimpleVector)first).capacity;
    430             ((SimpleVector)first).badIndex(index, capacity);
    431             // Not reached.
    432             return NIL;
    433           }
     413                        if (first instanceof SimpleVector) {
     414                                final SimpleVector sv = (SimpleVector)first;
     415                    int index = Fixnum.getValue(second);
     416                                try {
     417                                        sv.data[index] = third;
     418                                        return third;
     419                                } catch (ArrayIndexOutOfBoundsException e) {
     420                                        int capacity = sv.capacity;
     421                                         sv.badIndex(index, capacity);
     422                                        // Not reached.
     423                                        return NIL;
     424                                }
     425                        }
     426                        return type_error(first, Symbol.SIMPLE_VECTOR);
    434427      }
    435428    };
  • trunk/abcl/src/org/armedbear/lisp/SingleFloat.java

    r11714 r11754  
    226226    public static double getValue(LispObject obj) throws ConditionThrowable
    227227    {
    228         try {
     228        if (obj instanceof SingleFloat)
    229229            return ((SingleFloat)obj).value;
    230         }
    231         catch (ClassCastException e) {
    232             error(new TypeError(obj, Symbol.FLOAT));
    233             // Not reached.
    234             return 0;
    235         }
     230        type_error(obj, Symbol.FLOAT);
     231        // not reached
     232        return 0.0D;
    236233    }
    237234
  • trunk/abcl/src/org/armedbear/lisp/SlotClass.java

    r11488 r11754  
    185185            throws ConditionThrowable
    186186        {
    187             try {
     187                if (first instanceof SlotClass) {
    188188                ((SlotClass)first).directSlotDefinitions = second;
    189189                return second;
    190190            }
    191             catch (ClassCastException e) {
     191                else {
    192192                return type_error(first, Symbol.STANDARD_CLASS);
    193193            }
     
    219219            throws ConditionThrowable
    220220        {
    221             try {
     221                if (first instanceof SlotClass) {
    222222                ((SlotClass)first).slotDefinitions = second;
    223223                return second;
    224224            }
    225             catch (ClassCastException e) {
     225                else {
    226226                return type_error(first, Symbol.STANDARD_CLASS);
    227227            }
     
    253253            throws ConditionThrowable
    254254        {
    255             try {
    256                 ((SlotClass)first).directDefaultInitargs = second;
    257                 return second;
    258             }
    259             catch (ClassCastException e) {
    260                 return type_error(first, Symbol.STANDARD_CLASS);
    261             }
     255                   if (first instanceof SlotClass) {               
     256                           ((SlotClass)first).directDefaultInitargs = second;               
     257                           return second;
     258                   }
     259                   return type_error(first, Symbol.STANDARD_CLASS);
    262260        }
    263261    };
     
    304302        {
    305303            final SlotClass c;
    306             try {
     304            if (arg instanceof SlotClass) {
    307305                c = (SlotClass) arg;
    308306            }
    309             catch (ClassCastException e) {
     307            else {
    310308                return type_error(arg, Symbol.STANDARD_CLASS);
    311309            }
  • trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java

    r11714 r11754  
    8282      }
    8383  }
     84 
     85  public static SlotDefinition checkSlotDefination(LispObject obj) throws ConditionThrowable {
     86          if (obj instanceof SlotDefinition) return (SlotDefinition)obj;
     87      return (SlotDefinition)type_error(obj, Symbol.SLOT_DEFINITION);     
     88  }
    8489
    8590  public final LispObject getName()
     
    125130      public LispObject execute(LispObject arg) throws ConditionThrowable
    126131      {
    127         try
    128           {
    129             return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_NAME];
    130           }
    131         catch (ClassCastException e)
    132           {
    133             return type_error(arg, Symbol.SLOT_DEFINITION);
    134           }
     132          return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_NAME];
    135133      }
    136134    };
     
    145143        throws ConditionThrowable
    146144      {
    147         try
    148           {
    149             ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_NAME] = second;
    150             return second;
    151           }
    152         catch (ClassCastException e)
    153           {
    154             return type_error(first, Symbol.SLOT_DEFINITION);
    155           }
     145          checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_NAME] = second;
     146          return second;
    156147      }
    157148    };
     
    164155      public LispObject execute(LispObject arg) throws ConditionThrowable
    165156      {
    166         try
    167           {
    168             return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION];
    169           }
    170         catch (ClassCastException e)
    171           {
    172             return type_error(arg, Symbol.SLOT_DEFINITION);
    173           }
     157          return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION];
    174158      }
    175159    };
     
    184168        throws ConditionThrowable
    185169      {
    186         try
    187           {
    188             ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION] = second;
    189             return second;
    190           }
    191         catch (ClassCastException e)
    192           {
    193             return type_error(first, Symbol.SLOT_DEFINITION);
    194           }
     170          checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_INITFUNCTION] = second;
     171          return second;
    195172      }
    196173    };
     
    204181      public LispObject execute(LispObject arg) throws ConditionThrowable
    205182      {
    206         try
    207           {
    208             return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_INITFORM];
    209           }
    210         catch (ClassCastException e)
    211           {
    212             return type_error(arg, Symbol.SLOT_DEFINITION);
    213           }
     183          return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_INITFORM];
    214184      }
    215185    };
     
    224194        throws ConditionThrowable
    225195      {
    226         try
    227           {
    228             ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_INITFORM] = second;
    229             return second;
    230           }
    231         catch (ClassCastException e)
    232           {
    233             return type_error(first, Symbol.SLOT_DEFINITION);
    234           }
     196          checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_INITFORM] = second;
     197          return second;
    235198      }
    236199    };
     
    243206      public LispObject execute(LispObject arg) throws ConditionThrowable
    244207      {
    245         try
    246           {
    247             return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_INITARGS];
    248           }
    249         catch (ClassCastException e)
    250           {
    251             return type_error(arg, Symbol.SLOT_DEFINITION);
    252           }
     208          return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_INITARGS];
    253209      }
    254210    };
     
    263219        throws ConditionThrowable
    264220      {
    265         try
    266           {
    267             ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_INITARGS] = second;
    268             return second;
    269           }
    270         catch (ClassCastException e)
    271           {
    272             return type_error(first, Symbol.SLOT_DEFINITION);
    273           }
     221          checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_INITARGS] = second;
     222          return second;
    274223      }
    275224    };
     
    283232      public LispObject execute(LispObject arg) throws ConditionThrowable
    284233      {
    285         try
    286           {
    287             return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_READERS];
    288           }
    289         catch (ClassCastException e)
    290           {
    291             return type_error(arg, Symbol.SLOT_DEFINITION);
    292           }
     234          return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_READERS];
    293235      }
    294236    };
     
    303245        throws ConditionThrowable
    304246      {
    305         try
    306           {
    307             ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_READERS] = second;
    308             return second;
    309           }
    310         catch (ClassCastException e)
    311           {
    312             return type_error(first, Symbol.SLOT_DEFINITION);
    313           }
     247          checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_READERS] = second;
     248          return second;
    314249      }
    315250    };
     
    323258      public LispObject execute(LispObject arg) throws ConditionThrowable
    324259      {
    325         try
    326           {
    327             return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_WRITERS];
    328           }
    329         catch (ClassCastException e)
    330           {
    331             return type_error(arg, Symbol.SLOT_DEFINITION);
    332           }
     260          return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_WRITERS];
    333261      }
    334262    };
     
    343271        throws ConditionThrowable
    344272      {
    345         try
    346           {
    347             ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_WRITERS] = second;
    348             return second;
    349           }
    350         catch (ClassCastException e)
    351           {
    352             return type_error(first, Symbol.SLOT_DEFINITION);
    353           }
     273          checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_WRITERS] = second;
     274          return second;
    354275      }
    355276    };
     
    363284      public LispObject execute(LispObject arg) throws ConditionThrowable
    364285      {
    365         try
    366           {
    367             return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION];
    368           }
    369         catch (ClassCastException e)
    370           {
    371             return type_error(arg, Symbol.SLOT_DEFINITION);
    372           }
     286          return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION];
    373287      }
    374288    };
     
    383297        throws ConditionThrowable
    384298      {
    385         try
    386           {
    387             ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION] = second;
    388             return second;
    389           }
    390         catch (ClassCastException e)
    391           {
    392             return type_error(first, Symbol.SLOT_DEFINITION);
    393           }
     299          checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION] = second;
     300          return second;
    394301      }
    395302    };
     
    403310      public LispObject execute(LispObject arg) throws ConditionThrowable
    404311      {
    405         try
    406           {
    407             return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION_CLASS];
    408           }
    409         catch (ClassCastException e)
    410           {
    411             return type_error(arg, Symbol.SLOT_DEFINITION);
    412           }
     312          return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION_CLASS];
    413313      }
    414314    };
     
    423323        throws ConditionThrowable
    424324      {
    425         try
    426           {
    427             ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION_CLASS] = second;
    428             return second;
    429           }
    430         catch (ClassCastException e)
    431           {
    432             return type_error(first, Symbol.SLOT_DEFINITION);
    433           }
     325          checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_ALLOCATION_CLASS] = second;
     326          return second;
    434327      }
    435328    };
     
    442335      public LispObject execute(LispObject arg) throws ConditionThrowable
    443336      {
    444         try
    445           {
    446             return ((SlotDefinition)arg).slots[SlotDefinitionClass.SLOT_INDEX_LOCATION];
    447           }
    448         catch (ClassCastException e)
    449           {
    450             return type_error(arg, Symbol.SLOT_DEFINITION);
    451           }
     337          return checkSlotDefination(arg).slots[SlotDefinitionClass.SLOT_INDEX_LOCATION];
    452338      }
    453339    };
     
    461347        throws ConditionThrowable
    462348      {
    463         try
    464           {
    465             ((SlotDefinition)first).slots[SlotDefinitionClass.SLOT_INDEX_LOCATION] = second;
    466             return second;
    467           }
    468         catch (ClassCastException e)
    469           {
    470             return type_error(first, Symbol.SLOT_DEFINITION);
    471           }
     349          checkSlotDefination(first).slots[SlotDefinitionClass.SLOT_INDEX_LOCATION] = second;
     350          return second;
    472351      }
    473352    };
  • trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java

    r11711 r11754  
    136136                        while (vars != NIL)
    137137                          {
    138           specials.add(0, (Symbol) vars.car());
     138                            specials.add(0, (Symbol) vars.car());
    139139                            vars = ((Cons)vars).cdr;
    140140                          }
     
    148148          }
    149149        Environment ext = new Environment(env);
    150   LinkedList<Cons> nonSequentialVars = new LinkedList<Cons>();
    151   Symbol[] arrayToUseForSpecials = new Symbol[0];
     150        LinkedList<Cons> nonSequentialVars = new LinkedList<Cons>();
     151        Symbol[] arrayToUseForSpecials = new Symbol[0];
    152152        while (varList != NIL)
    153153          {
     
    161161                          + " binding specification " +
    162162                          obj.writeToString() + " is invalid."));
    163                 try
    164                   {
    165                     symbol = (Symbol) ((Cons)obj).car;
    166                   }
    167                 catch (ClassCastException e)
    168                   {
    169                     return type_error(((Cons)obj).car, Symbol.SYMBOL);
    170                   }
     163                symbol = checkSymbol(((Cons)obj).car);
    171164                value = eval(obj.cadr(), sequential ? ext : env, thread);
    172165              }
    173166            else
    174167              {
    175                 try
    176                   {
    177                     symbol = (Symbol) obj;
    178                   }
    179                 catch (ClassCastException e)
    180                   {
    181                     return type_error(obj, Symbol.SYMBOL);
    182                   }
     168                symbol = checkSymbol(obj);
    183169                value = NIL;
    184170              }
    185       if (sequential)
    186     bindArg(specials.toArray(arrayToUseForSpecials),
    187       symbol, value, ext, thread);
    188       else
    189     nonSequentialVars.add(new Cons(symbol, value));
     171            if (sequential)
     172                bindArg(specials.toArray(arrayToUseForSpecials),
     173                        symbol, value, ext, thread);
     174            else
     175                nonSequentialVars.add(new Cons(symbol, value));
    190176            varList = ((Cons)varList).cdr;
    191177          }
    192   if (!sequential)
    193     {
    194       for (Cons x : nonSequentialVars)
    195         {
    196     bindArg(specials.toArray(arrayToUseForSpecials),
    197       (Symbol)x.car(), x.cdr(), ext, thread);
    198         }
    199     }
     178        if (!sequential)
     179          {
     180            for (Cons x : nonSequentialVars)
     181              {
     182                bindArg(specials.toArray(arrayToUseForSpecials),
     183                        (Symbol)x.car(), x.cdr(), ext, thread);
     184              }
     185          }
    200186        // Make sure free special declarations are visible in the body.
    201187        // "The scope of free declarations specifically does not include
  • trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java

    r11711 r11754  
    260260      public LispObject execute(LispObject arg) throws ConditionThrowable
    261261      {
    262         try
    263           {
    264             return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_NAME];
    265           }
    266         catch (ClassCastException e)
    267           {
    268             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    269           }
     262          return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_NAME];
    270263      }
    271264    };
     
    279272        throws ConditionThrowable
    280273      {
    281         try
    282           {
    283             ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_NAME] = second;
    284             return second;
    285           }
    286         catch (ClassCastException e)
    287           {
    288             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    289           }
     274          checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_NAME] = second;
     275          return second;
    290276      }
    291277    };
     
    298284      public LispObject execute(LispObject arg) throws ConditionThrowable
    299285      {
    300         try
    301           {
    302             return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST];
    303           }
    304         catch (ClassCastException e)
    305           {
    306             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    307           }
     286          return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST];
    308287      }
    309288    };
     
    317296        throws ConditionThrowable
    318297      {
    319         try
    320           {
    321             ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST] = second;
    322             return second;
    323           }
    324         catch (ClassCastException e)
    325           {
    326             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    327           }
     298          checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_LAMBDA_LIST] = second;
     299          return second;
    328300      }
    329301    };
     
    338310        throws ConditionThrowable
    339311      {
    340         try
    341           {
    342             return ((StandardGenericFunction)arg).function;
    343           }
    344         catch (ClassCastException e)
    345           {
    346             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    347           }
     312          return checkStandardGenericFunction(arg).function;
    348313      }
    349314    };
     
    359324        throws ConditionThrowable
    360325      {
    361         try
    362           {
    363             ((StandardGenericFunction)first).function = second;
    364             return second;
    365           }
    366         catch (ClassCastException e)
    367           {
    368             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    369           }
     326          checkStandardGenericFunction(first).function = second;
     327          return second;
    370328      }
    371329    };
     
    378336      public LispObject execute(LispObject arg) throws ConditionThrowable
    379337      {
    380         try
    381           {
    382             return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_REQUIRED_ARGS];
    383           }
    384         catch (ClassCastException e)
    385           {
    386             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    387           }
     338          return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_REQUIRED_ARGS];
    388339      }
    389340    };
     
    397348        throws ConditionThrowable
    398349      {
    399         final StandardGenericFunction gf;
    400         try
    401           {
    402             gf = (StandardGenericFunction) first;
    403           }
    404         catch (ClassCastException e)
    405           {
    406             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    407           }
     350        final StandardGenericFunction gf = checkStandardGenericFunction(first);
    408351        gf.slots[StandardGenericFunctionClass.SLOT_INDEX_REQUIRED_ARGS] = second;
    409352        gf.numberOfRequiredArgs = second.length();
     
    419362      public LispObject execute(LispObject arg) throws ConditionThrowable
    420363      {
    421         try
    422           {
    423             return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS];
    424           }
    425         catch (ClassCastException e)
    426           {
    427             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    428           }
     364          return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS];
    429365      }
    430366    };
     
    438374        throws ConditionThrowable
    439375      {
    440         try
    441           {
    442             ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS] = second;
    443             return second;
    444           }
    445         catch (ClassCastException e)
    446           {
    447             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    448           }
     376          checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_INITIAL_METHODS] = second;
     377          return second;
    449378      }
    450379    };
     
    457386      public LispObject execute(LispObject arg) throws ConditionThrowable
    458387      {
    459         try
    460           {
    461             return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS];
    462           }
    463         catch (ClassCastException e)
    464           {
    465             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    466           }
     388          return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS];
    467389      }
    468390    };
     
    476398        throws ConditionThrowable
    477399      {
    478         try
    479           {
    480             ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS] = second;
    481             return second;
    482           }
    483         catch (ClassCastException e)
    484           {
    485             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    486           }
     400          checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHODS] = second;
     401          return second;
    487402      }
    488403    };
     
    495410      public LispObject execute(LispObject arg) throws ConditionThrowable
    496411      {
    497         try
    498           {
    499             return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS];
    500           }
    501         catch (ClassCastException e)
    502           {
    503             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    504           }
     412          return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS];
    505413      }
    506414    };
     
    514422        throws ConditionThrowable
    515423      {
    516         try
    517           {
    518             ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS] = second;
    519             return second;
    520           }
    521         catch (ClassCastException e)
    522           {
    523             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    524           }
     424          checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_CLASS] = second;
     425          return second;
    525426      }
    526427    };
     
    533434      public LispObject execute(LispObject arg) throws ConditionThrowable
    534435      {
    535         try
    536           {
    537             return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION];
    538           }
    539         catch (ClassCastException e)
    540           {
    541             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    542           }
     436          return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION];
    543437      }
    544438    };
     
    552446        throws ConditionThrowable
    553447      {
    554         try
    555           {
    556             ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION] = second;
    557             return second;
    558           }
    559         catch (ClassCastException e)
    560           {
    561             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    562           }
     448          checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_METHOD_COMBINATION] = second;
     449          return second;
    563450      }
    564451    };
     
    571458      public LispObject execute(LispObject arg) throws ConditionThrowable
    572459      {
    573         try
    574           {
    575             return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER];
    576           }
    577         catch (ClassCastException e)
    578           {
    579             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    580           }
     460          return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER];
    581461      }
    582462    };
     
    590470        throws ConditionThrowable
    591471      {
    592         try
    593           {
    594             ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER] = second;
    595             return second;
    596           }
    597         catch (ClassCastException e)
    598           {
    599             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    600           }
     472          checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_ARGUMENT_PRECEDENCE_ORDER] = second;
     473          return second;
    601474      }
    602475    };
     
    609482      public LispObject execute(LispObject arg) throws ConditionThrowable
    610483      {
    611         try
    612           {
    613             return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE];
    614           }
    615         catch (ClassCastException e)
    616           {
    617             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    618           }
     484          return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE];
    619485      }
    620486    };
     
    628494        throws ConditionThrowable
    629495      {
    630         try
    631           {
    632             ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE] = second;
    633             return second;
    634           }
    635         catch (ClassCastException e)
    636           {
    637             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    638           }
     496          checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_CLASSES_TO_EMF_TABLE] = second;
     497          return second;
    639498      }
    640499    };
     
    647506      public LispObject execute(LispObject arg) throws ConditionThrowable
    648507      {
    649         try
    650           {
    651             return ((StandardGenericFunction)arg).slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION];
    652           }
    653         catch (ClassCastException e)
    654           {
    655             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    656           }
     508          return checkStandardGenericFunction(arg).slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION];
    657509      }
    658510    };
     
    666518        throws ConditionThrowable
    667519      {
    668         try
    669           {
    670             ((StandardGenericFunction)first).slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION] = second;
    671             return second;
    672           }
    673         catch (ClassCastException e)
    674           {
    675             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    676           }
     520          checkStandardGenericFunction(first).slots[StandardGenericFunctionClass.SLOT_INDEX_DOCUMENTATION] = second;
     521          return second;
    677522      }
    678523    };
     
    686531      public LispObject execute(LispObject arg) throws ConditionThrowable
    687532      {
    688         final StandardGenericFunction gf;
    689         try
    690           {
    691             gf = (StandardGenericFunction) arg;
    692           }
    693         catch (ClassCastException e)
    694           {
    695             return type_error(arg, Symbol.STANDARD_GENERIC_FUNCTION);
    696           }
    697         gf.finalizeInternal();
    698         return T;
     533          final StandardGenericFunction gf = checkStandardGenericFunction(arg);
     534          gf.finalizeInternal();       
     535          return T;
    699536      }
    700537    };
     
    709546        throws ConditionThrowable
    710547      {
    711         final StandardGenericFunction gf;
    712         try
    713           {
    714             gf = (StandardGenericFunction) first;
    715           }
    716         catch (ClassCastException e)
    717           {
    718             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    719           }
     548        final StandardGenericFunction gf = checkStandardGenericFunction(first);
    720549        LispObject args = second;
    721550        LispObject[] array = new LispObject[gf.numberOfRequiredArgs];
     
    742571        throws ConditionThrowable
    743572      {
    744         final StandardGenericFunction gf;
    745         try
    746           {
    747             gf = (StandardGenericFunction) first;
    748           }
    749         catch (ClassCastException e)
    750           {
    751             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    752           }
     573        final StandardGenericFunction gf = checkStandardGenericFunction(first);
    753574        LispObject args = second;
    754575        LispObject[] array = new LispObject[gf.numberOfRequiredArgs];
     
    776597        throws ConditionThrowable
    777598      {
    778         final StandardGenericFunction gf;
    779         try
    780           {
    781             gf = (StandardGenericFunction) first;
    782           }
    783         catch (ClassCastException e)
    784           {
    785             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    786           }
     599        final StandardGenericFunction gf = checkStandardGenericFunction(first);
    787600        LispObject layout = second;
    788601        LispObject location = third;
     
    803616        throws ConditionThrowable
    804617      {
    805         final StandardGenericFunction gf;
    806         try
    807           {
    808             gf = (StandardGenericFunction) first;
    809           }
    810         catch (ClassCastException e)
    811           {
    812             return type_error(first, Symbol.STANDARD_GENERIC_FUNCTION);
    813           }
     618        final StandardGenericFunction gf = checkStandardGenericFunction(first);
    814619        LispObject layout = second;
    815620        HashMap<LispObject,LispObject> ht = gf.slotCache;
     
    862667    }
    863668  }
     669 
     670  public static final StandardGenericFunction checkStandardGenericFunction(LispObject obj)
     671  throws ConditionThrowable
     672  {
     673                if (obj instanceof StandardGenericFunction)
     674                        return (StandardGenericFunction) obj;
     675                return (StandardGenericFunction) // Not reached.
     676                type_error(obj, Symbol.STANDARD_GENERIC_FUNCTION);
     677        }
    864678}
  • trunk/abcl/src/org/armedbear/lisp/StandardMethod.java

    r11711 r11754  
    7070      public LispObject execute(LispObject arg) throws ConditionThrowable
    7171      {
    72         try
    73           {
    74             return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_LAMBDA_LIST];
    75           }
    76         catch (ClassCastException e)
    77           {
    78             return type_error(arg, Symbol.STANDARD_METHOD);
    79           }
     72          return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_LAMBDA_LIST];
    8073      }
    8174    };
     
    9083        throws ConditionThrowable
    9184      {
    92         try
    93           {
    94             ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_LAMBDA_LIST] = second;
    95             return second;
    96           }
    97         catch (ClassCastException e)
    98           {
    99             return type_error(first, Symbol.STANDARD_METHOD);
    100           }
     85          checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_LAMBDA_LIST] = second;
     86          return second;
    10187      }
    10288    };
     
    10995      public LispObject execute(LispObject arg) throws ConditionThrowable
    11096      {
    111         try
    112           {
    113             return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_QUALIFIERS];
    114           }
    115         catch (ClassCastException e)
    116           {
    117             return type_error(arg, Symbol.STANDARD_METHOD);
    118           }
     97          return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_QUALIFIERS];
    11998      }
    12099    };
     
    128107      public LispObject execute(LispObject first, LispObject second)
    129108        throws ConditionThrowable
    130       {
    131         try
    132           {
    133             ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_QUALIFIERS] = second;
    134             return second;
    135           }
    136         catch (ClassCastException e)
    137           {
    138             return type_error(first, Symbol.STANDARD_METHOD);
    139           }
     109      {         
     110          checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_QUALIFIERS] = second;
     111          return second;
    140112      }
    141113    };
     
    148120      public LispObject execute(LispObject arg) throws ConditionThrowable
    149121      {
    150         try
    151           {
    152             return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_DOCUMENTATION];
    153           }
    154         catch (ClassCastException e)
    155           {
    156             return type_error(arg, Symbol.STANDARD_METHOD);
    157           }
     122          return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_DOCUMENTATION];
    158123      }
    159124    };
     
    168133        throws ConditionThrowable
    169134      {
    170         try
    171           {
    172             ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_DOCUMENTATION] = second;
    173             return second;
    174           }
    175         catch (ClassCastException e)
    176           {
    177             return type_error(first, Symbol.STANDARD_METHOD);
    178           }
     135          checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_DOCUMENTATION] = second;
     136          return second;
    179137      }
    180138    };
     
    231189      public LispObject execute(LispObject arg) throws ConditionThrowable
    232190      {
    233         try
    234           {
    235             return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_GENERIC_FUNCTION];
    236           }
    237         catch (ClassCastException e)
    238           {
    239             return type_error(arg, Symbol.METHOD);
    240           }
     191          return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_GENERIC_FUNCTION];
    241192      }
    242193    };
     
    250201        throws ConditionThrowable
    251202      {
    252         try
    253           {
    254             ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_GENERIC_FUNCTION] = second;
    255             return second;
    256           }
    257         catch (ClassCastException e)
    258           {
    259             return type_error(first, Symbol.METHOD);
    260           }
     203          checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_GENERIC_FUNCTION] = second;
     204          return second;
    261205      }
    262206    };
     
    269213      public LispObject execute(LispObject arg) throws ConditionThrowable
    270214      {
    271         try
    272           {
    273             return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_FUNCTION];
    274           }
    275         catch (ClassCastException e)
    276           {
    277             return type_error(arg, Symbol.METHOD);
    278           }
     215          return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_FUNCTION];
    279216      }
    280217    };
     
    289226        throws ConditionThrowable
    290227      {
    291         try
    292           {
    293             ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_FUNCTION] = second;
    294             return second;
    295           }
    296         catch (ClassCastException e)
    297           {
    298             return type_error(first, Symbol.METHOD);
    299           }
     228          checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_FUNCTION] = second;
     229          return second;
    300230      }
    301231    };
     
    308238      public LispObject execute(LispObject arg) throws ConditionThrowable
    309239      {
    310         try
    311           {
    312             return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_FAST_FUNCTION];
    313           }
    314         catch (ClassCastException e)
    315           {
    316             return type_error(arg, Symbol.METHOD);
    317           }
     240          return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_FAST_FUNCTION];
    318241      }
    319242    };
     
    328251        throws ConditionThrowable
    329252      {
    330         try
    331           {
    332             ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_FAST_FUNCTION] = second;
    333             return second;
    334           }
    335         catch (ClassCastException e)
    336           {
    337             return type_error(first, Symbol.METHOD);
    338           }
     253          checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_FAST_FUNCTION] = second;
     254          return second;
    339255      }
    340256    };
     
    347263      public LispObject execute(LispObject arg) throws ConditionThrowable
    348264      {
    349         try
    350           {
    351             return ((StandardMethod)arg).slots[StandardMethodClass.SLOT_INDEX_SPECIALIZERS];
    352           }
    353         catch (ClassCastException e)
    354           {
    355             return type_error(arg, Symbol.METHOD);
    356           }
     265          return checkStandardMethod(arg).slots[StandardMethodClass.SLOT_INDEX_SPECIALIZERS];
    357266      }
    358267    };
     
    367276        throws ConditionThrowable
    368277      {
    369         try
    370           {
    371             ((StandardMethod)first).slots[StandardMethodClass.SLOT_INDEX_SPECIALIZERS] = second;
    372             return second;
    373           }
    374         catch (ClassCastException e)
    375           {
    376             return type_error(first, Symbol.METHOD);
    377           }
     278          checkStandardMethod(first).slots[StandardMethodClass.SLOT_INDEX_SPECIALIZERS] = second;
     279          return second;
    378280      }
    379281    };
     
    395297                                list(StandardClass.STANDARD_METHOD));
    396298
     299        final public static StandardMethod checkStandardMethod(LispObject first) throws ConditionThrowable
     300        {
     301                if (first instanceof StandardMethod)
     302                        return (StandardMethod) first;
     303                return (StandardMethod) type_error(first, Symbol.METHOD);
     304        }
     305
    397306}
  • trunk/abcl/src/org/armedbear/lisp/StandardObject.java

    r11714 r11754  
    273273  }
    274274
     275        final public static StandardObject checkStandardObject(LispObject first) throws ConditionThrowable
     276        {
     277                if (first instanceof StandardObject)
     278                        return (StandardObject) first;
     279                return (StandardObject) type_error(first, Symbol.STANDARD_OBJECT);
     280        }
     281       
    275282  // ### swap-slots instance-1 instance-2 => nil
    276283  private static final Primitive SWAP_SLOTS =
     
    281288        throws ConditionThrowable
    282289      {
    283         StandardObject obj1, obj2;
    284         try
    285           {
    286             obj1 = (StandardObject) first;
    287           }
    288         catch (ClassCastException e)
    289           {
    290             return type_error(first, Symbol.STANDARD_OBJECT);
    291           }
    292         try
    293           {
    294             obj2 = (StandardObject) second;
    295           }
    296         catch (ClassCastException e)
    297           {
    298             return type_error(second, Symbol.STANDARD_OBJECT);
    299           }
     290        final StandardObject obj1 = checkStandardObject(first);
     291        final StandardObject obj2 = checkStandardObject(second);
    300292        LispObject[] temp = obj1.slots;
    301293        obj1.slots = obj2.slots;
     
    312304      public LispObject execute(LispObject arg) throws ConditionThrowable
    313305      {
    314         final StandardObject instance;
    315         try
    316           {
    317               instance = (StandardObject) arg;
    318           }
    319         catch (ClassCastException e)
    320           {
    321             return type_error(arg, Symbol.STANDARD_OBJECT);
    322           }
     306        final StandardObject instance = checkStandardObject(arg);
    323307        Layout layout = instance.layout;
    324308        if (layout.isInvalid())
     
    339323        throws ConditionThrowable
    340324      {
    341         try
    342           {
    343             ((StandardObject)first).layout = (Layout) second;
    344             return second;
    345           }
    346         catch (ClassCastException e)
    347           {
    348             if (!(first instanceof StandardObject))
    349               return type_error(first, Symbol.STANDARD_OBJECT);
    350             if (!(second instanceof Layout))
    351               return type_error(second, Symbol.LAYOUT);
    352             // Not reached.
    353             return NIL;
    354           }
     325          checkStandardObject(first).layout = checkLayout(second);         
     326          return second;
    355327      }
    356328    };
     
    363335      public LispObject execute(LispObject arg) throws ConditionThrowable
    364336      {
    365         try
    366           {
    367             return ((StandardObject)arg).layout.lispClass;
    368           }
    369         catch (ClassCastException e)
    370           {
    371             return type_error(arg, Symbol.STANDARD_OBJECT);
    372           }
     337          return checkStandardObject(arg).layout.lispClass;
    373338      }
    374339    };
     
    383348        throws ConditionThrowable
    384349      {
    385         final StandardObject instance;
    386         try
    387           {
    388             instance = (StandardObject) first;
    389           }
    390         catch (ClassCastException e)
    391           {
    392             return type_error(first, Symbol.STANDARD_OBJECT);
    393           }
     350        final StandardObject instance = checkStandardObject(first);
    394351        final int index;
    395         try
     352        if (second instanceof Fixnum)
    396353          {
    397354            index = ((Fixnum)second).value;
    398355          }
    399         catch (ClassCastException e)
     356        else
    400357          {
    401358            return type_error(second,
     
    434391        throws ConditionThrowable
    435392      {
    436         try
    437           {
    438             ((StandardObject)first).slots[Fixnum.getValue(second)] = third; // FIXME
    439             return third;
    440           }
    441         catch (ClassCastException e)
    442           {
    443             return type_error(first, Symbol.STANDARD_OBJECT);
    444           }
     393          checkStandardObject(first).slots[Fixnum.getValue(second)] = third; // FIXME
     394          return third;
    445395      }
    446396    };
     
    454404        throws ConditionThrowable
    455405      {
    456         final StandardObject instance;
    457         try
    458           {
    459             instance = (StandardObject) first;
    460           }
    461         catch (ClassCastException e)
    462           {
    463             return type_error(first, Symbol.STANDARD_OBJECT);
    464           }
     406        final StandardObject instance = checkStandardObject(first);
    465407        Layout layout = instance.layout;
    466408        if (layout.isInvalid())
  • trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java

    r11488 r11754  
    4545        if (arg == StandardClass.STANDARD_CLASS)
    4646          return new StandardClass();
    47         final StandardClass c;
    48         try
    49           {
    50             c = (StandardClass) arg;
    51           }
    52         catch (ClassCastException e)
    53           {
    54             return type_error(arg, Symbol.STANDARD_CLASS);
    55           }
    56         return c.allocateInstance();
     47        if (arg instanceof StandardClass)
     48                return ((StandardClass)arg).allocateInstance();
     49        return type_error(arg, Symbol.STANDARD_CLASS);
    5750      }
    5851    };
  • trunk/abcl/src/org/armedbear/lisp/StandardReaderMethod.java

    r11488 r11754  
    4949      public LispObject execute(LispObject arg) throws ConditionThrowable
    5050      {
    51           try
    52           {
     51          if (arg instanceof StandardReaderMethod)
    5352              return ((StandardReaderMethod)arg).slots[StandardReaderMethodClass.SLOT_INDEX_SLOT_NAME];
    54           }
    55           catch (ClassCastException e)
    56           {
    57               return type_error(arg, Symbol.STANDARD_READER_METHOD);
    58           }
     53          return type_error(arg, Symbol.STANDARD_READER_METHOD);
    5954      }
    6055  };
     
    6964          throws ConditionThrowable
    7065      {
    71           try
     66          if (first instanceof StandardReaderMethod)
    7267          {
    7368              ((StandardReaderMethod)first).slots[StandardReaderMethodClass.SLOT_INDEX_SLOT_NAME] = second;
    7469              return second;
    7570          }
    76           catch (ClassCastException e)
    77           {
    7871              return type_error(first, Symbol.STANDARD_READER_METHOD);
    79           }
    8072      }
    8173  };
  • trunk/abcl/src/org/armedbear/lisp/Stream.java

    r11748 r11754  
    145145        isBinaryStream = true;
    146146        InputStream stream = new BufferedInputStream(inputStream);
    147   initAsBinaryInputStream(stream);
     147        initAsBinaryInputStream(stream);
    148148      }
    149149  }
     
    167167    if (elementType == Symbol.CHARACTER || elementType == Symbol.BASE_CHAR)
    168168      {
    169   Writer w =
     169        Writer w =
    170170            (encoding == null) ?
    171171                new OutputStreamWriter(outputStream)
    172172                : new OutputStreamWriter(outputStream,
    173173                    Charset.forName(encoding).newEncoder());
    174   initAsCharacterOutputStream(w);
     174        initAsCharacterOutputStream(w);
    175175      }
    176176    else
    177177      {
    178178        OutputStream stream = new BufferedOutputStream(outputStream);
    179   initAsBinaryOutputStream(stream);
     179        initAsBinaryOutputStream(stream);
    180180      }
    181181  }
     
    12811281  {
    12821282    final int readBase;
    1283     try
    1284       {
    1285         readBase = ((Fixnum)Symbol.READ_BASE.symbolValue(thread)).value;
    1286       }
    1287     catch (ClassCastException e)
    1288       {
     1283    final LispObject readBaseObject = Symbol.READ_BASE.symbolValue(thread);
     1284    if (readBaseObject instanceof Fixnum) {
     1285        readBase = ((Fixnum)readBaseObject).value;
     1286    } else {
    12891287        // The value of *READ-BASE* is not a Fixnum.
    12901288        error(new LispError("The value of *READ-BASE* is not of type '(INTEGER 2 36)."));
    12911289        // Not reached.
    1292         return 10;
    1293       }
     1290        return 10;     
     1291    }
    12941292    if (readBase < 2 || readBase > 36)
    12951293      {
     
    18921890      {
    18931891        if (c == '\n') {
    1894     if (eolStyle == EolStyle.CRLF && lastChar != '\r')
     1892          if (eolStyle == EolStyle.CRLF && lastChar != '\r')
    18951893              writer.write('\r');
    18961894
     
    19481946                index = i;
    19491947                break;
    1950     }
    1951   }
     1948          }
     1949        }
    19521950        if (index < 0)
    19531951          {
    19541952            // No newline.
    19551953            charPos += (end - start);
    1956         }
     1954              }
    19571955        else
    19581956          {
    19591957            charPos = end - (index + 1);
    19601958              writer.flush();
    1961       }
    1962     }
     1959            }
     1960          }
    19631961    catch (NullPointerException e)
    19641962      {
     
    19841982    try
    19851983      {
    1986   _writeChars(s.toCharArray(), 0, s.length());
     1984        _writeChars(s.toCharArray(), 0, s.length());
    19871985      }
    19881986    catch (NullPointerException e)
     
    22132211        throws ConditionThrowable
    22142212      {
    2215         try
    2216           {
    2217             ((Stream)second)._writeChar(((LispCharacter)first).value);
    2218           }
    2219         catch (ClassCastException e)
    2220           {
    2221             if (second instanceof Stream)
    2222               return type_error(first, Symbol.CHARACTER);
    2223             else
    2224               return type_error(second, Symbol.STREAM);
    2225           }
    2226         return first;
     2213          checkStream(second)._writeChar(LispCharacter.getValue(first));       
     2214          return first;
    22272215      }
    22282216    };
     
    22372225        throws ConditionThrowable
    22382226      {
    2239         final char c;
    2240         try
    2241           {
    2242             c = ((LispCharacter)first).value;
    2243           }
    2244         catch (ClassCastException e)
    2245           {
    2246             return type_error(first, Symbol.CHARACTER);
    2247           }
     2227        final char c = LispCharacter.getValue(first);
    22482228        if (second == T)
    22492229          second = Symbol.TERMINAL_IO.symbolValue();
    22502230        else if (second == NIL)
    22512231          second = Symbol.STANDARD_OUTPUT.symbolValue();
    2252         final Stream stream;
    2253         try
    2254           {
    2255             stream = (Stream) second;
    2256           }
    2257         catch (ClassCastException e)
    2258           {
    2259             return type_error(second, Symbol.STREAM);
    2260           }
     2232        final Stream stream = checkStream(second);
    22612233        stream._writeChar(c);
    22622234        return first;
     
    22742246        throws ConditionThrowable
    22752247      {
    2276         final AbstractString s;
    2277         try
    2278           {
    2279             s = (AbstractString) first;
    2280           }
    2281         catch (ClassCastException e)
    2282           {
    2283             return type_error(first, Symbol.STRING);
    2284           }
     2248        final AbstractString s = checkString(first);
    22852249        char[] chars = s.chars();
    2286         final Stream out;
    2287         try
    2288           {
    2289             if (second == T)
    2290               out = (Stream) Symbol.TERMINAL_IO.symbolValue();
    2291             else if (second == NIL)
    2292               out = (Stream) Symbol.STANDARD_OUTPUT.symbolValue();
    2293             else
    2294               out = (Stream) second;
    2295           }
    2296         catch (ClassCastException e)
    2297           {
    2298             return type_error(second, Symbol.STREAM);
    2299           }
    2300         final int start;
    2301         try
    2302           {
    2303             start = ((Fixnum)third).value;
    2304           }
    2305         catch (ClassCastException e)
    2306           {
    2307             return type_error(third, Symbol.FIXNUM);
    2308           }
     2250        final Stream out = outSynonymOf(second);
     2251        final int start = Fixnum.getValue(third);
    23092252        final int end;
    23102253        if (fourth == NIL)
     
    23122255        else
    23132256          {
    2314             try
    2315               {
    2316                 end = ((Fixnum)fourth).value;
    2317               }
    2318             catch (ClassCastException e)
    2319               {
    2320                 return type_error(fourth, Symbol.FIXNUM);
    2321               }
     2257                end = Fixnum.getValue(fourth);
    23222258          }
    23232259        checkBounds(start, end, chars.length);
     
    23522288    throws ConditionThrowable
    23532289  {
    2354     final Stream out;
    2355     try
    2356       {
     2290    final LispObject out;
    23572291        if (arg == T)
    2358           out = (Stream) Symbol.TERMINAL_IO.symbolValue();
     2292          out = Symbol.TERMINAL_IO.symbolValue();
    23592293        else if (arg == NIL)
    2360           out = (Stream) Symbol.STANDARD_OUTPUT.symbolValue();
     2294          out = Symbol.STANDARD_OUTPUT.symbolValue();
    23612295        else
    2362           out = (Stream) arg;
    2363       }
    2364     catch (ClassCastException e)
    2365       {
    2366         return type_error(arg, Symbol.STREAM);
    2367       }
    2368     return out.finishOutput();
     2296          out = arg;
     2297    return checkStream(out).finishOutput();
    23692298  }
    23702299
     
    24142343      public LispObject execute(LispObject arg) throws ConditionThrowable
    24152344      {
    2416         try
    2417           {
    2418             return ((Stream)arg).close(NIL);
    2419           }
    2420         catch (ClassCastException e)
    2421           {
    2422             return type_error(arg, Symbol.STREAM);
    2423           }
     2345          return checkStream(arg).close(NIL);
    24242346      }
    24252347
     
    24292351        throws ConditionThrowable
    24302352      {
    2431         final Stream stream;
    2432         try
    2433           {
    2434             stream = (Stream) first;
    2435           }
    2436         catch (ClassCastException e)
    2437           {
    2438             return type_error(first, Symbol.STREAM);
    2439           }
    2440         if (second == Keyword.ABORT)
    2441           return stream.close(third);
    2442         return error(new ProgramError("Unrecognized keyword argument " +
    2443                                        second.writeToString() + "."));
     2353          final Stream stream = checkStream(first);
     2354          if (second == Keyword.ABORT)         
     2355                  return stream.close(third);       
     2356          return error(new ProgramError("Unrecognized keyword argument " +                                     
     2357                          second.writeToString() + "."));
    24442358      }
    24452359    };
     
    24712385        throws ConditionThrowable
    24722386      {
    2473         int n;
    2474         try
    2475           {
    2476             n = ((Fixnum)first).value;
    2477           }
    2478         catch (ClassCastException e)
    2479           {
    2480             return type_error(first, Symbol.FIXNUM);
    2481           }
     2387        int n = Fixnum.getValue(first);
    24822388        if (n < 0 || n > 255)
    24832389    &nb