Changeset 13695


Ignore:
Timestamp:
11/08/11 23:24:05 (9 years ago)
Author:
astalla
Message:

Reimplementation of global symbol macros to avoid using the symbol's value slot.
Global symbol macros are stored on the symbols' property lists instead.
Tested with FSet which uses symbol macros quite heavily to implement and use
global lexical variables.

Location:
trunk/abcl/src/org/armedbear/lisp
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/abcl/src/org/armedbear/lisp/Autoload.java

    r13466 r13695  
    579579        autoload(PACKAGE_SYS, "%set-method-generic-function", "StandardMethod", true);
    580580        autoload(PACKAGE_SYS, "%set-method-specializers", "StandardMethod", true);
     581        autoload(PACKAGE_SYS, "%set-symbol-macro", "Primitives");
    581582        autoload(PACKAGE_SYS, "%simple-bit-vector-bit-and", "SimpleBitVector");
    582583        autoload(PACKAGE_SYS, "%simple-bit-vector-bit-andc1", "SimpleBitVector");
     
    662663        autoload(PACKAGE_SYS, "make-slot-definition", "SlotDefinition", true);
    663664        autoload(PACKAGE_SYS, "make-structure-class", "StructureClass");
    664         autoload(PACKAGE_SYS, "make-symbol-macro", "SymbolMacro");
     665        autoload(PACKAGE_SYS, "make-symbol-macro", "Primitives");
    665666        autoload(PACKAGE_SYS, "method-documentation", "StandardMethod", true);
    666667        autoload(PACKAGE_SYS, "method-lambda-list", "StandardMethod", true);
  • trunk/abcl/src/org/armedbear/lisp/Binding.java

    r12170 r13695  
    4141final class Binding
    4242{
    43     /** The symbol in case of a variable, block or
     43    /** The symbol in case of a variable, block, symbol-macro or
    4444     * non-SETF function binding, the tag (symbol or
    4545     * integer) in case of a tag binding or the cons
     
    6666     * In case of a variable binding, it holds the value associated with the
    6767     * variable, unless specialp is true.
     68     *
     69     * In case of a symbol macro binding, holds the SymbolMacro instance
     70     * holding the macro's expansion.
    6871     */
    6972    LispObject value;
  • trunk/abcl/src/org/armedbear/lisp/Environment.java

    r13444 r13695  
    111111  }
    112112
     113    public LispObject lookup(LispObject symbol, Binding binding) {
     114        while (binding != null) {
     115            if (binding.symbol == symbol)
     116                return binding.value;
     117            binding = binding.next;
     118        }
     119        return null;
     120    }
     121
    113122  public LispObject lookup(LispObject symbol)
    114123  {
    115     Binding binding = vars;
    116     while (binding != null)
    117       {
    118         if (binding.symbol == symbol)
    119           return binding.value;
    120         binding = binding.next;
    121       }
    122     return null;
    123   }
    124 
    125   public Binding getBinding(LispObject symbol)
    126   {
    127     Binding binding = vars;
    128     while (binding != null)
    129       {
    130         if (binding.symbol == symbol)
    131           return binding;
    132         binding = binding.next;
    133       }
     124      return lookup(symbol, vars);
     125  }
     126
     127  public Binding getBinding(LispObject symbol) {
     128    return getBinding(symbol, vars);
     129  }
     130
     131  public Binding getBinding(LispObject symbol, Binding binding) {
     132    while (binding != null) {
     133      if (binding.symbol == symbol)
     134        return binding;
     135      binding = binding.next;
     136    }
    134137    return null;
    135138  }
  • trunk/abcl/src/org/armedbear/lisp/Lisp.java

    r13518 r13695  
    249249      {
    250250        Symbol symbol = (Symbol) form;
    251         LispObject obj = null;
    252         if (symbol.isSpecialVariable())
    253           obj = thread.lookupSpecial(symbol);
    254         else
    255           obj = env.lookup(symbol);
    256         if (obj == null)
    257           obj = symbol.getSymbolValue();
    258         if (obj instanceof SymbolMacro)
     251        LispObject obj = env.lookup(symbol);
     252        if (obj == null) {
     253          obj = symbol.getSymbolMacro();
     254        }
     255        if (obj instanceof SymbolMacro) {
    259256          return thread.setValues(((SymbolMacro)obj).getExpansion(), T);
     257        }
    260258      }
    261259    // Not a macro.
     
    474472        if (result == null)
    475473          {
    476             result = symbol.getSymbolValue();
    477             if (result == null)
     474            result = symbol.getSymbolMacro();
     475            if (result == null) {
     476                result = symbol.getSymbolValue();
     477            }
     478            if(result == null) {
    478479              return error(new UnboundVariable(obj));
     480            }
    479481          }
    480482        if (result instanceof SymbolMacro)
     
    16341636
    16351637  {
    1636           if (obj instanceof Stream)     
    1637                   return (Stream) obj;         
    1638           return (Stream) // Not reached.       
     1638      if (obj instanceof Stream)
     1639                  return (Stream) obj;
     1640          return (Stream) // Not reached.
    16391641        type_error(obj, Symbol.STREAM);
    16401642  }
     
    26232625  {
    26242626    // ### multiple-values-limit
    2625     Symbol.MULTIPLE_VALUES_LIMIT.initializeConstant(Fixnum.constants[20]);
     2627    Symbol.MULTIPLE_VALUES_LIMIT.initializeConstant(Fixnum.constants[32]);
    26262628  }
    26272629
  • trunk/abcl/src/org/armedbear/lisp/Primitives.java

    r13516 r13695  
    677677            final LispObject value;
    678678            value = checkSymbol(arg).symbolValue();
    679             if (value instanceof SymbolMacro)
    680                 return error(new LispError(arg.princToString() +
    681                                            " has no dynamic value."));
    682679            return value;
    683680        }
     
    19491946        public LispObject execute(LispObject arg) {
    19501947            return new SymbolMacro(arg);
     1948        }
     1949    };
     1950
     1951    // ### %set-symbol-macro
     1952    private static final Primitive SET_SYMBOL_MACRO = new pf_set_symbol_macro();
     1953    private static final class pf_set_symbol_macro extends Primitive {
     1954        pf_set_symbol_macro() {
     1955            super("%set-symbol-macro", PACKAGE_SYS, false, "symbol symbol-macro");
     1956        }
     1957
     1958        @Override
     1959        public LispObject execute(LispObject sym, LispObject symbolMacro) {
     1960            checkSymbol(sym).setSymbolMacro((SymbolMacro) symbolMacro);
     1961            return symbolMacro;
    19511962        }
    19521963    };
  • trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java

    r13461 r13695  
    205205                                             " with SYMBOL-MACROLET."));
    206206                        }
    207                         bindArg(null, symbol, new SymbolMacro(obj.cadr()), ext, thread);
     207                        ext.bind(symbol, new SymbolMacro(obj.cadr()));
    208208                    } else {
    209209                        return error(new ProgramError(
     
    526526                if (symbol.isSpecialVariable() || env.isDeclaredSpecial(symbol)) {
    527527                    SpecialBinding binding = thread.getSpecialBinding(symbol);
     528                    value = eval(args.car(), env, thread);
    528529                    if (binding != null) {
    529                         if (binding.value instanceof SymbolMacro) {
    530                             LispObject expansion =
    531                                 ((SymbolMacro)binding.value).getExpansion();
    532                             LispObject form = list(Symbol.SETF, expansion, args.car());
    533                             value = eval(form, env, thread);
    534                         } else {
    535                             value = eval(args.car(), env, thread);
    536                             binding.value = value;
    537                         }
     530                        binding.value = value;
    538531                    } else {
    539                         if (symbol.getSymbolValue() instanceof SymbolMacro) {
    540                             LispObject expansion =
    541                                 ((SymbolMacro)symbol.getSymbolValue()).getExpansion();
    542                             LispObject form = list(Symbol.SETF, expansion, args.car());
    543                             value = eval(form, env, thread);
    544                         } else {
    545                             value = eval(args.car(), env, thread);
    546                             symbol.setSymbolValue(value);
    547                         }
     532                        symbol.setSymbolValue(value);
    548533                    }
    549534                } else {
     
    561546                        }
    562547                    } else {
    563                         if (symbol.getSymbolValue() instanceof SymbolMacro) {
     548                        if (symbol.getSymbolMacro() != null) {
    564549                            LispObject expansion =
    565                                 ((SymbolMacro)symbol.getSymbolValue()).getExpansion();
     550                                symbol.getSymbolMacro().getExpansion();
    566551                            LispObject form = list(Symbol.SETF, expansion, args.car());
    567552                            value = eval(form, env, thread);
  • trunk/abcl/src/org/armedbear/lisp/Symbol.java

    r13442 r13695  
    299299    this.value = value;
    300300  }
     301
     302    public SymbolMacro getSymbolMacro() {
     303        LispObject symbolMacro = get(this, SYMBOL_MACRO, null);
     304        if(symbolMacro instanceof SymbolMacro) {
     305            return (SymbolMacro) symbolMacro;
     306        } else if(symbolMacro != null) {
     307            error(new TypeError("The object " + symbolMacro + " is not a symbol macro"));
     308        }
     309        return null;
     310    }
     311
     312    public void setSymbolMacro(SymbolMacro symbolMacro) {
     313        if(isSpecialVariable()) {
     314            error(new ProgramError("Symbol " + princToString() + " names a special variable; can't install symbol macro."));
     315        }
     316        put(this, SYMBOL_MACRO, symbolMacro);
     317    }
    301318
    302319  /** Returns the value associated with this symbol in the current
     
    30373054  public static final Symbol SET_STD_SLOT_VALUE =
    30383055    PACKAGE_SYS.addExternalSymbol("SET-STD-SLOT-VALUE");
     3056  public static final Symbol SYMBOL_MACRO =
     3057    PACKAGE_SYS.addExternalSymbol("SYMBOL-MACRO");
    30393058  public static final Symbol SUBCLASSP =
    30403059    PACKAGE_SYS.addExternalSymbol("SUBCLASSP");
  • trunk/abcl/src/org/armedbear/lisp/define-symbol-macro.lisp

    r11391 r13695  
    3333
    3434(defun %define-symbol-macro (symbol expansion)
    35   (setf (symbol-value symbol) (make-symbol-macro expansion))
     35  (%set-symbol-macro symbol (make-symbol-macro expansion))
    3636  symbol)
    3737
    3838(defmacro define-symbol-macro (symbol expansion)
    39   (when (special-variable-p symbol)
     39  (when (special-variable-p symbol) ;;TODO astalla also check local declarations?
    4040    (error 'program-error "~S has already been defined as a global variable." symbol))
    4141  `(eval-when (:compile-toplevel :load-toplevel :execute)
Note: See TracChangeset for help on using the changeset viewer.