RexxConstants.hpp File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	CONSTCLASS   extern
#define	INITIAL(x)
#define	CHARCONSTANT(name, value)   CONSTCLASS char CHAR_##name[] INITIAL(value)

Functions
	CHARCONSTANT (ACTIVITY, "ACTIVITY")
	CHARCONSTANT (ACTIVATE, "ACTIVATE")
	CHARCONSTANT (ADD, "ADD")
	CHARCONSTANT (ADDCLASS, "ADDCLASS")
	CHARCONSTANT (ADDROUTINE, "ADDROUTINE")
	CHARCONSTANT (ADDPUBLICCLASS, "ADDPUBLICCLASS")
	CHARCONSTANT (ADDPUBLICROUTINE, "ADDPUBLICROUTINE")
	CHARCONSTANT (ADDPACKAGE, "ADDPACKAGE")
	CHARCONSTANT (ADDITIONAL, "ADDITIONAL")
	CHARCONSTANT (ALLAT, "ALLAT")
	CHARCONSTANT (ALLINDEX, "ALLINDEX")
	CHARCONSTANT (ALLINDEXES, "ALLINDEXES")
	CHARCONSTANT (ALLITEMS, "ALLITEMS")
	CHARCONSTANT (ANY, "ANY")
	CHARCONSTANT (APPEND, "APPEND")
	CHARCONSTANT (ARGUMENTS, "ARGUMENTS")
	CHARCONSTANT (ARRAY, "ARRAY")
	CHARCONSTANT (ARGS, "ARGS")
	CHARCONSTANT (ARRAYSYM, "ARRAY")
	CHARCONSTANT (AT, "AT")
	CHARCONSTANT (ATTRIBUTE, "ATTRIBUTE")
	CHARCONSTANT (AUTO, "AUTO")
	CHARCONSTANT (AVAILABLE, "AVAILABLE")
	CHARCONSTANT (BAD, "BAD")
	CHARCONSTANT (BASECLASS, "BASECLASS")
	CHARCONSTANT (BOOLEAN, "BOOLEAN")
	CHARCONSTANT (BLANK, " ")
	CHARCONSTANT (BUFFER, "BUFFER")
	CHARCONSTANT (CALL, "CALL")
	CHARCONSTANT (CALLWITH, "CALLWITH")
	CHARCONSTANT (CASELESSCOMPARETO, "CASELESSCOMPARETO")
	CHARCONSTANT (CASELESSCOMPARE, "CASELESSCOMPARE")
	CHARCONSTANT (CASELESSEQUALS, "CASELESSEQUALS")
	CHARCONSTANT (CASELESSLASTPOS, "CASELESSLASTPOS")
	CHARCONSTANT (CASELESSMATCH, "CASELESSMATCH")
	CHARCONSTANT (CASELESSMATCHCHAR, "CASELESSMATCHCHAR")
	CHARCONSTANT (CASELESSPOS, "CASELESSPOS")
	CHARCONSTANT (CHAR, "CHAR")
	CHARCONSTANT (CLASS, "CLASS")
	CHARCONSTANT (CLASSES, "CLASSES")
	CHARCONSTANT (CLAUSER, "CLAUSER")
	CHARCONSTANT (CLOSE, "CLOSE")
	CHARCONSTANT (CODE, "CODE")
	CHARCONSTANT (COMMAND, "COMMAND")
	CHARCONSTANT (COMMANDS, "COMMANDS")
	CHARCONSTANT (COMMON_RETRIEVERS, "COMMON_RETRIEVERS")
	CHARCONSTANT (COMPARETO, "COMPARETO")
	CHARCONSTANT (COMPARABLE, "COMPARABLE")
	CHARCONSTANT (COMPLETED, "COMPLETED")
	CHARCONSTANT (CONDITION, "CONDITION")
	CHARCONSTANT (CONSTANT, "CONSTANT")
	CHARCONSTANT (CONTEXT, "CONTEXT")
	CHARCONSTANT (CONTINUE, "CONTINUE")
	CHARCONSTANT (COPY, "COPY")
	CHARCONSTANT (DEBUGINPUT, "DEBUGINPUT")
	CHARCONSTANT (DECODEBASE64, "DECODEBASE64")
	CHARCONSTANT (DEFAULTNAME, "DEFAULTNAME")
	CHARCONSTANT (DEFINE, "DEFINE")
	CHARCONSTANT (DEFINEDMETHODS, "DEFINEDMETHODS")
	CHARCONSTANT (DEFINE_METHODS, "!DEFINE_METHODS")
	CHARCONSTANT (DELAY, "DELAY")
	CHARCONSTANT (DELETE, "DELETE")
	CHARCONSTANT (DESCRIPTION, "DESCRIPTION")
	CHARCONSTANT (DIMENSION, "DIMENSION")
	CHARCONSTANT (DIRECTORY, "DIRECTORY")
	CHARCONSTANT (DOUBLE, "DOUBLE")
	CHARCONSTANT (EMPTY, "EMPTY")
	CHARCONSTANT (EXTENSION, "EXTENSION")
	CHARCONSTANT (ENCODEBASE64, "ENCODEBASE64")
	CHARCONSTANT (ENDLOCAL, "ENDLOCAL")
	CHARCONSTANT (ENGINEERING, "ENGINEERING")
	CHARCONSTANT (ENHANCED, "ENHANCED")
	CHARCONSTANT (ENTRY, "ENTRY")
	CHARCONSTANT (ENVELOPE, "ENVELOPE")
	CHARCONSTANT (ENVIRONMENT, "ENVIRONMENT")
	CHARCONSTANT (ERROR, "ERROR")
	CHARCONSTANT (EQUALS, "EQUALS")
	CHARCONSTANT (ERRORTEXT, "ERRORTEXT")
	CHARCONSTANT (ERRORCONDITION, "ERRORCONDITION")
	CHARCONSTANT (EXECUTABLE, "EXECUTABLE")
	CHARCONSTANT (EXCEPTION, "EXCEPTION")
	CHARCONSTANT (EXIT, "EXIT")
	CHARCONSTANT (EXMODE, "EXMODE")
	CHARCONSTANT (EXTERNAL, "EXTERNAL")
	CHARCONSTANT (FAILURENAME, "FAILURE")
	CHARCONSTANT (FALSE, "FALSE")
	CHARCONSTANT (FILE, "FILE")
	CHARCONSTANT (FILESYSTEM, "FILESYSTEM")
	CHARCONSTANT (FINDCLASS, "FINDCLASS")
	CHARCONSTANT (FINDROUTINE, "FINDROUTINE")
	CHARCONSTANT (FIRST, "FIRST")
	CHARCONSTANT (FIRSTITEM, "FIRSTITEM")
	CHARCONSTANT (FORWARD, "FORWARD")
	CHARCONSTANT (FUNCTIONNAME, "FUNCTION")
	CHARCONSTANT (FUNCTIONS, "FUNCTIONS")
	CHARCONSTANT (GUARDED, "GUARDED")
	CHARCONSTANT (GET, "GET")
	CHARCONSTANT (GETBUFFERSIZE, "GETBUFFERSIZE")
	CHARCONSTANT (GETDEFINEDMETHODS, "GETDEFINEDMETHODS")
	CHARCONSTANT (GLOBAL_STRINGS, "GLOBAL_STRINGS")
	CHARCONSTANT (HALT, "HALT")
	CHARCONSTANT (HASENTRY, "HASENTRY")
	CHARCONSTANT (HASERROR, "HASERROR")
	CHARCONSTANT (HASINDEX, "HASINDEX")
	CHARCONSTANT (HASITEM, "HASITEM")
	CHARCONSTANT (HASMETHOD, "HASMETHOD")
	CHARCONSTANT (ID, "ID")
	CHARCONSTANT (IDENTITYTABLE, "IDENTITYTABLE")
	CHARCONSTANT (IMPORTEDCLASSES, "IMPORTEDCLASSES")
	CHARCONSTANT (IMPORTEDPACKAGES, "IMPORTEDPACKAGES")
	CHARCONSTANT (IMPORTEDROUTINES, "IMPORTEDROUTINES")
	CHARCONSTANT (INDEX, "INDEX")
	CHARCONSTANT (INHERIT, "INHERIT")
	CHARCONSTANT (INITINSTANCE, "INITINSTANCE")
	CHARCONSTANT (INIT, "INIT")
	CHARCONSTANT (INITIALADDRESS, SYSINITIALADDRESS)
	CHARCONSTANT (INPUT, "INPUT")
	CHARCONSTANT (INSTANCEMETHOD, "INSTANCEMETHOD")
	CHARCONSTANT (INSTANCEMETHODS, "INSTANCEMETHODS")
	CHARCONSTANT (INSTRUCTION, "INSTRUCTION")
	CHARCONSTANT (INTERNALNAME, "INTERNALNAME")
	CHARCONSTANT (INTEGER, "INTEGER")
	CHARCONSTANT (ISA, "ISA")
	CHARCONSTANT (ISASCII, "ISASCII")
	CHARCONSTANT (ISEMPTY, "ISEMPTY")
	CHARCONSTANT (ISGUARDED, "ISGUARDED")
	CHARCONSTANT (ISNULL, "ISNULL")
	CHARCONSTANT (ISPRIVATE, "ISPRIVATE")
	CHARCONSTANT (ISPROTECTED, "ISPROTECTED")
	CHARCONSTANT (ISSUBCLASSOF, "ISSUBCLASSOF")
	CHARCONSTANT (ISINSTANCEOF, "ISINSTANCEOF")
	CHARCONSTANT (ITEM, "ITEM")
	CHARCONSTANT (ITEMS, "ITEMS")
	CHARCONSTANT (KERNEL, "KERNEL")
	CHARCONSTANT (KIND, "KIND")
	CHARCONSTANT (LAST, "LAST")
	CHARCONSTANT (LASTITEM, "LASTITEM")
	CHARCONSTANT (LIBRARY, "LIBRARY")
	CHARCONSTANT (LIST, "LIST")
	CHARCONSTANT (LIT, "LIT")
	CHARCONSTANT (LOCAL, "LOCAL")
	CHARCONSTANT (LOADPACKAGE, "LOADPACKAGE")
	CHARCONSTANT (LOSTDIGITS, "LOSTDIGITS")
	CHARCONSTANT (MACROSPACE, "MACROSPACE")
	CHARCONSTANT (MAKE, "MAKE")
	CHARCONSTANT (MAKEARRAY, "MAKEARRAY")
	CHARCONSTANT (MAKEINTEGER, "MAKEINTEGER")
	CHARCONSTANT (MAKESTRING, "MAKESTRING")
	CHARCONSTANT (MAPCOLLECTION, "MAPCOLLECTION")
	CHARCONSTANT (MATCH, "MATCH")
	CHARCONSTANT (MATCHCHAR, "MATCHCHAR")
	CHARCONSTANT (MEMORY, "MEMORY")
	CHARCONSTANT (MERGE, "MERGE")
	CHARCONSTANT (MESSAGE, "MESSAGE")
	CHARCONSTANT (MESSAGENAME, "MESSAGENAME")
	CHARCONSTANT (METACLASS, "METACLASS")
	CHARCONSTANT (METHOD, "METHOD")
	CHARCONSTANT (METHODNAME, "METHOD")
	CHARCONSTANT (METHODS, "METHODS")
	CHARCONSTANT (MIXINCLASS, "MIXINCLASS")
	CHARCONSTANT (MUTABLEBUFFER, "MUTABLEBUFFER")
	CHARCONSTANT (NAME, "NAME")
	CHARCONSTANT (NAME_STRINGS, "NAME_STRINGS")
	CHARCONSTANT (NAMED, "NAMED")
	CHARCONSTANT (Named, "Named")
	CHARCONSTANT (named, "named")
	CHARCONSTANT (NAMEDARGS, "NAMEDARGS")
	CHARCONSTANT (NAMEDARGUMENTS, "NAMEDARGUMENTS")
	CHARCONSTANT (NEW, "NEW")
	CHARCONSTANT (NEWFILE, "NEWFILE")
	CHARCONSTANT (NEXT, "NEXT")
	CHARCONSTANT (NIL, "NIL")
	CHARCONSTANT (NMETHOD, "NMETHOD")
	CHARCONSTANT (NOCOMMANDS, "NOCOMMANDS")
	CHARCONSTANT (NOEXMODE, "NOEXMODE")
	CHARCONSTANT (NOMACROSPACE, "NOMACROSPACE")
	CHARCONSTANT (NOMETHOD, "NOMETHOD")
	CHARCONSTANT (NONE, "<none>")
	CHARCONSTANT (NORMAL, "NORMAL")
	CHARCONSTANT (NOSTRING, "NOSTRING")
	CHARCONSTANT (NOTIFY, "NOTIFY")
	CHARCONSTANT (NOVALUE, "NOVALUE")
	CHARCONSTANT (NULLARRAY, "NULLARRAY")
	CHARCONSTANT (NULLPOINTER, "NULLPOINTER")
	CHARCONSTANT (NULLSTRING, "")
	CHARCONSTANT (NUMBERSTRING, "NUMBERSTRING")
	CHARCONSTANT (NUMERIC, "NUMERIC")
	CHARCONSTANT (OBJECTSYM, "OBJECT")
	CHARCONSTANT (OBJECTNAMEEQUALS, "OBJECTNAME=")
	CHARCONSTANT (OBJECTNAME, "OBJECTNAME")
	CHARCONSTANT (OF, "OF")
	CHARCONSTANT (OFF, "OFF")
	CHARCONSTANT (ON, "ON")
	CHARCONSTANT (ORDEREDCOLLECTION, "ORDEREDCOLLECTION")
	CHARCONSTANT (OUTPUT, "OUTPUT")
	CHARCONSTANT (PACKAGE, "PACKAGE")
	CHARCONSTANT (PARSE, "PARSE")
	CHARCONSTANT (PARENTCONTEXT, "PARENTCONTEXT")
	CHARCONSTANT (PEEK, "PEEK")
	CHARCONSTANT (PERIOD, ".")
	CHARCONSTANT (POSITION, "POSITION")
	CHARCONSTANT (POSITIONAL, "POSITIONAL")
	CHARCONSTANT (Positional, "Positional")
	CHARCONSTANT (positional, "positional")
	CHARCONSTANT (PREVIOUS, "PREVIOUS")
	CHARCONSTANT (PROGRAM, "PROGRAM")
	CHARCONSTANT (PROPAGATE, "PROPAGATE")
	CHARCONSTANT (PROPAGATED, "PROPAGATED")
	CHARCONSTANT (PROTECTED, "PROTECTED")
	CHARCONSTANT (PUBLIC, "PUBLIC")
	CHARCONSTANT (PUBLICCLASSES, "PUBLICCLASSES")
	CHARCONSTANT (PUBLICROUTINES, "PUBLICROUTINES")
	CHARCONSTANT (PUT, "PUT")
	CHARCONSTANT (QUALIFY, "QUALIFY")
	CHARCONSTANT (QUEUE, "QUEUE")
	CHARCONSTANT (QUEUEEXIT, "!QUEUEEXIT")
	CHARCONSTANT (QUERYMIXINCLASS, "QUERYMIXINCLASS")
	CHARCONSTANT (QUERY, "QUERY")
	CHARCONSTANT (RAWEXECUTABLE, "RAWEXECUTABLE")
	CHARCONSTANT (RC, "RC")
	CHARCONSTANT (RECLAIM, "RECLAIM")
	CHARCONSTANT (REGISTERED, "REGISTERED")
	CHARCONSTANT (RELATION, "RELATION")
	CHARCONSTANT (REMOVE, "REMOVE")
	CHARCONSTANT (REMOVEITEM, "REMOVEITEM")
	CHARCONSTANT (REPLACEAT, "REPLACEAT")
	CHARCONSTANT (REQUEST, "REQUEST")
	CHARCONSTANT (REQUIRES, "REQUIRES")
	CHARCONSTANT (RESULT, "RESULT")
	CHARCONSTANT (REXXCONTEXT, "REXXCONTEXT")
	CHARCONSTANT (REXXBLOCK, "REXXBLOCK")
	CHARCONSTANT (REXXTEXT, "REXXTEXT")
	CHARCONSTANT (REXX, "REXX")
	CHARCONSTANT (REXXQUEUE, "STDQUE")
	CHARCONSTANT (REXXUTIL, "rexxutil")
	CHARCONSTANT (ROUTINE, "ROUTINE")
	CHARCONSTANT (ROUTINES, "ROUTINES")
	CHARCONSTANT (ROUTINENAME, "SUBROUTINE")
	CHARCONSTANT (RS, "RS")
	CHARCONSTANT (RUN, "RUN")
	CHARCONSTANT (RUNUNINIT, "RUNUNINIT")
	CHARCONSTANT (RXFUNCADD, "RXFUNCADD")
	CHARCONSTANT (RXFUNCDROP, "RXFUNCDROP")
	CHARCONSTANT (RXFUNCQUERY, "RXFUNCQUERY")
	CHARCONSTANT (SCIENTIFIC, "SCIENTIFIC")
	CHARCONSTANT (SCRIPT, "SCRIPT")
	CHARCONSTANT (SECURITYMANAGER, "SECURITYMANAGER")
	CHARCONSTANT (SECTION, "SECTION")
	CHARCONSTANT (SELF, "SELF")
	CHARCONSTANT (SEND, "SEND")
	CHARCONSTANT (SEQUENCE, "SEQUENCE")
	CHARCONSTANT (SERVER, "SERVER")
	CHARCONSTANT (SESSION, "SESSION")
	CHARCONSTANT (SET, "SET")
	CHARCONSTANT (SETARGS, "SETARGS")
	CHARCONSTANT (SETBUFFERSIZE, "SETBUFFERSIZE")
	CHARCONSTANT (SETDUMP, "SETDUMP")
	CHARCONSTANT (SETENTRY, "SETENTRY")
	CHARCONSTANT (SETGUARDED, "SETGUARDED")
	CHARCONSTANT (SETINTERFACE, "SETINTERFACE")
	CHARCONSTANT (SETLOCAL, "SETLOCAL")
	CHARCONSTANT (SETMETHOD, "SETMETHOD")
	CHARCONSTANT (SETPARMS, "SETPARMS")
	CHARCONSTANT (SETPRIVATE, "SETPRIVATE")
	CHARCONSTANT (SETPROTECTED, "SETPROTECTED")
	CHARCONSTANT (SETSECURITYMANAGER, "SETSECURITYMANAGER")
	CHARCONSTANT (SETUNGUARDED, "SETUNGUARDED")
	CHARCONSTANT (SHRIEKREXXDEFINED, "!REXXDEFINED")
	CHARCONSTANT (SHRIEK_DISPATCH, "!DISPATCH")
	CHARCONSTANT (SIGL, "SIGL")
	CHARCONSTANT (SIGNAL, "SIGNAL")
	CHARCONSTANT (SIZE, "SIZE")
	CHARCONSTANT (SORT, "SORT")
	CHARCONSTANT (SORTWITH, "SORTWITH")
	CHARCONSTANT (SOURCE, "SOURCE")
	CHARCONSTANT (STABLESORT, "STABLESORT")
	CHARCONSTANT (STABLESORTWITH, "STABLESORTWITH")
	CHARCONSTANT (START, "START")
	CHARCONSTANT (STARTAT, "STARTAT")
	CHARCONSTANT (STATE, "STATE")
	CHARCONSTANT (STATS, "STATS")
	CHARCONSTANT (STDIN, "STDIN")
	CHARCONSTANT (STDERR, "STDERR")
	CHARCONSTANT (STDOUT, "STDOUT")
	CHARCONSTANT (TRANSFORMSOURCE, "TRANSFORMSOURCE")
	CHARCONSTANT (CSTDIN, "STDIN:")
	CHARCONSTANT (CSTDERR, "STDERR:")
	CHARCONSTANT (CSTDOUT, "STDOUT:")
	CHARCONSTANT (STACKFRAMES, "STACKFRAMES")
	CHARCONSTANT (STEM, "STEM")
	CHARCONSTANT (STREAMS, "STREAMS")
	CHARCONSTANT (STRICT, "STRICT")
	CHARCONSTANT (STRING, "STRING")
	CHARCONSTANT (STRINGSYM, "STRING")
	CHARCONSTANT (SUBCLASS, "SUBCLASS")
	CHARCONSTANT (SUBCLASSES, "SUBCLASSES")
	CHARCONSTANT (SUBROUTINE, "SUBROUTINE")
	CHARCONSTANT (SUPER, "SUPER")
	CHARCONSTANT (SUPERCLASS, "SUPERCLASS")
	CHARCONSTANT (SUPERCLASSES, "SUPERCLASSES")
	CHARCONSTANT (SUPPLIER, "SUPPLIER")
	CHARCONSTANT (SYNTAX, "SYNTAX")
	CHARCONSTANT (SYSTEM, "SYSTEM")
	CHARCONSTANT (TABLE, "TABLE")
	CHARCONSTANT (TARGET, "TARGET")
	CHARCONSTANT (THREADLOCAL, "THREADLOCAL")
	CHARCONSTANT (TOKENIZE_ONLY, "//T")
	CHARCONSTANT (TODIRECTORY, "TODIRECTORY")
	CHARCONSTANT (TOSTRING, "TOSTRING")
	CHARCONSTANT (TRACEBACK, "TRACEBACK")
	CHARCONSTANT (TRACE_is_dropped, "is dropped")
	CHARCONSTANT (TRACEOUTPUT, "TRACEOUTPUT")
	CHARCONSTANT (TRANSLATE, "TRANSLATE")
	CHARCONSTANT (TRUE, "TRUE")
	CHARCONSTANT (UNGUARDED, "UNGUARDED")
	CHARCONSTANT (UNINHERIT, "UNINHERIT")
	CHARCONSTANT (UNINIT, "UNINIT")
	CHARCONSTANT (UNKNOWN, "UNKNOWN")
	CHARCONSTANT (UNKNOWNDISABLED, "UNKNOWNDISABLED")
	CHARCONSTANT (UNPACK, "UNPACK")
	CHARCONSTANT (UNPROTECTED, "UNPROTECTED")
	CHARCONSTANT (UNSETMETHOD, "UNSETMETHOD")
	CHARCONSTANT (USER_BLANK, "USER ")
	CHARCONSTANT (USERID, "USERID")
	CHARCONSTANT (VALUES, "VALUES")
	CHARCONSTANT (VAR, "VAR")
	CHARCONSTANT (VARIABLE, "VARIABLE")
	CHARCONSTANT (VARIABLES, "VARIABLES")
	CHARCONSTANT (VERSION, "VERSION")
	CHARCONSTANT (WEAKREFERENCE, "WEAKREFERENCE")
	CHARCONSTANT (AND, "&")
	CHARCONSTANT (ASSIGNMENT_AND, "&=")
	CHARCONSTANT (BACKSLASH, "\\")
	CHARCONSTANT (BACKSLASH_EQUAL, "\\=")
	CHARCONSTANT (BACKSLASH_GREATERTHAN, "\>")
	CHARCONSTANT (BACKSLASH_LESSTHAN, "\<")
	CHARCONSTANT (TILDE_ROUND_BRACKETS, "~()")
	CHARCONSTANT (ROUND_BRACKETS, "()")
	CHARCONSTANT (BRACKETS, "[]")
	CHARCONSTANT (BRACKETSEQUAL, "[]=")
	CHARCONSTANT (CONCATENATE, "||")
	CHARCONSTANT (ASSIGNMENT_CONCATENATE, "||=")
	CHARCONSTANT (DIVIDE, "/")
	CHARCONSTANT (ASSIGNMENT_DIVIDE, "/=")
	CHARCONSTANT (EQUAL, "=")
	CHARCONSTANT (GREATERTHAN, ">")
	CHARCONSTANT (GREATERTHAN_EQUAL, ">=")
	CHARCONSTANT (GREATERTHAN_LESSTHAN, "><")
	CHARCONSTANT (INTDIV, "%")
	CHARCONSTANT (ASSIGNMENT_INTDIV, "%=")
	CHARCONSTANT (LESSTHAN, "<")
	CHARCONSTANT (LESSTHAN_EQUAL, "<=")
	CHARCONSTANT (LESSTHAN_GREATERTHAN, "<>")
	CHARCONSTANT (MULTIPLY, "*")
	CHARCONSTANT (ASSIGNMENT_MULTIPLY, "*=")
	CHARCONSTANT (OR, "|")
	CHARCONSTANT (ASSIGNMENT_OR, "|=")
	CHARCONSTANT (PLUS, "+")
	CHARCONSTANT (ASSIGNMENT_PLUS, "+=")
	CHARCONSTANT (POWER, "**")
	CHARCONSTANT (ASSIGNMENT_POWER, "**=")
	CHARCONSTANT (REMAINDER, "//")
	CHARCONSTANT (ASSIGNMENT_REMAINDER, "//=")
	CHARCONSTANT (STRICT_BACKSLASH_EQUAL, "\\==")
	CHARCONSTANT (STRICT_BACKSLASH_GREATERTHAN, "\>>")
	CHARCONSTANT (STRICT_BACKSLASH_LESSTHAN, "\<<")
	CHARCONSTANT (STRICT_EQUAL, "==")
	CHARCONSTANT (STRICT_GREATERTHAN, ">>")
	CHARCONSTANT (STRICT_GREATERTHAN_EQUAL, ">>=")
	CHARCONSTANT (STRICT_LESSTHAN, "<<")
	CHARCONSTANT (STRICT_LESSTHAN_EQUAL, "<<=")
	CHARCONSTANT (SUBTRACT, "-")
	CHARCONSTANT (ASSIGNMENT_SUBTRACT, "-=")
	CHARCONSTANT (XOR, "&&")
	CHARCONSTANT (ASSIGNMENT_XOR, "&&=")
	CHARCONSTANT (ELLIPSIS, "...")
	CHARCONSTANT (AND_RIGHT, "&OP:RIGHT")
	CHARCONSTANT (BACKSLASH_RIGHT, "\\OP:RIGHT")
	CHARCONSTANT (BACKSLASH_EQUAL_RIGHT, "\\=OP:RIGHT")
	CHARCONSTANT (BACKSLASH_GREATERTHAN_RIGHT, "\>OP:RIGHT")
	CHARCONSTANT (BACKSLASH_LESSTHAN_RIGHT, "\<OP:RIGHT")
	CHARCONSTANT (BLANK_RIGHT, " OP:RIGHT")
	CHARCONSTANT (CONCATENATE_RIGHT, "||OP:RIGHT")
	CHARCONSTANT (DIVIDE_RIGHT, "/OP:RIGHT")
	CHARCONSTANT (EQUAL_RIGHT, "=OP:RIGHT")
	CHARCONSTANT (GREATERTHAN_RIGHT, ">OP:RIGHT")
	CHARCONSTANT (GREATERTHAN_EQUAL_RIGHT, ">=OP:RIGHT")
	CHARCONSTANT (GREATERTHAN_LESSTHAN_RIGHT, "><OP:RIGHT")
	CHARCONSTANT (INTDIV_RIGHT, "%OP:RIGHT")
	CHARCONSTANT (LESSTHAN_RIGHT, "<OP:RIGHT")
	CHARCONSTANT (LESSTHAN_EQUAL_RIGHT, "<=OP:RIGHT")
	CHARCONSTANT (LESSTHAN_GREATERTHAN_RIGHT, "<>OP:RIGHT")
	CHARCONSTANT (MULTIPLY_RIGHT, "*OP:RIGHT")
	CHARCONSTANT (NULLSTRING_RIGHT, "OP:RIGHT")
	CHARCONSTANT (OR_RIGHT, "|OP:RIGHT")
	CHARCONSTANT (PLUS_LEFT, "+OP:LEFT")
	CHARCONSTANT (PLUS_RIGHT, "+OP:RIGHT")
	CHARCONSTANT (POWER_RIGHT, "**OP:RIGHT")
	CHARCONSTANT (REMAINDER_RIGHT, "//OP:RIGHT")
	CHARCONSTANT (STRICT_BACKSLASH_EQUAL_RIGHT, "\\==OP:RIGHT")
	CHARCONSTANT (STRICT_BACKSLASH_GREATERTHAN_RIGHT, "\>>OP:RIGHT")
	CHARCONSTANT (STRICT_BACKSLASH_LESSTHAN_RIGHT, "\<<OP:RIGHT")
	CHARCONSTANT (STRICT_EQUAL_RIGHT, "==OP:RIGHT")
	CHARCONSTANT (STRICT_GREATERTHAN_RIGHT, ">>OP:RIGHT")
	CHARCONSTANT (STRICT_GREATERTHAN_EQUAL_RIGHT, ">>=OP:RIGHT")
	CHARCONSTANT (STRICT_LESSTHAN_RIGHT, "<<OP:RIGHT")
	CHARCONSTANT (STRICT_LESSTHAN_EQUAL_RIGHT, "<<=OP:RIGHT")
	CHARCONSTANT (SUBTRACT_LEFT, "-OP:LEFT")
	CHARCONSTANT (SUBTRACT_RIGHT, "-OP:RIGHT")
	CHARCONSTANT (XOR_RIGHT, "&&OP:RIGHT")
	CHARCONSTANT (ABBREV, "ABBREV")
	CHARCONSTANT (CASELESSABBREV, "CASELESSABBREV")
	CHARCONSTANT (ABS, "ABS")
	CHARCONSTANT (ABSTRACT, "ABSTRACT")
	CHARCONSTANT (ADDRESS, "ADDRESS")
	CHARCONSTANT (ARG, "ARG")
	CHARCONSTANT (B2X, "B2X")
	CHARCONSTANT (BITAND, "BITAND")
	CHARCONSTANT (BITOR, "BITOR")
	CHARCONSTANT (BITXOR, "BITXOR")
	CHARCONSTANT (C2D, "C2D")
	CHARCONSTANT (C2X, "C2X")
	CHARCONSTANT (CENTER, "CENTER")
	CHARCONSTANT (CENTRE, "CENTRE")
	CHARCONSTANT (CHANGESTR, "CHANGESTR")
	CHARCONSTANT (CASELESSCHANGESTR, "CASELESSCHANGESTR")
	CHARCONSTANT (CHARIN, "CHARIN")
	CHARCONSTANT (CHAROUT, "CHAROUT")
	CHARCONSTANT (CHARS, "CHARS")
	CHARCONSTANT (COMPARE, "COMPARE")
	CHARCONSTANT (COPIES, "COPIES")
	CHARCONSTANT (COUNTSTR, "COUNTSTR")
	CHARCONSTANT (CASELESSCOUNTSTR, "CASELESSCOUNTSTR")
	CHARCONSTANT (D2C, "D2C")
	CHARCONSTANT (D2X, "D2X")
	CHARCONSTANT (DATATYPE, "DATATYPE")
	CHARCONSTANT (DATE, "DATE")
	CHARCONSTANT (DELSTR, "DELSTR")
	CHARCONSTANT (DELWORD, "DELWORD")
	CHARCONSTANT (DIGITS, "DIGITS")
	CHARCONSTANT (FORM, "FORM")
	CHARCONSTANT (FORMAT, "FORMAT")
	CHARCONSTANT (FUZZ, "FUZZ")
	CHARCONSTANT (HASHCODE, "HASHCODE")
	CHARCONSTANT (IDENTITYHASH, "IDENTITYHASH")
	CHARCONSTANT (INSERT, "INSERT")
	CHARCONSTANT (LASTPOS, "LASTPOS")
	CHARCONSTANT (LEFT, "LEFT")
	CHARCONSTANT (LENGTH, "LENGTH")
	CHARCONSTANT (LINEIN, "LINEIN")
	CHARCONSTANT (LINEOUT, "LINEOUT")
	CHARCONSTANT (LINES, "LINES")
	CHARCONSTANT (LINE, "LINE")
	CHARCONSTANT (ORXMAX, "MAX")
	CHARCONSTANT (ORXMIN, "MIN")
	CHARCONSTANT (OVERLAY, "OVERLAY")
	CHARCONSTANT (POS, "POS")
	CHARCONSTANT (QUEUED, "QUEUED")
	CHARCONSTANT (RANDOM, "RANDOM")
	CHARCONSTANT (REVERSE, "REVERSE")
	CHARCONSTANT (RIGHT, "RIGHT")
	CHARCONSTANT (SAY, "SAY")
	CHARCONSTANT (SIGN, "SIGN")
	CHARCONSTANT (SOURCELINE, "SOURCELINE")
	CHARCONSTANT (SOURCESIZE, "SOURCESIZE")
	CHARCONSTANT (SPACE, "SPACE")
	CHARCONSTANT (STREAM, "STREAM")
	CHARCONSTANT (STRIP, "STRIP")
	CHARCONSTANT (SUBCHAR, "SUBCHAR")
	CHARCONSTANT (SUBSTR, "SUBSTR")
	CHARCONSTANT (SUBWORD, "SUBWORD")
	CHARCONSTANT (SYMBOL, "SYMBOL")
	CHARCONSTANT (TIME, "TIME")
	CHARCONSTANT (TRACE, "TRACE")
	CHARCONSTANT (TRUNC, "TRUNC")
	CHARCONSTANT (VALUE, "VALUE")
	CHARCONSTANT (VERIFY, "VERIFY")
	CHARCONSTANT (WORD, "WORD")
	CHARCONSTANT (WORDINDEX, "WORDINDEX")
	CHARCONSTANT (WORDLENGTH, "WORDLENGTH")
	CHARCONSTANT (WORDPOS, "WORDPOS")
	CHARCONSTANT (CASELESSWORDPOS, "CASELESSWORDPOS")
	CHARCONSTANT (WORDS, "WORDS")
	CHARCONSTANT (X2B, "X2B")
	CHARCONSTANT (X2C, "X2C")
	CHARCONSTANT (X2D, "X2D")
	CHARCONSTANT (XRANGE, "XRANGE")
	CHARCONSTANT (BY, "BY")
	CHARCONSTANT (CASELESS, "CASELESS")
	CHARCONSTANT (DO, "DO")
	CHARCONSTANT (DROP, "DROP")
	CHARCONSTANT (ELSE, "ELSE")
	CHARCONSTANT (END, "END")
	CHARCONSTANT (EXPOSE, "EXPOSE")
	CHARCONSTANT (FAILURE, "FAILURE")
	CHARCONSTANT (FOR, "FOR")
	CHARCONSTANT (FOREVER, "FOREVER")
	CHARCONSTANT (GUARD, "GUARD")
	CHARCONSTANT (IF, "IF")
	CHARCONSTANT (INTERPRET, "INTERPRET")
	CHARCONSTANT (ITERATE, "ITERATE")
	CHARCONSTANT (PULL, "PULL")
	CHARCONSTANT (PUSH, "PUSH")
	CHARCONSTANT (LABEL, "LABEL")
	CHARCONSTANT (LEAVE, "LEAVE")
	CHARCONSTANT (LOOP, "LOOP")
	CHARCONSTANT (LOWER, "LOWER")
	CHARCONSTANT (NOP, "NOP")
	CHARCONSTANT (NOTREADY, "NOTREADY")
	CHARCONSTANT (OBJECT, "OBJECT")
	CHARCONSTANT (OPTIONS, "OPTIONS")
	CHARCONSTANT (OTHERWISE, "OTHERWISE")
	CHARCONSTANT (OVER, "OVER")
	CHARCONSTANT (PRIVATE, "PRIVATE")
	CHARCONSTANT (PROCEDURE, "PROCEDURE")
	CHARCONSTANT (RAISE, "RAISE")
	CHARCONSTANT (REPLY, "REPLY")
	CHARCONSTANT (RETURN, "RETURN")
	CHARCONSTANT (SELECT, "SELECT")
	CHARCONSTANT (THEN, "THEN")
	CHARCONSTANT (TO, "TO")
	CHARCONSTANT (UNTIL, "UNTIL")
	CHARCONSTANT (UPPER, "UPPER")
	CHARCONSTANT (USE, "USE")
	CHARCONSTANT (USER, "USER")
	CHARCONSTANT (WHEN, "WHEN")
	CHARCONSTANT (WHILE, "WHILE")
	CHARCONSTANT (WITH, "WITH")
	CHARCONSTANT (ZERO, "0")
	CHARCONSTANT (SIGTERM, "SIGTERM")
	CHARCONSTANT (SIGINT, "SIGINT")
	CHARCONSTANT (SIGHUP, "SIGHUP")
	CHARCONSTANT (PUBLIC_ROUTINES, "PUBLIC_ROUTINES")

