Changeset 12166


Ignore:
Timestamp:
09/29/09 19:54:02 (12 years ago)
Author:
ehuelsmann
Message:

More TAGBODY processing duplication removal; DOTIMES and DOLIST this time.

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

Legend:

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

    r12055 r12166  
    5858    bodyForm = bodyAndDecls.car();
    5959
     60    LispObject blockId = new LispObject();
    6061    try
    6162      {
    6263        final Environment ext = new Environment(env);
    6364        // Implicit block.
    64         ext.addBlock(NIL, new LispObject());
     65        ext.addBlock(NIL, blockId);
    6566        // Evaluate the list form.
    6667        LispObject list = checkList(eval(listForm, ext, thread));
    6768        // Look for tags.
    6869        LispObject remaining = bodyForm;
    69         while (remaining != NIL)
    70           {
    71             LispObject current = remaining.car();
    72             remaining = remaining.cdr();
    73             if (current instanceof Cons)
    74               continue;
    75             // It's a tag.
    76             ext.addTagBinding(current, remaining);
    77           }
    78         // Establish a reusable binding.
     70        LispObject localTags = preprocessTagBody(bodyForm, ext);
     71
    7972        final Object binding;
    8073        if (specials != NIL && memq(var, specials))
     
    10598            else
    10699              ((Binding)binding).value = list.car();
    107             LispObject body = bodyForm;
    108             while (body != NIL)
    109               {
    110                 LispObject current = body.car();
    111                 if (current instanceof Cons)
    112                   {
    113                     try
    114                       {
    115                         // Handle GO inline if possible.
    116                         if (current.car() == Symbol.GO)
    117                           {
    118                             LispObject tag = current.cadr();
    119                             Binding b = ext.getTagBinding(tag);
    120                             if (b != null && b.value != null)
    121                               {
    122                                 body = b.value;
    123                                 continue;
    124                               }
    125                             throw new Go(tag);
    126                           }
    127                         eval(current, ext, thread);
    128                       }
    129                     catch (Go go)
    130                       {
    131                         LispObject tag = go.getTag();
    132                         Binding b = ext.getTagBinding(tag);
    133                         if (b != null && b.value != null)
    134                           {
    135                             body = b.value;
    136                             continue;
    137                           }
    138                         throw go;
    139                       }
    140                   }
    141                 body = body.cdr();
    142               }
     100
     101            processTagBody(bodyForm, localTags, ext);
     102
    143103            list = list.cdr();
    144104            if (interrupted)
     
    154114    catch (Return ret)
    155115      {
    156         if (ret.getTag() == NIL)
     116        if (ret.getBlock() == blockId)
    157117          {
    158118            return ret.getResult();
  • trunk/abcl/src/org/armedbear/lisp/dotimes.java

    r12055 r12166  
    5757    bodyForm = bodyAndDecls.car();
    5858
     59    LispObject blockId = new LispObject();
    5960    try
    6061      {
    6162        LispObject limit = eval(countForm, env, thread);
    6263        Environment ext = new Environment(env);
    63         LispObject localTags = NIL; // Tags that are local to this TAGBODY.
    64         // Look for tags.
    65         LispObject remaining = bodyForm;
    66         while (remaining != NIL)
    67           {
    68             LispObject current = remaining.car();
    69             remaining = remaining.cdr();
    70             if (current instanceof Cons)
    71               continue;
    72             // It's a tag.
    73             ext.addTagBinding(current, remaining);
    74             localTags = new Cons(current, localTags);
    75           }
    76         // Implicit block.
    77         ext.addBlock(NIL, new LispObject());
     64        LispObject localTags = preprocessTagBody(bodyForm, ext);
     65
     66        ext.addBlock(NIL, blockId);
    7867        LispObject result;
    7968        // Establish a reusable binding.
     
    11099                else
    111100                  ((Binding)binding).value = Fixnum.getInstance(i);
    112                 LispObject body = bodyForm;
    113                 while (body != NIL)
    114                   {
    115                     LispObject current = body.car();
    116                     if (current instanceof Cons)
    117                       {
    118                         try
    119                           {
    120                             // Handle GO inline if possible.
    121                             if (current.car() == Symbol.GO)
    122                               {
    123                                 LispObject tag = current.cadr();
    124                                 if (memql(tag, localTags))
    125                                   {
    126                                     Binding b = ext.getTagBinding(tag);
    127                                     if (b != null && b.value != null)
    128                                       {
    129                                         body = b.value;
    130                                         continue;
    131                                       }
    132                                   }
    133                                 throw new Go(tag);
    134                               }
    135                             eval(current, ext, thread);
    136                           }
    137                         catch (Go go)
    138                           {
    139                             LispObject tag = go.getTag();
    140                             if (memql(tag, localTags))
    141                               {
    142                                 Binding b = ext.getTagBinding(tag);
    143                                 if (b != null && b.value != null)
    144                                   {
    145                                     body = b.value;
    146                                     continue;
    147                                   }
    148                               }
    149                             throw go;
    150                           }
    151                       }
    152                     body = body.cdr();
    153                   }
     101
     102                processTagBody(bodyForm, localTags, ext);
     103
    154104                if (interrupted)
    155105                  handleInterrupt();
     
    170120                else
    171121                  ((Binding)binding).value = i;
    172                 LispObject body = bodyForm;
    173                 while (body != NIL)
    174                   {
    175                     LispObject current = body.car();
    176                     if (current instanceof Cons)
    177                       {
    178                         try
    179                           {
    180                             // Handle GO inline if possible.
    181                             if (current.car() == Symbol.GO)
    182                               {
    183                                 LispObject tag = current.cadr();
    184                                 if (memql(tag, localTags))
    185                                   {
    186                                     Binding b = ext.getTagBinding(tag);
    187                                     if (b != null && b.value != null)
    188                                       {
    189                                         body = b.value;
    190                                         continue;
    191                                       }
    192                                   }
    193                                 throw new Go(tag);
    194                               }
    195                             eval(current, ext, thread);
    196                           }
    197                         catch (Go go)
    198                           {
    199                             LispObject tag = go.getTag();
    200                             if (memql(tag, localTags))
    201                               {
    202                                 Binding b = ext.getTagBinding(tag);
    203                                 if (b != null && b.value != null)
    204                                   {
    205                                     body = b.value;
    206                                     continue;
    207                                   }
    208                               }
    209                             throw go;
    210                           }
    211                       }
    212                     body = body.cdr();
    213                   }
     122
     123                processTagBody(bodyForm, localTags, ext);
     124
    214125                i = i.incr();
    215126                if (interrupted)
     
    228139    catch (Return ret)
    229140      {
    230         if (ret.getTag() == NIL)
     141        if (ret.getBlock() == blockId)
    231142          {
    232143            return ret.getResult();
Note: See TracChangeset for help on using the changeset viewer.