Changeset 5897


Ignore:
Timestamp:
02/23/04 14:24:48 (17 years ago)
Author:
piso
Message:

String refactoring.

Location:
trunk/j/src/org/armedbear/lisp
Files:
25 edited

Legend:

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

    r5825 r5897  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: DisplacedArray.java,v 1.23 2004-02-14 18:52:50 piso Exp $
     5 * $Id: DisplacedArray.java,v 1.24 2004-02-23 14:24:46 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5252    {
    5353        if (dimv.length == 1) {
    54             if (array instanceof LispString)
     54            if (array instanceof AbstractString)
    5555                return Symbol.STRING;
    5656            if (array instanceof BitVector)
     
    226226    public String toString()
    227227    {
    228         if (array instanceof LispString) {
    229             LispString s = (LispString) array;
     228        if (array instanceof AbstractString) {
     229            AbstractString s = (AbstractString) array;
    230230            return s.toString(offset, offset + size);
    231231        }
  • trunk/j/src/org/armedbear/lisp/FillPointerOutputStream.java

    r5554 r5897  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: FillPointerOutputStream.java,v 1.6 2004-01-26 00:36:38 piso Exp $
     5 * $Id: FillPointerOutputStream.java,v 1.7 2004-02-23 14:24:46 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5959                final int limit = Math.min(cbuf.length, off + len);
    6060                for (int i = off; i < limit && fp < capacity; i++) {
    61                     string.set(fp, cbuf[i]);
     61                    try {
     62                        string.setChar(fp, cbuf[i]);
     63                    }
     64                    catch (ConditionThrowable t) {
     65                        // Shouldn't happen.
     66                        Debug.trace(t);
     67                    }
    6268                    ++fp;
    6369                }
  • trunk/j/src/org/armedbear/lisp/Function.java

    r5439 r5897  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Function.java,v 1.31 2004-01-10 15:57:38 piso Exp $
     5 * $Id: Function.java,v 1.32 2004-02-23 14:24:46 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4646    {
    4747        this(name);
    48         setArglist(new LispString(arglist));
     48        setArglist(new SimpleString(arglist));
    4949    }
    5050
     
    7171        index = 0;
    7272        if (arglist instanceof String)
    73             setArglist(new LispString(arglist));
     73            setArglist(new SimpleString(arglist));
    7474        if (name != null) {
    7575            Symbol symbol = pkg.intern(this.name);
  • trunk/j/src/org/armedbear/lisp/JHandler.java

    r5251 r5897  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: JHandler.java,v 1.6 2003-12-24 16:06:28 piso Exp $
     5 * $Id: JHandler.java,v 1.7 2004-02-23 14:24:46 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5858                }
    5959                LispObject lispAiVector = new Vector(lispAi);
    60                 LispString[] lispAs = new LispString[as.length];
     60                SimpleString[] lispAs = new SimpleString[as.length];
    6161                for (int i = 0; i < as.length; i++) {
    62                     lispAs[i] = new LispString(as[i]);
     62                    lispAs[i] = new SimpleString(as[i]);
    6363                }
    6464                LispObject lispAsVector = new Vector(lispAs);
     
    9999        }
    100100    };
    101    
     101
    102102    private static class Entry
    103103    {
     
    107107        Map entryTable;
    108108        String event;
    109        
     109
    110110        public Entry (Function handler, LispObject data, String event, Map entryTable)
    111111        {
  • trunk/j/src/org/armedbear/lisp/Java.java

    r5541 r5897  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Java.java,v 1.39 2004-01-24 22:56:00 asimon Exp $
     5 * $Id: Java.java,v 1.40 2004-02-23 14:24:46 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3636        public LispObject execute(LispObject arg) throws ConditionThrowable
    3737        {
    38             String className = LispString.getValue(arg);
     38            String className = arg.getStringValue();
    3939            try {
    4040                return new JavaObject(classForName(className));
     
    104104            Object instance = null;
    105105            try {
    106                 if (args[1] instanceof LispString) {
     106                if (args[1] instanceof AbstractString) {
    107107                    // Cases 1-5.
    108                     fieldName = LispString.getValue(args[1]);
     108                    fieldName = args[1].getStringValue();
    109109                    c = forClassRef(args[0]);
    110110                } else {
    111111                    // Cases 6 and 7.
    112                     fieldName = LispString.getValue(args[0]);
     112                    fieldName = args[0].getStringValue();
    113113                    instance = JavaObject.getObject(args[1]);
    114114                    c = instance.getClass();
     
    221221    // ### jmethod
    222222    // jmethod class-ref name &rest parameter-class-refs
    223     private static final Primitive JMETHOD = new Primitive("jmethod", PACKAGE_JAVA, true,
    224                                                            "class-ref name &rest parameter-class-refs")
     223    private static final Primitive JMETHOD =
     224        new Primitive("jmethod", PACKAGE_JAVA, true,
     225                      "class-ref name &rest parameter-class-refs")
    225226    {
    226227        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    228229            if (args.length < 2)
    229230                signal(new WrongNumberOfArgumentsException(this));
    230             String methodName = LispString.getValue(args[1]);
     231            String methodName = args[1].getStringValue();
    231232            try {
    232233                final Class c = forClassRef(args[0]);
     
    297298                    if (obj instanceof Method)
    298299                        m = (Method) obj;
    299                 } else if (methodRef instanceof LispString) {
     300                } else if (methodRef instanceof AbstractString) {
    300301                    Class c = forClassRef(args[1]);
    301302                    if (c != null) {
    302                         String methodName = LispString.getValue(methodRef);
     303                        String methodName = methodRef.getStringValue();
    303304                        Method[] methods = c.getMethods();
    304305                        for (int i = 0; i < methods.length; i++) {
     
    322323                    if (arg == NIL)
    323324                        methodArgs[i-2] = null;
    324                     else 
     325                    else
    325326                        methodArgs[i-2] = arg.javaInstance(argTypes[i-2]);
    326327                }
     
    478479                Class[] argTypes = method.getParameterTypes();
    479480                Object instance;
    480                 if (args[1] instanceof LispString)
    481                     instance = LispString.getValue(args[1]);
     481                if (args[1] instanceof AbstractString)
     482                    instance = args[1].getStringValue();
    482483                else
    483484                    instance = JavaObject.getObject(args[1]);
     
    487488                    if (arg == NIL)
    488489                        methodArgs[i-2] = null;
    489                     else 
     490                    else
    490491                        methodArgs[i-2] = arg.javaInstance(argTypes[i-2]);
    491492                }
     
    523524                        if (object == NIL)
    524525                            return new JavaObject(null);
    525                         else 
     526                        else
    526527                            throw new Error();
    527528                    }
     
    571572    private static Class forClassRef(LispObject classRef) throws ClassNotFoundException, ConditionThrowable
    572573    {
    573         if (classRef instanceof LispString) {
    574             String className = LispString.getValue(classRef);
     574        if (classRef instanceof AbstractString) {
     575            String className = classRef.getStringValue();
    575576            if (className.equals("boolean"))
    576577                return Boolean.TYPE;
     
    607608    private static final LispObject makeLispObject(Object obj) throws ConditionThrowable
    608609    {
    609         if (obj == null)         
     610        if (obj == null)
    610611            return NIL;
    611612        if (obj instanceof Boolean)
     
    618619            return new LispFloat(((Number)obj).doubleValue());
    619620        if (obj instanceof String)
    620             return new LispString((String)obj);
     621            return new SimpleString((String)obj);
    621622        if (obj instanceof Character)
    622623            return LispCharacter.getInstance(((Character)obj).charValue());
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r5851 r5897  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Lisp.java,v 1.207 2004-02-16 12:40:09 piso Exp $
     5 * $Id: Lisp.java,v 1.208 2004-02-23 14:24:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    712712            return arg;
    713713        if (arg instanceof Symbol)
    714             return new LispString(arg.getName());
     714            return new SimpleString(arg.getName());
    715715        if (arg instanceof LispCharacter)
    716             return new LispString(((LispCharacter)arg).getValue());
     716            return new SimpleString(((LispCharacter)arg).getValue());
    717717        signal(new TypeError(String.valueOf(arg) + " cannot be coerced to a string."));
    718718        // Not reached.
     
    11811181    {
    11821182        final LispThread thread = LispThread.currentThread();
    1183         String control = LispString.getValue(formatControl);
     1183        String control = formatControl.getStringValue();
    11841184        LispObject[] args = formatArguments.copyToArray();
    11851185        StringBuffer sb = new StringBuffer();
     
    12631263    private static final Hashtable objectTable = new Hashtable();
    12641264
    1265     public static final LispObject recall(LispString key)
    1266     {
    1267         return (LispObject) objectTable.get(((LispString)key).getValue());
    1268     }
    1269 
    1270     public static final void forget(LispString key)
    1271     {
    1272         objectTable.remove(((LispString)key).getValue());
     1265    public static final LispObject recall(SimpleString key)
     1266    {
     1267        return (LispObject) objectTable.get(key.getStringValue());
     1268    }
     1269
     1270    public static final void forget(SimpleString key)
     1271    {
     1272        objectTable.remove(key.getStringValue());
    12731273    }
    12741274
     
    12761276        new Primitive2("remember", PACKAGE_SYS, false)
    12771277    {
    1278         public LispObject execute(LispObject first, LispObject second)
     1278        public LispObject execute(LispObject key, LispObject value)
    12791279            throws ConditionThrowable
    12801280        {
    1281             objectTable.put(LispString.getValue(first), second);
     1281            objectTable.put(key.getStringValue(), value);
    12821282            return NIL;
    12831283        }
     
    13441344        }
    13451345        // This string will be converted to a pathname when Pathname.java is loaded.
    1346         _DEFAULT_PATHNAME_DEFAULTS_.setSymbolValue(new LispString(userDir));
     1346        _DEFAULT_PATHNAME_DEFAULTS_.setSymbolValue(new SimpleString(userDir));
    13471347        _DEFAULT_PATHNAME_DEFAULTS_.setSpecial(true);
    13481348    }
     
    15141514    public static final int CHAR_MAX = 256;
    15151515    public static final Symbol CHAR_CODE_LIMIT =
    1516         exportSpecial("CHAR-CODE-LIMIT", PACKAGE_CL, new Fixnum(CHAR_MAX));
     1516        exportConstant("CHAR-CODE-LIMIT", PACKAGE_CL, new Fixnum(CHAR_MAX));
    15171517
    15181518    // Printer control variables.
  • trunk/j/src/org/armedbear/lisp/LispCharacter.java

    r5875 r5897  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: LispCharacter.java,v 1.37 2004-02-19 01:44:50 piso Exp $
     5 * $Id: LispCharacter.java,v 1.38 2004-02-23 14:24:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    199199            if (arg instanceof LispCharacter)
    200200                return arg;
    201             if (arg instanceof LispString) {
     201            if (arg instanceof AbstractString) {
    202202                if (arg.length() == 1)
    203                     return ((LispString)arg).get(0);
     203                    return ((AbstractString)arg).get(0);
    204204            } else if (arg instanceof Symbol) {
    205205                String name = arg.getName();
  • trunk/j/src/org/armedbear/lisp/LispString.java

    r5888 r5897  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: LispString.java,v 1.83 2004-02-22 15:57:34 piso Exp $
     5 * $Id: LispString.java,v 1.84 2004-02-23 14:24:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
    24 public final class LispString extends AbstractVector
     24public final class LispString extends AbstractString
    2525{
    2626    private char[] chars;
    2727
    28     public LispString(LispCharacter c)
    29     {
    30         chars = new char[1];
    31         chars[0] = c.getValue();
    32     }
    33 
    34     public LispString(char c)
    35     {
    36         chars = new char[1];
    37         chars[0] = c;
    38     }
    39 
    4028    public LispString(int length)
    4129    {
     
    4331    }
    4432
    45     public LispString(String s)
    46     {
    47         chars = s.toCharArray();
    48     }
    49 
    5033    public char[] chars()
    5134    {
     
    5336    }
    5437
    55     // Used by jvm compiler.
    56     public static LispString getInstance(String s)
    57     {
    58         return new LispString(s);
    59     }
    60 
    6138    public LispObject typeOf()
    6239    {
    63         return list2(fillPointer < 0 ? Symbol.SIMPLE_STRING : Symbol.STRING,
    64                      number(chars.length));
     40        return list2(/*fillPointer < 0 ? Symbol.SIMPLE_STRING :*/
     41                     Symbol.STRING,
     42                     number(capacity()));
    6543    }
    6644
     
    7755            if (type == Symbol.BASE_STRING)
    7856                return T;
    79             if (type == Symbol.SIMPLE_STRING ||
    80                 type == Symbol.SIMPLE_BASE_STRING)
    81                 return fillPointer < 0 ? T : NIL;
    8257        }
    8358        if (type == BuiltInClass.STRING)
     
    8661    }
    8762
    88     public LispObject STRINGP()
    89     {
    90         return T;
    91     }
    92 
    93     public boolean stringp()
    94     {
    95         return true;
    96     }
    97 
    98     public LispObject SIMPLE_STRING_P()
    99     {
    100         return fillPointer < 0 ? T : NIL;
    101     }
    102 
    103     public LispObject getElementType()
    104     {
    105         return Symbol.CHARACTER;
    106     }
    107 
    108     public boolean isSimpleVector()
    109     {
    110         return false;
    111     }
    112 
    11363    public boolean equal(LispObject obj) throws ConditionThrowable
    11464    {
    11565        if (this == obj)
    11666            return true;
    117         if (obj instanceof LispString) {
    118             LispString string = (LispString) obj;
     67        if (obj instanceof AbstractString) {
     68            AbstractString string = (AbstractString) obj;
    11969            if (string.length() != length())
    12070                return false;
    12171            for (int i = length(); i-- > 0;)
    122                 if (string.chars[i] != chars[i])
     72                if (string.getChar(i) != getChar(i))
    12373                    return false;
    12474            return true;
     
    13383        if (this == obj)
    13484            return true;
    135         if (obj instanceof LispString) {
    136             LispString string = (LispString) obj;
     85        if (obj instanceof AbstractString) {
     86            AbstractString string = (AbstractString) obj;
    13787            if (string.length() != length())
    13888                return false;
    13989            for (int i = length(); i-- > 0;) {
    140                 if (string.chars[i] != chars[i]) {
    141                     if (Utilities.toLowerCase(string.chars[i]) != Utilities.toLowerCase(chars[i]))
     90                if (string.getChar(i) != getChar(i)) {
     91                    if (Utilities.toLowerCase(string.getChar(i)) != Utilities.toLowerCase(getChar(i)))
    14292                        return false;
    14393                }
     
    152102    public LispObject subseq(int start, int end) throws ConditionThrowable
    153103    {
    154         LispString s = new LispString(end - start);
     104        SimpleString s = new SimpleString(end - start);
    155105        int i = start, j = 0;
    156         try {
    157             while (i < end)
    158                 s.chars[j++] = chars[i++];
    159             return s;
    160         }
    161         catch (ArrayIndexOutOfBoundsException e) {
    162             return signal(new TypeError("Array index out of bounds: " + i + "."));
    163         }
     106        while (i < end)
     107            s.setChar(j++, getChar(i++));
     108        return s;
    164109    }
    165110
     
    171116    public void fill(char c)
    172117    {
    173         final int limit = fillPointer >= 0 ? fillPointer : chars.length;
    174         for (int i = limit; i-- > 0;)
     118        for (int i = length(); i-- > 0;)
    175119            chars[i] = c;
    176120    }
     
    192136    {
    193137        int length = length();
    194         LispString result = new LispString(length);
     138        SimpleString result = new SimpleString(length);
    195139        int i, j;
    196140        for (i = 0, j = length - 1; i < length; i++, j--)
    197             result.chars[i] = chars[j];
     141            result.setChar(i, getChar(j));
    198142        return result;
    199143    }
     
    204148        int j = length() - 1;
    205149        while (i < j) {
    206             char temp = chars[i];
    207             chars[i] = chars[j];
    208             chars[j] = temp;
     150            char temp = getChar(i);
     151            setChar(i, getChar(j));
     152            setChar(j, temp);
    209153            ++i;
    210154            --j;
     
    215159    public LispObject getRowMajor(int index) throws ConditionThrowable
    216160    {
     161        return LispCharacter.getInstance(getChar(index));
     162    }
     163
     164    public void setRowMajor(int index, LispObject newValue) throws ConditionThrowable
     165    {
     166        setChar(index, LispCharacter.getValue(newValue));
     167    }
     168
     169    public LispObject get(int index) throws ConditionThrowable
     170    {
     171        return LispCharacter.getInstance(getChar(index));
     172    }
     173
     174    public void set(int index, LispObject newValue) throws ConditionThrowable
     175    {
     176        setChar(index, LispCharacter.getValue(newValue));
     177    }
     178
     179    public char getChar(int index) throws ConditionThrowable
     180    {
    217181        try {
    218             return LispCharacter.getInstance(chars[index]);
     182            return chars[index];
    219183        }
    220184        catch (ArrayIndexOutOfBoundsException e) {
    221185            badIndex(index, chars.length);
    222             return NIL; // Not reached.
    223         }
    224     }
    225 
    226     public void setRowMajor(int index, LispObject newValue) throws ConditionThrowable
     186            return 0; // Not reached.
     187        }
     188    }
     189
     190    public void setChar(int index, char c) throws ConditionThrowable
    227191    {
    228192        try {
    229             chars[index] = LispCharacter.getValue(newValue);
     193            chars[index] = c;
    230194        }
    231195        catch (ArrayIndexOutOfBoundsException e) {
    232196            badIndex(index, chars.length);
    233197        }
    234     }
    235 
    236     public LispObject get(int index) throws ConditionThrowable
    237     {
    238         try {
    239             return LispCharacter.getInstance(chars[index]);
    240         }
    241         catch (ArrayIndexOutOfBoundsException e) {
    242             badIndex(index, chars.length);
    243             return NIL; // Not reached.
    244         }
    245     }
    246 
    247     public void set(int index, LispObject newValue) throws ConditionThrowable
    248     {
    249         try {
    250             chars[index] = LispCharacter.getValue(newValue);
    251         }
    252         catch (ArrayIndexOutOfBoundsException e) {
    253             badIndex(index, chars.length);
    254         }
    255     }
    256 
    257     public void set(int index, char c)
    258     {
    259         chars[index] = c;
    260     }
    261 
    262     public static String getValue(LispObject obj) throws ConditionThrowable
    263     {
    264         try {
    265             return ((LispString)obj).getValue();
    266         }
    267         catch (ClassCastException e) {
    268             signal(new TypeError(obj, Symbol.STRING));
    269             // Not reached.
    270             return null;
    271         }
    272     }
    273 
    274     public final String getValue()
    275     {
    276         if (fillPointer >= 0)
    277             return new String(chars, 0, fillPointer);
    278         else
    279             return new String(chars);
    280198    }
    281199
     
    358276        if (index < 0 || index >= limit)
    359277            badIndex(index, limit);
    360         return LispCharacter.getInstance(chars[index]);
     278        return LispCharacter.getInstance(getChar(index));
    361279    }
    362280
     
    364282    public LispObject AREF(LispObject index) throws ConditionThrowable
    365283    {
    366         try {
    367             return LispCharacter.getInstance(chars[Fixnum.getValue(index)]);
    368         }
    369         catch (ArrayIndexOutOfBoundsException e) {
    370             badIndex(Fixnum.getValue(index), chars.length);
    371             return NIL; // Not reached.
    372         }
     284        return LispCharacter.getInstance(getChar(Fixnum.getValue(index)));
    373285    }
    374286
     
    413325            return cachedHashCode;
    414326        int hashCode = 0;
    415         final int limit = length();
    416         for (int i = 0; i < limit; i++)
    417             hashCode = hashCode * 31 + chars[i];
     327        try {
     328            final int limit = length();
     329            for (int i = 0; i < limit; i++)
     330                hashCode = hashCode * 31 + getChar(i);
     331        }
     332        catch (ConditionThrowable t) {
     333            // Shouldn't happen.
     334            Debug.trace(t);
     335        }
    418336        return cachedHashCode = hashCode;
    419337    }
    420 
    421     public final String toString(int beginIndex, int endIndex)
    422     {
    423         if (beginIndex < 0)
    424             beginIndex = 0;
    425         final int limit = fillPointer >= 0 ? fillPointer : chars.length;
    426         if (endIndex > limit)
    427             endIndex = limit;
    428         if (_PRINT_ESCAPE_.symbolValueNoThrow() != NIL) {
    429             StringBuffer sb = new StringBuffer();
    430             sb.append('"');
    431             for (int i = beginIndex; i < endIndex; i++) {
    432                 char c = chars[i];
    433                 if (c == '\"' || c == '\\')
    434                     sb.append('\\');
    435                 sb.append(c);
    436             }
    437             sb.append('"');
    438             return sb.toString();
    439         } else
    440             return getValue().substring(beginIndex, endIndex);
    441     }
    442 
    443     public final String toString()
    444     {
    445         return toString(0, chars.length);
    446     }
    447338}
  • trunk/j/src/org/armedbear/lisp/Load.java

    r5756 r5897  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Load.java,v 1.33 2004-02-11 00:22:57 piso Exp $
     5 * $Id: Load.java,v 1.34 2004-02-23 14:24:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    286286            // FIXME Need to support streams as well as pathname designators.
    287287            String filename;
    288             if (args[0] instanceof LispString)
    289                 filename = ((LispString)args[0]).getValue();
     288            if (args[0] instanceof AbstractString)
     289                filename = args[0].getStringValue();
    290290            else if (args[0] instanceof Pathname)
    291291                filename = ((Pathname)args[0]).getNamestring();
     
    306306        public LispObject execute(LispObject arg) throws ConditionThrowable
    307307        {
    308             return _load(LispString.getValue(arg),
     308            return _load(arg.getStringValue(),
    309309                         _LOAD_VERBOSE_.symbolValueNoThrow() != NIL,
    310310                         _LOAD_PRINT_.symbolValueNoThrow() != NIL,
  • trunk/j/src/org/armedbear/lisp/LogicalPathname.java

    r5682 r5897  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: LogicalPathname.java,v 1.2 2004-02-03 02:46:24 piso Exp $
     5 * $Id: LogicalPathname.java,v 1.3 2004-02-23 14:24:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6363            throws ConditionThrowable
    6464        {
    65             String host = LispString.getValue(first).toUpperCase();
     65            String host = first.getStringValue().toUpperCase();
    6666            map.put(host, NIL); // FIXME
    6767            return NIL;
     
    8585        public LispObject execute(LispObject arg) throws ConditionThrowable
    8686        {
    87             String host = LispString.getValue(arg).toUpperCase();
     87            String host = arg.getStringValue().toUpperCase();
    8888            if (map.get(host) != null)
    8989                return NIL;
     
    100100            if (arg instanceof LogicalPathname)
    101101                return arg;
    102             if (arg instanceof LispString) {
    103                 String s = ((LispString)arg).getValue();
     102            if (arg instanceof AbstractString) {
     103                String s = arg.getStringValue();
    104104                int index = s.indexOf(':');
    105105                if (index >= 0) {
    106106                    String host = s.substring(0, index).toUpperCase();
    107107                    LogicalPathname p = new LogicalPathname();
    108                     p.host = new LispString(host);
     108                    p.host = new SimpleString(host);
    109109                    return p;
    110110                }
  • trunk/j/src/org/armedbear/lisp/NilVector.java

    r5824 r5897  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: NilVector.java,v 1.4 2004-02-14 18:51:08 piso Exp $
     5 * $Id: NilVector.java,v 1.5 2004-02-23 14:24:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    101101            return true;
    102102        }
    103         if (obj instanceof LispString) {
     103        if (obj instanceof AbstractString) {
    104104            if (capacity != obj.length())
    105105                return false;
  • trunk/j/src/org/armedbear/lisp/Package.java

    r5113 r5897  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Package.java,v 1.49 2003-12-13 00:28:08 piso Exp $
     5 * $Id: Package.java,v 1.50 2004-02-23 14:24:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    510510            for (int i = nicknames.size(); i-- > 0;) {
    511511                String nickname = (String) nicknames.get(i);
    512                 list = new Cons(new LispString(nickname), list);
     512                list = new Cons(new SimpleString(nickname), list);
    513513            }
    514514        }
  • trunk/j/src/org/armedbear/lisp/PackageFunctions.java

    r5892 r5897  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: PackageFunctions.java,v 1.25 2004-02-23 00:08:00 piso Exp $
     5 * $Id: PackageFunctions.java,v 1.26 2004-02-23 14:24:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4242        {
    4343            String name = coerceToPackage(arg).getName();
    44             return name != null ? new LispString(name) : NIL;
     44            return name != null ? new SimpleString(name) : NIL;
    4545        }
    4646    };
  • trunk/j/src/org/armedbear/lisp/Pathname.java

    r5815 r5897  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: Pathname.java,v 1.50 2004-02-14 00:21:15 piso Exp $
     5 * $Id: Pathname.java,v 1.51 2004-02-23 14:24:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6565            if (Utilities.isPlatformWindows()) {
    6666                if (s.length() >= 2 && s.charAt(1) == ':') {
    67                     device = new LispString(s.charAt(0));
     67                    device = new SimpleString(s.charAt(0));
    6868                    s = s.substring(2);
    6969                }
     
    9797            }
    9898            if (s.startsWith(".")) {
    99                 name = new LispString(s);
     99                name = new SimpleString(s);
    100100                return;
    101101            }
     
    112112                    name = Keyword.WILD;
    113113                else
    114                     name = new LispString(n);
     114                    name = new SimpleString(n);
    115115            }
    116116            if (t != null) {
     
    118118                    type = Keyword.WILD;
    119119                else
    120                     type = new LispString(t);
     120                    type = new SimpleString(t);
    121121            }
    122122        }
     
    142142                obj = Keyword.WILD_INFERIORS;
    143143            else if (token.equals("..")) {
    144                 if (result.car() instanceof LispString) {
     144                if (result.car() instanceof AbstractString) {
    145145                    result = result.cdr();
    146146                    continue;
     
    148148                obj= Keyword.UP;
    149149            } else
    150                 obj = new LispString(token);
     150                obj = new SimpleString(token);
    151151            result = new Cons(obj, result);
    152152        }
     
    183183        StringBuffer sb = new StringBuffer();
    184184        if (Utilities.isPlatformWindows() && device != NIL) {
    185             if (device instanceof LispString)
    186                 sb.append(((LispString)device).getValue());
     185            if (device instanceof AbstractString)
     186                sb.append(device.getStringValue());
    187187            else
    188188                Debug.assertTrue(false);
    189189            sb.append(':');
    190190        }
    191         if (directory instanceof LispString)
     191        if (directory instanceof AbstractString)
    192192            Debug.assertTrue(false);
    193193        sb.append(getDirectoryNamestring());
    194         if (name instanceof LispString)
    195             sb.append(((LispString)name).getValue());
     194        if (name instanceof AbstractString)
     195            sb.append(name.getStringValue());
    196196        else if (name == Keyword.WILD)
    197197            sb.append('*');
    198198        if (type != NIL) {
    199199            sb.append('.');
    200             if (type instanceof LispString)
    201                 sb.append(((LispString)type).getValue());
     200            if (type instanceof AbstractString)
     201                sb.append(type.getStringValue());
    202202            else if (type == Keyword.WILD)
    203203                sb.append('*');
     
    223223            while (temp != NIL) {
    224224                part = temp.car();
    225                 if (part instanceof LispString)
    226                     sb.append(((LispString)part).getValue());
     225                if (part instanceof AbstractString)
     226                    sb.append(part.getStringValue());
    227227                else if (part == Keyword.WILD)
    228228                    sb.append("*");
     
    407407        if (arg instanceof Pathname)
    408408            return (Pathname) arg;
    409         if (arg instanceof LispString)
    410             return new Pathname(((LispString)arg).getValue());
     409        if (arg instanceof AbstractString)
     410            return new Pathname(arg.getStringValue());
    411411        if (arg instanceof FileStream)
    412412            return ((FileStream)arg).getPathname();
     
    500500                signal(new SimpleError("Pathname has no namestring: " +
    501501                                       pathname + "."));
    502             return new LispString(namestring);
     502            return new SimpleString(namestring);
    503503        }
    504504    };
     
    512512        public LispObject execute(LispObject arg) throws ConditionThrowable
    513513        {
    514             return new LispString(coerceToPathname(arg).getDirectoryNamestring());
     514            return new SimpleString(coerceToPathname(arg).getDirectoryNamestring());
    515515        }
    516516    };
     
    562562                p.device = value;
    563563            } else if (key == Keyword.DIRECTORY) {
    564                 if (value instanceof LispString)
     564                if (value instanceof AbstractString)
    565565                    p.directory = list2(Keyword.ABSOLUTE, value);
    566566                else if (value == Keyword.WILD)
     
    820820        if (pathname.version != NIL)
    821821            p.version = pathname.version;
    822         else if (pathname.name instanceof LispString)
     822        else if (pathname.name instanceof AbstractString)
    823823            p.version = defaultVersion;
    824824        else if (defaultPathname.version != NIL)
     
    849849            for (int i = 0; i < array.length - 1; i++) {
    850850                if (array[i] == Keyword.BACK) {
    851                     if (array[i+1] instanceof LispString || array[i+1] == Keyword.WILD) {
     851                    if (array[i+1] instanceof AbstractString || array[i+1] == Keyword.WILD) {
    852852                        array[i] = null;
    853853                        array[i+1] = null;
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r5874 r5897  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Primitives.java,v 1.574 2004-02-19 01:35:12 piso Exp $
     5 * $Id: Primitives.java,v 1.575 2004-02-23 14:24:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    364364            throws ConditionThrowable
    365365        {
    366             return first.elt(Fixnum.getValue(second));
     366            try {
     367                return first.elt(((Fixnum)second).value);
     368            }
     369            catch (ClassCastException e) {
     370                return signal(new TypeError(second, Symbol.FIXNUM));
     371            }
    367372        }
    368373    };
     
    661666        public LispObject execute(LispObject arg) throws ConditionThrowable
    662667        {
    663             return new LispString(String.valueOf(arg));
     668            return new SimpleString(String.valueOf(arg));
    664669        }
    665670    };
     
    690695            Environment oldDynEnv = thread.getDynamicEnvironment();
    691696            thread.bindSpecial(_PRINT_ESCAPE_, NIL);
    692             LispString string = new LispString(String.valueOf(arg));
     697            SimpleString string = new SimpleString(String.valueOf(arg));
    693698            thread.setDynamicEnvironment(oldDynEnv);
    694699            return string;
     
    716721    // ### prin1-to-string
    717722    private static final Primitive1 PRIN1_TO_STRING =
    718         new Primitive1("prin1-to-string","object") {
    719         public LispObject execute(LispObject arg) throws ConditionThrowable
    720         {
    721             return new LispString(String.valueOf(arg));
     723        new Primitive1("prin1-to-string", "object")
     724    {
     725        public LispObject execute(LispObject arg) throws ConditionThrowable
     726        {
     727            return new SimpleString(String.valueOf(arg));
    722728        }
    723729    };
     
    727733    // PRINT is just like PRIN1 except that the printed representation of
    728734    // object is preceded by a newline and followed by a space.
    729     private static final Primitive1 PRINT = new Primitive1("print","object &optional output-stream") {
     735    private static final Primitive1 PRINT =
     736        new Primitive1("print", "object &optional output-stream")
     737    {
    730738        public LispObject execute(LispObject arg) throws ConditionThrowable
    731739        {
     
    12981306            }
    12991307            if (destination == NIL)
    1300                 return new LispString(s);
     1308                return new SimpleString(s);
    13011309            if (destination instanceof TwoWayStream) {
    13021310                Stream out = ((TwoWayStream)destination).getOutputStream();
     
    13721380            LispObject arglist = checkList(second);
    13731381            LispObject body = checkList(third);
    1374             if (body.car() instanceof LispString && body.cdr() != NIL) {
     1382            if (body.car() instanceof AbstractString && body.cdr() != NIL) {
    13751383                // Documentation.
    13761384                if (first instanceof Symbol)
     
    14811489        {
    14821490            Symbol symbol = checkSymbol(first);
    1483             if (third instanceof LispString)
     1491            if (third instanceof AbstractString)
    14841492                symbol.setVariableDocumentation(third);
    14851493            else if (third != NIL)
     
    15111519        {
    15121520            Symbol symbol = checkSymbol(first);
    1513             if (third instanceof LispString)
     1521            if (third instanceof AbstractString)
    15141522                symbol.setVariableDocumentation(third);
    15151523            else if (third != NIL)
     
    20522060            Function function = checkFunction(arg);
    20532061            String name = function.getName();
    2054             final LispObject value3 = name != null ? new LispString(name) : NIL;
     2062            final LispObject value3 = name != null ? new SimpleString(name) : NIL;
    20552063            if (function instanceof Closure) {
    20562064                Closure closure = (Closure) function;
     
    23602368                return new Symbol(sb.toString());
    23612369            }
    2362             if (arg instanceof LispString)
    2363                 prefix = ((LispString)arg).getValue();
     2370            if (arg instanceof AbstractString)
     2371                prefix = arg.getStringValue();
    23642372            else
    23652373                signal(new TypeError(arg, "string or non-negative integer"));
     
    24032411        public LispObject execute(LispObject arg) throws ConditionThrowable
    24042412        {
    2405             String s;
    2406             try {
    2407                 s = ((LispString)arg).getValue();
    2408             }
    2409             catch (ClassCastException e) {
    2410                 if (arg instanceof NilVector) {
    2411                     if (arg.length() == 0)
    2412                         s = "";
    2413                     else
    2414                         return ((NilVector)arg).accessError();
    2415                 } else
    2416                     return signal(new TypeError(arg, Symbol.STRING));
    2417             }
     2413            String s = arg.getStringValue();
    24182414            final LispThread thread = LispThread.currentThread();
    24192415            Package pkg =
     
    24242420            throws ConditionThrowable
    24252421        {
    2426             String s;
    2427             try {
    2428                 s = ((LispString)first).getValue();
    2429             }
    2430             catch (ClassCastException e) {
    2431                 if (first instanceof NilVector) {
    2432                     if (first.length() == 0)
    2433                         s = "";
    2434                     else
    2435                         return ((NilVector)first).accessError();
    2436                 } else
    2437                     return signal(new TypeError(first, Symbol.STRING));
    2438             }
     2422            String s = first.getStringValue();
    24392423            Package pkg = coerceToPackage(second);
    24402424            return pkg.intern(s, LispThread.currentThread());
     
    24632447    // ### find-package
    24642448    private static final Primitive1 FIND_PACKAGE =
    2465         new Primitive1("find-package","name") {
     2449        new Primitive1("find-package", "name") {
    24662450        public LispObject execute(LispObject arg) throws ConditionThrowable
    24672451        {
    24682452            if (arg instanceof Package)
    24692453                return arg;
    2470             if (arg instanceof LispString) {
     2454            if (arg instanceof AbstractString) {
    24712455                Package pkg =
    2472                     Packages.findPackage(((LispString)arg).getValue());
     2456                    Packages.findPackage(arg.getStringValue());
    24732457                return pkg != null ? pkg : NIL;
    24742458            }
     
    26802664            if (args.length == 0 || args.length > 2)
    26812665                signal(new WrongNumberOfArgumentsException(this));
    2682             String name = LispString.getValue(args[0]);
     2666            String name = args[0].getStringValue();
    26832667            Package pkg;
    26842668            if (args.length == 2)
     
    35453529            if (args.length < 6)
    35463530                signal(new WrongNumberOfArgumentsException(this));
    3547             String s = LispString.getValue(args[0]);
     3531            String s = args[0].getStringValue();
    35483532            boolean eofError = args[1] != NIL;
    35493533            LispObject eofValue = args[2];
     
    36043588        public LispObject execute(LispObject arg) throws ConditionThrowable
    36053589        {
    3606             String s = LispString.getValue(string(arg));
     3590            String s = string(arg).getStringValue();
    36073591            int n = nameToChar(s);
    36083592            return n >= 0 ? LispCharacter.getInstance((char)n) : NIL;
     
    36383622                    break;
    36393623            }
    3640             return name != null ? new LispString(name) : NIL;
     3624            return name != null ? new SimpleString(name) : NIL;
    36413625        }
    36423626    };
     
    40824066                }
    40834067            }
    4084             signal(new TypeError(first, "sequence"));
     4068            signal(new TypeError(first, Symbol.SEQUENCE));
    40854069            return NIL;
    40864070        }
     
    44164400        public LispObject execute(LispObject arg) throws ConditionThrowable
    44174401        {
    4418             return new LispString(Integer.toHexString(System.identityHashCode(arg)));
     4402            return new SimpleString(Integer.toHexString(System.identityHashCode(arg)));
    44194403        }
    44204404    };
     
    44264410        public LispObject execute(LispObject arg) throws ConditionThrowable
    44274411        {
    4428             if (arg instanceof LispString)
    4429                 return new File(((LispString)arg).getValue()).mkdir() ? T : NIL;
     4412            if (arg instanceof AbstractString)
     4413                return new File(arg.getStringValue()).mkdir() ? T : NIL;
    44304414            else
    44314415                return signal(new TypeError(arg, Symbol.STRING));
  • trunk/j/src/org/armedbear/lisp/Stream.java

    r5850 r5897  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: Stream.java,v 1.23 2004-02-16 02:33:35 piso Exp $
     5 * $Id: Stream.java,v 1.24 2004-02-23 14:24:47 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    308308    }
    309309
    310     private LispString readString() throws ConditionThrowable
    311     {
    312         return new LispString(_readString());
     310    private SimpleString readString() throws ConditionThrowable
     311    {
     312        return new SimpleString(_readString());
    313313    }
    314314
     
    316316    {
    317317        LispObject obj = read(true, NIL, false);
    318         if (obj instanceof LispString)
    319             return new Pathname(((LispString)obj).getValue());
     318        if (obj instanceof AbstractString)
     319            return new Pathname(obj.getStringValue());
    320320        if (obj.listp())
    321321            return Pathname.makePathname(obj);
     
    10261026                    return thread.setValues(eofValue, T);
    10271027                }
    1028                 return thread.setValues(new LispString(sb.toString()), T);
     1028                return thread.setValues(new SimpleString(sb.toString()), T);
    10291029            }
    10301030            if (n == '\n')
    1031                 return thread.setValues(new LispString(sb.toString()), NIL);
     1031                return thread.setValues(new SimpleString(sb.toString()), NIL);
    10321032            else
    10331033                sb.append((char)n);
     
    11771177        if (arg instanceof LispCharacter)
    11781178            return Fixnum.ONE;
    1179         else if (arg instanceof LispString)
     1179        else if (arg instanceof AbstractString)
    11801180            return number(arg.length());
    11811181        else
  • trunk/j/src/org/armedbear/lisp/StringFunctions.java

    r5889 r5897  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: StringFunctions.java,v 1.17 2004-02-22 15:58:27 piso Exp $
     5 * $Id: StringFunctions.java,v 1.18 2004-02-23 14:24:48 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    532532            for (i = end; i < length; i++)
    533533                sb.append(array[i]);
    534             return new LispString(sb.toString());
     534            return new SimpleString(sb.toString());
    535535        }
    536536    };
     
    566566            for (i = end; i < length; i++)
    567567                sb.append(array[i]);
    568             return new LispString(sb.toString());
     568            return new SimpleString(sb.toString());
    569569        }
    570570    };
     
    612612            for (i = end; i < length; i++)
    613613                sb.append(array[i]);
    614             return new LispString(sb.toString());
     614            return new SimpleString(sb.toString());
    615615        }
    616616    };
     
    755755    };
    756756
    757     // ### string-p
     757    // ### stringp
    758758    public static final Primitive1 STRINGP = new Primitive1("stringp", "object")
    759759    {
     
    789789            if (n < 0 || n >= limit) {
    790790                StringBuffer sb = new StringBuffer();
    791                 sb.append("the size specified for this string (");
     791                sb.append("The size specified for this string (");
    792792                sb.append(n);
    793793                sb.append(')');
     
    795795                    sb.append(" is >= ARRAY-DIMENSION-LIMIT (");
    796796                    sb.append(limit);
    797                     sb.append(')');
     797                    sb.append(").");
    798798                } else
    799                     sb.append(" is negative");
     799                    sb.append(" is negative.");
    800800                return signal(new LispError(sb.toString()));
    801801            }
    802802            // Ignore elementType.
    803             LispString string = new LispString(n);
     803            SimpleString string = new SimpleString(n);
    804804            if (initialElement != NIL) {
    805805                // Initial element was specified.
     
    845845            throws ConditionThrowable
    846846        {
    847             return checkString(first).get(Fixnum.getInt(second));
     847            try {
     848                return ((SimpleString)first).get(((Fixnum)second).value);
     849            }
     850            catch (ClassCastException e) {
     851                if (first instanceof SimpleString)
     852                    return signal(new TypeError(second, Symbol.FIXNUM));
     853                else
     854                    return signal(new TypeError(first, Symbol.SIMPLE_STRING));
     855            }
    848856        }
    849857    };
     
    856864                                  LispObject third) throws ConditionThrowable
    857865        {
    858             checkString(first).set(Fixnum.getInt(second), checkCharacter(third));
    859             return third;
     866            try {
     867                ((SimpleString)first).set(((Fixnum)second).value, third);
     868                return third;
     869            }
     870            catch (ClassCastException e) {
     871                if (first instanceof SimpleString)
     872                    return signal(new TypeError(second, Symbol.FIXNUM));
     873                else
     874                    return signal(new TypeError(first, Symbol.SIMPLE_STRING));
     875            }
    860876        }
    861877    };
     
    889905            throws ConditionThrowable
    890906        {
    891             int index = LispString.getValue(second).indexOf(LispString.getValue(first));
     907            // FIXME Don't call getStringValue() here! (Just look at the chars.)
     908            int index = second.getStringValue().indexOf(first.getStringValue());
    892909            return index >= 0 ? new Fixnum(index) : NIL;
    893910        }
     
    901918            throws ConditionThrowable
    902919        {
    903             checkString(first).fill(LispCharacter.getValue(second));
    904             return first;
     920            try {
     921                AbstractString s = (AbstractString) first;
     922                s.fill(LispCharacter.getValue(second));
     923                return first;
     924            }
     925            catch (ClassCastException e) {
     926                return signal(new TypeError(first, Symbol.SIMPLE_STRING));
     927            }
    905928        }
    906929    };
  • trunk/j/src/org/armedbear/lisp/StringOutputStream.java

    r5842 r5897  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: StringOutputStream.java,v 1.12 2004-02-15 19:42:03 piso Exp $
     5 * $Id: StringOutputStream.java,v 1.13 2004-02-23 14:24:48 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    105105        String s = stringWriter.toString();
    106106        stringWriter.getBuffer().setLength(0);
    107         return new LispString(s);
     107        return new SimpleString(s);
    108108    }
    109109
  • trunk/j/src/org/armedbear/lisp/Symbol.java

    r5893 r5897  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Symbol.java,v 1.107 2004-02-23 00:12:37 piso Exp $
     5 * $Id: Symbol.java,v 1.108 2004-02-23 14:24:48 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    389389        throws ConditionThrowable
    390390    {
    391         put(this, _FUNCTION_DOCUMENTATION, new LispString(docstring));
     391        put(this, _FUNCTION_DOCUMENTATION, new SimpleString(docstring));
    392392    }
    393393
     
    488488        {
    489489            try {
    490                 return new LispString(((Symbol)arg).name);
     490                return new SimpleString(((Symbol)arg).name);
    491491            }
    492492            catch (ClassCastException e) {
    493                 return signal(new TypeError(arg, "symbol"));
     493                return signal(new TypeError(arg, Symbol.SYMBOL));
    494494            }
    495495        }
  • trunk/j/src/org/armedbear/lisp/arglist.java

    r5854 r5897  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: arglist.java,v 1.8 2004-02-16 13:13:11 piso Exp $
     5 * $Id: arglist.java,v 1.9 2004-02-23 14:24:48 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6363                arglist = functional.getArglist();
    6464            final LispObject value1, value2;
    65             if (arglist instanceof LispString) {
    66                 String s = ((LispString)arglist).getValue();
     65            if (arglist instanceof AbstractString) {
     66                String s = arglist.getStringValue();
    6767                // Give the string list syntax.
    6868                s = "(" + s + ")";
  • trunk/j/src/org/armedbear/lisp/describe.java

    r5593 r5897  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: describe.java,v 1.13 2004-01-28 20:19:22 piso Exp $
     5 * $Id: describe.java,v 1.14 2004-02-23 14:24:48 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8080                            thread.bindSpecial(_PRINT_ESCAPE_, NIL);
    8181                            sb.append("Function argument list:\n  ");
    82                             if (arglist instanceof LispString)
    83                                 sb.append(((LispString)arglist).getValue());
     82                            if (arglist instanceof AbstractString)
     83                                sb.append(arglist.getStringValue());
    8484                            else
    8585                                sb.append(arglist);
     
    9090                    LispObject documentation =
    9191                        symbol.getFunctionDocumentation();
    92                     if (documentation instanceof LispString) {
     92                    if (documentation instanceof AbstractString) {
    9393                        sb.append("Function documentation:\n  ");
    94                         sb.append(((LispString)documentation).getValue());
     94                        sb.append(documentation.getStringValue());
    9595                        sb.append('\n');
    9696                    }
  • trunk/j/src/org/armedbear/lisp/jvm.lisp

    r5879 r5897  
    22;;;
    33;;; Copyright (C) 2003-2004 Peter Graves
    4 ;;; $Id: jvm.lisp,v 1.74 2004-02-19 18:16:44 piso Exp $
     4;;; $Id: jvm.lisp,v 1.75 2004-02-23 14:24:48 piso Exp $
    55;;;
    66;;; This program is free software; you can redistribute it and/or
     
    501501(defconstant +lisp-object-class+ "org/armedbear/lisp/LispObject")
    502502(defconstant +lisp-object+ "Lorg/armedbear/lisp/LispObject;")
    503 (defconstant +lisp-string+ "Lorg/armedbear/lisp/LispString;")
     503(defconstant +lisp-string+ "Lorg/armedbear/lisp/SimpleString;")
    504504(defconstant +lisp-symbol-class+ "org/armedbear/lisp/Symbol")
    505505(defconstant +lisp-thread-class+ "org/armedbear/lisp/LispThread")
     
    12141214      (emit-invokestatic +lisp-class+
    12151215                         "recall"
    1216                          "(Lorg/armedbear/lisp/LispString;)Lorg/armedbear/lisp/LispObject;"
     1216                         "(Lorg/armedbear/lisp/SimpleString;)Lorg/armedbear/lisp/LispObject;"
    12171217                         0)
    12181218      (emit 'putstatic
     
    12221222      (emit-invokestatic +lisp-class+
    12231223                         "forget"
    1224                          "(Lorg/armedbear/lisp/LispString;)V"
     1224                         "(Lorg/armedbear/lisp/SimpleString;)V"
    12251225                         -1)
    12261226      (setq *static-code* *code*)
     
    12301230  (let ((g (symbol-name (gensym)))
    12311231        (*code* *static-code*))
    1232     (declare-field g "Lorg/armedbear/lisp/LispString;")
     1232    (declare-field g "Lorg/armedbear/lisp/SimpleString;")
    12331233    (emit 'ldc
    12341234          (pool-string string))
    1235     (emit-invokestatic "org/armedbear/lisp/LispString"
     1235    (emit-invokestatic "org/armedbear/lisp/SimpleString"
    12361236                       "getInstance"
    1237                        "(Ljava/lang/String;)Lorg/armedbear/lisp/LispString;"
     1237                       "(Ljava/lang/String;)Lorg/armedbear/lisp/SimpleString;"
    12381238                       0)
    12391239    (emit 'putstatic
     
    12851285            *this-class*
    12861286            g
    1287             "Lorg/armedbear/lisp/LispString;")
     1287            "Lorg/armedbear/lisp/SimpleString;")
    12881288      (emit-store-value)))
    12891289   ((vectorp form)
  • trunk/j/src/org/armedbear/lisp/lisp_implementation_type.java

    r5047 r5897  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: lisp_implementation_type.java,v 1.2 2003-12-10 08:12:43 asimon Exp $
     5 * $Id: lisp_implementation_type.java,v 1.3 2004-02-23 14:24:48 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3535    public LispObject execute()
    3636    {
    37         return new LispString("Armed Bear Lisp");
     37        return new SimpleString("Armed Bear Lisp");
    3838    }
    3939
  • trunk/j/src/org/armedbear/lisp/lisp_implementation_version.java

    r5047 r5897  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: lisp_implementation_version.java,v 1.3 2003-12-10 08:12:43 asimon Exp $
     5 * $Id: lisp_implementation_version.java,v 1.4 2004-02-23 14:24:48 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3535    public LispObject execute()
    3636    {
    37         return new LispString(Version.getVersion());
     37        return new SimpleString(Version.getVersion());
    3838    }
    3939
  • trunk/j/src/org/armedbear/lisp/make_array.java

    r5767 r5897  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: make_array.java,v 1.10 2004-02-11 20:01:26 piso Exp $
     5 * $Id: make_array.java,v 1.11 2004-02-23 14:24:48 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9595            LispObject upgradedType =
    9696                getUpgradedArrayElementType(elementType);
    97             if (upgradedType == Symbol.CHARACTER)
    98                 v = new LispString(size);
    99             else if (upgradedType == Symbol.BIT)
     97            if (upgradedType == Symbol.CHARACTER) {
     98                if (fillPointer != NIL || adjustable != NIL)
     99                    v = new LispString(size);
     100                else
     101                    v = new SimpleString(size);
     102            } else if (upgradedType == Symbol.BIT)
    100103                v = new BitVector(size);
    101104            else if (upgradedType == NIL)
Note: See TracChangeset for help on using the changeset viewer.