Macro Definition Documentation

CHARCONSTANT

#define CHARCONSTANT	(		name,
			value
	)		CONSTCLASS char CHAR_##name[] INITIAL(value)

Definition at line 58 of file RexxConstants.hpp.

CONSTCLASS

#define CONSTCLASS   extern

Definition at line 53 of file RexxConstants.hpp.

INITIAL

#define INITIAL

(

x

)

Definition at line 55 of file RexxConstants.hpp.

Function Documentation

CHARCONSTANT() [1/533]

CHARCONSTANT	(	ABBREV	,
		"ABBREV"
	)

CHARCONSTANT() [2/533]

CHARCONSTANT	(	ABS	,
		"ABS"
	)

CHARCONSTANT() [3/533]

CHARCONSTANT	(	ABSTRACT	,
		"ABSTRACT"
	)

CHARCONSTANT() [4/533]

CHARCONSTANT	(	ACTIVATE	,
		"ACTIVATE"
	)

CHARCONSTANT() [5/533]

CHARCONSTANT	(	ACTIVITY	,
		"ACTIVITY"
	)

CHARCONSTANT() [6/533]

CHARCONSTANT	(	ADD	,
		"ADD"
	)

CHARCONSTANT() [7/533]

CHARCONSTANT	(	ADDCLASS	,
		"ADDCLASS"
	)

