Changeset 8479


Ignore:
Timestamp:
02/06/05 00:55:08 (16 years ago)
Author:
piso
Message:

getAttribute() => getSyntaxType()

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

Legend:

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

    r8351 r8479  
    33 *
    44 * Copyright (C) 2004-2005 Peter Graves
    5  * $Id: LispReader.java,v 1.32 2005-01-13 11:54:36 piso Exp $
     5 * $Id: LispReader.java,v 1.33 2005-02-06 00:54:25 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    189189                    sb.append(c);
    190190                else {
    191                     int attr = currentReadtable().getAttribute(c);
    192                     if (attr == Readtable.ATTR_WHITESPACE ||
    193                         attr == Readtable.ATTR_TERMINATING_MACRO) {
     191                    int syntaxType = currentReadtable().getSyntaxType(c);
     192                    if (syntaxType == Readtable.SYNTAX_TYPE_WHITESPACE ||
     193                        syntaxType == Readtable.SYNTAX_TYPE_TERMINATING_MACRO) {
    194194                        stream._unreadChar(c);
    195195                        break;
  • trunk/j/src/org/armedbear/lisp/Readtable.java

    r8476 r8479  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Readtable.java,v 1.39 2005-02-05 20:48:50 piso Exp $
     5 * $Id: Readtable.java,v 1.40 2005-02-06 00:53:33 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2626public final class Readtable extends LispObject
    2727{
    28     public static final byte ATTR_CONSTITUENT           = 0;
    29     public static final byte ATTR_WHITESPACE            = 1;
    30     public static final byte ATTR_TERMINATING_MACRO     = 2;
    31     public static final byte ATTR_NON_TERMINATING_MACRO = 3;
    32     public static final byte ATTR_SINGLE_ESCAPE         = 4;
    33     public static final byte ATTR_MULTIPLE_ESCAPE       = 5;
    34 
    35     private final byte[]          attributes           = new byte[CHAR_MAX];
     28    public static final byte SYNTAX_TYPE_CONSTITUENT           = 0;
     29    public static final byte SYNTAX_TYPE_WHITESPACE            = 1;
     30    public static final byte SYNTAX_TYPE_TERMINATING_MACRO     = 2;
     31    public static final byte SYNTAX_TYPE_NON_TERMINATING_MACRO = 3;
     32    public static final byte SYNTAX_TYPE_SINGLE_ESCAPE         = 4;
     33    public static final byte SYNTAX_TYPE_MULTIPLE_ESCAPE       = 5;
     34
     35    private final byte[]          syntax               = new byte[CHAR_MAX];
    3636    private final LispObject[]    readerMacroFunctions = new LispObject[CHAR_MAX];
    3737    private final DispatchTable[] dispatchTables       = new DispatchTable[CHAR_MAX];
     
    4141    public Readtable()
    4242    {
    43         attributes[9]    = ATTR_WHITESPACE; // tab
    44         attributes[10]   = ATTR_WHITESPACE; // linefeed
    45         attributes[12]   = ATTR_WHITESPACE; // form feed
    46         attributes[13]   = ATTR_WHITESPACE; // return
    47         attributes[' ']  = ATTR_WHITESPACE;
    48 
    49         attributes['"']  = ATTR_TERMINATING_MACRO;
    50         attributes['\''] = ATTR_TERMINATING_MACRO;
    51         attributes['(']  = ATTR_TERMINATING_MACRO;
    52         attributes[')']  = ATTR_TERMINATING_MACRO;
    53         attributes[',']  = ATTR_TERMINATING_MACRO;
    54         attributes[';']  = ATTR_TERMINATING_MACRO;
    55         attributes['`']  = ATTR_TERMINATING_MACRO;
    56 
    57         attributes['#']  = ATTR_NON_TERMINATING_MACRO;
    58 
    59         attributes['\\'] = ATTR_SINGLE_ESCAPE;
    60         attributes['|']  = ATTR_MULTIPLE_ESCAPE;
     43        syntax[9]    = SYNTAX_TYPE_WHITESPACE; // tab
     44        syntax[10]   = SYNTAX_TYPE_WHITESPACE; // linefeed
     45        syntax[12]   = SYNTAX_TYPE_WHITESPACE; // form feed
     46        syntax[13]   = SYNTAX_TYPE_WHITESPACE; // return
     47        syntax[' ']  = SYNTAX_TYPE_WHITESPACE;
     48
     49        syntax['"']  = SYNTAX_TYPE_TERMINATING_MACRO;
     50        syntax['\''] = SYNTAX_TYPE_TERMINATING_MACRO;
     51        syntax['(']  = SYNTAX_TYPE_TERMINATING_MACRO;
     52        syntax[')']  = SYNTAX_TYPE_TERMINATING_MACRO;
     53        syntax[',']  = SYNTAX_TYPE_TERMINATING_MACRO;
     54        syntax[';']  = SYNTAX_TYPE_TERMINATING_MACRO;
     55        syntax['`']  = SYNTAX_TYPE_TERMINATING_MACRO;
     56
     57        syntax['#']  = SYNTAX_TYPE_NON_TERMINATING_MACRO;
     58
     59        syntax['\\'] = SYNTAX_TYPE_SINGLE_ESCAPE;
     60        syntax['|']  = SYNTAX_TYPE_MULTIPLE_ESCAPE;
    6161
    6262        readerMacroFunctions[';']  = LispReader.READ_COMMENT;
     
    108108            rt = checkReadtable(obj);
    109109        synchronized (rt) {
    110             System.arraycopy(rt.attributes, 0, attributes, 0,
     110            System.arraycopy(rt.syntax, 0, syntax, 0,
    111111                             CHAR_MAX);
    112112            System.arraycopy(rt.readerMacroFunctions, 0, readerMacroFunctions, 0,
     
    125125    private static void copyReadtable(Readtable from, Readtable to)
    126126    {
    127         System.arraycopy(from.attributes, 0, to.attributes, 0,
     127        System.arraycopy(from.syntax, 0, to.syntax, 0,
    128128                         CHAR_MAX);
    129129        System.arraycopy(from.readerMacroFunctions, 0, to.readerMacroFunctions, 0,
     
    171171    {
    172172        if (c < CHAR_MAX)
    173             return attributes[c] == ATTR_WHITESPACE;
     173            return syntax[c] == SYNTAX_TYPE_WHITESPACE;
    174174        return false;
    175175    }
    176176
    177     public byte getAttribute(char c)
     177    public byte getSyntaxType(char c)
    178178    {
    179179        if (c < CHAR_MAX)
    180             return attributes[c];
    181         return ATTR_CONSTITUENT;
     180            return syntax[c];
     181        return SYNTAX_TYPE_CONSTITUENT;
    182182    }
    183183
     
    226226        LispObject non_terminating_p;
    227227        if (function != null) {
    228             byte attribute = attributes[c];
    229             if (attribute == ATTR_NON_TERMINATING_MACRO)
     228            if (syntax[c] == SYNTAX_TYPE_NON_TERMINATING_MACRO)
    230229                non_terminating_p = T;
    231230            else
     
    240239    private void makeDispatchMacroCharacter(char dispChar, LispObject non_terminating_p)
    241240    {
    242         byte attribute;
     241        byte syntaxType;
    243242        if (non_terminating_p != NIL)
    244             attribute = ATTR_NON_TERMINATING_MACRO;
     243            syntaxType = SYNTAX_TYPE_NON_TERMINATING_MACRO;
    245244        else
    246             attribute = ATTR_TERMINATING_MACRO;
     245            syntaxType = SYNTAX_TYPE_TERMINATING_MACRO;
    247246        // FIXME synchronization
    248         attributes[dispChar] = attribute;
     247        syntax[dispChar] = syntaxType;
    249248        readerMacroFunctions[dispChar] = LispReader.READ_DISPATCH_CHAR;
    250249        dispatchTables[dispChar] = new DispatchTable();
     
    373372            Readtable rt = currentReadtable();
    374373            // FIXME synchronization
    375             rt.attributes[c] = ATTR_TERMINATING_MACRO;
     374            rt.syntax[c] = SYNTAX_TYPE_TERMINATING_MACRO;
    376375            rt.readerMacroFunctions[c] = coerceToFunction(second);
    377376            return T;
     
    384383            char c = LispCharacter.getValue(first);
    385384            Readtable rt = currentReadtable();
    386             byte attribute;
     385            byte syntaxType;
    387386            if (third != NIL)
    388                 attribute = ATTR_NON_TERMINATING_MACRO;
    389             else
    390                 attribute = ATTR_TERMINATING_MACRO;
     387                syntaxType = SYNTAX_TYPE_NON_TERMINATING_MACRO;
     388            else
     389                syntaxType = SYNTAX_TYPE_TERMINATING_MACRO;
    391390            // FIXME synchronization
    392             rt.attributes[c] = attribute;
     391            rt.syntax[c] = syntaxType;
    393392            rt.readerMacroFunctions[c] = coerceToFunction(second);
    394393            return T;
     
    400399                return signal(new WrongNumberOfArgumentsException(this));
    401400            char c = LispCharacter.getValue(args[0]);
    402             byte attribute;
     401            byte syntaxType;
    403402            if (args[2] != NIL)
    404                 attribute = ATTR_NON_TERMINATING_MACRO;
    405             else
    406                 attribute = ATTR_TERMINATING_MACRO;
     403                syntaxType = SYNTAX_TYPE_NON_TERMINATING_MACRO;
     404            else
     405                syntaxType = SYNTAX_TYPE_TERMINATING_MACRO;
    407406            Readtable rt = checkReadtable(args[3]);
    408407            // FIXME synchronization
    409             rt.attributes[c] = attribute;
     408            rt.syntax[c] = syntaxType;
    410409            rt.readerMacroFunctions[c] = coerceToFunction(args[1]);
    411410            return T;
     
    508507                fromReadtable = new Readtable(NIL);
    509508            // FIXME synchronization
    510             toReadtable.attributes[toChar] = fromReadtable.attributes[fromChar];
     509            toReadtable.syntax[toChar] = fromReadtable.syntax[fromChar];
    511510            toReadtable.readerMacroFunctions[toChar] =
    512511                fromReadtable.readerMacroFunctions[fromChar];
  • trunk/j/src/org/armedbear/lisp/Stream.java

    r8478 r8479  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Stream.java,v 1.108 2005-02-06 00:40:22 piso Exp $
     5 * $Id: Stream.java,v 1.109 2005-02-06 00:55:08 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    548548            }
    549549            char c = (char) n;
    550             byte attr = rt.getAttribute(c);
    551             if (attr == Readtable.ATTR_SINGLE_ESCAPE) {
     550            byte syntaxType = rt.getSyntaxType(c);
     551            if (syntaxType == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE) {
    552552                n = _readChar();
    553553                if (n < 0) {
     
    559559                continue;
    560560            }
    561             if (attr == Readtable.ATTR_MULTIPLE_ESCAPE)
     561            if (syntaxType == Readtable.SYNTAX_TYPE_MULTIPLE_ESCAPE)
    562562                break;
    563563            sb.append(c);
     
    694694            Debug.assertTrue(sb.length() == 1);
    695695            char c = sb.charAt(0);
    696             byte attr = rt.getAttribute(c);
    697             if (attr == Readtable.ATTR_SINGLE_ESCAPE) {
     696            byte syntaxType = rt.getSyntaxType(c);
     697            if (syntaxType == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE) {
    698698                int n = _readChar();
    699699                if (n < 0) {
     
    705705                flags = new BitSet(1);
    706706                flags.set(0);
    707             } else if (attr == Readtable.ATTR_MULTIPLE_ESCAPE) {
     707            } else if (syntaxType == Readtable.SYNTAX_TYPE_MULTIPLE_ESCAPE) {
    708708                sb.setLength(0);
    709709                sb.append(readMultipleEscape(rt));
     
    729729                break;
    730730            }
    731             byte attribute = rt.getAttribute(c);
    732             if (attribute == Readtable.ATTR_TERMINATING_MACRO) {
     731            byte syntaxType = rt.getSyntaxType(c);
     732            if (syntaxType == Readtable.SYNTAX_TYPE_TERMINATING_MACRO) {
    733733                _unreadChar(c);
    734734                break;
    735735            }
    736736            rt.checkInvalid(c);
    737             if (attribute == Readtable.ATTR_SINGLE_ESCAPE) {
     737            if (syntaxType == Readtable.SYNTAX_TYPE_SINGLE_ESCAPE) {
    738738                n = _readChar();
    739739                if (n < 0)
     
    745745                continue;
    746746            }
    747             if (attribute == Readtable.ATTR_MULTIPLE_ESCAPE) {
     747            if (syntaxType == Readtable.SYNTAX_TYPE_MULTIPLE_ESCAPE) {
    748748                int begin = sb.length();
    749749                sb.append(readMultipleEscape(rt));
Note: See TracChangeset for help on using the changeset viewer.