Changeset 4024


Ignore:
Timestamp:
09/23/03 15:42:18 (19 years ago)
Author:
piso
Message:

Restructuring.

File:
1 edited

Legend:

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

    r4019 r4024  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: dotimes.java,v 1.1 2003-09-23 15:15:19 piso Exp $
     5 * $Id: dotimes.java,v 1.2 2003-09-23 15:42:18 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
    24 public final class dotimes extends Lisp
     24public final class dotimes extends SpecialOperator
    2525{
    26     // ### dotimes
    27     private static final SpecialOperator DOTIMES = new SpecialOperator("dotimes")
     26    private dotimes()
    2827    {
    29         public LispObject execute(LispObject args, Environment env)
    30             throws ConditionThrowable
    31         {
    32             LispObject bodyForm = args.cdr();
    33             args = args.car();
    34             Symbol var = checkSymbol(args.car());
    35             LispObject countForm = args.cadr();
    36             final LispThread thread = LispThread.currentThread();
    37             LispObject resultForm = args.cdr().cdr().car();
    38             Environment oldDynEnv = thread.getDynamicEnvironment();
    39             int depth = thread.getStackDepth();
    40             try {
    41                 LispObject limit = eval(countForm, env, thread);
    42                 // Look for tags.
    43                 Binding tags = null;
    44                 LispObject remaining = bodyForm;
    45                 while (remaining != NIL) {
    46                     LispObject current = remaining.car();
    47                     remaining = remaining.cdr();
    48                     if (current instanceof Cons)
    49                         continue;
    50                     // It's a tag.
    51                     tags = new Binding(current, remaining, tags);
    52                 }
    53                 LispObject result;
    54                 if (limit instanceof Fixnum) {
    55                     int count = ((Fixnum)limit).getValue();
    56                     int i;
    57                     for (i = 0; i < count; i++) {
    58                         Environment ext = new Environment(env);
    59                         bind(var, new Fixnum(i), ext);
    60                         LispObject body = bodyForm;
    61                         while (body != NIL) {
    62                             LispObject current = body.car();
    63                             if (current instanceof Cons) {
    64                                 try {
    65                                     // Handle GO inline if possible.
    66                                     if (current.car() == Symbol.GO) {
    67                                         LispObject code = null;
    68                                         LispObject tag = current.cadr();
    69                                         for (Binding binding = tags; binding != null; binding = binding.next) {
    70                                             if (binding.symbol.eql(tag)) {
    71                                                 code = binding.value;
    72                                                 break;
    73                                             }
    74                                         }
    75                                         if (code != null) {
    76                                             body = code;
    77                                             continue;
    78                                         }
    79                                         throw new Go(tag);
    80                                     }
    81                                     eval(current, ext, thread);
    82                                 }
    83                                 catch (Go go) {
     28        super("dotimes");
     29    }
     30
     31    public LispObject execute(LispObject args, Environment env)
     32        throws ConditionThrowable
     33    {
     34        LispObject bodyForm = args.cdr();
     35        args = args.car();
     36        Symbol var = checkSymbol(args.car());
     37        LispObject countForm = args.cadr();
     38        final LispThread thread = LispThread.currentThread();
     39        LispObject resultForm = args.cdr().cdr().car();
     40        Environment oldDynEnv = thread.getDynamicEnvironment();
     41        int depth = thread.getStackDepth();
     42        try {
     43            LispObject limit = eval(countForm, env, thread);
     44            // Look for tags.
     45            Binding tags = null;
     46            LispObject remaining = bodyForm;
     47            while (remaining != NIL) {
     48                LispObject current = remaining.car();
     49                remaining = remaining.cdr();
     50                if (current instanceof Cons)
     51                    continue;
     52                // It's a tag.
     53                tags = new Binding(current, remaining, tags);
     54            }
     55            LispObject result;
     56            if (limit instanceof Fixnum) {
     57                int count = ((Fixnum)limit).getValue();
     58                int i;
     59                for (i = 0; i < count; i++) {
     60                    Environment ext = new Environment(env);
     61                    bind(var, new Fixnum(i), ext);
     62                    LispObject body = bodyForm;
     63                    while (body != NIL) {
     64                        LispObject current = body.car();
     65                        if (current instanceof Cons) {
     66                            try {
     67                                // Handle GO inline if possible.
     68                                if (current.car() == Symbol.GO) {
    8469                                    LispObject code = null;
    85                                     LispObject tag = go.getTag();
     70                                    LispObject tag = current.cadr();
    8671                                    for (Binding binding = tags; binding != null; binding = binding.next) {
    8772                                        if (binding.symbol.eql(tag)) {
     
    9277                                    if (code != null) {
    9378                                        body = code;
    94                                         thread.setStackDepth(depth);
    9579                                        continue;
    9680                                    }
    97                                     throw go;
     81                                    throw new Go(tag);
    9882                                }
     83                                eval(current, ext, thread);
    9984                            }
    100                             body = body.cdr();
     85                            catch (Go go) {
     86                                LispObject code = null;
     87                                LispObject tag = go.getTag();
     88                                for (Binding binding = tags; binding != null; binding = binding.next) {
     89                                    if (binding.symbol.eql(tag)) {
     90                                        code = binding.value;
     91                                        break;
     92                                    }
     93                                }
     94                                if (code != null) {
     95                                    body = code;
     96                                    thread.setStackDepth(depth);
     97                                    continue;
     98                                }
     99                                throw go;
     100                            }
    101101                        }
     102                        body = body.cdr();
    102103                    }
     104                }
     105                Environment ext = new Environment(env);
     106                bind(var, new Fixnum(i), ext);
     107                result = eval(resultForm, ext, thread);
     108            } else if (limit instanceof Bignum) {
     109                LispObject i = Fixnum.ZERO;
     110                while (i.isLessThan(limit)) {
    103111                    Environment ext = new Environment(env);
    104                     bind(var, new Fixnum(i), ext);
    105                     result = eval(resultForm, ext, thread);
    106                 } else if (limit instanceof Bignum) {
    107                     LispObject i = Fixnum.ZERO;
    108                     while (i.isLessThan(limit)) {
    109                         Environment ext = new Environment(env);
    110                         bind(var, i, ext);
    111                         LispObject body = bodyForm;
    112                         while (body != NIL) {
    113                             LispObject current = body.car();
    114                             if (current instanceof Cons) {
    115                                 try {
    116                                     // Handle GO inline if possible.
    117                                     if (current.car() == Symbol.GO) {
    118                                         LispObject code = null;
    119                                         LispObject tag = current.cadr();
    120                                         for (Binding binding = tags; binding != null; binding = binding.next) {
    121                                             if (binding.symbol.eql(tag)) {
    122                                                 code = binding.value;
    123                                                 break;
    124                                             }
    125                                         }
    126                                         if (code != null) {
    127                                             body = code;
    128                                             continue;
    129                                         }
    130                                         throw new Go(tag);
    131                                     }
    132                                     eval(current, ext, thread);
    133                                 }
    134                                 catch (Go go) {
     112                    bind(var, i, ext);
     113                    LispObject body = bodyForm;
     114                    while (body != NIL) {
     115                        LispObject current = body.car();
     116                        if (current instanceof Cons) {
     117                            try {
     118                                // Handle GO inline if possible.
     119                                if (current.car() == Symbol.GO) {
    135120                                    LispObject code = null;
    136                                     LispObject tag = go.getTag();
     121                                    LispObject tag = current.cadr();
    137122                                    for (Binding binding = tags; binding != null; binding = binding.next) {
    138123                                        if (binding.symbol.eql(tag)) {
     
    143128                                    if (code != null) {
    144129                                        body = code;
    145                                         thread.setStackDepth(depth);
    146130                                        continue;
    147131                                    }
    148                                     throw go;
     132                                    throw new Go(tag);
    149133                                }
     134                                eval(current, ext, thread);
    150135                            }
    151                             body = body.cdr();
     136                            catch (Go go) {
     137                                LispObject code = null;
     138                                LispObject tag = go.getTag();
     139                                for (Binding binding = tags; binding != null; binding = binding.next) {
     140                                    if (binding.symbol.eql(tag)) {
     141                                        code = binding.value;
     142                                        break;
     143                                    }
     144                                }
     145                                if (code != null) {
     146                                    body = code;
     147                                    thread.setStackDepth(depth);
     148                                    continue;
     149                                }
     150                                throw go;
     151                            }
    152152                        }
    153                         i = i.incr();
     153                        body = body.cdr();
    154154                    }
    155                     Environment ext = new Environment(env);
    156                     bind(var, i, ext);
    157                     result = eval(resultForm, ext, thread);
    158                 } else
    159                     throw new ConditionThrowable(new TypeError(limit, "integer"));
    160                 return result;
     155                    i = i.incr();
     156                }
     157                Environment ext = new Environment(env);
     158                bind(var, i, ext);
     159                result = eval(resultForm, ext, thread);
     160            } else
     161                throw new ConditionThrowable(new TypeError(limit, "integer"));
     162            return result;
     163        }
     164        catch (Return ret) {
     165            if (ret.getTag() == NIL) {
     166                thread.setStackDepth(depth);
     167                return ret.getResult();
    161168            }
    162             catch (Return ret) {
    163                 if (ret.getTag() == NIL) {
    164                     thread.setStackDepth(depth);
    165                     return ret.getResult();
    166                 }
    167                 throw ret;
    168             }
    169             finally {
    170                 thread.setDynamicEnvironment(oldDynEnv);
    171             }
     169            throw ret;
    172170        }
    173     };
     171        finally {
     172            thread.setDynamicEnvironment(oldDynEnv);
     173        }
     174    }
     175
     176    private static final dotimes DOTIMES = new dotimes();
    174177}
Note: See TracChangeset for help on using the changeset viewer.