Changeset 8890


Ignore:
Timestamp:
04/08/05 10:50:25 (16 years ago)
Author:
piso
Message:

Refactoring and simplification (continued).

Location:
trunk/j/src/org/armedbear/lisp
Files:
8 edited

Legend:

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

    r8887 r8890  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Closure.java,v 1.96 2005-04-07 23:34:38 piso Exp $
     5 * $Id: Closure.java,v 1.97 2005-04-08 10:45:34 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040    private static final int STATE_AUX      = 4;
    4141
    42     private final LispObject lambdaList;
    4342    private final Parameter[] requiredParameters;
    4443    private final Parameter[] optionalParameters;
     
    7271    {
    7372        super(name);
    74         this.lambdaList = lambdaList;
     73        setLambdaList(lambdaList);
    7574        Debug.assertTrue(lambdaList == NIL || lambdaList instanceof Cons);
    7675        boolean andKey = false;
     
    323322    }
    324323
    325     public final LispObject getLambdaList()
    326     {
    327         return lambdaList;
    328     }
    329 
    330324    public final LispObject getVariableList()
    331325    {
     
    10431037    }
    10441038
    1045     public String writeToString() throws ConditionThrowable
    1046     {
    1047         LispObject name = getLambdaName();
    1048         StringBuffer sb = new StringBuffer("#<FUNCTION ");
    1049         if (name != null && name != NIL) {
    1050             sb.append(name.writeToString());
    1051         } else {
    1052             sb.append("(LAMBDA ");
    1053             if (lambdaList == NIL) {
    1054                 sb.append("()");
    1055             } else {
    1056                 final LispThread thread = LispThread.currentThread();
    1057                 SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
    1058                 thread.bindSpecial(_PRINT_LENGTH_, Fixnum.THREE);
    1059                 try {
    1060                     sb.append(lambdaList.writeToString());
    1061                 }
    1062                 finally {
    1063                     thread.lastSpecialBinding = lastSpecialBinding;
    1064                 }
    1065             }
    1066             sb.append(")");
    1067         }
    1068         sb.append(" {");
    1069         sb.append(Integer.toHexString(System.identityHashCode(this)).toUpperCase());
    1070         sb.append("}>");
    1071         return sb.toString();
    1072     }
    1073 
    10741039    // ### closure-environment closure => environment
    10751040    private static final Primitive CLOSURE_ENVIRONMENT =
  • trunk/j/src/org/armedbear/lisp/Function.java

    r8888 r8890  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Function.java,v 1.49 2005-04-07 23:35:34 piso Exp $
     5 * $Id: Function.java,v 1.50 2005-04-08 10:44:07 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4141    {
    4242        this(name);
    43         setArglist(new SimpleString(arglist));
     43        setLambdaList(new SimpleString(arglist));
    4444    }
    4545
     
    6464    {
    6565        if (arglist instanceof String)
    66             setArglist(new SimpleString(arglist));
     66            setLambdaList(new SimpleString(arglist));
    6767        if (name != null) {
    6868            try {
     
    9090    }
    9191
     92    public Function(LispObject name, LispObject lambdaList)
     93    {
     94        setLambdaName(name);
     95        setLambdaList(lambdaList);
     96    }
     97
    9298    public LispObject typeOf()
    9399    {
     
    172178            sb.append("}>");
    173179            return sb.toString();
    174         } else
    175             return unreadableString("FUNCTION");
     180        }
     181        // No name.
     182        LispObject lambdaList = getLambdaList();
     183        if (lambdaList != null) {
     184            StringBuffer sb = new StringBuffer("#<FUNCTION ");
     185            sb.append("(LAMBDA ");
     186            if (lambdaList == NIL) {
     187                sb.append("()");
     188            } else {
     189                final LispThread thread = LispThread.currentThread();
     190                SpecialBinding lastSpecialBinding = thread.lastSpecialBinding;
     191                thread.bindSpecial(_PRINT_LENGTH_, Fixnum.THREE);
     192                try {
     193                    sb.append(lambdaList.writeToString());
     194                }
     195                finally {
     196                    thread.lastSpecialBinding = lastSpecialBinding;
     197                }
     198            }
     199            sb.append(")");
     200            sb.append(" {");
     201            sb.append(Integer.toHexString(System.identityHashCode(this)).toUpperCase());
     202            sb.append("}>");
     203            return sb.toString();
     204        }
     205        return unreadableString("FUNCTION");
    176206    }
    177207
  • trunk/j/src/org/armedbear/lisp/Operator.java

    r8877 r8890  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: Operator.java,v 1.2 2005-04-05 15:34:16 piso Exp $
     5 * $Id: Operator.java,v 1.3 2005-04-08 10:46:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
    24 // Common superclass of Function and SpecialOperator.
    2524public abstract class Operator extends LispObject
    2625{
    2726    protected LispObject lambdaName;
    2827
    29     private LispObject arglist;
     28    private LispObject lambdaList;
    3029
    3130    public final LispObject getLambdaName()
     
    3938    }
    4039
    41     public final LispObject getArglist()
     40    public final LispObject getLambdaList()
    4241    {
    43         return arglist;
     42        return lambdaList;
    4443    }
    4544
    46     public final void setArglist(LispObject obj)
     45    public final void setLambdaList(LispObject obj)
    4746    {
    48         arglist = obj;
     47        lambdaList = obj;
     48    }
     49
     50    public LispObject getParts() throws ConditionThrowable
     51    {
     52        LispObject result = NIL;
     53        result = result.push(new Cons("lambda-name", lambdaName));
     54        result = result.push(new Cons("lambda-list", lambdaList));
     55        return result.nreverse();
    4956    }
    5057}
  • trunk/j/src/org/armedbear/lisp/Primitive.java

    r8879 r8890  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Primitive.java,v 1.15 2005-04-05 18:52:51 piso Exp $
     5 * $Id: Primitive.java,v 1.16 2005-04-08 10:47:57 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4141    {
    4242        super(name, arglist);
     43    }
     44
     45    public Primitive(LispObject name, LispObject lambdaList)
     46    {
     47        super(name, lambdaList);
    4348    }
    4449
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r8889 r8890  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Primitives.java,v 1.758 2005-04-07 23:36:12 piso Exp $
     5 * $Id: Primitives.java,v 1.759 2005-04-08 10:48:21 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    16281628            else
    16291629                symbol.setSymbolFunction(macroObject);
    1630       macroObject.setArglist(lambdaList);
     1630      macroObject.setLambdaList(lambdaList);
    16311631            LispThread.currentThread().clearValues();
    16321632            return symbol;
     
    29632963                ((Operator)second).setLambdaName(first);
    29642964                if (fourth != NIL)
    2965                     ((Operator)second).setArglist(fourth);
     2965                    ((Operator)second).setLambdaList(fourth);
    29662966            }
    29672967            return second;
  • trunk/j/src/org/armedbear/lisp/SpecialOperator.java

    r8871 r8890  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: SpecialOperator.java,v 1.16 2005-04-04 19:32:24 piso Exp $
     5 * $Id: SpecialOperator.java,v 1.17 2005-04-08 10:47:25 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3939    {
    4040        this(name);
    41         setArglist(new SimpleString(arglist));
     41        setLambdaList(new SimpleString(arglist));
    4242    }
    4343
  • trunk/j/src/org/armedbear/lisp/arglist.java

    r8886 r8890  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: arglist.java,v 1.16 2005-04-07 23:33:45 piso Exp $
     5 * $Id: arglist.java,v 1.17 2005-04-08 10:49:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3030            return (Operator) obj;
    3131        if (obj instanceof Symbol) {
    32             LispObject fun = obj.getSymbolFunction();
    33             if (fun instanceof Autoload) {
    34                 Autoload autoload = (Autoload) fun;
     32            LispObject function = obj.getSymbolFunction();
     33            if (function instanceof Autoload) {
     34                Autoload autoload = (Autoload) function;
    3535                autoload.load();
    36                 fun = (Operator)autoload.getSymbol().getSymbolFunction();
     36                function = autoload.getSymbol().getSymbolFunction();
    3737            }
    38             if (fun instanceof Operator) {
    39                 Operator func = (Operator) fun;
    40                 if (func.getArglist() != null)
    41                     return func;
     38            if (function instanceof Operator) {
     39                Operator operator = (Operator) function;
     40                if (operator.getLambdaList() != null)
     41                    return operator;
    4242                LispObject other =
    4343                    get(checkSymbol(obj), Symbol.MACROEXPAND_MACRO, NIL);
     
    6262            LispObject arglist = null;
    6363            if (operator != null)
    64                 arglist = operator.getArglist();
     64                arglist = operator.getLambdaList();
    6565            final LispObject value1, value2;
    6666            if (arglist instanceof AbstractString) {
     
    7878                    thread.lastSpecialBinding = lastSpecialBinding;
    7979                }
    80                 operator.setArglist(arglist);
     80                operator.setLambdaList(arglist);
    8181            }
    8282            if (arglist != null) {
     
    9898            throws ConditionThrowable
    9999        {
    100             coerceToFunctional(first).setArglist(second);
     100            coerceToFunctional(first).setLambdaList(second);
    101101            return second;
    102102        }
  • trunk/j/src/org/armedbear/lisp/jvm.lisp

    r8885 r8890  
    22;;;
    33;;; Copyright (C) 2003-2005 Peter Graves
    4 ;;; $Id: jvm.lisp,v 1.420 2005-04-07 23:32:59 piso Exp $
     4;;; $Id: jvm.lisp,v 1.421 2005-04-08 10:50:25 piso Exp $
    55;;;
    66;;; This program is free software; you can redistribute it and/or
     
    20482048                  (emit 'ldc (pool-string (package-name (symbol-package lambda-name))))
    20492049                  (emit-invokestatic +lisp-class+ "internInPackage"
    2050                                      (list +java-string+ +java-string+) +lisp-symbol+)
    2051                   (emit-invokespecial-init super (list +lisp-object+)))
     2050                                     (list +java-string+ +java-string+) +lisp-symbol+))
    20522051                 (t
    2053                   (emit-invokespecial-init super nil)))
    2054            )
     2052                  (emit-push-nil))) ; no name
     2053           (let* ((*print-level* nil)
     2054                  (*print-length* nil)
     2055                  (s (sys::%format nil "~S" args)))
     2056             (emit 'ldc (pool-string s))
     2057             (emit-invokestatic +lisp-class+ "readObjectFromString"
     2058                                (list +java-string+) +lisp-object+))
     2059           (emit-invokespecial-init super (list +lisp-object+ +lisp-object+)))
    20552060          ((equal super +lisp-ctf-class+)
    20562061           (emit 'aload_0) ;; this
Note: See TracChangeset for help on using the changeset viewer.