tests/gpgscm/opdefines.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205

_OP_DEF(OP_LOAD,                "load",                           1,  1,       TST_STRING                        )
_OP_DEF(OP_T0LVL,               0,                                0,  0,       0                                 )
_OP_DEF(OP_T1LVL,               0,                                0,  0,       0                                 )
_OP_DEF(OP_READ_INTERNAL,       0,                                0,  0,       0                                 )
_OP_DEF(OP_GENSYM,              "gensym",                         0,  0,       0                                 )
_OP_DEF(OP_VALUEPRINT,          0,                                0,  0,       0                                 )
_OP_DEF(OP_EVAL,                0,                                0,  0,       0                                 )
#if USE_TRACING
_OP_DEF(OP_REAL_EVAL,           0,                                0,  0,       0                                 )
#endif
_OP_DEF(OP_E0ARGS,              0,                                0,  0,       0                                 )
_OP_DEF(OP_E1ARGS,              0,                                0,  0,       0                                 )
#if USE_HISTORY
_OP_DEF(OP_CALLSTACK_POP,       0,                                0,  0,       0                                 )
#endif
_OP_DEF(OP_APPLY_CODE,          0,                                0,  0,       0                                 )
_OP_DEF(OP_APPLY,               0,                                0,  0,       0                                 )
#if USE_TRACING
_OP_DEF(OP_REAL_APPLY,          0,                                0,  0,       0                                 )
_OP_DEF(OP_TRACING,             "tracing",                        1,  1,       TST_NATURAL                       )
#endif
_OP_DEF(OP_DOMACRO,             0,                                0,  0,       0                                 )
_OP_DEF(OP_LAMBDA,              0,                                0,  0,       0                                 )
_OP_DEF(OP_LAMBDA1,             0,                                0,  0,       0                                 )
_OP_DEF(OP_MKCLOSURE,           "make-closure",                   1,  2,       TST_PAIR, TST_ENVIRONMENT         )
_OP_DEF(OP_QUOTE,               0,                                0,  0,       0                                 )
_OP_DEF(OP_DEF0,                0,                                0,  0,       0                                 )
_OP_DEF(OP_DEF1,                0,                                0,  0,       0                                 )
_OP_DEF(OP_DEFP,                "defined?",                       1,  2,       TST_SYMBOL, TST_ENVIRONMENT       )
_OP_DEF(OP_BEGIN,               0,                                0,  0,       0                                 )
_OP_DEF(OP_IF0,                 0,                                0,  0,       0                                 )
_OP_DEF(OP_IF1,                 0,                                0,  0,       0                                 )
_OP_DEF(OP_SET0,                0,                                0,  0,       0                                 )
_OP_DEF(OP_SET1,                0,                                0,  0,       0                                 )
_OP_DEF(OP_LET0,                0,                                0,  0,       0                                 )
_OP_DEF(OP_LET1,                0,                                0,  0,       0                                 )
_OP_DEF(OP_LET2,                0,                                0,  0,       0                                 )
_OP_DEF(OP_LET0AST,             0,                                0,  0,       0                                 )
_OP_DEF(OP_LET1AST,             0,                                0,  0,       0                                 )
_OP_DEF(OP_LET2AST,             0,                                0,  0,       0                                 )
_OP_DEF(OP_LET0REC,             0,                                0,  0,       0                                 )
_OP_DEF(OP_LET1REC,             0,                                0,  0,       0                                 )
_OP_DEF(OP_LET2REC,             0,                                0,  0,       0                                 )
_OP_DEF(OP_COND0,               0,                                0,  0,       0                                 )
_OP_DEF(OP_COND1,               0,                                0,  0,       0                                 )
_OP_DEF(OP_DELAY,               0,                                0,  0,       0                                 )
_OP_DEF(OP_AND0,                0,                                0,  0,       0                                 )
_OP_DEF(OP_AND1,                0,                                0,  0,       0                                 )
_OP_DEF(OP_OR0,                 0,                                0,  0,       0                                 )
_OP_DEF(OP_OR1,                 0,                                0,  0,       0                                 )
_OP_DEF(OP_C0STREAM,            0,                                0,  0,       0                                 )
_OP_DEF(OP_C1STREAM,            0,                                0,  0,       0                                 )
_OP_DEF(OP_MACRO0,              0,                                0,  0,       0                                 )
_OP_DEF(OP_MACRO1,              0,                                0,  0,       0                                 )
_OP_DEF(OP_CASE0,               0,                                0,  0,       0                                 )
_OP_DEF(OP_CASE1,               0,                                0,  0,       0                                 )
_OP_DEF(OP_CASE2,               0,                                0,  0,       0                                 )
_OP_DEF(OP_PEVAL,               "eval",                           1,  2,       TST_ANY, TST_ENVIRONMENT          )
_OP_DEF(OP_PAPPLY,              "apply",                          1,  INF_ARG, TST_NONE                          )
_OP_DEF(OP_CONTINUATION,        "call-with-current-continuation", 1,  1,       TST_NONE                          )
#if USE_MATH
_OP_DEF(OP_INEX2EX,             "inexact->exact",                 1,  1,       TST_NUMBER                        )
_OP_DEF(OP_EXP,                 "exp",                            1,  1,       TST_NUMBER                        )
_OP_DEF(OP_LOG,                 "log",                            1,  1,       TST_NUMBER                        )
_OP_DEF(OP_SIN,                 "sin",                            1,  1,       TST_NUMBER                        )
_OP_DEF(OP_COS,                 "cos",                            1,  1,       TST_NUMBER                        )
_OP_DEF(OP_TAN,                 "tan",                            1,  1,       TST_NUMBER                        )
_OP_DEF(OP_ASIN,                "asin",                           1,  1,       TST_NUMBER                        )
_OP_DEF(OP_ACOS,                "acos",                           1,  1,       TST_NUMBER                        )
_OP_DEF(OP_ATAN,                "atan",                           1,  2,       TST_NUMBER                        )
_OP_DEF(OP_SQRT,                "sqrt",                           1,  1,       TST_NUMBER                        )
_OP_DEF(OP_EXPT,                "expt",                           2,  2,       TST_NUMBER                        )
_OP_DEF(OP_FLOOR,               "floor",                          1,  1,       TST_NUMBER                        )
_OP_DEF(OP_CEILING,             "ceiling",                        1,  1,       TST_NUMBER                        )
_OP_DEF(OP_TRUNCATE,            "truncate",                       1,  1,       TST_NUMBER                        )
_OP_DEF(OP_ROUND,               "round",                          1,  1,       TST_NUMBER                        )
#endif
_OP_DEF(OP_ADD,                 "+",                              0,  INF_ARG, TST_NUMBER                        )
_OP_DEF(OP_SUB,                 "-",                              1,  INF_ARG, TST_NUMBER                        )
_OP_DEF(OP_MUL,                 "*",                              0,  INF_ARG, TST_NUMBER                        )
_OP_DEF(OP_DIV,                 "/",                              1,  INF_ARG, TST_NUMBER                        )
_OP_DEF(OP_INTDIV,              "quotient",                       1,  INF_ARG, TST_INTEGER                       )
_OP_DEF(OP_REM,                 "remainder",                      2,  2,       TST_INTEGER                       )
_OP_DEF(OP_MOD,                 "modulo",                         2,  2,       TST_INTEGER                       )
_OP_DEF(OP_CAR,                 "car",                            1,  1,       TST_PAIR                          )
_OP_DEF(OP_CDR,                 "cdr",                            1,  1,       TST_PAIR                          )
_OP_DEF(OP_CONS,                "cons",                           2,  2,       TST_NONE                          )
_OP_DEF(OP_SETCAR,              "set-car!",                       2,  2,       TST_PAIR, TST_ANY                 )
_OP_DEF(OP_SETCDR,              "set-cdr!",                       2,  2,       TST_PAIR, TST_ANY                 )
_OP_DEF(OP_CHAR2INT,            "char->integer",                  1,  1,       TST_CHAR                          )
_OP_DEF(OP_INT2CHAR,            "integer->char",                  1,  1,       TST_NATURAL                       )
_OP_DEF(OP_CHARUPCASE,          "char-upcase",                    1,  1,       TST_CHAR                          )
_OP_DEF(OP_CHARDNCASE,          "char-downcase",                  1,  1,       TST_CHAR                          )
_OP_DEF(OP_SYM2STR,             "symbol->string",                 1,  1,       TST_SYMBOL                        )
_OP_DEF(OP_ATOM2STR,            "atom->string",                   1,  2,       TST_ANY, TST_NATURAL              )
_OP_DEF(OP_STR2SYM,             "string->symbol",                 1,  1,       TST_STRING                        )
_OP_DEF(OP_STR2ATOM,            "string->atom",                   1,  2,       TST_STRING, TST_NATURAL           )
_OP_DEF(OP_MKSTRING,            "make-string",                    1,  2,       TST_NATURAL, TST_CHAR             )
_OP_DEF(OP_STRLEN,              "string-length",                  1,  1,       TST_STRING                        )
_OP_DEF(OP_STRREF,              "string-ref",                     2,  2,       TST_STRING, TST_NATURAL           )
_OP_DEF(OP_STRSET,              "string-set!",                    3,  3,       TST_STRING, TST_NATURAL, TST_CHAR )
_OP_DEF(OP_STRAPPEND,           "string-append",                  0,  INF_ARG, TST_STRING                        )
_OP_DEF(OP_SUBSTR,              "substring",                      2,  3,       TST_STRING, TST_NATURAL           )
_OP_DEF(OP_VECTOR,              "vector",                         0,  INF_ARG, TST_NONE                          )
_OP_DEF(OP_MKVECTOR,            "make-vector",                    1,  2,       TST_NATURAL, TST_ANY              )
_OP_DEF(OP_VECLEN,              "vector-length",                  1,  1,       TST_VECTOR                        )
_OP_DEF(OP_VECREF,              "vector-ref",                     2,  2,       TST_VECTOR, TST_NATURAL           )
_OP_DEF(OP_VECSET,              "vector-set!",                    3,  3,       TST_VECTOR, TST_NATURAL, TST_ANY  )
_OP_DEF(OP_NOT,                 "not",                            1,  1,       TST_NONE                          )
_OP_DEF(OP_BOOLP,               "boolean?",                       1,  1,       TST_NONE                          )
_OP_DEF(OP_EOFOBJP,             "eof-object?",                    1,  1,       TST_NONE                          )
_OP_DEF(OP_NULLP,               "null?",                          1,  1,       TST_NONE                          )
_OP_DEF(OP_NUMEQ,               "=",                              2,  INF_ARG, TST_NUMBER                        )
_OP_DEF(OP_LESS,                "<",                              2,  INF_ARG, TST_NUMBER                        )
_OP_DEF(OP_GRE,                 ">",                              2,  INF_ARG, TST_NUMBER                        )
_OP_DEF(OP_LEQ,                 "<=",                             2,  INF_ARG, TST_NUMBER                        )
_OP_DEF(OP_GEQ,                 ">=",                             2,  INF_ARG, TST_NUMBER                        )
_OP_DEF(OP_SYMBOLP,             "symbol?",                        1,  1,       TST_ANY                           )
_OP_DEF(OP_NUMBERP,             "number?",                        1,  1,       TST_ANY                           )
_OP_DEF(OP_STRINGP,             "string?",                        1,  1,       TST_ANY                           )
_OP_DEF(OP_INTEGERP,            "integer?",                       1,  1,       TST_ANY                           )
_OP_DEF(OP_REALP,               "real?",                          1,  1,       TST_ANY                           )
_OP_DEF(OP_CHARP,               "char?",                          1,  1,       TST_ANY                           )
#if USE_CHAR_CLASSIFIERS
_OP_DEF(OP_CHARAP,              "char-alphabetic?",               1,  1,       TST_CHAR                          )
_OP_DEF(OP_CHARNP,              "char-numeric?",                  1,  1,       TST_CHAR                          )
_OP_DEF(OP_CHARWP,              "char-whitespace?",               1,  1,       TST_CHAR                          )
_OP_DEF(OP_CHARUP,              "char-upper-case?",               1,  1,       TST_CHAR                          )
_OP_DEF(OP_CHARLP,              "char-lower-case?",               1,  1,       TST_CHAR                          )
#endif
_OP_DEF(OP_PORTP,               "port?",                          1,  1,       TST_ANY                           )
_OP_DEF(OP_INPORTP,             "input-port?",                    1,  1,       TST_ANY                           )
_OP_DEF(OP_OUTPORTP,            "output-port?",                   1,  1,       TST_ANY                           )
_OP_DEF(OP_PROCP,               "procedure?",                     1,  1,       TST_ANY                           )
_OP_DEF(OP_PAIRP,               "pair?",                          1,  1,       TST_ANY                           )
_OP_DEF(OP_LISTP,               "list?",                          1,  1,       TST_ANY                           )
_OP_DEF(OP_ENVP,                "environment?",                   1,  1,       TST_ANY                           )
_OP_DEF(OP_VECTORP,             "vector?",                        1,  1,       TST_ANY                           )
_OP_DEF(OP_EQ,                  "eq?",                            2,  2,       TST_ANY                           )
_OP_DEF(OP_EQV,                 "eqv?",                           2,  2,       TST_ANY                           )
_OP_DEF(OP_FORCE,               "force",                          1,  1,       TST_ANY                           )
_OP_DEF(OP_SAVE_FORCED,         0,                                0,  0,       0                                 )
_OP_DEF(OP_WRITE,               "write",                          1,  2,       TST_ANY, TST_OUTPORT              )
_OP_DEF(OP_WRITE_CHAR,          "write-char",                     1,  2,       TST_CHAR, TST_OUTPORT             )
_OP_DEF(OP_DISPLAY,             "display",                        1,  2,       TST_ANY, TST_OUTPORT              )
_OP_DEF(OP_NEWLINE,             "newline",                        0,  1,       TST_OUTPORT                       )
_OP_DEF(OP_ERR0,                "error",                          1,  INF_ARG, TST_NONE                          )
_OP_DEF(OP_ERR1,                0,                                0,  0,       0                                 )
_OP_DEF(OP_REVERSE,             "reverse",                        1,  1,       TST_LIST                          )
_OP_DEF(OP_REVERSE_IN_PLACE,    "reverse!",                       1,  1,       TST_LIST                          )
_OP_DEF(OP_LIST_STAR,           "list*",                          1,  INF_ARG, TST_NONE                          )
_OP_DEF(OP_APPEND,              "append",                         0,  INF_ARG, TST_NONE                          )
#if USE_PLIST
_OP_DEF(OP_SET_SYMBOL_PROPERTY, "set-symbol-property!",           3,  3,       TST_SYMBOL, TST_SYMBOL, TST_ANY   )
_OP_DEF(OP_SYMBOL_PROPERTY,     "symbol-property",                2,  2,       TST_SYMBOL, TST_SYMBOL            )
#endif
_OP_DEF(OP_TAG_VALUE,           0,                                0,  0,       TST_NONE                          )
_OP_DEF(OP_MK_TAGGED,           "make-tagged-value",              2,  2,       TST_ANY, TST_PAIR                 )
_OP_DEF(OP_GET_TAG,             "get-tag",                        1,  1,       TST_ANY                           )
_OP_DEF(OP_QUIT,                "quit",                           0,  1,       TST_NUMBER                        )
_OP_DEF(OP_GC,                  "gc",                             0,  0,       0                                 )
_OP_DEF(OP_GCVERB,              "gc-verbose",                     0,  1,       TST_NONE                          )
_OP_DEF(OP_NEWSEGMENT,          "new-segment",                    0,  1,       TST_NUMBER                        )
_OP_DEF(OP_OBLIST,              "oblist",                         0,  0,       0                                 )
_OP_DEF(OP_CURR_INPORT,         "current-input-port",             0,  0,       0                                 )
_OP_DEF(OP_CURR_OUTPORT,        "current-output-port",            0,  0,       0                                 )
_OP_DEF(OP_OPEN_INFILE,         "open-input-file",                1,  1,       TST_STRING                        )
_OP_DEF(OP_OPEN_OUTFILE,        "open-output-file",               1,  1,       TST_STRING                        )
_OP_DEF(OP_OPEN_INOUTFILE,      "open-input-output-file",         1,  1,       TST_STRING                        )
#if USE_STRING_PORTS
_OP_DEF(OP_OPEN_INSTRING,       "open-input-string",              1,  1,       TST_STRING                        )
_OP_DEF(OP_OPEN_INOUTSTRING,    "open-input-output-string",       1,  1,       TST_STRING                        )
_OP_DEF(OP_OPEN_OUTSTRING,      "open-output-string",             0,  1,       TST_STRING                        )
_OP_DEF(OP_GET_OUTSTRING,       "get-output-string",              1,  1,       TST_OUTPORT                       )
#endif
_OP_DEF(OP_CLOSE_INPORT,        "close-input-port",               1,  1,       TST_INPORT                        )
_OP_DEF(OP_CLOSE_OUTPORT,       "close-output-port",              1,  1,       TST_OUTPORT                       )
_OP_DEF(OP_INT_ENV,             "interaction-environment",        0,  0,       0                                 )
_OP_DEF(OP_CURR_ENV,            "current-environment",            0,  0,       0                                 )
_OP_DEF(OP_READ,                "read",                           0,  1,       TST_INPORT                        )
_OP_DEF(OP_READ_CHAR,           "read-char",                      0,  1,       TST_INPORT                        )
_OP_DEF(OP_PEEK_CHAR,           "peek-char",                      0,  1,       TST_INPORT                        )
_OP_DEF(OP_CHAR_READY,          "char-ready?",                    0,  1,       TST_INPORT                        )
_OP_DEF(OP_SET_INPORT,          "set-input-port",                 1,  1,       TST_INPORT                        )
_OP_DEF(OP_SET_OUTPORT,         "set-output-port",                1,  1,       TST_OUTPORT                       )
_OP_DEF(OP_RDSEXPR,             0,                                0,  0,       0                                 )
_OP_DEF(OP_RDLIST,              0,                                0,  0,       0                                 )
_OP_DEF(OP_RDDOT,               0,                                0,  0,       0                                 )
_OP_DEF(OP_RDQUOTE,             0,                                0,  0,       0                                 )
_OP_DEF(OP_RDQQUOTE,            0,                                0,  0,       0                                 )
_OP_DEF(OP_RDQQUOTEVEC,         0,                                0,  0,       0                                 )
_OP_DEF(OP_RDUNQUOTE,           0,                                0,  0,       0                                 )
_OP_DEF(OP_RDUQTSP,             0,                                0,  0,       0                                 )
_OP_DEF(OP_RDVEC,               0,                                0,  0,       0                                 )
_OP_DEF(OP_P0LIST,              0,                                0,  0,       0                                 )
_OP_DEF(OP_P1LIST,              0,                                0,  0,       0                                 )
_OP_DEF(OP_PVECFROM,            0,                                0,  0,       0                                 )
_OP_DEF(OP_LIST_LENGTH,         "length",                         1,  1,       TST_LIST                          )
_OP_DEF(OP_ASSQ,                "assq",                           2,  2,       TST_NONE                          )
_OP_DEF(OP_GET_CLOSURE,         "get-closure-code",               1,  1,       TST_NONE                          )
_OP_DEF(OP_CLOSUREP,            "closure?",                       1,  1,       TST_NONE                          )
_OP_DEF(OP_MACROP,              "macro?",                         1,  1,       TST_NONE                          )
_OP_DEF(OP_VM_HISTORY,          "*vm-history*",                   0,  0,       TST_NONE                          )

#undef _OP_DEF