Changeset 13440 for trunk/abcl/src/org


Ignore:
Timestamp:
08/05/11 21:25:10 (10 years ago)
Author:
ehuelsmann
Message:

Rename writeToString() to printObject() since that's what it's being used for.
Additionally, create princToString() for use in error messages, making the

required replacement where appropriate.

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

Legend:

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

    r12713 r13440  
    161161                final String errorMsg =
    162162                    "Invalid index %d for array %s.";
    163                 error(new ProgramError(String.format(errorMsg, n, writeToString())));
     163                error(new ProgramError(String.format(errorMsg, n, printObject())));
    164164            }
    165165            sum += n * lastSize;
     
    219219        if (this instanceof SimpleArray_T)
    220220            sb.append("SIMPLE-");
    221         sb.append("ARRAY " + getElementType().writeToString() + " (");
     221        sb.append("ARRAY " + getElementType().printObject() + " (");
    222222        for (int i = 0; i < dimv.length; i++) {
    223223            sb.append(dimv[i]);
     
    229229    }
    230230
    231     // Helper for writeToString().
     231    // Helper for printObject().
    232232    private void appendContents(int[] dimensions, int index, StringBuilder sb,
    233233                                LispThread thread)
     
    241241                sb.append(stream.getString().getStringValue());
    242242            } else
    243                 sb.append(AREF(index).writeToString());
     243                sb.append(AREF(index).printObject());
    244244        } else {
    245245            final LispObject printReadably =
  • trunk/abcl/src/org/armedbear/lisp/AbstractBitVector.java

    r12588 r13440  
    173173
    174174    @Override
    175     public String writeToString()
     175    public String printObject()
    176176    {
    177177        final LispThread thread = LispThread.currentThread();
  • trunk/abcl/src/org/armedbear/lisp/AbstractString.java

    r12431 r13440  
    111111
    112112    @Override
    113     public String writeToString()
     113    public String printObject()
    114114    {
    115115        return writeToString(0, length());
  • trunk/abcl/src/org/armedbear/lisp/AbstractVector.java

    r12431 r13440  
    155155    sb.append(index);
    156156    sb.append(" for ");
    157     sb.append(writeToString());
     157    sb.append(princToString());
    158158    if (limit > 0)
    159159      {
     
    205205
    206206  @Override
    207   public String writeToString()
     207  public String printObject()
    208208  {
    209209    final LispThread thread = LispThread.currentThread();
     
    216216            if (i > 0)
    217217              sb.append(' ');
    218             sb.append(AREF(i).writeToString());
     218            sb.append(AREF(i).printObject());
    219219          }
    220220        sb.append(')');
     
    249249                    if (i > 0)
    250250                      sb.append(' ');
    251                     sb.append(AREF(i).writeToString());
     251                    sb.append(AREF(i).printObject());
    252252                  }
    253253              }
  • trunk/abcl/src/org/armedbear/lisp/Autoload.java

    r13369 r13440  
    154154            if (symbol != null) {
    155155                if (symbol.getSymbolFunction() instanceof Autoload) {
    156                     Debug.trace("Unable to autoload " + symbol.writeToString());
     156                    Debug.trace("Unable to autoload " + symbol.princToString());
    157157                    throw new IntegrityError();
    158158                }
     
    260260
    261261    @Override
    262     public String writeToString()
     262    public String printObject()
    263263    {
    264264        StringBuffer sb = new StringBuffer("#<AUTOLOAD ");
    265         sb.append(symbol.writeToString());
     265        sb.append(symbol.princToString());
    266266        sb.append(" \"");
    267267        if (className != null) {
  • trunk/abcl/src/org/armedbear/lisp/AutoloadMacro.java

    r12513 r13440  
    6565
    6666    @Override
    67     public String writeToString()
     67    public String printObject()
    6868    {
    6969        StringBuffer sb = new StringBuffer("#<AUTOLOAD-MACRO ");
    70         sb.append(getSymbol().writeToString());
     70        sb.append(getSymbol().princToString());
    7171        sb.append(" \"");
    7272        sb.append(getFileName());
  • trunk/abcl/src/org/armedbear/lisp/Bignum.java

    r12288 r13440  
    290290    float f = value.floatValue();
    291291    if (Float.isInfinite(f))
    292       error(new TypeError("The value " + writeToString() +
     292      error(new TypeError("The value " + princToString() +
    293293                           " is too large to be converted to a single float."));
    294294    return f;
     
    300300    double d = value.doubleValue();
    301301    if (Double.isInfinite(d))
    302       error(new TypeError("The value " + writeToString() +
     302      error(new TypeError("The value " + princToString() +
    303303                           " is too large to be converted to a double float."));
    304304    return d;
     
    756756
    757757  @Override
    758   public String writeToString()
     758  public String printObject()
    759759  {
    760760    final LispThread thread = LispThread.currentThread();
  • trunk/abcl/src/org/armedbear/lisp/BroadcastStream.java

    r12513 r13440  
    220220
    221221    @Override
    222     public String writeToString()
     222    public String printObject()
    223223    {
    224224        return unreadableString("BROADCAST-STREAM");
  • trunk/abcl/src/org/armedbear/lisp/BuiltInClass.java

    r13246 r13440  
    7474  public LispObject getDescription()
    7575  {
    76     return new SimpleString(writeToString());
    77   }
    78 
    79   @Override
    80   public String writeToString()
     76    return new SimpleString(princToString());
     77  }
     78
     79  @Override
     80  public String printObject()
    8181  {
    8282    StringBuilder sb = new StringBuilder("#<BUILT-IN-CLASS ");
    83     sb.append(getName().writeToString());
     83    sb.append(getName().printObject());
    8484    sb.append('>');
    8585    return sb.toString();
  • trunk/abcl/src/org/armedbear/lisp/CaseFrobStream.java

    r12362 r13440  
    210210
    211211    @Override
    212     public String writeToString()
     212    public String printObject()
    213213    {
    214214        return unreadableString("CASE-FROB-STREAM");
  • trunk/abcl/src/org/armedbear/lisp/CellError.java

    r12512 r13440  
    103103        if (Symbol.PRINT_ESCAPE.symbolValue() == NIL)
    104104            return super.getMessage();
    105         StringBuffer sb = new StringBuffer(typeOf().writeToString());
     105        StringBuffer sb = new StringBuffer(typeOf().princToString());
    106106        sb.append(' ');
    107         sb.append(getCellName().writeToString());
     107        sb.append(getCellName().princToString());
    108108        return unreadableString(sb.toString());
    109109    }
  • trunk/abcl/src/org/armedbear/lisp/Closure.java

    r12678 r13440  
    132132    setLambdaList(lambdaList);
    133133    if (!(lambdaList == NIL || lambdaList instanceof Cons))
    134       error(new ProgramError("The lambda list " + lambdaList.writeToString() +
     134      error(new ProgramError("The lambda list " + lambdaList.princToString() +
    135135                           " is invalid."));
    136136    boolean _andKey = false;
     
    388388
    389389  {
    390     error(new ProgramError(obj.writeToString() +
     390    error(new ProgramError(obj.princToString() +
    391391                         " may not be used as a variable in a lambda list."));
    392392  }
     
    861861                                (allowOtherKeysValue == null || allowOtherKeysValue == NIL))
    862862                              error(new ProgramError("Unrecognized keyword argument " +
    863                                                       unrecognizedKeyword.writeToString()));
     863                                                      unrecognizedKeyword.printObject()));
    864864                          }
    865865                      }
  • trunk/abcl/src/org/armedbear/lisp/CompiledClosure.java

    r12398 r13440  
    237237    } catch(Throwable t) {
    238238        Debug.trace(t);
    239         return error(new LispError("Unable to load " + arg.writeToString()));
     239        return error(new LispError("Unable to load " + arg.princToString()));
    240240    }
    241241      }
    242       return error(new LispError("Unable to load " + arg.writeToString()));
     242      return error(new LispError("Unable to load " + arg.princToString()));
    243243    }
    244244  };
  • trunk/abcl/src/org/armedbear/lisp/Complex.java

    r12940 r13440  
    344344
    345345  @Override
    346   public String writeToString()
     346  public String printObject()
    347347  {
    348348    StringBuilder sb = new StringBuilder("#C(");
    349     sb.append(realpart.writeToString());
     349    sb.append(realpart.printObject());
    350350    sb.append(' ');
    351     sb.append(imagpart.writeToString());
     351    sb.append(imagpart.printObject());
    352352    sb.append(')');
    353353    return sb.toString();
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray.java

    r12288 r13440  
    234234
    235235    @Override
    236     public String writeToString()
     236    public String printObject()
    237237    {
    238238        return writeToString(dimv);
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte32.java

    r12288 r13440  
    230230
    231231    @Override
    232     public String writeToString()
     232    public String printObject()
    233233    {
    234234        return writeToString(dimv);
  • trunk/abcl/src/org/armedbear/lisp/ComplexArray_UnsignedByte8.java

    r12288 r13440  
    227227
    228228    @Override
    229     public String writeToString()
     229    public String printObject()
    230230    {
    231231        if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
  • trunk/abcl/src/org/armedbear/lisp/Condition.java

    r13182 r13440  
    179179        return format(formatControl, getFormatArguments());
    180180      }
    181     return unreadableString(typeOf().writeToString());
    182   }
    183 
    184   @Override
    185   public final String writeToString()
     181    return unreadableString(typeOf().princToString());
     182  }
     183
     184  @Override
     185  public final String printObject()
    186186  {
    187187    final LispThread thread = LispThread.currentThread();
     
    217217    if (currentLevel >= maxLevel)
    218218      return "#";
    219     return unreadableString(typeOf().writeToString());
     219    return unreadableString(typeOf().princToString());
    220220  }
    221221}
  • trunk/abcl/src/org/armedbear/lisp/Cons.java

    r12713 r13440  
    499499
    500500  @Override
    501   public String writeToString()
     501  public String printObject()
    502502  {
    503503    final LispThread thread = LispThread.currentThread();
     
    523523              {
    524524                sb.append('\'');
    525                 sb.append(cdr.car().writeToString());
     525                sb.append(cdr.car().printObject());
    526526                return sb.toString();
    527527              }
     
    536536              {
    537537                sb.append("#'");
    538                 sb.append(cdr.car().writeToString());
     538                sb.append(cdr.car().printObject());
    539539                return sb.toString();
    540540              }
     
    556556              {
    557557                LispObject p = this;
    558                 sb.append(p.car().writeToString());
     558                sb.append(p.car().printObject());
    559559                ++count;
    560560                while ((p = p.cdr()) instanceof Cons)
     
    563563                    if (count < maxLength)
    564564                      {
    565                         sb.append(p.car().writeToString());
     565                        sb.append(p.car().printObject());
    566566                        ++count;
    567567                      }
     
    575575                  {
    576576                    sb.append(" . ");
    577                     sb.append(p.writeToString());
     577                    sb.append(p.printObject());
    578578                  }
    579579              }
  • trunk/abcl/src/org/armedbear/lisp/DoubleFloat.java

    r12535 r13440  
    530530                m = (bits & 0xfffffffffffffL) | 0x10000000000000L;
    531531            LispObject significand = number(m);
    532 //             Debug.trace("significand = " + significand.writeToString());
     532//             Debug.trace("significand = " + significand.printObject());
    533533            Fixnum exponent = Fixnum.getInstance(e - 1075);
    534 //             Debug.trace("exponent = " + exponent.writeToString());
     534//             Debug.trace("exponent = " + exponent.printObject());
    535535            Fixnum sign = Fixnum.getInstance(s);
    536 //             Debug.trace("sign = " + sign.writeToString());
     536//             Debug.trace("sign = " + sign.printObject());
    537537            LispObject result = significand;
    538 //             Debug.trace("result = " + result.writeToString());
     538//             Debug.trace("result = " + result.printObject());
    539539            result =
    540540                result.multiplyBy(MathFunctions.EXPT.execute(Fixnum.TWO, exponent));
    541 //             Debug.trace("result = " + result.writeToString());
     541//             Debug.trace("result = " + result.printObject());
    542542
    543543
     
    546546
    547547            result = result.multiplyBy(sign);
    548 //             Debug.trace("result = " + result.writeToString());
     548//             Debug.trace("result = " + result.printObject());
    549549//             // Calculate remainder.
    550550//             LispObject product = result.multiplyBy(obj);
    551 //             Debug.trace("product = " + product.writeToString());
     551//             Debug.trace("product = " + product.printObject());
    552552//             LispObject remainder = subtract(product);
    553553            return thread.setValues(result, remainder);
     
    573573
    574574    @Override
    575     public String writeToString()
     575    public String printObject()
    576576    {
    577577        if (value == Double.POSITIVE_INFINITY) {
    578578            StringBuilder sb = new StringBuilder("#.");
    579             sb.append(Symbol.DOUBLE_FLOAT_POSITIVE_INFINITY.writeToString());
     579            sb.append(Symbol.DOUBLE_FLOAT_POSITIVE_INFINITY.printObject());
    580580            return sb.toString();
    581581        }
    582582        if (value == Double.NEGATIVE_INFINITY) {
    583583            StringBuilder sb = new StringBuilder("#.");
    584             sb.append(Symbol.DOUBLE_FLOAT_NEGATIVE_INFINITY.writeToString());
     584            sb.append(Symbol.DOUBLE_FLOAT_NEGATIVE_INFINITY.printObject());
    585585            return sb.toString();
    586586        }
     
    647647        if (obj instanceof Ratio)
    648648            return new DoubleFloat(((Ratio)obj).doubleValue());
    649         error(new TypeError("The value " + obj.writeToString() +
     649        error(new TypeError("The value " + obj.princToString() +
    650650                             " cannot be converted to type DOUBLE-FLOAT."));
    651651        // Not reached.
  • trunk/abcl/src/org/armedbear/lisp/Environment.java

    r12513 r13440  
    246246
    247247  @Override
    248   public String writeToString()
     248  public String printObject()
    249249  {
    250250    return unreadableString(Symbol.ENVIRONMENT);
  • trunk/abcl/src/org/armedbear/lisp/FileStream.java

    r12607 r13440  
    184184            if (namestring == null)
    185185                return error(new SimpleError("Pathname has no namestring: " +
    186                                               pathname.writeToString()));
     186                                              pathname.princToString()));
    187187            File file = new File(namestring);
    188188            length = file.length(); // in 8-bit bytes
     
    264264
    265265    @Override
    266     public String writeToString()
     266    public String printObject()
    267267    {
    268268        return unreadableString(Symbol.FILE_STREAM);
  • trunk/abcl/src/org/armedbear/lisp/Fixnum.java

    r12431 r13440  
    940940
    941941  @Override
    942   public String writeToString()
     942  public String printObject()
    943943  {
    944944    final LispThread thread = LispThread.currentThread();
  • trunk/abcl/src/org/armedbear/lisp/FloatFunctions.java

    r12513 r13440  
    6464                        else
    6565                            error(new LispError("Unsupported floating point trap: " +
    66                                                  car.writeToString()));
     66                                                 car.princToString()));
    6767                        value = value.cdr();
    6868                    }
     
    7070                    TRAP_UNDERFLOW = trap_underflow;
    7171                } else
    72                     error(new LispError("Unrecognized keyword: " + key.writeToString()));
     72                    error(new LispError("Unrecognized keyword: " + key.princToString()));
    7373            }
    7474            return LispThread.currentThread().nothing();
  • trunk/abcl/src/org/armedbear/lisp/ForwardReferencedClass.java

    r13245 r13440  
    6666
    6767    @Override
    68     public String writeToString()
     68    public String printObject()
    6969    {
    7070        StringBuffer sb =
    71             new StringBuffer(Symbol.FORWARD_REFERENCED_CLASS.writeToString());
     71            new StringBuffer(Symbol.FORWARD_REFERENCED_CLASS.printObject());
    7272        if (getName() != null) {
    7373            sb.append(' ');
    74             sb.append(getName().writeToString());
     74            sb.append(getName().printObject());
    7575        }
    7676        return unreadableString(sb.toString());
     
    9191                return c;
    9292            }
    93                 return error(new TypeError(arg.writeToString() +
     93                return error(new TypeError(arg.princToString() +
    9494                                            " is not a valid class name."));
    9595        }
  • trunk/abcl/src/org/armedbear/lisp/Function.java

    r13374 r13440  
    314314
    315315    @Override
    316     public String writeToString()
     316    public String printObject()
    317317    {
    318318        LispObject name = getLambdaName();
    319319        if (name != null && name != NIL) {
    320320            StringBuffer sb = new StringBuffer("#<FUNCTION ");
    321             sb.append(name.writeToString());
     321            sb.append(name.printObject());
    322322            sb.append(" {");
    323323            sb.append(Integer.toHexString(System.identityHashCode(this)).toUpperCase());
     
    337337                thread.bindSpecial(Symbol.PRINT_LENGTH, Fixnum.THREE);
    338338                try {
    339                     sb.append(lambdaList.writeToString());
     339                    sb.append(lambdaList.printObject());
    340340                }
    341341                finally {
  • trunk/abcl/src/org/armedbear/lisp/Go.java

    r12298 r13440  
    5959    {
    6060        StringBuffer sb = new StringBuffer("No tag named ");
    61         sb.append(tag.writeToString());
     61        sb.append(tag.princToString());
    6262        sb.append(" is currently visible");
    6363        return new ControlError(sb.toString());
  • trunk/abcl/src/org/armedbear/lisp/HashTable.java

    r13336 r13440  
    226226
    227227    @Override
    228     public String writeToString() {
     228    public String printObject() {
    229229        if (Symbol.PRINT_READABLY.symbolValue(LispThread.currentThread()) != NIL) {
    230230            error(new PrintNotReadable(list(Keyword.OBJECT, this)));
    231231            return null; // Not reached.
    232232        }
    233         StringBuilder sb = new StringBuilder(getTest().writeToString());
     233        StringBuilder sb = new StringBuilder(getTest().princToString());
    234234        sb.append(' ');
    235         sb.append(Symbol.HASH_TABLE.writeToString());
     235        sb.append(Symbol.HASH_TABLE.princToString());
    236236        sb.append(' ');
    237237        sb.append(count);
  • trunk/abcl/src/org/armedbear/lisp/HashTableFunctions.java

    r13333 r13440  
    7070          return HashTable.newEqualpHashTable(n, rehashSize, rehashThreshold);
    7171        return error(new LispError("Unsupported test for MAKE-HASH-TABLE: " +
    72                                     test.writeToString()));
     72                                    test.princToString()));
    7373      }
    7474    };
     
    103103              rehashThreshold, weakness);
    104104        return error(new LispError("Unsupported test for MAKE-HASH-TABLE: " +
    105                                     test.writeToString()));
     105                                    test.princToString()));
    106106      }
    107107    };
  • trunk/abcl/src/org/armedbear/lisp/Interpreter.java

    r13356 r13440  
    310310                            sb.append(separator);
    311311                            sb.append("Caught ");
    312                             sb.append(c.getCondition().typeOf().writeToString());
     312                            sb.append(c.getCondition().typeOf().printObject());
    313313                            sb.append(" while processing --eval option \"" +
    314314                                      args[i + 1] + "\":");
     
    317317                            final LispThread thread = LispThread.currentThread();
    318318                            thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
    319                             sb.append(c.getCondition().writeToString());
     319                            sb.append(c.getCondition().princToString());
    320320                            sb.append(separator);
    321321                            System.err.print(sb.toString());
     
    409409                    Symbol.SLASH.setSymbolValue(slash);
    410410                    for (int i = 0; i < values.length; i++)
    411                         out._writeLine(values[i].writeToString());
     411                        out._writeLine(values[i].printObject());
    412412                } else {
    413413                    Symbol.SLASH.setSymbolValue(new Cons(result));
    414                     out._writeLine(result.writeToString());
     414                    out._writeLine(result.printObject());
    415415                }
    416416                out._finishOutput();
     
    446446        Condition condition = (Condition) c.getCondition();
    447447        out._writeLine("Error: unhandled condition: " +
    448                        condition.writeToString());
     448                       condition.princToString());
    449449        if (thread != null)
    450450            thread.printBacktrace();
     
    458458        Condition condition = (Condition) c.getCondition();
    459459        out._writeLine("Error: unhandled condition: " +
    460                        condition.writeToString());
     460                       condition.princToString());
    461461        if (thread != null)
    462462            thread.printBacktrace();
     
    517517            thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
    518518            try {
    519                 conditionText = getCondition().writeToString();
     519                conditionText = getCondition().princToString();
    520520            } catch (Throwable t) {
    521521                conditionText = "<error printing Lisp condition>";
     
    553553                                ((Stream)stream).getOffset();
    554554                            Debug.trace("Error loading " +
    555                                         truename.writeToString() +
     555                                        truename.princToString() +
    556556                                        " at line " + lineNumber +
    557557                                        " (offset " + offset + ")");
     
    559559                    }
    560560                    Debug.trace("Encountered unhandled condition of type " +
    561                                 condition.typeOf().writeToString() + ':');
    562                     Debug.trace("  " + condition.writeToString());
     561                                condition.typeOf().princToString() + ':');
     562                    Debug.trace("  " + condition.princToString());
    563563                }
    564564                catch (Throwable t) {} // catch any exception to throw below
  • trunk/abcl/src/org/armedbear/lisp/JarStream.java

    r13405 r13440  
    137137
    138138    @Override
    139     public String writeToString()
     139    public String printObject()
    140140    {
    141141        StringBuffer sb = new StringBuffer();
    142         sb.append(Symbol.JAR_STREAM.writeToString());
     142        sb.append(Symbol.JAR_STREAM.princToString());
    143143        String namestring = pathname.getNamestring();
    144144        if (namestring != null) {
  • trunk/abcl/src/org/armedbear/lisp/Java.java

    r13365 r13440  
    414414                sb.append('(');
    415415                for (int i = 2; i < args.length; i++) {
    416                     sb.append(args[i].writeToString());
     416                    sb.append(args[i].princToString());
    417417                    if (i < args.length - 1)
    418418                        sb.append(',');
     
    559559      constructor = findConstructor((Class<?>) object, args);
    560560        } else {
    561       return error(new LispError(classRef.writeToString() + " is neither a Constructor nor a Class"));
     561      return error(new LispError(classRef.princToString() + " is neither a Constructor nor a Class"));
    562562        }
    563563    }
     
    13941394            return (Class) javaObjectgetObject;
    13951395        }
    1396             error(new LispError(obj.writeToString() + " does not designate a Java class."));
     1396            error(new LispError(obj.princToString() + " does not designate a Java class."));
    13971397            return null;
    13981398    }
  • trunk/abcl/src/org/armedbear/lisp/JavaObject.java

    r13359 r13440  
    355355
    356356    @Override
    357     public String writeToString()
     357    public String printObject()
    358358    {
    359359        if (obj instanceof ControlTransfer)
     
    541541        final Object obj = javaObject.getObject();
    542542        final StringBuilder sb =
    543             new StringBuilder(javaObject.writeToString());
     543            new StringBuilder(javaObject.princToString());
    544544        sb.append(" is an object of type ");
    545         sb.append(Symbol.JAVA_OBJECT.writeToString());
     545        sb.append(Symbol.JAVA_OBJECT.princToString());
    546546        sb.append(".");
    547547        sb.append(System.getProperty("line.separator"));
  • trunk/abcl/src/org/armedbear/lisp/JavaStackFrame.java

    r12288 r13440  
    5555
    5656  @Override
    57   public String writeToString() {
     57  public String printObject() {
    5858    final String JAVA_STACK_FRAME = "JAVA-STACK-FRAME";
    5959    return unreadableString(JAVA_STACK_FRAME + " "
  • trunk/abcl/src/org/armedbear/lisp/Layout.java

    r12955 r13440  
    136136
    137137  @Override
    138   public String writeToString()
     138  public String printObject()
    139139  {
    140140    return unreadableString(Symbol.LAYOUT);
  • trunk/abcl/src/org/armedbear/lisp/Lisp.java

    r13274 r13440  
    515515            else
    516516              return error(new ProgramError("Illegal function object: " +
    517                                              first.writeToString()));
     517                                             first.princToString()));
    518518          }
    519519      }
     
    708708    if (tagbody == null)
    709709      return error(new ControlError("Unmatched tag "
    710                                     + tag.writeToString() +
     710                                    + tag.princToString() +
    711711                                    " for GO outside lexical extent."));
    712712
     
    725725    if (binding.env.inactive)
    726726      return error(new ControlError("Unmatched tag "
    727                                     + binding.symbol.writeToString() +
     727                                    + binding.symbol.princToString() +
    728728                                    " for GO outside of lexical extent."));
    729729
     
    744744    if (blockId == null)
    745745      return error(new ControlError("Unmatched block "
    746                                     + blockName.writeToString() + " for " +
     746                                    + blockName.princToString() + " for " +
    747747                                    "RETURN-FROM outside lexical extent."));
    748748
     
    768768    if (binding.env.inactive)
    769769      return error(new ControlError("Unmatched block "
    770                                     + binding.symbol.writeToString() +
     770                                    + binding.symbol.princToString() +
    771771                                    " for RETURN-FROM outside of" +
    772772                                    " lexical extent."));
     
    797797                  if (binding == null)
    798798                    return error(new ControlError("No tag named " +
    799                                                   tag.writeToString() +
     799                                                  tag.princToString() +
    800800                                                  " is currently visible."));
    801801                  else if (memql(tag, localTags))
     
    11191119           Symbol.GENSYM_COUNTER.setSymbolValue(Fixnum.ZERO);
    11201120           error(new TypeError("The value of *GENSYM-COUNTER* was not a nonnegative integer. Old value: " +
    1121                                 oldValue.writeToString() + " New value: 0"));
     1121                                oldValue.princToString() + " New value: 0"));
    11221122        }
    11231123    } else {
     
    11321132               Symbol.GENSYM_COUNTER.setSymbolValue(Fixnum.ZERO);
    11331133               error(new TypeError("The value of *GENSYM-COUNTER* was not a nonnegative integer. Old value: " +
    1134                                     oldValue.writeToString() + " New value: 0"));
     1134                                    oldValue.princToString() + " New value: 0"));
    11351135            }
    11361136        }
     
    14221422  {
    14231423    try {
    1424         return obj.writeToString();
     1424        return obj.printObject();
    14251425      }
    14261426    catch (NullPointerException e)
     
    16361636                  return stream;                       
    16371637          return (Stream) // Not reached.                     
    1638           error(new TypeError("The value " + obj.writeToString() +
     1638          error(new TypeError("The value " + obj.princToString() +
    16391639                        " is not a character input stream."));
    16401640  }
     
    16471647                  return stream;                       
    16481648        return (Stream) // Not reached.
    1649         error(new TypeError("The value " + obj.writeToString() +
     1649        error(new TypeError("The value " + obj.princToString() +
    16501650                            " is not a character output stream."));
    16511651  }
     
    16581658                  return stream;                       
    16591659        return (Stream) // Not reached.
    1660         error(new TypeError("The value " + obj.writeToString() +
     1660        error(new TypeError("The value " + obj.princToString() +
    16611661                             " is not a binary input stream."));
    16621662  }
     
    17871787    if (pkg != null)
    17881788      return pkg;
    1789     error(new PackageError(obj.writeToString() + " is not the name of a package."));
     1789    error(new PackageError(obj.princToString() + " is not the name of a package."));
    17901790    // Not reached.
    17911791    return null;
     
    18741874        else
    18751875          return error(new TypeError("Malformed property list: " +
    1876                                       plist.writeToString()));
     1876                                      plist.princToString()));
    18771877      }
    18781878    return defaultValue;
     
    19571957      {
    19581958        if (!(list.cdr() instanceof Cons))
    1959           error(new ProgramError("The symbol " + symbol.writeToString() +
     1959          error(new ProgramError("The symbol " + symbol.princToString() +
    19601960                                  " has an odd number of items in its property list."));
    19611961        if (list.car() == indicator)
     
    20112011                        thread.bindSpecial(Symbol.PRINT_READABLY, NIL);
    20122012                        try {
    2013                             sb.append(obj.writeToString());
     2013                            sb.append(obj.printObject());
    20142014                        }
    20152015                        finally {
     
    20262026                        thread.bindSpecial(Symbol.PRINT_ESCAPE, T);
    20272027                        try {
    2028                             sb.append(obj.writeToString());
     2028                            sb.append(obj.printObject());
    20292029                        }
    20302030                        finally {
     
    20432043                        thread.bindSpecial(Symbol.PRINT_BASE, Fixnum.constants[10]);
    20442044                        try {
    2045                             sb.append(obj.writeToString());
     2045                            sb.append(obj.printObject());
    20462046                        }
    20472047                        finally {
     
    20602060                        thread.bindSpecial(Symbol.PRINT_BASE, Fixnum.constants[16]);
    20612061                        try {
    2062                             sb.append(obj.writeToString());
     2062                            sb.append(obj.printObject());
    20632063                        }
    20642064                        finally {
     
    27042704  {
    27052705    @Override
    2706     public String writeToString()
     2706    public String printObject()
    27072707    {
    27082708      return "#<UNBOUND>";
     
    27142714  {
    27152715    @Override
    2716     public String writeToString()
     2716    public String printObject()
    27172717    {
    27182718      return "null";
  • trunk/abcl/src/org/armedbear/lisp/LispCharacter.java

    r13415 r13440  
    224224
    225225  @Override
    226   public final String writeToString()
     226  public final String printObject()
    227227  {
    228228    final LispThread thread = LispThread.currentThread();
  • trunk/abcl/src/org/armedbear/lisp/LispClass.java

    r13273 r13440  
    7676        StringBuilder sb =
    7777          new StringBuilder("There is no class named ");
    78         sb.append(name.writeToString());
     78        sb.append(name.princToString());
    7979        sb.append('.');
    8080        return error(new LispError(sb.toString()));
  • trunk/abcl/src/org/armedbear/lisp/LispObject.java

    r13249 r13440  
    6666  {
    6767    StringBuilder sb = new StringBuilder("An object of type ");
    68     sb.append(typeOf().writeToString());
     68    sb.append(typeOf().princToString());
    6969    sb.append(" at #x");
    7070    sb.append(Integer.toHexString(System.identityHashCode(this)).toUpperCase());
     
    131131      if (c.isAssignableFrom(getClass()))
    132132    return this;
    133       return error(new LispError("The value " + writeToString() +
     133      return error(new LispError("The value " + princToString() +
    134134         " is not of class " + c.getName()));
    135135  }
     
    732732  }
    733733
    734   public String writeToString()
     734  /** PRINC-TO-STRING function to be used with Java objects
     735   *
     736   * @return A string in human-readable format, as per PRINC definition
     737   */
     738  public String princToString()
     739  {
     740      LispThread thread = LispThread.currentThread();
     741      SpecialBindingsMark mark = thread.markSpecialBindings();
     742      try {
     743          thread.bindSpecial(Symbol.PRINT_READABLY, NIL);
     744          thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
     745          return printObject();
     746      }
     747      finally {
     748          thread.resetSpecialBindings(mark);
     749      }
     750  }
     751 
     752  public String printObject()
    735753  {
    736754    return toString();
     
    760778
    761779  {
    762     return unreadableString(symbol.writeToString(), identity);
     780    return unreadableString(symbol.printObject(), identity);
    763781  }
    764782
     
    11501168  public LispObject STRING()
    11511169  {
    1152     return error(new TypeError(writeToString() + " cannot be coerced to a string."));
     1170    return error(new TypeError(princToString() + " cannot be coerced to a string."));
    11531171  }
    11541172
  • trunk/abcl/src/org/armedbear/lisp/LispStackFrame.java

    r12376 r13440  
    4949    public UnavailableArgument () { }
    5050    @Override
    51     public String writeToString() {
     51    public String printObject() {
    5252      return unreadableString("unavailable arg", false);
    5353    }
     
    115115
    116116   @Override
    117    public String writeToString()
     117   public String printObject()
    118118   {
    119119     String result = "";
    120120     final String LISP_STACK_FRAME = "LISP-STACK-FRAME";
    121121     try {
    122    result = Symbol.PRIN1_TO_STRING.execute(this.toLispList()).writeToString();
     122   result = Symbol.PRIN1_TO_STRING.execute(this.toLispList()).printObject();
    123123     } catch (Throwable t) { // error while printing stack
    124124       Debug.trace("Serious printing error: ");
     
    191191    String result;
    192192    try {
    193       result = this.toLispList().writeToString();
     193      result = this.toLispList().printObject();
    194194    } catch (Throwable t) { // error while printing stack
    195195      Debug.trace("Serious printing error: ");
  • trunk/abcl/src/org/armedbear/lisp/LispThread.java

    r13137 r13440  
    587587        }
    588588        error(new ControlError("Attempt to throw to the nonexistent tag " +
    589                                 tag.writeToString() + "."));
     589                                tag.princToString() + "."));
    590590    }
    591591
     
    872872            stream._writeString(sb.toString());
    873873        }
    874         String raw = obj.writeToString();
     874        String raw = obj.printObject();
    875875        if (stream.getCharPos() + raw.length() < 80) {
    876876            // It fits.
     
    918918
    919919    @Override
    920     public String writeToString()
     920    public String printObject()
    921921    {
    922922        StringBuffer sb = new StringBuffer("THREAD");
     
    949949                else
    950950                    error(new ProgramError("Unrecognized keyword argument " +
    951                                             args[1].writeToString() + "."));
     951                                            args[1].princToString() + "."));
    952952            }
    953953            return new LispThread(checkFunction(args[0]), name);
  • trunk/abcl/src/org/armedbear/lisp/Load.java

    r13353 r13440  
    289289        // Look for a init FASL inside a packed FASL
    290290        if (truename != null
    291             && truename.type.writeToString().equals(COMPILE_FILE_TYPE) && Utilities.checkZipFile(truename))  {
     291            && truename.type.princToString().equals(COMPILE_FILE_TYPE) && Utilities.checkZipFile(truename))  {
    292292            Pathname init = new Pathname(truename.getNamestring());
    293293            init.type = COMPILE_FILE_INIT_FASL_TYPE;
     
    417417            return
    418418                error(new SimpleError("FASL version mismatch; found '"
    419                         + second.writeToString() + "' but expected '"
    420                         + _FASL_VERSION_.getSymbolValue().writeToString()
     419                        + second.princToString() + "' but expected '"
     420                        + _FASL_VERSION_.getSymbolValue().princToString()
    421421                        + "' in "
    422                         + Symbol.LOAD_PATHNAME.symbolValue(thread).writeToString()));
     422                        + Symbol.LOAD_PATHNAME.symbolValue(thread).princToString()));
    423423        }
    424424    }
     
    526526                out._writeString(prefix);
    527527                out._writeString(auto ? " Autoloading " : " Loading ");
    528                 out._writeString(!truename.equals(NIL) ? truePathname.writeToString() : "stream");
     528                out._writeString(!truename.equals(NIL) ? truePathname.princToString() : "stream");
    529529                out._writeLine(" ...");
    530530                out._finishOutput();
     
    534534                out._writeString(prefix);
    535535                out._writeString(auto ? " Autoloaded " : " Loaded ");
    536                 out._writeString(!truename.equals(NIL) ? truePathname.writeToString() : "stream");
     536                out._writeString(!truename.equals(NIL) ? truePathname.princToString() : "stream");
    537537                out._writeString(" (");
    538538                out._writeString(String.valueOf(((float)elapsed)/1000));
     
    577577                    Stream out =
    578578                        checkCharacterOutputStream(Symbol.STANDARD_OUTPUT.symbolValue(thread));
    579                     out._writeLine(result.writeToString());
     579                    out._writeLine(result.printObject());
    580580                    out._finishOutput();
    581581                }
  • trunk/abcl/src/org/armedbear/lisp/LogicalPathname.java

    r12431 r13440  
    216216                sb.append(';');
    217217            else
    218                 error(new FileError("Unsupported directory component " + part.writeToString() + ".",
     218                error(new FileError("Unsupported directory component " + part.princToString() + ".",
    219219                                     this));
    220220            temp = temp.cdr();
     
    230230                    sb.append("..");
    231231                else
    232                     error(new FileError("Unsupported directory component " + part.writeToString() + ".",
     232                    error(new FileError("Unsupported directory component " + part.princToString() + ".",
    233233                                         this));
    234234                sb.append(';');
     
    240240
    241241    @Override
    242     public String writeToString()
     242    public String printObject()
    243243    {
    244244        final LispThread thread = LispThread.currentThread();
  • trunk/abcl/src/org/armedbear/lisp/MacroObject.java

    r12288 r13440  
    130130
    131131  @Override
    132   public String writeToString()
     132  public String printObject()
    133133  {
    134134    return unreadableString("MACRO-OBJECT");
  • trunk/abcl/src/org/armedbear/lisp/MathFunctions.java

    r12940 r13440  
    668668            else
    669669                return error(new LispError("EXPT: unsupported case: base is of type " +
    670                                             base.typeOf().writeToString()));
     670                                            base.typeOf().princToString()));
    671671
    672672            if (power instanceof Fixnum)
     
    682682            else
    683683                return error(new LispError("EXPT: unsupported case: power is of type " +
    684                                             power.typeOf().writeToString()));
     684                                            power.typeOf().princToString()));
    685685            double r = Math.pow(x, y);
    686686            if (Double.isNaN(r)) {
  • trunk/abcl/src/org/armedbear/lisp/Package.java

    r13135 r13440  
    847847
    848848    @Override
    849     public String writeToString()
     849    public String printObject()
    850850    {
    851851        if (_PRINT_FASL_.symbolValue() != NIL && name != null) {
  • trunk/abcl/src/org/armedbear/lisp/PackageFunctions.java

    r12290 r13440  
    343343                    Package p = Packages.findPackage(string.getStringValue());
    344344                    if (p == null)
    345                         return error(new LispError(obj.writeToString() +
     345                        return error(new LispError(obj.princToString() +
    346346                                                    " is not the name of a package."));
    347347                    pkg.usePackage(p);
  • trunk/abcl/src/org/armedbear/lisp/Pathname.java

    r13358 r13440  
    774774            } else {
    775775                error(new FileError("Unsupported directory component "
    776                   + part.writeToString() + ".",
     776                  + part.printObject() + ".",
    777777                  this));
    778778            }
     
    788788                    sb.append("..");
    789789                } else {
    790                     error(new FileError("Unsupported directory component " + part.writeToString() + ".",
     790                    error(new FileError("Unsupported directory component " + part.princToString() + ".",
    791791                      this));
    792792                }
     
    887887
    888888    @Override
    889     public String writeToString() {
     889    public String printObject() {
    890890        final LispThread thread = LispThread.currentThread();
    891891        final boolean printReadably = (Symbol.PRINT_READABLY.symbolValue(thread) != NIL);
     
    940940        if (host != NIL) {
    941941            sb.append(":HOST ");
    942             sb.append(host.writeToString());
     942            sb.append(host.printObject());
    943943            sb.append(" ");
    944944        }
    945945        if (device != NIL) {
    946946            sb.append(":DEVICE ");
    947             sb.append(device.writeToString());
     947            sb.append(device.printObject());
    948948            sb.append(" ");
    949949        }
    950950        if (directory != NIL) {
    951951            sb.append(":DIRECTORY ");
    952             sb.append(directory.writeToString());
     952            sb.append(directory.printObject());
    953953            sb.append(" ");
    954954        }
    955955        if (name != NIL) {
    956956            sb.append(":NAME ");
    957             sb.append(name.writeToString());
     957            sb.append(name.printObject());
    958958            sb.append(" ");
    959959        }
    960960        if (type != NIL) {
    961961            sb.append(":TYPE ");
    962             sb.append(type.writeToString());
     962            sb.append(type.printObject());
    963963            sb.append(" ");
    964964        }
    965965        if (version != NIL) {
    966966            sb.append(":VERSION ");
    967             sb.append(version.writeToString());
     967            sb.append(version.printObject());
    968968            sb.append(" ");
    969969        }
     
    10681068            return new LogicalPathname(host.getStringValue(), s);
    10691069        }
    1070         error(new LispError(host.writeToString() + " is not defined as a logical pathname host."));
     1070        error(new LispError(host.princToString() + " is not defined as a logical pathname host."));
    10711071        // Not reached.
    10721072        return null;
     
    11851185            if (namestring == null) {
    11861186                error(new SimpleError("Pathname has no namestring: "
    1187                                       + pathname.writeToString()));
     1187                                      + pathname.princToString()));
    11881188            }
    11891189            return new SimpleString(namestring);
     
    13751375            if (LOGICAL_PATHNAME_TRANSLATIONS.get(logicalHost) == null) {
    13761376                // Not a defined logical pathname host -- A UNC path
    1377                 //warning(new LispError(host.writeToString() + " is not defined as a logical pathname host."));
     1377                //warning(new LispError(host.printObject() + " is not defined as a logical pathname host."));
    13781378                p = new Pathname();
    13791379                logical = false;
     
    14161416                    p.directory = directory;
    14171417                } else {
    1418                     error(new LispError("Invalid directory component for logical pathname: " + directory.writeToString()));
     1418                    error(new LispError("Invalid directory component for logical pathname: " + directory.princToString()));
    14191419                }
    14201420            } else {
     
    14691469                    if (signalError) {
    14701470                        StringBuilder sb = new StringBuilder();
    1471                         sb.append(first.writeToString());
     1471                        sb.append(first.printObject());
    14721472                        sb.append(" may not be followed immediately by ");
    1473                         sb.append(second.writeToString());
     1473                        sb.append(second.printObject());
    14741474                        sb.append('.');
    14751475                        error(new FileError(sb.toString(), this));
     
    16311631                        }
    16321632                    } catch (IOException e) {
    1633                         return error(new FileError("Unable to list directory " + pathname.writeToString() + ".",
     1633                        return error(new FileError("Unable to list directory " + pathname.princToString() + ".",
    16341634                                                   pathname));
    16351635                    } catch (SecurityException e) {
     
    18081808            while (true) {
    18091809                if (d.car() instanceof AbstractString) {
    1810                     String s = d.car().writeToString();
     1810                    String s = d.car().printObject();
    18111811                    if (s.contains("*")) {
    18121812                        return true;
     
    18231823        }
    18241824        if (name instanceof AbstractString) {
    1825             if (name.writeToString().contains("*")) {
     1825            if (name.printObject().contains("*")) {
    18261826                return true;
    18271827            }
     
    18311831        }
    18321832        if (type instanceof AbstractString) {
    1833             if (type.writeToString().contains("*")) {
     1833            if (type.printObject().contains("*")) {
    18341834                return true;
    18351835            }
     
    18831883            } else {
    18841884                return error(new ProgramError("Unrecognized keyword "
    1885                                               + second.writeToString() + "."));
     1885                                              + second.princToString() + "."));
    18861886            }
    18871887            if (value == Keyword.WILD || value == Keyword.WILD_INFERIORS) {
     
    21272127            if (namestring == null) {
    21282128                return error(new FileError("Pathname has no namestring: "
    2129                                            + pathname.writeToString(),
     2129                                           + pathname.princToString(),
    21302130                                           pathname));
    21312131            }
     
    22322232        if (errorIfDoesNotExist) {
    22332233            StringBuilder sb = new StringBuilder("The file ");
    2234             sb.append(pathname.writeToString());
     2234            sb.append(pathname.princToString());
    22352235            sb.append(" does not exist.");
    22362236            return error(new FileError(sb.toString(), pathname));
     
    24622462            }
    24632463            return error(new FileError("Unable to rename "
    2464                                        + original.writeToString()
    2465                                        + " to " + newName.writeToString()
     2464                                       + original.princToString()
     2465                                       + " to " + newName.princToString()
    24662466                                       + "."));
    24672467        }
  • trunk/abcl/src/org/armedbear/lisp/Primitives.java

    r13409 r13440  
    678678            value = checkSymbol(arg).symbolValue();
    679679            if (value instanceof SymbolMacro)
    680                 return error(new LispError(arg.writeToString() +
     680                return error(new LispError(arg.princToString() +
    681681                                           " has no dynamic value."));
    682682            return value;
     
    885885
    886886        {
    887             checkStream(second)._writeString(first.writeToString());
     887            checkStream(second)._writeString(first.printObject());
    888888            return first;
    889889        }
     
    908908            else
    909909                out = second;
    910             String output = first.writeToString();
     910            String output = first.printObject();
    911911            if (Symbol.PRINT_READABLY.symbolValue(LispThread.currentThread()) != NIL
    912912                && output.contains("#<")) {
     
    935935        @Override
    936936        public LispObject execute(LispObject arg) {
    937             return new SimpleString(arg.writeToString());
     937            return new SimpleString(arg.printObject());
    938938        }
    939939    };
     
    15971597
    15981598            if (args.length == 1 && args[0] instanceof Condition) {
    1599                 System.out.println(args[0].writeToString());
     1599                System.out.println(args[0].princToString());
    16001600                System.out.println(((Condition)args[0]).getConditionReport());
    16011601            } else
    16021602            for (LispObject a : args)
    1603                 System.out.println(a.writeToString());
     1603                System.out.println(a.princToString());
    16041604
    16051605            throw e;
     
    17341734                }
    17351735                error(new TypeError("The value " +
    1736                                     destination.writeToString() +
     1736                                    destination.princToString() +
    17371737                                    " is not a character output stream."));
    17381738            }
     
    24242424            } else {
    24252425                return error(new TypeError("The value " +
    2426                                            first.writeToString() +
     2426                                           first.princToString() +
    24272427                                           " is not an array of rank 0."));
    24282428            }
     
    32633263                        Package p = Packages.findPackage(s);
    32643264                        if (p == null) {
    3265                             error(new LispError(obj.writeToString() +
     3265                            error(new LispError(obj.princToString() +
    32663266                                                " is not the name of a package."));
    32673267                            return NIL;
     
    32883288                    Package p = Packages.findPackage(s);
    32893289                    if (p == null) {
    3290                         error(new LispError(obj.writeToString() +
     3290                        error(new LispError(obj.princToString() +
    32913291                                            " is not the name of a package."));
    32923292                        return NIL;
     
    37143714            if (binding == null)
    37153715                return error(new ControlError("No tag named " +
    3716                                               args.car().writeToString() +
     3716                                              args.car().princToString() +
    37173717                                              " is currently visible."));
    37183718
     
    40154015                function = obj;
    40164016            } else {
    4017                 error(new LispError(obj.writeToString() +
     4017                error(new LispError(obj.princToString() +
    40184018                                    " is not a function name."));
    40194019                return NIL;
  • trunk/abcl/src/org/armedbear/lisp/PrintNotReadable.java

    r12431 r13440  
    8686        object = getInstanceSlotValue(Symbol.OBJECT);
    8787        if (object != UNBOUND_VALUE) {
    88             final LispThread thread = LispThread.currentThread();
    89             final SpecialBindingsMark mark = thread.markSpecialBindings();
    90             thread.bindSpecial(Symbol.PRINT_READABLY, NIL);
    91             thread.bindSpecial(Symbol.PRINT_ARRAY, NIL);
    92             try {
    93                 sb.append(object.writeToString());
    94             }
    95             finally {
    96                 thread.resetSpecialBindings(mark);
    97             }
     88            sb.append(object.princToString());
    9889        } else
    9990            sb.append("Object");
  • trunk/abcl/src/org/armedbear/lisp/RandomState.java

    r13406 r13440  
    9292
    9393    @Override
    94     public String writeToString()
     94    public String printObject()
    9595    {
    9696        return unreadableString(Symbol.RANDOM_STATE);
  • trunk/abcl/src/org/armedbear/lisp/Ratio.java

    r12951 r13440  
    554554
    555555    @Override
    556     public String writeToString()
     556    public String printObject()
    557557    {
    558558        final LispThread thread = LispThread.currentThread();
  • trunk/abcl/src/org/armedbear/lisp/Readtable.java

    r12749 r13440  
    292292      {
    293293        LispCharacter c = LispCharacter.getInstance(dispChar);
    294         return error(new LispError(c.writeToString() +
     294        return error(new LispError(c.princToString() +
    295295                                    " is not a dispatch character."));
    296296      }
     
    308308      {
    309309        LispCharacter c = LispCharacter.getInstance(dispChar);
    310         error(new LispError(c.writeToString() +
     310        error(new LispError(c.princToString() +
    311311                             " is not a dispatch character."));
    312312      }
     
    427427          designator = second;
    428428        else
    429           return error(new LispError(second.writeToString() +
     429          return error(new LispError(second.princToString() +
    430430                                      " does not designate a function."));
    431431        byte syntaxType;
  • trunk/abcl/src/org/armedbear/lisp/Return.java

    r12431 r13440  
    7373    {
    7474        StringBuilder sb = new StringBuilder("No block named ");
    75         sb.append(tag.writeToString());
     75        sb.append(tag.princToString());
    7676        sb.append(" is currently visible.");
    7777        return new ControlError(sb.toString());
  • trunk/abcl/src/org/armedbear/lisp/ShellCommand.java

    r12803 r13440  
    260260                    namestring = pathname.getNamestring();
    261261                    if (namestring == null) {
    262                         return error(new FileError("Pathname has no namestring: " + pathname.writeToString(),
     262                        return error(new FileError("Pathname has no namestring: " + pathname.princToString(),
    263263                                                    pathname));
    264264                    }
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_T.java

    r12431 r13440  
    320320
    321321  @Override
    322   public String writeToString()
     322  public String printObject()
    323323  {
    324324    return writeToString(dimv);
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte16.java

    r12288 r13440  
    292292
    293293    @Override
    294     public String writeToString()
     294    public String printObject()
    295295    {
    296296        if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte32.java

    r12288 r13440  
    282282
    283283    @Override
    284     public String writeToString()
     284    public String printObject()
    285285    {
    286286        if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
  • trunk/abcl/src/org/armedbear/lisp/SimpleArray_UnsignedByte8.java

    r12288 r13440  
    279279
    280280    @Override
    281     public String writeToString()
     281    public String printObject()
    282282    {
    283283        if (Symbol.PRINT_READABLY.symbolValue() != NIL) {
  • trunk/abcl/src/org/armedbear/lisp/SingleFloat.java

    r12951 r13440  
    562562
    563563    @Override
    564     public String writeToString()
     564    public String printObject()
    565565    {
    566566        if (value == Float.POSITIVE_INFINITY) {
    567567            StringBuffer sb = new StringBuffer("#.");
    568             sb.append(Symbol.SINGLE_FLOAT_POSITIVE_INFINITY.writeToString());
     568            sb.append(Symbol.SINGLE_FLOAT_POSITIVE_INFINITY.printObject());
    569569            return sb.toString();
    570570        }
    571571        if (value == Float.NEGATIVE_INFINITY) {
    572572            StringBuffer sb = new StringBuffer("#.");
    573             sb.append(Symbol.SINGLE_FLOAT_NEGATIVE_INFINITY.writeToString());
     573            sb.append(Symbol.SINGLE_FLOAT_NEGATIVE_INFINITY.printObject());
    574574            return sb.toString();
    575575        }
     
    641641        if (obj instanceof Ratio)
    642642            return new SingleFloat(((Ratio)obj).floatValue());
    643         error(new TypeError("The value " + obj.writeToString() +
     643        error(new TypeError("The value " + obj.princToString() +
    644644                             " cannot be converted to type SINGLE-FLOAT."));
    645645        // Not reached.
  • trunk/abcl/src/org/armedbear/lisp/SlotDefinition.java

    r13273 r13440  
    117117
    118118  @Override
    119   public String writeToString()
     119  public String printObject()
    120120  {
    121121    StringBuilder sb =
    122       new StringBuilder(Symbol.SLOT_DEFINITION.writeToString());
     122      new StringBuilder(Symbol.SLOT_DEFINITION.printObject());
    123123    LispObject name = slots[SlotDefinitionClass.SLOT_INDEX_NAME];
    124124    if (name != null && name != NIL)
    125125      {
    126126        sb.append(' ');
    127         sb.append(name.writeToString());
     127        sb.append(name.printObject());
    128128      }
    129129    return unreadableString(sb.toString());
  • trunk/abcl/src/org/armedbear/lisp/SpecialOperator.java

    r12288 r13440  
    147147
    148148    @Override
    149     public String writeToString()
     149    public String printObject()
    150150    {
    151151        StringBuffer sb = new StringBuffer("#<SPECIAL-OPERATOR ");
    152         sb.append(lambdaName.writeToString());
     152        sb.append(lambdaName.princToString());
    153153        sb.append(">");
    154154        return sb.toString();
  • trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java

    r12513 r13440  
    142142                        return error(new LispError("The " + (sequential ? "LET*" : "LET")
    143143                                                   + " binding specification " +
    144                                                    obj.writeToString() + " is invalid."));
     144                                                   obj.princToString() + " is invalid."));
    145145                    symbol = checkSymbol(((Cons)obj).car);
    146146                    value = eval(obj.cadr(), sequential ? ext : env, thread);
     
    202202                            return error(new ProgramError(
    203203                                             "Attempt to bind the special variable " +
    204                                              symbol.writeToString() +
     204                                             symbol.princToString() +
    205205                                             " with SYMBOL-MACROLET."));
    206206                        }
     
    209209                        return error(new ProgramError(
    210210                                         "Malformed symbol-expansion pair in SYMBOL-MACROLET: " +
    211                                          obj.writeToString()));
     211                                         obj.princToString()));
    212212                    }
    213213                }
     
    520520                Symbol symbol = checkSymbol(args.car());
    521521                if (symbol.isConstant()) {
    522                     return error(new ProgramError(symbol.writeToString() +
     522                    return error(new ProgramError(symbol.princToString() +
    523523                                                  " is a constant and thus cannot be set."));
    524524                }
  • trunk/abcl/src/org/armedbear/lisp/StandardClass.java

    r13273 r13440  
    140140        LispThread.currentThread().printBacktrace();
    141141        return (Layout)Lisp.error(Symbol.TYPE_ERROR,
    142                 new SimpleString("The value " + layout.writeToString()
    143                     + " is not of expected type " + Symbol.LAYOUT.writeToString()
    144                     + " in class " + this.writeToString() + "."));
     142                new SimpleString("The value " + layout.princToString()
     143                    + " is not of expected type " + Symbol.LAYOUT.princToString()
     144                    + " in class " + this.princToString() + "."));
    145145      }
    146146   
     
    321321
    322322  @Override
    323   public String writeToString()
     323  public String printObject()
    324324  {
    325325    StringBuilder sb =
    326       new StringBuilder(Symbol.STANDARD_CLASS.writeToString());
     326      new StringBuilder(Symbol.STANDARD_CLASS.printObject());
    327327    if (getName() != null)
    328328      {
    329329        sb.append(' ');
    330         sb.append(getName().writeToString());
     330        sb.append(getName().printObject());
    331331      }
    332332    return unreadableString(sb.toString());
  • trunk/abcl/src/org/armedbear/lisp/StandardGenericFunction.java

    r12954 r13440  
    204204
    205205  @Override
    206   public String writeToString()
     206  public String printObject()
    207207  {
    208208    LispObject name = getGenericFunctionName();
     
    217217          className = Symbol.CLASS_NAME.execute(lispClass);
    218218
    219         sb.append(className.writeToString());
     219        sb.append(className.princToString());
    220220        sb.append(' ');
    221         sb.append(name.writeToString());
     221        sb.append(name.princToString());
    222222        return unreadableString(sb.toString());
    223223      }
    224     return super.writeToString();
     224    return super.printObject();
    225225  }
    226226
  • trunk/abcl/src/org/armedbear/lisp/StandardMethod.java

    r12576 r13440  
    146146
    147147  @Override
    148   public String writeToString()
     148  public String printObject()
    149149  {
    150150    LispObject genericFunction =
     
    164164              className = Symbol.CLASS_NAME.execute(lispClass);
    165165
    166             sb.append(className.writeToString());
     166            sb.append(className.printObject());
    167167            sb.append(' ');
    168             sb.append(name.writeToString());
     168            sb.append(name.printObject());
    169169            LispObject specializers =
    170170              slots[StandardMethodClass.SLOT_INDEX_SPECIALIZERS];
     
    183183                  }
    184184                sb.append(' ');
    185                 sb.append(names.nreverse().writeToString());
     185                sb.append(names.nreverse().printObject());
    186186              }
    187187            return unreadableString(sb.toString());
    188188          }
    189189      }
    190     return super.writeToString();
     190    return super.printObject();
    191191  }
    192192
  • trunk/abcl/src/org/armedbear/lisp/StandardObject.java

    r13399 r13440  
    197197
    198198  @Override
    199   public String writeToString()
     199  public String printObject()
    200200  {
    201201    final LispThread thread = LispThread.currentThread();
     
    209209    if (currentLevel >= maxLevel)
    210210      return "#";
    211     return unreadableString(typeOf().writeToString());
     211    return unreadableString(typeOf().printObject());
    212212  }
    213213
     
    305305    //### FIXME: should call SLOT-MISSING (clhs)
    306306    if (index < 0)
    307       return error(new LispError("Missing slot " + slotName.writeToString()));
     307      return error(new LispError("Missing slot " + slotName.princToString()));
    308308    return slots[index];
    309309  }
     
    323323    //### FIXME: should call SLOT-MISSING (clhs)
    324324    if (index < 0)
    325       error(new LispError("Missing slot " + slotName.writeToString()));
     325      error(new LispError("Missing slot " + slotName.princToString()));
    326326    slots[index] = newValue;
    327327  }
  • trunk/abcl/src/org/armedbear/lisp/StandardObjectFunctions.java

    r13201 r13440  
    5252            LispObject l = Symbol.CLASS_LAYOUT.execute(arg);
    5353            if (! (l instanceof Layout))
    54                 return error(new ProgramError("Invalid standard class layout for: " + arg.writeToString()));
     54                return error(new ProgramError("Invalid standard class layout for: " + arg.princToString()));
    5555           
    5656            return new StandardObject((Layout)l);
  • trunk/abcl/src/org/armedbear/lisp/Stream.java

    r13178 r13440  
    577577            if ((length % 2) != 0)
    578578                return error(new ReaderError("Odd number of keyword arguments following #S: " +
    579                                              obj.writeToString(),
     579                                             obj.princToString(),
    580580                                             this));
    581581            LispObject[] array = new LispObject[length];
     
    595595        }
    596596        return error(new ReaderError("Non-list following #S: " +
    597                                      obj.writeToString(),
     597                                     obj.princToString(),
    598598                                     this));
    599599    }
     
    667667                            if (!obj.listp())
    668668                                error(new ReaderError("The value " +
    669                                                       obj.writeToString() +
     669                                                      obj.princToString() +
    670670                                                      " is not of type " +
    671                                                       Symbol.LIST.writeToString() + ".",
     671                                                      Symbol.LIST.princToString() + ".",
    672672                                                      this));
    673673                        }
     
    930930            if (obj.listp() || obj instanceof AbstractVector)
    931931                return new SimpleVector(obj);
    932             return error(new ReaderError(obj.writeToString() + " is not a sequence.",
     932            return error(new ReaderError(obj.princToString() + " is not a sequence.",
    933933                                         this));
    934934        }
     
    961961        }
    962962        sb.append(": #C");
    963         sb.append(obj.writeToString());
     963        sb.append(obj.printObject());
    964964        return error(new ReaderError(sb.toString(), this));
    965965    }
     
    16201620        thread.bindSpecial(Symbol.PRINT_ESCAPE, T);
    16211621        try {
    1622             _writeString(obj.writeToString());
     1622            _writeString(obj.printObject());
    16231623        } finally {
    16241624            thread.resetSpecialBindings(mark);
     
    16721672            return number(arg.length());
    16731673        }
    1674         return error(new TypeError(arg.writeToString() +
     1674        return error(new TypeError(arg.princToString() +
    16751675                                   " is neither a string nor a character."));
    16761676    }
     
    19721972
    19731973    protected LispObject streamNotInputStream() {
    1974         return error(new StreamError(this, writeToString() + " is not an input stream."));
     1974        return error(new StreamError(this, princToString() + " is not an input stream."));
    19751975    }
    19761976
    19771977    protected LispObject streamNotCharacterInputStream() {
    1978         return error(new StreamError(this, writeToString() + " is not a character input stream."));
     1978        return error(new StreamError(this, princToString() + " is not a character input stream."));
    19791979    }
    19801980
    19811981    protected LispObject streamNotOutputStream() {
    1982         return error(new StreamError(this, writeToString() + " is not an output stream."));
     1982        return error(new StreamError(this, princToString() + " is not an output stream."));
    19831983    }
    19841984
    19851985    protected LispObject streamNotBinaryOutputStream() {
    1986         return error(new StreamError(this, writeToString() + " is not a binary output stream."));
     1986        return error(new StreamError(this, princToString() + " is not a binary output stream."));
    19871987    }
    19881988
    19891989    protected LispObject streamNotCharacterOutputStream() {
    1990         return error(new StreamError(this, writeToString() + " is not a character output stream."));
     1990        return error(new StreamError(this, princToString() + " is not a character output stream."));
    19911991    }
    19921992
     
    21312131                return stream.close(third);
    21322132            return error(new ProgramError("Unrecognized keyword argument " +
    2133                                           second.writeToString() + "."));
     2133                                          second.princToString() + "."));
    21342134        }
    21352135    };
  • trunk/abcl/src/org/armedbear/lisp/StructureClass.java

    r12513 r13440  
    7373    public LispObject getDescription()
    7474    {
    75         return new SimpleString(writeToString());
     75        return new SimpleString(princToString());
    7676    }
    7777
    7878    @Override
    79     public String writeToString()
     79    public String printObject()
    8080    {
    8181        StringBuffer sb = new StringBuffer("#<STRUCTURE-CLASS ");
    82         sb.append(getName().writeToString());
     82        sb.append(getName().princToString());
    8383        sb.append('>');
    8484        return sb.toString();
  • trunk/abcl/src/org/armedbear/lisp/StructureObject.java

    r12756 r13440  
    422422  {
    423423    StringBuilder sb = new StringBuilder("Invalid slot index ");
    424     sb.append(Fixnum.getInstance(n).writeToString());
     424    sb.append(Fixnum.getInstance(n).princToString());
    425425    sb.append(" for ");
    426     sb.append(writeToString());
     426    sb.append(princToString());
    427427    return error(new LispError(sb.toString()));
    428428  }
     
    450450
    451451  @Override
    452   public String writeToString()
     452  public String printObject()
    453453  {
    454454    try
     
    465465          }
    466466        if (_PRINT_STRUCTURE_.symbolValue(thread) == NIL)
    467           return unreadableString(structureClass.getName().writeToString());
     467          return unreadableString(structureClass.getName().printObject());
    468468        int maxLevel = Integer.MAX_VALUE;
    469469        LispObject printLevel = Symbol.PRINT_LEVEL.symbolValue(thread);
     
    476476          return "#";
    477477        StringBuilder sb = new StringBuilder("#S(");
    478         sb.append(structureClass.getName().writeToString());
     478        sb.append(structureClass.getName().printObject());
    479479        if (currentLevel < maxLevel)
    480480          {
     
    508508                  }
    509509                else
    510                   sb.append(slots[i].writeToString());
     510                  sb.append(slots[i].printObject());
    511511              }
    512512            if (limit < slots.length)
  • trunk/abcl/src/org/armedbear/lisp/Symbol.java

    r13369 r13440  
    131131      {
    132132        StringBuilder sb = new StringBuilder("The symbol ");
    133         sb.append(name.writeToString());
     133        sb.append(name.princToString());
    134134        sb.append(" at #x");
    135135        sb.append(Integer.toHexString(System.identityHashCode(this)).toUpperCase());
     
    301301    if (isConstant())
    302302      // Complement the check already done in SpecialOperators.sf_setq
    303       error(new ProgramError("Can't change value of constant symbol " + writeToString() + "."));
     303      error(new ProgramError("Can't change value of constant symbol " + princToString() + "."));
    304304    this.value = value;
    305305  }
     
    446446
    447447  @Override
    448   public String writeToString()
     448  public String printObject()
    449449  {
    450450    final String n = name.getStringValue();
  • trunk/abcl/src/org/armedbear/lisp/SynonymStream.java

    r12513 r13440  
    216216
    217217    @Override
    218     public String writeToString()
     218    public String printObject()
    219219    {
    220220        StringBuffer sb = new StringBuffer("SYNONYM-STREAM ");
    221         sb.append(symbol.writeToString());
     221        sb.append(symbol.printObject());
    222222        return unreadableString(sb.toString());
    223223    }
  • trunk/abcl/src/org/armedbear/lisp/Throw.java

    r12298 r13440  
    5858    {
    5959        return new ControlError("Attempt to throw to the nonexistent tag " +
    60                                 tag.writeToString() + ".");
     60                                tag.princToString() + ".");
    6161    }
    6262}
  • trunk/abcl/src/org/armedbear/lisp/TwoWayStream.java

    r12362 r13440  
    215215
    216216    @Override
    217     public String writeToString()
     217    public String printObject()
    218218    {
    219219        return unreadableString(Symbol.TWO_WAY_STREAM);
  • trunk/abcl/src/org/armedbear/lisp/TypeError.java

    r12431 r13440  
    140140            final LispObject expectedType = getExpectedType();
    141141            StringBuilder sb = new StringBuilder();
    142             String name = datum != null ? datum.writeToString() : null;
     142            String name = datum != null ? datum.princToString() : null;
    143143            String type = null;
    144144            if (expectedType != null)
    145                 type = expectedType.writeToString();
     145                type = expectedType.princToString();
    146146            if (type != null) {
    147147                if (name != null) {
  • trunk/abcl/src/org/armedbear/lisp/URLStream.java

    r13405 r13440  
    136136
    137137    @Override
    138     public String writeToString()
     138    public String printObject()
    139139    {
    140140        StringBuffer sb = new StringBuffer();
    141         sb.append(Symbol.URL_STREAM.writeToString());
     141        sb.append(Symbol.URL_STREAM.printObject());
    142142        String namestring = pathname.getNamestring();
    143143        if (namestring != null) {
  • trunk/abcl/src/org/armedbear/lisp/UnboundSlot.java

    r12431 r13440  
    7777        try {
    7878            StringBuilder sb = new StringBuilder("The slot ");
    79             sb.append(getCellName().writeToString());
     79            sb.append(getCellName().princToString());
    8080            sb.append(" is unbound in the object ");
    81             sb.append(getInstance().writeToString());
     81            sb.append(getInstance().princToString());
    8282            sb.append('.');
    8383            return sb.toString();
  • trunk/abcl/src/org/armedbear/lisp/UnboundVariable.java

    r12298 r13440  
    5656    StringBuffer sb = new StringBuffer("The variable ");
    5757    try {
    58         sb.append(getCellName().writeToString());
     58        sb.append(getCellName().princToString());
    5959    }
    6060    finally {
  • trunk/abcl/src/org/armedbear/lisp/UndefinedFunction.java

    r12431 r13440  
    7474  {
    7575    StringBuilder sb = new StringBuilder("The function ");
    76     sb.append(getCellName().writeToString());
     76    sb.append(getCellName().princToString());
    7777    sb.append(" is undefined.");
    7878    return sb.toString();
  • trunk/abcl/src/org/armedbear/lisp/Utilities.java

    r13056 r13440  
    105105        if (namestring != null)
    106106            return new File(namestring);
    107         error(new FileError("Pathname has no namestring: " + merged.writeToString(),
     107        error(new FileError("Pathname has no namestring: " + merged.princToString(),
    108108                             merged));
    109109        // Not reached.
  • trunk/abcl/src/org/armedbear/lisp/WeakHashTable.java

    r13405 r13440  
    316316
    317317    @Override
    318     public String writeToString() {
     318    public String printObject() {
    319319        if (Symbol.PRINT_READABLY.symbolValue(LispThread.currentThread()) != NIL) {
    320320            error(new PrintNotReadable(list(Keyword.OBJECT, this)));
    321321            return null; // Not reached.
    322322        }
    323         StringBuilder sb = new StringBuilder(getTest().writeToString());
     323        StringBuilder sb = new StringBuilder(getTest().princToString());
    324324        sb.append(' ');
    325         sb.append(Symbol.HASH_TABLE.writeToString());
     325        sb.append(Symbol.HASH_TABLE.princToString());
    326326        sb.append(' ');
    327327        if (bucketType instanceof HashEntryWeakKey) {
  • trunk/abcl/src/org/armedbear/lisp/WeakReference.java

    r13405 r13440  
    5454
    5555    @Override
    56     public String writeToString() {
     56    public String printObject() {
    5757        return unreadableString("WEAK-REFERENCE "
    5858                + toString());
  • trunk/abcl/src/org/armedbear/lisp/WrongNumberOfArgumentsException.java

    r13259 r13440  
    7777        if (lambdaName != null && lambdaName != NIL) {
    7878            sb.append(" for ");
    79             sb.append(operator.getLambdaName().writeToString());
     79            sb.append(operator.getLambdaName().princToString());
    8080        }
    8181  if(expectedArgs >= 0) {
  • trunk/abcl/src/org/armedbear/lisp/ZeroRankArray.java

    r12288 r13440  
    135135
    136136    @Override
    137     public String writeToString()
     137    public String printObject()
    138138    {
    139139        final LispThread thread = LispThread.currentThread();
     
    154154                sb.append(stream.getString().getStringValue());
    155155            } else
    156                 sb.append(data.writeToString());
     156                sb.append(data.printObject());
    157157            return sb.toString();
    158158        }
     
    161161            sb.append("SIMPLE-");
    162162        sb.append("ARRAY ");
    163         sb.append(elementType.writeToString());
     163        sb.append(elementType.printObject());
    164164        sb.append(" NIL");
    165165        return unreadableString(sb.toString());
  • trunk/abcl/src/org/armedbear/lisp/delete_file.java

    r12448 r13440  
    6666        final String namestring = defaultedPathname.getNamestring();
    6767        if (namestring == null)
    68             return error(new FileError("Pathname has no namestring: " + defaultedPathname.writeToString(),
     68            return error(new FileError("Pathname has no namestring: " + defaultedPathname.princToString(),
    6969                                        defaultedPathname));
    7070        final File file = new File(namestring);
     
    8181            StringBuilder sb = new StringBuilder("Unable to delete ");
    8282            sb.append(file.isDirectory() ? "directory " : "file ");
    83             sb.append(truename.writeToString());
     83            sb.append(truename.princToString());
    8484            sb.append('.');
    8585            return error(new FileError(sb.toString(), truename));
  • trunk/abcl/src/org/armedbear/lisp/jclass_name.java

    r12288 r13440  
    6767            // Fall through.
    6868        }
    69         return error(new LispError(arg.writeToString() + " does not designate a Java class."));
     69        return error(new LispError(arg.princToString() + " does not designate a Java class."));
    7070    }
    7171
     
    8989        }
    9090        if (className == null)
    91             return error(new LispError(first.writeToString() + " does not designate a Java class."));
     91            return error(new LispError(first.princToString() + " does not designate a Java class."));
    9292        final AbstractString name = checkString(second);
    9393        return LispThread.currentThread().setValues(name.getStringValue().equals(className) ? T : NIL,
  • trunk/abcl/src/org/armedbear/lisp/jmethod_return_type.java

    r12288 r13440  
    5656            return new JavaObject(((Method)method).getReturnType());
    5757        }
    58         return error(new LispError(arg.writeToString() + " does not designate a Java method."));
     58        return error(new LispError(arg.princToString() + " does not designate a Java method."));
    5959    }
    6060
  • trunk/abcl/src/org/armedbear/lisp/jvm-class-file.lisp

    r13435 r13440  
    904904  attribute)
    905905
    906 (defun method-add-code (method)
     906(defun method-add-code (method &optional (optimize t))
    907907  "Creates an (empty) 'Code' attribute for the method,
    908908returning the created attribute."
     
    911911   (make-code-attribute (+ (length (cdr (method-descriptor method)))
    912912                           (if (member :static (method-access-flags method))
    913                                0 1))))) ;; 1 == implicit 'this'
    914 
    915 (defun method-ensure-code (method)
     913                               0 1)) ;; 1 == implicit 'this'
     914      optimize)))
     915
     916(defun method-ensure-code (method &optional (optimize t))
    916917  "Ensures the existence of a 'Code' attribute for the method,
    917918returning the attribute."
    918919  (let ((code (method-attribute method "Code")))
    919920    (if (null code)
    920         (method-add-code method)
     921        (method-add-code method optimize)
    921922        code)))
    922923
     
    10031004  ;; labels contains offsets into the code array after it's finalized
    10041005  labels ;; an alist
    1005 
     1006  optimize
    10061007  (current-local 0)) ;; used for handling nested WITH-CODE-TO-METHOD blocks
    10071008
     
    10271028                            (mapcar #'exception-end-pc handlers)
    10281029                            (mapcar #'exception-handler-pc handlers))
    1029                      t)))
     1030                     (code-optimize code))))
    10301031    (invoke-callbacks :code-finalized class parent
    10311032                      (coerce c 'list) handlers)
     
    10871088  (write-attributes (code-attributes code) stream))
    10881089
    1089 (defun make-code-attribute (arg-count)
     1090(defun make-code-attribute (arg-count &optional optimize)
    10901091  "Creates an empty 'Code' attribute for a method which takes
    10911092`arg-count` parameters, including the implicit `this` parameter."
    1092   (%make-code-attribute :max-locals arg-count))
     1093  (%make-code-attribute :max-locals arg-count :optimize optimize))
    10931094
    10941095(defun code-add-attribute (code attribute)
     
    11931194       (when *current-code-attribute*
    11941195         (save-code-specials *current-code-attribute*))
    1195        (let* ((,m ,method)
    1196               (*method* ,m)
    1197               (,c (method-ensure-code ,method))
    1198               (*pool* (class-file-constants ,class-file))
    1199               (*code* (code-code ,c))
    1200               (*registers-allocated* (code-max-locals ,c))
    1201               (*register* (code-current-local ,c))
    1202               (*current-code-attribute* ,c))
    1203          ,@body
    1204          (setf (code-code ,c) *code*
    1205                (code-current-local ,c) *register*
    1206                (code-max-locals ,c) *registers-allocated*))
    1207        (when *current-code-attribute*
    1208          (restore-code-specials *current-code-attribute*)))))
     1196       (unwind-protect
     1197           (let* ((,m ,method)
     1198                  (*method* ,m)
     1199                  (,c (method-ensure-code ,method))
     1200                  (*pool* (class-file-constants ,class-file))
     1201                  (*code* (code-code ,c))
     1202                  (*registers-allocated* (code-max-locals ,c))
     1203                  (*register* (code-current-local ,c))
     1204                  (*current-code-attribute* ,c))
     1205             (unwind-protect
     1206                 ,@body
     1207               ;; in case of a RETURN-FROM or GO, save the current state
     1208               (setf (code-code ,c) *code*
     1209                     (code-current-local ,c) *register*
     1210                     (code-max-locals ,c) *registers-allocated*)))
     1211         ;; using the same line of reasoning, restore the outer-scope state
     1212         (when *current-code-attribute*
     1213           (restore-code-specials *current-code-attribute*))))))
    12091214
    12101215
  • trunk/abcl/src/org/armedbear/lisp/zip.java

    r13336 r13440  
    7373            if (zipfileNamestring == null)
    7474                return error(new SimpleError("Pathname has no namestring: " +
    75                                               zipfilePathname.writeToString()));
     75                                              zipfilePathname.princToString()));
    7676            ZipOutputStream out =
    7777                new ZipOutputStream(new FileOutputStream(zipfileNamestring));
     
    8686                    zipfile.delete();
    8787                    return error(new SimpleError("Pathname has no namestring: "
    88                                                  + pathname.writeToString()));
     88                                                 + pathname.princToString()));
    8989                }
    9090                File file = new File(namestring);
     
    110110            if (zipfileNamestring == null)
    111111                return error(new SimpleError("Pathname has no namestring: " +
    112                                               zipfilePathname.writeToString()));
     112                                              zipfilePathname.princToString()));
    113113            ZipOutputStream out =
    114114                new ZipOutputStream(new FileOutputStream(zipfileNamestring));
     
    127127                    zipfile.delete();
    128128                    return error(new SimpleError("Pathname has no namestring: " +
    129                                                   pathname.writeToString()));
     129                                                  pathname.princToString()));
    130130                }
    131131                String directory = "";
     
    200200        if (zipfileNamestring == null)
    201201            return error(new SimpleError("Pathname has no namestring: " +
    202                                          zipfilePathname.writeToString()));
     202                                         zipfilePathname.princToString()));
    203203        ZipOutputStream out = null;
    204204        try {
Note: See TracChangeset for help on using the changeset viewer.