Changeset 10210


Ignore:
Timestamp:
10/23/05 18:44:50 (16 years ago)
Author:
piso
Message:

Symbol refactoring (work in progress).

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

Legend:

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

    r10209 r10210  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: AbstractArray.java,v 1.46 2005-10-23 18:11:10 piso Exp $
     5 * $Id: AbstractArray.java,v 1.47 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    187187                }
    188188            } else {
    189                 LispObject printLevel = _PRINT_LEVEL_.symbolValue(thread);
     189                LispObject printLevel = Symbol.PRINT_LEVEL.symbolValue(thread);
    190190                if (printLevel instanceof Fixnum)
    191191                    maxLevel = ((Fixnum)printLevel).value;
     
    239239                    maxLength = ((Fixnum)printLength).value;
    240240                final LispObject printLevel =
    241                     _PRINT_LEVEL_.symbolValue(thread);
     241                    Symbol.PRINT_LEVEL.symbolValue(thread);
    242242                if (printLevel instanceof Fixnum)
    243243                    maxLevel = ((Fixnum)printLevel).value;
  • trunk/j/src/org/armedbear/lisp/AbstractBitVector.java

    r10202 r10210  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: AbstractBitVector.java,v 1.12 2005-10-23 16:39:48 piso Exp $
     5 * $Id: AbstractBitVector.java,v 1.13 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    167167        final int length = length();
    168168        if (Symbol.PRINT_READABLY.symbolValue(thread) != NIL ||
    169             _PRINT_ARRAY_.symbolValue(thread) != NIL)
     169            Symbol.PRINT_ARRAY.symbolValue(thread) != NIL)
    170170        {
    171             StringBuffer sb = new StringBuffer(length + 2);
     171            FastStringBuffer sb = new FastStringBuffer(length + 2);
    172172            sb.append("#*");
    173173            for (int i = 0; i < length; i++)
     
    175175            return sb.toString();
    176176        } else {
    177             StringBuffer sb = new StringBuffer("(");
     177            FastStringBuffer sb = new FastStringBuffer("(");
    178178            if (this instanceof SimpleBitVector)
    179179                sb.append("SIMPLE-");
  • trunk/j/src/org/armedbear/lisp/AbstractVector.java

    r10202 r10210  
    193193            sb.append(')');
    194194            return sb.toString();
    195         } else if (_PRINT_ARRAY_.symbolValue(thread) != NIL) {
     195        } else if (Symbol.PRINT_ARRAY.symbolValue(thread) != NIL) {
    196196            int maxLevel = Integer.MAX_VALUE;
    197197            final LispObject printLevel =
    198                 _PRINT_LEVEL_.symbolValue(thread);
     198                Symbol.PRINT_LEVEL.symbolValue(thread);
    199199            if (printLevel instanceof Fixnum)
    200200                maxLevel = ((Fixnum)printLevel).value;
     
    206206                int maxLength = Integer.MAX_VALUE;
    207207                final LispObject printLength =
    208                     _PRINT_LENGTH_.symbolValue(thread);
     208                    Symbol.PRINT_LENGTH.symbolValue(thread);
    209209                if (printLength instanceof Fixnum)
    210210                    maxLength = ((Fixnum)printLength).value;
  • trunk/j/src/org/armedbear/lisp/Condition.java

    r10202 r10210  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Condition.java,v 1.42 2005-10-23 16:39:49 piso Exp $
     5 * $Id: Condition.java,v 1.43 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    176176        }
    177177        final int maxLevel;
    178         LispObject printLevel = _PRINT_LEVEL_.symbolValue(thread);
     178        LispObject printLevel = Symbol.PRINT_LEVEL.symbolValue(thread);
    179179        if (printLevel instanceof Fixnum)
    180180            maxLevel = ((Fixnum)printLevel).value;
  • trunk/j/src/org/armedbear/lisp/Cons.java

    r9922 r10210  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Cons.java,v 1.67 2005-08-26 00:33:49 piso Exp $
     5 * $Id: Cons.java,v 1.68 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    494494    {
    495495        final LispThread thread = LispThread.currentThread();
    496         final LispObject printLength = _PRINT_LENGTH_.symbolValue(thread);
     496        final LispObject printLength = Symbol.PRINT_LENGTH.symbolValue(thread);
    497497        final int maxLength;
    498498        if (printLength instanceof Fixnum)
     
    500500        else
    501501            maxLength = Integer.MAX_VALUE;
    502         final LispObject printLevel = _PRINT_LEVEL_.symbolValue(thread);
     502        final LispObject printLevel = Symbol.PRINT_LEVEL.symbolValue(thread);
    503503        final int maxLevel;
    504504        if (printLevel instanceof Fixnum)
  • trunk/j/src/org/armedbear/lisp/DoubleFloat.java

    r10202 r10210  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: DoubleFloat.java,v 1.5 2005-10-23 16:39:49 piso Exp $
     5 * $Id: DoubleFloat.java,v 1.6 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    509509        LispThread thread = LispThread.currentThread();
    510510        if (Symbol.PRINT_READABLY.symbolValue(thread) != NIL ||
    511             !memq(_READ_DEFAULT_FLOAT_FORMAT_.symbolValue(thread),
     511            !memq(Symbol.READ_DEFAULT_FLOAT_FORMAT.symbolValue(thread),
    512512                  list2(Symbol.DOUBLE_FLOAT, Symbol.LONG_FLOAT)))
    513513        {
  • trunk/j/src/org/armedbear/lisp/Function.java

    r10195 r10210  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Function.java,v 1.56 2005-10-23 14:12:19 piso Exp $
     5 * $Id: Function.java,v 1.57 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    237237                final LispThread thread = LispThread.currentThread();
    238238                SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    239                 thread.bindSpecial(_PRINT_LENGTH_, Fixnum.THREE);
     239                thread.bindSpecial(Symbol.PRINT_LENGTH, Fixnum.THREE);
    240240                try {
    241241                    sb.append(lambdaList.writeToString());
  • trunk/j/src/org/armedbear/lisp/Interpreter.java

    r10208 r10210  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Interpreter.java,v 1.98 2005-10-23 17:51:56 piso Exp $
     5 * $Id: Interpreter.java,v 1.99 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    538538            return signal(new EndOfFile(stream));
    539539        final SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    540         thread.bindSpecial(Symbol._DEBUGGER_HOOK_, _DEBUGGER_HOOK_FUNCTION);
     540        thread.bindSpecial(Symbol.DEBUGGER_HOOK, _DEBUGGER_HOOK_FUNCTION);
    541541        try {
    542542            return eval(obj, new Environment(), thread);
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r10209 r10210  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Lisp.java,v 1.410 2005-10-23 18:11:10 piso Exp $
     5 * $Id: Lisp.java,v 1.411 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    701701    }
    702702
    703     // ### *gensym-counter*
    704     private static final Symbol _GENSYM_COUNTER_ =
    705         exportSpecial("*GENSYM-COUNTER*", PACKAGE_CL, Fixnum.ZERO);
     703    static {
     704        Symbol.GENSYM_COUNTER.initializeSpecial(Fixnum.ZERO);
     705    }
    706706
    707707    public static final Symbol gensym(LispThread thread)
     
    715715    {
    716716        FastStringBuffer sb = new FastStringBuffer(prefix);
    717         SpecialBinding binding = thread.getSpecialBinding(_GENSYM_COUNTER_);
     717        SpecialBinding binding = thread.getSpecialBinding(Symbol.GENSYM_COUNTER);
    718718        final LispObject oldValue;
    719719        if (binding != null)
    720720            oldValue = binding.value;
    721721        else
    722             oldValue = _GENSYM_COUNTER_.getSymbolValue();
     722            oldValue = Symbol.GENSYM_COUNTER.getSymbolValue();
    723723        // Decimal representation.
    724724        if (oldValue instanceof Fixnum)
     
    731731                binding.value = Fixnum.ZERO;
    732732            else
    733                 _GENSYM_COUNTER_.setSymbolValue(Fixnum.ZERO);
     733                Symbol.GENSYM_COUNTER.setSymbolValue(Fixnum.ZERO);
    734734            signal(new TypeError("The value of *GENSYM-COUNTER* was not a nonnegative integer. Old value: " +
    735735                                 oldValue.writeToString() + " New value: 0"));
     
    738738            binding.value = oldValue.incr();
    739739        else
    740             _GENSYM_COUNTER_.setSymbolValue(oldValue.incr());
     740            Symbol.GENSYM_COUNTER.setSymbolValue(oldValue.incr());
    741741        return new Symbol(new SimpleString(sb));
    742742    }
     
    18131813    static {
    18141814        Symbol.READ_SUPPRESS.initializeSpecial(NIL);
    1815         Symbol._DEBUGGER_HOOK_.initializeSpecial(NIL);
     1815        Symbol.DEBUGGER_HOOK.initializeSpecial(NIL);
    18161816    }
    18171817
     
    18311831    // We can't use exportConstant() here since we need to set T's value to
    18321832    // itself.
    1833     public static final Symbol T = exportConstant("T", PACKAGE_CL, null);
    1834     static {
    1835         T.setSymbolValue(T);
     1833//     public static final Symbol T = exportConstant("T", PACKAGE_CL, null);
     1834    public static final Symbol T = Symbol.T;
     1835    static {
     1836//         T.setSymbolValue(T);
     1837        T.initializeConstant(T);
    18361838    }
    18371839
     
    19461948        exportSpecial("*COMPILE-FILE-ZIP*", PACKAGE_SYS, T);
    19471949
    1948     // ### *macroexpand-hook*
    1949 //     public static final Symbol _MACROEXPAND_HOOK_ =
    1950 //         exportSpecial("*MACROEXPAND-HOOK*", PACKAGE_CL, Symbol.FUNCALL);
    19511950    static {
    19521951        Symbol.MACROEXPAND_HOOK.initializeSpecial(Symbol.FUNCALL);
     
    19551954    // ### array-dimension-limit
    19561955    public static final int ARRAY_DIMENSION_MAX = 0x1000000;
    1957     public static final Symbol ARRAY_DIMENSION_LIMIT =
    1958         exportConstant("ARRAY-DIMENSION-LIMIT", PACKAGE_CL,
    1959                        new Fixnum(ARRAY_DIMENSION_MAX));
     1956//     public static final Symbol ARRAY_DIMENSION_LIMIT =
     1957//         exportConstant("ARRAY-DIMENSION-LIMIT", PACKAGE_CL,
     1958//                        new Fixnum(ARRAY_DIMENSION_MAX));
     1959    static {
     1960        Symbol.ARRAY_DIMENSION_LIMIT.initializeConstant(new Fixnum(ARRAY_DIMENSION_MAX));
     1961    }
    19601962
    19611963    // ### char-code-limit
    19621964    // "The upper exclusive bound on the value returned by the function CHAR-CODE."
    19631965    public static final int CHAR_MAX = 256;
    1964     public static final Symbol CHAR_CODE_LIMIT =
    1965         exportConstant("CHAR-CODE-LIMIT", PACKAGE_CL, new Fixnum(CHAR_MAX));
    1966 
    1967     // ### *read-base*
    1968     public static final Symbol _READ_BASE_ =
    1969         exportSpecial("*READ-BASE*", PACKAGE_CL, new Fixnum(10));
    1970 
    1971     // ### *read-default-float-format*
    1972     public static final Symbol _READ_DEFAULT_FLOAT_FORMAT_ =
    1973         exportSpecial("*READ-DEFAULT-FLOAT-FORMAT*", PACKAGE_CL, Symbol.SINGLE_FLOAT);
     1966    static {
     1967        Symbol.CHAR_CODE_LIMIT.initializeConstant(new Fixnum(CHAR_MAX));
     1968    }
     1969
     1970    static {
     1971        Symbol.READ_BASE.initializeSpecial(new Fixnum(10));
     1972    }
     1973
     1974    static {
     1975        Symbol.READ_DEFAULT_FLOAT_FORMAT.initializeSpecial(Symbol.SINGLE_FLOAT);
     1976    }
    19741977
    19751978    // Printer control variables.
    1976     public static final Symbol _PRINT_ARRAY_ =
    1977         exportSpecial("*PRINT-ARRAY*", PACKAGE_CL, T);
    1978 
    1979 //     public static final Symbol PRINT_BASE =
    1980 //         exportSpecial("*PRINT-BASE*", PACKAGE_CL, new Fixnum(10));
    1981     static {
     1979    static {
     1980        Symbol.PRINT_ARRAY.initializeSpecial(T);
    19821981        Symbol.PRINT_BASE.initializeSpecial(new Fixnum(10));
    1983     }
    1984 
    1985 //     public static final Symbol _PRINT_CASE_ =
    1986 //         exportSpecial("*PRINT-CASE*", PACKAGE_CL, Keyword.UPCASE);
    1987     static {
    19881982        Symbol.PRINT_CASE.initializeSpecial(Keyword.UPCASE);
    1989     }
    1990 
    1991 //     public static final Symbol PRINT_CIRCLE =
    1992 //         exportSpecial("*PRINT-CIRCLE*", PACKAGE_CL, NIL);
    1993     static {
    19941983        Symbol.PRINT_CIRCLE.initializeSpecial(NIL);
    1995     }
    1996 
    1997     static {
    19981984        Symbol.PRINT_ESCAPE.initializeSpecial(T);
    19991985        Symbol.PRINT_GENSYM.initializeSpecial(T);
    2000     }
    2001 
    2002     public static final Symbol _PRINT_LENGTH_ =
    2003         exportSpecial("*PRINT-LENGTH*", PACKAGE_CL, NIL);
    2004 
    2005     public static final Symbol _PRINT_LEVEL_ =
    2006         exportSpecial("*PRINT-LEVEL*", PACKAGE_CL, NIL);
    2007 
    2008     public static final Symbol _PRINT_LINES_ =
    2009         exportSpecial("*PRINT-LINES*", PACKAGE_CL, NIL);
    2010 
    2011     public static final Symbol _PRINT_MISER_WIDTH_ =
    2012         exportSpecial("*PRINT-MISER-WIDTH*", PACKAGE_CL, NIL);
    2013 
    2014     public static final Symbol _PRINT_PPRINT_DISPATCH_ =
    2015         exportSpecial("*PRINT-PPRINT-DISPATCH*", PACKAGE_CL, NIL);
    2016 
    2017     public static final Symbol _PRINT_PRETTY_ =
    2018         exportSpecial("*PRINT-PRETTY*", PACKAGE_CL, NIL);
    2019 
    2020     static {
     1986        Symbol.PRINT_LENGTH.initializeSpecial(NIL);
     1987        Symbol.PRINT_LEVEL.initializeSpecial(NIL);
     1988        Symbol.PRINT_LINES.initializeSpecial(NIL);
     1989        Symbol.PRINT_MISER_WIDTH.initializeSpecial(NIL);
     1990        Symbol.PRINT_PPRINT_DISPATCH.initializeSpecial(NIL);
     1991        Symbol.PRINT_PRETTY.initializeSpecial(NIL);
    20211992        Symbol.PRINT_RADIX.initializeSpecial(NIL);
    20221993        Symbol.PRINT_READABLY.initializeSpecial(NIL);
    2023     }
    2024 
    2025     public static final Symbol _PRINT_RIGHT_MARGIN_ =
    2026         exportSpecial("*PRINT-RIGHT-MARGIN*", PACKAGE_CL, NIL);
     1994        Symbol.PRINT_RIGHT_MARGIN.initializeSpecial(NIL);
     1995    }
    20271996
    20281997    public static final Symbol _PRINT_STRUCTURE_ =
     
    20402009        internSpecial("*PRINT-FASL*", PACKAGE_SYS, NIL);
    20412010
    2042     public static final Symbol _RANDOM_STATE_ =
    2043         exportSpecial("*RANDOM-STATE*", PACKAGE_CL, new RandomState());
     2011    static {
     2012        Symbol._RANDOM_STATE_.initializeSpecial(new RandomState());
     2013    }
    20442014
    20452015    static {
     
    21132083
    21142084    // ### call-arguments-limit
    2115     public static final Symbol CALL_ARGUMENTS_LIMIT =
    2116         exportConstant("CALL-ARGUMENTS-LIMIT", PACKAGE_CL, new Fixnum(50));
     2085//     public static final Symbol CALL_ARGUMENTS_LIMIT =
     2086//         exportConstant("CALL-ARGUMENTS-LIMIT", PACKAGE_CL, new Fixnum(50));
     2087    static {
     2088        Symbol.CALL_ARGUMENTS_LIMIT.initializeConstant(new Fixnum(50));
     2089    }
    21172090
    21182091    // ### lambda-parameters-limit
    2119     public static final Symbol LAMBDA_PARAMETERS_LIMIT =
    2120         exportConstant("LAMBDA-PARAMETERS-LIMIT", PACKAGE_CL, new Fixnum(50));
     2092//     public static final Symbol LAMBDA_PARAMETERS_LIMIT =
     2093//         exportConstant("LAMBDA-PARAMETERS-LIMIT", PACKAGE_CL, new Fixnum(50));
     2094    static {
     2095        Symbol.LAMBDA_PARAMETERS_LIMIT.initializeConstant(new Fixnum(50));
     2096    }
    21212097
    21222098    // ### multiple-values-limit
    2123     public static final Symbol MULTIPLE_VALUES_LIMIT =
    2124         exportConstant("MULTIPLE-VALUES-LIMIT", PACKAGE_CL, new Fixnum(20));
     2099//     public static final Symbol MULTIPLE_VALUES_LIMIT =
     2100//         exportConstant("MULTIPLE-VALUES-LIMIT", PACKAGE_CL, new Fixnum(20));
     2101    static {
     2102        Symbol.MULTIPLE_VALUES_LIMIT.initializeConstant(new Fixnum(20));
     2103    }
    21252104
    21262105    // ### internal-time-units-per-second
    2127     public static final Symbol INTERNAL_TIME_UNITS_PER_SECOND =
    2128         exportConstant("INTERNAL-TIME-UNITS-PER-SECOND", PACKAGE_CL,
    2129                        new Fixnum(1000));
     2106//     public static final Symbol INTERNAL_TIME_UNITS_PER_SECOND =
     2107//         exportConstant("INTERNAL-TIME-UNITS-PER-SECOND", PACKAGE_CL,
     2108//                        new Fixnum(1000));
     2109    static {
     2110        Symbol.INTERNAL_TIME_UNITS_PER_SECOND.initializeSpecial(new Fixnum(1000));
     2111    }
    21302112
    21312113    // ### call-registers-limit
     
    22452227        loadClass("org.armedbear.lisp.BuiltInClass");
    22462228        loadClass("org.armedbear.lisp.StructureObject");
    2247 
    22482229        loadClass("org.armedbear.lisp.ash");
    2249 
    22502230        cold = false;
    22512231    }
  • trunk/j/src/org/armedbear/lisp/RandomState.java

    r8784 r10210  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: RandomState.java,v 1.5 2005-03-17 14:55:44 piso Exp $
     5 * $Id: RandomState.java,v 1.6 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    114114    }
    115115
    116     // ### random
    117     // random limit &optional random-state => random-number
     116    // ### random limit &optional random-state => random-number
    118117    private static final Primitive RANDOM =
    119118        new Primitive("random", "limit &optional random-state")
     
    122121        {
    123122            RandomState randomState =
    124                 (RandomState) _RANDOM_STATE_.symbolValueNoThrow();
     123                (RandomState) Symbol._RANDOM_STATE_.symbolValue();
    125124            return randomState.random(arg);
    126125        }
     
    132131                return randomState.random(first);
    133132            }
    134             return signal(new TypeError(first, Symbol.RANDOM_STATE));
     133            return signalTypeError(first, Symbol.RANDOM_STATE);
    135134        }
    136135    };
     
    142141        public LispObject execute() throws ConditionThrowable
    143142        {
    144             return new RandomState((RandomState)_RANDOM_STATE_.symbolValueNoThrow());
     143            return new RandomState((RandomState)Symbol._RANDOM_STATE_.symbolValue());
    145144        }
    146145        public LispObject execute(LispObject arg)
     
    148147        {
    149148            if (arg == NIL)
    150                 return new RandomState((RandomState)_RANDOM_STATE_.symbolValueNoThrow());
     149                return new RandomState((RandomState)Symbol._RANDOM_STATE_.symbolValue());
    151150            if (arg == T)
    152151                return new RandomState();
    153152            if (arg instanceof RandomState)
    154153                return new RandomState((RandomState)arg);
    155             return signal(new TypeError(arg, Symbol.RANDOM_STATE));
     154            return signalTypeError(arg, Symbol.RANDOM_STATE);
    156155        }
    157156    };
  • trunk/j/src/org/armedbear/lisp/SingleFloat.java

    r10202 r10210  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: SingleFloat.java,v 1.4 2005-10-23 16:39:49 piso Exp $
     5 * $Id: SingleFloat.java,v 1.5 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    493493        LispThread thread = LispThread.currentThread();
    494494        if (Symbol.PRINT_READABLY.symbolValue(thread) != NIL ||
    495             !memq(_READ_DEFAULT_FLOAT_FORMAT_.symbolValue(thread),
     495            !memq(Symbol.READ_DEFAULT_FLOAT_FORMAT.symbolValue(thread),
    496496                  list2(Symbol.SINGLE_FLOAT, Symbol.SHORT_FLOAT)))
    497497        {
  • trunk/j/src/org/armedbear/lisp/StandardObject.java

    r9504 r10210  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: StandardObject.java,v 1.48 2005-06-23 14:18:49 piso Exp $
     5 * $Id: StandardObject.java,v 1.49 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    126126        final LispThread thread = LispThread.currentThread();
    127127        int maxLevel = Integer.MAX_VALUE;
    128         LispObject printLevel = _PRINT_LEVEL_.symbolValue(thread);
     128        LispObject printLevel = Symbol.PRINT_LEVEL.symbolValue(thread);
    129129        if (printLevel instanceof Fixnum)
    130130            maxLevel = ((Fixnum)printLevel).value;
  • trunk/j/src/org/armedbear/lisp/Stream.java

    r10206 r10210  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Stream.java,v 1.142 2005-10-23 17:38:10 piso Exp $
     5 * $Id: Stream.java,v 1.143 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    10181018        final int readBase;
    10191019        try {
    1020             readBase = ((Fixnum)_READ_BASE_.symbolValue(thread)).value;
     1020            readBase = ((Fixnum)Symbol.READ_BASE.symbolValue(thread)).value;
    10211021        }
    10221022        catch (ClassCastException e) {
     
    11431143                    marker = 'D';
    11441144                else if (marker == 'E') {
    1145                     LispObject format = _READ_DEFAULT_FLOAT_FORMAT_.symbolValue();
     1145                    LispObject format = Symbol.READ_DEFAULT_FLOAT_FORMAT.symbolValue();
    11461146                    if (format == Symbol.SINGLE_FLOAT || format == Symbol.SHORT_FLOAT)
    11471147                        marker = 'F';
     
    11591159        try {
    11601160            if (marker == 0) {
    1161                 LispObject format = _READ_DEFAULT_FLOAT_FORMAT_.symbolValue();
     1161                LispObject format = Symbol.READ_DEFAULT_FLOAT_FORMAT.symbolValue();
    11621162                if (format == Symbol.SINGLE_FLOAT || format == Symbol.SHORT_FLOAT)
    11631163                    marker = 'F';
  • trunk/j/src/org/armedbear/lisp/StructureObject.java

    r10209 r10210  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: StructureObject.java,v 1.54 2005-10-23 18:11:10 piso Exp $
     5 * $Id: StructureObject.java,v 1.55 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    158158                return unreadableString(structureClass.getSymbol().writeToString());
    159159            int maxLevel = Integer.MAX_VALUE;
    160             LispObject printLevel = _PRINT_LEVEL_.symbolValue(thread);
     160            LispObject printLevel = Symbol.PRINT_LEVEL.symbolValue(thread);
    161161            if (printLevel instanceof Fixnum)
    162162                maxLevel = ((Fixnum)printLevel).value;
     
    172172                LispObject[] effectiveSlotsArray = effectiveSlots.copyToArray();
    173173                Debug.assertTrue(effectiveSlotsArray.length == slots.length);
    174                 final LispObject printLength = _PRINT_LENGTH_.symbolValue(thread);
     174                final LispObject printLength = Symbol.PRINT_LENGTH.symbolValue(thread);
    175175                final int limit;
    176176                if (printLength instanceof Fixnum)
  • trunk/j/src/org/armedbear/lisp/Symbol.java

    r10209 r10210  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Symbol.java,v 1.222 2005-10-23 18:11:10 piso Exp $
     5 * $Id: Symbol.java,v 1.223 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    810810    public static final Symbol STAR_STAR_STAR =
    811811        PACKAGE_CL.addExternalSymbol("***");
    812     public static final Symbol _BREAK_ON_SIGNALS_ =
     812    public static final Symbol BREAK_ON_SIGNALS =
    813813        PACKAGE_CL.addExternalSymbol("*BREAK-ON-SIGNALS*");
    814814    public static final Symbol _COMPILE_FILE_PATHNAME_ =
     
    822822    public static final Symbol DEBUG_IO =
    823823        PACKAGE_CL.addExternalSymbol("*DEBUG-IO*");
    824     public static final Symbol _DEBUGGER_HOOK_ =
     824    public static final Symbol DEBUGGER_HOOK =
    825825        PACKAGE_CL.addExternalSymbol("*DEBUGGER-HOOK*");
    826826    public static final Symbol DEFAULT_PATHNAME_DEFAULTS =
     
    860860    public static final Symbol PRINT_LENGTH =
    861861        PACKAGE_CL.addExternalSymbol("*PRINT-LENGTH*");
    862     public static final Symbol _PRINT_LEVEL_ =
     862    public static final Symbol PRINT_LEVEL =
    863863        PACKAGE_CL.addExternalSymbol("*PRINT-LEVEL*");
    864     public static final Symbol _PRINT_LINES_ =
     864    public static final Symbol PRINT_LINES =
    865865        PACKAGE_CL.addExternalSymbol("*PRINT-LINES*");
    866     public static final Symbol _PRINT_MISER_WIDTH_ =
     866    public static final Symbol PRINT_MISER_WIDTH =
    867867        PACKAGE_CL.addExternalSymbol("*PRINT-MISER-WIDTH*");
    868     public static final Symbol _PRINT_PPRINT_DISPATCH_ =
     868    public static final Symbol PRINT_PPRINT_DISPATCH =
    869869        PACKAGE_CL.addExternalSymbol("*PRINT-PPRINT-DISPATCH*");
    870     public static final Symbol _PRINT_PRETTY_ =
     870    public static final Symbol PRINT_PRETTY =
    871871        PACKAGE_CL.addExternalSymbol("*PRINT-PRETTY*");
    872872    public static final Symbol PRINT_RADIX =
     
    874874    public static final Symbol PRINT_READABLY =
    875875        PACKAGE_CL.addExternalSymbol("*PRINT-READABLY*");
    876     public static final Symbol _PRINT_RIGHT_MARGIN_ =
     876    public static final Symbol PRINT_RIGHT_MARGIN =
    877877        PACKAGE_CL.addExternalSymbol("*PRINT-RIGHT-MARGIN*");
    878878    public static final Symbol QUERY_IO =
     
    880880    public static final Symbol _RANDOM_STATE_ =
    881881        PACKAGE_CL.addExternalSymbol("*RANDOM-STATE*");
    882     public static final Symbol _READ_BASE_ =
     882    public static final Symbol READ_BASE =
    883883        PACKAGE_CL.addExternalSymbol("*READ-BASE*");
    884     public static final Symbol _READ_DEFAULT_FLOAT_FORMAT_ =
     884    public static final Symbol READ_DEFAULT_FLOAT_FORMAT =
    885885        PACKAGE_CL.addExternalSymbol("*READ-DEFAULT-FLOAT-FORMAT*");
    886886    public static final Symbol READ_EVAL =
  • trunk/j/src/org/armedbear/lisp/ZeroRankArray.java

    r10209 r10210  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: ZeroRankArray.java,v 1.13 2005-10-23 18:11:10 piso Exp $
     5 * $Id: ZeroRankArray.java,v 1.14 2005-10-23 18:44:50 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    120120            }
    121121        }
    122         if (printReadably || _PRINT_ARRAY_.symbolValue(thread) != NIL) {
     122        if (printReadably || Symbol.PRINT_ARRAY.symbolValue(thread) != NIL) {
    123123            StringBuffer sb = new StringBuffer("#0A");
    124124            if (data == this && Symbol.PRINT_CIRCLE.symbolValue(thread) != NIL) {
Note: See TracChangeset for help on using the changeset viewer.