CHARCONSTANT() [8/533]

CHARCONSTANT	(	ADDITIONAL	,
		"ADDITIONAL"
	)

CHARCONSTANT() [9/533]

CHARCONSTANT	(	ADDPACKAGE	,
		"ADDPACKAGE"
	)

CHARCONSTANT() [10/533]

CHARCONSTANT	(	ADDPUBLICCLASS	,
		"ADDPUBLICCLASS"
	)

CHARCONSTANT() [11/533]

CHARCONSTANT	(	ADDPUBLICROUTINE	,
		"ADDPUBLICROUTINE"
	)

CHARCONSTANT() [12/533]

CHARCONSTANT	(	ADDRESS	,
		"ADDRESS"
	)

CHARCONSTANT() [13/533]

CHARCONSTANT	(	ADDROUTINE	,
		"ADDROUTINE"
	)

CHARCONSTANT() [14/533]

CHARCONSTANT	(	ALLAT	,
		"ALLAT"
	)

CHARCONSTANT() [15/533]

CHARCONSTANT	(	ALLINDEX	,
		"ALLINDEX"
	)

CHARCONSTANT() [16/533]

CHARCONSTANT	(	ALLINDEXES	,
		"ALLINDEXES"
	)

CHARCONSTANT() [17/533]

CHARCONSTANT	(	ALLITEMS	,
		"ALLITEMS"
	)

