Changeset 10198


Ignore:
Timestamp:
10/23/05 15:51:45 (16 years ago)
Author:
piso
Message:

Symbol refactoring (work in progress, tested).

File:
1 edited

Legend:

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

    r10197 r10198  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Primitives.java,v 1.840 2005-10-23 14:53:27 piso Exp $
     5 * $Id: Primitives.java,v 1.841 2005-10-23 15:51:45 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    139139            LispObject result = args[0];
    140140            if (!result.realp())
    141                 signal(new TypeError(result, Symbol.REAL));
     141                signalTypeError(result, Symbol.REAL);
    142142            for (int i = 1; i < args.length; i++) {
    143143                if (args[i].isGreaterThan(result))
     
    17071707                symbol.setDocumentation(Symbol.VARIABLE, third);
    17081708            else if (third != NIL)
    1709                 signal(new TypeError(third, Symbol.STRING));
     1709                signalTypeError(third, Symbol.STRING);
    17101710            symbol.setSymbolValue(second);
    17111711            symbol.setSpecial(true);
     
    17471747                    symbol.setDocumentation(Symbol.VARIABLE, third);
    17481748                else
    1749                     signal(new TypeError(third, Symbol.STRING));
     1749                    signalTypeError(third, Symbol.STRING);
    17501750            }
    17511751            symbol.setSymbolValue(second);
     
    21832183            }
    21842184            catch (ClassCastException e) {
    2185                 return signal(new TypeError(args[0], Symbol.ARRAY));
     2185                return signalTypeError(args[0], Symbol.ARRAY);
    21862186            }
    21872187            final int nsubs = args.length - 2;
     
    21922192                }
    21932193                catch (ClassCastException e) {
    2194                     signal(new TypeError(args[i+1], Symbol.FIXNUM));
     2194                    signalTypeError(args[i+1], Symbol.FIXNUM);
    21952195                }
    21962196            }
     
    31313131                put(symbol, Symbol.SETF_FUNCTION, second);
    31323132            } else
    3133                 return signal(new TypeError(first, FUNCTION_NAME));
     3133                return signalTypeError(first, FUNCTION_NAME);
    31343134            if (second instanceof Operator) {
    31353135                Operator op = (Operator) second;
     
    33693369            }
    33703370            catch (ClassCastException e) {
    3371                 return signal(new TypeError(args.car(), Symbol.SYMBOL));
     3371                return signalTypeError(args.car(), Symbol.SYMBOL);
    33723372            }
    33733373            LispObject body = args.cdr();
     
    34103410            }
    34113411            catch (ClassCastException e) {
    3412                 return signal(new TypeError(args.car(), Symbol.SYMBOL));
     3412                return signalTypeError(args.car(), Symbol.SYMBOL);
    34133413            }
    34143414            LispObject block = env.lookupBlock(symbol);
     
    38753875    }
    38763876
    3877     // ### clear-input
    3878     // clear-input &optional input-stream => nil
     3877    // ### clear-input &optional input-stream => nil
    38793878    private static final Primitive CLEAR_INPUT =
    3880         new Primitive("clear-input", "&optional input-stream")
     3879        new Primitive(Symbol.CLEAR_INPUT, "&optional input-stream")
    38813880    {
    38823881        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    39203919    };
    39213920
    3922     // ### close
    3923     // close stream &key abort => result
     3921    // ### close stream &key abort => result
    39243922    private static final Primitive CLOSE =
    3925         new Primitive("close", "stream &key abort")
     3923        new Primitive(Symbol.CLOSE, "stream &key abort")
    39263924    {
    39273925        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    39523950    };
    39533951
    3954     // ### multiple-value-list
    3955     // multiple-value-list form => list
     3952    // ### multiple-value-list form => list
    39563953    // Evaluates form and creates a list of the multiple values it returns.
    39573954    // Should be a macro.
    39583955    private static final SpecialOperator MULTIPLE_VALUE_LIST =
    3959         new SpecialOperator("multiple-value-list", "value-form")
     3956        new SpecialOperator(Symbol.MULTIPLE_VALUE_LIST, "value-form")
    39603957    {
    39613958        public LispObject execute(LispObject args, Environment env)
     
    39773974    };
    39783975
    3979     // ### nth-value
    3980     // nth-value n form => object
     3976    // ### nth-value n form => object
    39813977    // Evaluates n and then form and returns the nth value returned by form, or
    39823978    // NIL if n >= number of values returned.
    39833979    // Should be a macro.
    39843980    private static final SpecialOperator NTH_VALUE =
    3985         new SpecialOperator("nth-value", "n form")
     3981        new SpecialOperator(Symbol.NTH_VALUE, "n form")
    39863982    {
    39873983        public LispObject execute(LispObject args, Environment env)
     
    40784074    // => line, missing-newline-p
    40794075    private static final Primitive READ_LINE =
    4080         new Primitive("read-line",
     4076        new Primitive(Symbol.READ_LINE,
    40814077                      "&optional input-stream eof-error-p eof-value recursive-p")
    40824078    {
     
    41784174    // &optional input-stream eof-error-p eof-value recursive-p => object
    41794175    private static final Primitive READ =
    4180         new Primitive("read",
     4176        new Primitive(Symbol.READ,
    41814177                      "&optional input-stream eof-error-p eof-value recursive-p")
    41824178    {
     
    42684264    // &optional input-stream eof-error-p eof-value recursive-p => object
    42694265    private static final Primitive READ_PRESERVING_WHITESPACE =
    4270         new Primitive("read-preserving-whitespace",
     4266        new Primitive(Symbol.READ_PRESERVING_WHITESPACE,
    42714267                      "&optional input-stream eof-error-p eof-value recursive-p")
    42724268    {
     
    42874283    };
    42884284
    4289     // ### read-char
    4290     // read-char &optional input-stream eof-error-p eof-value recursive-p => char
     4285    // ### read-char &optional input-stream eof-error-p eof-value recursive-p
     4286    // => char
    42914287    private static final Primitive READ_CHAR =
    4292         new Primitive("read-char",
     4288        new Primitive(Symbol.READ_CHAR,
    42934289                      "&optional input-stream eof-error-p eof-value recursive-p")
    42944290    {
     
    43204316    };
    43214317
    4322     // ### unread-char
    4323     // unread-char character &optional input-stream => nil
     4318    // ### unread-char character &optional input-stream => nil
    43244319    private static final Primitive UNREAD_CHAR =
    4325         new Primitive("unread-char", "character &optional input-stream")
     4320        new Primitive(Symbol.UNREAD_CHAR, "character &optional input-stream")
    43264321    {
    43274322        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    43494344                return ((StandardGenericFunction)arg).getGenericFunctionName();
    43504345            }
    4351             return signal(new TypeError(arg, Symbol.FUNCTION));
     4346            return signalTypeError(arg, Symbol.FUNCTION);
    43524347        }
    43534348    };
     
    43684363                return second;
    43694364            }
    4370             return signal(new TypeError(first, Symbol.FUNCTION));
     4365            return signalTypeError(first, Symbol.FUNCTION);
    43714366        }
    43724367    };
     
    43874382    };
    43884383
    4389     // ### subseq
    4390     // subseq sequence start &optional end
     4384    // ### subseq sequence start &optional end
    43914385    private static final Primitive SUBSEQ =
    4392         new Primitive("subseq", "sequence start &optional end")
    4393     {
    4394         public LispObject execute(LispObject first, LispObject second)
    4395             throws ConditionThrowable
    4396         {
    4397             final int start = Fixnum.getValue(second);
     4386        new Primitive(Symbol.SUBSEQ, "sequence start &optional end")
     4387    {
     4388        public LispObject execute(LispObject first, LispObject second)
     4389            throws ConditionThrowable
     4390        {
     4391            final int start;
     4392            try {
     4393                start = ((Fixnum)second).value;
     4394            }
     4395            catch (ClassCastException e) {
     4396                return signalTypeError(second, Symbol.FIXNUM);
     4397            }
    43984398            if (start < 0) {
    43994399                FastStringBuffer sb = new FastStringBuffer("Bad start index (");
     
    44044404            if (first.listp())
    44054405                return list_subseq(first, start, -1);
    4406             if (first.vectorp()) {
    4407                 AbstractVector v = (AbstractVector) first;
     4406            if (first instanceof AbstractVector) {
     4407                final AbstractVector v = (AbstractVector) first;
    44084408                return v.subseq(start, v.length());
    44094409            }
    4410             return signal(new TypeError(first, Symbol.SEQUENCE));
     4410            return signalTypeError(first, Symbol.SEQUENCE);
    44114411        }
    44124412        public LispObject execute(LispObject first, LispObject second,
     
    44144414            throws ConditionThrowable
    44154415        {
    4416             final int start = Fixnum.getValue(second);
     4416            final int start;
     4417            try {
     4418                start = ((Fixnum)second).value;
     4419            }
     4420            catch (ClassCastException e) {
     4421                return signalTypeError(second, Symbol.FIXNUM);
     4422            }
    44174423            if (start < 0) {
    44184424                FastStringBuffer sb = new FastStringBuffer("Bad start index (");
     
    44364442            if (first.listp())
    44374443                return list_subseq(first, start, end);
    4438             if (first.vectorp()) {
    4439                 AbstractVector v = (AbstractVector) first;
     4444            if (first instanceof AbstractVector) {
     4445                final AbstractVector v = (AbstractVector) first;
    44404446                if (end < 0)
    44414447                    end = v.length();
    44424448                return v.subseq(start, end);
    44434449            }
    4444             return signal(new TypeError(first, Symbol.SEQUENCE));
     4450            return signalTypeError(first, Symbol.SEQUENCE);
    44454451        }
    44464452    };
     
    44634469
    44644470    // ### list
    4465     private static final Primitive LIST = new Primitive("list", "&rest objects")
     4471    private static final Primitive LIST =
     4472        new Primitive(Symbol.LIST, "&rest objects")
    44664473    {
    44674474        public LispObject execute()
     
    45004507
    45014508    // ### list*
    4502     private static final Primitive LIST_ =
    4503         new Primitive("list*", "&rest objects")
     4509    private static final Primitive LIST_STAR =
     4510        new Primitive(Symbol.LIST_STAR, "&rest objects")
    45044511    {
    45054512        public LispObject execute() throws ConditionThrowable
     
    45434550    // ### nreverse
    45444551    public static final Primitive NREVERSE =
    4545         new Primitive("nreverse", "sequence")
     4552        new Primitive(Symbol.NREVERSE, "sequence")
    45464553    {
    45474554        public LispObject execute (LispObject arg) throws ConditionThrowable
     
    45534560    // ### nreconc
    45544561    private static final Primitive NRECONC =
    4555         new Primitive("nreconc", "list tail")
     4562        new Primitive(Symbol.NRECONC, "list tail")
    45564563    {
    45574564        public LispObject execute(LispObject list, LispObject obj)
     
    45914598    // ### reverse
    45924599    private static final Primitive REVERSE =
    4593         new Primitive("reverse", "sequence")
     4600        new Primitive(Symbol.REVERSE, "sequence")
    45944601    {
    45954602        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    47714778                }
    47724779            }
    4773             return signal(new TypeError(first, Symbol.SEQUENCE));
     4780            return signalTypeError(first, Symbol.SEQUENCE);
    47744781        }
    47754782    };
     
    48984905
    48994906    // ### streamp
    4900     private static final Primitive STREAMP = new Primitive("streamp", "object")
     4907    private static final Primitive STREAMP =
     4908        new Primitive(Symbol.STREAMP, "object")
    49014909    {
    49024910        public LispObject execute(LispObject arg)
     
    49074915
    49084916    // ### integerp
    4909     private static final Primitive INTEGERP = new Primitive("integerp", "object")
     4917    private static final Primitive INTEGERP =
     4918        new Primitive(Symbol.INTEGERP, "object")
    49104919    {
    49114920        public LispObject execute(LispObject arg)
     
    49164925
    49174926    // ### evenp
    4918     private static final Primitive EVENP = new Primitive("evenp", "integer")
     4927    private static final Primitive EVENP =
     4928        new Primitive(Symbol.EVENP, "integer")
    49194929    {
    49204930        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    49254935
    49264936    // ### oddp
    4927     private static final Primitive ODDP = new Primitive("oddp", "integer")
     4937    private static final Primitive ODDP = new Primitive(Symbol.ODDP, "integer")
    49284938    {
    49294939        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    49344944
    49354945    // ### numberp
    4936     private static final Primitive NUMBERP = new Primitive("numberp", "object")
     4946    private static final Primitive NUMBERP =
     4947        new Primitive(Symbol.NUMBERP, "object")
    49374948    {
    49384949        public LispObject execute(LispObject arg)
     
    49434954
    49444955    // ### realp
    4945     private static final Primitive REALP = new Primitive("realp", "object")
     4956    private static final Primitive REALP =
     4957        new Primitive(Symbol.REALP, "object")
    49464958    {
    49474959        public LispObject execute(LispObject arg)
     
    49524964
    49534965    // ### rationalp
    4954     private static final Primitive RATIONALP = new Primitive("rationalp","object") {
     4966    private static final Primitive RATIONALP =
     4967        new Primitive(Symbol.RATIONALP,"object")
     4968    {
    49554969        public LispObject execute(LispObject arg)
    49564970        {
     
    49614975    // ### complex
    49624976    private static final Primitive COMPLEX =
    4963         new Primitive("complex", "realpart &optional imagpart")
     4977        new Primitive(Symbol.COMPLEX, "realpart &optional imagpart")
    49644978    {
    49654979        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    49714985            if (arg.realp())
    49724986                return arg;
    4973             signal(new TypeError(arg, Symbol.REAL));
    4974             return NIL;
     4987            return signalTypeError(arg, Symbol.REAL);
    49754988        }
    49764989        public LispObject execute(LispObject first, LispObject second)
     
    49834996    // ### complexp
    49844997    private static final Primitive COMPLEXP =
    4985         new Primitive("complexp", "object")
     4998        new Primitive(Symbol.COMPLEXP, "object")
    49864999    {
    49875000        public LispObject execute(LispObject arg)
     
    49935006    // ### numerator
    49945007    private static final Primitive NUMERATOR =
    4995         new Primitive("numerator", "rational")
     5008        new Primitive(Symbol.NUMERATOR, "rational")
    49965009    {
    49975010        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    50035016    // ### denominator
    50045017    private static final Primitive DENOMINATOR =
    5005         new Primitive("denominator", "rational")
     5018        new Primitive(Symbol.DENOMINATOR, "rational")
    50065019    {
    50075020        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    50135026    // ### realpart
    50145027    private static final Primitive REALPART =
    5015         new Primitive("realpart", "number")
     5028        new Primitive(Symbol.REALPART, "number")
    50165029    {
    50175030        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    50215034            if (arg.numberp())
    50225035                return arg;
    5023             signal(new TypeError(arg, Symbol.NUMBER));
    5024             return NIL;
     5036            return signalTypeError(arg, Symbol.NUMBER);
    50255037        }
    50265038    };
     
    50285040    // ### imagpart
    50295041    private static final Primitive IMAGPART =
    5030         new Primitive("imagpart", "number")
     5042        new Primitive(Symbol.IMAGPART, "number")
    50315043    {
    50325044        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    50405052    // ### integer-length
    50415053    private static final Primitive INTEGER_LENGTH =
    5042         new Primitive("integer-length", "integer")
     5054        new Primitive(Symbol.INTEGER_LENGTH, "integer")
    50435055    {
    50445056        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    50575069            if (arg instanceof Bignum)
    50585070                return new Fixnum(((Bignum)arg).value.bitLength());
    5059             return signal(new TypeError(arg, Symbol.INTEGER));
     5071            return signalTypeError(arg, Symbol.INTEGER);
    50605072        }
    50615073    };
     
    50735085            else if (first instanceof Bignum)
    50745086                n1 = ((Bignum)first).getValue();
    5075             else {
    5076                 signal(new TypeError(first, Symbol.INTEGER));
    5077                 return NIL;
    5078             }
     5087            else
     5088                return signalTypeError(first, Symbol.INTEGER);
    50795089            if (second instanceof Fixnum)
    50805090                n2 = BigInteger.valueOf(((Fixnum)second).getValue());
    50815091            else if (second instanceof Bignum)
    50825092                n2 = ((Bignum)second).getValue();
    5083             else {
    5084                 signal(new TypeError(second, Symbol.INTEGER));
    5085                 return NIL;
    5086             }
     5093            else
     5094                return signalTypeError(second, Symbol.INTEGER);
    50875095            return number(n1.gcd(n2));
    50885096        }
     
    51795187            }
    51805188            catch (ClassCastException e) {
    5181                 return signal(new TypeError(arg, Symbol.SYMBOL));
     5189                return signalTypeError(arg, Symbol.SYMBOL);
    51825190            }
    51835191        }
     
    51945202            }
    51955203            catch (ClassCastException e) {
    5196                 return signal(new TypeError(arg, Symbol.SYMBOL));
     5204                return signalTypeError(arg, Symbol.SYMBOL);
    51975205            }
    51985206        }
     
    52115219            }
    52125220            catch (ClassCastException e) {
    5213                 return signal(new TypeError(first, Symbol.SYMBOL));
     5221                return signalTypeError(first, Symbol.SYMBOL);
    52145222            }
    52155223        }
     
    52385246    // ### symbol-name
    52395247    public static final Primitive SYMBOL_NAME =
    5240         new Primitive("symbol-name", "symbol")
     5248        new Primitive(Symbol.SYMBOL_NAME, "symbol")
    52415249    {
    52425250        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    52535261    // ### symbol-package
    52545262    public static final Primitive SYMBOL_PACKAGE =
    5255         new Primitive("symbol-package", "symbol")
     5263        new Primitive(Symbol.SYMBOL_PACKAGE, "symbol")
    52565264    {
    52575265        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    52685276    // ### symbol-function
    52695277    public static final Primitive SYMBOL_FUNCTION =
    5270         new Primitive("symbol-function", "symbol")
     5278        new Primitive(Symbol.SYMBOL_FUNCTION, "symbol")
    52715279    {
    52725280        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    53035311    // ### symbol-plist
    53045312    public static final Primitive SYMBOL_PLIST =
    5305         new Primitive("symbol-plist", "symbol")
     5313        new Primitive(Symbol.SYMBOL_PLIST, "symbol")
    53065314    {
    53075315        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    53175325
    53185326    // ### keywordp
    5319     public static final Primitive KEYWORDP = new Primitive("keywordp", "object")
     5327    public static final Primitive KEYWORDP =
     5328        new Primitive(Symbol.KEYWORDP, "object")
    53205329    {
    53215330        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    53315340    // ### make-symbol
    53325341    public static final Primitive MAKE_SYMBOL =
    5333         new Primitive("make-symbol", "name")
     5342        new Primitive(Symbol.MAKE_SYMBOL, "name")
    53345343    {
    53355344        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    53465355    // makunbound
    53475356    public static final Primitive MAKUNBOUND =
    5348         new Primitive("makunbound", "symbol")
     5357        new Primitive(Symbol.MAKUNBOUND, "symbol")
    53495358    {
    53505359        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    53625371    // ### find-class symbol &optional errorp environment => class
    53635372    private static final Primitive FIND_CLASS =
    5364         new Primitive("find-class", "symbol &optional errorp environment")
     5373        new Primitive(Symbol.FIND_CLASS, "symbol &optional errorp environment")
    53655374    {
    53665375        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    54305439                    return second;
    54315440                }
    5432                 return signal(new TypeError(second, Symbol.CLASS));
    5433             }
    5434             catch (ClassCastException e) {
    5435                 return signal(new TypeError(first, Symbol.SYMBOL));
     5441                return signalTypeError(second, Symbol.CLASS);
     5442            }
     5443            catch (ClassCastException e) {
     5444                return signalTypeError(first, Symbol.SYMBOL);
    54365445            }
    54375446        }
     
    54485457            }
    54495458            catch (ClassCastException e) {
    5450                 return signal(new TypeError(arg, Symbol.CLASS));
     5459                return signalTypeError(arg, Symbol.CLASS);
    54515460            }
    54525461        }
     
    54655474            }
    54665475            catch (ClassCastException e) {
    5467                 return signal(new TypeError(first, Symbol.CLASS));
     5476                return signalTypeError(first, Symbol.CLASS);
    54685477            }
    54695478        }
     
    54815490            }
    54825491            catch (ClassCastException e) {
    5483                 return signal(new TypeError(arg, Symbol.CLASS));
     5492                return signalTypeError(arg, Symbol.CLASS);
    54845493            }
    54855494        }
     
    54995508            catch (ClassCastException e) {
    55005509                if (!(first instanceof LispClass))
    5501                     return signal(new TypeError(first, Symbol.CLASS));
     5510                    return signalTypeError(first, Symbol.CLASS);
    55025511                if (!(second instanceof Layout))
    5503                     return signal(new TypeError(second, Symbol.LAYOUT));
     5512                    return signalTypeError(second, Symbol.LAYOUT);
    55045513                // Not reached.
    55055514                return NIL;
     
    55185527            }
    55195528            catch (ClassCastException e) {
    5520                 return signal(new TypeError(arg, Symbol.CLASS));
     5529                return signalTypeError(arg, Symbol.CLASS);
    55215530            }
    55225531        }
     
    55355544            }
    55365545            catch (ClassCastException e) {
    5537                 return signal(new TypeError(first, Symbol.CLASS));
     5546                return signalTypeError(first, Symbol.CLASS);
    55385547            }
    55395548        }
     
    55505559            }
    55515560            catch (ClassCastException e) {
    5552                 return signal(new TypeError(arg, Symbol.CLASS));
     5561                return signalTypeError(arg, Symbol.CLASS);
    55535562            }
    55545563        }
     
    55685577            }
    55695578            catch (ClassCastException e) {
    5570                 return signal(new TypeError(first, Symbol.CLASS));
     5579                return signalTypeError(first, Symbol.CLASS);
    55715580            }
    55725581        }
     
    55835592            }
    55845593            catch (ClassCastException e) {
    5585                 return signal(new TypeError(arg, Symbol.CLASS));
     5594                return signalTypeError(arg, Symbol.CLASS);
    55865595            }
    55875596        }
     
    56005609            }
    56015610            catch (ClassCastException e) {
    5602                 return signal(new TypeError(first, Symbol.CLASS));
     5611                return signalTypeError(first, Symbol.CLASS);
    56035612            }
    56045613        }
     
    56165625            }
    56175626            catch (ClassCastException e) {
    5618                 return signal(new TypeError(arg, Symbol.CLASS));
     5627                return signalTypeError(arg, Symbol.CLASS);
    56195628            }
    56205629        }
     
    56335642            }
    56345643            catch (ClassCastException e) {
    5635                 return signal(new TypeError(first, Symbol.CLASS));
     5644                return signalTypeError(first, Symbol.CLASS);
    56365645            }
    56375646        }
     
    56495658            }
    56505659            catch (ClassCastException e) {
    5651                 return signal(new TypeError(arg, Symbol.CLASS));
     5660                return signalTypeError(arg, Symbol.CLASS);
    56525661            }
    56535662        }
     
    56665675            }
    56675676            catch (ClassCastException e) {
    5668                 return signal(new TypeError(first, Symbol.CLASS));
     5677                return signalTypeError(first, Symbol.CLASS);
    56695678            }
    56705679        }
     
    56815690            }
    56825691            catch (ClassCastException e) {
    5683                 return signal(new TypeError(arg, Symbol.CLASS));
     5692                return signalTypeError(arg, Symbol.CLASS);
    56845693            }
    56855694        }
     
    56985707            }
    56995708            catch (ClassCastException e) {
    5700                 return signal(new TypeError(first, Symbol.CLASS));
     5709                return signalTypeError(first, Symbol.CLASS);
    57015710            }
    57025711        }
     
    57245733            }
    57255734            catch (ClassCastException e) {
    5726                 return signal(new TypeError(arg, Symbol.CHARACTER));
     5735                return signalTypeError(arg, Symbol.CHARACTER);
    57275736            }
    57285737            char[] chars = new char[1];
     
    57865795            int end = Fixnum.getValue(fourth);
    57875796            if (!v.getElementType().equal(UNSIGNED_BYTE_8))
    5788                 return signal(new TypeError(first, list2(Symbol.VECTOR,
    5789                                                          UNSIGNED_BYTE_8)));
     5797                return signalTypeError(first, list2(Symbol.VECTOR,
     5798                                                    UNSIGNED_BYTE_8));
    57905799            for (int i = start; i < end; i++) {
    57915800                int n = stream._readByte();
     
    58575866            }
    58585867            catch (ClassCastException e) {
    5859                 return signal(new TypeError(arg, Symbol.FUNCTION));
     5868                return signalTypeError(arg, Symbol.FUNCTION);
    58605869            }
    58615870        }
     
    58725881            }
    58735882            catch (ClassCastException e) {
    5874                 return signal(new TypeError(arg, Symbol.SYMBOL));
     5883                return signalTypeError(arg, Symbol.SYMBOL);
    58755884            }
    58765885        }
Note: See TracChangeset for help on using the changeset viewer.