Changeset 13850

Timestamp:

02/04/12 13:09:35 (11 years ago)

Author:

ehuelsmann

Message:

Remove Closure.fastProcessArgs(): it's concept has been abstracted away
in ArgumentListProcessor?.

Location:

trunk/abcl/src/org/armedbear/lisp

Files:

• ArgumentListProcessor.java (modified) (2 diffs)
• Closure.java (modified) (1 diff)
• compiler-pass2.lisp (modified) (2 diffs)
• jvm-class-file.lisp (modified) (1 diff)

trunk/abcl/src/org/armedbear/lisp/ArgumentListProcessor.java

@@ -546 +546 @@
    * including validation of the keywords passed. */
   private class SlowMatcher extends ArgumentMatcher {
+      private LispObject[] _match(LispObject[] args, Environment _environment,
+                Environment env, LispThread thread) {
+        final ArgList argslist = new ArgList(_environment, args);
+        final LispObject[] array = new LispObject[variables.length];
+        int index = 0;
+
+        
+        for (Param p : positionalParameters)
+            index = p.assign(index, array, argslist, env, thread);
+
+        if (andKey) {
+            argslist.assertRemainderKeywords();
+
+            for (Param p : keywordParameters)
+                index = p.assign(index, array, argslist, env, thread);
+        }
+        for (Param p : auxVars)
+            index = p.assign(index, array, argslist, env, thread);
+
+        if (andKey) {
+            if (allowOtherKeys)
+                return array;
+
+            if (!argslist.consumed()) // verify keywords
+              {
+                LispObject allowOtherKeysValue =
+                        argslist.findKeywordArg(Keyword.ALLOW_OTHER_KEYS, NIL);
+
+                if (allowOtherKeysValue != NIL)
+                    return array;
+
+                // verify keywords
+                next_key:
+                  while (! argslist.consumed()) {
+                      LispObject key = argslist.consume();
+                      argslist.consume(); // consume value
+
+                      if (key == Keyword.ALLOW_OTHER_KEYS)
+                          continue next_key;
+
+                      for (KeywordParam k : keywordParameters)
+                          if (k.keyword == key)
+                              continue next_key;
+
+                      error(new ProgramError("Unrecognized keyword argument " +
+                                              key.printObject()));
+                  }
+              }
+        } 
+
+        if (restVar == null && !argslist.consumed())
+            error(new WrongNumberOfArgumentsException(function));
+
+        return array;
+      }
+      
       @Override
       LispObject[] match(LispObject[] args, Environment _environment,
@@ -561 +617 @@
           error(new WrongNumberOfArgumentsException(function, minArgs, -1));
 
+        if (thread == null)
+            return _match(args, _environment, env, thread);
           
         final SpecialBindingsMark mark = thread.markSpecialBindings();
-        final LispObject[] array = new LispObject[variables.length];
-        int index = 0;
-        ArgList argslist = new ArgList(_environment, args);
-        
         try {
-            for (Param p : positionalParameters)
-                index = p.assign(index, array, argslist, env, thread);
-            
-            if (andKey) {
-                argslist.assertRemainderKeywords();
-            
-                for (Param p : keywordParameters)
-                    index = p.assign(index, array, argslist, env, thread);
-            }
-            for (Param p : auxVars)
-                index = p.assign(index, array, argslist, env, thread);
-            
-            if (andKey) {
-                if (allowOtherKeys)
-                    return array;
-                
-                if (!argslist.consumed()) // verify keywords
-                  {
-                    LispObject allowOtherKeysValue =
-                            argslist.findKeywordArg(Keyword.ALLOW_OTHER_KEYS, NIL);
-
-                    if (allowOtherKeysValue != NIL)
-                        return array;
-
-                    // verify keywords
-                    next_key:
-                      while (! argslist.consumed()) {
-                          LispObject key = argslist.consume();
-                          argslist.consume(); // consume value
-
-                          if (key == Keyword.ALLOW_OTHER_KEYS)
-                              continue next_key;
-
-                          for (KeywordParam k : keywordParameters)
-                              if (k.keyword == key)
-                                  continue next_key;
-
-                          error(new ProgramError("Unrecognized keyword argument " +
-                                                  key.printObject()));
-                      }
-                  }
-            } 
-            
-            if (restVar == null && !argslist.consumed())
-                error(new WrongNumberOfArgumentsException(function));
-                
-            return array;
+            return _match(args, _environment, env, thread);
         }
         finally {

trunk/abcl/src/org/armedbear/lisp/Closure.java

@@ -222 +222 @@
   }
 
-  // No optional or keyword parameters.
-  protected final LispObject[] fastProcessArgs(LispObject[] args)
-  {
-    return arglist.match(args, environment, null, null);
-  }
-
   // ### lambda-list-names
   private static final Primitive LAMBDA_LIST_NAMES =

trunk/abcl/src/org/armedbear/lisp/compiler-pass2.lisp

@@ -7047 +7047 @@
          (class-file (compiland-class-file compiland))
          (*this-class* (abcl-class-file-class class-file))
-         (args (cadr p1-result))
          (closure-args (intersection *closure-variables*
                                      (compiland-arg-vars compiland)))
@@ -7234 +7233 @@
           (aver (not (null (compiland-argument-register compiland))))
           (aload (compiland-argument-register compiland)) ; arg vector
-          (cond ((or (memq '&OPTIONAL args) (memq '&KEY args))
-                 (ensure-thread-var-initialized)
-                 (maybe-initialize-thread-var)
-                 (emit-push-current-thread)
-                 (emit-invokevirtual *this-class* "processArgs"
-                                     (list +lisp-object-array+ +lisp-thread+)
-                                     +lisp-object-array+))
-                (t
-                 (emit-invokevirtual *this-class* "fastProcessArgs"
-                                     (list +lisp-object-array+)
-                                     +lisp-object-array+)))
+          (emit 'aconst_null) ;; no thread arg required:
+                 ;; there's no non-constant initform or special
+                 ;; which might require the thread
+          (emit-invokevirtual *this-class* "processArgs"
+                              (list +lisp-object-array+ +lisp-thread+)
+                              +lisp-object-array+)
           (astore (compiland-argument-register compiland)))
 
-        (unless (and *hairy-arglist-p*
-                     (or (memq '&OPTIONAL args) (memq '&KEY args)))
-          (maybe-initialize-thread-var))
-        (setf *code* (nconc code *code*)))
-      ))
+        (maybe-initialize-thread-var)
+        (setf *code* (nconc code *code*)))))
   t)
 

trunk/abcl/src/org/armedbear/lisp/jvm-class-file.lisp

@@ -190 +190 @@
 (define-class-name +alp-keyword-parameter+
     "org.armedbear.lisp.ArgumentListProcessor$KeywordParam")
-(defconstant +lisp-closure-parameter-array+
-  (class-array +lisp-closure-parameter+))
 
 #|