Changeset 8087


Ignore:
Timestamp:
11/03/04 15:39:02 (17 years ago)
Author:
piso
Message:

Primitive[01] => Primitive

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

Legend:

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

    r7968 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: ArithmeticError.java,v 1.11 2004-10-13 00:22:17 piso Exp $
     5 * $Id: ArithmeticError.java,v 1.12 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8080
    8181    // ### arithmetic-error-operation
    82     private static final Primitive1 ARITHMETIC_ERROR_OPERATION =
    83         new Primitive1("arithmetic-error-operation", "condition")
     82    private static final Primitive ARITHMETIC_ERROR_OPERATION =
     83        new Primitive("arithmetic-error-operation", "condition")
    8484    {
    8585        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    9494    };
    9595    // ### arithmetic-error-operands
    96     private static final Primitive1 ARITHMETIC_ERROR_OPERANDS =
    97         new Primitive1("arithmetic-error-operands", "condition")
     96    private static final Primitive ARITHMETIC_ERROR_OPERANDS =
     97        new Primitive("arithmetic-error-operands", "condition")
    9898    {
    9999        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Autoload.java

    r8035 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: Autoload.java,v 1.203 2004-10-22 15:55:37 piso Exp $
     5 * $Id: Autoload.java,v 1.204 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    222222    // ### resolve
    223223    // Force autoload to be resolved.
    224     private static final Primitive1 RESOLVE =
    225         new Primitive1("resolve", PACKAGE_EXT, true, "symbol")
     224    private static final Primitive RESOLVE =
     225        new Primitive("resolve", PACKAGE_EXT, true, "symbol")
    226226    {
    227227        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    239239
    240240    // ### autoloadp
    241     private static final Primitive1 AUTOLOADP =
    242         new Primitive1("autoloadp", PACKAGE_EXT, true, "symbol")
     241    private static final Primitive AUTOLOADP =
     242        new Primitive("autoloadp", PACKAGE_EXT, true, "symbol")
    243243    {
    244244        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/BroadcastStream.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: BroadcastStream.java,v 1.9 2004-10-13 00:22:17 piso Exp $
     5 * $Id: BroadcastStream.java,v 1.10 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    212212
    213213    // ### broadcast-stream-streams broadcast-stream => streams
    214     private static final Primitive1 BROADCAST_STREAM_STREAMS =
    215         new Primitive1("broadcast-stream-streams", "broadcast-stream")
     214    private static final Primitive BROADCAST_STREAM_STREAMS =
     215        new Primitive("broadcast-stream-streams", "broadcast-stream")
    216216    {
    217217        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Closure.java

    r8047 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Closure.java,v 1.84 2004-10-23 15:01:50 piso Exp $
     5 * $Id: Closure.java,v 1.85 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    10911091
    10921092    // ### closure-environment closure => environment
    1093     private static final Primitive1 CLOSURE_ENVIRONMENT =
    1094         new Primitive1("closure-environment", PACKAGE_SYS, false, "closure")
     1093    private static final Primitive CLOSURE_ENVIRONMENT =
     1094        new Primitive("closure-environment", PACKAGE_SYS, false, "closure")
    10951095    {
    10961096        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/CompiledFunction.java

    r7732 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: CompiledFunction.java,v 1.29 2004-09-18 18:43:55 piso Exp $
     5 * $Id: CompiledFunction.java,v 1.30 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    108108
    109109    // ### varlist
    110     private static final Primitive1 VARLIST =
    111         new Primitive1("varlist", PACKAGE_SYS, false)
     110    private static final Primitive VARLIST =
     111        new Primitive("varlist", PACKAGE_SYS, false)
    112112    {
    113113        public LispObject execute(LispObject arg) throws ConditionThrowable {
  • trunk/j/src/org/armedbear/lisp/ConcatenatedStream.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: ConcatenatedStream.java,v 1.5 2004-10-13 00:22:17 piso Exp $
     5 * $Id: ConcatenatedStream.java,v 1.6 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    235235
    236236    // ### concatenated-stream-streams concatenated-stream => streams
    237     private static final Primitive1 CONCATENATED_STREAM_STREAMS =
    238         new Primitive1("concatenated-stream-streams", "concatenated-stream")
     237    private static final Primitive CONCATENATED_STREAM_STREAMS =
     238        new Primitive("concatenated-stream-streams", "concatenated-stream")
    239239    {
    240240        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Condition.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: Condition.java,v 1.29 2004-10-13 00:22:17 piso Exp $
     5 * $Id: Condition.java,v 1.30 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    154154
    155155    // ### condition-report
    156     private static final Primitive1 CONDITION_REPORT =
    157         new Primitive1("condition-report", PACKAGE_SYS, false, "condition")
     156    private static final Primitive CONDITION_REPORT =
     157        new Primitive("condition-report", PACKAGE_SYS, false, "condition")
    158158    {
    159159        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/EchoStream.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: EchoStream.java,v 1.12 2004-11-03 15:27:21 piso Exp $
     5 * $Id: EchoStream.java,v 1.13 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    222222    // ### echo-stream-input-stream
    223223    // echo-stream => input-stream
    224     private static final Primitive1 ECHO_STREAM_INPUT_STREAM =
    225         new Primitive1("echo-stream-input-stream","echo-stream") {
     224    private static final Primitive ECHO_STREAM_INPUT_STREAM =
     225        new Primitive("echo-stream-input-stream","echo-stream") {
    226226        public LispObject execute(LispObject arg) throws ConditionThrowable
    227227        {
     
    234234    // ### echo-stream-output-stream
    235235    // echo-stream => output-stream
    236     private static final Primitive1 ECHO_STREAM_OUTPUT_STREAM =
    237         new Primitive1("echo-stream-output-stream","echo-stream") {
     236    private static final Primitive ECHO_STREAM_OUTPUT_STREAM =
     237        new Primitive("echo-stream-output-stream","echo-stream") {
    238238        public LispObject execute(LispObject arg) throws ConditionThrowable
    239239        {
  • trunk/j/src/org/armedbear/lisp/Environment.java

    r7460 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Environment.java,v 1.16 2004-08-19 18:14:46 piso Exp $
     5 * $Id: Environment.java,v 1.17 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    205205
    206206    // ### empty-environment-p
    207     private static final Primitive1 EMPTY_ENVIRONMENT_P =
    208         new Primitive1("empty-environment-p", PACKAGE_SYS, false, "environment")
     207    private static final Primitive EMPTY_ENVIRONMENT_P =
     208        new Primitive("empty-environment-p", PACKAGE_SYS, false, "environment")
    209209    {
    210210        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    221221
    222222    // ### environment-vars
    223     private static final Primitive1 ENVIRONMENT_VARS =
    224         new Primitive1("environment-vars", PACKAGE_SYS, false, "environment")
     223    private static final Primitive ENVIRONMENT_VARS =
     224        new Primitive("environment-vars", PACKAGE_SYS, false, "environment")
    225225    {
    226226        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Extensions.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Extensions.java,v 1.32 2004-11-03 15:27:21 piso Exp $
     5 * $Id: Extensions.java,v 1.33 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7575
    7676    // ### special-variable-p
    77     private static final Primitive1 SPECIAL_VARIABLE_P =
    78         new Primitive1("special-variable-p", PACKAGE_EXT, true)
     77    private static final Primitive SPECIAL_VARIABLE_P =
     78        new Primitive("special-variable-p", PACKAGE_EXT, true)
    7979    {
    8080        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    8686    // ### charpos
    8787    // charpos stream => position
    88     private static final Primitive1 CHARPOS =
    89         new Primitive1("charpos", PACKAGE_EXT, true)
     88    private static final Primitive CHARPOS =
     89        new Primitive("charpos", PACKAGE_EXT, true)
    9090    {
    9191        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    111111
    112112    // ### source
    113     private static final Primitive1 SOURCE =
    114         new Primitive1("source", PACKAGE_EXT, true)
     113    private static final Primitive SOURCE =
     114        new Primitive("source", PACKAGE_EXT, true)
    115115    {
    116116        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    121121
    122122    // ### source-file-position
    123     private static final Primitive1 SOURCE_FILE_POSITION =
    124         new Primitive1("source-file-position", PACKAGE_EXT, true)
     123    private static final Primitive SOURCE_FILE_POSITION =
     124        new Primitive("source-file-position", PACKAGE_EXT, true)
    125125    {
    126126        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    134134
    135135    // ### source-pathname
    136     private static final Primitive1 SOURCE_PATHNAME =
    137         new Primitive1("source-pathname", PACKAGE_EXT, true)
     136    private static final Primitive SOURCE_PATHNAME =
     137        new Primitive("source-pathname", PACKAGE_EXT, true)
    138138    {
    139139        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    149149
    150150    // ### exit
    151     private static final Primitive0 EXIT =
    152         new Primitive0("exit", PACKAGE_EXT, true)
     151    private static final Primitive EXIT =
     152        new Primitive("exit", PACKAGE_EXT, true)
    153153    {
    154154        public LispObject execute() throws ConditionThrowable
     
    160160
    161161    // ### quit
    162     private static final Primitive0 QUIT =
    163         new Primitive0("quit", PACKAGE_EXT, true)
     162    private static final Primitive QUIT =
     163        new Primitive("quit", PACKAGE_EXT, true)
    164164    {
    165165        public LispObject execute() throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/FillPointerOutputStream.java

    r6935 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: FillPointerOutputStream.java,v 1.10 2004-05-28 18:12:41 piso Exp $
     5 * $Id: FillPointerOutputStream.java,v 1.11 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3939    // ### make-fill-pointer-output-stream
    4040    // make-fill-pointer-output-stream string => string-stream
    41     private static final Primitive1 MAKE_FILL_POINTER_OUTPUT_STREAM =
    42         new Primitive1("make-fill-pointer-output-stream", PACKAGE_SYS, false) {
     41    private static final Primitive MAKE_FILL_POINTER_OUTPUT_STREAM =
     42        new Primitive("make-fill-pointer-output-stream", PACKAGE_SYS, false) {
    4343        public LispObject execute(LispObject arg) throws ConditionThrowable
    4444        {
  • trunk/j/src/org/armedbear/lisp/HashTable.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: HashTable.java,v 1.43 2004-11-03 15:27:22 piso Exp $
     5 * $Id: HashTable.java,v 1.44 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    399399    // ### clrhash
    400400    // clrhash hash-table => hash-table
    401     private static final Primitive1 CLRHASH =
    402         new Primitive1("clrhash", "hash-table")
     401    private static final Primitive CLRHASH =
     402        new Primitive("clrhash", "hash-table")
    403403    {
    404404        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    413413
    414414    // ### hash-table-count
    415     private static final Primitive1 HASH_TABLE_COUNT =
    416         new Primitive1("hash-table-count", "hash-table")
     415    private static final Primitive HASH_TABLE_COUNT =
     416        new Primitive("hash-table-count", "hash-table")
    417417    {
    418418        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    426426    // ### sxhash
    427427    // sxhash object => hash-code
    428     private static final Primitive1 SXHASH = new Primitive1("sxhash", "object")
     428    private static final Primitive SXHASH = new Primitive("sxhash", "object")
    429429    {
    430430        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    437437    // psxhash object => hash-code
    438438    // For EQUALP hash tables.
    439     private static final Primitive1 PSXHASH =
    440         new Primitive1("psxhash", PACKAGE_SYS, false, "object")
     439    private static final Primitive PSXHASH =
     440        new Primitive("psxhash", PACKAGE_SYS, false, "object")
    441441    {
    442442        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    457457
    458458    // ### hash-table-p
    459     private static final Primitive1 HASH_TABLE_P =
    460         new Primitive1("hash-table-p","object") {
     459    private static final Primitive HASH_TABLE_P =
     460        new Primitive("hash-table-p","object") {
    461461        public LispObject execute(LispObject arg) throws ConditionThrowable
    462462        {
     
    466466
    467467    // ### hash-table-entries
    468     private static final Primitive1 HASH_TABLE_ENTRIES =
    469         new Primitive1("hash-table-entries", PACKAGE_SYS, false) {
     468    private static final Primitive HASH_TABLE_ENTRIES =
     469        new Primitive("hash-table-entries", PACKAGE_SYS, false) {
    470470        public LispObject execute(LispObject arg) throws ConditionThrowable
    471471        {
     
    476476    };
    477477
    478     private static final Primitive1 HASH_TABLE_TEST =
    479         new Primitive1("hash-table-test", "hash-table")
     478    private static final Primitive HASH_TABLE_TEST =
     479        new Primitive("hash-table-test", "hash-table")
    480480    {
    481481        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    500500    };
    501501
    502     private static final Primitive1 HASH_TABLE_SIZE =
    503         new Primitive1("hash-table-size", "hash-table")
     502    private static final Primitive HASH_TABLE_SIZE =
     503        new Primitive("hash-table-size", "hash-table")
    504504    {
    505505        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    511511    };
    512512
    513     private static final Primitive1 HASH_TABLE_REHASH_SIZE =
    514         new Primitive1("hash-table-rehash-size", "hash-table")
     513    private static final Primitive HASH_TABLE_REHASH_SIZE =
     514        new Primitive("hash-table-rehash-size", "hash-table")
    515515    {
    516516        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    522522    };
    523523
    524     private static final Primitive1 HASH_TABLE_REHASH_THRESHOLD =
    525         new Primitive1("hash-table-rehash-threshold", "hash-table")
     524    private static final Primitive HASH_TABLE_REHASH_THRESHOLD =
     525        new Primitive("hash-table-rehash-threshold", "hash-table")
    526526    {
    527527        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Java.java

    r7391 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Java.java,v 1.44 2004-08-10 22:28:13 asimon Exp $
     5 * $Id: Java.java,v 1.45 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3232{
    3333    // ### jclass
    34     private static final Primitive1 JCLASS = new Primitive1("jclass", PACKAGE_JAVA, true, "name")
     34    private static final Primitive JCLASS = new Primitive("jclass", PACKAGE_JAVA, true, "name")
    3535    {
    3636        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    541541    };
    542542
    543     private static final Primitive1 JAVA_OBJECT_P = new Primitive1("java-object-p", PACKAGE_JAVA, true,
     543    private static final Primitive JAVA_OBJECT_P = new Primitive("java-object-p", PACKAGE_JAVA, true,
    544544                                                                   "object")
    545545    {
     
    552552    // ### jobject-lisp-value
    553553    // jobject-lisp-value java-object
    554     private static final Primitive1 JOBJECT_LISP_VALUE =
    555         new Primitive1("jobject-lisp-value", PACKAGE_JAVA, true, "java-object")
     554    private static final Primitive JOBJECT_LISP_VALUE =
     555        new Primitive("jobject-lisp-value", PACKAGE_JAVA, true, "java-object")
    556556    {
    557557        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Layout.java

    r8080 r8087  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Layout.java,v 1.6 2004-11-03 15:06:03 piso Exp $
     5 * $Id: Layout.java,v 1.7 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5959
    6060    // ### layout-class
    61     private static final Primitive1 LAYOUT_CLASS =
    62         new Primitive1("layout-class", PACKAGE_SYS, false)
     61    private static final Primitive LAYOUT_CLASS =
     62        new Primitive("layout-class", PACKAGE_SYS, false)
    6363    {
    6464        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    7474
    7575    // ### layout-length
    76     private static final Primitive1 LAYOUT_LENGTH =
    77         new Primitive1("layout-length", PACKAGE_SYS, false)
     76    private static final Primitive LAYOUT_LENGTH =
     77        new Primitive("layout-length", PACKAGE_SYS, false)
    7878    {
    7979        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Lisp.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Lisp.java,v 1.291 2004-11-03 15:27:22 piso Exp $
     5 * $Id: Lisp.java,v 1.292 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    294294
    295295    // ### interactive-eval
    296     private static final Primitive1 INTERACTIVE_EVAL =
    297         new Primitive1("interactive-eval", PACKAGE_SYS, false)
     296    private static final Primitive INTERACTIVE_EVAL =
     297        new Primitive("interactive-eval", PACKAGE_SYS, false)
    298298    {
    299299        public LispObject execute(LispObject object) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/LispCharacter.java

    r8013 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: LispCharacter.java,v 1.58 2004-10-20 00:11:10 piso Exp $
     5 * $Id: LispCharacter.java,v 1.59 2004-11-03 15:38:52 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    221221    }
    222222
    223     private static final Primitive1 CHARACTER =
    224         new Primitive1("character", "character")
     223    private static final Primitive CHARACTER =
     224        new Primitive("character", "character")
    225225    {
    226226        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    241241
    242242    // ### whitespacep
    243     private static final Primitive1 WHITESPACEP =
    244         new Primitive1("whitespacep", PACKAGE_SYS, false)
     243    private static final Primitive WHITESPACEP =
     244        new Primitive("whitespacep", PACKAGE_SYS, false)
    245245    {
    246246        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    256256
    257257    // ### char-code
    258     private static final Primitive1 CHAR_CODE = new Primitive1("char-code", "character")
     258    private static final Primitive CHAR_CODE = new Primitive("char-code", "character")
    259259    {
    260260        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    270270
    271271    // ### char-int
    272     private static final Primitive1 CHAR_INT = new Primitive1("char-int", "character")
     272    private static final Primitive CHAR_INT = new Primitive("char-int", "character")
    273273    {
    274274        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    284284
    285285    // ### code-char
    286     private static final Primitive1 CODE_CHAR = new Primitive1("code-char", "code")
     286    private static final Primitive CODE_CHAR = new Primitive("code-char", "code")
    287287    {
    288288        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    301301
    302302    // ### characterp
    303     private static final Primitive1 CHARACTERP =
    304         new Primitive1("characterp", "object")
     303    private static final Primitive CHARACTERP =
     304        new Primitive("characterp", "object")
    305305    {
    306306        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    311311
    312312    // ### both-case-p
    313     private static final Primitive1 BOTH_CASE_P =
    314         new Primitive1("both-case-p", "character")
     313    private static final Primitive BOTH_CASE_P =
     314        new Primitive("both-case-p", "character")
    315315    {
    316316        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    324324
    325325    // ### lower-case-p
    326     private static final Primitive1 LOWER_CASE_P =
    327         new Primitive1("lower-case-p", "character")
     326    private static final Primitive LOWER_CASE_P =
     327        new Primitive("lower-case-p", "character")
    328328    {
    329329        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    334334
    335335    // ### upper-case-p
    336     private static final Primitive1 UPPER_CASE_P =
    337         new Primitive1("upper-case-p", "character")
     336    private static final Primitive UPPER_CASE_P =
     337        new Primitive("upper-case-p", "character")
    338338    {
    339339        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    344344
    345345    // ### char-downcase
    346     private static final Primitive1 CHAR_DOWNCASE =
    347         new Primitive1("char-downcase", "character")
     346    private static final Primitive CHAR_DOWNCASE =
     347        new Primitive("char-downcase", "character")
    348348    {
    349349        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    354354
    355355    // ### char-upcase
    356     private static final Primitive1 CHAR_UPCASE =
    357         new Primitive1("char-upcase", "character")
     356    private static final Primitive CHAR_UPCASE =
     357        new Primitive("char-upcase", "character")
    358358    {
    359359        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    454454
    455455    // ### standard-char-p
    456     private static final Primitive1 STANDARD_CHAR_P =
    457         new Primitive1("standard-char-p", "character")
     456    private static final Primitive STANDARD_CHAR_P =
     457        new Primitive("standard-char-p", "character")
    458458    {
    459459        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    469469
    470470    // ### graphic-char-p
    471     private static final Primitive1 GRAPHIC_CHAR_P =
    472         new Primitive1("graphic-char-p", "char")
     471    private static final Primitive GRAPHIC_CHAR_P =
     472        new Primitive("graphic-char-p", "char")
    473473    {
    474474        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    487487
    488488    // ### alpha-char-p
    489     private static final Primitive1 ALPHA_CHAR_P =
    490         new Primitive1("alpha-char-p", "character")
     489    private static final Primitive ALPHA_CHAR_P =
     490        new Primitive("alpha-char-p", "character")
    491491    {
    492492        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    502502
    503503    // ### alphanumericp
    504     private static final Primitive1 ALPHANUMERICP =
    505         new Primitive1("alphanumericp", "character")
     504    private static final Primitive ALPHANUMERICP =
     505        new Primitive("alphanumericp", "character")
    506506    {
    507507        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    542542
    543543    // ### name-char
    544     private static final Primitive1 NAME_CHAR =
    545         new Primitive1("name-char", "name")
     544    private static final Primitive NAME_CHAR =
     545        new Primitive("name-char", "name")
    546546    {
    547547        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    577577
    578578    // ### char-name
    579     private static final Primitive1 CHAR_NAME =
    580         new Primitive1("char-name", "character")
     579    private static final Primitive CHAR_NAME =
     580        new Primitive("char-name", "character")
    581581    {
    582582        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/LispClass.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: LispClass.java,v 1.51 2004-11-03 15:27:22 piso Exp $
     5 * $Id: LispClass.java,v 1.52 2004-11-03 15:39:00 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    284284
    285285    // ### %class-name
    286     private static final Primitive1 _CLASS_NAME =
    287         new Primitive1("%class-name", PACKAGE_SYS, false, "class")
     286    private static final Primitive _CLASS_NAME =
     287        new Primitive("%class-name", PACKAGE_SYS, false, "class")
    288288    {
    289289        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    316316
    317317    // ### class-layout
    318     private static final Primitive1 CLASS_LAYOUT =
    319         new Primitive1("class-layout", PACKAGE_SYS, false)
     318    private static final Primitive CLASS_LAYOUT =
     319        new Primitive("class-layout", PACKAGE_SYS, false)
    320320    {
    321321        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    354354
    355355    // ### class-direct-superclasses
    356     private static final Primitive1 CLASS_DIRECT_SUPERCLASSES =
    357         new Primitive1("class-direct-superclasses", PACKAGE_SYS, false)
     356    private static final Primitive CLASS_DIRECT_SUPERCLASSES =
     357        new Primitive("class-direct-superclasses", PACKAGE_SYS, false)
    358358    {
    359359        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    381381
    382382    // ### class-direct-subclasses
    383     private static final Primitive1 CLASS_DIRECT_SUBCLASSES =
    384         new Primitive1("class-direct-subclasses", PACKAGE_SYS, false)
     383    private static final Primitive CLASS_DIRECT_SUBCLASSES =
     384        new Primitive("class-direct-subclasses", PACKAGE_SYS, false)
    385385    {
    386386        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    408408
    409409    // ### class-precedence-list
    410     private static final Primitive1 CLASS_PRECEDENCE_LIST =
    411         new Primitive1("class-precedence-list", PACKAGE_SYS, false)
     410    private static final Primitive CLASS_PRECEDENCE_LIST =
     411        new Primitive("class-precedence-list", PACKAGE_SYS, false)
    412412    {
    413413        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    420420
    421421    // ### %set-class-precedence-list
    422     private static final Primitive1 _SET_CLASS_PRECEDENCE_LIST =
    423         new Primitive1("%set-class-precedence-list", PACKAGE_SYS, false)
     422    private static final Primitive _SET_CLASS_PRECEDENCE_LIST =
     423        new Primitive("%set-class-precedence-list", PACKAGE_SYS, false)
    424424    {
    425425        public LispObject execute(LispObject first, LispObject second)
     
    435435
    436436    // ### class-direct-methods
    437     private static final Primitive1 CLASS_DIRECT_METHODS =
    438         new Primitive1("class-direct-methods", PACKAGE_SYS, false)
     437    private static final Primitive CLASS_DIRECT_METHODS =
     438        new Primitive("class-direct-methods", PACKAGE_SYS, false)
    439439    {
    440440        public LispObject execute(LispObject arg)
     
    463463
    464464    // ### class-documentation
    465     private static final Primitive1 CLASS_DOCUMENTATION =
    466         new Primitive1("class-documentation", PACKAGE_SYS, false)
     465    private static final Primitive CLASS_DOCUMENTATION =
     466        new Primitive("class-documentation", PACKAGE_SYS, false)
    467467    {
    468468        public LispObject execute(LispObject arg)
     
    491491
    492492    // ### classp
    493     private static final Primitive1 CLASSP =
    494         new Primitive1("classp", PACKAGE_EXT, true)
     493    private static final Primitive CLASSP =
     494        new Primitive("classp", PACKAGE_EXT, true)
    495495    {
    496496        public LispObject execute(LispObject arg)
  • trunk/j/src/org/armedbear/lisp/LispFloat.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: LispFloat.java,v 1.78 2004-11-03 15:27:22 piso Exp $
     5 * $Id: LispFloat.java,v 1.79 2004-11-03 15:39:00 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    477477    // ### integer-decode-float
    478478    // integer-decode-float float => significand, exponent, integer-sign
    479     private static final Primitive1 INTEGER_DECODE_FLOAT =
    480         new Primitive1("integer-decode-float", "float")
     479    private static final Primitive INTEGER_DECODE_FLOAT =
     480        new Primitive("integer-decode-float", "float")
    481481    {
    482482        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    532532
    533533    // ### rational
    534     private static final Primitive1 RATIONAL =
    535         new Primitive1("rational", "number")
     534    private static final Primitive RATIONAL =
     535        new Primitive("rational", "number")
    536536    {
    537537        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    547547    // ### float-radix
    548548    // float-radix float => float-radix
    549     private static final Primitive1 FLOAT_RADIX =
    550         new Primitive1("float-radix", "float")
     549    private static final Primitive FLOAT_RADIX =
     550        new Primitive("float-radix", "float")
    551551    {
    552552        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    562562    // ### float-digits
    563563    // float-digits float => float-digits
    564     private static final Primitive1 FLOAT_DIGITS =
    565         new Primitive1("float-digits", "float")
     564    private static final Primitive FLOAT_DIGITS =
     565        new Primitive("float-digits", "float")
    566566    {
    567567        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    603603
    604604    // ### coerce-to-float
    605     private static final Primitive1 COERCE_TO_FLOAT =
    606         new Primitive1("coerce-to-float", PACKAGE_SYS, false)
     605    private static final Primitive COERCE_TO_FLOAT =
     606        new Primitive("coerce-to-float", PACKAGE_SYS, false)
    607607    {
    608608        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    629629    // ### floatp
    630630    // floatp object => generalized-boolean
    631     private static final Primitive1 FLOATP = new Primitive1("floatp", "object")
     631    private static final Primitive FLOATP = new Primitive("floatp", "object")
    632632    {
    633633        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    638638
    639639    // ### double-float-high-bits
    640     private static final Primitive1 DOUBLE_FLOAT_HIGH_BITS =
    641         new Primitive1("double-float-high-bits", PACKAGE_SYS, false, "float")
     640    private static final Primitive DOUBLE_FLOAT_HIGH_BITS =
     641        new Primitive("double-float-high-bits", PACKAGE_SYS, false, "float")
    642642    {
    643643        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    652652
    653653    // ### double-float-low-bits
    654     private static final Primitive1 DOUBLE_FLOAT_LOW_BITS =
    655         new Primitive1("double-float-low-bits", PACKAGE_SYS, false, "float")
     654    private static final Primitive DOUBLE_FLOAT_LOW_BITS =
     655        new Primitive("double-float-low-bits", PACKAGE_SYS, false, "float")
    656656    {
    657657        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    684684    };
    685685
    686     private static final Primitive1 FLOAT_INFINITY_P =
    687         new Primitive1("float-infinity-p", PACKAGE_SYS, false)
     686    private static final Primitive FLOAT_INFINITY_P =
     687        new Primitive("float-infinity-p", PACKAGE_SYS, false)
    688688    {
    689689        public LispObject execute(LispObject arg)
     
    696696    };
    697697
    698     private static final Primitive1 FLOAT_NAN_P =
    699         new Primitive1("float-nan-p", PACKAGE_SYS, false)
     698    private static final Primitive FLOAT_NAN_P =
     699        new Primitive("float-nan-p", PACKAGE_SYS, false)
    700700    {
    701701        public LispObject execute(LispObject arg)
  • trunk/j/src/org/armedbear/lisp/LispThread.java

    r8072 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: LispThread.java,v 1.64 2004-10-25 13:24:32 piso Exp $
     5 * $Id: LispThread.java,v 1.65 2004-11-03 15:39:00 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    754754
    755755    // ### thread-alive-p
    756     private static final Primitive1 THREAD_ALIVE_P =
    757         new Primitive1("thread-alive-p", PACKAGE_EXT, true, "thread")
     756    private static final Primitive THREAD_ALIVE_P =
     757        new Primitive("thread-alive-p", PACKAGE_EXT, true, "thread")
    758758    {
    759759        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    769769
    770770    // ### thread-name
    771     private static final Primitive1 THREAD_NAME =
    772         new Primitive1("thread-name", PACKAGE_EXT, true, "thread")
     771    private static final Primitive THREAD_NAME =
     772        new Primitive("thread-name", PACKAGE_EXT, true, "thread")
    773773    {
    774774        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    784784
    785785    // ### sleep
    786     private static final Primitive1 SLEEP = new Primitive1("sleep", "seconds")
     786    private static final Primitive SLEEP = new Primitive("sleep", "seconds")
    787787    {
    788788        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    804804
    805805    // ### mapcar-threads
    806     private static final Primitive1 MAPCAR_THREADS =
    807         new Primitive1("mapcar-threads", PACKAGE_EXT, true)
     806    private static final Primitive MAPCAR_THREADS =
     807        new Primitive("mapcar-threads", PACKAGE_EXT, true)
    808808    {
    809809        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    823823
    824824    // ### destroy-thread
    825     private static final Primitive1 DESTROY_THREAD =
    826         new Primitive1("destroy-thread", PACKAGE_EXT, true)
     825    private static final Primitive DESTROY_THREAD =
     826        new Primitive("destroy-thread", PACKAGE_EXT, true)
    827827    {
    828828        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    863863
    864864    // ### current-thread
    865     private static final Primitive0 CURRENT_THREAD =
    866         new Primitive0("current-thread", PACKAGE_EXT, true)
     865    private static final Primitive CURRENT_THREAD =
     866        new Primitive("current-thread", PACKAGE_EXT, true)
    867867    {
    868868        public LispObject execute() throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Load.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Load.java,v 1.81 2004-11-03 15:27:22 piso Exp $
     5 * $Id: Load.java,v 1.82 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    420420
    421421    // ### load-system-file
    422     private static final Primitive1 LOAD_SYSTEM_FILE =
    423         new Primitive1("load-system-file", PACKAGE_SYS, true)
     422    private static final Primitive LOAD_SYSTEM_FILE =
     423        new Primitive("load-system-file", PACKAGE_SYS, true)
    424424    {
    425425        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/LogicalPathname.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: LogicalPathname.java,v 1.5 2004-11-03 15:27:22 piso Exp $
     5 * $Id: LogicalPathname.java,v 1.6 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7070
    7171    // ### logical-pathname-translations host => translations
    72     private static final Primitive1 LOGICAL_PATHNAME_TRANSLATIONS =
    73         new Primitive1("logical-pathname-translations", "host")
     72    private static final Primitive LOGICAL_PATHNAME_TRANSLATIONS =
     73        new Primitive("logical-pathname-translations", "host")
    7474    {
    7575        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    8080
    8181    // ### load-logical-pathname-translations host => just-loaded
    82     private static final Primitive1 LOAD_LOGICAL_PATHNAME_TRANSLATIONS =
    83         new Primitive1("load-logical-pathname-translations", "host")
     82    private static final Primitive LOAD_LOGICAL_PATHNAME_TRANSLATIONS =
     83        new Primitive("load-logical-pathname-translations", "host")
    8484    {
    8585        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    9393
    9494    // ### logical-pathname pathspec => logical-pathname
    95     private static final Primitive1 LOGICAL_PATHNAME =
    96         new Primitive1("logical-pathname", "pathspec")
     95    private static final Primitive LOGICAL_PATHNAME =
     96        new Primitive("logical-pathname", "pathspec")
    9797    {
    9898        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Mailbox.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: Mailbox.java,v 1.5 2004-11-03 15:27:22 piso Exp $
     5 * $Id: Mailbox.java,v 1.6 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7373
    7474    // ### make-mailbox
    75     private static final Primitive0 MAKE_MAILBOX =
    76         new Primitive0("make-mailbox", PACKAGE_EXT, true, "")
     75    private static final Primitive MAKE_MAILBOX =
     76        new Primitive("make-mailbox", PACKAGE_EXT, true, "")
    7777    {
    7878        public LispObject execute() throws ConditionThrowable
     
    9999
    100100    // ### mailbox-read mailbox
    101     private static final Primitive1 MAILBOX_READ =
    102         new Primitive1("mailbox-read", PACKAGE_EXT, true, "mailbox")
     101    private static final Primitive MAILBOX_READ =
     102        new Primitive("mailbox-read", PACKAGE_EXT, true, "mailbox")
    103103    {
    104104        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    113113
    114114    // ### mailbox-peek mailbox
    115     private static final Primitive1 MAILBOX_PEEK =
    116         new Primitive1("mailbox-peek", PACKAGE_EXT, true, "mailbox")
     115    private static final Primitive MAILBOX_PEEK =
     116        new Primitive("mailbox-peek", PACKAGE_EXT, true, "mailbox")
    117117    {
    118118        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    127127
    128128    // ### mailbox-empty-p mailbox
    129     private static final Primitive1 MAILBOX_EMPTY_P =
    130         new Primitive1("mailbox-empty-p", PACKAGE_EXT, true, "mailbox")
     129    private static final Primitive MAILBOX_EMPTY_P =
     130        new Primitive("mailbox-empty-p", PACKAGE_EXT, true, "mailbox")
    131131    {
    132132        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/MathFunctions.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: MathFunctions.java,v 1.15 2004-11-03 15:27:22 piso Exp $
     5 * $Id: MathFunctions.java,v 1.16 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3333
    3434    // ### sin
    35     private static final Primitive1 SIN = new Primitive1("sin", "radians")
     35    private static final Primitive SIN = new Primitive("sin", "radians")
    3636    {
    3737        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    5757
    5858    // ### cos
    59     private static final Primitive1 COS = new Primitive1("cos", "radians")
     59    private static final Primitive COS = new Primitive("cos", "radians")
    6060    {
    6161        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    8080
    8181    // ### tan
    82     private static final Primitive1 TAN = new Primitive1("tan", "radians")
     82    private static final Primitive TAN = new Primitive("tan", "radians")
    8383    {
    8484        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    9191
    9292    // ### asin
    93     private static final Primitive1 ASIN = new Primitive1("asin", "number")
     93    private static final Primitive ASIN = new Primitive("asin", "number")
    9494    {
    9595        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    126126
    127127    // ### acos
    128     private static final Primitive1 ACOS = new Primitive1("acos", "number")
     128    private static final Primitive ACOS = new Primitive("acos", "number")
    129129    {
    130130        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    192192
    193193    // ### sinh
    194     private static final Primitive1 SINH = new Primitive1("sinh", "number")
     194    private static final Primitive SINH = new Primitive("sinh", "number")
    195195    {
    196196        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    245245
    246246    // ### cosh
    247     private static final Primitive1 COSH = new Primitive1("cosh", "number")
     247    private static final Primitive COSH = new Primitive("cosh", "number")
    248248    {
    249249        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    300300
    301301    // ### tanh
    302     private static final Primitive1 TANH = new Primitive1("tanh", "number")
     302    private static final Primitive TANH = new Primitive("tanh", "number")
    303303    {
    304304        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    330330
    331331    // ### asinh
    332     private static final Primitive1 ASINH = new Primitive1("asinh", "number")
     332    private static final Primitive ASINH = new Primitive("asinh", "number")
    333333    {
    334334        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    362362
    363363    // ### acosh
    364     private static final Primitive1 ACOSH = new Primitive1("acosh", "number")
     364    private static final Primitive ACOSH = new Primitive("acosh", "number")
    365365    {
    366366        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    398398
    399399    // ### atanh
    400     private static final Primitive1 ATANH = new Primitive1("atanh", "number")
     400    private static final Primitive ATANH = new Primitive("atanh", "number")
    401401    {
    402402        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Method.java

    r8056 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: Method.java,v 1.4 2004-10-24 00:38:26 piso Exp $
     5 * $Id: Method.java,v 1.5 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9494    }
    9595
    96     private static final Primitive1 _METHOD_GENERIC_FUNCTION =
    97         new Primitive1("%method-generic-function", PACKAGE_SYS, false)
     96    private static final Primitive _METHOD_GENERIC_FUNCTION =
     97        new Primitive("%method-generic-function", PACKAGE_SYS, false)
    9898    {
    9999        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    108108    };
    109109
    110     private static final Primitive1 _SET_METHOD_GENERICFUNCTION =
    111         new Primitive1("%set-method-generic-function", PACKAGE_SYS, false)
     110    private static final Primitive _SET_METHOD_GENERICFUNCTION =
     111        new Primitive("%set-method-generic-function", PACKAGE_SYS, false)
    112112    {
    113113        public LispObject execute(LispObject first, LispObject second)
     
    124124    };
    125125
    126     private static final Primitive1 METHOD_FUNCTION =
    127         new Primitive1("method-function", PACKAGE_SYS, false)
     126    private static final Primitive METHOD_FUNCTION =
     127        new Primitive("method-function", PACKAGE_SYS, false)
    128128    {
    129129        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    138138    };
    139139
    140     private static final Primitive1 _SET_METHOD_FUNCTION =
    141         new Primitive1("%set-method-function", PACKAGE_SYS, false)
     140    private static final Primitive _SET_METHOD_FUNCTION =
     141        new Primitive("%set-method-function", PACKAGE_SYS, false)
    142142    {
    143143        public LispObject execute(LispObject first, LispObject second)
     
    154154    };
    155155
    156     private static final Primitive1 _METHOD_SPECIALIZERS =
    157         new Primitive1("%method-specializers", PACKAGE_SYS, false)
     156    private static final Primitive _METHOD_SPECIALIZERS =
     157        new Primitive("%method-specializers", PACKAGE_SYS, false)
    158158    {
    159159        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    168168    };
    169169
    170     private static final Primitive1 _SET_METHOD_SPECIALIZERS =
    171         new Primitive1("%set-method-specializers", PACKAGE_SYS, false)
     170    private static final Primitive _SET_METHOD_SPECIALIZERS =
     171        new Primitive("%set-method-specializers", PACKAGE_SYS, false)
    172172    {
    173173        public LispObject execute(LispObject first, LispObject second)
  • trunk/j/src/org/armedbear/lisp/PackageError.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: PackageError.java,v 1.13 2004-10-13 00:22:19 piso Exp $
     5 * $Id: PackageError.java,v 1.14 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6767
    6868    // ### package-error-package
    69     private static final Primitive1 PACKAGE_ERROR_PACKAGE =
    70         new Primitive1("package-error-package", "condition")
     69    private static final Primitive PACKAGE_ERROR_PACKAGE =
     70        new Primitive("package-error-package", "condition")
    7171    {
    7272        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/PackageFunctions.java

    r7410 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: PackageFunctions.java,v 1.27 2004-08-15 12:39:38 piso Exp $
     5 * $Id: PackageFunctions.java,v 1.28 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2626    // ### packagep
    2727    // packagep object => generalized-boolean
    28     private static final Primitive1 PACKAGEP = new Primitive1("packagep", "object")
     28    private static final Primitive PACKAGEP = new Primitive("packagep", "object")
    2929    {
    3030        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    3636    // ### package-name
    3737    // package-name package => nicknames
    38     private static final Primitive1 PACKAGE_NAME =
    39         new Primitive1("package-name", "package")
     38    private static final Primitive PACKAGE_NAME =
     39        new Primitive("package-name", "package")
    4040    {
    4141        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    4848    // ### package-nicknames
    4949    // package-nicknames package => nicknames
    50     private static final Primitive1 PACKAGE_NICKNAMES =
    51         new Primitive1("package-nicknames", "package")
     50    private static final Primitive PACKAGE_NICKNAMES =
     51        new Primitive("package-nicknames", "package")
    5252    {
    5353        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    5959    // ### package-use-list
    6060    // package-use-list package => use-list
    61     private static final Primitive1 PACKAGE_USE_LIST =
    62         new Primitive1("package-use-list", "package")
     61    private static final Primitive PACKAGE_USE_LIST =
     62        new Primitive("package-use-list", "package")
    6363    {
    6464        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    7070    // ### package-used-by-list
    7171    // package-used-by-list package => used-by-list
    72     private static final Primitive1 PACKAGE_USED_BY_LIST =
    73         new Primitive1("package-used-by-list", "package")
     72    private static final Primitive PACKAGE_USED_BY_LIST =
     73        new Primitive("package-used-by-list", "package")
    7474    {
    7575        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    173173    // ### package-shadowing-symbols
    174174    // package-shadowing-symbols package => used-by-list
    175     private static final Primitive1 PACKAGE_SHADOWING_SYMBOLS =
    176         new Primitive1("package-shadowing-symbols", "package")
     175    private static final Primitive PACKAGE_SHADOWING_SYMBOLS =
     176        new Primitive("package-shadowing-symbols", "package")
    177177    {
    178178        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    183183
    184184    // ### delete-package
    185     private static final Primitive1 DELETE_PACKAGE =
    186         new Primitive1("delete-package", "package")
     185    private static final Primitive DELETE_PACKAGE =
     186        new Primitive("delete-package", "package")
    187187    {
    188188        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    235235    };
    236236
    237     private static final Primitive0 LIST_ALL_PACKAGES =
    238         new Primitive0("list-all-packages", "")
     237    private static final Primitive LIST_ALL_PACKAGES =
     238        new Primitive("list-all-packages", "")
    239239    {
    240240        public LispObject execute()
  • trunk/j/src/org/armedbear/lisp/Pathname.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: Pathname.java,v 1.70 2004-11-03 15:27:22 piso Exp $
     5 * $Id: Pathname.java,v 1.71 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    567567    };
    568568
    569     private static final Primitive1 PATHNAME_VERSION =
    570         new Primitive1("pathname-version", "pathname")
     569    private static final Primitive PATHNAME_VERSION =
     570        new Primitive("pathname-version", "pathname")
    571571    {
    572572        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    578578    // ### namestring
    579579    // namestring pathname => namestring
    580     private static final Primitive1 NAMESTRING =
    581         new Primitive1("namestring", "pathname")
     580    private static final Primitive NAMESTRING =
     581        new Primitive("namestring", "pathname")
    582582    {
    583583        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    594594    // ### directory-namestring
    595595    // directory-namestring pathname => namestring
    596     private static final Primitive1 DIRECTORY_NAMESTRING =
    597         new Primitive1("directory-namestring", "pathname")
     596    private static final Primitive DIRECTORY_NAMESTRING =
     597        new Primitive("directory-namestring", "pathname")
    598598    {
    599599        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    605605    // ### pathname
    606606    // pathname pathspec => pathname
    607     private static final Primitive1 PATHNAME =
    608         new Primitive1("pathname", "pathspec")
     607    private static final Primitive PATHNAME =
     608        new Primitive("pathname", "pathspec")
    609609    {
    610610        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    707707
    708708    // ### pathnamep
    709     private static final Primitive1 PATHNAMEP =
    710         new Primitive1("pathnamep", "object")
     709    private static final Primitive PATHNAMEP =
     710        new Primitive("pathnamep", "object")
    711711    {
    712712        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    755755
    756756    // ### list-directory
    757     private static final Primitive1 LIST_DIRECTORY =
    758         new Primitive1("list-directory", PACKAGE_SYS, false)
     757    private static final Primitive LIST_DIRECTORY =
     758        new Primitive("list-directory", PACKAGE_SYS, false)
    759759    {
    760760        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    986986
    987987    // ### mkdir
    988     private static final Primitive1 MKDIR =
    989         new Primitive1("mkdir", PACKAGE_SYS, false)
     988    private static final Primitive MKDIR =
     989        new Primitive("mkdir", PACKAGE_SYS, false)
    990990    {
    991991        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    10331033
    10341034    // ### file-namestring pathname => namestring
    1035     private static final Primitive1 FILE_NAMESTRING =
    1036         new Primitive1("file-namestring", "pathname")
     1035    private static final Primitive FILE_NAMESTRING =
     1036        new Primitive("file-namestring", "pathname")
    10371037    {
    10381038        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    10571057
    10581058    // ### host-namestring pathname => namestring
    1059     private static final Primitive1 HOST_NAMESTRING =
    1060         new Primitive1("host-namestring", "pathname")
     1059    private static final Primitive HOST_NAMESTRING =
     1060        new Primitive("host-namestring", "pathname")
    10611061    {
    10621062        public LispObject execute(LispObject arg)
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Primitives.java,v 1.700 2004-11-03 15:27:22 piso Exp $
     5 * $Id: Primitives.java,v 1.701 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    148148
    149149    // ### identity
    150     private static final Primitive1 IDENTITY = new Primitive1("identity", "object")
     150    private static final Primitive IDENTITY = new Primitive("identity", "object")
    151151    {
    152152        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    157157
    158158    // ### compiled-function-p
    159     private static final Primitive1 COMPILED_FUNCTION_P =
    160         new Primitive1("compiled-function-p", "object")
     159    private static final Primitive COMPILED_FUNCTION_P =
     160        new Primitive("compiled-function-p", "object")
    161161    {
    162162        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    167167
    168168    // ### consp
    169     private static final Primitive1 CONSP = new Primitive1("consp", "object")
     169    private static final Primitive CONSP = new Primitive("consp", "object")
    170170    {
    171171        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    176176
    177177    // ### listp
    178     private static final Primitive1 LISTP = new Primitive1("listp", "object")
     178    private static final Primitive LISTP = new Primitive("listp", "object")
    179179    {
    180180        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    185185
    186186    // ### abs
    187     private static final Primitive1 ABS = new Primitive1("abs", "number")
     187    private static final Primitive ABS = new Primitive("abs", "number")
    188188    {
    189189        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    194194
    195195    // ### arrayp
    196     private static final Primitive1 ARRAYP = new Primitive1("arrayp", "object")
     196    private static final Primitive ARRAYP = new Primitive("arrayp", "object")
    197197    {
    198198        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    203203
    204204    // ### array-has-fill-pointer-p
    205     private static final Primitive1 ARRAY_HAS_FILL_POINTER_P =
    206         new Primitive1("array-has-fill-pointer-p", "array")
     205    private static final Primitive ARRAY_HAS_FILL_POINTER_P =
     206        new Primitive("array-has-fill-pointer-p", "array")
    207207    {
    208208        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    218218
    219219    // ### vectorp
    220     private static final Primitive1 VECTORP = new Primitive1("vectorp", "object")
     220    private static final Primitive VECTORP = new Primitive("vectorp", "object")
    221221    {
    222222        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    227227
    228228    // ### simple-vector-p
    229     private static final Primitive1 SIMPLE_VECTOR_P =
    230         new Primitive1("simple-vector-p", "object")
     229    private static final Primitive SIMPLE_VECTOR_P =
     230        new Primitive("simple-vector-p", "object")
    231231    {
    232232        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    237237
    238238    // ### bit-vector-p
    239     private static final Primitive1 BIT_VECTOR_P =
    240         new Primitive1("bit-vector-p", "object")
     239    private static final Primitive BIT_VECTOR_P =
     240        new Primitive("bit-vector-p", "object")
    241241    {
    242242        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    247247
    248248    // ### simple-bit-vector-p
    249     private static final Primitive1 SIMPLE_BIT_VECTOR_P =
    250         new Primitive1("simple-bit-vector-p", "object")
     249    private static final Primitive SIMPLE_BIT_VECTOR_P =
     250        new Primitive("simple-bit-vector-p", "object")
    251251    {
    252252        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    257257
    258258    // ### %eval
    259     private static final Primitive1 _EVAL =
    260         new Primitive1("%eval", PACKAGE_SYS, false, "form")
     259    private static final Primitive _EVAL =
     260        new Primitive("%eval", PACKAGE_SYS, false, "form")
    261261    {
    262262        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    340340    // values-list list => element*
    341341    // Returns the elements of the list as multiple values.
    342     private static final Primitive1 VALUES_LIST =
    343         new Primitive1("values-list", "list")
     342    private static final Primitive VALUES_LIST =
     343        new Primitive("values-list", "list")
    344344    {
    345345        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    361361
    362362    // ### length
    363     private static final Primitive1 LENGTH =
    364         new Primitive1("length", "sequence")
     363    private static final Primitive LENGTH =
     364        new Primitive("length", "sequence")
    365365    {
    366366        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    387387
    388388    // ### atom
    389     private static final Primitive1 ATOM = new Primitive1("atom", "object")
     389    private static final Primitive ATOM = new Primitive("atom", "object")
    390390    {
    391391        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    411411
    412412    // ### functionp
    413     private static final Primitive1 FUNCTIONP = new Primitive1("functionp","object")
     413    private static final Primitive FUNCTIONP = new Primitive("functionp","object")
    414414    {
    415415        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    420420
    421421    // ### special-operator-p
    422     private static final Primitive1 SPECIAL_OPERATOR_P =
    423         new Primitive1("special-operator-p","symbol")
     422    private static final Primitive SPECIAL_OPERATOR_P =
     423        new Primitive("special-operator-p","symbol")
    424424    {
    425425        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    430430
    431431    // ### symbolp
    432     private static final Primitive1 SYMBOLP = new Primitive1("symbolp", "object")
     432    private static final Primitive SYMBOLP = new Primitive("symbolp", "object")
    433433    {
    434434        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    439439
    440440    // ### endp
    441     private static final Primitive1 ENDP = new Primitive1("endp", "list")
     441    private static final Primitive ENDP = new Primitive("endp", "list")
    442442    {
    443443        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    448448
    449449    // ### null
    450     private static final Primitive1 NULL = new Primitive1("null", "object")
     450    private static final Primitive NULL = new Primitive("null", "object")
    451451    {
    452452        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    457457
    458458    // ### not
    459     private static final Primitive1 NOT = new Primitive1("not", "x")
     459    private static final Primitive NOT = new Primitive("not", "x")
    460460    {
    461461        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    466466
    467467    // ### plusp
    468     private static final Primitive1 PLUSP = new Primitive1("plusp", "real")
     468    private static final Primitive PLUSP = new Primitive("plusp", "real")
    469469    {
    470470        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    475475
    476476    // ### minusp
    477     private static final Primitive1 MINUSP = new Primitive1("minusp", "real")
     477    private static final Primitive MINUSP = new Primitive("minusp", "real")
    478478    {
    479479        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    484484
    485485    // ### zerop
    486     private static final Primitive1 ZEROP = new Primitive1("zerop","number") {
     486    private static final Primitive ZEROP = new Primitive("zerop","number") {
    487487        public LispObject execute(LispObject arg) throws ConditionThrowable
    488488        {
     
    492492
    493493    // ### fixnump
    494     private static final Primitive1 FIXNUMP =
    495         new Primitive1("fixnump", PACKAGE_EXT, true) {
     494    private static final Primitive FIXNUMP =
     495        new Primitive("fixnump", PACKAGE_EXT, true) {
    496496        public LispObject execute(LispObject arg) throws ConditionThrowable
    497497        {
     
    501501
    502502    // ### symbol-value
    503     private static final Primitive1 SYMBOL_VALUE =
    504         new Primitive1("symbol-value", "symbol")
     503    private static final Primitive SYMBOL_VALUE =
     504        new Primitive("symbol-value", "symbol")
    505505    {
    506506        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    584584
    585585    // ### 1+
    586     private static final Primitive1 ONE_PLUS = new Primitive1("1+", "number")
     586    private static final Primitive ONE_PLUS = new Primitive("1+", "number")
    587587    {
    588588        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    622622
    623623    // ### 1-
    624     private static final Primitive1 ONE_MINUS = new Primitive1("1-","number")
     624    private static final Primitive ONE_MINUS = new Primitive("1-","number")
    625625    {
    626626        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    687687
    688688    // ### %write-to-string object => string
    689     private static final Primitive1 _WRITE_TO_STRING =
    690         new Primitive1("%write-to-string", PACKAGE_SYS, false)
     689    private static final Primitive _WRITE_TO_STRING =
     690        new Primitive("%write-to-string", PACKAGE_SYS, false)
    691691    {
    692692        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    698698    // ### %terpri
    699699    // %terpri output-stream => nil
    700     private static final Primitive1 _TERPRI =
    701         new Primitive1("%terpri", PACKAGE_SYS, false, "output-stream")
     700    private static final Primitive _TERPRI =
     701        new Primitive("%terpri", PACKAGE_SYS, false, "output-stream")
    702702    {
    703703        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    709709    // ### %fresh-line
    710710    // %fresh-line &optional output-stream => generalized-boolean
    711     private static final Primitive1 _FRESH_LINE =
    712         new Primitive1("%fresh-line", PACKAGE_SYS, false, "output-stream")
     711    private static final Primitive _FRESH_LINE =
     712        new Primitive("%fresh-line", PACKAGE_SYS, false, "output-stream")
    713713    {
    714714        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    721721    // Determines only whether a symbol has a value in the global environment;
    722722    // any lexical bindings are ignored.
    723     private static final Primitive1 BOUNDP = new Primitive1("boundp", "symbol")
     723    private static final Primitive BOUNDP = new Primitive("boundp", "symbol")
    724724    {
    725725        public LispObject execute(LispObject obj) throws ConditionThrowable
     
    742742
    743743    // ### fboundp
    744     private static final Primitive1 FBOUNDP = new Primitive1("fboundp","name")
     744    private static final Primitive FBOUNDP = new Primitive("fboundp","name")
    745745    {
    746746        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    759759
    760760    // ### fmakunbound
    761     private static final Primitive1 FMAKUNBOUND = new Primitive1("fmakunbound","name")
     761    private static final Primitive FMAKUNBOUND = new Primitive("fmakunbound","name")
    762762    {
    763763        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    14281428
    14291429    // ### %defvar
    1430     private static final Primitive1 _DEFVAR =
    1431         new Primitive1("%defvar", PACKAGE_SYS, false)
     1430    private static final Primitive _DEFVAR =
     1431        new Primitive("%defvar", PACKAGE_SYS, false)
    14321432    {
    14331433        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    15861586    // ### array-rank
    15871587    // array-rank array => rank
    1588     private static final Primitive1 ARRAY_RANK =
    1589         new Primitive1("array-rank", "array") {
     1588    private static final Primitive ARRAY_RANK =
     1589        new Primitive("array-rank", "array") {
    15901590        public LispObject execute(LispObject arg) throws ConditionThrowable
    15911591        {
     
    15971597    // array-dimensions array => dimensions
    15981598    // Returns a list of integers. Fill pointer (if any) is ignored.
    1599     private static final Primitive1 ARRAY_DIMENSIONS =
    1600         new Primitive1("array-dimensions", "array") {
     1599    private static final Primitive ARRAY_DIMENSIONS =
     1600        new Primitive("array-dimensions", "array") {
    16011601        public LispObject execute(LispObject arg) throws ConditionThrowable
    16021602        {
     
    16181618    // ### array-total-size
    16191619    // array-total-size array => size
    1620     private static final Primitive1 ARRAY_TOTAL_SIZE =
    1621         new Primitive1("array-total-size","array") {
     1620    private static final Primitive ARRAY_TOTAL_SIZE =
     1621        new Primitive("array-total-size","array") {
    16221622        public LispObject execute(LispObject arg) throws ConditionThrowable
    16231623        {
     
    16291629    // ### array-element-type
    16301630    // array-element-type array => typespec
    1631     private static final Primitive1 ARRAY_ELEMENT_TYPE =
    1632         new Primitive1("array-element-type", "array")
     1631    private static final Primitive ARRAY_ELEMENT_TYPE =
     1632        new Primitive("array-element-type", "array")
    16331633    {
    16341634        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    16391639
    16401640    // ### adjustable-array-p
    1641     private static final Primitive1 ADJUSTABLE_ARRAY_P =
    1642         new Primitive1("adjustable-array-p", "array")
     1641    private static final Primitive ADJUSTABLE_ARRAY_P =
     1642        new Primitive("adjustable-array-p", "array")
    16431643    {
    16441644        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    16551655    // ### array-displacement
    16561656    // array-displacement array => displaced-to, displaced-index-offset
    1657     private static final Primitive1 ARRAY_DISPLACEMENT =
    1658         new Primitive1("array-displacement", "array")
     1657    private static final Primitive ARRAY_DISPLACEMENT =
     1658        new Primitive("array-displacement", "array")
    16591659    {
    16601660        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    19411941
    19421942    // ### fill-pointer
    1943     private static final Primitive1 FILL_POINTER =
    1944         new Primitive1("fill-pointer", "vector")
     1943    private static final Primitive FILL_POINTER =
     1944        new Primitive("fill-pointer", "vector")
    19451945    {
    19461946        public LispObject execute(LispObject arg)
     
    20262026
    20272027    // ### vector-pop vector => element
    2028     private static final Primitive1 VECTOR_POP =
    2029         new Primitive1("vector-pop", "vector")
     2028    private static final Primitive VECTOR_POP =
     2029        new Primitive("vector-pop", "vector")
    20302030    {
    20312031        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    20452045
    20462046    // ### type-of
    2047     private static final Primitive1 TYPE_OF = new Primitive1("type-of", "object")
     2047    private static final Primitive TYPE_OF = new Primitive("type-of", "object")
    20482048    {
    20492049        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    20542054
    20552055    // ### class-of
    2056     private static final Primitive1 CLASS_OF = new Primitive1("class-of", "object")
     2056    private static final Primitive CLASS_OF = new Primitive("class-of", "object")
    20572057    {
    20582058        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    20752075    // ### function-lambda-expression
    20762076    // function-lambda-expression function => lambda-expression, closure-p, name
    2077     private static final Primitive1 FUNCTION_LAMBDA_EXPRESSION =
    2078         new Primitive1("function-lambda-expression", "function")
     2077    private static final Primitive FUNCTION_LAMBDA_EXPRESSION =
     2078        new Primitive("function-lambda-expression", "function")
    20792079    {
    20802080        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    23742374
    23752375    // ### string
    2376     private static final Primitive1 STRING = new Primitive1("string", "x")
     2376    private static final Primitive STRING = new Primitive("string", "x")
    23772377    {
    23782378        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    24252425
    24262426    // ### find-package
    2427     private static final Primitive1 FIND_PACKAGE =
    2428         new Primitive1("find-package", "name") {
     2427    private static final Primitive FIND_PACKAGE =
     2428        new Primitive("find-package", "name") {
    24292429        public LispObject execute(LispObject arg) throws ConditionThrowable
    24302430        {
     
    25252525
    25262526    // ### %in-package
    2527     private static final Primitive1 _IN_PACKAGE =
    2528         new Primitive1("%in-package", PACKAGE_SYS, false)
     2527    private static final Primitive _IN_PACKAGE =
     2528        new Primitive("%in-package", PACKAGE_SYS, false)
    25292529    {
    25302530        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    25772577
    25782578    // ### package-symbols
    2579     private static final Primitive1 PACKAGE_SYMBOLS =
    2580         new Primitive1("package-symbols", PACKAGE_SYS, true)
     2579    private static final Primitive PACKAGE_SYMBOLS =
     2580        new Primitive("package-symbols", PACKAGE_SYS, true)
    25812581    {
    25822582        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    25872587
    25882588    // ### package-internal-symbols
    2589     private static final Primitive1 PACKAGE_INTERNAL_SYMBOLS =
    2590         new Primitive1("package-internal-symbols", PACKAGE_SYS, true)
     2589    private static final Primitive PACKAGE_INTERNAL_SYMBOLS =
     2590        new Primitive("package-internal-symbols", PACKAGE_SYS, true)
    25912591    {
    25922592        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    25972597
    25982598    // ### package-external-symbols
    2599     private static final Primitive1 PACKAGE_EXTERNAL_SYMBOLS =
    2600         new Primitive1("package-external-symbols", PACKAGE_SYS, true)
     2599    private static final Primitive PACKAGE_EXTERNAL_SYMBOLS =
     2600        new Primitive("package-external-symbols", PACKAGE_SYS, true)
    26012601    {
    26022602        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    26072607
    26082608    // ### package-inherited-symbols
    2609     private static final Primitive1 PACKAGE_INHERITED_SYMBOLS =
    2610         new Primitive1("package-inherited-symbols", PACKAGE_SYS, true)
     2609    private static final Primitive PACKAGE_INHERITED_SYMBOLS =
     2610        new Primitive("package-inherited-symbols", PACKAGE_SYS, true)
    26112611    {
    26122612        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    33103310
    33113311    // ### %finish-output output-stream => nil
    3312     private static final Primitive1 _FINISH_OUTPUT =
    3313         new Primitive1("%finish-output", PACKAGE_SYS, false, "output-stream")
     3312    private static final Primitive _FINISH_OUTPUT =
     3313        new Primitive("%finish-output", PACKAGE_SYS, false, "output-stream")
    33143314    {
    33153315        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    33203320
    33213321    // ### %force-output output-stream => nil
    3322     private static final Primitive1 _FORCE_OUTPUT =
    3323         new Primitive1("%force-output", PACKAGE_SYS, false, "output-stream")
     3322    private static final Primitive _FORCE_OUTPUT =
     3323        new Primitive("%force-output", PACKAGE_SYS, false, "output-stream")
    33243324    {
    33253325        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    33713371    // "If any of these operations does not make sense for output-stream, then
    33723372    // it does nothing."
    3373     private static final Primitive1 _CLEAR_OUTPUT =
    3374         new Primitive1("%clear-output", PACKAGE_SYS, false, "output-stream")
     3373    private static final Primitive _CLEAR_OUTPUT =
     3374        new Primitive("%clear-output", PACKAGE_SYS, false, "output-stream")
    33753375    {
    33763376        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    35823582
    35833583    // ### call-count
    3584     private static final Primitive1 CALL_COUNT =
    3585         new Primitive1("call-count", PACKAGE_SYS, true)
     3584    private static final Primitive CALL_COUNT =
     3585        new Primitive("call-count", PACKAGE_SYS, true)
    35863586    {
    35873587        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    38473847
    38483848    // ### nreverse
    3849     public static final Primitive1 NREVERSE = new Primitive1("nreverse", "sequence")
     3849    public static final Primitive NREVERSE = new Primitive("nreverse", "sequence")
    38503850    {
    38513851        public LispObject execute (LispObject arg) throws ConditionThrowable
     
    38923892
    38933893    // ### reverse
    3894     private static final Primitive1 REVERSE = new Primitive1("reverse", "sequence")
     3894    private static final Primitive REVERSE = new Primitive("reverse", "sequence")
    38953895    {
    38963896        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    40674067
    40684068    // ### coerce-to-function
    4069     private static final Primitive1 COERCE_TO_FUNCTION =
    4070         new Primitive1("coerce-to-function", PACKAGE_SYS, false)
     4069    private static final Primitive COERCE_TO_FUNCTION =
     4070        new Primitive("coerce-to-function", PACKAGE_SYS, false)
    40714071    {
    40724072        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    40964096
    40974097    // ### streamp
    4098     private static final Primitive1 STREAMP = new Primitive1("streamp", "object")
     4098    private static final Primitive STREAMP = new Primitive("streamp", "object")
    40994099    {
    41004100        public LispObject execute(LispObject arg)
     
    41054105
    41064106    // ### integerp
    4107     private static final Primitive1 INTEGERP = new Primitive1("integerp", "object")
     4107    private static final Primitive INTEGERP = new Primitive("integerp", "object")
    41084108    {
    41094109        public LispObject execute(LispObject arg)
     
    41144114
    41154115    // ### evenp
    4116     private static final Primitive1 EVENP = new Primitive1("evenp", "integer")
     4116    private static final Primitive EVENP = new Primitive("evenp", "integer")
    41174117    {
    41184118        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    41234123
    41244124    // ### oddp
    4125     private static final Primitive1 ODDP = new Primitive1("oddp", "integer")
     4125    private static final Primitive ODDP = new Primitive("oddp", "integer")
    41264126    {
    41274127        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    41324132
    41334133    // ### numberp
    4134     private static final Primitive1 NUMBERP = new Primitive1("numberp", "object")
     4134    private static final Primitive NUMBERP = new Primitive("numberp", "object")
    41354135    {
    41364136        public LispObject execute(LispObject arg)
     
    41414141
    41424142    // ### realp
    4143     private static final Primitive1 REALP = new Primitive1("realp", "object")
     4143    private static final Primitive REALP = new Primitive("realp", "object")
    41444144    {
    41454145        public LispObject execute(LispObject arg)
     
    41504150
    41514151    // ### rationalp
    4152     private static final Primitive1 RATIONALP = new Primitive1("rationalp","object") {
     4152    private static final Primitive RATIONALP = new Primitive("rationalp","object") {
    41534153        public LispObject execute(LispObject arg)
    41544154        {
     
    41764176
    41774177    // ### complexp
    4178     private static final Primitive1 COMPLEXP = new Primitive1("complexp","object") {
     4178    private static final Primitive COMPLEXP = new Primitive("complexp","object") {
    41794179        public LispObject execute(LispObject arg)
    41804180        {
     
    41844184
    41854185    // ### numerator
    4186     private static final Primitive1 NUMERATOR = new Primitive1("numerator","rational") {
     4186    private static final Primitive NUMERATOR = new Primitive("numerator","rational") {
    41874187        public LispObject execute(LispObject arg) throws ConditionThrowable
    41884188        {
     
    41924192
    41934193    // ### denominator
    4194     private static final Primitive1 DENOMINATOR = new Primitive1("denominator","rational")
     4194    private static final Primitive DENOMINATOR = new Primitive("denominator","rational")
    41954195    {
    41964196        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    42014201
    42024202    // ### realpart
    4203     private static final Primitive1 REALPART = new Primitive1("realpart","number")
     4203    private static final Primitive REALPART = new Primitive("realpart","number")
    42044204    {
    42054205        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    42154215
    42164216    // ### imagpart
    4217     private static final Primitive1 IMAGPART = new Primitive1("imagpart", "number")
     4217    private static final Primitive IMAGPART = new Primitive("imagpart", "number")
    42184218    {
    42194219        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    42264226
    42274227    // ### integer-length
    4228     private static final Primitive1 INTEGER_LENGTH =
    4229         new Primitive1("integer-length", "integer")
     4228    private static final Primitive INTEGER_LENGTH =
     4229        new Primitive("integer-length", "integer")
    42304230    {
    42314231        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    42774277
    42784278    // ### identity-hash-code
    4279     private static final Primitive1 IDENTITY_HASH_CODE =
    4280         new Primitive1("identity-hash-code", PACKAGE_SYS, false)
     4279    private static final Primitive IDENTITY_HASH_CODE =
     4280        new Primitive("identity-hash-code", PACKAGE_SYS, false)
    42814281    {
    42824282        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    43474347
    43484348    // ### uptime
    4349     private static final Primitive0 UPTIME =
    4350         new Primitive0("uptime", PACKAGE_EXT, true)
     4349    private static final Primitive UPTIME =
     4350        new Primitive("uptime", PACKAGE_EXT, true)
    43514351    {
    43524352        public LispObject execute() throws ConditionThrowable
     
    43574357
    43584358    // ### built-in-function-p
    4359     private static final Primitive1 BUILT_IN_FUNCTION_P =
    4360         new Primitive1("built-in-function-p", PACKAGE_SYS, false)
     4359    private static final Primitive BUILT_IN_FUNCTION_P =
     4360        new Primitive("built-in-function-p", PACKAGE_SYS, false)
    43614361    {
    43624362        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    43724372
    43734373    // ### inspected-parts
    4374     private static final Primitive1 INSPECTED_PARTS =
    4375         new Primitive1("inspected-parts", PACKAGE_SYS, false)
     4374    private static final Primitive INSPECTED_PARTS =
     4375        new Primitive("inspected-parts", PACKAGE_SYS, false)
    43764376    {
    43774377        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    43824382
    43834383    // ### inspected-description
    4384     private static final Primitive1 INSPECTED_DESCRIPTION =
    4385         new Primitive1("inspected-description", PACKAGE_SYS, false)
     4384    private static final Primitive INSPECTED_DESCRIPTION =
     4385        new Primitive("inspected-description", PACKAGE_SYS, false)
    43864386    {
    43874387        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/PrintNotReadable.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: PrintNotReadable.java,v 1.4 2004-10-13 00:22:19 piso Exp $
     5 * $Id: PrintNotReadable.java,v 1.5 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    8787
    8888    // ### print-not-readable-object
    89     private static final Primitive1 PRINT_NOT_READABLE_OBJECT =
    90         new Primitive1("print-not-readable-object", "condition")
     89    private static final Primitive PRINT_NOT_READABLE_OBJECT =
     90        new Primitive("print-not-readable-object", "condition")
    9191    {
    9292        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Profiler.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: Profiler.java,v 1.8 2004-11-03 15:27:23 piso Exp $
     5 * $Id: Profiler.java,v 1.9 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    108108
    109109    // ### stop-profiler
    110     public static final Primitive0 STOP_PROFILER =
    111         new Primitive0("stop-profiler", PACKAGE_PROF, true)
     110    public static final Primitive STOP_PROFILER =
     111        new Primitive("stop-profiler", PACKAGE_PROF, true)
    112112    {
    113113        public LispObject execute() throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/RandomState.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: RandomState.java,v 1.3 2004-10-13 00:22:19 piso Exp $
     5 * $Id: RandomState.java,v 1.4 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    152152
    153153    // ### random-state-p
    154     private static final Primitive1 RANDOM_STATE_P =
    155         new Primitive1("random-state-p", "object")
     154    private static final Primitive RANDOM_STATE_P =
     155        new Primitive("random-state-p", "object")
    156156    {
    157157        public LispObject execute(LispObject arg)
  • trunk/j/src/org/armedbear/lisp/Readtable.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: Readtable.java,v 1.35 2004-11-03 15:27:23 piso Exp $
     5 * $Id: Readtable.java,v 1.36 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    262262
    263263    // ### readtablep
    264     private static final Primitive1 READTABLEP =
    265         new Primitive1("readtablep", "object")
     264    private static final Primitive READTABLEP =
     265        new Primitive("readtablep", "object")
    266266    {
    267267        public LispObject execute(LispObject arg)
     
    486486
    487487    // ### readtable-case readtable => mode
    488     private static final Primitive1 READTABLE_CASE =
    489         new Primitive1("readtable-case", "readtable")
     488    private static final Primitive READTABLE_CASE =
     489        new Primitive("readtable-case", "readtable")
    490490    {
    491491        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/SimpleCondition.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: SimpleCondition.java,v 1.9 2004-10-13 00:22:19 piso Exp $
     5 * $Id: SimpleCondition.java,v 1.10 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6666
    6767    // ### simple-condition-format-control
    68     private static final Primitive1 SIMPLE_CONDITION_FORMAT_CONTROL =
    69         new Primitive1("simple-condition-format-control", "condition")
     68    private static final Primitive SIMPLE_CONDITION_FORMAT_CONTROL =
     69        new Primitive("simple-condition-format-control", "condition")
    7070    {
    7171        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    7878
    7979    // ### simple-condition-format-arguments
    80     private static final Primitive1 SIMPLE_CONDITION_FORMAT_ARGUMENTS =
    81         new Primitive1("simple-condition-format-arguments", "condition")
     80    private static final Primitive SIMPLE_CONDITION_FORMAT_ARGUMENTS =
     81        new Primitive("simple-condition-format-arguments", "condition")
    8282    {
    8383        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/SiteName.java

    r6023 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: SiteName.java,v 1.1 2004-02-27 17:50:06 piso Exp $
     5 * $Id: SiteName.java,v 1.2 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3838    }
    3939
    40     private static final Primitive0 MACHINE_INSTANCE =
    41         new Primitive0("machine-instance")
     40    private static final Primitive MACHINE_INSTANCE =
     41        new Primitive("machine-instance")
    4242    {
    4343        public LispObject execute()
     
    4747    };
    4848
    49     private static final Primitive0 LONG_SITE_NAME =
    50         new Primitive0("long-site-name")
     49    private static final Primitive LONG_SITE_NAME =
     50        new Primitive("long-site-name")
    5151    {
    5252        public LispObject execute()
     
    5656    };
    5757
    58     private static final Primitive0 SHORT_SITE_NAME =
    59         new Primitive0("short-site-name")
     58    private static final Primitive SHORT_SITE_NAME =
     59        new Primitive("short-site-name")
    6060    {
    6161        public LispObject execute()
  • trunk/j/src/org/armedbear/lisp/SlimeOutputStream.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: SlimeOutputStream.java,v 1.4 2004-10-13 00:22:19 piso Exp $
     5 * $Id: SlimeOutputStream.java,v 1.5 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    121121    // ### %make-string-output-stream
    122122    // %make-string-output-stream element-type => string-stream
    123     private static final Primitive1 MAKE_SLIME_OUTPUT_STREAM =
    124         new Primitive1("make-slime-output-stream", PACKAGE_EXT, true, "function")
     123    private static final Primitive MAKE_SLIME_OUTPUT_STREAM =
     124        new Primitive("make-slime-output-stream", PACKAGE_EXT, true, "function")
    125125    {
    126126        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/SlotClass.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: SlotClass.java,v 1.7 2004-11-03 15:27:23 piso Exp $
     5 * $Id: SlotClass.java,v 1.8 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6969
    7070    // ### class-direct-slots
    71     private static final Primitive1 CLASS_DIRECT_SLOTS =
    72         new Primitive1("class-direct-slots", PACKAGE_SYS, false)
     71    private static final Primitive CLASS_DIRECT_SLOTS =
     72        new Primitive("class-direct-slots", PACKAGE_SYS, false)
    7373    {
    7474        public LispObject execute(LispObject arg)
     
    9999
    100100    // ### class-slots
    101     private static final Primitive1 CLASS_SLOTS =
    102         new Primitive1("class-slots", PACKAGE_SYS, false)
     101    private static final Primitive CLASS_SLOTS =
     102        new Primitive("class-slots", PACKAGE_SYS, false)
    103103    {
    104104        public LispObject execute(LispObject arg)
     
    129129
    130130    // ### class-direct-default-initargs
    131     private static final Primitive1 CLASS_DIRECT_DEFAULT_INITARGS =
    132         new Primitive1("class-direct-default-initargs", PACKAGE_SYS, false)
     131    private static final Primitive CLASS_DIRECT_DEFAULT_INITARGS =
     132        new Primitive("class-direct-default-initargs", PACKAGE_SYS, false)
    133133    {
    134134        public LispObject execute(LispObject arg)
     
    159159
    160160    // ### class-default-initargs
    161     private static final Primitive1 CLASS_DEFAULT_INITARGS =
    162         new Primitive1("class-default-initargs", PACKAGE_SYS, false)
     161    private static final Primitive CLASS_DEFAULT_INITARGS =
     162        new Primitive("class-default-initargs", PACKAGE_SYS, false)
    163163    {
    164164        public LispObject execute(LispObject arg)
  • trunk/j/src/org/armedbear/lisp/StandardObject.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: StandardObject.java,v 1.27 2004-11-03 15:27:23 piso Exp $
     5 * $Id: StandardObject.java,v 1.28 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    115115
    116116    // ### std-instance-layout
    117     private static final Primitive1 STD_INSTANCE_LAYOUT =
    118         new Primitive1("std-instance-layout", PACKAGE_SYS, false)
     117    private static final Primitive STD_INSTANCE_LAYOUT =
     118        new Primitive("std-instance-layout", PACKAGE_SYS, false)
    119119    {
    120120        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    152152
    153153    // ### std-instance-class
    154     private static final Primitive1 STD_INSTANCE_CLASS =
    155         new Primitive1("std-instance-class", PACKAGE_SYS, false)
     154    private static final Primitive STD_INSTANCE_CLASS =
     155        new Primitive("std-instance-class", PACKAGE_SYS, false)
    156156    {
    157157        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    164164
    165165    // ### std-instance-slots
    166     private static final Primitive1 STD_INSTANCE_SLOTS =
    167         new Primitive1("std-instance-slots", PACKAGE_SYS, false)
     166    private static final Primitive STD_INSTANCE_SLOTS =
     167        new Primitive("std-instance-slots", PACKAGE_SYS, false)
    168168    {
    169169        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Stream.java

    r8065 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: Stream.java,v 1.92 2004-10-24 19:24:34 piso Exp $
     5 * $Id: Stream.java,v 1.93 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    13811381
    13821382    // ### stream-line-number
    1383     private static final Primitive1 STREAM_LINE_NUMBER =
    1384         new Primitive1("stream-line-number", PACKAGE_SYS, false, "stream")
     1383    private static final Primitive STREAM_LINE_NUMBER =
     1384        new Primitive("stream-line-number", PACKAGE_SYS, false, "stream")
    13851385    {
    13861386        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    13921392
    13931393    // ### stream-offset
    1394     private static final Primitive1 STREAM_OFFSET =
    1395         new Primitive1("stream-offset", PACKAGE_SYS, false, "stream")
     1394    private static final Primitive STREAM_OFFSET =
     1395        new Primitive("stream-offset", PACKAGE_SYS, false, "stream")
    13961396    {
    13971397        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/StreamError.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: StreamError.java,v 1.13 2004-10-13 00:22:20 piso Exp $
     5 * $Id: StreamError.java,v 1.14 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    100100
    101101    // ### stream-error-stream
    102     private static final Primitive1 STREAM_ERROR_STREAM =
    103         new Primitive1("stream-error-stream", "condition")
     102    private static final Primitive STREAM_ERROR_STREAM =
     103        new Primitive("stream-error-stream", "condition")
    104104    {
    105105        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/StringFunctions.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: StringFunctions.java,v 1.30 2004-11-03 15:27:23 piso Exp $
     5 * $Id: StringFunctions.java,v 1.31 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    779779
    780780    // ### stringp
    781     public static final Primitive1 STRINGP = new Primitive1("stringp", "object")
     781    public static final Primitive STRINGP = new Primitive("stringp", "object")
    782782    {
    783783        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    788788
    789789    // ### simple-string-p
    790     public static final Primitive1 SIMPLE_STRING_P =
    791         new Primitive1("simple-string-p", "object")
     790    public static final Primitive SIMPLE_STRING_P =
     791        new Primitive("simple-string-p", "object")
    792792    {
    793793        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/StringInputStream.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: StringInputStream.java,v 1.16 2004-10-13 00:22:20 piso Exp $
     5 * $Id: StringInputStream.java,v 1.17 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    147147
    148148    // ### string-input-stream-current
    149     private static final Primitive1 STRING_INPUT_STREAM_CURRENT =
    150         new Primitive1("string-input-stream-current", PACKAGE_EXT, true, "stream")
     149    private static final Primitive STRING_INPUT_STREAM_CURRENT =
     150        new Primitive("string-input-stream-current", PACKAGE_EXT, true, "stream")
    151151    {
    152152        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/StringOutputStream.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: StringOutputStream.java,v 1.15 2004-10-13 00:22:20 piso Exp $
     5 * $Id: StringOutputStream.java,v 1.16 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    124124    // ### %make-string-output-stream
    125125    // %make-string-output-stream element-type => string-stream
    126     private static final Primitive1 MAKE_STRING_OUTPUT_STREAM =
    127         new Primitive1("%make-string-output-stream", PACKAGE_SYS, false,
     126    private static final Primitive MAKE_STRING_OUTPUT_STREAM =
     127        new Primitive("%make-string-output-stream", PACKAGE_SYS, false,
    128128                       "element-type")
    129129    {
     
    136136    // ### get-output-stream-string
    137137    // get-output-stream-string string-output-stream => string
    138     private static final Primitive1 GET_OUTPUT_STREAM_STRING =
    139         new Primitive1("get-output-stream-string", "string-output-stream")
     138    private static final Primitive GET_OUTPUT_STREAM_STRING =
     139        new Primitive("get-output-stream-string", "string-output-stream")
    140140    {
    141141        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/StructureObject.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: StructureObject.java,v 1.37 2004-11-03 15:27:23 piso Exp $
     5 * $Id: StructureObject.java,v 1.38 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    271271    // ### copy-structure
    272272    // copy-structure structure => copy
    273     private static final Primitive1 COPY_STRUCTURE =
    274         new Primitive1("copy-structure", "structure")
     273    private static final Primitive COPY_STRUCTURE =
     274        new Primitive("copy-structure", "structure")
    275275    {
    276276        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Symbol.java

    r8063 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: Symbol.java,v 1.155 2004-10-24 18:03:08 piso Exp $
     5 * $Id: Symbol.java,v 1.156 2004-11-03 15:39:01 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    780780
    781781    // ### symbol-name
    782     public static final Primitive1 SYMBOL_NAME = new Primitive1("symbol-name","symbol")
     782    public static final Primitive SYMBOL_NAME = new Primitive("symbol-name","symbol")
    783783    {
    784784        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    794794
    795795    // ### symbol-package
    796     public static final Primitive1 SYMBOL_PACKAGE = new Primitive1("symbol-package","symbol")
     796    public static final Primitive SYMBOL_PACKAGE = new Primitive("symbol-package","symbol")
    797797    {
    798798        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    808808
    809809    // ### symbol-function
    810     public static final Primitive1 SYMBOL_FUNCTION =
    811         new Primitive1("symbol-function", "symbol")
     810    public static final Primitive SYMBOL_FUNCTION =
     811        new Primitive("symbol-function", "symbol")
    812812    {
    813813        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    826826
    827827    // ### symbol-plist
    828     public static final Primitive1 SYMBOL_PLIST = new Primitive1("symbol-plist", "symbol")
     828    public static final Primitive SYMBOL_PLIST = new Primitive("symbol-plist", "symbol")
    829829    {
    830830        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    841841
    842842    // ### keywordp
    843     public static final Primitive1 KEYWORDP = new Primitive1("keywordp", "object")
     843    public static final Primitive KEYWORDP = new Primitive("keywordp", "object")
    844844    {
    845845        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    854854
    855855    // ### make-symbol
    856     public static final Primitive1 MAKE_SYMBOL = new Primitive1("make-symbol", "name")
     856    public static final Primitive MAKE_SYMBOL = new Primitive("make-symbol", "name")
    857857    {
    858858        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    863863
    864864    // makunbound
    865     public static final Primitive1 MAKUNBOUND = new Primitive1("makunbound", "symbol")
     865    public static final Primitive MAKUNBOUND = new Primitive("makunbound", "symbol")
    866866    {
    867867        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/SymbolMacro.java

    r4538 r8087  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: SymbolMacro.java,v 1.2 2003-10-25 21:51:31 piso Exp $
     5 * $Id: SymbolMacro.java,v 1.3 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3737
    3838    // ### make-symbol-macro
    39     private static final Primitive1 MAKE_MACRO =
    40         new Primitive1("make-symbol-macro", PACKAGE_SYS, false)
     39    private static final Primitive MAKE_MACRO =
     40        new Primitive("make-symbol-macro", PACKAGE_SYS, false)
    4141    {
    4242        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/SynonymStream.java

    r7968 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: SynonymStream.java,v 1.7 2004-10-13 00:22:20 piso Exp $
     5 * $Id: SynonymStream.java,v 1.8 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    191191
    192192    // ### synonym-stream-symbol synonym-stream => symbol
    193     private static final Primitive1 SYNONYM_STREAM_STREAMS =
    194         new Primitive1("synonym-stream-symbol", "synonym-stream")
     193    private static final Primitive SYNONYM_STREAM_STREAMS =
     194        new Primitive("synonym-stream-symbol", "synonym-stream")
    195195    {
    196196        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/ThreadLock.java

    r7936 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: ThreadLock.java,v 1.3 2004-10-09 13:25:50 piso Exp $
     5 * $Id: ThreadLock.java,v 1.4 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5959
    6060    // ### make-thread-lock
    61     private static final Primitive0 MAKE_THREAD_LOCK =
    62         new Primitive0("make-thread-lock", PACKAGE_EXT, true)
     61    private static final Primitive MAKE_THREAD_LOCK =
     62        new Primitive("make-thread-lock", PACKAGE_EXT, true)
    6363    {
    6464        public LispObject execute() throws ConditionThrowable
     
    6969
    7070    // ### thread-lock lock
    71     private static final Primitive1 THREAD_LOCK =
    72         new Primitive1("thread-lock", PACKAGE_EXT, true)
     71    private static final Primitive THREAD_LOCK =
     72        new Primitive("thread-lock", PACKAGE_EXT, true)
    7373    {
    7474        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    8181
    8282    // ### thread-unlock lock
    83     private static final Primitive1 THREAD_UNLOCK =
    84         new Primitive1("thread-unlock", PACKAGE_EXT, true)
     83    private static final Primitive THREAD_UNLOCK =
     84        new Primitive("thread-unlock", PACKAGE_EXT, true)
    8585    {
    8686        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Time.java

    r7168 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: Time.java,v 1.21 2004-06-23 01:50:39 piso Exp $
     5 * $Id: Time.java,v 1.22 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2828{
    2929    // ### %time
    30     private static final Primitive1 _TIME =
    31         new Primitive1("%time", PACKAGE_SYS, false)
     30    private static final Primitive _TIME =
     31        new Primitive("%time", PACKAGE_SYS, false)
    3232    {
    3333        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    5959
    6060    // ### get-internal-real-time
    61     private static final Primitive0 GET_INTERNAL_REAL_TIME =
    62         new Primitive0("get-internal-real-time","") {
     61    private static final Primitive GET_INTERNAL_REAL_TIME =
     62        new Primitive("get-internal-real-time","") {
    6363        public LispObject execute() throws ConditionThrowable
    6464        {
     
    6868
    6969    // ### get-internal-run-time
    70     private static final Primitive0 GET_INTERNAL_RUN_TIME =
    71         new Primitive0("get-internal-run-time","") {
     70    private static final Primitive GET_INTERNAL_RUN_TIME =
     71        new Primitive("get-internal-run-time","") {
    7272        public LispObject execute() throws ConditionThrowable
    7373        {
     
    7777
    7878    // ### get-universal-time
    79     private static final Primitive0 GET_UNIVERSAL_TIME =
    80         new Primitive0("get-universal-time","") {
     79    private static final Primitive GET_UNIVERSAL_TIME =
     80        new Primitive("get-universal-time","") {
    8181        public LispObject execute()
    8282        {
     
    8686
    8787    // ### default-time-zone
    88     private static final Primitive0 DEFAULT_TIME_ZONE =
    89         new Primitive0("default-time-zone", PACKAGE_SYS, false)
     88    private static final Primitive DEFAULT_TIME_ZONE =
     89        new Primitive("default-time-zone", PACKAGE_SYS, false)
    9090    {
    9191        public LispObject execute() throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/TwoWayStream.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: TwoWayStream.java,v 1.24 2004-11-03 15:27:23 piso Exp $
     5 * $Id: TwoWayStream.java,v 1.25 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    206206    // ### two-way-stream-input-stream
    207207    // two-way-stream => input-stream
    208     private static final Primitive1 TWO_WAY_STREAM_INPUT_STREAM =
    209         new Primitive1("two-way-stream-input-stream", "two-way-stream")
     208    private static final Primitive TWO_WAY_STREAM_INPUT_STREAM =
     209        new Primitive("two-way-stream-input-stream", "two-way-stream")
    210210    {
    211211        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    219219    // ### two-way-stream-output-stream
    220220    // two-way-stream => output-stream
    221     private static final Primitive1 TWO_WAY_STREAM_OUTPUT_STREAM =
    222         new Primitive1("two-way-stream-output-stream", "two-way-stream")
     221    private static final Primitive TWO_WAY_STREAM_OUTPUT_STREAM =
     222        new Primitive("two-way-stream-output-stream", "two-way-stream")
    223223    {
    224224        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/TypeError.java

    r7973 r8087  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: TypeError.java,v 1.22 2004-10-13 17:53:57 piso Exp $
     5 * $Id: TypeError.java,v 1.23 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    142142
    143143    // ### type-error-datum
    144     private static final Primitive1 TYPE_ERROR_DATUM =
    145         new Primitive1("type-error-datum", "condition")
     144    private static final Primitive TYPE_ERROR_DATUM =
     145        new Primitive("type-error-datum", "condition")
    146146    {
    147147        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    154154
    155155    // ### type-error-expected-type
    156     private static final Primitive1 TYPE_ERROR_EXPECTED_TYPE =
    157         new Primitive1("type-error-expected-type", "condition")
     156    private static final Primitive TYPE_ERROR_EXPECTED_TYPE =
     157        new Primitive("type-error-expected-type", "condition")
    158158    {
    159159        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/arglist.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: arglist.java,v 1.11 2004-11-03 15:27:23 piso Exp $
     5 * $Id: arglist.java,v 1.12 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5353
    5454    // ### arglist
    55     private static final Primitive1 ARGLIST =
    56         new Primitive1("arglist", PACKAGE_EXT, true)
     55    private static final Primitive ARGLIST =
     56        new Primitive("arglist", PACKAGE_EXT, true)
    5757    {
    5858        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/cell_error_name.java

    r5321 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: cell_error_name.java,v 1.3 2004-01-02 01:23:37 piso Exp $
     5 * $Id: cell_error_name.java,v 1.4 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### cell-error-name
    25 public final class cell_error_name extends Primitive1
     25public final class cell_error_name extends Primitive
    2626{
    2727    private cell_error_name()
  • trunk/j/src/org/armedbear/lisp/create_new_file.java

    r6088 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: create_new_file.java,v 1.2 2004-03-05 16:10:22 piso Exp $
     5 * $Id: create_new_file.java,v 1.3 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2626
    2727// ### create-new-file
    28 public final class create_new_file extends Primitive1
     28public final class create_new_file extends Primitive
    2929{
    3030    private create_new_file()
     
    4747    }
    4848
    49     private static final Primitive1 CREATE_NEW_FILE = new create_new_file();
     49    private static final Primitive CREATE_NEW_FILE = new create_new_file();
    5050}
  • trunk/j/src/org/armedbear/lisp/cxr.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: cxr.java,v 1.7 2004-11-03 15:27:24 piso Exp $
     5 * $Id: cxr.java,v 1.8 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4949
    5050    // ### car
    51     private static final Primitive1 CAR = new Primitive1("car", "list")
     51    private static final Primitive CAR = new Primitive("car", "list")
    5252    {
    5353        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    5858
    5959    // ### cdr
    60     private static final Primitive1 CDR = new Primitive1("cdr", "list")
     60    private static final Primitive CDR = new Primitive("cdr", "list")
    6161    {
    6262        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    6767
    6868    // ### caar
    69     private static final Primitive1 CAAR = new Primitive1("caar", "list")
     69    private static final Primitive CAAR = new Primitive("caar", "list")
    7070    {
    7171        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    7676
    7777    // ### cadr
    78     private static final Primitive1 CADR = new Primitive1("cadr", "list")
     78    private static final Primitive CADR = new Primitive("cadr", "list")
    7979    {
    8080        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    8585
    8686    // ### cdar
    87     private static final Primitive1 CDAR = new Primitive1("cdar", "list")
     87    private static final Primitive CDAR = new Primitive("cdar", "list")
    8888    {
    8989        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    9494
    9595    // ### cddr
    96     private static final Primitive1 CDDR = new Primitive1("cddr", "list")
     96    private static final Primitive CDDR = new Primitive("cddr", "list")
    9797    {
    9898        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    103103
    104104    // ### caddr
    105     private static final Primitive1 CADDR = new Primitive1("caddr", "list")
     105    private static final Primitive CADDR = new Primitive("caddr", "list")
    106106    {
    107107        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    112112
    113113    // ### caadr
    114     private static final Primitive1 CAADR = new Primitive1("caadr", "list")
     114    private static final Primitive CAADR = new Primitive("caadr", "list")
    115115    {
    116116        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    121121
    122122    // ### caaar
    123     private static final Primitive1 CAAAR = new Primitive1("caaar", "list")
     123    private static final Primitive CAAAR = new Primitive("caaar", "list")
    124124    {
    125125        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    130130
    131131    // ### cdaar
    132     private static final Primitive1 CDAAR = new Primitive1("cdaar", "list")
     132    private static final Primitive CDAAR = new Primitive("cdaar", "list")
    133133    {
    134134        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    139139
    140140    // ### cddar
    141     private static final Primitive1 CDDAR = new Primitive1("cddar", "list")
     141    private static final Primitive CDDAR = new Primitive("cddar", "list")
    142142    {
    143143        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    148148
    149149    // ### cdddr
    150     private static final Primitive1 CDDDR = new Primitive1("cdddr", "list")
     150    private static final Primitive CDDDR = new Primitive("cdddr", "list")
    151151    {
    152152        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    157157
    158158    // ### cadar
    159     private static final Primitive1 CADAR = new Primitive1("cadar", "list")
     159    private static final Primitive CADAR = new Primitive("cadar", "list")
    160160    {
    161161        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    166166
    167167    // ### cdadr
    168     private static final Primitive1 CDADR = new Primitive1("cdadr", "list")
     168    private static final Primitive CDADR = new Primitive("cdadr", "list")
    169169    {
    170170        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    175175
    176176    // ### first
    177     private static final Primitive1 FIRST = new Primitive1("first","list")
     177    private static final Primitive FIRST = new Primitive("first","list")
    178178    {
    179179        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    184184
    185185    // ### second
    186     private static final Primitive1 SECOND = new Primitive1("second","list")
     186    private static final Primitive SECOND = new Primitive("second","list")
    187187    {
    188188        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    193193
    194194    // ### third
    195     private static final Primitive1 THIRD = new Primitive1("third","list")
     195    private static final Primitive THIRD = new Primitive("third","list")
    196196    {
    197197        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    202202
    203203    // ### fourth
    204     private static final Primitive1 FOURTH = new Primitive1("fourth","list")
     204    private static final Primitive FOURTH = new Primitive("fourth","list")
    205205    {
    206206        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    211211
    212212    // ### rest
    213     private static final Primitive1 REST = new Primitive1("rest","list")
     213    private static final Primitive REST = new Primitive("rest","list")
    214214    {
    215215        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/delete_file.java

    r7703 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: delete_file.java,v 1.5 2004-09-16 18:34:19 piso Exp $
     5 * $Id: delete_file.java,v 1.6 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2424import java.io.File;
    2525
    26 public final class delete_file extends Primitive1
     26public final class delete_file extends Primitive
    2727{
    2828    private delete_file()
     
    5757    }
    5858
    59     private static final Primitive1 DELETE_FILE = new delete_file();
     59    private static final Primitive DELETE_FILE = new delete_file();
    6060}
  • trunk/j/src/org/armedbear/lisp/file_author.java

    r5409 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: file_author.java,v 1.1 2004-01-07 19:05:37 piso Exp $
     5 * $Id: file_author.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2525
    2626// ### file-author
    27 public final class file_author extends Primitive1
     27public final class file_author extends Primitive
    2828{
    2929    private file_author()
     
    4040    }
    4141
    42     private static final Primitive1 FILE_AUTHOR = new file_author();
     42    private static final Primitive FILE_AUTHOR = new file_author();
    4343}
  • trunk/j/src/org/armedbear/lisp/file_error_pathname.java

    r5334 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: file_error_pathname.java,v 1.1 2004-01-02 19:03:01 piso Exp $
     5 * $Id: file_error_pathname.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### file-error-pathname
    25 public final class file_error_pathname extends Primitive1
     25public final class file_error_pathname extends Primitive
    2626{
    2727    private file_error_pathname()
  • trunk/j/src/org/armedbear/lisp/file_length.java

    r6788 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: file_length.java,v 1.4 2004-05-12 16:45:26 piso Exp $
     5 * $Id: file_length.java,v 1.5 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
    24 public final class file_length extends Primitive1
     24public final class file_length extends Primitive
    2525{
    2626    private file_length()
     
    4141    }
    4242
    43     private static final Primitive1 FILE_LENGTH = new file_length();
     43    private static final Primitive FILE_LENGTH = new file_length();
    4444}
  • trunk/j/src/org/armedbear/lisp/file_write_date.java

    r5408 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: file_write_date.java,v 1.2 2004-01-07 19:02:06 piso Exp $
     5 * $Id: file_write_date.java,v 1.3 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2525
    2626// ### file-write-date
    27 public final class file_write_date extends Primitive1
     27public final class file_write_date extends Primitive
    2828{
    2929    private file_write_date()
     
    4444    }
    4545
    46     private static final Primitive1 FILE_WRITE_DATE = new file_write_date();
     46    private static final Primitive FILE_WRITE_DATE = new file_write_date();
    4747}
  • trunk/j/src/org/armedbear/lisp/function_info.java

    r8084 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: function_info.java,v 1.3 2004-11-03 15:27:24 piso Exp $
     5 * $Id: function_info.java,v 1.4 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2929
    3030    // ### function-info name
    31     private static final Primitive1 FUNCTION_INFO =
    32         new Primitive1("function-info", PACKAGE_SYS, false)
     31    private static final Primitive FUNCTION_INFO =
     32        new Primitive("function-info", PACKAGE_SYS, false)
    3333    {
    3434        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/gc.java

    r4362 r8087  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: gc.java,v 1.1 2003-10-14 12:47:18 piso Exp $
     5 * $Id: gc.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### gc
    25 public final class gc extends Primitive0
     25public final class gc extends Primitive
    2626{
    2727    private gc()
  • trunk/j/src/org/armedbear/lisp/input_stream_p.java

    r5633 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: input_stream_p.java,v 1.4 2004-01-31 20:11:13 piso Exp $
     5 * $Id: input_stream_p.java,v 1.5 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### input-stream-p
    25 public final class input_stream_p extends Primitive1
     25public final class input_stream_p extends Primitive
    2626{
    2727    private input_stream_p()
     
    4040    }
    4141
    42     private static final Primitive1 INPUT_STREAM_P = new input_stream_p();
     42    private static final Primitive INPUT_STREAM_P = new input_stream_p();
    4343}
  • trunk/j/src/org/armedbear/lisp/interactive_stream_p.java

    r5537 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: interactive_stream_p.java,v 1.2 2004-01-24 19:53:17 piso Exp $
     5 * $Id: interactive_stream_p.java,v 1.3 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### interactive-stream-p
    25 public final class interactive_stream_p extends Primitive1
     25public final class interactive_stream_p extends Primitive
    2626{
    2727    private interactive_stream_p()
     
    3737    }
    3838
    39     private static final Primitive1 INTERACTIVE_STREAM_P = new interactive_stream_p();
     39    private static final Primitive INTERACTIVE_STREAM_P = new interactive_stream_p();
    4040}
  • trunk/j/src/org/armedbear/lisp/lisp_implementation_type.java

    r6336 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: lisp_implementation_type.java,v 1.4 2004-03-19 01:01:26 piso Exp $
     5 * $Id: lisp_implementation_type.java,v 1.5 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### lisp-implementation-type <no arguments> => description
    25 public final class lisp_implementation_type extends Primitive0
     25public final class lisp_implementation_type extends Primitive
    2626{
    2727    private lisp_implementation_type()
  • trunk/j/src/org/armedbear/lisp/lisp_implementation_version.java

    r5897 r8087  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: lisp_implementation_version.java,v 1.4 2004-02-23 14:24:48 piso Exp $
     5 * $Id: lisp_implementation_version.java,v 1.5 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2626// ### lisp_implementation_version
    2727// lisp_implementation_version <no arguments> => description
    28 public final class lisp_implementation_version extends Primitive0
     28public final class lisp_implementation_version extends Primitive
    2929{
    3030    private lisp_implementation_version()
  • trunk/j/src/org/armedbear/lisp/logcount.java

    r5114 r8087  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: logcount.java,v 1.3 2003-12-13 00:58:51 piso Exp $
     5 * $Id: logcount.java,v 1.4 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2626// ### logcount
    2727// logcount integer => number-of-on-bits
    28 public final class logcount extends Primitive1
     28public final class logcount extends Primitive
    2929{
    3030    private logcount()
  • trunk/j/src/org/armedbear/lisp/machine_type.java

    r6020 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: machine_type.java,v 1.1 2004-02-27 17:20:31 piso Exp $
     5 * $Id: machine_type.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### machine-type
    25 public final class machine_type extends Primitive0
     25public final class machine_type extends Primitive
    2626{
    2727    private machine_type()
     
    3535    }
    3636
    37     private static final Primitive0 MACHINE_TYPE = new machine_type();
     37    private static final Primitive MACHINE_TYPE = new machine_type();
    3838}
  • trunk/j/src/org/armedbear/lisp/machine_version.java

    r6020 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: machine_version.java,v 1.1 2004-02-27 17:19:59 piso Exp $
     5 * $Id: machine_version.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2828
    2929// ### machine-version
    30 public final class machine_version extends Primitive0
     30public final class machine_version extends Primitive
    3131{
    3232    private machine_version()
     
    6666    }
    6767
    68     private static final Primitive0 MACHINE_VERSION = new machine_version();
     68    private static final Primitive MACHINE_VERSION = new machine_version();
    6969}
  • trunk/j/src/org/armedbear/lisp/make_server_socket.java

    r6898 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: make_server_socket.java,v 1.1 2004-05-25 18:12:51 piso Exp $
     5 * $Id: make_server_socket.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2525
    2626// ### %make-server-socket
    27 public final class make_server_socket extends Primitive1
     27public final class make_server_socket extends Primitive
    2828{
    2929    private make_server_socket()
     
    4545    }
    4646
    47     private static final Primitive1 MAKE_SERVER_SOCKET = new make_server_socket();
     47    private static final Primitive MAKE_SERVER_SOCKET = new make_server_socket();
    4848}
  • trunk/j/src/org/armedbear/lisp/open_stream_p.java

    r5808 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: open_stream_p.java,v 1.3 2004-02-13 17:04:52 piso Exp $
     5 * $Id: open_stream_p.java,v 1.4 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### open-stream-p
    25 public final class open_stream_p extends Primitive1
     25public final class open_stream_p extends Primitive
    2626{
    2727    private open_stream_p()
     
    4040    }
    4141
    42     private static final Primitive1 OPEN_STREAM_P = new open_stream_p();
     42    private static final Primitive OPEN_STREAM_P = new open_stream_p();
    4343}
  • trunk/j/src/org/armedbear/lisp/output_stream_p.java

    r5633 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: output_stream_p.java,v 1.4 2004-01-31 20:11:07 piso Exp $
     5 * $Id: output_stream_p.java,v 1.5 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### output-stream-p
    25 public final class output_stream_p extends Primitive1
     25public final class output_stream_p extends Primitive
    2626{
    2727    private output_stream_p()
     
    4040    }
    4141
    42     private static final Primitive1 OUTPUT_STREAM_P = new output_stream_p();
     42    private static final Primitive OUTPUT_STREAM_P = new output_stream_p();
    4343}
  • trunk/j/src/org/armedbear/lisp/probe_file.java

    r5421 r8087  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: probe_file.java,v 1.13 2004-01-08 17:42:02 piso Exp $
     5 * $Id: probe_file.java,v 1.14 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2929    // ### probe-file
    3030    // probe-file pathspec => truename
    31     private static final Primitive1 PROBE_FILE =
    32         new Primitive1("probe-file", "pathspec")
     31    private static final Primitive PROBE_FILE =
     32        new Primitive("probe-file", "pathspec")
    3333    {
    3434        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    4040    // ### truename
    4141    // truename filespec => truename
    42     private static final Primitive1 TRUENAME =
    43         new Primitive1("truename", "filespec")
     42    private static final Primitive TRUENAME =
     43        new Primitive("truename", "filespec")
    4444    {
    4545        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    5151    // ### probe-directory
    5252    // probe-directory pathspec => truename
    53     private static final Primitive1 PROBE_DIRECTORY =
    54         new Primitive1("probe-directory", PACKAGE_EXT, true)
     53    private static final Primitive PROBE_DIRECTORY =
     54        new Primitive("probe-directory", PACKAGE_EXT, true)
    5555    {
    5656        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    6666    // ### file-directory-p
    6767    // file-directory-p pathspec => generalized-boolean
    68     private static final Primitive1 FILE_DIRECTORY_P =
    69         new Primitive1("file-directory-p", PACKAGE_EXT, true)
     68    private static final Primitive FILE_DIRECTORY_P =
     69        new Primitive("file-directory-p", PACKAGE_EXT, true)
    7070    {
    7171        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/server_socket_close.java

    r6898 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: server_socket_close.java,v 1.1 2004-05-25 18:13:46 piso Exp $
     5 * $Id: server_socket_close.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2525
    2626// ### %server-socket-close
    27 public final class server_socket_close extends Primitive1
     27public final class server_socket_close extends Primitive
    2828{
    2929    private server_socket_close()
     
    4545    }
    4646
    47     private static final Primitive1 SERVER_SOCKET_CLOSE = new server_socket_close();
     47    private static final Primitive SERVER_SOCKET_CLOSE = new server_socket_close();
    4848}
  • trunk/j/src/org/armedbear/lisp/simple_list_remove_duplicates.java

    r6225 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: simple_list_remove_duplicates.java,v 1.1 2004-03-13 17:49:00 piso Exp $
     5 * $Id: simple_list_remove_duplicates.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### simple-list-remove-duplicates
    25 public final class simple_list_remove_duplicates extends Primitive1
     25public final class simple_list_remove_duplicates extends Primitive
    2626{
    2727    private simple_list_remove_duplicates()
     
    5151    }
    5252
    53     private static final Primitive1 SIMPLE_LIST_REMOVE_DUPLICATES =
     53    private static final Primitive SIMPLE_LIST_REMOVE_DUPLICATES =
    5454        new simple_list_remove_duplicates();
    5555}
  • trunk/j/src/org/armedbear/lisp/socket_accept.java

    r7102 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: socket_accept.java,v 1.3 2004-06-13 18:09:55 asimon Exp $
     5 * $Id: socket_accept.java,v 1.4 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2626
    2727// ### %socket-accept
    28 public final class socket_accept extends Primitive1
     28public final class socket_accept extends Primitive
    2929{
    3030    private socket_accept()
     
    4747    }
    4848
    49     private static final Primitive1 SOCKET_ACCEPT = new socket_accept();
     49    private static final Primitive SOCKET_ACCEPT = new socket_accept();
    5050}
  • trunk/j/src/org/armedbear/lisp/socket_close.java

    r6898 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: socket_close.java,v 1.1 2004-05-25 18:14:33 piso Exp $
     5 * $Id: socket_close.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2525
    2626// ### %socket-close
    27 public final class socket_close extends Primitive1
     27public final class socket_close extends Primitive
    2828{
    2929    private socket_close()
     
    4545    }
    4646
    47     private static final Primitive1 SOCKET_CLOSE = new socket_close();
     47    private static final Primitive SOCKET_CLOSE = new socket_close();
    4848}
  • trunk/j/src/org/armedbear/lisp/software_type.java

    r6015 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: software_type.java,v 1.1 2004-02-27 16:44:12 piso Exp $
     5 * $Id: software_type.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### software-type
    25 public final class software_type extends Primitive0
     25public final class software_type extends Primitive
    2626{
    2727    private software_type()
     
    3535    }
    3636
    37     private static final Primitive0 SOFTWARE_TYPE = new software_type();
     37    private static final Primitive SOFTWARE_TYPE = new software_type();
    3838}
  • trunk/j/src/org/armedbear/lisp/software_version.java

    r6015 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: software_version.java,v 1.1 2004-02-27 16:44:19 piso Exp $
     5 * $Id: software_version.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### software-version
    25 public final class software_version extends Primitive0
     25public final class software_version extends Primitive
    2626{
    2727    private software_version()
     
    3535    }
    3636
    37     private static final Primitive0 SOFTWARE_VERSION = new software_version();
     37    private static final Primitive SOFTWARE_VERSION = new software_version();
    3838}
  • trunk/j/src/org/armedbear/lisp/stream_element_type.java

    r5537 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: stream_element_type.java,v 1.2 2004-01-24 19:56:23 piso Exp $
     5 * $Id: stream_element_type.java,v 1.3 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### stream-element-type
    25 public final class stream_element_type extends Primitive1
     25public final class stream_element_type extends Primitive
    2626{
    2727    private stream_element_type()
     
    4040    }
    4141
    42     private static final Primitive1 STREAM_ELEMENT_TYPE = new stream_element_type();
     42    private static final Primitive STREAM_ELEMENT_TYPE = new stream_element_type();
    4343}
  • trunk/j/src/org/armedbear/lisp/stream_external_format.java

    r5591 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: stream_external_format.java,v 1.1 2004-01-28 19:48:38 piso Exp $
     5 * $Id: stream_external_format.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### stream-external-format
    25 public final class stream_external_format extends Primitive1
     25public final class stream_external_format extends Primitive
    2626{
    2727    private stream_external_format()
     
    3838    }
    3939
    40     private static final Primitive1 STREAM_EXTERNAL_FORMAT =
     40    private static final Primitive STREAM_EXTERNAL_FORMAT =
    4141        new stream_external_format();
    4242}
  • trunk/j/src/org/armedbear/lisp/unbound_slot_instance.java

    r5318 r8087  
    33 *
    44 * Copyright (C) 2004 Peter Graves
    5  * $Id: unbound_slot_instance.java,v 1.1 2004-01-02 01:19:12 piso Exp $
     5 * $Id: unbound_slot_instance.java,v 1.2 2004-11-03 15:39:02 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2323
    2424// ### unbound-slot-instance
    25 public final class unbound_slot_instance extends Primitive1
     25public final class unbound_slot_instance extends Primitive
    2626{
    2727    private unbound_slot_instance()
Note: See TracChangeset for help on using the changeset viewer.