Changeset 11548


Ignore:
Timestamp:
01/06/09 12:12:14 (12 years ago)
Author:
vvoutilainen
Message:

Remove bindArg duplication.

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

Legend:

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

    r11529 r11548  
    428428        bindParameterDefaults(optionalParameters, ext, thread);
    429429        if (restVar != null)
    430           bindArg(restVar, NIL, ext, thread);
     430          bindArg(specials, restVar, NIL, ext, thread);
    431431        bindParameterDefaults(keywordParameters, ext, thread);
    432432      }
     
    449449    // &whole and &environment before anything
    450450    if (envVar != null)
    451       bindArg(envVar, environment, ext, thread);
     451      bindArg(specials, envVar, environment, ext, thread);
    452452    for (int i = 0; i < objects.length; ++i)
    453453      {
    454         bindArg(requiredParameters[i].var, objects[i], ext, thread);
     454        bindArg(specials, requiredParameters[i].var, objects[i], ext, thread);
    455455      }
    456456  }
     
    645645    if (envVar != null)
    646646      {
    647         bindArg(envVar, environment, ext, thread);
     647        bindArg(specials, envVar, environment, ext, thread);
    648648      }
    649649    for (int i = 0; i < variables.length; i++)
    650650      {
    651651        Symbol sym = variables[i];
    652         bindArg(sym, args[i], ext, thread);
     652        bindArg(specials, sym, args[i], ext, thread);
    653653      }
    654654    bindAuxVars(ext, thread);
     
    671671        thread.lastSpecialBinding = lastSpecialBinding;
    672672      }
    673   }
    674 
    675   private final boolean isSpecial(Symbol sym)
    676   {
    677     if (sym.isSpecialVariable())
    678       return true;
    679     for (Symbol special : specials)
    680       {
    681         if (sym == special)
    682             return true;
    683       }
    684     return false;
    685673  }
    686674
     
    712700    if (bindInitForms)
    713701      if (envVar != null)
    714           bindArg(envVar, environment, ext, thread);
     702  bindArg(specials, envVar, environment, ext, thread);
    715703    // Required parameters.
    716704    for (int i = 0; i < minArgs; i++)
    717705      {
    718706        if (bindInitForms)
    719           bindArg(requiredParameters[i].var, args[i], ext, thread);
     707          bindArg(specials, requiredParameters[i].var, args[i], ext, thread);
    720708        array[index++] = args[i];
    721709      }
     
    728716          {
    729717            if (bindInitForms)
    730               bindArg(parameter.var, args[i], ext, thread);
     718              bindArg(specials, parameter.var, args[i], ext, thread);
    731719            array[index++] = args[i];
    732720            ++argsUsed;
     
    734722              {
    735723                if (bindInitForms)
    736                   bindArg((Symbol)parameter.svar, T, ext, thread);
     724                  bindArg(specials, (Symbol)parameter.svar, T, ext, thread);
    737725                array[index++] = T;
    738726              }
     
    747735              value = eval(parameter.initForm, ext, thread);
    748736            if (bindInitForms)
    749               bindArg(parameter.var, value, ext, thread);
     737              bindArg(specials, parameter.var, value, ext, thread);
    750738            array[index++] = value;
    751739            if (parameter.svar != NIL)
    752740              {
    753741                if (bindInitForms)
    754                   bindArg((Symbol)parameter.svar, NIL, ext, thread);
     742                  bindArg(specials, (Symbol)parameter.svar, NIL, ext, thread);
    755743                array[index++] = NIL;
    756744              }
     
    765753          rest = new Cons(args[j], rest);
    766754        if (bindInitForms)
    767             bindArg(restVar, rest, ext, thread);
     755    bindArg(specials, restVar, rest, ext, thread);
    768756        array[index++] = rest;
    769757      }
     
    785773                  value = eval(parameter.initForm, ext, thread);
    786774                if (bindInitForms)
    787                     bindArg(parameter.var, value, ext, thread);
     775      bindArg(specials, parameter.var, value, ext, thread);
    788776                array[index++] = value;
    789777                if (parameter.svar != NIL)
    790778                  {
    791779                    if (bindInitForms)
    792                         bindArg((Symbol)parameter.svar, NIL, ext, thread);
     780          bindArg(specials, (Symbol)parameter.svar, NIL, ext, thread);
    793781                    array[index++] = NIL;
    794782                  }
     
    810798                      {
    811799                        if (bindInitForms)
    812                             bindArg(parameter.var, args[j+1], ext, thread);
     800        bindArg(specials, parameter.var, args[j+1], ext, thread);
    813801                        value = array[index++] = args[j+1];
    814802                        if (parameter.svar != NIL)
    815803                          {
    816804                            if (bindInitForms)
    817                                 bindArg((Symbol)parameter.svar, T, ext, thread);
     805            bindArg(specials,(Symbol)parameter.svar, T, ext, thread);
    818806                            array[index++] = T;
    819807                          }
     
    831819                      value = eval(parameter.initForm, ext, thread);
    832820                    if (bindInitForms)
    833                         bindArg(parameter.var, value, ext, thread);
     821          bindArg(specials, parameter.var, value, ext, thread);
    834822                    array[index++] = value;
    835823                    if (parameter.svar != NIL)
    836824                      {
    837825                        if (bindInitForms)
    838                             bindArg((Symbol)parameter.svar, NIL, ext, thread);
     826        bindArg(specials, (Symbol)parameter.svar, NIL, ext, thread);
    839827                        array[index++] = NIL;
    840828                      }
     
    10301018        else
    10311019          value = eval(parameter.initForm, env, thread);
    1032         bindArg(parameter.var, value, env, thread);
     1020        bindArg(specials, parameter.var, value, env, thread);
    10331021        if (parameter.svar != NIL)
    1034             bindArg((Symbol)parameter.svar, NIL, env, thread);
    1035       }
    1036   }
    1037 
    1038     private final void bindArg(Symbol sym, LispObject value,
    1039                                Environment env, LispThread thread)
    1040         throws ConditionThrowable
    1041     {
    1042         if (isSpecial(sym)) {
    1043             env.declareSpecial(sym);
    1044             thread.bindSpecial(sym, value);
    1045         }
    1046         else
    1047             env.bind(sym, value);
    1048     }
     1022    bindArg(specials, (Symbol)parameter.svar, NIL, env, thread);
     1023      }
     1024  }
    10491025
    10501026  private final void bindAuxVars(Environment env, LispThread thread)
     
    10621038          value = eval(parameter.initForm, env, thread);
    10631039
    1064         bindArg(sym, value, env, thread);
     1040        bindArg(specials, sym, value, env, thread);
    10651041      }
    10661042  }
  • trunk/abcl/src/org/armedbear/lisp/Lisp.java

    r11512 r11548  
    563563
    564564  // Environment wrappers.
    565   public static final void bind(Symbol symbol, LispObject value,
    566                                 Environment env)
    567     throws ConditionThrowable
    568   {
    569     if (symbol.isSpecialVariable() || env.isDeclaredSpecial(symbol))
    570       LispThread.currentThread().bindSpecial(symbol, value);
     565  private static final boolean isSpecial(Symbol sym, Symbol[] ownSpecials,
     566           Environment env)
     567  {
     568    if (ownSpecials != null)
     569      {
     570  if (sym.isSpecialVariable())
     571    return true;
     572  for (Symbol special : ownSpecials)
     573    {
     574      if (sym == special)
     575        return true;
     576    }
     577      }
     578    return false;
     579  }
     580  protected static final void bindArg(Symbol[] ownSpecials,
     581              Symbol sym, LispObject value,
     582              Environment env, LispThread thread)
     583    throws ConditionThrowable
     584  {
     585    if (isSpecial(sym, ownSpecials, env)) {
     586      env.declareSpecial(sym);
     587      thread.bindSpecial(sym, value);
     588    }
    571589    else
    572       env.bind(symbol, value);
     590      env.bind(sym, value);
    573591  }
    574592
  • trunk/abcl/src/org/armedbear/lisp/SpecialOperators.java

    r11547 r11548  
    110110    };
    111111
    112   private static final void bindArg(LispObject specials, Symbol symbol,
    113              LispObject value, Environment ext)
    114     throws ConditionThrowable
    115     {
    116       final LispThread thread = LispThread.currentThread();
    117       if (specials != NIL && memq(symbol, specials))
    118   {
    119     thread.bindSpecial(symbol, value);
    120     ext.declareSpecial(symbol);
    121   }
    122       else if (symbol.isSpecialVariable())
    123   {
    124     thread.bindSpecial(symbol, value);
    125   }
    126       else
    127     ext.bind(symbol, value);
    128     }
    129 
    130112  private static final LispObject _let(LispObject args, Environment env,
    131113                                       boolean sequential)
     
    139121        LispObject body = args.cdr();
    140122        // Process declarations.
    141         LispObject specials = NIL;
     123        ArrayList<Symbol> specials = new ArrayList<Symbol>();
    142124        while (body != NIL)
    143125          {
     
    154136                        while (vars != NIL)
    155137                          {
    156                             specials = new Cons(vars.car(), specials);
     138          specials.add(0, (Symbol) vars.car());
    157139                            vars = ((Cons)vars).cdr;
    158140                          }
     
    167149        Environment ext = new Environment(env);
    168150  LinkedList<Cons> nonSequentialVars = new LinkedList<Cons>();
     151  Symbol[] arrayToUseForSpecials = new Symbol[0];
    169152        while (varList != NIL)
    170153          {
     
    201184              }
    202185      if (sequential)
    203     bindArg(specials, symbol, value, ext);
     186    bindArg(specials.toArray(arrayToUseForSpecials),
     187      symbol, value, ext, thread);
    204188      else
    205189    nonSequentialVars.add(new Cons(symbol, value));
     
    210194      for (Cons x : nonSequentialVars)
    211195        {
    212     bindArg(specials, (Symbol)x.car(), x.cdr(), ext);
     196    bindArg(specials.toArray(arrayToUseForSpecials),
     197      (Symbol)x.car(), x.cdr(), ext, thread);
    213198        }
    214199    }
     
    217202        // initialization forms for bindings established by the form
    218203        // containing the declarations." (3.3.4)
    219         while (specials != NIL)
    220           {
    221             Symbol symbol = (Symbol) specials.car();
     204        for (Symbol symbol : specials)
     205          {
    222206            ext.declareSpecial(symbol);
    223             specials = ((Cons)specials).cdr;
    224207          }
    225208        return progn(body, ext, thread);
     
    265248                              " with SYMBOL-MACROLET."));
    266249                          }
    267                         bind(symbol, new SymbolMacro(obj.cadr()), ext);
     250                        bindArg(null, symbol, new SymbolMacro(obj.cadr()), ext, thread);
    268251                      }
    269252                    else
Note: See TracChangeset for help on using the changeset viewer.