Changeset 5037


Ignore:
Timestamp:
12/09/03 20:26:23 (17 years ago)
Author:
asimon
Message:

Added arglist info

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

Legend:

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

    r4103 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: CharacterFunctions.java,v 1.5 2003-09-28 16:24:37 piso Exp $
     5 * $Id: CharacterFunctions.java,v 1.6 2003-12-09 20:26:22 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2525{
    2626    // ### char=
    27     private static final Primitive CHAR_EQUALS = new Primitive("char=") {
     27    private static final Primitive CHAR_EQUALS = new Primitive("char=","&rest characters") {
    2828        public LispObject execute(LispObject first, LispObject second)
    2929            throws ConditionThrowable
     
    4848
    4949    // ### char-equal
    50     private static final Primitive CHAR_EQUAL = new Primitive("char-equal") {
     50    private static final Primitive CHAR_EQUAL = new Primitive("char-equal","&rest characters") {
    5151        public LispObject execute(LispObject first, LispObject second)
    5252            throws ConditionThrowable
     
    8686    // ### char-greaterp
    8787    private static final Primitive CHAR_GREATERP =
    88         new Primitive("char-greaterp") {
     88        new Primitive("char-greaterp","&rest characters") {
    8989        public LispObject execute(LispObject first, LispObject second)
    9090            throws ConditionThrowable
     
    114114    // ### char-not-greaterp
    115115    private static final Primitive CHAR_NOT_GREATERP =
    116         new Primitive("char-not-greaterp") {
     116        new Primitive("char-not-greaterp","&rest characters") {
    117117        public LispObject execute(LispObject first, LispObject second)
    118118            throws ConditionThrowable
     
    142142    // ### char-lessp
    143143    private static final Primitive CHAR_LESSP =
    144         new Primitive("char-lessp") {
     144        new Primitive("char-lessp","&rest characters") {
    145145        public LispObject execute(LispObject first, LispObject second)
    146146            throws ConditionThrowable
     
    170170    // ### char-not-lessp
    171171    private static final Primitive CHAR_NOT_LESSP =
    172         new Primitive("char-not-lessp") {
     172        new Primitive("char-not-lessp","&rest characters") {
    173173        public LispObject execute(LispObject first, LispObject second)
    174174            throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/DisplacedArray.java

    r4789 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: DisplacedArray.java,v 1.16 2003-11-16 18:24:12 piso Exp $
     5 * $Id: DisplacedArray.java,v 1.17 2003-12-09 20:26:22 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    172172    // array-displacement array => displaced-to, displaced-index-offset
    173173    private static final Primitive1 ARRAY_DISPLACEMENT =
    174         new Primitive1("array-displacement")
     174        new Primitive1("array-displacement","array")
    175175    {
    176176        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/HashTable.java

    r4931 r5037  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: HashTable.java,v 1.26 2003-11-30 18:18:59 piso Exp $
     5 * $Id: HashTable.java,v 1.27 2003-12-09 20:26:22 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    296296    // ### gethash
    297297    // gethash key hash-table &optional default => value, present-p
    298     private static final Primitive GETHASH = new Primitive("gethash") {
     298    private static final Primitive GETHASH = new Primitive("gethash","key hash-table &optional default") {
    299299        public LispObject execute(LispObject[] args) throws ConditionThrowable
    300300        {
     
    339339
    340340    // remhash key hash-table => generalized-boolean
    341     private static final Primitive2 REMHASH = new Primitive2("remhash") {
     341    private static final Primitive2 REMHASH = new Primitive2("remhash","key hash-table") {
    342342        public LispObject execute(LispObject first, LispObject second)
    343343            throws ConditionThrowable
     
    354354    // ### clrhash
    355355    // clrhash hash-table => hash-table
    356     private static final Primitive1 CLRHASH = new Primitive1("clrhash") {
     356    private static final Primitive1 CLRHASH = new Primitive1("clrhash","hash-table") {
    357357        public LispObject execute(LispObject arg) throws ConditionThrowable
    358358        {
     
    367367    // ### hash-table-count
    368368    private static final Primitive1 HASH_TABLE_COUNT =
    369         new Primitive1("hash-table-count") {
     369        new Primitive1("hash-table-count","hash-table") {
    370370        public LispObject execute(LispObject arg) throws ConditionThrowable
    371371        {
     
    378378    // ### sxhash
    379379    // sxhash object => hash-code
    380     private static final Primitive1 SXHASH = new Primitive1("sxhash")
     380    private static final Primitive1 SXHASH = new Primitive1("sxhash","object")
    381381    {
    382382        public LispObject execute(LispObject arg)
     
    388388    // ### hash-table-p
    389389    private static final Primitive1 HASH_TABLE_P =
    390         new Primitive1("hash-table-p") {
     390        new Primitive1("hash-table-p","object") {
    391391        public LispObject execute(LispObject arg) throws ConditionThrowable
    392392        {
  • trunk/j/src/org/armedbear/lisp/LispCharacter.java

    r5010 r5037  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: LispCharacter.java,v 1.31 2003-12-07 19:13:42 piso Exp $
     5 * $Id: LispCharacter.java,v 1.32 2003-12-09 20:26:22 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    176176    }
    177177
    178     private static final Primitive1 CHARACTER = new Primitive1("character") {
     178    private static final Primitive1 CHARACTER = new Primitive1("character","character") {
    179179        public LispObject execute(LispObject arg) throws ConditionThrowable
    180180        {
     
    204204
    205205    // ### char-code
    206     private static final Primitive1 CHAR_CODE = new Primitive1("char-code")
     206    private static final Primitive1 CHAR_CODE = new Primitive1("char-code","character")
    207207    {
    208208        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    213213
    214214    // ### char-int
    215     private static final Primitive1 CHAR_INT = new Primitive1("char-int")
     215    private static final Primitive1 CHAR_INT = new Primitive1("char-int","character")
    216216    {
    217217        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    222222
    223223    // ### code-char
    224     private static final Primitive1 CODE_CHAR = new Primitive1("code-char")
     224    private static final Primitive1 CODE_CHAR = new Primitive1("code-char","code")
    225225    {
    226226        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    236236
    237237    // ### characterp
    238     private static final Primitive1 CHARACTERP = new Primitive1("characterp")
     238    private static final Primitive1 CHARACTERP = new Primitive1("characterp","object")
    239239    {
    240240        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    245245
    246246    // ### both-case-p
    247     private static final Primitive1 BOTH_CASE_P = new Primitive1("both-case-p")
     247    private static final Primitive1 BOTH_CASE_P = new Primitive1("both-case-p","character")
    248248    {
    249249        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    257257
    258258    // ### lower-case-p
    259     private static final Primitive1 LOWER_CASE_P = new Primitive1("lower-case-p")
     259    private static final Primitive1 LOWER_CASE_P = new Primitive1("lower-case-p","character")
    260260    {
    261261        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    266266
    267267    // ### upper-case-p
    268     private static final Primitive1 UPPER_CASE_P = new Primitive1("upper-case-p")
     268    private static final Primitive1 UPPER_CASE_P = new Primitive1("upper-case-p","character")
    269269    {
    270270        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    275275
    276276    // ### char-downcase
    277     private static final Primitive1 CHAR_DOWNCASE = new Primitive1("char-downcase")
     277    private static final Primitive1 CHAR_DOWNCASE = new Primitive1("char-downcase","character")
    278278    {
    279279        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    284284
    285285    // ### char-upcase
    286     private static final Primitive1 CHAR_UPCASE = new Primitive1("char-upcase")
     286    private static final Primitive1 CHAR_UPCASE = new Primitive1("char-upcase","character")
    287287    {
    288288        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/LispClass.java

    r4346 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: LispClass.java,v 1.33 2003-10-13 13:10:37 piso Exp $
     5 * $Id: LispClass.java,v 1.34 2003-12-09 20:26:22 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    173173    // ### find-class
    174174    // find-class symbol &optional errorp environment => class
    175     private static final Primitive FIND_CLASS = new Primitive("find-class") {
     175    private static final Primitive FIND_CLASS = new Primitive("find-class","symbol &optional errorp environment") {
    176176        public LispObject execute(LispObject symbol) throws ConditionThrowable
    177177        {
     
    228228
    229229    // ### class-name
    230     private static final Primitive1 CLASS_NAME = new Primitive1("class-name")
     230    private static final Primitive1 CLASS_NAME = new Primitive1("class-name","class")
    231231    {
    232232        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/LispFloat.java

    r4791 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: LispFloat.java,v 1.51 2003-11-16 18:30:38 piso Exp $
     5 * $Id: LispFloat.java,v 1.52 2003-12-09 20:26:22 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    369369    // integer-decode-float float => significand, exponent, integer-sign
    370370    private static final Primitive1 INTEGER_DECODE_FLOAT =
    371         new Primitive1("integer-decode-float")
     371        new Primitive1("integer-decode-float","float")
    372372    {
    373373        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    398398    // float-radix float => float-radix
    399399    private static final Primitive1 FLOAT_RADIX =
    400         new Primitive1("float-radix") {
     400        new Primitive1("float-radix","float") {
    401401        public LispObject execute(LispObject arg) throws ConditionThrowable
    402402        {
     
    410410    // float-digits float => float-digits
    411411    private static final Primitive1 FLOAT_DIGITS =
    412         new Primitive1("float-digits") {
     412        new Primitive1("float-digits","float") {
    413413        public LispObject execute(LispObject arg) throws ConditionThrowable
    414414        {
     
    434434    // ### float
    435435    // float number &optional prototype => float
    436     private static final Primitive FLOAT = new Primitive("float") {
     436    private static final Primitive FLOAT = new Primitive("float","number &optional prototype") {
    437437        public LispObject execute(LispObject[] args) throws ConditionThrowable
    438438        {
     
    447447    // ### floatp
    448448    // floatp object => generalized-boolean
    449     private static final Primitive1 FLOATP = new Primitive1("floatp") {
     449    private static final Primitive1 FLOATP = new Primitive1("floatp","object") {
    450450        public LispObject execute(LispObject arg) throws ConditionThrowable
    451451        {
  • trunk/j/src/org/armedbear/lisp/LispString.java

    r5007 r5037  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: LispString.java,v 1.69 2003-12-07 18:31:07 piso Exp $
     5 * $Id: LispString.java,v 1.70 2003-12-09 20:26:22 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    345345    }
    346346
    347     public static final Primitive1 STRINGP = new Primitive1("stringp")
     347    public static final Primitive1 STRINGP = new Primitive1("stringp","object")
    348348    {
    349349        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    354354    };
    355355
    356     public static final Primitive1 SIMPLE_STRING_P = new Primitive1("simple-string-p")
     356    public static final Primitive1 SIMPLE_STRING_P = new Primitive1("simple-string-p","object")
    357357    {
    358358        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    402402    };
    403403
    404     private static final Primitive2 CHAR = new Primitive2("char")
     404    private static final Primitive2 CHAR = new Primitive2("char","string index")
    405405    {
    406406        public LispObject execute(LispObject first, LispObject second)
     
    421421    };
    422422
    423     private static final Primitive2 SCHAR = new Primitive2("schar") {
     423    private static final Primitive2 SCHAR = new Primitive2("schar","string index") {
    424424        public LispObject execute(LispObject first, LispObject second)
    425425            throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/LispThread.java

    r4829 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: LispThread.java,v 1.25 2003-11-19 02:00:48 piso Exp $
     5 * $Id: LispThread.java,v 1.26 2003-12-09 20:26:22 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    445445
    446446    // ### sleep
    447     private static final Primitive1 SLEEP = new Primitive1("sleep") {
     447    private static final Primitive1 SLEEP = new Primitive1("sleep","seconds") {
    448448        public LispObject execute(LispObject arg) throws ConditionThrowable
    449449        {
  • trunk/j/src/org/armedbear/lisp/Load.java

    r4930 r5037  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Load.java,v 1.26 2003-11-30 17:27:19 piso Exp $
     5 * $Id: Load.java,v 1.27 2003-12-09 20:26:22 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    292292    // Need to support keyword args.
    293293    // load filespec &key verbose print if-does-not-exist external-format
    294     public static final Primitive LOAD = new Primitive("load") {
     294    public static final Primitive LOAD = new Primitive("load","filespec &key verbose print if-does-not-exist external-format") {
    295295        public LispObject execute(LispObject[] args) throws ConditionThrowable
    296296        {
  • trunk/j/src/org/armedbear/lisp/PackageFunctions.java

    r4140 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: PackageFunctions.java,v 1.20 2003-09-30 09:40:43 piso Exp $
     5 * $Id: PackageFunctions.java,v 1.21 2003-12-09 20:26:22 asimon 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") {
     28    private static final Primitive1 PACKAGEP = new Primitive1("packagep","object") {
    2929        public LispObject execute(LispObject arg) throws ConditionThrowable
    3030        {
     
    3636    // package-name package => nicknames
    3737    private static final Primitive1 PACKAGE_NAME =
    38         new Primitive1("package-name") {
     38        new Primitive1("package-name","package") {
    3939        public LispObject execute(LispObject arg) throws ConditionThrowable
    4040        {
     
    4747    // package-nicknames package => nicknames
    4848    private static final Primitive1 PACKAGE_NICKNAMES =
    49         new Primitive1("package-nicknames") {
     49        new Primitive1("package-nicknames","package") {
    5050        public LispObject execute(LispObject arg) throws ConditionThrowable
    5151        {
     
    5757    // package-use-list package => use-list
    5858    private static final Primitive1 PACKAGE_USE_LIST =
    59         new Primitive1("package-use-list") {
     59        new Primitive1("package-use-list","package") {
    6060        public LispObject execute(LispObject arg) throws ConditionThrowable
    6161        {
     
    6767    // package-used-by-list package => used-by-list
    6868    private static final Primitive1 PACKAGE_USED_BY_LIST =
    69         new Primitive1("package-used-by-list") {
     69        new Primitive1("package-used-by-list","package") {
    7070        public LispObject execute(LispObject arg) throws ConditionThrowable
    7171        {
     
    7676    // ### import
    7777    // import symbols &optional package => t
    78     private static final Primitive IMPORT = new Primitive("import") {
     78    private static final Primitive IMPORT = new Primitive("import","symbols &optional package") {
    7979        public LispObject execute(LispObject[] args) throws ConditionThrowable
    8080        {
     
    9797    // ### unexport
    9898    // unexport symbols &optional package => t
    99     private static final Primitive UNEXPORT = new Primitive("unexport") {
     99    private static final Primitive UNEXPORT = new Primitive("unexport","symbols &optional package") {
    100100        public LispObject execute(LispObject[] args) throws ConditionThrowable
    101101        {
     
    118118    // ### shadow
    119119    // shadow symbol-names &optional package => t
    120     private static final Primitive SHADOW = new Primitive("shadow") {
     120    private static final Primitive SHADOW = new Primitive("shadow","symbol-names &optional package") {
    121121        public LispObject execute(LispObject[] args) throws ConditionThrowable
    122122        {
     
    140140    // shadowing-import symbols &optional package => t
    141141    private static final Primitive SHADOWING_IMPORT =
    142         new Primitive("shadowing-import") {
     142        new Primitive("shadowing-import","symbols &optional package") {
    143143        public LispObject execute(LispObject[] args) throws ConditionThrowable
    144144        {
     
    162162    // package-shadowing-symbols package => used-by-list
    163163    private static final Primitive1 PACKAGE_SHADOWING_SYMBOLS =
    164         new Primitive1("package-shadowing-symbols") {
     164        new Primitive1("package-shadowing-symbols","package") {
    165165        public LispObject execute(LispObject arg) throws ConditionThrowable
    166166        {
     
    171171    // ### delete-package
    172172    private static final Primitive1 DELETE_PACKAGE =
    173         new Primitive1("delete-package") {
     173        new Primitive1("delete-package","package") {
    174174        public LispObject execute(LispObject arg) throws ConditionThrowable
    175175        {
     
    181181    // unuse-package packages-to-unuse &optional package => t
    182182    private static final Primitive USE_PACKAGE =
    183         new Primitive("unuse-package") {
     183        new Primitive("unuse-package","packages-to-unuse &optional package") {
    184184        public LispObject execute(LispObject[] args) throws ConditionThrowable
    185185        {
     
    206206    // rename-package package new-name &optional new-nicknames => package-object
    207207    private static final Primitive RENAME_PACKAGE =
    208         new Primitive("rename-package") {
     208        new Primitive("rename-package","package new-name &optional new-nicknames") {
    209209        public LispObject execute(LispObject[] args) throws ConditionThrowable
    210210        {
     
    220220
    221221    private static final Primitive0 LIST_ALL_PACKAGES =
    222         new Primitive0("list-all-packages") {
     222        new Primitive0("list-all-packages","()") {
    223223        public LispObject execute()
    224224        {
  • trunk/j/src/org/armedbear/lisp/Pathname.java

    r4971 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Pathname.java,v 1.19 2003-12-04 18:40:34 piso Exp $
     5 * $Id: Pathname.java,v 1.20 2003-12-09 20:26:22 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    102102    // namestring pathname => namestring
    103103    // FIXME arg can be a stream, too...
    104     private static final Primitive1 NAMESTRING = new Primitive1("namestring")
     104    private static final Primitive1 NAMESTRING = new Primitive1("namestring","pathname")
    105105    {
    106106        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    118118    // FIXME arg can be a stream, too...
    119119    private static final Primitive1 DIRECTORY_NAMESTRING =
    120         new Primitive1("directory-namestring")
     120        new Primitive1("directory-namestring","pathname")
    121121    {
    122122        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    143143    // pathname pathspec => pathname
    144144    // FIXME pathspec can be a stream, too...
    145     private static final Primitive1 PATHNAME = new Primitive1("pathname")
     145    private static final Primitive1 PATHNAME = new Primitive1("pathname","pathspec")
    146146    {
    147147        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    210210
    211211    // ### pathnamep
    212     private static final Primitive1 PATHNAMEP = new Primitive1("pathnamep")
     212    private static final Primitive1 PATHNAMEP = new Primitive1("pathnamep","object")
    213213    {
    214214        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    219219
    220220    // ### pathname-type
    221     private static final Primitive1 PATHNAME_TYPE = new Primitive1("pathname-type")
     221    private static final Primitive1 PATHNAME_TYPE = new Primitive1("pathname-type","pathname &key case")
    222222    {
    223223        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    244244    // user-homedir-pathname &optional host => pathname
    245245    private static final Primitive USER_HOMEDIR_PATHNAME =
    246         new Primitive("user-homedir-pathname")
     246        new Primitive("user-homedir-pathname","&optional host")
    247247    {
    248248        public LispObject execute(LispObject[] args) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Primitives.java

    r5019 r5037  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Primitives.java,v 1.519 2003-12-08 04:49:13 piso Exp $
     5 * $Id: Primitives.java,v 1.520 2003-12-09 20:26:22 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3131{
    3232    // ### *
    33     public static final Primitive MULTIPLY = new Primitive("*")
     33    public static final Primitive MULTIPLY = new Primitive("*","&rest numbers")
    3434    {
    3535        public LispObject execute()
     
    5858
    5959    // ### /
    60     public static final Primitive DIVIDE = new Primitive("/")
     60    public static final Primitive DIVIDE = new Primitive("/","numerator &rest denominators")
    6161    {
    6262        public LispObject execute() throws ConditionThrowable
     
    8383
    8484    // ### min
    85     public static final Primitive MIN = new Primitive("min")
     85    public static final Primitive MIN = new Primitive("min","&rest reals")
    8686    {
    8787        public LispObject execute() throws ConditionThrowable
     
    110110
    111111    // ### max
    112     public static final Primitive MAX = new Primitive("max")
     112    public static final Primitive MAX = new Primitive("max","&rest reals")
    113113    {
    114114        public LispObject execute() throws ConditionThrowable
     
    136136
    137137    // ### identity
    138     private static final Primitive1 IDENTITY = new Primitive1("identity")
     138    private static final Primitive1 IDENTITY = new Primitive1("identity","object")
    139139    {
    140140        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    146146    // ### compiled-function-p
    147147    private static final Primitive1 COMPILED_FUNCTION_P =
    148         new Primitive1("compiled-function-p")
     148        new Primitive1("compiled-function-p","object")
    149149    {
    150150        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    155155
    156156    // ### consp
    157     private static final Primitive1 CONSP = new Primitive1("consp")
     157    private static final Primitive1 CONSP = new Primitive1("consp","object")
    158158    {
    159159        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    164164
    165165    // ### listp
    166     private static final Primitive1 LISTP = new Primitive1("listp")
     166    private static final Primitive1 LISTP = new Primitive1("listp","object")
    167167    {
    168168        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    173173
    174174    // ### abs
    175     private static final Primitive1 ABS = new Primitive1("abs")
     175    private static final Primitive1 ABS = new Primitive1("abs","number")
    176176    {
    177177        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    182182
    183183    // ### arrayp
    184     private static final Primitive1 ARRAYP = new Primitive1("arrayp")
     184    private static final Primitive1 ARRAYP = new Primitive1("arrayp","object")
    185185    {
    186186        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    192192    // ### array-has-fill-pointer-p
    193193    private static final Primitive1 ARRAY_HAS_FILL_POINTER_P =
    194         new Primitive1("array-has-fill-pointer-p")
     194        new Primitive1("array-has-fill-pointer-p","array")
    195195    {
    196196        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    205205
    206206    // ### vectorp
    207     private static final Primitive1 VECTORP = new Primitive1("vectorp")
     207    private static final Primitive1 VECTORP = new Primitive1("vectorp","object")
    208208    {
    209209        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    215215    // ### simple-vector-p
    216216    private static final Primitive1 SIMPLE_VECTOR_P =
    217         new Primitive1("simple-vector-p")
     217        new Primitive1("simple-vector-p","object")
    218218    {
    219219        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    225225    // ### bit-vector-p
    226226    private static final Primitive1 BIT_VECTOR_P =
    227         new Primitive1("bit-vector-p")
     227        new Primitive1("bit-vector-p","object")
    228228    {
    229229        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    235235    // ### simple-bit-vector-p
    236236    private static final Primitive1 SIMPLE_BIT_VECTOR_P =
    237         new Primitive1("simple-bit-vector-p")
     237        new Primitive1("simple-bit-vector-p","object")
    238238    {
    239239        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    244244
    245245    // ### eval
    246     private static final Primitive1 EVAL = new Primitive1("eval")
     246    private static final Primitive1 EVAL = new Primitive1("eval","form")
    247247    {
    248248        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    253253
    254254    // ### eq
    255     private static final Primitive2 EQ = new Primitive2("eq")
     255    private static final Primitive2 EQ = new Primitive2("eq","x y")
    256256    {
    257257        public LispObject execute(LispObject first, LispObject second)
     
    263263
    264264    // ### eql
    265     private static final Primitive2 EQL = new Primitive2("eql")
     265    private static final Primitive2 EQL = new Primitive2("eql","x y")
    266266    {
    267267        public LispObject execute(LispObject first, LispObject second)
     
    273273
    274274    // ### equal
    275     private static final Primitive2 EQUAL = new Primitive2("equal")
     275    private static final Primitive2 EQUAL = new Primitive2("equal","x y")
    276276    {
    277277        public LispObject execute(LispObject first, LispObject second)
     
    283283
    284284    // ### equalp
    285     private static final Primitive2 EQUALP = new Primitive2("equalp")
     285    private static final Primitive2 EQUALP = new Primitive2("equalp","x y")
    286286    {
    287287        public LispObject execute(LispObject first, LispObject second)
     
    293293
    294294    // ### values
    295     private static final Primitive VALUES = new Primitive("values")
     295    private static final Primitive VALUES = new Primitive("values","&rest object")
    296296    {
    297297        public LispObject execute()
     
    321321    // values-list list => element*
    322322    // Returns the elements of the list as multiple values.
    323     private static final Primitive1 VALUES_LIST = new Primitive1("values-list")
     323    private static final Primitive1 VALUES_LIST = new Primitive1("values-list","list")
    324324    {
    325325        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    330330
    331331    // ### cons
    332     private static final Primitive2 CONS = new Primitive2("cons")
     332    private static final Primitive2 CONS = new Primitive2("cons","object-1 object-2")
    333333    {
    334334        public LispObject execute(LispObject first, LispObject second)
     
    340340
    341341    // ### length
    342     private static final Primitive1 LENGTH = new Primitive1("length")
     342    private static final Primitive1 LENGTH = new Primitive1("length","sequence")
    343343    {
    344344        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    349349
    350350    // ### elt
    351     private static final Primitive2 ELT = new Primitive2("elt")
     351    private static final Primitive2 ELT = new Primitive2("elt","sequence index")
    352352    {
    353353        public LispObject execute(LispObject first, LispObject second)
     
    359359
    360360    // ### atom
    361     private static final Primitive1 ATOM = new Primitive1("atom")
     361    private static final Primitive1 ATOM = new Primitive1("atom","object")
    362362    {
    363363        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    368368
    369369    // ### constantp
    370     private static final Primitive CONSTANTP = new Primitive("constantp")
     370    private static final Primitive CONSTANTP = new Primitive("constantp","form &optional environment")
    371371    {
    372372        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    382382
    383383    // ### functionp
    384     private static final Primitive1 FUNCTIONP = new Primitive1("functionp")
     384    private static final Primitive1 FUNCTIONP = new Primitive1("functionp","object")
    385385    {
    386386        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    392392    // ### special-operator-p
    393393    private static final Primitive1 SPECIAL_OPERATOR_P =
    394         new Primitive1("special-operator-p")
     394        new Primitive1("special-operator-p","symbol")
    395395    {
    396396        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    401401
    402402    // ### symbolp
    403     private static final Primitive1 SYMBOLP = new Primitive1("symbolp") {
     403    private static final Primitive1 SYMBOLP = new Primitive1("symbolp","object") {
    404404        public LispObject execute(LispObject arg) throws ConditionThrowable
    405405        {
     
    409409
    410410    // ### endp
    411     private static final Primitive1 ENDP = new Primitive1("endp") {
     411    private static final Primitive1 ENDP = new Primitive1("endp","list") {
    412412        public LispObject execute(LispObject arg) throws ConditionThrowable
    413413        {
     
    417417
    418418    // ### null
    419     private static final Primitive1 NULL = new Primitive1("null") {
     419    private static final Primitive1 NULL = new Primitive1("null","object") {
    420420        public LispObject execute(LispObject arg) throws ConditionThrowable
    421421        {
     
    425425
    426426    // ### not
    427     private static final Primitive1 NOT = new Primitive1("not") {
     427    private static final Primitive1 NOT = new Primitive1("not","x") {
    428428        public LispObject execute(LispObject arg) throws ConditionThrowable
    429429        {
     
    433433
    434434    // ### plusp
    435     private static final Primitive1 PLUSP = new Primitive1("plusp") {
     435    private static final Primitive1 PLUSP = new Primitive1("plusp","real") {
    436436        public LispObject execute(LispObject arg) throws ConditionThrowable
    437437        {
     
    441441
    442442    // ### minusp
    443     private static final Primitive1 MINUSP = new Primitive1("minusp") {
     443    private static final Primitive1 MINUSP = new Primitive1("minusp","real") {
    444444        public LispObject execute(LispObject arg) throws ConditionThrowable
    445445        {
     
    449449
    450450    // ### zerop
    451     private static final Primitive1 ZEROP = new Primitive1("zerop") {
     451    private static final Primitive1 ZEROP = new Primitive1("zerop","number") {
    452452        public LispObject execute(LispObject arg) throws ConditionThrowable
    453453        {
     
    466466
    467467    // ### symbol-value
    468     private static final Primitive1 SYMBOL_VALUE = new Primitive1("symbol-value")
     468    private static final Primitive1 SYMBOL_VALUE = new Primitive1("symbol-value","symbol")
    469469    {
    470470        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    484484    // ### set
    485485    // set symbol value => value
    486     private static final Primitive2 SET = new Primitive2("set")
     486    private static final Primitive2 SET = new Primitive2("set","symbol value")
    487487    {
    488488        public LispObject execute(LispObject first, LispObject second)
     
    505505
    506506    // ### rplaca
    507     private static final Primitive2 RPLACA = new Primitive2("rplaca")
     507    private static final Primitive2 RPLACA = new Primitive2("rplaca","cons object")
    508508    {
    509509        public LispObject execute(LispObject first, LispObject second)
     
    516516
    517517    // ### rplacd
    518     private static final Primitive2 RPLACD = new Primitive2("rplacd")
     518    private static final Primitive2 RPLACD = new Primitive2("rplacd","cons object")
    519519    {
    520520        public LispObject execute(LispObject first, LispObject second)
     
    527527
    528528    // ### +
    529     private static final Primitive ADD = new Primitive("+")
     529    private static final Primitive ADD = new Primitive("+","&rest numbers")
    530530    {
    531531        public LispObject execute(LispObject first, LispObject second)
     
    545545
    546546    // ### 1+
    547     private static final Primitive1 ONE_PLUS = new Primitive1("1+")
     547    private static final Primitive1 ONE_PLUS = new Primitive1("1+","number")
    548548    {
    549549        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    554554
    555555    // ### -
    556     private static final Primitive SUBTRACT = new Primitive("-")
     556    private static final Primitive SUBTRACT = new Primitive("-","minuend &rest subtrahends")
    557557    {
    558558        public LispObject execute(LispObject first, LispObject second)
     
    582582
    583583    // ### 1-
    584     private static final Primitive1 ONE_MINUS = new Primitive1("1-")
     584    private static final Primitive1 ONE_MINUS = new Primitive1("1-","number")
    585585    {
    586586        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    646646    // ### princ
    647647    // princ object &optional output-stream => object
    648     private static final Primitive PRINC = new Primitive("princ") {
     648    private static final Primitive PRINC = new Primitive("princ","object &optional output-stream") {
    649649        public LispObject execute(LispObject[] args) throws ConditionThrowable
    650650        {
     
    663663    // ### princ-to-string
    664664    private static final Primitive1 PRINC_TO_STRING =
    665         new Primitive1("princ-to-string") {
     665        new Primitive1("princ-to-string","object") {
    666666        public LispObject execute(LispObject arg) throws ConditionThrowable
    667667        {
     
    677677    // ### prin1
    678678    // prin1 object &optional output-stream => object
    679     private static final Primitive PRIN1 = new Primitive("prin1") {
     679    private static final Primitive PRIN1 = new Primitive("prin1","object &optional output-stream") {
    680680        public LispObject execute(LispObject arg) throws ConditionThrowable
    681681        {
     
    695695    // ### prin1-to-string
    696696    private static final Primitive1 PRIN1_TO_STRING =
    697         new Primitive1("prin1-to-string") {
     697        new Primitive1("prin1-to-string","object") {
    698698        public LispObject execute(LispObject arg) throws ConditionThrowable
    699699        {
     
    706706    // PRINT is just like PRIN1 except that the printed representation of
    707707    // object is preceded by a newline and followed by a space.
    708     private static final Primitive1 PRINT = new Primitive1("print") {
     708    private static final Primitive1 PRINT = new Primitive1("print","object &optional output-stream") {
    709709        public LispObject execute(LispObject arg) throws ConditionThrowable
    710710        {
     
    729729    // ### terpri
    730730    // terpri &optional output-stream => nil
    731     private static final Primitive TERPRI = new Primitive("terpri") {
     731    private static final Primitive TERPRI = new Primitive("terpri","&optional output-stream") {
    732732        public LispObject execute(LispObject[] args) throws ConditionThrowable
    733733        {
     
    745745    // ### fresh-line
    746746    // fresh-line &optional output-stream => generalized-boolean
    747     private static final Primitive FRESH_LINE = new Primitive("fresh-line") {
     747    private static final Primitive FRESH_LINE = new Primitive("fresh-line","&optional output-stream") {
    748748        public LispObject execute(LispObject[] args) throws ConditionThrowable
    749749        {
     
    762762    // Determines only whether a symbol has a value in the global environment;
    763763    // any lexical bindings are ignored.
    764     private static final Primitive1 BOUNDP = new Primitive1("boundp")
     764    private static final Primitive1 BOUNDP = new Primitive1("boundp","symbol")
    765765    {
    766766        public LispObject execute(LispObject obj) throws ConditionThrowable
     
    783783
    784784    // ### fboundp
    785     private static final Primitive1 FBOUNDP = new Primitive1("fboundp")
     785    private static final Primitive1 FBOUNDP = new Primitive1("fboundp","name")
    786786    {
    787787        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    799799
    800800    // ### fmakunbound
    801     private static final Primitive1 FMAKUNBOUND = new Primitive1("fmakunbound")
     801    private static final Primitive1 FMAKUNBOUND = new Primitive1("fmakunbound","name")
    802802    {
    803803        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    815815
    816816    // ### remprop
    817     private static final Primitive2 REMPROP = new Primitive2("remprop")
     817    private static final Primitive2 REMPROP = new Primitive2("remprop","symbol indicator")
    818818    {
    819819        public LispObject execute(LispObject first, LispObject second)
     
    825825
    826826    // ### append
    827     public static final Primitive APPEND = new Primitive("append") {
     827    public static final Primitive APPEND = new Primitive("append","&rest lists") {
    828828        public LispObject execute()
    829829        {
     
    890890
    891891    // ### nconc
    892     private static final Primitive NCONC = new Primitive("nconc") {
     892    private static final Primitive NCONC = new Primitive("nconc","&rest lists") {
    893893        public LispObject execute(LispObject[] array) throws ConditionThrowable
    894894        {
     
    935935    // ### =
    936936    // Numeric equality.
    937     private static final Primitive EQUALS = new Primitive("=") {
     937    private static final Primitive EQUALS = new Primitive("=","&rest numbers") {
    938938        public LispObject execute(LispObject first, LispObject second)
    939939            throws ConditionThrowable
     
    956956
    957957    // Returns true if no two numbers are the same; otherwise returns false.
    958     private static final Primitive NOT_EQUALS = new Primitive("/=") {
     958    private static final Primitive NOT_EQUALS = new Primitive("/=","&rest numbers") {
    959959        public LispObject execute(LispObject first, LispObject second)
    960960            throws ConditionThrowable
     
    10021002
    10031003    // ### <=
    1004     private static final Primitive LE = new Primitive("<=") {
     1004    private static final Primitive LE = new Primitive("<=","&rest numbers") {
    10051005        public LispObject execute(LispObject first, LispObject second)
    10061006            throws ConditionThrowable
     
    10511051
    10521052    // ### >=
    1053     private static final Primitive GE = new Primitive(">=") {
     1053    private static final Primitive GE = new Primitive(">=","&rest numbers") {
    10541054        public LispObject execute(LispObject first, LispObject second)
    10551055            throws ConditionThrowable
     
    10821082    // This is the bootstrap version (needed for %set-documentation).
    10831083    // Redefined properly in assoc.lisp.
    1084     private static final Primitive ASSOC = new Primitive("assoc")
     1084    private static final Primitive ASSOC = new Primitive("assoc","item alist &key key test test-not")
    10851085    {
    10861086        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    11051105    // ### nth
    11061106    // nth n list => object
    1107     private static final Primitive2 NTH = new Primitive2("nth")
     1107    private static final Primitive2 NTH = new Primitive2("nth","n list")
    11081108    {
    11091109        public LispObject execute(LispObject first, LispObject second)
     
    11531153
    11541154    // ### nthcdr
    1155     private static final Primitive2 NTHCDR = new Primitive2("nthcdr") {
     1155    private static final Primitive2 NTHCDR = new Primitive2("nthcdr","n list") {
    11561156        public LispObject execute(LispObject first, LispObject second)
    11571157            throws ConditionThrowable
     
    11701170
    11711171    // ### error
    1172     private static final Primitive ERROR = new Primitive("error")
     1172    private static final Primitive ERROR = new Primitive("error","datum &rest arguments")
    11731173    {
    11741174        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    11981198
    11991199    // ### signal
    1200     private static final Primitive SIGNAL = new Primitive("signal")
     1200    private static final Primitive SIGNAL = new Primitive("signal","datum &rest arguments")
    12011201    {
    12021202        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    12111211
    12121212    // ### format
    1213     private static final Primitive FORMAT = new Primitive("format")
     1213    private static final Primitive FORMAT = new Primitive("format","destination control-string &rest args")
    12141214    {
    12151215        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    14071407    // ### macro-function
    14081408    // Need to support optional second argument specifying environment.
    1409     private static final Primitive MACRO_FUNCTION = new Primitive("macro-function")
     1409    private static final Primitive MACRO_FUNCTION = new Primitive("macro-function","symbol &optional environment")
    14101410    {
    14111411        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    17371737    // => upgraded-typespec
    17381738    private static final Primitive UPGRADED_ARRAY_ELEMENT_TYPE =
    1739         new Primitive("upgraded-array-element-type") {
     1739        new Primitive("upgraded-array-element-type","typespec &optional environment") {
    17401740        public LispObject execute(LispObject arg) throws ConditionThrowable
    17411741        {
     
    17531753    // array-rank array => rank
    17541754    private static final Primitive1 ARRAY_RANK =
    1755         new Primitive1("array-rank") {
     1755        new Primitive1("array-rank","array") {
    17561756        public LispObject execute(LispObject arg) throws ConditionThrowable
    17571757        {
     
    17641764    // Returns a list of integers. Fill pointer (if any) is ignored.
    17651765    private static final Primitive1 ARRAY_DIMENSIONS =
    1766         new Primitive1("array-dimensions") {
     1766        new Primitive1("array-dimensions","array") {
    17671767        public LispObject execute(LispObject arg) throws ConditionThrowable
    17681768        {
     
    17741774    // array-dimension array axis-number => dimension
    17751775    private static final Primitive2 ARRAY_DIMENSION =
    1776         new Primitive2("array-dimension") {
     1776        new Primitive2("array-dimension","array axis-number") {
    17771777        public LispObject execute(LispObject first, LispObject second)
    17781778            throws ConditionThrowable
     
    17851785    // array-total-size array => size
    17861786    private static final Primitive1 ARRAY_TOTAL_SIZE =
    1787         new Primitive1("array-total-size") {
     1787        new Primitive1("array-total-size","array") {
    17881788        public LispObject execute(LispObject arg) throws ConditionThrowable
    17891789        {
     
    17961796    // array-element-type array => typespec
    17971797    private static final Primitive1 ARRAY_ELEMENT_TYPE =
    1798         new Primitive1("array-element-type") {
     1798        new Primitive1("array-element-type","array") {
    17991799        public LispObject execute(LispObject arg) throws ConditionThrowable
    18001800        {
     
    18061806    // array-in-bounds-p array &rest subscripts => generalized-boolean
    18071807    private static final Primitive ARRAY_IN_BOUNDS_P =
    1808         new Primitive("array-in-bounds-p") {
     1808        new Primitive("array-in-bounds-p","array &rest subscripts") {
    18091809        public LispObject execute(LispObject[] args) throws ConditionThrowable
    18101810        {
     
    18511851    // ### aref
    18521852    // aref array &rest subscripts => element
    1853     private static final Primitive AREF = new Primitive("aref") {
     1853    private static final Primitive AREF = new Primitive("aref","array &rest subscripts") {
    18541854        public LispObject execute(LispObject arg) throws ConditionThrowable
    18551855        {
     
    19171917    // row-major-aref array index => element
    19181918    private static final Primitive2 ROW_MAJOR_AREF =
    1919         new Primitive2("row-major-aref") {
     1919        new Primitive2("row-major-aref","array index") {
    19201920        public LispObject execute(LispObject first, LispObject second)
    19211921            throws ConditionThrowable
     
    19451945
    19461946    // ### vector
    1947     private static final Primitive VECTOR = new Primitive("vector") {
     1947    private static final Primitive VECTOR = new Primitive("vector","&rest objects") {
    19481948        public LispObject execute(LispObject[] args) throws ConditionThrowable
    19491949        {
     
    19731973    // ### svref
    19741974    // svref simple-vector index => element
    1975     private static final Primitive2 SVREF = new Primitive2("svref") {
     1975    private static final Primitive2 SVREF = new Primitive2("svref","simple-vector index") {
    19761976        public LispObject execute(LispObject first, LispObject second)
    19771977            throws ConditionThrowable
     
    20042004    // ### fill-pointer
    20052005    private static final Primitive1 FILL_POINTER =
    2006         new Primitive1("fill-pointer") {
     2006        new Primitive1("fill-pointer","vector") {
    20072007        public LispObject execute(LispObject arg)
    20082008            throws ConditionThrowable
     
    20332033    // vector-push new-element vector => index-of-new-element
    20342034    private static final Primitive2 VECTOR_PUSH =
    2035         new Primitive2("vector-push") {
     2035        new Primitive2("vector-push","new-element vector") {
    20362036        public LispObject execute(LispObject first, LispObject second)
    20372037            throws ConditionThrowable
     
    20522052    // vector-push new-element vector &optional extension => index-of-new-element
    20532053    private static final Primitive VECTOR_PUSH_EXTEND =
    2054         new Primitive("vector-push-extend") {
     2054        new Primitive("vector-push-extend","new-element vector &optional extension") {
    20552055        public LispObject execute(LispObject[] args) throws ConditionThrowable
    20562056        {
     
    20792079    // ### vector-pop
    20802080    // vector-pop vector => element
    2081     private static final Primitive1 VECTOR_POP = new Primitive1("vector-pop") {
     2081    private static final Primitive1 VECTOR_POP = new Primitive1("vector-pop","vector") {
    20822082        public LispObject execute(LispObject arg) throws ConditionThrowable
    20832083        {
     
    20972097    // ### adjust-array
    20982098    // FIXME Very incomplete!
    2099     private static final Primitive2 ADJUST_ARRAY = new Primitive2("adjust-array")
     2099    private static final Primitive2 ADJUST_ARRAY = new Primitive2("adjust-array","array new-dimensions &key element-type initial-element initial-contents fill-pointer displaced-to displaced-index-offset")
    21002100    {
    21012101        public LispObject execute(LispObject first, LispObject second)
     
    21182118
    21192119    // ### type-of
    2120     private static final Primitive1 TYPE_OF = new Primitive1("type-of") {
     2120    private static final Primitive1 TYPE_OF = new Primitive1("type-of","object") {
    21212121        public LispObject execute(LispObject arg) throws ConditionThrowable
    21222122        {
     
    21262126
    21272127    // ### class-of
    2128     private static final Primitive1 CLASS_OF = new Primitive1("class-of") {
     2128    private static final Primitive1 CLASS_OF = new Primitive1("class-of","object") {
    21292129        public LispObject execute(LispObject arg) throws ConditionThrowable
    21302130        {
     
    21472147    // function-lambda-expression function => lambda-expression, closure-p, name
    21482148    private static final Primitive1 FUNCTION_LAMBDA_EXPRESSION =
    2149         new Primitive1("function-lambda-expression")
     2149        new Primitive1("function-lambda-expression","function")
    21502150    {
    21512151        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    21742174    // ### funcall
    21752175    // This needs to be public for LispAPI.java.
    2176     public static final Primitive FUNCALL = new Primitive("funcall") {
     2176    public static final Primitive FUNCALL = new Primitive("funcall","function &rest args") {
    21772177        public LispObject execute(LispObject arg) throws ConditionThrowable
    21782178        {
     
    22362236
    22372237    // ### apply
    2238     public static final Primitive APPLY = new Primitive("apply") {
     2238    public static final Primitive APPLY = new Primitive("apply","function &rest args") {
    22392239        public LispObject execute(LispObject first, LispObject second)
    22402240            throws ConditionThrowable
     
    22942294
    22952295    // ### mapcar
    2296     private static final Primitive MAPCAR = new Primitive("mapcar")
     2296    private static final Primitive MAPCAR = new Primitive("mapcar","function &rest lists")
    22972297    {
    22982298        public LispObject execute(LispObject op, LispObject list)
     
    23962396
    23972397    // ### macroexpand
    2398     private static final Primitive MACROEXPAND = new Primitive("macroexpand") {
     2398    private static final Primitive MACROEXPAND = new Primitive("macroexpand","form &optional env") {
    23992399        public LispObject execute(LispObject[] args) throws ConditionThrowable
    24002400        {
     
    24132413
    24142414    // ### macroexpand-1
    2415     private static final Primitive MACROEXPAND_1 = new Primitive("macroexpand-1")
     2415    private static final Primitive MACROEXPAND_1 = new Primitive("macroexpand-1","form &optional env")
    24162416    {
    24172417        public LispObject execute(LispObject form) throws ConditionThrowable
     
    24392439
    24402440    // ### gensym
    2441     private static final Primitive GENSYM = new Primitive("gensym")
     2441    private static final Primitive GENSYM = new Primitive("gensym","&optional x")
    24422442    {
    24432443        public LispObject execute() throws ConditionThrowable
     
    24942494
    24952495    // ### string
    2496     private static final Primitive1 STRING = new Primitive1("string") {
     2496    private static final Primitive1 STRING = new Primitive1("string","x") {
    24972497        public LispObject execute(LispObject arg) throws ConditionThrowable
    24982498        {
     
    25042504    // intern string &optional package => symbol, status
    25052505    // status is one of :INHERITED, :EXTERNAL, :INTERNAL or NIL.
    2506     private static final Primitive INTERN = new Primitive("intern") {
     2506    private static final Primitive INTERN = new Primitive("intern","string &optional package") {
    25072507        public LispObject execute(LispObject[] args) throws ConditionThrowable
    25082508        {
     
    25262526    // ### unintern
    25272527    // unintern symbol &optional package => generalized-boolean
    2528     private static final Primitive UNINTERN = new Primitive("unintern") {
     2528    private static final Primitive UNINTERN = new Primitive("unintern","symbol &optional package") {
    25292529        public LispObject execute(LispObject[] args) throws ConditionThrowable
    25302530        {
     
    25432543    // ### find-package
    25442544    private static final Primitive1 FIND_PACKAGE =
    2545         new Primitive1("find-package") {
     2545        new Primitive1("find-package","name") {
    25462546        public LispObject execute(LispObject arg) throws ConditionThrowable
    25472547        {
     
    26632663    // ### use-package
    26642664    // use-package packages-to-use &optional package => t
    2665     private static final Primitive USE_PACKAGE = new Primitive("use-package") {
     2665    private static final Primitive USE_PACKAGE = new Primitive("use-package","packages-to-use &optional package") {
    26662666        public LispObject execute(LispObject[] args) throws ConditionThrowable
    26672667        {
     
    28012801    // export symbols &optional package
    28022802    private static final Primitive EXPORT =
    2803         new Primitive("export") {
     2803        new Primitive("export","symbols &optional package") {
    28042804        public LispObject execute(LispObject[] args) throws ConditionThrowable
    28052805        {
     
    28242824    // find-symbol string &optional package => symbol, status
    28252825    private static final Primitive FIND_SYMBOL =
    2826         new Primitive("find-symbol") {
     2826        new Primitive("find-symbol","string &optional package") {
    28272827        public LispObject execute(LispObject[] args) throws ConditionThrowable
    28282828        {
     
    28632863    // ### getf
    28642864    // getf plist indicator &optional default => value
    2865     private static final Primitive GETF = new Primitive("getf")
     2865    private static final Primitive GETF = new Primitive("getf","plist indicator &optional default")
    28662866    {
    28672867        public LispObject execute(LispObject plist, LispObject indicator)
     
    28802880    // ### get
    28812881    // get symbol indicator &optional default => value
    2882     private static final Primitive GET = new Primitive("get")
     2882    private static final Primitive GET = new Primitive("get","symbol indicator &optional default")
    28832883    {
    28842884        public LispObject execute(LispObject symbol, LispObject indicator)
     
    33583358    // write-char character &optional output-stream => character
    33593359    private static final Primitive WRITE_CHAR =
    3360         new Primitive("write-char") {
     3360        new Primitive("write-char","character &optional output-stream") {
    33613361        public LispObject execute(LispObject[] args) throws ConditionThrowable
    33623362        {
     
    34063406    // ### finish-output
    34073407    // finish-output &optional output-stream => nil
    3408     private static final Primitive FINISH_OUTPUT = new Primitive("finish-output") {
     3408    private static final Primitive FINISH_OUTPUT = new Primitive("finish-output","&optional output-stream") {
    34093409        public LispObject execute(LispObject[] args) throws ConditionThrowable
    34103410        {
     
    34173417    // ### force-output
    34183418    // force-output &optional output-stream => nil
    3419     private static final Primitive FORCE_OUTPUT = new Primitive("force-output") {
     3419    private static final Primitive FORCE_OUTPUT = new Primitive("force-output","&optional output-stream") {
    34203420        public LispObject execute(LispObject[] args) throws ConditionThrowable
    34213421        {
     
    34443444    // ### clear-input
    34453445    // clear-input &optional input-stream => nil
    3446     private static final Primitive CLEAR_INPUT = new Primitive("clear-input") {
     3446    private static final Primitive CLEAR_INPUT = new Primitive("clear-input","&optional input-stream") {
    34473447        public LispObject execute(LispObject[] args) throws ConditionThrowable
    34483448        {
     
    34613461    // ### close
    34623462    // close stream &key abort => result
    3463     private static final Primitive CLOSE = new Primitive("close") {
     3463    private static final Primitive CLOSE = new Primitive("close","stream &key abort") {
    34643464        public LispObject execute(LispObject[] args) throws ConditionThrowable
    34653465        {
     
    35413541    // ### write-byte
    35423542    // write-byte byte stream => byte
    3543     private static final Primitive2 WRITE_BYTE = new Primitive2("write-byte")
     3543    private static final Primitive2 WRITE_BYTE = new Primitive2("write-byte","byte stream")
    35443544    {
    35453545        public LispObject execute (LispObject first, LispObject second)
     
    35573557    // ### read-byte
    35583558    // read-byte stream &optional eof-error-p eof-value => byte
    3559     private static final Primitive READ_BYTE = new Primitive("read-byte")
     3559    private static final Primitive READ_BYTE = new Primitive("read-byte","stream &optional eof-error-p eof-value")
    35603560    {
    35613561        public LispObject execute (LispObject[] args) throws ConditionThrowable
     
    35743574    // read-line &optional input-stream eof-error-p eof-value recursive-p
    35753575    // => line, missing-newline-p
    3576     private static final Primitive READ_LINE = new Primitive("read-line")
     3576    private static final Primitive READ_LINE = new Primitive("read-line","&optional input-stream eof-error-p eof-value recursive-p")
    35773577    {
    35783578        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    36383638
    36393639    private static final Primitive1 STANDARD_CHAR_P =
    3640         new Primitive1("standard-char-p")
     3640        new Primitive1("standard-char-p","character")
    36413641    {
    36423642        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    36473647
    36483648    private static final Primitive1 GRAPHIC_CHAR_P =
    3649         new Primitive1("graphic-char-p")
     3649        new Primitive1("graphic-char-p","char")
    36503650    {
    36513651        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    36573657
    36583658    private static final Primitive1 ALPHA_CHAR_P =
    3659         new Primitive1("alpha-char-p")
     3659        new Primitive1("alpha-char-p","character")
    36603660    {
    36613661        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    36663666    };
    36673667
    3668     private static final Primitive1 NAME_CHAR = new Primitive1("name-char") {
     3668    private static final Primitive1 NAME_CHAR = new Primitive1("name-char","name") {
    36693669        public LispObject execute(LispObject arg) throws ConditionThrowable
    36703670        {
     
    36753675    };
    36763676
    3677     private static final Primitive1 CHAR_NAME = new Primitive1("char-name")
     3677    private static final Primitive1 CHAR_NAME = new Primitive1("char-name","character")
    36783678    {
    36793679        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    37073707    };
    37083708
    3709     private static final Primitive DIGIT_CHAR = new Primitive("digit-char")
     3709    private static final Primitive DIGIT_CHAR = new Primitive("digit-char","weight &optional radix")
    37103710    {
    37113711        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    37553755    // => function
    37563756    private static final Primitive GET_DISPATCH_MACRO_CHARACTER =
    3757         new Primitive("get-dispatch-macro-character") {
     3757        new Primitive("get-dispatch-macro-character","disp-char sub-char &optional readtable") {
    37583758        public LispObject execute(LispObject[] args) throws ConditionThrowable
    37593759        {
     
    37753775    // => t
    37763776    private static final Primitive SET_DISPATCH_MACRO_CHARACTER =
    3777         new Primitive("set-dispatch-macro-character") {
     3777        new Primitive("set-dispatch-macro-character","disp-char sub-char new-function &optional readtable") {
    37783778        public LispObject execute(LispObject[] args) throws ConditionThrowable
    37793779        {
     
    37943794    // ### read
    37953795    // read &optional input-stream eof-error-p eof-value recursive-p => object
    3796     private static final Primitive READ = new Primitive("read") {
     3796    private static final Primitive READ = new Primitive("read","&optional input-stream eof-error-p eof-value recursive-p") {
    37973797        public LispObject execute(LispObject[] args) throws ConditionThrowable
    37983798        {
     
    38113811    // ### read-char
    38123812    // read-char &optional input-stream eof-error-p eof-value recursive-p => char
    3813     private static final Primitive READ_CHAR = new Primitive("read-char") {
     3813    private static final Primitive READ_CHAR = new Primitive("read-char","&optional input-stream eof-error-p eof-value recursive-p") {
    38143814        public LispObject execute(LispObject[] args) throws ConditionThrowable
    38153815        {
     
    38283828    // ### unread-char
    38293829    // unread-char character &optional input-stream => nil
    3830     private static final Primitive UNREAD_CHAR = new Primitive("unread-char") {
     3830    private static final Primitive UNREAD_CHAR = new Primitive("unread-char","character &optional input-stream") {
    38313831        public LispObject execute(LispObject[] args) throws ConditionThrowable
    38323832        {
     
    38933893    // ### random
    38943894    // random limit &optional random-state => random-number
    3895     private static final Primitive RANDOM = new Primitive("random") {
     3895    private static final Primitive RANDOM = new Primitive("random","limit &optional random-state") {
    38963896        public LispObject execute(LispObject[] args) throws ConditionThrowable
    38973897        {
     
    39313931    // ### make-random-state
    39323932    private static final Primitive MAKE_RANDOM_STATE =
    3933         new Primitive("make-random-state") {
     3933        new Primitive("make-random-state","&optional state") {
    39343934        public LispObject execute(LispObject[] args) throws ConditionThrowable
    39353935        {
     
    39403940
    39413941    // ### truncate
    3942     private static final Primitive TRUNCATE = new Primitive("truncate") {
     3942    private static final Primitive TRUNCATE = new Primitive("truncate","number &optional divisor") {
    39433943        public LispObject execute(LispObject[] args) throws ConditionThrowable
    39443944        {
     
    39623962    // ### expt
    39633963    // expt base-number power-number => result
    3964     public static final Primitive2 EXPT = new Primitive2("expt") {
     3964    public static final Primitive2 EXPT = new Primitive2("expt","base-number power-number") {
    39653965        public LispObject execute(LispObject n, LispObject power)
    39663966            throws ConditionThrowable
     
    40094009
    40104010    // ### list
    4011     private static final Primitive LIST = new Primitive("list") {
     4011    private static final Primitive LIST = new Primitive("list","&rest objects") {
    40124012        public LispObject execute(LispObject arg) throws ConditionThrowable
    40134013        {
     
    40344034
    40354035    // ### list*
    4036     private static final Primitive LIST_ = new Primitive("list*") {
     4036    private static final Primitive LIST_ = new Primitive("list*","&rest objects") {
    40374037        public LispObject execute() throws ConditionThrowable
    40384038        {
     
    40644064
    40654065    // ### nreverse
    4066     public static final Primitive1 NREVERSE = new Primitive1("nreverse")
     4066    public static final Primitive1 NREVERSE = new Primitive1("nreverse","sequence")
    40674067    {
    40684068        public LispObject execute (LispObject arg) throws ConditionThrowable
     
    40744074    // ### nreconc
    40754075    // From CLISP.
    4076     private static final Primitive2 NRECONC = new Primitive2("nreconc") {
     4076    private static final Primitive2 NRECONC = new Primitive2("nreconc","list tail") {
    40774077        public LispObject execute(LispObject list, LispObject obj)
    40784078            throws ConditionThrowable
     
    41074107
    41084108    // ### reverse
    4109     private static final Primitive1 REVERSE = new Primitive1("reverse")
     4109    private static final Primitive1 REVERSE = new Primitive1("reverse","sequence")
    41104110    {
    41114111        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    42874287
    42884288    // ### streamp
    4289     private static final Primitive1 STREAMP = new Primitive1("streamp") {
     4289    private static final Primitive1 STREAMP = new Primitive1("streamp","object") {
    42904290        public LispObject execute(LispObject arg)
    42914291        {
     
    42954295
    42964296    // ### integerp
    4297     private static final Primitive1 INTEGERP = new Primitive1("integerp") {
     4297    private static final Primitive1 INTEGERP = new Primitive1("integerp","object") {
    42984298        public LispObject execute(LispObject arg)
    42994299        {
     
    43034303
    43044304    // ### evenp
    4305     private static final Primitive1 EVENP = new Primitive1("evenp")
     4305    private static final Primitive1 EVENP = new Primitive1("evenp","integer")
    43064306    {
    43074307        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    43124312
    43134313    // ### oddp
    4314     private static final Primitive1 ODDP = new Primitive1("oddp")
     4314    private static final Primitive1 ODDP = new Primitive1("oddp","integer")
    43154315    {
    43164316        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    43214321
    43224322    // ### numberp
    4323     private static final Primitive1 NUMBERP = new Primitive1("numberp")
     4323    private static final Primitive1 NUMBERP = new Primitive1("numberp","object")
    43244324    {
    43254325        public LispObject execute(LispObject arg)
     
    43304330
    43314331    // ### realp
    4332     private static final Primitive1 REALP = new Primitive1("realp") {
     4332    private static final Primitive1 REALP = new Primitive1("realp","object") {
    43334333        public LispObject execute(LispObject arg)
    43344334        {
     
    43384338
    43394339    // ### rationalp
    4340     private static final Primitive1 RATIONALP = new Primitive1("rationalp") {
     4340    private static final Primitive1 RATIONALP = new Primitive1("rationalp","object") {
    43414341        public LispObject execute(LispObject arg)
    43424342        {
     
    43464346
    43474347    // ### complex
    4348     private static final Primitive2 COMPLEX = new Primitive2("complex") {
     4348    private static final Primitive2 COMPLEX = new Primitive2("complex","realpart &optional imagpart") {
    43494349        public LispObject execute(LispObject arg) throws ConditionThrowable
    43504350        {
     
    43634363
    43644364    // ### complexp
    4365     private static final Primitive1 COMPLEXP = new Primitive1("complexp") {
     4365    private static final Primitive1 COMPLEXP = new Primitive1("complexp","object") {
    43664366        public LispObject execute(LispObject arg)
    43674367        {
     
    43714371
    43724372    // ### numerator
    4373     private static final Primitive1 NUMERATOR = new Primitive1("numerator") {
     4373    private static final Primitive1 NUMERATOR = new Primitive1("numerator","rational") {
    43744374        public LispObject execute(LispObject arg) throws ConditionThrowable
    43754375        {
     
    43794379
    43804380    // ### denominator
    4381     private static final Primitive1 DENOMINATOR = new Primitive1("denominator")
     4381    private static final Primitive1 DENOMINATOR = new Primitive1("denominator","rational")
    43824382    {
    43834383        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    43884388
    43894389    // ### realpart
    4390     private static final Primitive1 REALPART = new Primitive1("realpart")
     4390    private static final Primitive1 REALPART = new Primitive1("realpart","number")
    43914391    {
    43924392        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    44014401
    44024402    // ### imagpart
    4403     private static final Primitive1 IMAGPART = new Primitive1("imagpart")
     4403    private static final Primitive1 IMAGPART = new Primitive1("imagpart","number")
    44044404    {
    44054405        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    44124412
    44134413    // ### integer-length
    4414     private static final Primitive1 INTEGER_LENGTH = new Primitive1("integer-length")
     4414    private static final Primitive1 INTEGER_LENGTH = new Primitive1("integer-length","integer")
    44154415    {
    44164416        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    44274427    };
    44284428
    4429     private static final Primitive1 COS = new Primitive1("cos")
     4429    private static final Primitive1 COS = new Primitive1("cos","radians")
    44304430    {
    44314431        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    44524452    }
    44534453
    4454     private static final Primitive1 SIN = new Primitive1("sin")
     4454    private static final Primitive1 SIN = new Primitive1("sin","radians")
    44554455    {
    44564456        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    44774477    }
    44784478
    4479     private static final Primitive1 TAN = new Primitive1("tan")
     4479    private static final Primitive1 TAN = new Primitive1("tan","radians")
    44804480    {
    44814481        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    44904490    }
    44914491
    4492     private static final Primitive1 EXP = new Primitive1("exp")
     4492    private static final Primitive1 EXP = new Primitive1("exp","number")
    44934493    {
    44944494        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    45174517    // ### sqrt
    45184518    private static final Primitive1 SQRT =
    4519         new Primitive1("sqrt") {
     4519        new Primitive1("sqrt","number") {
    45204520        public LispObject execute(LispObject arg) throws ConditionThrowable
    45214521        {
     
    45414541    }
    45424542
    4543     private static final Primitive LOG = new Primitive("log") {
     4543    private static final Primitive LOG = new Primitive("log","number &optional base") {
    45444544        public LispObject execute(LispObject arg) throws ConditionThrowable
    45454545        {
  • trunk/j/src/org/armedbear/lisp/StringInputStream.java

    r4615 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: StringInputStream.java,v 1.5 2003-11-02 19:57:53 piso Exp $
     5 * $Id: StringInputStream.java,v 1.6 2003-12-09 20:26:23 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7979    // make-string-input-stream string &optional start end => string-stream
    8080    private static final Primitive MAKE_STRING_INPUT_STREAM =
    81         new Primitive("make-string-input-stream")
     81        new Primitive("make-string-input-stream","string &optional start end")
    8282    {
    8383        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/StringOutputStream.java

    r4615 r5037  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: StringOutputStream.java,v 1.5 2003-11-02 19:57:40 piso Exp $
     5 * $Id: StringOutputStream.java,v 1.6 2003-12-09 20:26:23 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5757    // make-string-output-stream &key element-type => string-stream
    5858    private static final Primitive MAKE_STRING_OUTPUT_STREAM =
    59         new Primitive("make-string-output-stream") {
     59        new Primitive("make-string-output-stream","&key element-type") {
    6060        public LispObject execute(LispObject[] args) throws ConditionThrowable
    6161        {
     
    7070    // get-output-stream-string string-output-stream => string
    7171    private static final Primitive1 GET_OUTPUT_STREAM_STRING =
    72         new Primitive1("get-output-stream-string") {
     72        new Primitive1("get-output-stream-string","string-output-stream") {
    7373        public LispObject execute(LispObject arg) throws ConditionThrowable
    7474        {
  • trunk/j/src/org/armedbear/lisp/StructureObject.java

    r3966 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: StructureObject.java,v 1.15 2003-09-21 15:07:43 piso Exp $
     5 * $Id: StructureObject.java,v 1.16 2003-12-09 20:26:23 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    245245    // copy-structure structure => copy
    246246    private static final Primitive1 COPY_STRUCTURE =
    247         new Primitive1("copy-structure") {
     247        new Primitive1("copy-structure","structure") {
    248248        public LispObject execute(LispObject arg) throws ConditionThrowable
    249249        {
  • trunk/j/src/org/armedbear/lisp/Symbol.java

    r5009 r5037  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Symbol.java,v 1.96 2003-12-07 18:42:46 piso Exp $
     5 * $Id: Symbol.java,v 1.97 2003-12-09 20:26:23 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    453453
    454454    // ### symbol-name
    455     public static final Primitive1 SYMBOL_NAME = new Primitive1("symbol-name")
     455    public static final Primitive1 SYMBOL_NAME = new Primitive1("symbol-name","symbol")
    456456    {
    457457        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    467467
    468468    // ### symbol-package
    469     public static final Primitive1 SYMBOL_PACKAGE = new Primitive1("symbol-package")
     469    public static final Primitive1 SYMBOL_PACKAGE = new Primitive1("symbol-package","symbol")
    470470    {
    471471        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    482482
    483483    // ### symbol-function
    484     public static final Primitive1 SYMBOL_FUNCTION = new Primitive1("symbol-function")
     484    public static final Primitive1 SYMBOL_FUNCTION = new Primitive1("symbol-function","symbol")
    485485    {
    486486        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    500500
    501501    // ### symbol-plist
    502     public static final Primitive1 SYMBOL_PLIST = new Primitive1("symbol-plist")
     502    public static final Primitive1 SYMBOL_PLIST = new Primitive1("symbol-plist","symbol")
    503503    {
    504504        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    515515
    516516    // ### keywordp
    517     public static final Primitive1 KEYWORDP = new Primitive1("keywordp")
     517    public static final Primitive1 KEYWORDP = new Primitive1("keywordp","object")
    518518    {
    519519        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    528528
    529529    // ### make-symbol
    530     public static final Primitive1 MAKE_SYMBOL = new Primitive1("make-symbol")
     530    public static final Primitive1 MAKE_SYMBOL = new Primitive1("make-symbol","name")
    531531    {
    532532        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    537537
    538538    // makunbound
    539     public static final Primitive1 MAKUNBOUND = new Primitive1("makunbound")
     539    public static final Primitive1 MAKUNBOUND = new Primitive1("makunbound","symbol")
    540540    {
    541541        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/Time.java

    r4897 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: Time.java,v 1.13 2003-11-25 15:04:07 piso Exp $
     5 * $Id: Time.java,v 1.14 2003-12-09 20:26:23 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    6060    // ### get-internal-real-time
    6161    private static final Primitive0 GET_INTERNAL_REAL_TIME =
    62         new Primitive0("get-internal-real-time") {
     62        new Primitive0("get-internal-real-time","()") {
    6363        public LispObject execute() throws ConditionThrowable
    6464        {
     
    6969    // ### get-internal-run-time
    7070    private static final Primitive0 GET_INTERNAL_RUN_TIME =
    71         new Primitive0("get-internal-run-time") {
     71        new Primitive0("get-internal-run-time","()") {
    7272        public LispObject execute() throws ConditionThrowable
    7373        {
     
    7878    // ### get-universal-time
    7979    private static final Primitive0 GET_UNIVERSAL_TIME =
    80         new Primitive0("get-universal-time") {
     80        new Primitive0("get-universal-time","()") {
    8181        public LispObject execute()
    8282        {
     
    8787    // ### file-write-date
    8888    private static final Primitive1 FILE_WRITE_DATE =
    89         new Primitive1("file-write-date") {
     89        new Primitive1("file-write-date","pathspec") {
    9090        public LispObject execute(LispObject arg) throws ConditionThrowable
    9191        {
  • trunk/j/src/org/armedbear/lisp/TwoWayStream.java

    r4616 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: TwoWayStream.java,v 1.7 2003-11-02 19:58:17 piso Exp $
     5 * $Id: TwoWayStream.java,v 1.8 2003-12-09 20:26:23 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    7272    // input-stream output-stream => two-way-stream
    7373    private static final Primitive2 MAKE_TWO_WAY_STREAM =
    74         new Primitive2("make-two-way-stream") {
     74        new Primitive2("make-two-way-stream","input-stream output-stream") {
    7575        public LispObject execute(LispObject first, LispObject second)
    7676            throws ConditionThrowable
     
    8888    // two-way-stream => input-stream
    8989    private static final Primitive1 TWO_WAY_STREAM_INPUT_STREAM =
    90         new Primitive1("two-way-stream-input-stream") {
     90        new Primitive1("two-way-stream-input-stream","two-way-stream") {
    9191        public LispObject execute(LispObject arg) throws ConditionThrowable
    9292        {
     
    100100    // two-way-stream => output-stream
    101101    private static final Primitive1 TWO_WAY_STREAM_OUTPUT_STREAM =
    102         new Primitive1("two-way-stream-output-stream") {
     102        new Primitive1("two-way-stream-output-stream","two-way-stream") {
    103103        public LispObject execute(LispObject arg) throws ConditionThrowable
    104104        {
  • trunk/j/src/org/armedbear/lisp/atan.java

    r3883 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: atan.java,v 1.2 2003-09-19 01:46:42 piso Exp $
     5 * $Id: atan.java,v 1.3 2003-12-09 20:26:23 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2525{
    2626    // ### atan
    27     private static final Primitive ATAN = new Primitive("atan") {
     27    private static final Primitive ATAN = new Primitive("atan","number1 &optional number2") {
    2828        public LispObject execute(LispObject arg) throws ConditionThrowable
    2929        {
  • trunk/j/src/org/armedbear/lisp/coerce.java

    r3884 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: coerce.java,v 1.8 2003-09-19 11:50:19 piso Exp $
     5 * $Id: coerce.java,v 1.9 2003-12-09 20:26:23 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2626    // ### coerce
    2727    // coerce object result-type => result
    28     private static final Primitive2 COERCE = new Primitive2("coerce") {
     28    private static final Primitive2 COERCE = new Primitive2("coerce","object result-type") {
    2929        public LispObject execute(LispObject first, LispObject second)
    3030            throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/cxr.java

    r5004 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: cxr.java,v 1.4 2003-12-07 17:28:04 piso Exp $
     5 * $Id: cxr.java,v 1.5 2003-12-09 20:26:23 asimon 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")
     51    private static final Primitive1 CAR = new Primitive1("car","x")
    5252    {
    5353        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    5858
    5959    // ### cdr
    60     private static final Primitive1 CDR = new Primitive1("cdr")
     60    private static final Primitive1 CDR = new Primitive1("cdr","x")
    6161    {
    6262        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    6767
    6868    // ### caar
    69     private static final Primitive1 CAAR = new Primitive1("caar")
     69    private static final Primitive1 CAAR = new Primitive1("caar","x")
    7070    {
    7171        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    7676
    7777    // ### cadr
    78     private static final Primitive1 CADR = new Primitive1("cadr")
     78    private static final Primitive1 CADR = new Primitive1("cadr","x")
    7979    {
    8080        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    8585
    8686    // ### cdar
    87     private static final Primitive1 CDAR = new Primitive1("cdar")
     87    private static final Primitive1 CDAR = new Primitive1("cdar","x")
    8888    {
    8989        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    9494
    9595    // ### cddr
    96     private static final Primitive1 CDDR = new Primitive1("cddr")
     96    private static final Primitive1 CDDR = new Primitive1("cddr","x")
    9797    {
    9898        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    103103
    104104    // ### caddr
    105     private static final Primitive1 CADDR = new Primitive1("caddr")
     105    private static final Primitive1 CADDR = new Primitive1("caddr","x")
    106106    {
    107107        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    112112
    113113    // ### caadr
    114     private static final Primitive1 CAADR = new Primitive1("caadr")
     114    private static final Primitive1 CAADR = new Primitive1("caadr","x")
    115115    {
    116116        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    121121
    122122    // ### caaar
    123     private static final Primitive1 CAAAR = new Primitive1("caaar")
     123    private static final Primitive1 CAAAR = new Primitive1("caaar","x")
    124124    {
    125125        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    130130
    131131    // ### cdaar
    132     private static final Primitive1 CDAAR = new Primitive1("cdaar")
     132    private static final Primitive1 CDAAR = new Primitive1("cdaar","x")
    133133    {
    134134        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    139139
    140140    // ### cddar
    141     private static final Primitive1 CDDAR = new Primitive1("cddar")
     141    private static final Primitive1 CDDAR = new Primitive1("cddar","x")
    142142    {
    143143        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    148148
    149149    // ### cdddr
    150     private static final Primitive1 CDDDR = new Primitive1("cdddr")
     150    private static final Primitive1 CDDDR = new Primitive1("cdddr","x")
    151151    {
    152152        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    157157
    158158    // ### cadar
    159     private static final Primitive1 CADAR = new Primitive1("cadar")
     159    private static final Primitive1 CADAR = new Primitive1("cadar","x")
    160160    {
    161161        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    166166
    167167    // ### cdadr
    168     private static final Primitive1 CDADR = new Primitive1("cdadr")
     168    private static final Primitive1 CDADR = new Primitive1("cdadr","x")
    169169    {
    170170        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    175175
    176176    // ### first
    177     private static final Primitive1 FIRST = new Primitive1("first")
     177    private static final Primitive1 FIRST = new Primitive1("first","list")
    178178    {
    179179        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    184184
    185185    // ### second
    186     private static final Primitive1 SECOND = new Primitive1("second")
     186    private static final Primitive1 SECOND = new Primitive1("second","list")
    187187    {
    188188        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    193193
    194194    // ### third
    195     private static final Primitive1 THIRD = new Primitive1("third")
     195    private static final Primitive1 THIRD = new Primitive1("third","list")
    196196    {
    197197        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    202202
    203203    // ### fourth
    204     private static final Primitive1 FOURTH = new Primitive1("fourth")
     204    private static final Primitive1 FOURTH = new Primitive1("fourth","list")
    205205    {
    206206        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    211211
    212212    // ### rest
    213     private static final Primitive1 REST = new Primitive1("rest")
     213    private static final Primitive1 REST = new Primitive1("rest","list")
    214214    {
    215215        public LispObject execute(LispObject arg) throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/describe.java

    r4588 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: describe.java,v 1.9 2003-10-31 17:46:26 piso Exp $
     5 * $Id: describe.java,v 1.10 2003-12-09 20:26:23 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2626    // ### describe
    2727    // Need to support optional second argument specifying output stream.
    28     private static final Primitive DESCRIBE = new Primitive("describe") {
     28    private static final Primitive DESCRIBE = new Primitive("describe","object &optional stream") {
    2929        public LispObject execute(LispObject[] args) throws ConditionThrowable
    3030        {
  • trunk/j/src/org/armedbear/lisp/probe_file.java

    r4436 r5037  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: probe_file.java,v 1.7 2003-10-17 17:31:38 piso Exp $
     5 * $Id: probe_file.java,v 1.8 2003-12-09 20:26:23 asimon 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 = new Primitive1("probe-file")
     31    private static final Primitive1 PROBE_FILE = new Primitive1("probe-file","pathspec")
    3232    {
    3333        public LispObject execute(LispObject arg) throws ConditionThrowable
Note: See TracChangeset for help on using the changeset viewer.