CHARCONSTANT() [18/533]

CHARCONSTANT	(	AND	,
		"&"
	)

CHARCONSTANT() [19/533]

CHARCONSTANT	(	AND_RIGHT	,
		"&OP:RIGHT"
	)

CHARCONSTANT() [20/533]

CHARCONSTANT	(	ANY	,
		"ANY"
	)

CHARCONSTANT() [21/533]

CHARCONSTANT	(	APPEND	,
		"APPEND"
	)

CHARCONSTANT() [22/533]

CHARCONSTANT	(	ARG	,
		"ARG"
	)

CHARCONSTANT() [23/533]

CHARCONSTANT	(	ARGS	,
		"ARGS"
	)

CHARCONSTANT() [24/533]

CHARCONSTANT	(	ARGUMENTS	,
		"ARGUMENTS"
	)

CHARCONSTANT() [25/533]

CHARCONSTANT	(	ARRAY	,
		"ARRAY"
	)

CHARCONSTANT() [26/533]

CHARCONSTANT	(	ARRAYSYM	,
		"ARRAY"
	)

CHARCONSTANT() [27/533]

CHARCONSTANT

(

ASSIGNMENT_AND

)

CHARCONSTANT() [28/533]

CHARCONSTANT

(

ASSIGNMENT_CONCATENATE

)

CHARCONSTANT() [29/533]

CHARCONSTANT

(

ASSIGNMENT_DIVIDE

)

CHARCONSTANT() [30/533]

CHARCONSTANT

(

ASSIGNMENT_INTDIV

)

CHARCONSTANT() [31/533]

CHARCONSTANT

(

ASSIGNMENT_MULTIPLY

)

CHARCONSTANT() [32/533]

CHARCONSTANT

(

ASSIGNMENT_OR

)

CHARCONSTANT() [33/533]

CHARCONSTANT

(

ASSIGNMENT_PLUS

)

CHARCONSTANT() [34/533]

CHARCONSTANT

(

ASSIGNMENT_POWER

)

CHARCONSTANT() [35/533]

CHARCONSTANT

(

ASSIGNMENT_REMAINDER

)

CHARCONSTANT() [36/533]

CHARCONSTANT

(

ASSIGNMENT_SUBTRACT

)

CHARCONSTANT() [37/533]

CHARCONSTANT

(

ASSIGNMENT_XOR

)

CHARCONSTANT() [38/533]

CHARCONSTANT	(	AT	,
		"AT"
	)

CHARCONSTANT() [39/533]

CHARCONSTANT	(	ATTRIBUTE	,
		"ATTRIBUTE"
	)

CHARCONSTANT() [40/533]

CHARCONSTANT	(	AUTO	,
		"AUTO"
	)

CHARCONSTANT() [41/533]

CHARCONSTANT	(	AVAILABLE	,
		"AVAILABLE"
	)

CHARCONSTANT() [42/533]

CHARCONSTANT	(	B2X	,
		"B2X"
	)

CHARCONSTANT() [43/533]

CHARCONSTANT	(	BACKSLASH	,
		"\\"
	)

CHARCONSTANT() [44/533]

CHARCONSTANT

(

BACKSLASH_EQUAL

)

CHARCONSTANT() [45/533]

CHARCONSTANT

(

BACKSLASH_EQUAL_RIGHT

)

CHARCONSTANT() [46/533]

CHARCONSTANT	(	BACKSLASH_GREATERTHAN	,
		"\\	,
		"
	)

CHARCONSTANT() [47/533]

CHARCONSTANT	(	BACKSLASH_GREATERTHAN_RIGHT	,
		"\\	,
		OP:RIGHT"
	)

CHARCONSTANT() [48/533]

CHARCONSTANT

(

BACKSLASH_LESSTHAN

)

CHARCONSTANT() [49/533]

CHARCONSTANT

(

BACKSLASH_LESSTHAN_RIGHT

)

CHARCONSTANT() [50/533]

CHARCONSTANT	(	BACKSLASH_RIGHT	,
		"\\OP:RIGHT"
	)

CHARCONSTANT() [51/533]

CHARCONSTANT	(	BAD	,
		"BAD"
	)

CHARCONSTANT() [52/533]

CHARCONSTANT	(	BASECLASS	,
		"BASECLASS"
	)

CHARCONSTANT() [53/533]

CHARCONSTANT	(	BITAND	,
		"BITAND"
	)

CHARCONSTANT() [54/533]

CHARCONSTANT	(	BITOR	,
		"BITOR"
	)

CHARCONSTANT() [55/533]

CHARCONSTANT	(	BITXOR	,
		"BITXOR"
	)

CHARCONSTANT() [56/533]

CHARCONSTANT	(	BLANK	,
		" "
	)

CHARCONSTANT() [57/533]

CHARCONSTANT	(	BLANK_RIGHT	,
		" OP:RIGHT"
	)

CHARCONSTANT() [58/533]

CHARCONSTANT	(	BOOLEAN	,
		"BOOLEAN"
	)

CHARCONSTANT() [59/533]

CHARCONSTANT	(	BRACKETS	,
		""	[]
	)

CHARCONSTANT() [60/533]

CHARCONSTANT

(

BRACKETSEQUAL

)

CHARCONSTANT() [61/533]

CHARCONSTANT	(	BUFFER	,
		"BUFFER"
	)

CHARCONSTANT() [62/533]

CHARCONSTANT	(	BY	,
		"BY"
	)

CHARCONSTANT() [63/533]

CHARCONSTANT	(	C2D	,
		"C2D"
	)

CHARCONSTANT() [64/533]

CHARCONSTANT	(	C2X	,
		"C2X"
	)

CHARCONSTANT() [65/533]

CHARCONSTANT	(	CALL	,
		"CALL"
	)

CHARCONSTANT() [66/533]

CHARCONSTANT	(	CALLWITH	,
		"CALLWITH"
	)

CHARCONSTANT() [67/533]

CHARCONSTANT	(	CASELESS	,
		"CASELESS"
	)

CHARCONSTANT() [68/533]

CHARCONSTANT	(	CASELESSABBREV	,
		"CASELESSABBREV"
	)

CHARCONSTANT() [69/533]

CHARCONSTANT	(	CASELESSCHANGESTR	,
		"CASELESSCHANGESTR"
	)

CHARCONSTANT() [70/533]

CHARCONSTANT	(	CASELESSCOMPARE	,
		"CASELESSCOMPARE"
	)

CHARCONSTANT() [71/533]

CHARCONSTANT	(	CASELESSCOMPARETO	,
		"CASELESSCOMPARETO"
	)

CHARCONSTANT() [72/533]

CHARCONSTANT	(	CASELESSCOUNTSTR	,
		"CASELESSCOUNTSTR"
	)

CHARCONSTANT() [73/533]

CHARCONSTANT	(	CASELESSEQUALS	,
		"CASELESSEQUALS"
	)

CHARCONSTANT() [74/533]

CHARCONSTANT	(	CASELESSLASTPOS	,
		"CASELESSLASTPOS"
	)

CHARCONSTANT() [75/533]

CHARCONSTANT	(	CASELESSMATCH	,
		"CASELESSMATCH"
	)

CHARCONSTANT() [76/533]

CHARCONSTANT	(	CASELESSMATCHCHAR	,
		"CASELESSMATCHCHAR"
	)

CHARCONSTANT() [77/533]

CHARCONSTANT	(	CASELESSPOS	,
		"CASELESSPOS"
	)

CHARCONSTANT() [78/533]

CHARCONSTANT	(	CASELESSWORDPOS	,
		"CASELESSWORDPOS"
	)

CHARCONSTANT() [79/533]

CHARCONSTANT	(	CENTER	,
		"CENTER"
	)

CHARCONSTANT() [80/533]

CHARCONSTANT	(	CENTRE	,
		"CENTRE"
	)

CHARCONSTANT() [81/533]

CHARCONSTANT	(	CHANGESTR	,
		"CHANGESTR"
	)

CHARCONSTANT() [82/533]

CHARCONSTANT	(	CHAR	,
		"CHAR"
	)

CHARCONSTANT() [83/533]

CHARCONSTANT	(	CHARIN	,
		"CHARIN"
	)

CHARCONSTANT() [84/533]

CHARCONSTANT	(	CHAROUT	,
		"CHAROUT"
	)

CHARCONSTANT() [85/533]

CHARCONSTANT	(	CHARS	,
		"CHARS"
	)

CHARCONSTANT() [86/533]

CHARCONSTANT	(	CLASS	,
		"CLASS"
	)

CHARCONSTANT() [87/533]

CHARCONSTANT	(	CLASSES	,
		"CLASSES"
	)

CHARCONSTANT() [88/533]

CHARCONSTANT	(	CLAUSER	,
		"CLAUSER"
	)

CHARCONSTANT() [89/533]

CHARCONSTANT	(	CLOSE	,
		"CLOSE"
	)

CHARCONSTANT() [90/533]

CHARCONSTANT	(	CODE	,
		"CODE"
	)

CHARCONSTANT() [91/533]

CHARCONSTANT	(	COMMAND	,
		"COMMAND"
	)

CHARCONSTANT() [92/533]

CHARCONSTANT	(	COMMANDS	,
		"COMMANDS"
	)

CHARCONSTANT() [93/533]

CHARCONSTANT	(	COMMON_RETRIEVERS	,
		"COMMON_RETRIEVERS"
	)

CHARCONSTANT() [94/533]

CHARCONSTANT	(	COMPARABLE	,
		"COMPARABLE"
	)

CHARCONSTANT() [95/533]

CHARCONSTANT	(	COMPARE	,
		"COMPARE"
	)

CHARCONSTANT() [96/533]

CHARCONSTANT	(	COMPARETO	,
		"COMPARETO"
	)

CHARCONSTANT() [97/533]

CHARCONSTANT	(	COMPLETED	,
		"COMPLETED"
	)

CHARCONSTANT() [98/533]

CHARCONSTANT	(	CONCATENATE	,
		"||"
	)

CHARCONSTANT() [99/533]

CHARCONSTANT	(	CONCATENATE_RIGHT	,
		"||OP:RIGHT"
	)

CHARCONSTANT() [100/533]

CHARCONSTANT	(	CONDITION	,
		"CONDITION"
	)

CHARCONSTANT() [101/533]

CHARCONSTANT	(	CONSTANT	,
		"CONSTANT"
	)

CHARCONSTANT() [102/533]

CHARCONSTANT	(	CONTEXT	,
		"CONTEXT"
	)

CHARCONSTANT() [103/533]

CHARCONSTANT	(	CONTINUE	,
		"CONTINUE"
	)

CHARCONSTANT() [104/533]

CHARCONSTANT	(	COPIES	,
		"COPIES"
	)

CHARCONSTANT() [105/533]

CHARCONSTANT	(	COPY	,
		"COPY"
	)

CHARCONSTANT() [106/533]

CHARCONSTANT	(	COUNTSTR	,
		"COUNTSTR"
	)

CHARCONSTANT() [107/533]

CHARCONSTANT	(	CSTDERR	,
		"STDERR:"
	)

CHARCONSTANT() [108/533]

CHARCONSTANT	(	CSTDIN	,
		"STDIN:"
	)

CHARCONSTANT() [109/533]

CHARCONSTANT	(	CSTDOUT	,
		"STDOUT:"
	)

CHARCONSTANT() [110/533]

CHARCONSTANT	(	D2C	,
		"D2C"
	)

CHARCONSTANT() [111/533]

CHARCONSTANT	(	D2X	,
		"D2X"
	)

CHARCONSTANT() [112/533]

CHARCONSTANT	(	DATATYPE	,
		"DATATYPE"
	)

CHARCONSTANT() [113/533]

CHARCONSTANT	(	DATE	,
		"DATE"
	)

CHARCONSTANT() [114/533]

CHARCONSTANT	(	DEBUGINPUT	,
		"DEBUGINPUT"
	)

CHARCONSTANT() [115/533]

CHARCONSTANT	(	DECODEBASE64	,
		"DECODEBASE64"
	)

CHARCONSTANT() [116/533]

CHARCONSTANT	(	DEFAULTNAME	,
		"DEFAULTNAME"
	)

