Changeset 14465


Ignore:
Timestamp:
04/24/13 12:50:37 (9 years ago)
Author:
rschlatte
Message:

new method program_error, analogous to type_error

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

Legend:

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

    r13443 r14465  
    148148            final String errorMsg =
    149149                "Wrong number of subscripts (%d) for array of rank %d.";
    150             error(new ProgramError(String.format(errorMsg, subscripts.length, rank)));
     150            program_error(String.format(errorMsg, subscripts.length, rank));
    151151        }
    152152        int sum = 0;
     
    161161                final String errorMsg =
    162162                    "Invalid index %d for array %s.";
    163                 error(new ProgramError(String.format(errorMsg, n, printObject())));
     163                program_error(String.format(errorMsg, n, printObject()));
    164164            }
    165165            sum += n * lastSize;
  • trunk/abcl/src/org/armedbear/lisp/ArgumentListProcessor.java

    r14131 r14465  
    189189        if (remaining.car() == Symbol.AND_WHOLE) {
    190190            if (type == LambdaListType.ORDINARY) {
    191                 error(new ProgramError("&WHOLE not allowed in ordinary lambda lists."));
     191              program_error("&WHOLE not allowed in ordinary lambda lists.");
    192192            } else {
    193193                // skip the &WHOLE <var> part of the lambda list
     
    204204                if (obj == Symbol.AND_WHOLE) {
    205205                    if (type == LambdaListType.ORDINARY)
    206                       error(new ProgramError("&WHOLE not allowed in ordinary lambda lists."));
     206                      program_error("&WHOLE not allowed in ordinary lambda lists.");
    207207                    else
    208                       error(new ProgramError("&WHOLE must appear first in macro lambda list."));
     208                      program_error("&WHOLE must appear first in macro lambda list.");
    209209                }
    210210                if (state == STATE_AUX)
     
    224224                    if (_andKey)
    225225                      {
    226                         error(new ProgramError(
    227                           "&REST/&BODY must precede &KEY."));
     226                        program_error("&REST/&BODY must precede &KEY.");
    228227                      }
    229228                    if (type == LambdaListType.ORDINARY && obj == Symbol.AND_BODY)
    230                       error(new ProgramError("&BODY not allowed in ordinary lambda lists."));
     229                      program_error("&BODY not allowed in ordinary lambda lists.");
    231230                    state = STATE_REST;
    232231                    arity = -1;
     
    235234                    if (remaining == NIL)
    236235                      {
    237                         error(new ProgramError(
    238                           "&REST/&BODY must be followed by a variable."));
     236                        program_error("&REST/&BODY must be followed by a variable.");
    239237                      }
    240238                    if (restVar != null)
    241239                      {
    242                         error(new ProgramError(
    243                           "&REST/&BODY may occur only once."));
     240                        program_error("&REST/&BODY may occur only once.");
    244241                      }
    245242                    final LispObject remainingcar =  remaining.car();
     
    251248                    else
    252249                      {
    253                         error(new ProgramError(
    254                           "&REST/&BODY must be followed by a variable."));
     250                        program_error("&REST/&BODY must be followed by a variable.");
    255251                      }
    256252                  }
     
    258254                  {
    259255                    if (type == LambdaListType.ORDINARY)
    260                       error(new ProgramError("&ENVIRONMENT not allowed in ordinary lambda lists."));
     256                      program_error("&ENVIRONMENT not allowed in ordinary lambda lists.");
    261257                    remaining = remaining.cdr();
    262258                    envVar = (Symbol) remaining.car();
     
    305301                        if (state != STATE_REQUIRED)
    306302                          {
    307                             error(new ProgramError(
    308                               "required parameters cannot appear after &REST/&BODY."));
     303                            program_error("required parameters cannot appear after &REST/&BODY.");
    309304                          }
    310305                        if (required == null)
     
    546541 
    547542  private static void invalidParameter(LispObject obj) {
    548     error(new ProgramError(obj.princToString() +
    549                          " may not be used as a variable in a lambda list."));
     543    program_error(obj.princToString()
     544                  + " may not be used as a variable in a lambda list.");
    550545  }
    551546
     
    619614                              continue next_key;
    620615
    621                       error(new ProgramError("Unrecognized keyword argument " +
    622                                               key.printObject()));
     616                      program_error("Unrecognized keyword argument "
     617                                    + key.printObject() + ".");
    623618                  }
    624619              }
     
    703698               
    704699                if (key != Keyword.ALLOW_OTHER_KEYS)
    705                     error(new ProgramError("Invalid keyword argument " + key.printObject()));
    706                
     700                    program_error("Invalid keyword argument "
     701                                  + key.printObject() + ".");
    707702                allowOtherKeysValue = null;
    708703            }
     
    757752      void assertRemainderKeywords() {
    758753          if (((len - argsConsumed) & 1) == 1)
    759               error(new ProgramError("Odd number of keyword arguments."));
     754              program_error("Odd number of keyword arguments.");
    760755      }
    761756     
  • trunk/abcl/src/org/armedbear/lisp/Closure.java

    r14131 r14465  
    8787    setLambdaList(lambdaList);
    8888    if (!(lambdaList == NIL || lambdaList instanceof Cons))
    89       error(new ProgramError("The lambda list " + lambdaList.princToString() +
    90                            " is invalid."));
     89      program_error("The lambda list " + lambdaList.princToString()
     90                    + " is invalid.");
    9191    this.body = lambdaExpression.cddr();
    9292    LispObject bodyAndDecls = parseBody(this.body, false);
  • trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java

    r13440 r14465  
    4949        {
    5050            if (args.length % 2 != 0)
    51                 error(new ProgramError("Odd number of keyword arguments."));
     51                program_error("Odd number of keyword arguments.");
    5252            for (int i = 0; i < args.length; i += 2) {
    5353                LispObject key = checkSymbol(args[i]);
  • trunk/abcl/src/org/armedbear/lisp/FuncallableStandardObject.java

    r14462 r14465  
    198198        LispObject l = Symbol.CLASS_LAYOUT.execute(arg);
    199199        if (! (l instanceof Layout)) {
    200           return error(new ProgramError("Invalid standard class layout for: " + arg.princToString()));
     200          return program_error("Invalid standard class layout for: "
     201                               + arg.princToString() + ".");
    201202        }
    202203        if (Symbol.SUBTYPEP.execute(arg, StandardClass.STANDARD_GENERIC_FUNCTION) != NIL) {
  • trunk/abcl/src/org/armedbear/lisp/Java.java

    r14326 r14465  
    806806            }
    807807            if(instance == null) {
    808                 return error(new ProgramError("JRESOLVE-METHOD: instance must not be null"));
     808                return program_error("JRESOLVE-METHOD: instance must not be null.");
    809809            }
    810810            String methodName = methodArg.getStringValue();
  • trunk/abcl/src/org/armedbear/lisp/Lisp.java

    r14448 r14465  
    419419  public static final LispObject type_error(LispObject datum,
    420420                                            LispObject expectedType)
    421 
    422421  {
    423422    return error(new TypeError(datum, expectedType));
     423  }
     424
     425  public static final LispObject program_error(String message)
     426  {
     427    return error(new ProgramError(message));
     428  }
     429
     430  public static final LispObject program_error(LispObject initArgs)
     431  {
     432    return error(new ProgramError(initArgs));
    424433  }
    425434
     
    527536              }
    528537            else
    529               return error(new ProgramError("Illegal function object: " +
    530                                              first.princToString()));
     538              return program_error("Illegal function object: "
     539                                   + first.princToString() + ".");
    531540          }
    532541      }
  • trunk/abcl/src/org/armedbear/lisp/LispThread.java

    r14406 r14465  
    916916            if (length > 1) {
    917917                if ((length - 1) % 2 != 0)
    918                     error(new ProgramError("Odd number of keyword arguments."));
     918                    program_error("Odd number of keyword arguments.");
    919919                if (length > 3)
    920920                    error(new WrongNumberOfArgumentsException(this, -1, 2)); // don't count the keyword itself as an argument
     
    922922                    name = args[2].STRING();
    923923                else
    924                     error(new ProgramError("Unrecognized keyword argument " +
    925                                             args[1].princToString() + "."));
     924                    program_error("Unrecognized keyword argument "
     925                                  + args[1].princToString() + ".");
    926926            }
    927927            return new LispThread(checkFunction(args[0]), name);
  • trunk/abcl/src/org/armedbear/lisp/Pathname.java

    r14238 r14465  
    13071307    static final Pathname _makePathname(LispObject[] args) {
    13081308        if (args.length % 2 != 0) {
    1309             error(new ProgramError("Odd number of keyword arguments."));
     1309            program_error("Odd number of keyword arguments.");
    13101310        }
    13111311        LispObject host = NIL;
     
    19091909                value = pathname.version;
    19101910            } else {
    1911                 return error(new ProgramError("Unrecognized keyword "
    1912                                               + second.princToString() + "."));
     1911                return program_error("Unrecognized keyword "
     1912                                     + second.princToString() + ".");
    19131913            }
    19141914            if (value == Keyword.WILD || value == Keyword.WILD_INFERIORS) {
  • trunk/abcl/src/org/armedbear/lisp/Primitives.java

    r14452 r14465  
    17811781                Symbol symbol = (Symbol) name;
    17821782                if (symbol.getSymbolFunction() instanceof SpecialOperator) {
    1783                     String message =
    1784                         symbol.getName() + " is a special operator and may not be redefined.";
    1785                     return error(new ProgramError(message));
     1783                    return program_error(symbol.getName() + " is a special operator and may not be redefined.");
    17861784                }
    17871785            } else if (!isValidSetfFunctionName(name))
     
    23112309                sb.append(") for array of rank ");
    23122310                sb.append(rank);
    2313                 error(new ProgramError(sb.toString()));
     2311                sb.append(".");
     2312                program_error(sb.toString());
    23142313            }
    23152314            for (int i = 0; i < rank; i++) {
     
    23672366            sb.append(array.getRank());
    23682367            sb.append('.');
    2369             return error(new ProgramError(sb.toString()));
     2368            return program_error(sb.toString());
    23702369        }
    23712370        @Override
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java

    r13443 r14465  
    259259        sb.append(rank);
    260260        sb.append('.');
    261         error(new ProgramError(sb.toString()));
     261        program_error(sb.toString());
    262262      }
    263263    int sum = 0;
     
    276276            sb.append(this);
    277277            sb.append('.');
    278             error(new ProgramError(sb.toString()));
     278            program_error(sb.toString());
    279279          }
    280280        sum += n * lastSize;
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java

    r13443 r14465  
    236236            sb.append(rank);
    237237            sb.append('.');
    238             error(new ProgramError(sb.toString()));
     238            program_error(sb.toString());
    239239        }
    240240        int sum = 0;
     
    251251                sb.append(this);
    252252                sb.append('.');
    253                 error(new ProgramError(sb.toString()));
     253                program_error(sb.toString());
    254254            }
    255255            sum += n * lastSize;
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java

    r13443 r14465  
    227227            sb.append(rank);
    228228            sb.append('.');
    229             error(new ProgramError(sb.toString()));
     229            program_error(sb.toString());
    230230        }
    231231        int sum = 0;
     
    242242                sb.append(this);
    243243                sb.append('.');
    244                 error(new ProgramError(sb.toString()));
     244                program_error(sb.toString());
    245245            }
    246246            sum += n * lastSize;
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java

    r13443 r14465  
    223223            sb.append(rank);
    224224            sb.append('.');
    225             error(new ProgramError(sb.toString()));
     225            program_error(sb.toString());
    226226        }
    227227        int sum = 0;
     
    238238                sb.append(this);
    239239                sb.append('.');
    240                 error(new ProgramError(sb.toString()));
     240                program_error(sb.toString());
    241241            }
    242242            sum += n * lastSize;
  • trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java

    r14448 r14465  
    200200                        if (symbol.isSpecialVariable()
    201201                                || ext.isDeclaredSpecial(symbol)) {
    202                             return error(new ProgramError(
    203                                              "Attempt to bind the special variable " +
    204                                              symbol.princToString() +
    205                                              " with SYMBOL-MACROLET."));
     202                            return program_error("Attempt to bind the special variable "
     203                                                 + symbol.princToString()
     204                                                 + " with SYMBOL-MACROLET.");
    206205                        }
    207206                        ext.bind(symbol, new SymbolMacro(obj.cadr()));
    208207                    } else {
    209                         return error(new ProgramError(
    210                                          "Malformed symbol-expansion pair in SYMBOL-MACROLET: " +
    211                                          obj.princToString()));
     208                        return program_error("Malformed symbol-expansion pair in SYMBOL-MACROLET: "
     209                                             + obj.princToString() + ".");
    212210                    }
    213211                }
     
    323321                symbol = checkSymbol(name);
    324322                if (symbol.getSymbolFunction() instanceof SpecialOperator) {
    325                     String message =
    326                         symbol.getName() + " is a special operator and may not be redefined";
    327                     return error(new ProgramError(message));
     323                  return program_error(symbol.getName()
     324                                       + " is a special operator and may not be redefined.");
    328325                }
    329326            } else if (isValidSetfFunctionName(name))
     
    522519                Symbol symbol = checkSymbol(args.car());
    523520                if (symbol.isConstant()) {
    524                     return error(new ProgramError(symbol.princToString() +
    525                                                   " is a constant and thus cannot be set."));
     521                    return program_error(symbol.princToString()
     522                                         + " is a constant and thus cannot be set.");
    526523                }
    527524                args = args.cdr();
  • trunk/abcl/src/org/armedbear/lisp/StandardObject.java

    r14464 r14465  
    449449                                 Fixnum.getInstance(instance.slots.length - 1)));
    450450        else
    451           return error(new ProgramError("The object "
    452                                         + instance.princToString() +
    453                                         " has no slots."));
     451          return program_error("The object " + instance.princToString()
     452                               + " has no slots.");
    454453
    455454      }
     
    496495                                 Fixnum.getInstance(instance.slots.length - 1)));
    497496        else
    498           return error(new ProgramError("The object "
    499                                         + instance.princToString() +
    500                                         " has no slots."));
    501 
     497          return program_error("The object " + instance.princToString()
     498                               + " has no slots.");
    502499      }
    503500      return third;
     
    665662        Layout layout = cls.getClassLayout();
    666663        if (layout == null) {
    667           error(new ProgramError("No layout for funcallable class "
    668                                  + cls.princToString()));
     664          program_error("No layout for funcallable class " + cls.princToString() + ".");
    669665        }
    670666        return new FuncallableStandardObject(cls, layout.getLength());
     
    673669        Layout layout = cls.getClassLayout();
    674670        if (layout == null) {
    675           error(new ProgramError("No layout for class " + cls.princToString()));
     671          program_error("No layout for class " + cls.princToString() + ".");
    676672        }
    677673        return new StandardObject(cls, layout.getLength());
     
    679675        LispObject l = Symbol.CLASS_LAYOUT.execute(arg);
    680676        if (! (l instanceof Layout)) {
    681           error(new ProgramError("Invalid standard class layout for class " + arg.princToString()));
     677          program_error("Invalid standard class layout for class "
     678                        + arg.princToString() + ".");
    682679        }
    683680        return new StandardObject((Layout)l);
  • trunk/abcl/src/org/armedbear/lisp/Stream.java

    r14405 r14465  
    22342234            if (second == Keyword.ABORT)
    22352235                return stream.close(third);
    2236             return error(new ProgramError("Unrecognized keyword argument " +
    2237                                           second.princToString() + "."));
     2236            return program_error("Unrecognized keyword argument "
     2237                                 + second.princToString() + ".");
    22382238        }
    22392239    };
  • trunk/abcl/src/org/armedbear/lisp/Symbol.java

    r14431 r14465  
    296296    if (isConstant())
    297297      // Complement the check already done in SpecialOperators.sf_setq
    298       error(new ProgramError("Can't change value of constant symbol " + princToString() + "."));
     298      program_error("Can't change value of constant symbol "
     299                    + princToString() + ".");
    299300    this.value = value;
    300301  }
     
    312313    public void setSymbolMacro(SymbolMacro symbolMacro) {
    313314        if(isSpecialVariable()) {
    314             error(new ProgramError("Symbol " + princToString() + " names a special variable; can't install symbol macro."));
     315            program_error("Symbol " + princToString() + " names a special variable; can't install symbol macro.");
    315316        }
    316317        put(this, SYMBOL_MACRO, symbolMacro);
Note: See TracChangeset for help on using the changeset viewer.