Changeset 10196


Ignore:
Timestamp:
10/23/05 14:28:26 (16 years ago)
Author:
piso
Message:

Symbol refactoring (work in progress).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r10195 r10196  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Primitives.java,v 1.838 2005-10-23 14:12:30 piso Exp $
     5 * $Id: Primitives.java,v 1.839 2005-10-23 14:28:26 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    20192019            if (args.length < 1)
    20202020                signal(new WrongNumberOfArgumentsException(this));
    2021 //             AbstractArray array = checkArray(args[0]);
    20222021            final AbstractArray array;
    20232022            try {
     
    20522051    };
    20532052
    2054     // ### %array-row-major-index
    2055     // %array-row-major-index array subscripts => index
     2053    // ### %array-row-major-index array subscripts => index
    20562054    private static final Primitive _ARRAY_ROW_MAJOR_INDEX =
    20572055        new Primitive("%array-row-major-index", PACKAGE_SYS, false)
     
    20602058            throws ConditionThrowable
    20612059        {
    2062             AbstractArray array = checkArray(first);
     2060            final AbstractArray array;
     2061            try {
     2062                array = (AbstractArray) first;
     2063            }
     2064            catch (ClassCastException e) {
     2065                return signalTypeError(first, Symbol.ARRAY);
     2066            }
    20632067            LispObject[] subscripts = second.copyToArray();
    20642068            return number(array.getRowMajorIndex(subscripts));
     
    20662070    };
    20672071
    2068     // ### aref
    2069     // aref array &rest subscripts => element
     2072    // ### aref array &rest subscripts => element
    20702073    private static final Primitive AREF =
    2071         new Primitive("aref", "array &rest subscripts")
     2074        new Primitive(Symbol.AREF, "array &rest subscripts")
    20722075    {
    20732076        public LispObject execute() throws ConditionThrowable
     
    20752078            return signal(new WrongNumberOfArgumentsException(this));
    20762079        }
    2077 
    2078         public LispObject execute(LispObject arg) throws ConditionThrowable
    2079         {
    2080             AbstractArray array = checkArray(arg);
     2080        public LispObject execute(LispObject arg) throws ConditionThrowable
     2081        {
     2082            final AbstractArray array;
     2083            try {
     2084                array = (AbstractArray) arg;
     2085            }
     2086            catch (ClassCastException e) {
     2087                return signalTypeError(arg, Symbol.ARRAY);
     2088            }
    20812089            if (array.getRank() == 0)
    20822090                return array.AREF(0);
     
    20852093            sb.append(array.getRank());
    20862094            sb.append('.');
    2087             signal(new ProgramError(sb.toString()));
    2088             return NIL;
    2089         }
    2090 
     2095            return signal(new ProgramError(sb.toString()));
     2096        }
    20912097        public LispObject execute(LispObject first, LispObject second)
    20922098            throws ConditionThrowable
     
    20942100            return first.AREF(second);
    20952101        }
    2096 
    20972102        public LispObject execute(LispObject first, LispObject second,
    20982103                                  LispObject third)
     
    21012106            final AbstractArray array;
    21022107            try {
    2103                 array = checkArray(first);
    2104             }
    2105             catch (ClassCastException e) {
    2106                 return signal(new TypeError(first, Symbol.ARRAY));
     2108                array = (AbstractArray) first;
     2109            }
     2110            catch (ClassCastException e) {
     2111                return signalTypeError(first, Symbol.ARRAY);
    21072112            }
    21082113            final int[] subs = new int[2];
     
    21112116            }
    21122117            catch (ClassCastException e) {
    2113                 return signal(new TypeError(second, Symbol.FIXNUM));
     2118                return signalTypeError(second, Symbol.FIXNUM);
    21142119            }
    21152120            try {
     
    21172122            }
    21182123            catch (ClassCastException e) {
    2119                 return signal(new TypeError(third, Symbol.FIXNUM));
     2124                return signalTypeError(third, Symbol.FIXNUM);
    21202125            }
    21212126            return array.get(subs);
    21222127        }
    2123 
    21242128        public LispObject execute(LispObject[] args) throws ConditionThrowable
    21252129        {
    21262130            final AbstractArray array;
    21272131            try {
    2128                 array = checkArray(args[0]);
    2129             }
    2130             catch (ClassCastException e) {
    2131                 return signal(new TypeError(args[0], Symbol.ARRAY));
     2132                array = (AbstractArray) args[0];
     2133            }
     2134            catch (ClassCastException e) {
     2135                return signalTypeError(args[0], Symbol.ARRAY);
    21322136            }
    21332137            final int[] subs = new int[args.length - 1];
     
    21372141                }
    21382142                catch (ClassCastException e) {
    2139                     return signal(new TypeError(args[i+i], Symbol.FIXNUM));
     2143                    return signalTypeError(args[i+i], Symbol.FIXNUM);
    21402144                }
    21412145            }
     
    21972201    };
    21982202
    2199     // ### row-major-aref
    2200     // row-major-aref array index => element
     2203    // ### row-major-aref array index => element
    22012204    private static final Primitive ROW_MAJOR_AREF =
    2202         new Primitive("row-major-aref", "array index")
     2205        new Primitive(Symbol.ROW_MAJOR_AREF, "array index")
    22032206    {
    22042207        public LispObject execute(LispObject first, LispObject second)
     
    22102213            catch (ClassCastException e) {
    22112214                if (first instanceof AbstractArray)
    2212                     return signal(new TypeError(second, Symbol.FIXNUM));
     2215                    return signalTypeError(second, Symbol.FIXNUM);
    22132216                else
    2214                     return signal(new TypeError(first, Symbol.ARRAY));
     2217                    return signalTypeError(first, Symbol.ARRAY);
    22152218            }
    22162219        }
     
    22192222    // ### vector
    22202223    private static final Primitive VECTOR =
    2221         new Primitive("vector", "&rest objects")
     2224        new Primitive(Symbol.VECTOR, "&rest objects")
    22222225    {
    22232226        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    22292232    // ### fill-pointer
    22302233    private static final Primitive FILL_POINTER =
    2231         new Primitive("fill-pointer", "vector")
     2234        new Primitive(Symbol.FILL_POINTER, "vector")
    22322235    {
    22332236        public LispObject execute(LispObject arg)
     
    22382241            }
    22392242            catch (ClassCastException e) {
    2240                 return signal(new TypeError(arg, list3(Symbol.AND, Symbol.VECTOR,
    2241                                                        list2(Symbol.SATISFIES,
    2242                                                              Symbol.ARRAY_HAS_FILL_POINTER_P))));
     2243                return signalTypeError(arg, list3(Symbol.AND, Symbol.VECTOR,
     2244                                                  list2(Symbol.SATISFIES,
     2245                                                        Symbol.ARRAY_HAS_FILL_POINTER_P)));
    22432246            }
    22442247        }
     
    22612264            }
    22622265            catch (ClassCastException e) {
    2263                 return signal(new TypeError(first, list3(Symbol.AND, Symbol.VECTOR,
    2264                                                          list2(Symbol.SATISFIES,
    2265                                                                Symbol.ARRAY_HAS_FILL_POINTER_P))));
     2266                return signalTypeError(first, list3(Symbol.AND, Symbol.VECTOR,
     2267                                                    list2(Symbol.SATISFIES,
     2268                                                          Symbol.ARRAY_HAS_FILL_POINTER_P)));
    22662269            }
    22672270        }
     
    22702273    // ### vector-push new-element vector => index-of-new-element
    22712274    private static final Primitive VECTOR_PUSH =
    2272         new Primitive("vector-push","new-element vector")
    2273     {
    2274         public LispObject execute(LispObject first, LispObject second)
    2275             throws ConditionThrowable
    2276         {
    2277             AbstractVector v = checkVector(second);
     2275        new Primitive(Symbol.VECTOR_PUSH, "new-element vector")
     2276    {
     2277        public LispObject execute(LispObject first, LispObject second)
     2278            throws ConditionThrowable
     2279        {
     2280            final AbstractVector v;
     2281            try {
     2282                v = (AbstractVector) second;
     2283            }
     2284            catch (ClassCastException e) {
     2285                return signalTypeError(second, Symbol.VECTOR);
     2286            }
    22782287            int fillPointer = v.getFillPointer();
    22792288            if (fillPointer < 0)
     
    22902299    // => index-of-new-element
    22912300    private static final Primitive VECTOR_PUSH_EXTEND =
    2292         new Primitive("vector-push-extend",
     2301        new Primitive(Symbol.VECTOR_PUSH_EXTEND,
    22932302                      "new-element vector &optional extension")
    22942303    {
     
    23002309            }
    23012310            catch (ClassCastException e) {
    2302                 return signal(new TypeError(second, Symbol.VECTOR));
     2311                return signalTypeError(second, Symbol.VECTOR);
    23032312            }
    23042313        }
     
    23122321            }
    23132322            catch (ClassCastException e) {
    2314                 return signal(new TypeError(second, Symbol.VECTOR));
     2323                return signalTypeError(second, Symbol.VECTOR);
    23152324            }
    23162325        }
     
    23192328    // ### vector-pop vector => element
    23202329    private static final Primitive VECTOR_POP =
    2321         new Primitive("vector-pop", "vector")
    2322     {
    2323         public LispObject execute(LispObject arg) throws ConditionThrowable
    2324         {
    2325             AbstractVector v = checkVector(arg);
     2330        new Primitive(Symbol.VECTOR_POP, "vector")
     2331    {
     2332        public LispObject execute(LispObject arg) throws ConditionThrowable
     2333        {
     2334            final AbstractVector v;
     2335            try {
     2336                v = (AbstractVector) arg;
     2337            }
     2338            catch (ClassCastException e) {
     2339                return signalTypeError(arg, Symbol.VECTOR);
     2340            }
    23262341            int fillPointer = v.getFillPointer();
    23272342            if (fillPointer < 0)
Note: See TracChangeset for help on using the changeset viewer.