CHARCONSTANT() [117/533]

CHARCONSTANT	(	DEFINE	,
		"DEFINE"
	)

CHARCONSTANT() [118/533]

CHARCONSTANT	(	DEFINE_METHODS	,
		"!DEFINE_METHODS"
	)

CHARCONSTANT() [119/533]

CHARCONSTANT	(	DEFINEDMETHODS	,
		"DEFINEDMETHODS"
	)

CHARCONSTANT() [120/533]

CHARCONSTANT	(	DELAY	,
		"DELAY"
	)

CHARCONSTANT() [121/533]

CHARCONSTANT	(	DELETE	,
		"DELETE"
	)

CHARCONSTANT() [122/533]

CHARCONSTANT	(	DELSTR	,
		"DELSTR"
	)

CHARCONSTANT() [123/533]

CHARCONSTANT	(	DELWORD	,
		"DELWORD"
	)

CHARCONSTANT() [124/533]

CHARCONSTANT	(	DESCRIPTION	,
		"DESCRIPTION"
	)

CHARCONSTANT() [125/533]

CHARCONSTANT	(	DIGITS	,
		"DIGITS"
	)

CHARCONSTANT() [126/533]

CHARCONSTANT	(	DIMENSION	,
		"DIMENSION"
	)

CHARCONSTANT() [127/533]

CHARCONSTANT	(	DIRECTORY	,
		"DIRECTORY"
	)

CHARCONSTANT() [128/533]

CHARCONSTANT	(	DIVIDE	,
		"/"
	)

CHARCONSTANT() [129/533]

CHARCONSTANT	(	DIVIDE_RIGHT	,
		"/OP:RIGHT"
	)

CHARCONSTANT() [130/533]

CHARCONSTANT	(	DO	,
		"DO"
	)

CHARCONSTANT() [131/533]

CHARCONSTANT	(	DOUBLE	,
		"DOUBLE"
	)

CHARCONSTANT() [132/533]

CHARCONSTANT	(	DROP	,
		"DROP"
	)

CHARCONSTANT() [133/533]

CHARCONSTANT	(	ELLIPSIS	,
		"..."
	)

CHARCONSTANT() [134/533]

CHARCONSTANT	(	ELSE	,
		"ELSE"
	)

CHARCONSTANT() [135/533]

CHARCONSTANT	(	EMPTY	,
		"EMPTY"
	)

CHARCONSTANT() [136/533]

CHARCONSTANT	(	ENCODEBASE64	,
		"ENCODEBASE64"
	)

CHARCONSTANT() [137/533]

CHARCONSTANT	(	END	,
		"END"
	)

CHARCONSTANT() [138/533]

CHARCONSTANT	(	ENDLOCAL	,
		"ENDLOCAL"
	)

CHARCONSTANT() [139/533]

CHARCONSTANT	(	ENGINEERING	,
		"ENGINEERING"
	)

CHARCONSTANT() [140/533]

CHARCONSTANT	(	ENHANCED	,
		"ENHANCED"
	)

CHARCONSTANT() [141/533]

CHARCONSTANT	(	ENTRY	,
		"ENTRY"
	)

CHARCONSTANT() [142/533]

CHARCONSTANT	(	ENVELOPE	,
		"ENVELOPE"
	)

CHARCONSTANT() [143/533]

CHARCONSTANT	(	ENVIRONMENT	,
		"ENVIRONMENT"
	)

CHARCONSTANT() [144/533]

CHARCONSTANT

(

EQUAL

)

CHARCONSTANT() [145/533]

CHARCONSTANT

(

EQUAL_RIGHT

)

CHARCONSTANT() [146/533]

CHARCONSTANT	(	EQUALS	,
		"EQUALS"
	)

CHARCONSTANT() [147/533]

CHARCONSTANT	(	ERROR	,
		"ERROR"
	)

CHARCONSTANT() [148/533]

CHARCONSTANT	(	ERRORCONDITION	,
		"ERRORCONDITION"
	)

CHARCONSTANT() [149/533]

CHARCONSTANT	(	ERRORTEXT	,
		"ERRORTEXT"
	)

CHARCONSTANT() [150/533]

CHARCONSTANT	(	EXCEPTION	,
		"EXCEPTION"
	)

CHARCONSTANT() [151/533]

CHARCONSTANT	(	EXECUTABLE	,
		"EXECUTABLE"
	)

CHARCONSTANT() [152/533]

CHARCONSTANT	(	EXIT	,
		"EXIT"
	)

CHARCONSTANT() [153/533]

CHARCONSTANT	(	EXMODE	,
		"EXMODE"
	)

CHARCONSTANT() [154/533]

CHARCONSTANT	(	EXPOSE	,
		"EXPOSE"
	)

CHARCONSTANT() [155/533]

CHARCONSTANT	(	EXTENSION	,
		"EXTENSION"
	)

CHARCONSTANT() [156/533]

CHARCONSTANT	(	EXTERNAL	,
		"EXTERNAL"
	)

CHARCONSTANT() [157/533]

CHARCONSTANT	(	FAILURE	,
		"FAILURE"
	)

CHARCONSTANT() [158/533]

CHARCONSTANT	(	FAILURENAME	,
		"FAILURE"
	)

CHARCONSTANT() [159/533]

CHARCONSTANT	(	FALSE	,
		"FALSE"
	)

CHARCONSTANT() [160/533]

CHARCONSTANT	(	FILE	,
		"FILE"
	)

CHARCONSTANT() [161/533]

CHARCONSTANT	(	FILESYSTEM	,
		"FILESYSTEM"
	)

CHARCONSTANT() [162/533]

CHARCONSTANT	(	FINDCLASS	,
		"FINDCLASS"
	)

CHARCONSTANT() [163/533]

CHARCONSTANT	(	FINDROUTINE	,
		"FINDROUTINE"
	)

CHARCONSTANT() [164/533]

CHARCONSTANT	(	FIRST	,
		"FIRST"
	)

CHARCONSTANT() [165/533]

CHARCONSTANT	(	FIRSTITEM	,
		"FIRSTITEM"
	)

CHARCONSTANT() [166/533]

CHARCONSTANT	(	FOR	,
		"FOR"
	)

CHARCONSTANT() [167/533]

CHARCONSTANT	(	FOREVER	,
		"FOREVER"
	)

CHARCONSTANT() [168/533]

CHARCONSTANT	(	FORM	,
		"FORM"
	)

CHARCONSTANT() [169/533]

CHARCONSTANT	(	FORMAT	,
		"FORMAT"
	)

CHARCONSTANT() [170/533]

CHARCONSTANT	(	FORWARD	,
		"FORWARD"
	)

CHARCONSTANT() [171/533]

CHARCONSTANT	(	FUNCTIONNAME	,
		"FUNCTION"
	)

CHARCONSTANT() [172/533]

CHARCONSTANT	(	FUNCTIONS	,
		"FUNCTIONS"
	)

CHARCONSTANT() [173/533]

CHARCONSTANT	(	FUZZ	,
		"FUZZ"
	)

CHARCONSTANT() [174/533]

CHARCONSTANT	(	GET	,
		"GET"
	)

CHARCONSTANT() [175/533]

CHARCONSTANT	(	GETBUFFERSIZE	,
		"GETBUFFERSIZE"
	)

CHARCONSTANT() [176/533]

CHARCONSTANT	(	GETDEFINEDMETHODS	,
		"GETDEFINEDMETHODS"
	)

CHARCONSTANT() [177/533]

CHARCONSTANT	(	GLOBAL_STRINGS	,
		"GLOBAL_STRINGS"
	)

CHARCONSTANT() [178/533]

CHARCONSTANT	(	GREATERTHAN	,
		"	,
		"
	)

CHARCONSTANT() [179/533]

CHARCONSTANT	(	GREATERTHAN_EQUAL	,
		">="
	)

CHARCONSTANT() [180/533]

CHARCONSTANT	(	GREATERTHAN_EQUAL_RIGHT	,
		">=OP:RIGHT"
	)

CHARCONSTANT() [181/533]

CHARCONSTANT	(	GREATERTHAN_LESSTHAN	,
		"
	)

CHARCONSTANT() [182/533]

CHARCONSTANT	(	GREATERTHAN_LESSTHAN_RIGHT	,
		"
	)

CHARCONSTANT() [183/533]

CHARCONSTANT	(	GREATERTHAN_RIGHT	,
		"	,
		OP:RIGHT"
	)

CHARCONSTANT() [184/533]

CHARCONSTANT	(	GUARD	,
		"GUARD"
	)

CHARCONSTANT() [185/533]

CHARCONSTANT	(	GUARDED	,
		"GUARDED"
	)

CHARCONSTANT() [186/533]

CHARCONSTANT	(	HALT	,
		"HALT"
	)

CHARCONSTANT() [187/533]

CHARCONSTANT	(	HASENTRY	,
		"HASENTRY"
	)

CHARCONSTANT() [188/533]

CHARCONSTANT	(	HASERROR	,
		"HASERROR"
	)

CHARCONSTANT() [189/533]

CHARCONSTANT	(	HASHCODE	,
		"HASHCODE"
	)

CHARCONSTANT() [190/533]

CHARCONSTANT	(	HASINDEX	,
		"HASINDEX"
	)

CHARCONSTANT() [191/533]

CHARCONSTANT	(	HASITEM	,
		"HASITEM"
	)

CHARCONSTANT() [192/533]

CHARCONSTANT	(	HASMETHOD	,
		"HASMETHOD"
	)

CHARCONSTANT() [193/533]

CHARCONSTANT	(	ID	,
		"ID"
	)

CHARCONSTANT() [194/533]

CHARCONSTANT	(	IDENTITYHASH	,
		"IDENTITYHASH"
	)

CHARCONSTANT() [195/533]

CHARCONSTANT	(	IDENTITYTABLE	,
		"IDENTITYTABLE"
	)

CHARCONSTANT() [196/533]

CHARCONSTANT	(	IF	,
		"IF"
	)

CHARCONSTANT() [197/533]

CHARCONSTANT	(	IMPORTEDCLASSES	,
		"IMPORTEDCLASSES"
	)

CHARCONSTANT() [198/533]

CHARCONSTANT	(	IMPORTEDPACKAGES	,
		"IMPORTEDPACKAGES"
	)

CHARCONSTANT() [199/533]

CHARCONSTANT	(	IMPORTEDROUTINES	,
		"IMPORTEDROUTINES"
	)

CHARCONSTANT() [200/533]

CHARCONSTANT	(	INDEX	,
		"INDEX"
	)

CHARCONSTANT() [201/533]

CHARCONSTANT	(	INHERIT	,
		"INHERIT"
	)

CHARCONSTANT() [202/533]

CHARCONSTANT	(	INIT	,
		"INIT"
	)

CHARCONSTANT() [203/533]

CHARCONSTANT	(	INITIALADDRESS	,
		SYSINITIALADDRESS
	)

CHARCONSTANT() [204/533]

CHARCONSTANT	(	INITINSTANCE	,
		"INITINSTANCE"
	)

CHARCONSTANT() [205/533]

CHARCONSTANT	(	INPUT	,
		"INPUT"
	)

CHARCONSTANT() [206/533]

CHARCONSTANT	(	INSERT	,
		"INSERT"
	)

CHARCONSTANT() [207/533]

CHARCONSTANT	(	INSTANCEMETHOD	,
		"INSTANCEMETHOD"
	)

CHARCONSTANT() [208/533]

CHARCONSTANT	(	INSTANCEMETHODS	,
		"INSTANCEMETHODS"
	)

CHARCONSTANT() [209/533]

CHARCONSTANT	(	INSTRUCTION	,
		"INSTRUCTION"
	)

CHARCONSTANT() [210/533]

CHARCONSTANT	(	INTDIV	,
		"%"
	)

CHARCONSTANT() [211/533]

CHARCONSTANT	(	INTDIV_RIGHT	,
		"%OP:RIGHT"
	)

CHARCONSTANT() [212/533]

CHARCONSTANT	(	INTEGER	,
		"INTEGER"
	)

CHARCONSTANT() [213/533]

CHARCONSTANT	(	INTERNALNAME	,
		"INTERNALNAME"
	)

CHARCONSTANT() [214/533]

CHARCONSTANT	(	INTERPRET	,
		"INTERPRET"
	)

CHARCONSTANT() [215/533]

CHARCONSTANT	(	ISA	,
		"ISA"
	)

CHARCONSTANT() [216/533]

CHARCONSTANT	(	ISASCII	,
		"ISASCII"
	)

CHARCONSTANT() [217/533]

CHARCONSTANT	(	ISEMPTY	,
		"ISEMPTY"
	)

CHARCONSTANT() [218/533]

CHARCONSTANT	(	ISGUARDED	,
		"ISGUARDED"
	)

CHARCONSTANT() [219/533]

CHARCONSTANT	(	ISINSTANCEOF	,
		"ISINSTANCEOF"
	)

