Changeset 5124


Ignore:
Timestamp:
12/14/03 17:05:34 (18 years ago)
Author:
piso
Message:

Enforce lexical scope of GO tags.

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

Legend:

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

    r4844 r5124  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: dolist.java,v 1.4 2003-11-19 17:34:00 piso Exp $
     5 * $Id: dolist.java,v 1.5 2003-12-14 17:05:34 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6464        try {
    6565            LispObject list = checkList(eval(listForm, env, thread));
     66            final Environment ext = new Environment(env);
    6667            // Look for tags.
    67             Binding tags = null;
    6868            LispObject remaining = bodyForm;
    6969            while (remaining != NIL) {
     
    7373                    continue;
    7474                // It's a tag.
    75                 tags = new Binding(current, remaining, tags);
     75                ext.addTagBinding(current, remaining);
    7676            }
    7777            // Establish a reusable binding.
    78             final Environment ext = new Environment(env);
    7978            final Binding binding;
    8079            if (var.isSpecialVariable() || (specials != NIL && memq(var, specials))) {
     
    9897                            // Handle GO inline if possible.
    9998                            if (current.car() == Symbol.GO) {
    100                                 LispObject code = null;
    10199                                LispObject tag = current.cadr();
    102                                 for (Binding b = tags; b != null; b = b.next) {
    103                                     if (b.symbol.eql(tag)) {
    104                                         code = b.value;
    105                                         break;
    106                                     }
    107                                 }
    108                                 if (code != null) {
    109                                     body = code;
     100                                Binding b = ext.getTagBinding(tag);
     101                                if (b != null && b.value != null) {
     102                                    body = b.value;
    110103                                    continue;
    111104                                }
     
    115108                        }
    116109                        catch (Go go) {
    117                             LispObject code = null;
    118110                            LispObject tag = go.getTag();
    119                             for (Binding b = tags; b != null; b = b.next) {
    120                                 if (b.symbol.eql(tag)) {
    121                                     code = b.value;
    122                                     break;
    123                                 }
    124                             }
    125                             if (code != null) {
    126                                 body = code;
     111                            Binding b = ext.getTagBinding(tag);
     112                            if (b != null && b.value != null) {
     113                                body = b.value;
    127114                                thread.setStackDepth(depth);
    128115                                continue;
  • trunk/j/src/org/armedbear/lisp/dotimes.java

    r5114 r5124  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: dotimes.java,v 1.5 2003-12-13 00:58:51 piso Exp $
     5 * $Id: dotimes.java,v 1.6 2003-12-14 17:05:12 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6363        try {
    6464            LispObject limit = eval(countForm, env, thread);
     65            Environment ext = new Environment(env);
    6566            // Look for tags.
    66             Binding tags = null;
    6767            LispObject remaining = bodyForm;
    6868            while (remaining != NIL) {
     
    7272                    continue;
    7373                // It's a tag.
    74                 tags = new Binding(current, remaining, tags);
     74                ext.addTagBinding(current, remaining);
    7575            }
    7676            LispObject result;
    7777            // Establish a reusable binding.
    78             Environment ext = new Environment(env);
    7978            final Binding binding;
    8079            if (specials != NIL && memq(var, specials)) {
     
    101100                                // Handle GO inline if possible.
    102101                                if (current.car() == Symbol.GO) {
    103                                     LispObject code = null;
    104102                                    LispObject tag = current.cadr();
    105                                     for (Binding b = tags; b != null; b = b.next) {
    106                                         if (b.symbol.eql(tag)) {
    107                                             code = b.value;
    108                                             break;
    109                                         }
    110                                     }
    111                                     if (code != null) {
    112                                         body = code;
     103                                    Binding b = ext.getTagBinding(tag);
     104                                    if (b != null && b.value != null) {
     105                                        body = b.value;
    113106                                        continue;
    114107                                    }
     
    118111                            }
    119112                            catch (Go go) {
    120                                 LispObject code = null;
    121113                                LispObject tag = go.getTag();
    122                                 for (Binding b = tags; b != null; b = b.next) {
    123                                     if (b.symbol.eql(tag)) {
    124                                         code = b.value;
    125                                         break;
    126                                     }
    127                                 }
    128                                 if (code != null) {
    129                                     body = code;
     114                                Binding b = ext.getTagBinding(tag);
     115                                if (b != null && b.value != null) {
     116                                    body = b.value;
    130117                                    thread.setStackDepth(depth);
    131118                                    continue;
     
    150137                                // Handle GO inline if possible.
    151138                                if (current.car() == Symbol.GO) {
    152                                     LispObject code = null;
    153139                                    LispObject tag = current.cadr();
    154                                     for (Binding b = tags; b != null; b = b.next) {
    155                                         if (b.symbol.eql(tag)) {
    156                                             code = b.value;
    157                                             break;
    158                                         }
    159                                     }
    160                                     if (code != null) {
    161                                         body = code;
     140                                    Binding b = ext.getTagBinding(tag);
     141                                    if (b != null && b.value != null) {
     142                                        body = b.value;
    162143                                        continue;
    163144                                    }
     
    169150                                LispObject code = null;
    170151                                LispObject tag = go.getTag();
    171                                 for (Binding b = tags; b != null; b = b.next) {
    172                                     if (b.symbol.eql(tag)) {
    173                                         code = b.value;
    174                                         break;
    175                                     }
    176                                 }
    177                                 if (code != null) {
    178                                     body = code;
     152                                Binding b = ext.getTagBinding(tag);
     153                                if (b != null && b.value != null) {
     154                                    body = b.value;
    179155                                    thread.setStackDepth(depth);
    180156                                    continue;
     
    190166                result = eval(resultForm, ext, thread);
    191167            } else
    192                 return signal(new TypeError(limit, "integer"));
     168                return signal(new TypeError(limit, Symbol.INTEGER));
    193169            return result;
    194170        }
Note: See TracChangeset for help on using the changeset viewer.