Changeset 4832


Ignore:
Timestamp:
11/19/03 02:44:16 (18 years ago)
Author:
piso
Message:

Added support for SPECIAL declarations.

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

Legend:

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

    r4783 r4832  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Lisp.java,v 1.180 2003-11-16 15:33:44 piso Exp $
     5 * $Id: Lisp.java,v 1.181 2003-11-19 02:40:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    353353        if (obj instanceof Symbol) {
    354354            LispObject result = null;
    355             if (obj.isSpecialVariable()) {
     355            if (env.isDeclaredSpecial((Symbol)obj) || obj.isSpecialVariable())
    356356                result = thread.lookupSpecial(obj);
    357             } else
     357            else
    358358                result = env.lookup(obj);
    359359            if (result == null) {
     
    475475                                  Environment env)
    476476    {
    477         if (symbol.isSpecialVariable())
     477        if (env.isDeclaredSpecial(symbol) || symbol.isSpecialVariable())
    478478            LispThread.currentThread().bindSpecial(symbol, value);
    479479        else
     
    484484                                    Environment env)
    485485    {
    486         if (symbol.isSpecialVariable()) {
     486        if (env.isDeclaredSpecial(symbol) || symbol.isSpecialVariable()) {
    487487            Environment dynEnv =
    488488                LispThread.currentThread().getDynamicEnvironment();
  • trunk/j/src/org/armedbear/lisp/SpecialOperators.java

    r4659 r4832  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: SpecialOperators.java,v 1.14 2003-11-06 17:12:33 piso Exp $
     5 * $Id: SpecialOperators.java,v 1.15 2003-11-19 02:44:16 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
     24import java.util.ArrayList;
     25
    2426public final class SpecialOperators extends Lisp
    2527{
     
    5759
    5860    // ### let
    59     private static final SpecialOperator LET = new SpecialOperator("let") {
     61    private static final SpecialOperator LET = new SpecialOperator("let")
     62    {
    6063        public LispObject execute(LispObject args, Environment env)
    6164            throws ConditionThrowable
     
    6669
    6770    // ### let*
    68     private static final SpecialOperator LETX = new SpecialOperator("let*") {
     71    private static final SpecialOperator LETX = new SpecialOperator("let*")
     72    {
    6973        public LispObject execute(LispObject args, Environment env)
    7074            throws ConditionThrowable
     
    7882        throws ConditionThrowable
    7983    {
    80         LispObject varList = checkList(args.car());
     84        LispObject result = NIL;
    8185        final LispThread thread = LispThread.currentThread();
    82         LispObject result = NIL;
    83         if (varList != NIL) {
    84             Environment oldDynEnv = thread.getDynamicEnvironment();
    85             try {
    86                 Environment ext = new Environment(env);
    87                 Environment evalEnv = sequential ? ext : env;
    88                 for (int i = varList.length(); i-- > 0;) {
    89                     LispObject obj = varList.car();
    90                     varList = varList.cdr();
    91                     if (obj instanceof Cons) {
    92                         bind(checkSymbol(obj.car()),
    93                              eval(obj.cadr(), evalEnv, thread),
    94                              ext);
    95                     } else
    96                         bind(checkSymbol(obj), NIL, ext);
    97                 }
    98                 LispObject body = args.cdr();
    99                 while (body != NIL) {
    100                     result = eval(body.car(), ext, thread);
     86        final Environment oldDynEnv = thread.getDynamicEnvironment();
     87        try {
     88            LispObject varList = checkList(args.car());
     89            LispObject body = args.cdr();
     90            Environment ext = new Environment(env);
     91            // FIXME An ArrayList is probably not the most efficient data
     92            // structure for this.
     93            ArrayList specials = null;
     94            while (body != NIL) {
     95                LispObject obj = body.car();
     96                if (obj instanceof Cons && obj.car() == Symbol.DECLARE) {
     97                    LispObject decls = obj.cdr();
     98                    while (decls != NIL) {
     99                        LispObject decl = decls.car();
     100                        if (decl instanceof Cons && decl.car() == Symbol.SPECIAL) {
     101                            LispObject vars = decl.cdr();
     102                            while (vars != NIL) {
     103                                Symbol var = checkSymbol(vars.car());
     104                                if (specials == null)
     105                                    specials = new ArrayList();
     106                                specials.add(var);
     107                                vars = vars.cdr();
     108                            }
     109                        }
     110                        decls = decls.cdr();
     111                    }
    101112                    body = body.cdr();
    102                 }
    103             }
    104             finally {
    105                 thread.setDynamicEnvironment(oldDynEnv);
    106             }
    107         } else {
    108             LispObject body = args.cdr();
     113                } else
     114                    break;
     115            }
     116            Environment evalEnv = sequential ? ext : env;
     117            while (varList != NIL) {
     118                LispObject obj = varList.car();
     119                varList = varList.cdr();
     120                if (obj instanceof Cons) {
     121                    Symbol symbol = checkSymbol(obj.car());
     122                    LispObject value = eval(obj.cadr(), evalEnv, thread);
     123                    if (specials != null && specials.contains(symbol)) {
     124                        thread.bindSpecial(symbol, value);
     125                        ext.declareSpecial(symbol);
     126                    }  else if (symbol.isSpecialVariable())
     127                        thread.bindSpecial(symbol, value);
     128                    else
     129                        ext.bind(symbol, value);
     130                } else {
     131                    Symbol symbol = checkSymbol(obj);
     132                    if (specials != null && specials.contains(symbol)) {
     133                        thread.bindSpecial(symbol, NIL);
     134                        ext.declareSpecial(symbol);
     135                    } else if (symbol.isSpecialVariable())
     136                        thread.bindSpecial(symbol, NIL);
     137                    else
     138                        ext.bind(symbol, NIL);
     139                }
     140            }
    109141            while (body != NIL) {
    110                 result = eval(body.car(), env, thread);
     142                result = eval(body.car(), ext, thread);
    111143                body = body.cdr();
    112144            }
     145        }
     146        finally {
     147            thread.setDynamicEnvironment(oldDynEnv);
    113148        }
    114149        return result;
     
    182217
    183218    // ### locally
    184     private static final SpecialOperator LOCALLY =
    185         new SpecialOperator("locally")
    186     {
    187         public LispObject execute(LispObject args, Environment env)
    188             throws ConditionThrowable
    189         {
    190             LispThread thread = LispThread.currentThread();
    191             while (args != NIL) {
    192                 LispObject obj = args.car();
    193                 if (obj instanceof Cons && obj.car() == Symbol.DECLARE)
    194                     ; // FIXME
    195                 else
    196                     break;
    197                 args = args.cdr();
    198             }
     219    private static final SpecialOperator LOCALLY = new SpecialOperator("locally")
     220    {
     221        public LispObject execute(LispObject args, Environment env)
     222            throws ConditionThrowable
     223        {
     224            final LispThread thread = LispThread.currentThread();
     225            final Environment ext = new Environment(env);
     226            args = ext.processDeclarations(args);
    199227            LispObject result = NIL;
    200228            while (args != NIL) {
    201                 result = eval(args.car(), env, thread);
     229                result = eval(args.car(), ext, thread);
    202230                args = args.cdr();
    203231            }
     
    347375    {
    348376        public LispObject execute(LispObject args, Environment env)
    349         {
     377            throws ConditionThrowable
     378        {
     379            while (args != NIL) {
     380                LispObject decl = args.car();
     381                args = args.cdr();
     382                if (decl instanceof Cons && decl.car() == Symbol.SPECIAL) {
     383                    LispObject vars = decl.cdr();
     384                    while (vars != NIL) {
     385                        Symbol var = checkSymbol(vars.car());
     386                        env.declareSpecial(var);
     387                        vars = vars.cdr();
     388                    }
     389                }
     390            }
    350391            return NIL;
    351392        }
     
    398439                args = args.cdr();
    399440                Binding binding = null;
    400                 if (symbol.isSpecialVariable()) {
     441                if (env.isDeclaredSpecial(symbol) || symbol.isSpecialVariable()) {
    401442                    Environment dynEnv = thread.getDynamicEnvironment();
    402443                    if (dynEnv != null)
Note: See TracChangeset for help on using the changeset viewer.