CHARCONSTANT() [220/533]

CHARCONSTANT	(	ISNULL	,
		"ISNULL"
	)

CHARCONSTANT() [221/533]

CHARCONSTANT	(	ISPRIVATE	,
		"ISPRIVATE"
	)

CHARCONSTANT() [222/533]

CHARCONSTANT	(	ISPROTECTED	,
		"ISPROTECTED"
	)

CHARCONSTANT() [223/533]

CHARCONSTANT	(	ISSUBCLASSOF	,
		"ISSUBCLASSOF"
	)

CHARCONSTANT() [224/533]

CHARCONSTANT	(	ITEM	,
		"ITEM"
	)

CHARCONSTANT() [225/533]

CHARCONSTANT	(	ITEMS	,
		"ITEMS"
	)

CHARCONSTANT() [226/533]

CHARCONSTANT	(	ITERATE	,
		"ITERATE"
	)

CHARCONSTANT() [227/533]

CHARCONSTANT	(	KERNEL	,
		"KERNEL"
	)

CHARCONSTANT() [228/533]

CHARCONSTANT	(	KIND	,
		"KIND"
	)

CHARCONSTANT() [229/533]

CHARCONSTANT	(	LABEL	,
		"LABEL"
	)

CHARCONSTANT() [230/533]

CHARCONSTANT	(	LAST	,
		"LAST"
	)

CHARCONSTANT() [231/533]

CHARCONSTANT	(	LASTITEM	,
		"LASTITEM"
	)

CHARCONSTANT() [232/533]

CHARCONSTANT	(	LASTPOS	,
		"LASTPOS"
	)

CHARCONSTANT() [233/533]

CHARCONSTANT	(	LEAVE	,
		"LEAVE"
	)

CHARCONSTANT() [234/533]

CHARCONSTANT	(	LEFT	,
		"LEFT"
	)

CHARCONSTANT() [235/533]

CHARCONSTANT	(	LENGTH	,
		"LENGTH"
	)

CHARCONSTANT() [236/533]

CHARCONSTANT

(

LESSTHAN

)

CHARCONSTANT() [237/533]

CHARCONSTANT	(	LESSTHAN_EQUAL	,
		"<="
	)

CHARCONSTANT() [238/533]

CHARCONSTANT	(	LESSTHAN_EQUAL_RIGHT	,
		"<=OP:RIGHT"
	)

CHARCONSTANT() [239/533]

CHARCONSTANT	(	LESSTHAN_GREATERTHAN	,
		"<>"
	)

CHARCONSTANT() [240/533]

CHARCONSTANT	(	LESSTHAN_GREATERTHAN_RIGHT	,
		"<>OP:RIGHT"
	)

CHARCONSTANT() [241/533]

CHARCONSTANT

(

LESSTHAN_RIGHT

)

CHARCONSTANT() [242/533]

CHARCONSTANT	(	LIBRARY	,
		"LIBRARY"
	)

CHARCONSTANT() [243/533]

CHARCONSTANT	(	LINE	,
		"LINE"
	)

CHARCONSTANT() [244/533]

CHARCONSTANT	(	LINEIN	,
		"LINEIN"
	)

CHARCONSTANT() [245/533]

CHARCONSTANT	(	LINEOUT	,
		"LINEOUT"
	)

CHARCONSTANT() [246/533]

CHARCONSTANT	(	LINES	,
		"LINES"
	)

CHARCONSTANT() [247/533]

CHARCONSTANT	(	LIST	,
		"LIST"
	)

CHARCONSTANT() [248/533]

CHARCONSTANT	(	LIT	,
		"LIT"
	)

CHARCONSTANT() [249/533]

CHARCONSTANT	(	LOADPACKAGE	,
		"LOADPACKAGE"
	)

CHARCONSTANT() [250/533]

CHARCONSTANT	(	LOCAL	,
		"LOCAL"
	)

CHARCONSTANT() [251/533]

CHARCONSTANT	(	LOOP	,
		"LOOP"
	)

CHARCONSTANT() [252/533]

CHARCONSTANT	(	LOSTDIGITS	,
		"LOSTDIGITS"
	)

CHARCONSTANT() [253/533]

CHARCONSTANT	(	LOWER	,
		"LOWER"
	)

CHARCONSTANT() [254/533]

CHARCONSTANT	(	MACROSPACE	,
		"MACROSPACE"
	)

CHARCONSTANT() [255/533]

CHARCONSTANT	(	MAKE	,
		"MAKE"
	)

CHARCONSTANT() [256/533]

CHARCONSTANT	(	MAKEARRAY	,
		"MAKEARRAY"
	)

CHARCONSTANT() [257/533]

CHARCONSTANT	(	MAKEINTEGER	,
		"MAKEINTEGER"
	)

CHARCONSTANT() [258/533]

CHARCONSTANT	(	MAKESTRING	,
		"MAKESTRING"
	)

CHARCONSTANT() [259/533]

CHARCONSTANT	(	MAPCOLLECTION	,
		"MAPCOLLECTION"
	)

CHARCONSTANT() [260/533]

CHARCONSTANT	(	MATCH	,
		"MATCH"
	)

CHARCONSTANT() [261/533]

CHARCONSTANT	(	MATCHCHAR	,
		"MATCHCHAR"
	)

CHARCONSTANT() [262/533]

CHARCONSTANT	(	MEMORY	,
		"MEMORY"
	)

CHARCONSTANT() [263/533]

CHARCONSTANT	(	MERGE	,
		"MERGE"
	)

CHARCONSTANT() [264/533]

CHARCONSTANT	(	MESSAGE	,
		"MESSAGE"
	)

CHARCONSTANT() [265/533]

CHARCONSTANT	(	MESSAGENAME	,
		"MESSAGENAME"
	)

CHARCONSTANT() [266/533]

CHARCONSTANT	(	METACLASS	,
		"METACLASS"
	)

CHARCONSTANT() [267/533]

CHARCONSTANT	(	METHOD	,
		"METHOD"
	)

CHARCONSTANT() [268/533]

CHARCONSTANT	(	METHODNAME	,
		"METHOD"
	)

CHARCONSTANT() [269/533]

CHARCONSTANT	(	METHODS	,
		"METHODS"
	)

CHARCONSTANT() [270/533]

CHARCONSTANT	(	MIXINCLASS	,
		"MIXINCLASS"
	)

CHARCONSTANT() [271/533]

CHARCONSTANT	(	MULTIPLY	,
		"*"
	)

CHARCONSTANT() [272/533]

CHARCONSTANT	(	MULTIPLY_RIGHT	,
		"*OP:RIGHT"
	)

CHARCONSTANT() [273/533]

CHARCONSTANT	(	MUTABLEBUFFER	,
		"MUTABLEBUFFER"
	)

CHARCONSTANT() [274/533]

CHARCONSTANT	(	NAME	,
		"NAME"
	)

CHARCONSTANT() [275/533]

CHARCONSTANT	(	NAME_STRINGS	,
		"NAME_STRINGS"
	)

CHARCONSTANT() [276/533]

CHARCONSTANT	(	NAMED	,
		"NAMED"
	)

CHARCONSTANT() [277/533]

CHARCONSTANT	(	Named	,
		"Named"
	)

CHARCONSTANT() [278/533]

CHARCONSTANT	(	named	,
		"named"
	)

CHARCONSTANT() [279/533]

CHARCONSTANT	(	NAMEDARGS	,
		"NAMEDARGS"
	)

CHARCONSTANT() [280/533]

CHARCONSTANT	(	NAMEDARGUMENTS	,
		"NAMEDARGUMENTS"
	)

CHARCONSTANT() [281/533]

CHARCONSTANT	(	NEW	,
		"NEW"
	)

CHARCONSTANT() [282/533]

CHARCONSTANT	(	NEWFILE	,
		"NEWFILE"
	)

CHARCONSTANT() [283/533]

CHARCONSTANT	(	NEXT	,
		"NEXT"
	)

CHARCONSTANT() [284/533]

CHARCONSTANT	(	NIL	,
		"NIL"
	)

CHARCONSTANT() [285/533]

CHARCONSTANT	(	NMETHOD	,
		"NMETHOD"
	)

CHARCONSTANT() [286/533]

CHARCONSTANT	(	NOCOMMANDS	,
		"NOCOMMANDS"
	)

CHARCONSTANT() [287/533]

CHARCONSTANT	(	NOEXMODE	,
		"NOEXMODE"
	)

CHARCONSTANT() [288/533]

CHARCONSTANT	(	NOMACROSPACE	,
		"NOMACROSPACE"
	)

CHARCONSTANT() [289/533]

CHARCONSTANT	(	NOMETHOD	,
		"NOMETHOD"
	)

CHARCONSTANT() [290/533]

CHARCONSTANT	(	NONE	,
		"<none>"
	)

CHARCONSTANT() [291/533]

CHARCONSTANT	(	NOP	,
		"NOP"
	)

CHARCONSTANT() [292/533]

CHARCONSTANT	(	NORMAL	,
		"NORMAL"
	)

CHARCONSTANT() [293/533]

CHARCONSTANT	(	NOSTRING	,
		"NOSTRING"
	)

CHARCONSTANT() [294/533]

CHARCONSTANT	(	NOTIFY	,
		"NOTIFY"
	)

CHARCONSTANT() [295/533]

CHARCONSTANT	(	NOTREADY	,
		"NOTREADY"
	)

CHARCONSTANT() [296/533]

CHARCONSTANT	(	NOVALUE	,
		"NOVALUE"
	)

CHARCONSTANT() [297/533]

CHARCONSTANT	(	NULLARRAY	,
		"NULLARRAY"
	)

CHARCONSTANT() [298/533]

CHARCONSTANT	(	NULLPOINTER	,
		"NULLPOINTER"
	)

CHARCONSTANT() [299/533]

CHARCONSTANT	(	NULLSTRING	,
		""
	)

CHARCONSTANT() [300/533]

CHARCONSTANT	(	NULLSTRING_RIGHT	,
		"OP:RIGHT"
	)

CHARCONSTANT() [301/533]

CHARCONSTANT	(	NUMBERSTRING	,
		"NUMBERSTRING"
	)

CHARCONSTANT() [302/533]

CHARCONSTANT	(	NUMERIC	,
		"NUMERIC"
	)

CHARCONSTANT() [303/533]

CHARCONSTANT	(	OBJECT	,
		"OBJECT"
	)

CHARCONSTANT() [304/533]

CHARCONSTANT	(	OBJECTNAME	,
		"OBJECTNAME"
	)

CHARCONSTANT() [305/533]

CHARCONSTANT

(

OBJECTNAMEEQUALS

)

CHARCONSTANT() [306/533]

CHARCONSTANT	(	OBJECTSYM	,
		"OBJECT"
	)

CHARCONSTANT() [307/533]

CHARCONSTANT	(	OF	,
		"OF"
	)

CHARCONSTANT() [308/533]

CHARCONSTANT	(	OFF	,
		"OFF"
	)

CHARCONSTANT() [309/533]

CHARCONSTANT	(	ON	,
		"ON"
	)

CHARCONSTANT() [310/533]

CHARCONSTANT	(	OPTIONS	,
		"OPTIONS"
	)

CHARCONSTANT() [311/533]

CHARCONSTANT	(	OR	,
		"|"
	)

CHARCONSTANT() [312/533]

CHARCONSTANT	(	OR_RIGHT	,
		"|OP:RIGHT"
	)

CHARCONSTANT() [313/533]

CHARCONSTANT	(	ORDEREDCOLLECTION	,
		"ORDEREDCOLLECTION"
	)

CHARCONSTANT() [314/533]

CHARCONSTANT	(	ORXMAX	,
		"MAX"
	)

CHARCONSTANT() [315/533]

CHARCONSTANT	(	ORXMIN	,
		"MIN"
	)

CHARCONSTANT() [316/533]

CHARCONSTANT	(	OTHERWISE	,
		"OTHERWISE"
	)

CHARCONSTANT() [317/533]

CHARCONSTANT	(	OUTPUT	,
		"OUTPUT"
	)

CHARCONSTANT() [318/533]

CHARCONSTANT	(	OVER	,
		"OVER"
	)

CHARCONSTANT() [319/533]

CHARCONSTANT	(	OVERLAY	,
		"OVERLAY"
	)

CHARCONSTANT() [320/533]

CHARCONSTANT	(	PACKAGE	,
		"PACKAGE"
	)

CHARCONSTANT() [321/533]

CHARCONSTANT	(	PARENTCONTEXT	,
		"PARENTCONTEXT"
	)

CHARCONSTANT() [322/533]

CHARCONSTANT	(	PARSE	,
		"PARSE"
	)

CHARCONSTANT() [323/533]

CHARCONSTANT	(	PEEK	,
		"PEEK"
	)

CHARCONSTANT() [324/533]

CHARCONSTANT	(	PERIOD	,
		"."
	)

CHARCONSTANT() [325/533]

