Changeset 11336


Ignore:
Timestamp:
10/05/08 20:53:02 (13 years ago)
Author:
ehuelsmann
Message:

Cleanup.

Patch by: Ville Voutilainen <ville.voutilainen at gmail dot com>

File:
1 edited

Legend:

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

    r11334 r11336  
    4141  private static final int STATE_AUX      = 4;
    4242
    43   private final Parameter[] requiredParameters;
    44   private final Parameter[] optionalParameters;
    45   private final Parameter[] keywordParameters;
    46   private final Parameter[] auxVars;
     43  private static final Parameter[] emptyParameterArray;
     44  static
     45    {
     46        emptyParameterArray = new Parameter[0];
     47    }
     48  private Parameter[] requiredParameters = emptyParameterArray;
     49  private Parameter[] optionalParameters = emptyParameterArray;
     50  private Parameter[] keywordParameters = emptyParameterArray;
     51  private Parameter[] auxVars = emptyParameterArray;
    4752  private final LispObject body;
    4853  private final Environment environment;
     
    5661  private int maxArgs;
    5762
    58   private final Symbol[] variables;
    59   private final Symbol[] specials;
     63  private static final Symbol[] emptySymbolArray;
     64  static
     65    {
     66        emptySymbolArray = new Symbol[0];
     67    }
     68  private Symbol[] variables = emptySymbolArray;
     69  private Symbol[] specials = emptySymbolArray;
    6070
    6171  private boolean bindInitForms;
     
    246256            required.toArray(requiredParameters);
    247257          }
    248         else
    249           requiredParameters = null;
    250258        if (optional != null)
    251259          {
     
    253261            optional.toArray(optionalParameters);
    254262          }
    255         else
    256           optionalParameters = null;
    257263        if (keywords != null)
    258264          {
     
    260266            keywords.toArray(keywordParameters);
    261267          }
    262         else
    263           keywordParameters = null;
    264268        if (aux != null)
    265269          {
     
    267271            aux.toArray(auxVars);
    268272          }
    269         else
    270           auxVars = null;
    271273      }
    272274    else
     
    274276        // Lambda list is empty.
    275277        Debug.assertTrue(lambdaList == NIL);
    276         requiredParameters = null;
    277         optionalParameters = null;
    278         keywordParameters = null;
    279         auxVars = null;
    280278        arity = 0;
    281         minArgs = maxArgs = 0;
     279        maxArgs = 0;
    282280      }
    283281    this.body = lambdaExpression.cddr();
     
    285283    this.andKey = _andKey;
    286284    this.allowOtherKeys = _allowOtherKeys;
    287     minArgs = requiredParameters != null ? requiredParameters.length : 0;
     285    minArgs = requiredParameters.length;
    288286    if (arity >= 0)
    289287      Debug.assertTrue(arity == minArgs);
     
    293291
    294292  private final void processParameters(ArrayList<Symbol> vars,
    295           final Parameter[] parameters)
    296   {
    297     if (parameters != null)
    298       {
    299         for (Parameter parameter : parameters)
    300           {
    301             vars.add(parameter.var);
    302             if (parameter.svar != NIL)
    303               vars.add((Symbol)parameter.svar);
    304             if (!bindInitForms)
    305               if (!parameter.initForm.constantp())
    306                 bindInitForms = true;
    307           }
     293                                       final Parameter[] parameters)
     294  {
     295    for (Parameter parameter : parameters)
     296      {
     297        vars.add(parameter.var);
     298        if (parameter.svar != NIL)
     299          vars.add((Symbol)parameter.svar);
     300        if (!bindInitForms)
     301          if (!parameter.initForm.constantp())
     302            bindInitForms = true;
    308303      }
    309304  }
     
    313308  {
    314309    ArrayList<Symbol> vars = new ArrayList<Symbol>();
    315     if (requiredParameters != null)
    316       {
    317         for (Parameter parameter : requiredParameters)
    318           vars.add(parameter.var);
    319       }
     310    for (Parameter parameter : requiredParameters)
     311      vars.add(parameter.var);
    320312    processParameters(vars, optionalParameters);
    321313    if (restVar != null)
     
    362354      }
    363355    if (arrayList == null)
    364       return null;
     356      return emptySymbolArray;
    365357    Symbol[] array = new Symbol[arrayList.size()];
    366358    arrayList.toArray(array);
     
    385377  {
    386378    LispObject result = NIL;
    387     if (variables != null)
    388       {
    389         for (int i = variables.length; i-- > 0;)
    390           result = new Cons(variables[i], result);
    391       }
     379    for (int i = variables.length; i-- > 0;)
     380      result = new Cons(variables[i], result);
    392381    return result;
    393382  }
     
    423412    if (arity != arityValue)
    424413      {
    425         if (optionalParameters != null)
     414        if (optionalParameters.length > 0)
    426415          bindOptionalParameterDefaults(ext, thread);
    427416        if (restVar != null)
    428417          bindArg(restVar, NIL, ext, thread);
    429         if (keywordParameters != null)
     418        if (keywordParameters.length > 0)
    430419          bindKeywordParameterDefaults(ext, thread);
    431420      }
    432     if (auxVars != null)
    433       bindAuxVars(ext, thread);
     421    bindAuxVars(ext, thread);
    434422    try
    435423      {
     
    609597        SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    610598        Environment ext = new Environment(environment);
    611         if (specials != null)
    612           {
    613             for (Symbol special : specials)
    614               ext.declareSpecial(special);
    615           }
     599        for (Symbol special : specials)
     600          ext.declareSpecial(special);
    616601        bindRequiredParameters(ext, thread, first, second, third, fourth,
    617602                               fifth, sixth, seventh, eighth);
     
    631616    SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    632617    Environment ext = new Environment(environment);
    633     if (optionalParameters == null && keywordParameters == null)
     618    if (optionalParameters.length == 0 && keywordParameters.length == 0)
    634619      args = fastProcessArgs(args);
    635620    else
     
    638623    if (envVar != null)
    639624      {
    640           bindArg(envVar, environment, ext, thread);
     625        bindArg(envVar, environment, ext, thread);
    641626      }
    642627    for (int i = 0; i < variables.length; i++)
     
    645630        bindArg(sym, args[i], ext, thread);
    646631      }
    647     if (auxVars != null)
    648       bindAuxVars(ext, thread);
    649     if (specials != null) {
    650       special:
    651         for (Symbol special : specials) {
    652             for (Symbol var : variables)
    653                 if (special == var)
    654                     continue special;
    655 
    656             if (auxVars != null)
    657                 for (Parameter parameter : auxVars)
    658                     if (special == parameter.var)
    659                         continue special;
    660 
    661             ext.declareSpecial(special);
    662         }
     632    bindAuxVars(ext, thread);
     633    special:
     634    for (Symbol special : specials) {
     635      for (Symbol var : variables)
     636        if (special == var)
     637          continue special;
     638      for (Parameter parameter : auxVars)
     639        if (special == parameter.var)
     640          continue special;
     641      ext.declareSpecial(special);
    663642    }
    664643    try
     
    690669    throws ConditionThrowable
    691670  {
    692     if (optionalParameters == null && keywordParameters == null)
     671    if (optionalParameters.length == 0 && keywordParameters.length == 0)
    693672      return fastProcessArgs(args);
    694673    final int argsLength = args.length;
     
    718697          bindArg(envVar, environment, ext, thread);
    719698    // Required parameters.
    720     if (requiredParameters != null)
    721       {
    722         for (int i = 0; i < minArgs; i++)
    723           {
    724             if (bindInitForms)
    725                 bindArg(requiredParameters[i].var, args[i], ext, thread);
    726             array[index++] = args[i];
    727           }
     699    for (int i = 0; i < minArgs; i++)
     700      {
     701        if (bindInitForms)
     702          bindArg(requiredParameters[i].var, args[i], ext, thread);
     703        array[index++] = args[i];
    728704      }
    729705    int i = minArgs;
    730706    int argsUsed = minArgs;
    731707    // Optional parameters.
    732     if (optionalParameters != null)
    733       {
    734         for (int j = 0; j < optionalParameters.length; j++)
    735           {
    736             Parameter parameter = optionalParameters[j];
    737             if (i < argsLength)
     708    for (Parameter parameter : optionalParameters)
     709      {
     710        if (i < argsLength)
     711          {
     712            if (bindInitForms)
     713              bindArg(parameter.var, args[i], ext, thread);
     714            array[index++] = args[i];
     715            ++argsUsed;
     716            if (parameter.svar != NIL)
    738717              {
    739718                if (bindInitForms)
    740                     bindArg(parameter.var, args[i], ext, thread);
    741                 array[index++] = args[i];
    742                 ++argsUsed;
    743                 if (parameter.svar != NIL)
    744                   {
    745                     if (bindInitForms)
    746                         bindArg((Symbol)parameter.svar, T, ext, thread);
    747                     array[index++] = T;
    748                   }
    749               }
     719                  bindArg((Symbol)parameter.svar, T, ext, thread);
     720                array[index++] = T;
     721              }
     722          }
     723        else
     724          {
     725            // We've run out of arguments.
     726            LispObject value;
     727            if (parameter.initVal != null)
     728              value = parameter.initVal;
    750729            else
    751               {
    752                 // We've run out of arguments.
    753                 LispObject value;
    754                 if (parameter.initVal != null)
    755                   value = parameter.initVal;
    756                 else
    757                   value = eval(parameter.initForm, ext, thread);
     730              value = eval(parameter.initForm, ext, thread);
     731            if (bindInitForms)
     732              bindArg(parameter.var, value, ext, thread);
     733            array[index++] = value;
     734            if (parameter.svar != NIL)
     735              {
    758736                if (bindInitForms)
    759                     bindArg(parameter.var, value, ext, thread);
    760                 array[index++] = value;
    761                 if (parameter.svar != NIL)
    762                   {
    763                     if (bindInitForms)
    764                         bindArg((Symbol)parameter.svar, NIL, ext, thread);
    765                     array[index++] = NIL;
    766                   }
    767               }
    768             ++i;
    769           }
     737                  bindArg((Symbol)parameter.svar, NIL, ext, thread);
     738                array[index++] = NIL;
     739              }
     740          }
     741        ++i;
    770742      }
    771743    // &rest parameter.
     
    780752      }
    781753    // Keyword parameters.
    782     if (keywordParameters != null)
     754    if (keywordParameters.length > 0)
    783755      {
    784756        int argsLeft = argsLength - argsUsed;
     
    970942    int index = 0;
    971943    // Required parameters.
    972     if (requiredParameters != null)
    973       {
    974         for (int i = 0; i < minArgs; i++)
    975           {
    976             array[index++] = args[i];
    977           }
     944    for (int i = 0; i < minArgs; i++)
     945      {
     946        array[index++] = args[i];
    978947      }
    979948    int argsUsed = minArgs;
Note: See TracChangeset for help on using the changeset viewer.