Changeset 10206


Ignore:
Timestamp:
10/23/05 17:38:10 (16 years ago)
Author:
piso
Message:

Symbol refactoring (work in progress).

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

Legend:

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

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

    r10205 r10206  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Lisp.java,v 1.406 2005-10-23 17:24:10 piso Exp $
     5 * $Id: Lisp.java,v 1.407 2005-10-23 17:38:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    13201320            return (Stream) obj;
    13211321        if (obj == T)
    1322             return checkCharacterInputStream(Symbol._TERMINAL_IO_.symbolValue());
     1322            return checkCharacterInputStream(Symbol.TERMINAL_IO.symbolValue());
    13231323        if (obj == NIL)
    1324             return checkCharacterInputStream(Symbol._STANDARD_INPUT_.symbolValue());
     1324            return checkCharacterInputStream(Symbol.STANDARD_INPUT.symbolValue());
    13251325        signalTypeError(obj, Symbol.STREAM);
    13261326        // Not reached.
     
    17591759
    17601760    static {
    1761         Symbol._STANDARD_INPUT_.initializeSpecial(stdin);
    1762     }
    1763 
    1764     static {
    1765         Symbol._STANDARD_OUTPUT_.initializeSpecial(stdout);
    1766     }
    1767 
    1768     static {
     1761        Symbol.STANDARD_INPUT.initializeSpecial(stdin);
     1762        Symbol.STANDARD_OUTPUT.initializeSpecial(stdout);
    17691763        Symbol._ERROR_OUTPUT_.initializeSpecial(stdout);
    1770     }
    1771 
    1772     static {
    1773         Symbol._TRACE_OUTPUT_.initializeSpecial(stdout);
    1774     }
    1775 
    1776     static {
    1777         Symbol._TERMINAL_IO_.initializeSpecial(new TwoWayStream(stdin, stdout, true));
    1778     }
    1779 
    1780     static {
    1781         Symbol._QUERY_IO_.initializeSpecial(new TwoWayStream(stdin, stdout, true));
    1782     }
    1783 
    1784     static {
     1764        Symbol.TRACE_OUTPUT.initializeSpecial(stdout);
     1765        Symbol.TERMINAL_IO.initializeSpecial(new TwoWayStream(stdin, stdout, true));
     1766        Symbol.QUERY_IO.initializeSpecial(new TwoWayStream(stdin, stdout, true));
    17851767        Symbol._DEBUG_IO_.initializeSpecial(new TwoWayStream(stdin, stdout, true));
    17861768    }
     
    17901772        stdin = in;
    17911773        stdout = out;
    1792         Symbol._STANDARD_INPUT_.setSymbolValue(stdin);
    1793         Symbol._STANDARD_OUTPUT_.setSymbolValue(stdout);
     1774        Symbol.STANDARD_INPUT.setSymbolValue(stdin);
     1775        Symbol.STANDARD_OUTPUT.setSymbolValue(stdout);
    17941776        Symbol._ERROR_OUTPUT_.setSymbolValue(stdout);
    1795         Symbol._TRACE_OUTPUT_.setSymbolValue(stdout);
    1796         Symbol._TERMINAL_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true));
    1797         Symbol._QUERY_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true));
     1777        Symbol.TRACE_OUTPUT.setSymbolValue(stdout);
     1778        Symbol.TERMINAL_IO.setSymbolValue(new TwoWayStream(stdin, stdout, true));
     1779        Symbol.QUERY_IO.setSymbolValue(new TwoWayStream(stdin, stdout, true));
    17981780        Symbol._DEBUG_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true));
    17991781    }
     
    18071789    public static final TwoWayStream getTerminalIO()
    18081790    {
    1809         return (TwoWayStream) Symbol._TERMINAL_IO_.symbolValueNoThrow();
     1791        return (TwoWayStream) Symbol.TERMINAL_IO.symbolValueNoThrow();
    18101792    }
    18111793
    18121794    public static final Stream getStandardInput()
    18131795    {
    1814         return (Stream) Symbol._STANDARD_INPUT_.symbolValueNoThrow();
     1796        return (Stream) Symbol.STANDARD_INPUT.symbolValueNoThrow();
    18151797    }
    18161798
    18171799    public static final Stream getStandardOutput() throws ConditionThrowable
    18181800    {
    1819         return checkCharacterOutputStream(Symbol._STANDARD_OUTPUT_.symbolValue());
     1801        return checkCharacterOutputStream(Symbol.STANDARD_OUTPUT.symbolValue());
    18201802    }
    18211803
     
    18301812
    18311813    static {
    1832         Symbol._READ_SUPPRESS_.initializeSpecial(NIL);
     1814        Symbol.READ_SUPPRESS.initializeSpecial(NIL);
    18331815    }
    18341816
     
    19251907        exportSpecial("*MODULES*", PACKAGE_CL, NIL);
    19261908
    1927     // ### *load-verbose*
    1928     public static final Symbol _LOAD_VERBOSE_ =
    1929         exportSpecial("*LOAD-VERBOSE*", PACKAGE_CL, NIL);
    1930 
    1931     // ### *load-print*
    1932     public static final Symbol _LOAD_PRINT_ =
    1933         exportSpecial("*LOAD-PRINT*", PACKAGE_CL, NIL);
     1909    static {
     1910        Symbol.LOAD_VERBOSE.initializeSpecial(NIL);
     1911        Symbol.LOAD_PRINT.initializeSpecial(NIL);
     1912    }
    19341913
    19351914    // ### *load-pathname*
  • trunk/j/src/org/armedbear/lisp/LispReader.java

    r10194 r10206  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: LispReader.java,v 1.43 2005-10-23 13:05:23 piso Exp $
     5 * $Id: LispReader.java,v 1.44 2005-10-23 17:38:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    185185            final LispThread thread = LispThread.currentThread();
    186186            final Readtable rt = (Readtable) Symbol._READTABLE_.symbolValue(thread);
    187             final boolean suppress = Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL;
     187            final boolean suppress = Symbol.READ_SUPPRESS.symbolValue(thread) != NIL;
    188188            FastStringBuffer sb = new FastStringBuffer();
    189189            while (true) {
  • trunk/j/src/org/armedbear/lisp/LispThread.java

    r10194 r10206  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: LispThread.java,v 1.85 2005-10-23 13:05:23 piso Exp $
     5 * $Id: LispThread.java,v 1.86 2005-10-23 17:38:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    812812                int count = 0;
    813813                Stream out =
    814                     checkCharacterOutputStream(Symbol._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

    r10201 r10206  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Load.java,v 1.122 2005-10-23 16:22:15 piso Exp $
     5 * $Id: Load.java,v 1.123 2005-10-23 17:38:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040        return load(new Pathname(filename),
    4141                    filename,
    42                     _LOAD_VERBOSE_.symbolValue(thread) != NIL,
    43                     _LOAD_PRINT_.symbolValue(thread) != NIL,
     42                    Symbol.LOAD_VERBOSE.symbolValue(thread) != NIL,
     43                    Symbol.LOAD_PRINT.symbolValue(thread) != NIL,
    4444                    true);
    4545    }
     
    164164        final LispThread thread = LispThread.currentThread();
    165165        return loadSystemFile(filename,
    166                               _LOAD_VERBOSE_.symbolValue(thread) != NIL,
    167                               _LOAD_PRINT_.symbolValue(thread) != NIL,
     166                              Symbol.LOAD_VERBOSE.symbolValue(thread) != NIL,
     167                              Symbol.LOAD_PRINT.symbolValue(thread) != NIL,
    168168                              false);
    169169    }
     
    181181                return loadSystemFile(filename,
    182182                                      _AUTOLOAD_VERBOSE_.symbolValue(thread) != NIL,
    183                                       _LOAD_PRINT_.symbolValue(thread) != NIL,
     183                                      Symbol.LOAD_PRINT.symbolValue(thread) != NIL,
    184184                                      auto);
    185185            }
     
    189189        } else {
    190190            return loadSystemFile(filename,
    191                                   _LOAD_VERBOSE_.symbolValue(thread) != NIL,
    192                                   _LOAD_PRINT_.symbolValue(thread) != NIL,
     191                                  Symbol.LOAD_VERBOSE.symbolValue(thread) != NIL,
     192                                  Symbol.LOAD_PRINT.symbolValue(thread) != NIL,
    193193                                  auto);
    194194        }
     
    434434                if (print) {
    435435                    Stream out =
    436                         checkCharacterOutputStream(Symbol._STANDARD_OUTPUT_.symbolValue(thread));
     436                        checkCharacterOutputStream(Symbol.STANDARD_OUTPUT.symbolValue(thread));
    437437                    out._writeLine(result.writeToString());
    438438                    out._finishOutput();
     
    535535            final LispThread thread = LispThread.currentThread();
    536536            return loadSystemFile(arg.getStringValue(),
    537                                   _LOAD_VERBOSE_.symbolValue(thread) != NIL,
    538                                   _LOAD_PRINT_.symbolValue(thread) != NIL,
     537                                  Symbol.LOAD_VERBOSE.symbolValue(thread) != NIL,
     538                                  Symbol.LOAD_PRINT.symbolValue(thread) != NIL,
    539539                                  false);
    540540        }
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r10198 r10206  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Primitives.java,v 1.841 2005-10-23 15:51:45 piso Exp $
     5 * $Id: Primitives.java,v 1.842 2005-10-23 17:38:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    734734            try {
    735735                if (second == T)
    736                     out = (Stream) Symbol._TERMINAL_IO_.symbolValue();
     736                    out = (Stream) Symbol.TERMINAL_IO.symbolValue();
    737737                else if (second == NIL)
    738                     out = (Stream) Symbol._STANDARD_OUTPUT_.symbolValue();
     738                    out = (Stream) Symbol.STANDARD_OUTPUT.symbolValue();
    739739                else
    740740                    out = (Stream) second;
     
    781781        {
    782782            if (arg == T)
    783                 arg = Symbol._TERMINAL_IO_.symbolValue();
     783                arg = Symbol.TERMINAL_IO.symbolValue();
    784784            else if (arg == NIL)
    785                 arg = Symbol._STANDARD_OUTPUT_.symbolValue();
     785                arg = Symbol.STANDARD_OUTPUT.symbolValue();
    786786            final Stream stream;
    787787            try {
     
    803803        {
    804804            if (arg == T)
    805                 arg = Symbol._TERMINAL_IO_.symbolValue();
     805                arg = Symbol.TERMINAL_IO.symbolValue();
    806806            else if (arg == NIL)
    807                 arg = Symbol._STANDARD_OUTPUT_.symbolValue();
     807                arg = Symbol.STANDARD_OUTPUT.symbolValue();
    808808            final Stream stream;
    809809            try {
     
    14971497        {
    14981498            if (destination == T) {
    1499                 checkCharacterOutputStream(Symbol._STANDARD_OUTPUT_.symbolValue())._writeString(s);
     1499                checkCharacterOutputStream(Symbol.STANDARD_OUTPUT.symbolValue())._writeString(s);
    15001500                return NIL;
    15011501            }
     
    37693769            }
    37703770            if (second == T)
    3771                 second = Symbol._TERMINAL_IO_.symbolValue();
     3771                second = Symbol.TERMINAL_IO.symbolValue();
    37723772            else if (second == NIL)
    3773                 second = Symbol._STANDARD_OUTPUT_.symbolValue();
     3773                second = Symbol.STANDARD_OUTPUT.symbolValue();
    37743774            final Stream stream;
    37753775            try {
     
    38043804            try {
    38053805                if (second == T)
    3806                     out = (Stream) Symbol._TERMINAL_IO_.symbolValue();
     3806                    out = (Stream) Symbol.TERMINAL_IO.symbolValue();
    38073807                else if (second == NIL)
    3808                     out = (Stream) Symbol._STANDARD_OUTPUT_.symbolValue();
     3808                    out = (Stream) Symbol.STANDARD_OUTPUT.symbolValue();
    38093809                else
    38103810                    out = (Stream) second;
     
    38633863        try {
    38643864            if (arg == T)
    3865                 out = (Stream) Symbol._TERMINAL_IO_.symbolValue();
     3865                out = (Stream) Symbol.TERMINAL_IO.symbolValue();
    38663866            else if (arg == NIL)
    3867                 out = (Stream) Symbol._STANDARD_OUTPUT_.symbolValue();
     3867                out = (Stream) Symbol.STANDARD_OUTPUT.symbolValue();
    38683868            else
    38693869                out = (Stream) arg;
     
    38853885            final Stream in;
    38863886            if (args.length == 0)
    3887                 in = checkCharacterInputStream(Symbol._STANDARD_INPUT_.symbolValue());
     3887                in = checkCharacterInputStream(Symbol.STANDARD_INPUT.symbolValue());
    38883888            else
    38893889                in = inSynonymOf(args[0]);
     
    40124012                return arg;
    40134013            if (arg == T)
    4014                 return Symbol._TERMINAL_IO_.symbolValue();
     4014                return Symbol.TERMINAL_IO.symbolValue();
    40154015            if (arg == NIL)
    4016                 return Symbol._STANDARD_OUTPUT_.symbolValue();
     4016                return Symbol.STANDARD_OUTPUT.symbolValue();
    40174017            return arg;
    40184018        }
     
    40794079        public LispObject execute() throws ConditionThrowable
    40804080        {
    4081             final LispObject obj = Symbol._STANDARD_INPUT_.symbolValue();
     4081            final LispObject obj = Symbol.STANDARD_INPUT.symbolValue();
    40824082            final Stream stream;
    40834083            try {
     
    41804180        {
    41814181            final LispThread thread = LispThread.currentThread();
    4182             final LispObject obj = Symbol._STANDARD_INPUT_.symbolValue(thread);
     4182            final LispObject obj = Symbol.STANDARD_INPUT.symbolValue(thread);
    41834183            final Stream stream;
    41844184            try {
     
    41944194            final LispThread thread = LispThread.currentThread();
    41954195            if (arg == T)
    4196                 arg = Symbol._TERMINAL_IO_.symbolValue(thread);
     4196                arg = Symbol.TERMINAL_IO.symbolValue(thread);
    41974197            else if (arg == NIL)
    4198                 arg = Symbol._STANDARD_INPUT_.symbolValue(thread);
     4198                arg = Symbol.STANDARD_INPUT.symbolValue(thread);
    41994199            final Stream stream;
    42004200            try {
     
    42114211            final LispThread thread = LispThread.currentThread();
    42124212            if (first == T)
    4213                 first = Symbol._TERMINAL_IO_.symbolValue(thread);
     4213                first = Symbol.TERMINAL_IO.symbolValue(thread);
    42144214            else if (first == NIL)
    4215                 first = Symbol._STANDARD_INPUT_.symbolValue(thread);
     4215                first = Symbol.STANDARD_INPUT.symbolValue(thread);
    42164216            final Stream stream;
    42174217            try {
     
    42294229            final LispThread thread = LispThread.currentThread();
    42304230            if (first == T)
    4231                 first = Symbol._TERMINAL_IO_.symbolValue(thread);
     4231                first = Symbol.TERMINAL_IO.symbolValue(thread);
    42324232            else if (first == NIL)
    4233                 first = Symbol._STANDARD_INPUT_.symbolValue(thread);
     4233                first = Symbol.STANDARD_INPUT.symbolValue(thread);
    42344234            final Stream stream;
    42354235            try {
     
    42474247            final LispThread thread = LispThread.currentThread();
    42484248            if (first == T)
    4249                 first = Symbol._TERMINAL_IO_.symbolValue(thread);
     4249                first = Symbol.TERMINAL_IO.symbolValue(thread);
    42504250            else if (first == NIL)
    4251                 first = Symbol._STANDARD_INPUT_.symbolValue(thread);
     4251                first = Symbol.STANDARD_INPUT.symbolValue(thread);
    42524252            final Stream stream;
    42534253            try {
     
    42914291        public LispObject execute() throws ConditionThrowable
    42924292        {
    4293             return checkCharacterInputStream(Symbol._STANDARD_INPUT_.symbolValue()).readChar();
     4293            return checkCharacterInputStream(Symbol.STANDARD_INPUT.symbolValue()).readChar();
    42944294        }
    42954295        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Stream.java

    r10202 r10206  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Stream.java,v 1.141 2005-10-23 16:39:49 piso Exp $
     5 * $Id: Stream.java,v 1.142 2005-10-23 17:38:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    249249            }
    250250        }
    251         if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
     251        if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
    252252            return NIL;
    253253        else
     
    306306            }
    307307        }
    308         if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
     308        if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
    309309            return NIL;
    310310        else
     
    392392        final LispThread thread = LispThread.currentThread();
    393393        LispObject obj = read(true, NIL, false, thread);
    394         if (Symbol._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 (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
     437        if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
    438438            return NIL;
    439439        if (obj.listp()) {
     
    497497                if (isTokenDelimiter(nextChar, rt)) {
    498498                    if (last == null) {
    499                         if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
     499                        if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
    500500                            return NIL;
    501501                        else
     
    612612            sb.append(c);
    613613        }
    614         if (Symbol._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 (Symbol._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 (Symbol._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 (Symbol._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 (Symbol._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 (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
     810        if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
    811811            return NIL;
    812812        final LispObject readtableCase = rt.getReadtableCase();
     
    11821182            (Readtable) Symbol._READTABLE_.symbolValue(thread);
    11831183        boolean escaped = (_readToken(sb, rt) != null);
    1184         if (Symbol._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 (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
     1210        if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
    12111211            return NIL;
    12121212        if (escaped)
     
    12571257                result = new Cons(obj, result);
    12581258        }
    1259         if (Symbol._READ_SUPPRESS_.symbolValue(thread) != NIL)
     1259        if (Symbol.READ_SUPPRESS.symbolValue(thread) != NIL)
    12601260            return NIL;
    12611261        else
  • trunk/j/src/org/armedbear/lisp/Symbol.java

    r10204 r10206  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Symbol.java,v 1.218 2005-10-23 17:17:00 piso Exp $
     5 * $Id: Symbol.java,v 1.219 2005-10-23 17:38:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    834834    public static final Symbol _LOAD_PATHNAME_ =
    835835        PACKAGE_CL.addExternalSymbol("*LOAD-PATHNAME*");
    836     public static final Symbol _LOAD_PRINT_ =
     836    public static final Symbol LOAD_PRINT =
    837837        PACKAGE_CL.addExternalSymbol("*LOAD-PRINT*");
    838838    public static final Symbol _LOAD_TRUENAME_ =
    839839        PACKAGE_CL.addExternalSymbol("*LOAD-TRUENAME*");
    840     public static final Symbol _LOAD_VERBOSE_ =
     840    public static final Symbol LOAD_VERBOSE =
    841841        PACKAGE_CL.addExternalSymbol("*LOAD-VERBOSE*");
    842842    public static final Symbol _MACROEXPAND_HOOK_ =
     
    876876    public static final Symbol _PRINT_RIGHT_MARGIN_ =
    877877        PACKAGE_CL.addExternalSymbol("*PRINT-RIGHT-MARGIN*");
    878     public static final Symbol _QUERY_IO_ =
     878    public static final Symbol QUERY_IO =
    879879        PACKAGE_CL.addExternalSymbol("*QUERY-IO*");
    880880    public static final Symbol _RANDOM_STATE_ =
     
    886886    public static final Symbol _READ_EVAL_ =
    887887        PACKAGE_CL.addExternalSymbol("*READ-EVAL*");
    888     public static final Symbol _READ_SUPPRESS_ =
     888    public static final Symbol READ_SUPPRESS =
    889889        PACKAGE_CL.addExternalSymbol("*READ-SUPPRESS*");
    890890    public static final Symbol _READTABLE_ =
    891891        PACKAGE_CL.addExternalSymbol("*READTABLE*");
    892     public static final Symbol _STANDARD_INPUT_ =
     892    public static final Symbol STANDARD_INPUT =
    893893        PACKAGE_CL.addExternalSymbol("*STANDARD-INPUT*");
    894     public static final Symbol _STANDARD_OUTPUT_ =
     894    public static final Symbol STANDARD_OUTPUT =
    895895        PACKAGE_CL.addExternalSymbol("*STANDARD-OUTPUT*");
    896     public static final Symbol _TERMINAL_IO_ =
     896    public static final Symbol TERMINAL_IO =
    897897        PACKAGE_CL.addExternalSymbol("*TERMINAL-IO*");
    898     public static final Symbol _TRACE_OUTPUT_ =
     898    public static final Symbol TRACE_OUTPUT =
    899899        PACKAGE_CL.addExternalSymbol("*TRACE-OUTPUT*");
    900900    public static final Symbol PLUS =
  • trunk/j/src/org/armedbear/lisp/Time.java

    r10194 r10206  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Time.java,v 1.30 2005-10-23 13:05:24 piso Exp $
     5 * $Id: Time.java,v 1.31 2005-10-23 17:38:10 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(Symbol._TRACE_OUTPUT_.symbolValue());
     57                    checkCharacterOutputStream(Symbol.TRACE_OUTPUT.symbolValue());
    5858                out.freshLine();
    5959                StringBuffer sb = new StringBuffer();
  • trunk/j/src/org/armedbear/lisp/listen.java

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