CHARCONSTANT	(	PLUS	,
		"+"
	)

CHARCONSTANT() [326/533]

CHARCONSTANT	(	PLUS_LEFT	,
		"+OP:LEFT"
	)

CHARCONSTANT() [327/533]

CHARCONSTANT	(	PLUS_RIGHT	,
		"+OP:RIGHT"
	)

CHARCONSTANT() [328/533]

CHARCONSTANT	(	POS	,
		"POS"
	)

CHARCONSTANT() [329/533]

CHARCONSTANT	(	POSITION	,
		"POSITION"
	)

CHARCONSTANT() [330/533]

CHARCONSTANT	(	POSITIONAL	,
		"POSITIONAL"
	)

CHARCONSTANT() [331/533]

CHARCONSTANT	(	Positional	,
		"Positional"
	)

CHARCONSTANT() [332/533]

CHARCONSTANT	(	positional	,
		"positional"
	)

CHARCONSTANT() [333/533]

CHARCONSTANT	(	POWER	,
		"**"
	)

CHARCONSTANT() [334/533]

CHARCONSTANT	(	POWER_RIGHT	,
		"**OP:RIGHT"
	)

CHARCONSTANT() [335/533]

CHARCONSTANT	(	PREVIOUS	,
		"PREVIOUS"
	)

CHARCONSTANT() [336/533]

CHARCONSTANT	(	PRIVATE	,
		"PRIVATE"
	)

CHARCONSTANT() [337/533]

CHARCONSTANT	(	PROCEDURE	,
		"PROCEDURE"
	)

CHARCONSTANT() [338/533]

CHARCONSTANT	(	PROGRAM	,
		"PROGRAM"
	)

CHARCONSTANT() [339/533]

CHARCONSTANT	(	PROPAGATE	,
		"PROPAGATE"
	)

CHARCONSTANT() [340/533]

CHARCONSTANT	(	PROPAGATED	,
		"PROPAGATED"
	)

CHARCONSTANT() [341/533]

CHARCONSTANT	(	PROTECTED	,
		"PROTECTED"
	)

CHARCONSTANT() [342/533]

CHARCONSTANT	(	PUBLIC	,
		"PUBLIC"
	)

CHARCONSTANT() [343/533]

CHARCONSTANT	(	PUBLIC_ROUTINES	,
		"PUBLIC_ROUTINES"
	)

CHARCONSTANT() [344/533]

CHARCONSTANT	(	PUBLICCLASSES	,
		"PUBLICCLASSES"
	)

CHARCONSTANT() [345/533]

CHARCONSTANT	(	PUBLICROUTINES	,
		"PUBLICROUTINES"
	)

CHARCONSTANT() [346/533]

CHARCONSTANT	(	PULL	,
		"PULL"
	)

CHARCONSTANT() [347/533]

CHARCONSTANT	(	PUSH	,
		"PUSH"
	)

CHARCONSTANT() [348/533]

CHARCONSTANT	(	PUT	,
		"PUT"
	)

CHARCONSTANT() [349/533]

CHARCONSTANT	(	QUALIFY	,
		"QUALIFY"
	)

CHARCONSTANT() [350/533]

CHARCONSTANT	(	QUERY	,
		"QUERY"
	)

CHARCONSTANT() [351/533]

CHARCONSTANT	(	QUERYMIXINCLASS	,
		"QUERYMIXINCLASS"
	)

CHARCONSTANT() [352/533]

CHARCONSTANT	(	QUEUE	,
		"QUEUE"
	)

CHARCONSTANT() [353/533]

CHARCONSTANT	(	QUEUED	,
		"QUEUED"
	)

CHARCONSTANT() [354/533]

CHARCONSTANT	(	QUEUEEXIT	,
		"!QUEUEEXIT"
	)

CHARCONSTANT() [355/533]

CHARCONSTANT	(	RAISE	,
		"RAISE"
	)

CHARCONSTANT() [356/533]

CHARCONSTANT	(	RANDOM	,
		"RANDOM"
	)

CHARCONSTANT() [357/533]

CHARCONSTANT	(	RAWEXECUTABLE	,
		"RAWEXECUTABLE"
	)

CHARCONSTANT() [358/533]

CHARCONSTANT	(	RC	,
		"RC"
	)

CHARCONSTANT() [359/533]

CHARCONSTANT	(	RECLAIM	,
		"RECLAIM"
	)

CHARCONSTANT() [360/533]

CHARCONSTANT	(	REGISTERED	,
		"REGISTERED"
	)

CHARCONSTANT() [361/533]

CHARCONSTANT	(	RELATION	,
		"RELATION"
	)

CHARCONSTANT() [362/533]

CHARCONSTANT	(	REMAINDER	,
		"//"
	)

CHARCONSTANT() [363/533]

CHARCONSTANT	(	REMAINDER_RIGHT	,
		"//OP:RIGHT"
	)

CHARCONSTANT() [364/533]

CHARCONSTANT	(	REMOVE	,
		"REMOVE"
	)

CHARCONSTANT() [365/533]

CHARCONSTANT	(	REMOVEITEM	,
		"REMOVEITEM"
	)

CHARCONSTANT() [366/533]

CHARCONSTANT	(	REPLACEAT	,
		"REPLACEAT"
	)

CHARCONSTANT() [367/533]

CHARCONSTANT	(	REPLY	,
		"REPLY"
	)

CHARCONSTANT() [368/533]

CHARCONSTANT	(	REQUEST	,
		"REQUEST"
	)

CHARCONSTANT() [369/533]

CHARCONSTANT	(	REQUIRES	,
		"REQUIRES"
	)

CHARCONSTANT() [370/533]

CHARCONSTANT	(	RESULT	,
		"RESULT"
	)

CHARCONSTANT() [371/533]

CHARCONSTANT	(	RETURN	,
		"RETURN"
	)

CHARCONSTANT() [372/533]

CHARCONSTANT	(	REVERSE	,
		"REVERSE"
	)

CHARCONSTANT() [373/533]

CHARCONSTANT	(	REXX	,
		"REXX"
	)

CHARCONSTANT() [374/533]

CHARCONSTANT	(	REXXBLOCK	,
		"REXXBLOCK"
	)

CHARCONSTANT() [375/533]

CHARCONSTANT	(	REXXCONTEXT	,
		"REXXCONTEXT"
	)

CHARCONSTANT() [376/533]

CHARCONSTANT	(	REXXQUEUE	,
		"STDQUE"
	)

CHARCONSTANT() [377/533]

CHARCONSTANT	(	REXXTEXT	,
		"REXXTEXT"
	)

CHARCONSTANT() [378/533]

CHARCONSTANT	(	REXXUTIL	,
		"rexxutil"
	)

CHARCONSTANT() [379/533]

CHARCONSTANT	(	RIGHT	,
		"RIGHT"
	)

CHARCONSTANT() [380/533]

CHARCONSTANT	(	ROUND_BRACKETS	,
		"()"
	)

CHARCONSTANT() [381/533]

CHARCONSTANT	(	ROUTINE	,
		"ROUTINE"
	)

CHARCONSTANT() [382/533]

CHARCONSTANT	(	ROUTINENAME	,
		"SUBROUTINE"
	)

CHARCONSTANT() [383/533]

CHARCONSTANT	(	ROUTINES	,
		"ROUTINES"
	)

CHARCONSTANT() [384/533]

CHARCONSTANT	(	RS	,
		"RS"
	)

CHARCONSTANT() [385/533]

CHARCONSTANT	(	RUN	,
		"RUN"
	)

CHARCONSTANT() [386/533]

CHARCONSTANT	(	RUNUNINIT	,
		"RUNUNINIT"
	)

CHARCONSTANT() [387/533]

CHARCONSTANT	(	RXFUNCADD	,
		"RXFUNCADD"
	)

CHARCONSTANT() [388/533]

CHARCONSTANT	(	RXFUNCDROP	,
		"RXFUNCDROP"
	)

CHARCONSTANT() [389/533]

CHARCONSTANT	(	RXFUNCQUERY	,
		"RXFUNCQUERY"
	)

CHARCONSTANT() [390/533]

CHARCONSTANT	(	SAY	,
		"SAY"
	)

CHARCONSTANT() [391/533]

CHARCONSTANT	(	SCIENTIFIC	,
		"SCIENTIFIC"
	)

CHARCONSTANT() [392/533]

CHARCONSTANT	(	SCRIPT	,
		"SCRIPT"
	)

CHARCONSTANT() [393/533]

CHARCONSTANT	(	SECTION	,
		"SECTION"
	)

CHARCONSTANT() [394/533]

CHARCONSTANT	(	SECURITYMANAGER	,
		"SECURITYMANAGER"
	)

CHARCONSTANT() [395/533]

CHARCONSTANT	(	SELECT	,
		"SELECT"
	)

CHARCONSTANT() [396/533]

CHARCONSTANT	(	SELF	,
		"SELF"
	)

CHARCONSTANT() [397/533]

CHARCONSTANT	(	SEND	,
		"SEND"
	)

CHARCONSTANT() [398/533]

CHARCONSTANT	(	SEQUENCE	,
		"SEQUENCE"
	)

CHARCONSTANT() [399/533]

CHARCONSTANT	(	SERVER	,
		"SERVER"
	)

CHARCONSTANT() [400/533]

CHARCONSTANT	(	SESSION	,
		"SESSION"
	)

CHARCONSTANT() [401/533]

CHARCONSTANT	(	SET	,
		"SET"
	)

CHARCONSTANT() [402/533]

CHARCONSTANT	(	SETARGS	,
		"SETARGS"
	)

CHARCONSTANT() [403/533]

CHARCONSTANT	(	SETBUFFERSIZE	,
		"SETBUFFERSIZE"
	)

CHARCONSTANT() [404/533]

CHARCONSTANT	(	SETDUMP	,
		"SETDUMP"
	)

CHARCONSTANT() [405/533]

CHARCONSTANT	(	SETENTRY	,
		"SETENTRY"
	)

CHARCONSTANT() [406/533]

CHARCONSTANT	(	SETGUARDED	,
		"SETGUARDED"
	)

CHARCONSTANT() [407/533]

CHARCONSTANT	(	SETINTERFACE	,
		"SETINTERFACE"
	)

CHARCONSTANT() [408/533]

CHARCONSTANT	(	SETLOCAL	,
		"SETLOCAL"
	)

CHARCONSTANT() [409/533]

CHARCONSTANT	(	SETMETHOD	,
		"SETMETHOD"
	)

CHARCONSTANT() [410/533]

CHARCONSTANT	(	SETPARMS	,
		"SETPARMS"
	)

CHARCONSTANT() [411/533]

CHARCONSTANT	(	SETPRIVATE	,
		"SETPRIVATE"
	)

CHARCONSTANT() [412/533]

CHARCONSTANT	(	SETPROTECTED	,
		"SETPROTECTED"
	)

CHARCONSTANT() [413/533]

CHARCONSTANT	(	SETSECURITYMANAGER	,
		"SETSECURITYMANAGER"
	)

CHARCONSTANT() [414/533]

CHARCONSTANT	(	SETUNGUARDED	,
		"SETUNGUARDED"
	)

CHARCONSTANT() [415/533]

CHARCONSTANT	(	SHRIEK_DISPATCH	,
		"!DISPATCH"
	)

CHARCONSTANT() [416/533]

CHARCONSTANT	(	SHRIEKREXXDEFINED	,
		"!REXXDEFINED"
	)

CHARCONSTANT() [417/533]

CHARCONSTANT	(	SIGHUP	,
		"SIGHUP"
	)

CHARCONSTANT() [418/533]

CHARCONSTANT	(	SIGINT	,
		"SIGINT"
	)

CHARCONSTANT() [419/533]

CHARCONSTANT	(	SIGL	,
		"SIGL"
	)

CHARCONSTANT() [420/533]

CHARCONSTANT	(	SIGN	,
		"SIGN"
	)

CHARCONSTANT() [421/533]

CHARCONSTANT	(	SIGNAL	,
		"SIGNAL"
	)

CHARCONSTANT() [422/533]

CHARCONSTANT	(	SIGTERM	,
		"SIGTERM"
	)

CHARCONSTANT() [423/533]

CHARCONSTANT	(	SIZE	,
		"SIZE"
	)

CHARCONSTANT() [424/533]

CHARCONSTANT	(	SORT	,
		"SORT"
	)

CHARCONSTANT() [425/533]

CHARCONSTANT	(	SORTWITH	,
		"SORTWITH"
	)

CHARCONSTANT() [426/533]

CHARCONSTANT	(	SOURCE	,
		"SOURCE"
	)

CHARCONSTANT() [427/533]

CHARCONSTANT	(	SOURCELINE	,
		"SOURCELINE"
	)

CHARCONSTANT() [428/533]

CHARCONSTANT	(	SOURCESIZE	,
		"SOURCESIZE"
	)

CHARCONSTANT() [429/533]

CHARCONSTANT	(	SPACE	,
		"SPACE"
	)

