Changeset 12460


Ignore:
Timestamp:
02/13/10 19:20:48 (11 years ago)
Author:
vvoutilainen
Message:

Reindentation.

File:
1 edited

Legend:

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

    r12459 r12460  
    3636import static org.armedbear.lisp.Lisp.*;
    3737
    38 public final class Do
    39 {
    40   // ### do
    41   private static final SpecialOperator DO = new sf_do();
    42   private static final class sf_do extends SpecialOperator {
    43       sf_do()
    44       {
    45         super(Symbol.DO, "varlist endlist &body body");
    46       }
    47  
    48       @Override
    49       public LispObject execute(LispObject args, Environment env)
     38public final class Do {
     39    // ### do
     40    private static final SpecialOperator DO = new sf_do();
     41    private static final class sf_do extends SpecialOperator {
     42        sf_do() {
     43            super(Symbol.DO, "varlist endlist &body body");
     44        }
    5045
    51       {
    52         return _do(args, env, false);
    53       }
     46        @Override
     47        public LispObject execute(LispObject args, Environment env)
     48
     49        {
     50            return _do(args, env, false);
     51        }
    5452    };
    5553
    56   // ### do*
    57   private static final SpecialOperator DO_STAR = new sf_do_star();
    58   private static final class sf_do_star extends SpecialOperator {
    59       sf_do_star()
    60       {
    61         super(Symbol.DO_STAR, "varlist endlist &body body");
    62       }
    63  
    64       @Override
    65       public LispObject execute(LispObject args, Environment env)
     54    // ### do*
     55    private static final SpecialOperator DO_STAR = new sf_do_star();
     56    private static final class sf_do_star extends SpecialOperator {
     57        sf_do_star() {
     58            super(Symbol.DO_STAR, "varlist endlist &body body");
     59        }
    6660
    67       {
    68         return _do(args, env, true);
    69       }
     61        @Override
     62        public LispObject execute(LispObject args, Environment env)
     63
     64        {
     65            return _do(args, env, true);
     66        }
    7067    };
    7168
    72   private static final LispObject _do(LispObject args, Environment env,
    73                                       boolean sequential)
     69    private static final LispObject _do(LispObject args, Environment env,
     70                                        boolean sequential)
    7471
    75   {
    76     LispObject varlist = args.car();
    77     LispObject second = args.cadr();
    78     LispObject end_test_form = second.car();
    79     LispObject result_forms = second.cdr();
    80     LispObject body = args.cddr();
    81     // Process variable specifications.
    82     final int numvars = varlist.length();
    83     Symbol[] vars = new Symbol[numvars];
    84     LispObject[] initforms = new LispObject[numvars];
    85     LispObject[] stepforms = new LispObject[numvars];
    86     for (int i = 0; i < numvars; i++)
    87       {
    88         final LispObject varspec = varlist.car();
    89         if (varspec instanceof Cons)
    90           {
    91             vars[i] = checkSymbol(varspec.car());
    92             initforms[i] = varspec.cadr();
    93             // Is there a step form?
    94             if (varspec.cddr() != NIL)
    95               stepforms[i] = varspec.caddr();
    96           }
    97         else
    98           {
    99             // Not a cons, must be a symbol.
    100             vars[i] = checkSymbol(varspec);
    101             initforms[i] = NIL;
    102           }
    103         varlist = varlist.cdr();
    104       }
    105     final LispThread thread = LispThread.currentThread();
    106     final SpecialBindingsMark mark = thread.markSpecialBindings();
    107     // Process declarations.
     72    {
     73        LispObject varlist = args.car();
     74        LispObject second = args.cadr();
     75        LispObject end_test_form = second.car();
     76        LispObject result_forms = second.cdr();
     77        LispObject body = args.cddr();
     78        // Process variable specifications.
     79        final int numvars = varlist.length();
     80        Symbol[] vars = new Symbol[numvars];
     81        LispObject[] initforms = new LispObject[numvars];
     82        LispObject[] stepforms = new LispObject[numvars];
     83        for (int i = 0; i < numvars; i++) {
     84            final LispObject varspec = varlist.car();
     85            if (varspec instanceof Cons) {
     86                vars[i] = checkSymbol(varspec.car());
     87                initforms[i] = varspec.cadr();
     88                // Is there a step form?
     89                if (varspec.cddr() != NIL)
     90                    stepforms[i] = varspec.caddr();
     91            } else {
     92                // Not a cons, must be a symbol.
     93                vars[i] = checkSymbol(varspec);
     94                initforms[i] = NIL;
     95            }
     96            varlist = varlist.cdr();
     97        }
     98        final LispThread thread = LispThread.currentThread();
     99        final SpecialBindingsMark mark = thread.markSpecialBindings();
     100        // Process declarations.
    108101
    109     final LispObject bodyAndDecls = parseBody(body, false);
    110     LispObject specials = parseSpecials(bodyAndDecls.NTH(1));
    111     body = bodyAndDecls.car();
     102        final LispObject bodyAndDecls = parseBody(body, false);
     103        LispObject specials = parseSpecials(bodyAndDecls.NTH(1));
     104        body = bodyAndDecls.car();
    112105
    113     Environment ext = new Environment(env);
    114     for (int i = 0; i < numvars; i++)
    115       {
    116         Symbol var = vars[i];
    117         LispObject value = eval(initforms[i], (sequential ? ext : env), thread);
    118   ext = new Environment(ext);
    119         if (specials != NIL && memq(var, specials))
    120             thread.bindSpecial(var, value);
    121         else if (var.isSpecialVariable())
    122           thread.bindSpecial(var, value);
    123         else
    124           ext.bind(var, value);
    125       }
    126     LispObject list = specials;
    127     while (list != NIL)
    128       {
    129         ext.declareSpecial(checkSymbol(list.car()));
    130         list = list.cdr();
    131       }
    132     // Look for tags.
    133     LispObject localTags = preprocessTagBody(body, ext);
    134     LispObject blockId = new LispObject();
    135     try
    136       {
    137         // Implicit block.
    138         ext.addBlock(NIL, blockId);
    139         while (true)
    140           {
    141             // Execute body.
    142             // Test for termination.
    143             if (eval(end_test_form, ext, thread) != NIL)
    144               break;
     106        Environment ext = new Environment(env);
     107        for (int i = 0; i < numvars; i++) {
     108            Symbol var = vars[i];
     109            LispObject value = eval(initforms[i], (sequential ? ext : env), thread);
     110            ext = new Environment(ext);
     111            if (specials != NIL && memq(var, specials))
     112                thread.bindSpecial(var, value);
     113            else if (var.isSpecialVariable())
     114                thread.bindSpecial(var, value);
     115            else
     116                ext.bind(var, value);
     117        }
     118        LispObject list = specials;
     119        while (list != NIL) {
     120            ext.declareSpecial(checkSymbol(list.car()));
     121            list = list.cdr();
     122        }
     123        // Look for tags.
     124        LispObject localTags = preprocessTagBody(body, ext);
     125        LispObject blockId = new LispObject();
     126        try {
     127            // Implicit block.
     128            ext.addBlock(NIL, blockId);
     129            while (true) {
     130                // Execute body.
     131                // Test for termination.
     132                if (eval(end_test_form, ext, thread) != NIL)
     133                    break;
    145134
    146             processTagBody(body, localTags, ext);
     135                processTagBody(body, localTags, ext);
    147136
    148             // Update variables.
    149             if (sequential)
    150               {
    151                 for (int i = 0; i < numvars; i++)
    152                   {
    153                     LispObject step = stepforms[i];
    154                     if (step != null)
    155                       {
    156                         Symbol symbol = vars[i];
    157                         LispObject value = eval(step, ext, thread);
    158                         if (symbol.isSpecialVariable()
    159                             || ext.isDeclaredSpecial(symbol))
    160                           thread.rebindSpecial(symbol, value);
    161                         else
    162                           ext.rebind(symbol, value);
    163                       }
    164                   }
    165               }
    166             else
    167               {
    168                 // Evaluate step forms.
    169                 LispObject results[] = new LispObject[numvars];
    170                 for (int i = 0; i < numvars; i++)
    171                   {
    172                     LispObject step = stepforms[i];
    173                     if (step != null)
    174                       {
    175                         LispObject result = eval(step, ext, thread);
    176                         results[i] = result;
    177                       }
    178                   }
    179137                // Update variables.
    180                 for (int i = 0; i < numvars; i++)
    181                   {
    182                     if (results[i] != null)
    183                       {
    184                         Symbol symbol = vars[i];
    185                         LispObject value = results[i];
    186                         if (symbol.isSpecialVariable()
    187                             || ext.isDeclaredSpecial(symbol))
    188                           thread.rebindSpecial(symbol, value);
    189                         else
    190                           ext.rebind(symbol, value);
    191                       }
    192                   }
    193               }
    194             if (interrupted)
    195               handleInterrupt();
    196           }
    197         LispObject result = progn(result_forms, ext, thread);
    198         return result;
    199       }
    200     catch (Return ret)
    201       {
    202         if (ret.getBlock() == blockId)
    203           {
    204             return ret.getResult();
    205           }
    206         throw ret;
    207       }
    208     finally
    209       {
    210         thread.resetSpecialBindings(mark);
    211         ext.inactive = true;
    212       }
    213   }
     138                if (sequential) {
     139                    for (int i = 0; i < numvars; i++) {
     140                        LispObject step = stepforms[i];
     141                        if (step != null) {
     142                            Symbol symbol = vars[i];
     143                            LispObject value = eval(step, ext, thread);
     144                            if (symbol.isSpecialVariable()
     145                                    || ext.isDeclaredSpecial(symbol))
     146                                thread.rebindSpecial(symbol, value);
     147                            else
     148                                ext.rebind(symbol, value);
     149                        }
     150                    }
     151                } else {
     152                    // Evaluate step forms.
     153                    LispObject results[] = new LispObject[numvars];
     154                    for (int i = 0; i < numvars; i++) {
     155                        LispObject step = stepforms[i];
     156                        if (step != null) {
     157                            LispObject result = eval(step, ext, thread);
     158                            results[i] = result;
     159                        }
     160                    }
     161                    // Update variables.
     162                    for (int i = 0; i < numvars; i++) {
     163                        if (results[i] != null) {
     164                            Symbol symbol = vars[i];
     165                            LispObject value = results[i];
     166                            if (symbol.isSpecialVariable()
     167                                    || ext.isDeclaredSpecial(symbol))
     168                                thread.rebindSpecial(symbol, value);
     169                            else
     170                                ext.rebind(symbol, value);
     171                        }
     172                    }
     173                }
     174                if (interrupted)
     175                    handleInterrupt();
     176            }
     177            LispObject result = progn(result_forms, ext, thread);
     178            return result;
     179        } catch (Return ret) {
     180            if (ret.getBlock() == blockId) {
     181                return ret.getResult();
     182            }
     183            throw ret;
     184        }
     185        finally {
     186            thread.resetSpecialBindings(mark);
     187            ext.inactive = true;
     188        }
     189    }
    214190}
Note: See TracChangeset for help on using the changeset viewer.