RexxConstants.hpp
Go to the documentation of this file.
1
/*----------------------------------------------------------------------------*/
2
/* */
3
/* Copyright (c) 1995, 2004 IBM Corporation. All rights reserved. */
4
/* Copyright (c) 2005-2009 Rexx Language Association. All rights reserved. */
5
/* */
6
/* This program and the accompanying materials are made available under */
7
/* the terms of the Common Public License v1.0 which accompanies this */
8
/* distribution. A copy is also available at the following address: */
9
/* http://www.oorexx.org/license.html */
10
/* */
11
/* Redistribution and use in source and binary forms, with or */
12
/* without modification, are permitted provided that the following */
13
/* conditions are met: */
14
/* */
15
/* Redistributions of source code must retain the above copyright */
16
/* notice, this list of conditions and the following disclaimer. */
17
/* Redistributions in binary form must reproduce the above copyright */
18
/* notice, this list of conditions and the following disclaimer in */
19
/* the documentation and/or other materials provided with the distribution. */
20
/* */
21
/* Neither the name of Rexx Language Association nor the names */
22
/* of its contributors may be used to endorse or promote products */
23
/* derived from this software without specific prior written permission. */
24
/* */
25
/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */
26
/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */
27
/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */
28
/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */
29
/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */
30
/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */
31
/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */
32
/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */
33
/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */
34
/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */
35
/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
36
/* */
37
/*----------------------------------------------------------------------------*/
38
/******************************************************************************/
39
/* REXX Kernel RexxConstants.hpp */
40
/* */
41
/* Global Object REXX constants */
42
/* */
43
/******************************************************************************/
44
#ifndef Included_RexxConstants
45
#define Included_RexxConstants
46
/* macros for dual definition */
47
/* and external prototyping */
48
#ifdef DEFINING
49
#define CONSTCLASS
50
#define INIT
51
#define INITIAL(x) =x
52
#else
53
#define CONSTCLASS extern
54
#undef INIT
55
#define INITIAL(x)
56
#endif
57
58
#define CHARCONSTANT(name, value) CONSTCLASS char CHAR_##name[] INITIAL(value)
59
60
CHARCONSTANT
(ACTIVITY,
"ACTIVITY"
);
61
CHARCONSTANT
(ACTIVATE,
"ACTIVATE"
);
62
CHARCONSTANT
(ADD,
"ADD"
);
63
CHARCONSTANT
(ADDCLASS,
"ADDCLASS"
);
64
CHARCONSTANT
(ADDROUTINE,
"ADDROUTINE"
);
65
CHARCONSTANT
(ADDPUBLICCLASS,
"ADDPUBLICCLASS"
);
66
CHARCONSTANT
(ADDPUBLICROUTINE,
"ADDPUBLICROUTINE"
);
67
CHARCONSTANT
(ADDPACKAGE,
"ADDPACKAGE"
);
68
CHARCONSTANT
(ADDITIONAL,
"ADDITIONAL"
);
69
CHARCONSTANT
(ALLAT,
"ALLAT"
);
70
CHARCONSTANT
(ALLINDEX,
"ALLINDEX"
);
71
CHARCONSTANT
(ALLINDEXES,
"ALLINDEXES"
);
72
CHARCONSTANT
(ALLITEMS,
"ALLITEMS"
);
73
CHARCONSTANT
(
ANY
,
"ANY"
);
74
CHARCONSTANT
(APPEND,
"APPEND"
);
75
CHARCONSTANT
(ARGUMENTS,
"ARGUMENTS"
);
76
CHARCONSTANT
(ARRAY,
"ARRAY"
);
77
CHARCONSTANT
(ARGS,
"ARGS"
);
78
CHARCONSTANT
(ARRAYSYM,
"ARRAY"
);
79
CHARCONSTANT
(AT,
"AT"
);
80
CHARCONSTANT
(ATTRIBUTE,
"ATTRIBUTE"
);
81
CHARCONSTANT
(AUTO,
"AUTO"
);
82
CHARCONSTANT
(AVAILABLE,
"AVAILABLE"
);
83
CHARCONSTANT
(BAD,
"BAD"
);
84
CHARCONSTANT
(BASECLASS,
"BASECLASS"
);
85
CHARCONSTANT
(BOOLEAN,
"BOOLEAN"
);
86
CHARCONSTANT
(BLANK,
" "
);
87
CHARCONSTANT
(
BUFFER
,
"BUFFER"
);
88
CHARCONSTANT
(CALL,
"CALL"
);
89
CHARCONSTANT
(CALLWITH,
"CALLWITH"
);
90
CHARCONSTANT
(CASELESSCOMPARETO,
"CASELESSCOMPARETO"
);
91
CHARCONSTANT
(CASELESSCOMPARE,
"CASELESSCOMPARE"
);
92
CHARCONSTANT
(CASELESSEQUALS,
"CASELESSEQUALS"
);
93
CHARCONSTANT
(CASELESSLASTPOS,
"CASELESSLASTPOS"
);
94
CHARCONSTANT
(CASELESSMATCH,
"CASELESSMATCH"
);
95
CHARCONSTANT
(CASELESSMATCHCHAR,
"CASELESSMATCHCHAR"
);
96
CHARCONSTANT
(CASELESSPOS,
"CASELESSPOS"
);
97
CHARCONSTANT
(CHAR,
"CHAR"
);
98
CHARCONSTANT
(CLASS,
"CLASS"
);
99
CHARCONSTANT
(CLASSES,
"CLASSES"
);
100
CHARCONSTANT
(CLAUSER,
"CLAUSER"
);
101
CHARCONSTANT
(CLOSE,
"CLOSE"
);
102
CHARCONSTANT
(CODE,
"CODE"
);
103
CHARCONSTANT
(COMMAND,
"COMMAND"
);
104
CHARCONSTANT
(COMMANDS,
"COMMANDS"
);
105
CHARCONSTANT
(COMMON_RETRIEVERS,
"COMMON_RETRIEVERS"
);
106
CHARCONSTANT
(COMPARETO,
"COMPARETO"
);
107
CHARCONSTANT
(COMPARABLE,
"COMPARABLE"
);
108
CHARCONSTANT
(COMPLETED,
"COMPLETED"
);
109
CHARCONSTANT
(CONDITION,
"CONDITION"
);
110
CHARCONSTANT
(
CONSTANT
,
"CONSTANT"
);
111
CHARCONSTANT
(CONTEXT,
"CONTEXT"
);
112
CHARCONSTANT
(CONTINUE,
"CONTINUE"
);
113
CHARCONSTANT
(COPY,
"COPY"
);
114
CHARCONSTANT
(
CSELF
,
"CSELF"
);
115
CHARCONSTANT
(DEBUGINPUT,
"DEBUGINPUT"
);
116
CHARCONSTANT
(DECODEBASE64,
"DECODEBASE64"
);
117
CHARCONSTANT
(DEFAULTNAME,
"DEFAULTNAME"
);
118
CHARCONSTANT
(DEFINE,
"DEFINE"
);
119
CHARCONSTANT
(DEFINEDMETHODS,
"DEFINEDMETHODS"
);
120
CHARCONSTANT
(DEFINE_METHODS,
"!DEFINE_METHODS"
);
121
CHARCONSTANT
(DELAY,
"DELAY"
);
122
CHARCONSTANT
(DELETE,
"DELETE"
);
123
CHARCONSTANT
(DESCRIPTION,
"DESCRIPTION"
);
124
CHARCONSTANT
(DIMENSION,
"DIMENSION"
);
125
CHARCONSTANT
(DIRECTORY,
"DIRECTORY"
);
126
CHARCONSTANT
(DOUBLE,
"DOUBLE"
);
127
CHARCONSTANT
(EMPTY,
"EMPTY"
);
128
CHARCONSTANT
(EXTENSION,
"EXTENSION"
);
129
CHARCONSTANT
(ENCODEBASE64,
"ENCODEBASE64"
);
130
CHARCONSTANT
(ENDLOCAL,
"ENDLOCAL"
);
131
CHARCONSTANT
(ENGINEERING,
"ENGINEERING"
);
132
CHARCONSTANT
(ENHANCED,
"ENHANCED"
);
133
CHARCONSTANT
(ENTRY,
"ENTRY"
);
134
CHARCONSTANT
(ENVELOPE,
"ENVELOPE"
);
135
CHARCONSTANT
(ENVIRONMENT,
"ENVIRONMENT"
);
136
CHARCONSTANT
(ERROR,
"ERROR"
);
137
CHARCONSTANT
(EQUALS,
"EQUALS"
);
138
CHARCONSTANT
(ERRORTEXT,
"ERRORTEXT"
);
139
CHARCONSTANT
(ERRORCONDITION,
"ERRORCONDITION"
);
140
CHARCONSTANT
(EXECUTABLE,
"EXECUTABLE"
);
141
CHARCONSTANT
(EXCEPTION,
"EXCEPTION"
);
142
CHARCONSTANT
(EXIT,
"EXIT"
);
143
CHARCONSTANT
(EXMODE,
"EXMODE"
);
144
CHARCONSTANT
(EXTERNAL,
"EXTERNAL"
);
145
CHARCONSTANT
(FAILURENAME,
"FAILURE"
);
146
CHARCONSTANT
(FALSE,
"FALSE"
);
147
CHARCONSTANT
(FILE,
"FILE"
);
148
CHARCONSTANT
(FILESYSTEM,
"FILESYSTEM"
);
149
CHARCONSTANT
(FINDCLASS,
"FINDCLASS"
);
150
CHARCONSTANT
(FINDROUTINE,
"FINDROUTINE"
);
151
CHARCONSTANT
(FIRST,
"FIRST"
);
152
CHARCONSTANT
(FIRSTITEM,
"FIRSTITEM"
);
153
CHARCONSTANT
(FORWARD,
"FORWARD"
);
154
CHARCONSTANT
(FUNCTIONNAME,
"FUNCTION"
);
155
CHARCONSTANT
(FUNCTIONS,
"FUNCTIONS"
);
156
CHARCONSTANT
(GUARDED,
"GUARDED"
);
157
CHARCONSTANT
(GET,
"GET"
);
158
CHARCONSTANT
(GETBUFFERSIZE,
"GETBUFFERSIZE"
);
159
CHARCONSTANT
(GETDEFINEDMETHODS,
"GETDEFINEDMETHODS"
);
160
CHARCONSTANT
(GLOBAL_STRINGS,
"GLOBAL_STRINGS"
);
161
CHARCONSTANT
(HALT,
"HALT"
);
162
CHARCONSTANT
(HASENTRY,
"HASENTRY"
);
163
CHARCONSTANT
(HASERROR,
"HASERROR"
);
164
CHARCONSTANT
(HASINDEX,
"HASINDEX"
);
165
CHARCONSTANT
(HASITEM,
"HASITEM"
);
166
CHARCONSTANT
(HASMETHOD,
"HASMETHOD"
);
167
CHARCONSTANT
(ID,
"ID"
);
168
CHARCONSTANT
(IDENTITYTABLE,
"IDENTITYTABLE"
);
169
CHARCONSTANT
(IMPORTEDCLASSES,
"IMPORTEDCLASSES"
);
170
CHARCONSTANT
(IMPORTEDPACKAGES,
"IMPORTEDPACKAGES"
);
171
CHARCONSTANT
(IMPORTEDROUTINES,
"IMPORTEDROUTINES"
);
172
CHARCONSTANT
(INDEX,
"INDEX"
);
173
CHARCONSTANT
(INHERIT,
"INHERIT"
);
174
CHARCONSTANT
(INITINSTANCE,
"INITINSTANCE"
);
175
CHARCONSTANT
(INIT,
"INIT"
);
176
CHARCONSTANT
(INITIALADDRESS,
SYSINITIALADDRESS
);
177
CHARCONSTANT
(INPUT,
"INPUT"
);
178
CHARCONSTANT
(INSTANCEMETHOD,
"INSTANCEMETHOD"
);
179
CHARCONSTANT
(INSTANCEMETHODS,
"INSTANCEMETHODS"
);
180
CHARCONSTANT
(INSTRUCTION,
"INSTRUCTION"
);
181
CHARCONSTANT
(INTERNALNAME,
"INTERNALNAME"
);
182
CHARCONSTANT
(INTEGER,
"INTEGER"
);
183
CHARCONSTANT
(ISA,
"ISA"
);
184
CHARCONSTANT
(ISASCII,
"ISASCII"
);
185
CHARCONSTANT
(ISEMPTY,
"ISEMPTY"
);
186
CHARCONSTANT
(ISGUARDED,
"ISGUARDED"
);
187
CHARCONSTANT
(ISNULL,
"ISNULL"
);
188
CHARCONSTANT
(ISPRIVATE,
"ISPRIVATE"
);
189
CHARCONSTANT
(ISPROTECTED,
"ISPROTECTED"
);
190
CHARCONSTANT
(ISSUBCLASSOF,
"ISSUBCLASSOF"
);
191
CHARCONSTANT
(ISINSTANCEOF,
"ISINSTANCEOF"
);
192
CHARCONSTANT
(ITEM,
"ITEM"
);
193
CHARCONSTANT
(ITEMS,
"ITEMS"
);
194
CHARCONSTANT
(KERNEL,
"KERNEL"
);
195
CHARCONSTANT
(KIND,
"KIND"
);
196
CHARCONSTANT
(LAST,
"LAST"
);
197
CHARCONSTANT
(LASTITEM,
"LASTITEM"
);
198
CHARCONSTANT
(LIBRARY,
"LIBRARY"
);
199
CHARCONSTANT
(LIST,
"LIST"
);
200
CHARCONSTANT
(LIT,
"LIT"
);
201
CHARCONSTANT
(
LOCAL
,
"LOCAL"
);
202
CHARCONSTANT
(LOADPACKAGE,
"LOADPACKAGE"
);
203
CHARCONSTANT
(LOSTDIGITS,
"LOSTDIGITS"
);
204
CHARCONSTANT
(MACROSPACE,
"MACROSPACE"
);
205
CHARCONSTANT
(MAKE,
"MAKE"
);
206
CHARCONSTANT
(MAKEARRAY,
"MAKEARRAY"
);
207
CHARCONSTANT
(MAKEINTEGER,
"MAKEINTEGER"
);
208
CHARCONSTANT
(MAKESTRING,
"MAKESTRING"
);
209
CHARCONSTANT
(MAPCOLLECTION,
"MAPCOLLECTION"
);
210
CHARCONSTANT
(MATCH,
"MATCH"
);
211
CHARCONSTANT
(MATCHCHAR,
"MATCHCHAR"
);
212
CHARCONSTANT
(MEMORY,
"MEMORY"
);
213
CHARCONSTANT
(MERGE,
"MERGE"
);
214
CHARCONSTANT
(MESSAGE,
"MESSAGE"
);
215
CHARCONSTANT
(MESSAGENAME,
"MESSAGENAME"
);
216
CHARCONSTANT
(METACLASS,
"METACLASS"
);
217
CHARCONSTANT
(METHOD,
"METHOD"
);
218
CHARCONSTANT
(METHODNAME,
"METHOD"
);
219
CHARCONSTANT
(METHODS,
"METHODS"
);
220
CHARCONSTANT
(MIXINCLASS,
"MIXINCLASS"
);
221
CHARCONSTANT
(MUTABLEBUFFER,
"MUTABLEBUFFER"
);
222
CHARCONSTANT
(
NAME
,
"NAME"
);
223
CHARCONSTANT
(NAME_STRINGS,
"NAME_STRINGS"
);
224
CHARCONSTANT
(NAMED,
"NAMED"
);
225
CHARCONSTANT
(Named,
"Named"
);
226
CHARCONSTANT
(named,
"named"
);
227
CHARCONSTANT
(NAMEDARGS,
"NAMEDARGS"
);
228
CHARCONSTANT
(NAMEDARGUMENTS,
"NAMEDARGUMENTS"
);
229
CHARCONSTANT
(NEW,
"NEW"
);
230
CHARCONSTANT
(NEWFILE,
"NEWFILE"
);
231
CHARCONSTANT
(NEXT,
"NEXT"
);
232
CHARCONSTANT
(NIL,
"NIL"
);
233
CHARCONSTANT
(NMETHOD,
"NMETHOD"
);
234
CHARCONSTANT
(NOCOMMANDS,
"NOCOMMANDS"
);
235
CHARCONSTANT
(NOEXMODE,
"NOEXMODE"
);
236
CHARCONSTANT
(NOMACROSPACE,
"NOMACROSPACE"
);
237
CHARCONSTANT
(NOMETHOD,
"NOMETHOD"
);
238
CHARCONSTANT
(NONE,
"<none>"
);
239
CHARCONSTANT
(NORMAL,
"NORMAL"
);
240
CHARCONSTANT
(NOSTRING,
"NOSTRING"
);
241
CHARCONSTANT
(NOTIFY,
"NOTIFY"
);
242
CHARCONSTANT
(NOVALUE,
"NOVALUE"
);
243
CHARCONSTANT
(NULLARRAY,
"NULLARRAY"
);
244
CHARCONSTANT
(NULLPOINTER,
"NULLPOINTER"
);
245
CHARCONSTANT
(NULLSTRING,
""
);
246
CHARCONSTANT
(NUMBERSTRING,
"NUMBERSTRING"
);
247
CHARCONSTANT
(NUMERIC,
"NUMERIC"
);
248
CHARCONSTANT
(OBJECTSYM,
"OBJECT"
);
249
CHARCONSTANT
(OBJECTNAMEEQUALS,
"OBJECTNAME="
);
250
CHARCONSTANT
(OBJECTNAME,
"OBJECTNAME"
);
251
CHARCONSTANT
(OF,
"OF"
);
252
CHARCONSTANT
(OFF,
"OFF"
);
253
CHARCONSTANT
(ON,
"ON"
);
254
CHARCONSTANT
(ORDEREDCOLLECTION,
"ORDEREDCOLLECTION"
);
255
CHARCONSTANT
(OUTPUT,
"OUTPUT"
);
256
CHARCONSTANT
(PACKAGE,
"PACKAGE"
);
257
CHARCONSTANT
(PARSE,
"PARSE"
);
258
CHARCONSTANT
(PARENTCONTEXT,
"PARENTCONTEXT"
);
259
CHARCONSTANT
(PEEK,
"PEEK"
);
260
CHARCONSTANT
(PERIOD,
"."
);
261
CHARCONSTANT
(
POINTER
,
"POINTER"
);
262
CHARCONSTANT
(POSITION,
"POSITION"
);
263
CHARCONSTANT
(POSITIONAL,
"POSITIONAL"
);
264
CHARCONSTANT
(Positional,
"Positional"
);
265
CHARCONSTANT
(positional,
"positional"
);
266
CHARCONSTANT
(PREVIOUS,
"PREVIOUS"
);
267
CHARCONSTANT
(PROGRAM,
"PROGRAM"
);
268
CHARCONSTANT
(PROPAGATE,
"PROPAGATE"
);
269
CHARCONSTANT
(PROPAGATED,
"PROPAGATED"
);
270
CHARCONSTANT
(PROTECTED,
"PROTECTED"
);
271
CHARCONSTANT
(PUBLIC,
"PUBLIC"
);
272
CHARCONSTANT
(PUBLICCLASSES,
"PUBLICCLASSES"
);
273
CHARCONSTANT
(PUBLICROUTINES,
"PUBLICROUTINES"
);
274
CHARCONSTANT
(PUT,
"PUT"
);
275
CHARCONSTANT
(QUALIFY,
"QUALIFY"
);
276
CHARCONSTANT
(QUEUE,
"QUEUE"
);
277
CHARCONSTANT
(QUEUEEXIT,
"!QUEUEEXIT"
);
278
CHARCONSTANT
(QUERYMIXINCLASS,
"QUERYMIXINCLASS"
);
279
CHARCONSTANT
(QUERY,
"QUERY"
);
280
CHARCONSTANT
(RAWEXECUTABLE,
"RAWEXECUTABLE"
);
281
CHARCONSTANT
(RC,
"RC"
);
282
CHARCONSTANT
(RECLAIM,
"RECLAIM"
);
283
CHARCONSTANT
(REGISTERED,
"REGISTERED"
);
284
CHARCONSTANT
(RELATION,
"RELATION"
);
285
CHARCONSTANT
(REMOVE,
"REMOVE"
);
286
CHARCONSTANT
(REMOVEITEM,
"REMOVEITEM"
);
287
CHARCONSTANT
(REPLACEAT,
"REPLACEAT"
);
288
CHARCONSTANT
(REQUEST,
"REQUEST"
);
289
CHARCONSTANT
(REQUIRES,
"REQUIRES"
);
290
CHARCONSTANT
(RESULT,
"RESULT"
);
291
CHARCONSTANT
(REXXCONTEXT,
"REXXCONTEXT"
);
292
CHARCONSTANT
(REXXBLOCK,
"REXXBLOCK"
);
293
CHARCONSTANT
(REXXTEXT,
"REXXTEXT"
);
294
CHARCONSTANT
(REXX,
"REXX"
);
295
CHARCONSTANT
(REXXQUEUE,
"STDQUE"
);
296
CHARCONSTANT
(REXXUTIL,
"rexxutil"
);
// NB: lower case for unix
297
CHARCONSTANT
(ROUTINE,
"ROUTINE"
);
298
CHARCONSTANT
(ROUTINES,
"ROUTINES"
);
299
CHARCONSTANT
(ROUTINENAME,
"SUBROUTINE"
);
300
CHARCONSTANT
(RS,
"RS"
);
301
CHARCONSTANT
(RUN,
"RUN"
);
302
CHARCONSTANT
(RUNUNINIT,
"RUNUNINIT"
);
303
CHARCONSTANT
(RXFUNCADD,
"RXFUNCADD"
);
304
CHARCONSTANT
(RXFUNCDROP,
"RXFUNCDROP"
);
305
CHARCONSTANT
(RXFUNCQUERY,
"RXFUNCQUERY"
);
306
CHARCONSTANT
(SCIENTIFIC,
"SCIENTIFIC"
);
307
CHARCONSTANT
(SCRIPT,
"SCRIPT"
);
308
CHARCONSTANT
(SECURITYMANAGER,
"SECURITYMANAGER"
);
309
CHARCONSTANT
(SECTION,
"SECTION"
);
310
CHARCONSTANT
(SELF,
"SELF"
);
311
CHARCONSTANT
(SEND,
"SEND"
);
312
CHARCONSTANT
(SEQUENCE,
"SEQUENCE"
);
313
CHARCONSTANT
(SERVER,
"SERVER"
);
314
CHARCONSTANT
(SESSION,
"SESSION"
);
315
CHARCONSTANT
(
SET
,
"SET"
);
316
CHARCONSTANT
(SETARGS,
"SETARGS"
);
317
CHARCONSTANT
(SETBUFFERSIZE,
"SETBUFFERSIZE"
);
318
CHARCONSTANT
(SETDUMP,
"SETDUMP"
);
319
CHARCONSTANT
(SETENTRY,
"SETENTRY"
);
320
CHARCONSTANT
(SETGUARDED,
"SETGUARDED"
);
321
CHARCONSTANT
(SETINTERFACE,
"SETINTERFACE"
);
322
CHARCONSTANT
(SETLOCAL,
"SETLOCAL"
);
323
CHARCONSTANT
(SETMETHOD,
"SETMETHOD"
);
324
CHARCONSTANT
(SETPARMS,
"SETPARMS"
);
325
CHARCONSTANT
(SETPRIVATE,
"SETPRIVATE"
);
326
CHARCONSTANT
(SETPROTECTED,
"SETPROTECTED"
);
327
CHARCONSTANT
(SETSECURITYMANAGER,
"SETSECURITYMANAGER"
);
328
CHARCONSTANT
(SETUNGUARDED,
"SETUNGUARDED"
);
329
CHARCONSTANT
(SHRIEKREXXDEFINED,
"!REXXDEFINED"
);
330
CHARCONSTANT
(SHRIEK_DISPATCH,
"!DISPATCH"
);
331
CHARCONSTANT
(SIGL,
"SIGL"
);
332
CHARCONSTANT
(SIGNAL,
"SIGNAL"
);
333
CHARCONSTANT
(SIZE,
"SIZE"
);
334
CHARCONSTANT
(SORT,
"SORT"
);
335
CHARCONSTANT
(SORTWITH,
"SORTWITH"
);
336
CHARCONSTANT
(SOURCE,
"SOURCE"
);
337
CHARCONSTANT
(STABLESORT,
"STABLESORT"
);
338
CHARCONSTANT
(STABLESORTWITH,
"STABLESORTWITH"
);
339
CHARCONSTANT
(
START
,
"START"
);
340
CHARCONSTANT
(STARTAT,
"STARTAT"
);
341
CHARCONSTANT
(STATE,
"STATE"
);
342
CHARCONSTANT
(STATS,
"STATS"
);
343
CHARCONSTANT
(STDIN,
"STDIN"
);
344
CHARCONSTANT
(STDERR,
"STDERR"
);
345
CHARCONSTANT
(STDOUT,
"STDOUT"
);
346
CHARCONSTANT
(TRANSFORMSOURCE,
"TRANSFORMSOURCE"
);
347
CHARCONSTANT
(CSTDIN,
"STDIN:"
);
/* standard streams with colon */
348
CHARCONSTANT
(CSTDERR,
"STDERR:"
);
/* standard streams with colon */
349
CHARCONSTANT
(CSTDOUT,
"STDOUT:"
);
/* standard streams with colon */
350
CHARCONSTANT
(STACKFRAMES,
"STACKFRAMES"
);
351
CHARCONSTANT
(
STEM
,
"STEM"
);
352
CHARCONSTANT
(STREAMS,
"STREAMS"
);
353
CHARCONSTANT
(STRICT,
"STRICT"
);
354
CHARCONSTANT
(STRING,
"STRING"
);
355
CHARCONSTANT
(STRINGSYM,
"STRING"
);
356
CHARCONSTANT
(SUBCLASS,
"SUBCLASS"
);
357
CHARCONSTANT
(SUBCLASSES,
"SUBCLASSES"
);
358
CHARCONSTANT
(SUBROUTINE,
"SUBROUTINE"
);
359
CHARCONSTANT
(
SUPER
,
"SUPER"
);
360
CHARCONSTANT
(SUPERCLASS,
"SUPERCLASS"
);
361
CHARCONSTANT
(SUPERCLASSES,
"SUPERCLASSES"
);
362
CHARCONSTANT
(SUPPLIER,
"SUPPLIER"
);
363
CHARCONSTANT
(SYNTAX,
"SYNTAX"
);
364
CHARCONSTANT
(SYSTEM,
"SYSTEM"
);
365
CHARCONSTANT
(TABLE,
"TABLE"
);
366
CHARCONSTANT
(TARGET,
"TARGET"
);
367
CHARCONSTANT
(THREADLOCAL,
"THREADLOCAL"
);
368
CHARCONSTANT
(TOKENIZE_ONLY,
"//T"
);
369
CHARCONSTANT
(TODIRECTORY,
"TODIRECTORY"
);
370
CHARCONSTANT
(TOSTRING,
"TOSTRING"
);
371
CHARCONSTANT
(TRACEBACK,
"TRACEBACK"
);
372
CHARCONSTANT
(TRACE_is_dropped,
"is dropped"
);
373
CHARCONSTANT
(TRACEOUTPUT,
"TRACEOUTPUT"
);
374
CHARCONSTANT
(TRANSLATE,
"TRANSLATE"
);
375
CHARCONSTANT
(TRUE,
"TRUE"
);
376
CHARCONSTANT
(UNGUARDED,
"UNGUARDED"
);
377
CHARCONSTANT
(UNINHERIT,
"UNINHERIT"
);
378
CHARCONSTANT
(UNINIT,
"UNINIT"
);
379
CHARCONSTANT
(UNKNOWN,
"UNKNOWN"
);
380
CHARCONSTANT
(UNKNOWNDISABLED,
"UNKNOWNDISABLED"
);
381
CHARCONSTANT
(UNPACK,
"UNPACK"
);
382
CHARCONSTANT
(UNPROTECTED,
"UNPROTECTED"
);
383
CHARCONSTANT
(UNSETMETHOD,
"UNSETMETHOD"
);
384
CHARCONSTANT
(USER_BLANK,
"USER "
);
385
CHARCONSTANT
(USERID,
"USERID"
);
386
CHARCONSTANT
(VALUES,
"VALUES"
);
387
CHARCONSTANT
(VAR,
"VAR"
);
388
CHARCONSTANT
(VARIABLE,
"VARIABLE"
);
389
CHARCONSTANT
(VARIABLES,
"VARIABLES"
);
390
CHARCONSTANT
(VERSION,
"VERSION"
);
391
CHARCONSTANT
(WEAKREFERENCE,
"WEAKREFERENCE"
);
392
393
394
/* Language operators */
395
396
CHARCONSTANT
(AND,
"&"
);
397
CHARCONSTANT
(ASSIGNMENT_AND,
"&="
);
398
CHARCONSTANT
(BACKSLASH,
"\\"
);
399
CHARCONSTANT
(BACKSLASH_EQUAL,
"\\="
);
400
CHARCONSTANT
(BACKSLASH_GREATERTHAN,
"\\>"
);
401
CHARCONSTANT
(BACKSLASH_LESSTHAN,
"\\<"
);
402
CHARCONSTANT
(TILDE_ROUND_BRACKETS,
"~()"
);
403
CHARCONSTANT
(ROUND_BRACKETS,
"()"
);
404
CHARCONSTANT
(BRACKETS,
"[]"
);
405
CHARCONSTANT
(BRACKETSEQUAL,
"[]="
);
406
CHARCONSTANT
(CONCATENATE,
"||"
);
407
CHARCONSTANT
(ASSIGNMENT_CONCATENATE,
"||="
);
408
CHARCONSTANT
(DIVIDE,
"/"
);
409
CHARCONSTANT
(ASSIGNMENT_DIVIDE,
"/="
);
410
CHARCONSTANT
(EQUAL,
"="
);
411
CHARCONSTANT
(GREATERTHAN,
">"
);
412
CHARCONSTANT
(GREATERTHAN_EQUAL,
">="
);
413
CHARCONSTANT
(GREATERTHAN_LESSTHAN,
"><"
);
414
CHARCONSTANT
(INTDIV,
"%"
);
415
CHARCONSTANT
(ASSIGNMENT_INTDIV,
"%="
);
416
CHARCONSTANT
(LESSTHAN,
"<"
);
417
CHARCONSTANT
(LESSTHAN_EQUAL,
"<="
);
418
CHARCONSTANT
(LESSTHAN_GREATERTHAN,
"<>"
);
419
CHARCONSTANT
(MULTIPLY,
"*"
);
420
CHARCONSTANT
(ASSIGNMENT_MULTIPLY,
"*="
);
421
CHARCONSTANT
(OR,
"|"
);
422
CHARCONSTANT
(ASSIGNMENT_OR,
"|="
);
423
CHARCONSTANT
(PLUS,
"+"
);
424
CHARCONSTANT
(ASSIGNMENT_PLUS,
"+="
);
425
CHARCONSTANT
(POWER,
"**"
);
426
CHARCONSTANT
(ASSIGNMENT_POWER,
"**="
);
427
CHARCONSTANT
(REMAINDER,
"//"
);
428
CHARCONSTANT
(ASSIGNMENT_REMAINDER,
"//="
);
429
CHARCONSTANT
(STRICT_BACKSLASH_EQUAL,
"\\=="
);
430
CHARCONSTANT
(STRICT_BACKSLASH_GREATERTHAN,
"\\>>"
);
431
CHARCONSTANT
(STRICT_BACKSLASH_LESSTHAN,
"\\<<"
);
432
CHARCONSTANT
(STRICT_EQUAL,
"=="
);
433
CHARCONSTANT
(STRICT_GREATERTHAN,
">>"
);
434
CHARCONSTANT
(STRICT_GREATERTHAN_EQUAL,
">>="
);
435
CHARCONSTANT
(STRICT_LESSTHAN,
"<<"
);
436
CHARCONSTANT
(STRICT_LESSTHAN_EQUAL,
"<<="
);
437
CHARCONSTANT
(SUBTRACT,
"-"
);
438
CHARCONSTANT
(ASSIGNMENT_SUBTRACT,
"-="
);
439
CHARCONSTANT
(XOR,
"&&"
);
440
CHARCONSTANT
(ASSIGNMENT_XOR,
"&&="
);
441
CHARCONSTANT
(ELLIPSIS,
"..."
);
442
443
444
/* Alternative operators */
445
446
CHARCONSTANT
(AND_RIGHT,
"&OP:RIGHT"
);
447
CHARCONSTANT
(BACKSLASH_RIGHT,
"\\OP:RIGHT"
);
448
CHARCONSTANT
(BACKSLASH_EQUAL_RIGHT,
"\\=OP:RIGHT"
);
449
CHARCONSTANT
(BACKSLASH_GREATERTHAN_RIGHT,
"\\>OP:RIGHT"
);
450
CHARCONSTANT
(BACKSLASH_LESSTHAN_RIGHT,
"\\<OP:RIGHT"
);
451
CHARCONSTANT
(BLANK_RIGHT,
" OP:RIGHT"
);
452
CHARCONSTANT
(CONCATENATE_RIGHT,
"||OP:RIGHT"
);
453
CHARCONSTANT
(DIVIDE_RIGHT,
"/OP:RIGHT"
);
454
CHARCONSTANT
(EQUAL_RIGHT,
"=OP:RIGHT"
);
455
CHARCONSTANT
(GREATERTHAN_RIGHT,
">OP:RIGHT"
);
456
CHARCONSTANT
(GREATERTHAN_EQUAL_RIGHT,
">=OP:RIGHT"
);
457
CHARCONSTANT
(GREATERTHAN_LESSTHAN_RIGHT,
"><OP:RIGHT"
);
458
CHARCONSTANT
(INTDIV_RIGHT,
"%OP:RIGHT"
);
459
CHARCONSTANT
(LESSTHAN_RIGHT,
"<OP:RIGHT"
);
460
CHARCONSTANT
(LESSTHAN_EQUAL_RIGHT,
"<=OP:RIGHT"
);
461
CHARCONSTANT
(LESSTHAN_GREATERTHAN_RIGHT,
"<>OP:RIGHT"
);
462
CHARCONSTANT
(MULTIPLY_RIGHT,
"*OP:RIGHT"
);
463
CHARCONSTANT
(NULLSTRING_RIGHT,
"OP:RIGHT"
);
464
CHARCONSTANT
(OR_RIGHT,
"|OP:RIGHT"
);
465
CHARCONSTANT
(PLUS_LEFT,
"+OP:LEFT"
);
466
CHARCONSTANT
(PLUS_RIGHT,
"+OP:RIGHT"
);
467
CHARCONSTANT
(POWER_RIGHT,
"**OP:RIGHT"
);
468
CHARCONSTANT
(REMAINDER_RIGHT,
"//OP:RIGHT"
);
469
CHARCONSTANT
(STRICT_BACKSLASH_EQUAL_RIGHT,
"\\==OP:RIGHT"
);
470
CHARCONSTANT
(STRICT_BACKSLASH_GREATERTHAN_RIGHT,
"\\>>OP:RIGHT"
);
471
CHARCONSTANT
(STRICT_BACKSLASH_LESSTHAN_RIGHT,
"\\<<OP:RIGHT"
);
472
CHARCONSTANT
(STRICT_EQUAL_RIGHT,
"==OP:RIGHT"
);
473
CHARCONSTANT
(STRICT_GREATERTHAN_RIGHT,
">>OP:RIGHT"
);
474
CHARCONSTANT
(STRICT_GREATERTHAN_EQUAL_RIGHT,
">>=OP:RIGHT"
);
475
CHARCONSTANT
(STRICT_LESSTHAN_RIGHT,
"<<OP:RIGHT"
);
476
CHARCONSTANT
(STRICT_LESSTHAN_EQUAL_RIGHT,
"<<=OP:RIGHT"
);
477
CHARCONSTANT
(SUBTRACT_LEFT,
"-OP:LEFT"
);
478
CHARCONSTANT
(SUBTRACT_RIGHT,
"-OP:RIGHT"
);
479
CHARCONSTANT
(XOR_RIGHT,
"&&OP:RIGHT"
);
480
481
/*now names for the builtin functions */
482
CHARCONSTANT
(ABBREV,
"ABBREV"
);
483
CHARCONSTANT
(CASELESSABBREV,
"CASELESSABBREV"
);
484
CHARCONSTANT
(ABS,
"ABS"
);
485
CHARCONSTANT
(ABSTRACT,
"ABSTRACT"
);
486
CHARCONSTANT
(ADDRESS,
"ADDRESS"
);
487
CHARCONSTANT
(ARG,
"ARG"
);
488
CHARCONSTANT
(B2X,
"B2X"
);
489
CHARCONSTANT
(BITAND,
"BITAND"
);
490
CHARCONSTANT
(BITOR,
"BITOR"
);
491
CHARCONSTANT
(BITXOR,
"BITXOR"
);
492
CHARCONSTANT
(C2D,
"C2D"
);
493
CHARCONSTANT
(C2X,
"C2X"
);
494
CHARCONSTANT
(CENTER,
"CENTER"
);
495
CHARCONSTANT
(CENTRE,
"CENTRE"
);
496
CHARCONSTANT
(CHANGESTR,
"CHANGESTR"
);
497
CHARCONSTANT
(CASELESSCHANGESTR,
"CASELESSCHANGESTR"
);
498
CHARCONSTANT
(CHARIN,
"CHARIN"
);
499
CHARCONSTANT
(CHAROUT,
"CHAROUT"
);
500
CHARCONSTANT
(CHARS,
"CHARS"
);
501
CHARCONSTANT
(COMPARE,
"COMPARE"
);
502
CHARCONSTANT
(COPIES,
"COPIES"
);
503
CHARCONSTANT
(COUNTSTR,
"COUNTSTR"
);
504
CHARCONSTANT
(CASELESSCOUNTSTR,
"CASELESSCOUNTSTR"
);
505
CHARCONSTANT
(D2C,
"D2C"
);
506
CHARCONSTANT
(D2X,
"D2X"
);
507
CHARCONSTANT
(DATATYPE,
"DATATYPE"
);
508
CHARCONSTANT
(DATE,
"DATE"
);
509
CHARCONSTANT
(DELSTR,
"DELSTR"
);
510
CHARCONSTANT
(DELWORD,
"DELWORD"
);
511
CHARCONSTANT
(DIGITS,
"DIGITS"
);
512
CHARCONSTANT
(FORM,
"FORM"
);
513
CHARCONSTANT
(FORMAT,
"FORMAT"
);
514
CHARCONSTANT
(FUZZ,
"FUZZ"
);
515
CHARCONSTANT
(HASHCODE,
"HASHCODE"
);
516
CHARCONSTANT
(IDENTITYHASH,
"IDENTITYHASH"
);
517
CHARCONSTANT
(INSERT,
"INSERT"
);
518
CHARCONSTANT
(LASTPOS,
"LASTPOS"
);
519
CHARCONSTANT
(LEFT,
"LEFT"
);
520
CHARCONSTANT
(LENGTH,
"LENGTH"
);
521
CHARCONSTANT
(LINEIN,
"LINEIN"
);
522
CHARCONSTANT
(LINEOUT,
"LINEOUT"
);
523
CHARCONSTANT
(LINES,
"LINES"
);
524
CHARCONSTANT
(LINE,
"LINE"
);
525
CHARCONSTANT
(ORXMAX,
"MAX"
);
526
CHARCONSTANT
(ORXMIN,
"MIN"
);
527
CHARCONSTANT
(OVERLAY,
"OVERLAY"
);
528
CHARCONSTANT
(POS,
"POS"
);
529
CHARCONSTANT
(QUEUED,
"QUEUED"
);
530
CHARCONSTANT
(RANDOM,
"RANDOM"
);
531
CHARCONSTANT
(REVERSE,
"REVERSE"
);
532
CHARCONSTANT
(RIGHT,
"RIGHT"
);
533
CHARCONSTANT
(SAY,
"SAY"
);
534
CHARCONSTANT
(SIGN,
"SIGN"
);
535
CHARCONSTANT
(SOURCELINE,
"SOURCELINE"
);
536
CHARCONSTANT
(SOURCESIZE,
"SOURCESIZE"
);
537
CHARCONSTANT
(SPACE,
"SPACE"
);
538
CHARCONSTANT
(STREAM,
"STREAM"
);
539
CHARCONSTANT
(STRIP,
"STRIP"
);
540
CHARCONSTANT
(SUBCHAR,
"SUBCHAR"
);
541
CHARCONSTANT
(SUBSTR,
"SUBSTR"
);
542
CHARCONSTANT
(SUBWORD,
"SUBWORD"
);
543
CHARCONSTANT
(SYMBOL,
"SYMBOL"
);
544
CHARCONSTANT
(TIME,
"TIME"
);
545
CHARCONSTANT
(TRACE,
"TRACE"
);
546
CHARCONSTANT
(TRUNC,
"TRUNC"
);
547
CHARCONSTANT
(VALUE,
"VALUE"
);
548
CHARCONSTANT
(VERIFY,
"VERIFY"
);
549
CHARCONSTANT
(WORD,
"WORD"
);
550
CHARCONSTANT
(WORDINDEX,
"WORDINDEX"
);
551
CHARCONSTANT
(WORDLENGTH,
"WORDLENGTH"
);
552
CHARCONSTANT
(WORDPOS,
"WORDPOS"
);
553
CHARCONSTANT
(CASELESSWORDPOS,
"CASELESSWORDPOS"
);
554
CHARCONSTANT
(WORDS,
"WORDS"
);
555
CHARCONSTANT
(X2B,
"X2B"
);
556
CHARCONSTANT
(X2C,
"X2C"
);
557
CHARCONSTANT
(X2D,
"X2D"
);
558
CHARCONSTANT
(XRANGE,
"XRANGE"
);
559
560
561
562
/* Now KEYWORD string constants */
563
564
CHARCONSTANT
(BY,
"BY"
);
565
CHARCONSTANT
(
CASELESS
,
"CASELESS"
);
566
CHARCONSTANT
(DO,
"DO"
);
567
CHARCONSTANT
(DROP,
"DROP"
);
568
CHARCONSTANT
(ELSE,
"ELSE"
);
569
CHARCONSTANT
(END,
"END"
);
570
CHARCONSTANT
(EXPOSE,
"EXPOSE"
);
571
CHARCONSTANT
(FAILURE,
"FAILURE"
);
572
CHARCONSTANT
(FOR,
"FOR"
);
573
CHARCONSTANT
(FOREVER,
"FOREVER"
);
574
CHARCONSTANT
(GUARD,
"GUARD"
);
575
CHARCONSTANT
(IF,
"IF"
);
576
CHARCONSTANT
(
INTERPRET
,
"INTERPRET"
);
577
CHARCONSTANT
(ITERATE,
"ITERATE"
);
578
CHARCONSTANT
(PULL,
"PULL"
);
579
CHARCONSTANT
(PUSH,
"PUSH"
);
580
CHARCONSTANT
(LABEL,
"LABEL"
);
581
CHARCONSTANT
(LEAVE,
"LEAVE"
);
582
CHARCONSTANT
(LOOP,
"LOOP"
);
583
CHARCONSTANT
(LOWER,
"LOWER"
);
584
CHARCONSTANT
(NOP,
"NOP"
);
585
CHARCONSTANT
(NOTREADY,
"NOTREADY"
);
586
CHARCONSTANT
(OBJECT,
"OBJECT"
);
587
CHARCONSTANT
(OPTIONS,
"OPTIONS"
);
588
CHARCONSTANT
(OTHERWISE,
"OTHERWISE"
);
589
CHARCONSTANT
(OVER,
"OVER"
);
590
CHARCONSTANT
(PRIVATE,
"PRIVATE"
);
591
CHARCONSTANT
(PROCEDURE,
"PROCEDURE"
);
592
CHARCONSTANT
(RAISE,
"RAISE"
);
593
CHARCONSTANT
(REPLY,
"REPLY"
);
594
CHARCONSTANT
(RETURN,
"RETURN"
);
595
CHARCONSTANT
(SELECT,
"SELECT"
);
596
CHARCONSTANT
(THEN,
"THEN"
);
597
CHARCONSTANT
(TO,
"TO"
);
598
CHARCONSTANT
(UNTIL,
"UNTIL"
);
599
CHARCONSTANT
(UPPER,
"UPPER"
);
600
CHARCONSTANT
(USE,
"USE"
);
601
CHARCONSTANT
(USER,
"USER"
);
602
CHARCONSTANT
(WHEN,
"WHEN"
);
603
CHARCONSTANT
(WHILE,
"WHILE"
);
604
CHARCONSTANT
(WITH,
"WITH"
);
605
606
CHARCONSTANT
(ZERO,
"0"
);
607
608
CHARCONSTANT
(SIGTERM,
"SIGTERM"
);
609
CHARCONSTANT
(SIGINT,
"SIGINT"
);
610
CHARCONSTANT
(SIGHUP,
"SIGHUP"
);
611
612
CHARCONSTANT
(PUBLIC_ROUTINES,
"PUBLIC_ROUTINES"
);
/* Name for the directory that holds public routines */
613
#endif
INTERPRET
#define INTERPRET
Definition:
RexxActivation.hpp:147
CHARCONSTANT
#define CHARCONSTANT(name, value)
Definition:
RexxConstants.hpp:58
START
@ START
Definition:
RexxMisc.cpp:60
CONSTANT
#define CONSTANT
Definition:
cmdparse.cpp:104
STEM
#define STEM
Definition:
cmdparse.cpp:107
BUFFER
void * BUFFER
Definition:
oorexxapi.h:4330
CSELF
void * CSELF
Definition:
oorexxapi.h:4329
SUPER
RexxClassObject SUPER
Definition:
oorexxapi.h:4333
NAME
CSTRING NAME
Definition:
oorexxapi.h:4334
SET
#define SET
Definition:
regexp.hpp:48
ANY
#define ANY
Definition:
regexp.hpp:47
POINTER
void * POINTER
Definition:
rexx.h:79
SYSINITIALADDRESS
#define SYSINITIALADDRESS
Definition:
unix/PlatformDefinitions.h:122
CASELESS
#define CASELESS
Definition:
unix/rexxutil.cpp:369
LOCAL
#define LOCAL
Definition:
windows/rexxutil.cpp:211
oorexx
executor
sandbox
jlf
trunk
interpreter
runtime
RexxConstants.hpp
Generated by
1.9.2
1.9.2