CHARCONSTANT() [430/533]

CHARCONSTANT	(	STABLESORT	,
		"STABLESORT"
	)

CHARCONSTANT() [431/533]

CHARCONSTANT	(	STABLESORTWITH	,
		"STABLESORTWITH"
	)

CHARCONSTANT() [432/533]

CHARCONSTANT	(	STACKFRAMES	,
		"STACKFRAMES"
	)

CHARCONSTANT() [433/533]

CHARCONSTANT	(	START	,
		"START"
	)

CHARCONSTANT() [434/533]

CHARCONSTANT	(	STARTAT	,
		"STARTAT"
	)

CHARCONSTANT() [435/533]

CHARCONSTANT	(	STATE	,
		"STATE"
	)

CHARCONSTANT() [436/533]

CHARCONSTANT	(	STATS	,
		"STATS"
	)

CHARCONSTANT() [437/533]

CHARCONSTANT	(	STDERR	,
		"STDERR"
	)

CHARCONSTANT() [438/533]

CHARCONSTANT	(	STDIN	,
		"STDIN"
	)

CHARCONSTANT() [439/533]

CHARCONSTANT	(	STDOUT	,
		"STDOUT"
	)

CHARCONSTANT() [440/533]

CHARCONSTANT	(	STEM	,
		"STEM"
	)

CHARCONSTANT() [441/533]

CHARCONSTANT	(	STREAM	,
		"STREAM"
	)

CHARCONSTANT() [442/533]

CHARCONSTANT	(	STREAMS	,
		"STREAMS"
	)

CHARCONSTANT() [443/533]

CHARCONSTANT	(	STRICT	,
		"STRICT"
	)

CHARCONSTANT() [444/533]

CHARCONSTANT

(

STRICT_BACKSLASH_EQUAL

)

CHARCONSTANT() [445/533]

CHARCONSTANT

(

STRICT_BACKSLASH_EQUAL_RIGHT

)

CHARCONSTANT() [446/533]

CHARCONSTANT	(	STRICT_BACKSLASH_GREATERTHAN	,
		"\>>"
	)

CHARCONSTANT() [447/533]

CHARCONSTANT	(	STRICT_BACKSLASH_GREATERTHAN_RIGHT	,
		"\>>OP:RIGHT"
	)

CHARCONSTANT() [448/533]

CHARCONSTANT	(	STRICT_BACKSLASH_LESSTHAN	,
		"\<<"
	)

CHARCONSTANT() [449/533]

CHARCONSTANT	(	STRICT_BACKSLASH_LESSTHAN_RIGHT	,
		"\<<OP:RIGHT"
	)

CHARCONSTANT() [450/533]

CHARCONSTANT

(

STRICT_EQUAL

)

CHARCONSTANT() [451/533]

CHARCONSTANT

(

STRICT_EQUAL_RIGHT

)

CHARCONSTANT() [452/533]

CHARCONSTANT	(	STRICT_GREATERTHAN	,
		">>"
	)

CHARCONSTANT() [453/533]

CHARCONSTANT

(

STRICT_GREATERTHAN_EQUAL

)

CHARCONSTANT() [454/533]

CHARCONSTANT

(

STRICT_GREATERTHAN_EQUAL_RIGHT

)

CHARCONSTANT() [455/533]

CHARCONSTANT	(	STRICT_GREATERTHAN_RIGHT	,
		">>OP:RIGHT"
	)

CHARCONSTANT() [456/533]

CHARCONSTANT	(	STRICT_LESSTHAN	,
		"<<"
	)

CHARCONSTANT() [457/533]

CHARCONSTANT

(

STRICT_LESSTHAN_EQUAL

)

CHARCONSTANT() [458/533]

CHARCONSTANT

(

STRICT_LESSTHAN_EQUAL_RIGHT

)

CHARCONSTANT() [459/533]

CHARCONSTANT	(	STRICT_LESSTHAN_RIGHT	,
		"<<OP:RIGHT"
	)

CHARCONSTANT() [460/533]

CHARCONSTANT	(	STRING	,
		"STRING"
	)

CHARCONSTANT() [461/533]

CHARCONSTANT	(	STRINGSYM	,
		"STRING"
	)

CHARCONSTANT() [462/533]

CHARCONSTANT	(	STRIP	,
		"STRIP"
	)

CHARCONSTANT() [463/533]

CHARCONSTANT	(	SUBCHAR	,
		"SUBCHAR"
	)

CHARCONSTANT() [464/533]

CHARCONSTANT	(	SUBCLASS	,
		"SUBCLASS"
	)

CHARCONSTANT() [465/533]

CHARCONSTANT	(	SUBCLASSES	,
		"SUBCLASSES"
	)

CHARCONSTANT() [466/533]

CHARCONSTANT	(	SUBROUTINE	,
		"SUBROUTINE"
	)

CHARCONSTANT() [467/533]

CHARCONSTANT	(	SUBSTR	,
		"SUBSTR"
	)

CHARCONSTANT() [468/533]

CHARCONSTANT	(	SUBTRACT	,
		"-"
	)

CHARCONSTANT() [469/533]

CHARCONSTANT	(	SUBTRACT_LEFT	,
		"-OP:LEFT"
	)

CHARCONSTANT() [470/533]

CHARCONSTANT	(	SUBTRACT_RIGHT	,
		"-OP:RIGHT"
	)

CHARCONSTANT() [471/533]

CHARCONSTANT	(	SUBWORD	,
		"SUBWORD"
	)

CHARCONSTANT() [472/533]

CHARCONSTANT	(	SUPER	,
		"SUPER"
	)

CHARCONSTANT() [473/533]

CHARCONSTANT	(	SUPERCLASS	,
		"SUPERCLASS"
	)

CHARCONSTANT() [474/533]

CHARCONSTANT	(	SUPERCLASSES	,
		"SUPERCLASSES"
	)

CHARCONSTANT() [475/533]

CHARCONSTANT	(	SUPPLIER	,
		"SUPPLIER"
	)

CHARCONSTANT() [476/533]

CHARCONSTANT	(	SYMBOL	,
		"SYMBOL"
	)

CHARCONSTANT() [477/533]

CHARCONSTANT	(	SYNTAX	,
		"SYNTAX"
	)

CHARCONSTANT() [478/533]

CHARCONSTANT	(	SYSTEM	,
		"SYSTEM"
	)

CHARCONSTANT() [479/533]

CHARCONSTANT	(	TABLE	,
		"TABLE"
	)

CHARCONSTANT() [480/533]

CHARCONSTANT	(	TARGET	,
		"TARGET"
	)

CHARCONSTANT() [481/533]

CHARCONSTANT	(	THEN	,
		"THEN"
	)

CHARCONSTANT() [482/533]

CHARCONSTANT	(	THREADLOCAL	,
		"THREADLOCAL"
	)

CHARCONSTANT() [483/533]

CHARCONSTANT	(	TILDE_ROUND_BRACKETS	,
		"~()"
	)

CHARCONSTANT() [484/533]

CHARCONSTANT	(	TIME	,
		"TIME"
	)

CHARCONSTANT() [485/533]

CHARCONSTANT	(	TO	,
		"TO"
	)

CHARCONSTANT() [486/533]

CHARCONSTANT	(	TODIRECTORY	,
		"TODIRECTORY"
	)

CHARCONSTANT() [487/533]

CHARCONSTANT	(	TOKENIZE_ONLY	,
		"//T"
	)

CHARCONSTANT() [488/533]

CHARCONSTANT	(	TOSTRING	,
		"TOSTRING"
	)

CHARCONSTANT() [489/533]

CHARCONSTANT	(	TRACE	,
		"TRACE"
	)

CHARCONSTANT() [490/533]

CHARCONSTANT	(	TRACE_is_dropped	,
		"is dropped"
	)

CHARCONSTANT() [491/533]

CHARCONSTANT	(	TRACEBACK	,
		"TRACEBACK"
	)

CHARCONSTANT() [492/533]

CHARCONSTANT	(	TRACEOUTPUT	,
		"TRACEOUTPUT"
	)

CHARCONSTANT() [493/533]

CHARCONSTANT	(	TRANSFORMSOURCE	,
		"TRANSFORMSOURCE"
	)

CHARCONSTANT() [494/533]

CHARCONSTANT	(	TRANSLATE	,
		"TRANSLATE"
	)

CHARCONSTANT() [495/533]

CHARCONSTANT	(	TRUE	,
		"TRUE"
	)

CHARCONSTANT() [496/533]

CHARCONSTANT	(	TRUNC	,
		"TRUNC"
	)

CHARCONSTANT() [497/533]

CHARCONSTANT	(	UNGUARDED	,
		"UNGUARDED"
	)

CHARCONSTANT() [498/533]

CHARCONSTANT	(	UNINHERIT	,
		"UNINHERIT"
	)

CHARCONSTANT() [499/533]

CHARCONSTANT	(	UNINIT	,
		"UNINIT"
	)

CHARCONSTANT() [500/533]

CHARCONSTANT	(	UNKNOWN	,
		"UNKNOWN"
	)

CHARCONSTANT() [501/533]

CHARCONSTANT	(	UNKNOWNDISABLED	,
		"UNKNOWNDISABLED"
	)

CHARCONSTANT() [502/533]

CHARCONSTANT	(	UNPACK	,
		"UNPACK"
	)

CHARCONSTANT() [503/533]

CHARCONSTANT	(	UNPROTECTED	,
		"UNPROTECTED"
	)

CHARCONSTANT() [504/533]

CHARCONSTANT	(	UNSETMETHOD	,
		"UNSETMETHOD"
	)

CHARCONSTANT() [505/533]

CHARCONSTANT	(	UNTIL	,
		"UNTIL"
	)

CHARCONSTANT() [506/533]

CHARCONSTANT	(	UPPER	,
		"UPPER"
	)

CHARCONSTANT() [507/533]

CHARCONSTANT	(	USE	,
		"USE"
	)

CHARCONSTANT() [508/533]

CHARCONSTANT	(	USER	,
		"USER"
	)

CHARCONSTANT() [509/533]

CHARCONSTANT	(	USER_BLANK	,
		"USER "
	)

CHARCONSTANT() [510/533]

CHARCONSTANT	(	USERID	,
		"USERID"
	)

CHARCONSTANT() [511/533]

CHARCONSTANT	(	VALUE	,
		"VALUE"
	)

CHARCONSTANT() [512/533]

CHARCONSTANT	(	VALUES	,
		"VALUES"
	)

CHARCONSTANT() [513/533]

CHARCONSTANT	(	VAR	,
		"VAR"
	)

CHARCONSTANT() [514/533]

CHARCONSTANT	(	VARIABLE	,
		"VARIABLE"
	)

CHARCONSTANT() [515/533]

CHARCONSTANT	(	VARIABLES	,
		"VARIABLES"
	)

CHARCONSTANT() [516/533]

CHARCONSTANT	(	VERIFY	,
		"VERIFY"
	)

CHARCONSTANT() [517/533]

CHARCONSTANT	(	VERSION	,
		"VERSION"
	)

CHARCONSTANT() [518/533]

CHARCONSTANT	(	WEAKREFERENCE	,
		"WEAKREFERENCE"
	)

CHARCONSTANT() [519/533]

CHARCONSTANT	(	WHEN	,
		"WHEN"
	)

CHARCONSTANT() [520/533]

CHARCONSTANT	(	WHILE	,
		"WHILE"
	)

CHARCONSTANT() [521/533]

CHARCONSTANT	(	WITH	,
		"WITH"
	)

CHARCONSTANT() [522/533]

CHARCONSTANT	(	WORD	,
		"WORD"
	)

CHARCONSTANT() [523/533]

CHARCONSTANT	(	WORDINDEX	,
		"WORDINDEX"
	)

CHARCONSTANT() [524/533]

CHARCONSTANT	(	WORDLENGTH	,
		"WORDLENGTH"
	)

CHARCONSTANT() [525/533]

CHARCONSTANT	(	WORDPOS	,
		"WORDPOS"
	)

CHARCONSTANT() [526/533]

CHARCONSTANT	(	WORDS	,
		"WORDS"
	)

CHARCONSTANT() [527/533]

CHARCONSTANT	(	X2B	,
		"X2B"
	)

CHARCONSTANT() [528/533]

CHARCONSTANT	(	X2C	,
		"X2C"
	)

CHARCONSTANT() [529/533]

CHARCONSTANT	(	X2D	,
		"X2D"
	)

CHARCONSTANT() [530/533]

CHARCONSTANT	(	XOR	,
		"&&"
	)

CHARCONSTANT() [531/533]

CHARCONSTANT	(	XOR_RIGHT	,
		"&&OP:RIGHT"
	)

CHARCONSTANT() [532/533]

CHARCONSTANT	(	XRANGE	,
		"XRANGE"
	)

CHARCONSTANT() [533/533]

CHARCONSTANT	(	ZERO	,
		"0"
	)