Changeset 10194


Ignore:
Timestamp:
10/23/05 13:05:24 (16 years ago)
Author:
piso
Message:

Symbol refactoring (work in progress).

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

Legend:

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

    r10132 r10194  
    33 *
    44 * Copyright (C) 2005 Peter Graves
    5  * $Id: FaslReader.java,v 1.6 2005-10-17 15:44:44 piso Exp $
     5 * $Id: FaslReader.java,v 1.7 2005-10-23 13:05:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    184184            final LispThread thread = LispThread.currentThread();
    185185            final Readtable rt = FaslReadtable.getInstance();
    186             final boolean suppress = _READ_SUPPRESS_.symbolValue(thread) != NIL;
     186            final boolean suppress =
     187                (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL);
    187188            FastStringBuffer sb = new FastStringBuffer();
    188189            while (true) {
  • trunk/j/src/org/armedbear/lisp/Interpreter.java

    r10135 r10194  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Interpreter.java,v 1.93 2005-10-17 16:45:19 piso Exp $
     5 * $Id: Interpreter.java,v 1.94 2005-10-23 13:05:23 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(_DEBUGGER_HOOK_, _DEBUGGER_HOOK_FUNCTION);
     540        thread.bindSpecial(Symbol._DEBUGGER_HOOK_, _DEBUGGER_HOOK_FUNCTION);
    541541        try {
    542542            return eval(obj, new Environment(), thread);
     
    590590    private static String prompt()
    591591    {
    592         Package pkg = (Package) _PACKAGE_.getSymbolValue();
     592        Package pkg = (Package) Symbol._PACKAGE_.getSymbolValue();
    593593        String pkgName = pkg.getNickname();
    594594        if (pkgName == null)
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r10174 r10194  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Lisp.java,v 1.400 2005-10-21 12:03:34 piso Exp $
     5 * $Id: Lisp.java,v 1.401 2005-10-23 13:02:13 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6868
    6969    // ### nil
     70    // Constructing NIL forces the Symbol class to be loaded (since Nil extends
     71    // Symbol).
    7072    public static final LispObject NIL = new Nil(PACKAGE_CL);
    7173
     
    102104            t.printStackTrace();
    103105        }
    104     }
    105 
    106     // Constructing NIL forces the Symbol class to be loaded (since Nil extends
    107     // Symbol). The Symbol class defines a number of named Symbol objects so
    108     // they can be referred to in the Java code. addInitialExports() is careful
    109     // not to touch symbols that have already been defined, so the Java names
    110     // assigned in Symbol.java continue to reference the right Symbol objects.
    111     static {
    112         PACKAGE_CL.addInitialExports(Exports.COMMON_LISP_SYMBOL_NAMES);
    113106    }
    114107
     
    13241317            return (Stream) obj;
    13251318        if (obj == T)
    1326             return checkCharacterInputStream(_TERMINAL_IO_.symbolValue());
     1319            return checkCharacterInputStream(Symbol._TERMINAL_IO_.symbolValue());
    13271320        if (obj == NIL)
    1328             return checkCharacterInputStream(_STANDARD_INPUT_.symbolValue());
     1321            return checkCharacterInputStream(Symbol._STANDARD_INPUT_.symbolValue());
    13291322        signalTypeError(obj, Symbol.STREAM);
    13301323        // Not reached.
     
    17361729    }
    17371730
    1738     public static final Symbol _PACKAGE_ =
    1739         exportSpecial("*PACKAGE*", PACKAGE_CL, PACKAGE_CL_USER);
     1731    static {
     1732        Symbol._PACKAGE_.initializeSpecial(PACKAGE_CL_USER);
     1733    }
    17401734
    17411735    public static final Package getCurrentPackage()
    17421736    {
    1743         return (Package) _PACKAGE_.symbolValueNoThrow();
     1737        return (Package) Symbol._PACKAGE_.symbolValueNoThrow();
    17441738    }
    17451739
     
    17481742    private static Stream stdout = new Stream(System.out, Symbol.CHARACTER, true);
    17491743
    1750     public static final Symbol _STANDARD_INPUT_ =
    1751         exportSpecial("*STANDARD-INPUT*", PACKAGE_CL, stdin);
    1752 
    1753     public static final Symbol _STANDARD_OUTPUT_ =
    1754         exportSpecial("*STANDARD-OUTPUT*", PACKAGE_CL, stdout);
    1755 
    1756     public static final Symbol _ERROR_OUTPUT_ =
    1757         exportSpecial("*ERROR-OUTPUT*", PACKAGE_CL, stdout);
    1758 
    1759     public static final Symbol _TRACE_OUTPUT_ =
    1760         exportSpecial("*TRACE-OUTPUT*", PACKAGE_CL, stdout);
    1761 
    1762     public static final Symbol _TERMINAL_IO_ =
    1763         exportSpecial("*TERMINAL-IO*", PACKAGE_CL,
    1764                       new TwoWayStream(stdin, stdout, true));
    1765 
    1766     public static final Symbol _QUERY_IO_ =
    1767         exportSpecial("*QUERY-IO*", PACKAGE_CL,
    1768                       new TwoWayStream(stdin, stdout, true));
    1769 
    1770     public static final Symbol _DEBUG_IO_ =
    1771         exportSpecial("*DEBUG-IO*", PACKAGE_CL,
    1772                       new TwoWayStream(stdin, stdout, true));
     1744    static {
     1745        Symbol._STANDARD_INPUT_.initializeSpecial(stdin);
     1746    }
     1747
     1748    static {
     1749        Symbol._STANDARD_OUTPUT_.initializeSpecial(stdout);
     1750    }
     1751
     1752    static {
     1753        Symbol._ERROR_OUTPUT_.initializeSpecial(stdout);
     1754    }
     1755
     1756    static {
     1757        Symbol._TRACE_OUTPUT_.initializeSpecial(stdout);
     1758    }
     1759
     1760    static {
     1761        Symbol._TERMINAL_IO_.initializeSpecial(new TwoWayStream(stdin, stdout, true));
     1762    }
     1763
     1764    static {
     1765        Symbol._QUERY_IO_.initializeSpecial(new TwoWayStream(stdin, stdout, true));
     1766    }
     1767
     1768    static {
     1769        Symbol._DEBUG_IO_.initializeSpecial(new TwoWayStream(stdin, stdout, true));
     1770    }
    17731771
    17741772    public static final void resetIO(Stream in, Stream out)
     
    17761774        stdin = in;
    17771775        stdout = out;
    1778         _STANDARD_INPUT_.setSymbolValue(stdin);
    1779         _STANDARD_OUTPUT_.setSymbolValue(stdout);
    1780         _ERROR_OUTPUT_.setSymbolValue(stdout);
    1781         _TRACE_OUTPUT_.setSymbolValue(stdout);
    1782         _TERMINAL_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true));
    1783         _QUERY_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true));
    1784         _DEBUG_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true));
     1776        Symbol._STANDARD_INPUT_.setSymbolValue(stdin);
     1777        Symbol._STANDARD_OUTPUT_.setSymbolValue(stdout);
     1778        Symbol._ERROR_OUTPUT_.setSymbolValue(stdout);
     1779        Symbol._TRACE_OUTPUT_.setSymbolValue(stdout);
     1780        Symbol._TERMINAL_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true));
     1781        Symbol._QUERY_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true));
     1782        Symbol._DEBUG_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true));
    17851783    }
    17861784
     
    17931791    public static final TwoWayStream getTerminalIO()
    17941792    {
    1795         return (TwoWayStream) _TERMINAL_IO_.symbolValueNoThrow();
     1793        return (TwoWayStream) Symbol._TERMINAL_IO_.symbolValueNoThrow();
    17961794    }
    17971795
    17981796    public static final Stream getStandardInput()
    17991797    {
    1800         return (Stream) _STANDARD_INPUT_.symbolValueNoThrow();
     1798        return (Stream) Symbol._STANDARD_INPUT_.symbolValueNoThrow();
    18011799    }
    18021800
    18031801    public static final Stream getStandardOutput() throws ConditionThrowable
    18041802    {
    1805         return checkCharacterOutputStream(_STANDARD_OUTPUT_.symbolValue());
    1806     }
    1807 
    1808     public static final Symbol _READTABLE_ =
    1809         exportSpecial("*READTABLE*", PACKAGE_CL, new Readtable());
     1803        return checkCharacterOutputStream(Symbol._STANDARD_OUTPUT_.symbolValue());
     1804    }
     1805
     1806    static {
     1807        Symbol._READTABLE_.initializeSpecial(new Readtable());
     1808    }
    18101809
    18111810    public static final Readtable currentReadtable() throws ConditionThrowable
    18121811    {
    1813         return (Readtable) _READTABLE_.symbolValue();
    1814     }
    1815 
    1816     public static final Symbol _READ_SUPPRESS_ =
    1817         exportSpecial("*READ-SUPPRESS*", PACKAGE_CL, NIL);
    1818 
    1819     public static final Symbol _DEBUGGER_HOOK_ =
    1820         exportSpecial("*DEBUGGER-HOOK*", PACKAGE_CL, NIL);
    1821 
    1822     public static final Symbol MOST_POSITIVE_FIXNUM =
    1823         exportConstant("MOST-POSITIVE-FIXNUM", PACKAGE_CL,
    1824             new Fixnum(Integer.MAX_VALUE));
    1825 
    1826     public static final Symbol MOST_NEGATIVE_FIXNUM =
    1827         exportConstant("MOST-NEGATIVE-FIXNUM", PACKAGE_CL,
    1828             new Fixnum(Integer.MIN_VALUE));
     1812        return (Readtable) Symbol._READTABLE_.symbolValue();
     1813    }
     1814
     1815    static {
     1816        Symbol._READ_SUPPRESS_.initializeSpecial(NIL);
     1817    }
     1818
     1819    static {
     1820        Symbol._DEBUGGER_HOOK_.initializeSpecial(NIL);
     1821    }
     1822
     1823    static {
     1824        Symbol.MOST_POSITIVE_FIXNUM.initializeConstant(new Fixnum(Integer.MAX_VALUE));
     1825    }
     1826
     1827    static {
     1828        Symbol.MOST_NEGATIVE_FIXNUM.initializeConstant(new Fixnum(Integer.MIN_VALUE));
     1829    }
    18291830
    18301831    public static void exit(int status)
     
    20392040        exportSpecial("*PRINT-RADIX*", PACKAGE_CL, NIL);
    20402041
    2041     public static final Symbol _PRINT_READABLY_ =
    2042         exportSpecial("*PRINT-READABLY*", PACKAGE_CL, NIL);
     2042    public static final Symbol _PRINT_READABLY_ = Symbol._PRINT_READABLY_;
     2043    static {
     2044        _PRINT_READABLY_.initializeSpecial(NIL);
     2045    }
    20432046
    20442047    public static final Symbol _PRINT_RIGHT_MARGIN_ =
  • trunk/j/src/org/armedbear/lisp/LispReader.java

    r10132 r10194  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: LispReader.java,v 1.42 2005-10-17 15:44:44 piso Exp $
     5 * $Id: LispReader.java,v 1.43 2005-10-23 13:05:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5151        {
    5252            final LispThread thread = LispThread.currentThread();
    53             final Readtable rt = (Readtable) _READTABLE_.symbolValue(thread);
     53            final Readtable rt = (Readtable) Symbol._READTABLE_.symbolValue(thread);
    5454            FastStringBuffer sb = new FastStringBuffer();
    5555            while (true) {
     
    184184        {
    185185            final LispThread thread = LispThread.currentThread();
    186             final Readtable rt = (Readtable) _READTABLE_.symbolValue(thread);
    187             final boolean suppress = _READ_SUPPRESS_.symbolValue(thread) != NIL;
     186            final Readtable rt = (Readtable) Symbol._READTABLE_.symbolValue(thread);
     187            final boolean suppress = Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL;
    188188            FastStringBuffer sb = new FastStringBuffer();
    189189            while (true) {
     
    383383        {
    384384            final LispThread thread = LispThread.currentThread();
    385             final Readtable rt = (Readtable) _READTABLE_.symbolValue(thread);
     385            final Readtable rt = (Readtable) Symbol._READTABLE_.symbolValue(thread);
    386386            return stream.readCharacterLiteral(rt, thread);
    387387        }
  • trunk/j/src/org/armedbear/lisp/LispThread.java

    r10111 r10194  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: LispThread.java,v 1.84 2005-10-15 16:16:23 piso Exp $
     5 * $Id: LispThread.java,v 1.85 2005-10-23 13:05:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    812812                int count = 0;
    813813                Stream out =
    814                     checkCharacterOutputStream(_TRACE_OUTPUT_.symbolValue());
     814                    checkCharacterOutputStream(Symbol._TRACE_OUTPUT_.symbolValue());
    815815                out._writeLine("Evaluation stack:");
    816816                out._finishOutput();
  • trunk/j/src/org/armedbear/lisp/Load.java

    r10135 r10194  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Load.java,v 1.120 2005-10-17 16:45:19 piso Exp $
     5 * $Id: Load.java,v 1.121 2005-10-23 13:05:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    175175        if (auto) {
    176176            SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    177             thread.bindSpecial(_READTABLE_,
     177            thread.bindSpecial(Symbol._READTABLE_,
    178178                               Readtable._STANDARD_READTABLE_.symbolValue(thread));
    179             thread.bindSpecial(_PACKAGE_, PACKAGE_CL_USER);
     179            thread.bindSpecial(Symbol._PACKAGE_, PACKAGE_CL_USER);
    180180            try {
    181181                return loadSystemFile(filename,
     
    359359        // "LOAD binds *READTABLE* and *PACKAGE* to the values they held before
    360360        // loading the file."
    361         thread.bindSpecialToCurrentValue(_READTABLE_);
    362         thread.bindSpecialToCurrentValue(_PACKAGE_);
     361        thread.bindSpecialToCurrentValue(Symbol._READTABLE_);
     362        thread.bindSpecialToCurrentValue(Symbol._PACKAGE_);
    363363        int loadDepth = Fixnum.getValue(_LOAD_DEPTH_.symbolValue(thread));
    364364        thread.bindSpecial(_LOAD_DEPTH_, new Fixnum(++loadDepth));
     
    434434                if (print) {
    435435                    Stream out =
    436                         checkCharacterOutputStream(_STANDARD_OUTPUT_.symbolValue(thread));
     436                        checkCharacterOutputStream(Symbol._STANDARD_OUTPUT_.symbolValue(thread));
    437437                    out._writeLine(result.writeToString());
    438438                    out._finishOutput();
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r10189 r10194  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Primitives.java,v 1.836 2005-10-22 19:34:25 piso Exp $
     5 * $Id: Primitives.java,v 1.837 2005-10-23 13:05:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    715715            try {
    716716                if (second == T)
    717                     out = (Stream) _TERMINAL_IO_.symbolValue();
     717                    out = (Stream) Symbol._TERMINAL_IO_.symbolValue();
    718718                else if (second == NIL)
    719                     out = (Stream) _STANDARD_OUTPUT_.symbolValue();
     719                    out = (Stream) Symbol._STANDARD_OUTPUT_.symbolValue();
    720720                else
    721721                    out = (Stream) second;
     
    762762        {
    763763            if (arg == T)
    764                 arg = _TERMINAL_IO_.symbolValue();
     764                arg = Symbol._TERMINAL_IO_.symbolValue();
    765765            else if (arg == NIL)
    766                 arg = _STANDARD_OUTPUT_.symbolValue();
     766                arg = Symbol._STANDARD_OUTPUT_.symbolValue();
    767767            final Stream stream;
    768768            try {
     
    784784        {
    785785            if (arg == T)
    786                 arg = _TERMINAL_IO_.symbolValue();
     786                arg = Symbol._TERMINAL_IO_.symbolValue();
    787787            else if (arg == NIL)
    788                 arg = _STANDARD_OUTPUT_.symbolValue();
     788                arg = Symbol._STANDARD_OUTPUT_.symbolValue();
    789789            final Stream stream;
    790790            try {
     
    14991499        {
    15001500            if (destination == T) {
    1501                 checkCharacterOutputStream(_STANDARD_OUTPUT_.symbolValue())._writeString(s);
     1501                checkCharacterOutputStream(Symbol._STANDARD_OUTPUT_.symbolValue())._writeString(s);
    15021502                return NIL;
    15031503            }
     
    15481548                    } else {
    15491549                        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    1550                         thread.bindSpecial(_PACKAGE_, PACKAGE_CL);
     1550                        thread.bindSpecial(Symbol._PACKAGE_, PACKAGE_CL);
    15511551                        try {
    15521552                            Symbol.STYLE_WARN.execute(new SimpleString("redefining ~S in ~S"),
     
    27872787                s = new SimpleString(arg.getStringValue());
    27882788            final LispThread thread = LispThread.currentThread();
    2789             Package pkg = (Package) _PACKAGE_.symbolValue(thread);
     2789            Package pkg = (Package) Symbol._PACKAGE_.symbolValue(thread);
    27902790            return pkg.intern(s, thread);
    27912791        }
     
    29342934                                               " does not designate any package."));
    29352935            SpecialBinding binding =
    2936                 LispThread.currentThread().getSpecialBinding(_PACKAGE_);
     2936                LispThread.currentThread().getSpecialBinding(Symbol._PACKAGE_);
    29372937            if (binding != null)
    29382938                binding.value = pkg;
    29392939            else
    29402940                // No dynamic binding.
    2941                 _PACKAGE_.setSymbolValue(pkg);
     2941                Symbol._PACKAGE_.setSymbolValue(pkg);
    29422942            return pkg;
    29432943        }
     
    37383738            }
    37393739            if (second == T)
    3740                 second = _TERMINAL_IO_.symbolValue();
     3740                second = Symbol._TERMINAL_IO_.symbolValue();
    37413741            else if (second == NIL)
    3742                 second = _STANDARD_OUTPUT_.symbolValue();
     3742                second = Symbol._STANDARD_OUTPUT_.symbolValue();
    37433743            final Stream stream;
    37443744            try {
     
    37733773            try {
    37743774                if (second == T)
    3775                     out = (Stream) _TERMINAL_IO_.symbolValue();
     3775                    out = (Stream) Symbol._TERMINAL_IO_.symbolValue();
    37763776                else if (second == NIL)
    3777                     out = (Stream) _STANDARD_OUTPUT_.symbolValue();
     3777                    out = (Stream) Symbol._STANDARD_OUTPUT_.symbolValue();
    37783778                else
    37793779                    out = (Stream) second;
     
    38323832        try {
    38333833            if (arg == T)
    3834                 out = (Stream) _TERMINAL_IO_.symbolValue();
     3834                out = (Stream) Symbol._TERMINAL_IO_.symbolValue();
    38353835            else if (arg == NIL)
    3836                 out = (Stream) _STANDARD_OUTPUT_.symbolValue();
     3836                out = (Stream) Symbol._STANDARD_OUTPUT_.symbolValue();
    38373837            else
    38383838                out = (Stream) arg;
     
    38553855            final Stream in;
    38563856            if (args.length == 0)
    3857                 in = checkCharacterInputStream(_STANDARD_INPUT_.symbolValue());
     3857                in = checkCharacterInputStream(Symbol._STANDARD_INPUT_.symbolValue());
    38583858            else
    38593859                in = inSynonymOf(args[0]);
     
    39853985                return arg;
    39863986            if (arg == T)
    3987                 return _TERMINAL_IO_.symbolValue();
     3987                return Symbol._TERMINAL_IO_.symbolValue();
    39883988            if (arg == NIL)
    3989                 return _STANDARD_OUTPUT_.symbolValue();
     3989                return Symbol._STANDARD_OUTPUT_.symbolValue();
    39903990            return arg;
    39913991        }
     
    40524052        public LispObject execute() throws ConditionThrowable
    40534053        {
    4054             final LispObject obj = _STANDARD_INPUT_.symbolValue();
     4054            final LispObject obj = Symbol._STANDARD_INPUT_.symbolValue();
    40554055            final Stream stream;
    40564056            try {
     
    41534153        {
    41544154            final LispThread thread = LispThread.currentThread();
    4155             final LispObject obj = _STANDARD_INPUT_.symbolValue(thread);
     4155            final LispObject obj = Symbol._STANDARD_INPUT_.symbolValue(thread);
    41564156            final Stream stream;
    41574157            try {
     
    41674167            final LispThread thread = LispThread.currentThread();
    41684168            if (arg == T)
    4169                 arg = _TERMINAL_IO_.symbolValue(thread);
     4169                arg = Symbol._TERMINAL_IO_.symbolValue(thread);
    41704170            else if (arg == NIL)
    4171                 arg = _STANDARD_INPUT_.symbolValue(thread);
     4171                arg = Symbol._STANDARD_INPUT_.symbolValue(thread);
    41724172            final Stream stream;
    41734173            try {
     
    41844184            final LispThread thread = LispThread.currentThread();
    41854185            if (first == T)
    4186                 first = _TERMINAL_IO_.symbolValue(thread);
     4186                first = Symbol._TERMINAL_IO_.symbolValue(thread);
    41874187            else if (first == NIL)
    4188                 first = _STANDARD_INPUT_.symbolValue(thread);
     4188                first = Symbol._STANDARD_INPUT_.symbolValue(thread);
    41894189            final Stream stream;
    41904190            try {
     
    42024202            final LispThread thread = LispThread.currentThread();
    42034203            if (first == T)
    4204                 first = _TERMINAL_IO_.symbolValue(thread);
     4204                first = Symbol._TERMINAL_IO_.symbolValue(thread);
    42054205            else if (first == NIL)
    4206                 first = _STANDARD_INPUT_.symbolValue(thread);
     4206                first = Symbol._STANDARD_INPUT_.symbolValue(thread);
    42074207            final Stream stream;
    42084208            try {
     
    42204220            final LispThread thread = LispThread.currentThread();
    42214221            if (first == T)
    4222                 first = _TERMINAL_IO_.symbolValue(thread);
     4222                first = Symbol._TERMINAL_IO_.symbolValue(thread);
    42234223            else if (first == NIL)
    4224                 first = _STANDARD_INPUT_.symbolValue(thread);
     4224                first = Symbol._STANDARD_INPUT_.symbolValue(thread);
    42254225            final Stream stream;
    42264226            try {
     
    42644264        public LispObject execute() throws ConditionThrowable
    42654265        {
    4266             return checkCharacterInputStream(_STANDARD_INPUT_.symbolValue()).readChar();
     4266            return checkCharacterInputStream(Symbol._STANDARD_INPUT_.symbolValue()).readChar();
    42674267        }
    42684268        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Stream.java

    r10135 r10194  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Stream.java,v 1.139 2005-10-17 16:45:19 piso Exp $
     5 * $Id: Stream.java,v 1.140 2005-10-23 13:05:24 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    243243                if (n >= 0) {
    244244                    char c = (char) n;
    245                     Readtable rt = (Readtable) _READTABLE_.symbolValue(thread);
     245                    Readtable rt = (Readtable) Symbol._READTABLE_.symbolValue(thread);
    246246                    if (!rt.isWhitespace(c))
    247247                        _unreadChar(c);
     
    249249            }
    250250        }
    251         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     251        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    252252            return NIL;
    253253        else
     
    267267    {
    268268        if (recursive) {
    269             final Readtable rt = (Readtable) _READTABLE_.symbolValue(thread);
     269            final Readtable rt = (Readtable) Symbol._READTABLE_.symbolValue(thread);
    270270            while (true) {
    271271                int n = _readChar();
     
    306306            }
    307307        }
    308         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     308        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    309309            return NIL;
    310310        else
     
    375375    {
    376376        final Readtable rt =
    377             (Readtable) _READTABLE_.symbolValue(LispThread.currentThread());
     377            (Readtable) Symbol._READTABLE_.symbolValue(LispThread.currentThread());
    378378        FastStringBuffer sb = new FastStringBuffer();
    379379        _readToken(sb, rt);
     
    392392        final LispThread thread = LispThread.currentThread();
    393393        LispObject obj = read(true, NIL, false, thread);
    394         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     394        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    395395            return NIL;
    396396        if (obj.listp()) {
     
    435435        final LispThread thread = LispThread.currentThread();
    436436        LispObject obj = faslRead(true, NIL, false, thread);
    437         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     437        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    438438            return NIL;
    439439        if (obj.listp()) {
     
    485485        while (true) {
    486486            if (!useFaslReadtable)
    487                 rt = (Readtable) _READTABLE_.symbolValue(thread);
     487                rt = (Readtable) Symbol._READTABLE_.symbolValue(thread);
    488488            char c = flushWhitespace(rt);
    489489            if (c == ')') {
     
    497497                if (isTokenDelimiter(nextChar, rt)) {
    498498                    if (last == null) {
    499                         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     499                        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    500500                            return NIL;
    501501                        else
     
    573573            rt = FaslReadtable.getInstance();
    574574        else
    575             rt = (Readtable) _READTABLE_.symbolValue(thread);
     575            rt = (Readtable) Symbol._READTABLE_.symbolValue(thread);
    576576        LispObject fun = rt.getDispatchMacroCharacter(dispChar, c);
    577577        if (fun instanceof DispatchMacroFunction)
     
    612612            sb.append(c);
    613613        }
    614         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     614        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    615615            return NIL;
    616616        if (sb.length() == 1)
     
    649649        final LispThread thread = LispThread.currentThread();
    650650        LispObject obj = read(true, NIL, true, thread);
    651         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     651        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    652652            return NIL;
    653653        switch (rank) {
     
    671671        final LispThread thread = LispThread.currentThread();
    672672        LispObject obj = faslRead(true, NIL, true, thread);
    673         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     673        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    674674            return NIL;
    675675        switch (rank) {
     
    693693        final LispThread thread = LispThread.currentThread();
    694694        LispObject obj = read(true, NIL, true, thread);
    695         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     695        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    696696            return NIL;
    697697        if (obj instanceof Cons && obj.length() == 2)
     
    721721        final LispThread thread = LispThread.currentThread();
    722722        LispObject obj = faslRead(true, NIL, true, thread);
    723         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     723        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    724724            return NIL;
    725725        if (obj instanceof Cons && obj.length() == 2)
     
    808808        final LispThread thread = LispThread.currentThread();
    809809        BitSet flags = _readToken(sb, rt);
    810         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     810        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    811811            return NIL;
    812812        final LispObject readtableCase = rt.getReadtableCase();
     
    893893        }
    894894        // Intern token in current package.
    895         return ((Package)_PACKAGE_.symbolValue(thread)).intern(new SimpleString(token));
     895        return ((Package)Symbol._PACKAGE_.symbolValue(thread)).intern(new SimpleString(token));
    896896    }
    897897
     
    11801180        final LispThread thread = LispThread.currentThread();
    11811181        final Readtable rt =
    1182             (Readtable) _READTABLE_.symbolValue(thread);
     1182            (Readtable) Symbol._READTABLE_.symbolValue(thread);
    11831183        boolean escaped = (_readToken(sb, rt) != null);
    1184         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     1184        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    11851185            return NIL;
    11861186        if (escaped)
     
    12081208        final Readtable rt = FaslReadtable.getInstance();
    12091209        boolean escaped = (_readToken(sb, rt) != null);
    1210         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     1210        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    12111211            return NIL;
    12121212        if (escaped)
     
    12491249        LispObject result = NIL;
    12501250        while (true) {
    1251             Readtable rt = (Readtable) _READTABLE_.symbolValue(thread);
     1251            Readtable rt = (Readtable) Symbol._READTABLE_.symbolValue(thread);
    12521252            char c = flushWhitespace(rt);
    12531253            if (c == delimiter)
     
    12571257                result = new Cons(obj, result);
    12581258        }
    1259         if (_READ_SUPPRESS_.symbolValue(thread) != NIL)
     1259        if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
    12601260            return NIL;
    12611261        else
  • trunk/j/src/org/armedbear/lisp/Time.java

    r10135 r10194  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Time.java,v 1.29 2005-10-17 16:45:20 piso Exp $
     5 * $Id: Time.java,v 1.30 2005-10-23 13:05:24 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5555                long count = Cons.getCount();
    5656                Stream out =
    57                     checkCharacterOutputStream(_TRACE_OUTPUT_.symbolValue());
     57                    checkCharacterOutputStream(Symbol._TRACE_OUTPUT_.symbolValue());
    5858                out.freshLine();
    5959                StringBuffer sb = new StringBuffer();
  • trunk/j/src/org/armedbear/lisp/arglist.java

    r9881 r10194  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: arglist.java,v 1.20 2005-08-16 17:39:58 piso Exp $
     5 * $Id: arglist.java,v 1.21 2005-10-23 13:05:24 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7070                // to intern any symbols.
    7171                SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    72                 thread.bindSpecial(_PACKAGE_, PACKAGE_EXT);
     72                thread.bindSpecial(Symbol._PACKAGE_, PACKAGE_EXT);
    7373                try {
    7474                    arglist = readObjectFromString(s);
  • trunk/j/src/org/armedbear/lisp/listen.java

    r6190 r10194  
    22 * listen.java
    33 *
    4  * Copyright (C) 2004 Peter Graves
    5  * $Id: listen.java,v 1.2 2004-03-11 11:37:53 piso Exp $
     4 * Copyright (C) 2004-2005 Peter Graves
     5 * $Id: listen.java,v 1.3 2005-10-23 13:05:24 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3333    {
    3434        Stream stream =
    35             checkCharacterInputStream(_STANDARD_INPUT_.symbolValue());
     35            checkCharacterInputStream(Symbol._STANDARD_INPUT_.symbolValue());
    3636        return stream.listen();
    3737    }
Note: See TracChangeset for help on using the changeset viewer.