Changeset 11010


Ignore:
Timestamp:
03/16/06 00:47:27 (15 years ago)
Author:
piso
Message:

Reformatted source.

File:
1 edited

Legend:

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

    r10199 r11010  
    22 * dolist.java
    33 *
    4  * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: dolist.java,v 1.12 2005-10-23 16:04:42 piso Exp $
     4 * Copyright (C) 2003-2006 Peter Graves
     5 * $Id: dolist.java,v 1.13 2006-03-16 00:47:27 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2525public final class dolist extends SpecialOperator
    2626{
    27     private dolist()
    28     {
    29         super(Symbol.DOLIST);
    30     }
     27  private dolist()
     28  {
     29    super(Symbol.DOLIST);
     30  }
    3131
    32     public LispObject execute(LispObject args, Environment env)
    33         throws ConditionThrowable
    34     {
    35         LispObject bodyForm = args.cdr();
    36         args = args.car();
    37         Symbol var = checkSymbol(args.car());
    38         LispObject listForm = args.cadr();
    39         final LispThread thread = LispThread.currentThread();
    40         LispObject resultForm = args.cdr().cdr().car();
    41         SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    42         final LispObject stack = thread.getStack();
    43         // Process declarations.
    44         LispObject specials = NIL;
    45         while (bodyForm != NIL) {
    46             LispObject obj = bodyForm.car();
    47             if (obj instanceof Cons && obj.car() == Symbol.DECLARE) {
    48                 LispObject decls = obj.cdr();
    49                 while (decls != NIL) {
    50                     LispObject decl = decls.car();
    51                     if (decl instanceof Cons && decl.car() == Symbol.SPECIAL) {
    52                         LispObject vars = decl.cdr();
    53                         while (vars != NIL) {
    54                             specials = new Cons(vars.car(), specials);
    55                             vars = vars.cdr();
    56                         }
    57                     }
    58                     decls = decls.cdr();
    59                 }
    60                 bodyForm = bodyForm.cdr();
    61             } else
    62                 break;
    63         }
    64         try {
    65             LispObject list = checkList(eval(listForm, env, thread));
    66             final Environment ext = new Environment(env);
    67             // Look for tags.
    68             LispObject remaining = bodyForm;
    69             while (remaining != NIL) {
    70                 LispObject current = remaining.car();
    71                 remaining = remaining.cdr();
     32  public LispObject execute(LispObject args, Environment env)
     33    throws ConditionThrowable
     34  {
     35    LispObject bodyForm = args.cdr();
     36    args = args.car();
     37    Symbol var = checkSymbol(args.car());
     38    LispObject listForm = args.cadr();
     39    final LispThread thread = LispThread.currentThread();
     40    LispObject resultForm = args.cdr().cdr().car();
     41    SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
     42    final LispObject stack = thread.getStack();
     43    // Process declarations.
     44    LispObject specials = NIL;
     45    while (bodyForm != NIL)
     46      {
     47        LispObject obj = bodyForm.car();
     48        if (obj instanceof Cons && obj.car() == Symbol.DECLARE)
     49          {
     50            LispObject decls = obj.cdr();
     51            while (decls != NIL)
     52              {
     53                LispObject decl = decls.car();
     54                if (decl instanceof Cons && decl.car() == Symbol.SPECIAL)
     55                  {
     56                    LispObject vars = decl.cdr();
     57                    while (vars != NIL)
     58                      {
     59                        specials = new Cons(vars.car(), specials);
     60                        vars = vars.cdr();
     61                      }
     62                  }
     63                decls = decls.cdr();
     64              }
     65            bodyForm = bodyForm.cdr();
     66          }
     67        else
     68          break;
     69      }
     70    try
     71      {
     72        LispObject list = checkList(eval(listForm, env, thread));
     73        final Environment ext = new Environment(env);
     74        // Look for tags.
     75        LispObject remaining = bodyForm;
     76        while (remaining != NIL)
     77          {
     78            LispObject current = remaining.car();
     79            remaining = remaining.cdr();
     80            if (current instanceof Cons)
     81              continue;
     82            // It's a tag.
     83            ext.addTagBinding(current, remaining);
     84          }
     85        // Implicit block.
     86        ext.addBlock(NIL, new LispObject());
     87        // Establish a reusable binding.
     88        final Object binding;
     89        if (specials != NIL && memq(var, specials))
     90          {
     91            thread.bindSpecial(var, null);
     92            binding = thread.getSpecialBinding(var);
     93            ext.declareSpecial(var);
     94          }
     95        else if (var.isSpecialVariable())
     96          {
     97            thread.bindSpecial(var, null);
     98            binding = thread.getSpecialBinding(var);
     99          }
     100        else
     101          {
     102            ext.bind(var, null);
     103            binding = ext.getBinding(var);
     104          }
     105        while (list != NIL)
     106          {
     107            if (binding instanceof SpecialBinding)
     108              ((SpecialBinding)binding).value = list.car();
     109            else
     110              ((Binding)binding).value = list.car();
     111            LispObject body = bodyForm;
     112            while (body != NIL)
     113              {
     114                LispObject current = body.car();
    72115                if (current instanceof Cons)
    73                     continue;
    74                 // It's a tag.
    75                 ext.addTagBinding(current, remaining);
    76             }
    77             // Implicit block.
    78             ext.addBlock(NIL, new LispObject());
    79             // Establish a reusable binding.
    80             final Object binding;
    81             if (specials != NIL && memq(var, specials)) {
    82                 thread.bindSpecial(var, null);
    83                 binding = thread.getSpecialBinding(var);
    84                 ext.declareSpecial(var);
    85             } else if (var.isSpecialVariable()) {
    86                 thread.bindSpecial(var, null);
    87                 binding = thread.getSpecialBinding(var);
    88             } else {
    89                 ext.bind(var, null);
    90                 binding = ext.getBinding(var);
    91             }
    92             while (list != NIL) {
    93                 if (binding instanceof SpecialBinding)
    94                     ((SpecialBinding)binding).value = list.car();
    95                 else
    96                     ((Binding)binding).value = list.car();
    97                 LispObject body = bodyForm;
    98                 while (body != NIL) {
    99                     LispObject current = body.car();
    100                     if (current instanceof Cons) {
    101                         try {
    102                             // Handle GO inline if possible.
    103                             if (current.car() == Symbol.GO) {
    104                                 LispObject tag = current.cadr();
    105                                 Binding b = ext.getTagBinding(tag);
    106                                 if (b != null && b.value != null) {
    107                                     body = b.value;
    108                                     continue;
    109                                 }
    110                                 throw new Go(tag);
    111                             }
    112                             eval(current, ext, thread);
    113                         }
    114                         catch (Go go) {
    115                             LispObject tag = go.getTag();
     116                  {
     117                    try
     118                      {
     119                        // Handle GO inline if possible.
     120                        if (current.car() == Symbol.GO)
     121                          {
     122                            LispObject tag = current.cadr();
    116123                            Binding b = ext.getTagBinding(tag);
    117                             if (b != null && b.value != null) {
     124                            if (b != null && b.value != null)
     125                              {
    118126                                body = b.value;
    119                                 thread.setStack(stack);
    120127                                continue;
    121                             }
    122                             throw go;
    123                         }
    124                     }
    125                     body = body.cdr();
    126                 }
    127                 list = list.cdr();
    128                 if (interrupted)
    129                     handleInterrupt();
    130             }
    131             if (binding instanceof SpecialBinding)
    132                 ((SpecialBinding)binding).value = NIL;
    133             else
    134                 ((Binding)binding).value = NIL;
    135             LispObject result = eval(resultForm, ext, thread);
    136             return result;
    137         }
    138         catch (Return ret) {
    139             if (ret.getTag() == NIL) {
    140                 thread.setStack(stack);
    141                 return ret.getResult();
    142             }
    143             throw ret;
    144         }
    145         finally {
    146             thread.lastSpecialBinding = lastSpecialBinding;
    147         }
    148     }
     128                              }
     129                            throw new Go(tag);
     130                          }
     131                        eval(current, ext, thread);
     132                      }
     133                    catch (Go go)
     134                      {
     135                        LispObject tag = go.getTag();
     136                        Binding b = ext.getTagBinding(tag);
     137                        if (b != null && b.value != null)
     138                          {
     139                            body = b.value;
     140                            thread.setStack(stack);
     141                            continue;
     142                          }
     143                        throw go;
     144                      }
     145                  }
     146                body = body.cdr();
     147              }
     148            list = list.cdr();
     149            if (interrupted)
     150              handleInterrupt();
     151          }
     152        if (binding instanceof SpecialBinding)
     153          ((SpecialBinding)binding).value = NIL;
     154        else
     155          ((Binding)binding).value = NIL;
     156        LispObject result = eval(resultForm, ext, thread);
     157        return result;
     158      }
     159    catch (Return ret)
     160      {
     161        if (ret.getTag() == NIL)
     162          {
     163            thread.setStack(stack);
     164            return ret.getResult();
     165          }
     166        throw ret;
     167      }
     168    finally
     169      {
     170        thread.lastSpecialBinding = lastSpecialBinding;
     171      }
     172  }
    149173
    150     private static final dolist DOLIST = new dolist();
     174  private static final dolist DOLIST = new dolist();
    151175}
Note: See TracChangeset for help on using the changeset viewer.