home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
PC World 2000 August
/
PCWorld_2000-08_cd.bin
/
Software
/
TemaCD
/
xbasic
/
xbpro.exe
/
xb
/
qbtoxb.x
< prev
next >
Wrap
Text File
|
1999-12-29
|
122KB
|
2,805 lines
'
'
' #################### QuickBasic to XBasic translator
' ##### PROLOG ##### copyright 1999
' #################### Max Reason
'
PROGRAM "qbtoxb"
VERSION "0.0060"
'
IMPORT "xma"
IMPORT "xst"
IMPORT "xgr"
IMPORT "xui"
'
' This software is "open source", subject to the terms and conditions
' of the GPU = "GNU general public license", which is reproduced at
' http://www.opensource.org/licenses/gpl-license.html .
'
' Microsoft distributes a stripped-down QuickBasic product called QBasic,
' but throughout this program, qbasic and QBasic always refer-to QuickBasic.
'
' This program is currently work-in-progress and far from functional.
'
' This following summarizes the flow of this program.
'
' Entry() ' the entry function - start here
' LoadQBasicProgram() ' load QBasic program into qbasic$[]
' QBasicToXBasic() ' translate qbasic$[] source into xbasic$[]
' Initialize() ' initialize everything that needs initializing
' InitializeVariables() ' create and initialize fundamental variables and arrays
' InitializeQBasicTokens() ' defines all QBasic language-defined symbols and tokens
' InitializeXBasicTokens() ' defines all XBasic language-defined symbols and tokens
' InitializeQBasicTokens() ' adds XBasic-equivalent-tokens to QBasic tokens
' InitializeXBasicTokens() ' pass #2 probably not necessary for XBasic
' ParseQBasic() ' parse QBasic source-code into tokens
' CallsManyFunctions ' ParseQBasic() calls many functions
' Translate() ' translate tokens into XBasic source
' TranslateLine() ' translate line of tokens to XBasic
' CallsManyFunctions ' Translate() calls many functions
'
'
' Parsing a QuickBasic program creates an array of token-numbers
' in three-dimensional array #program[function,line,token].
' The lower 24-bits of a token is the token-number, which gives
' access to information about the token at #token[token-number].
' The upper 8-bits of a token contains leading-whitespace info.
' See the TOKEN composite data-type declaration below for details.
'
'
' #######################################
' ##### composite/structure types #####
' #######################################
'
' TOKEN variables hold both QBasic and XBasic tokens.
'
TYPE TOKEN '
XLONG .token ' token number in #token[]
XLONG .string ' string number in #string$[]
XLONG .length ' length of string in characters
XLONG .function ' function number this string is in
XLONG .hashback ' previous token with same hash
XLONG .hashnext ' next token with same hash
XLONG .kindback ' previous token of same kind
XLONG .kindnext ' next token of same kind
XLONG .first ' first executable line in source
XLONG .final ' final executable line in source
XLONG .hash ' hash value of this string
XLONG .kind ' statement, operator, etc.
XLONG .type ' data-type - SBYTE, UBYTE, SSHORT, USHORT, etc.
XLONG .scope ' scope of allocation - AUTO, STATIC, SHARED, EXTERNAL
XLONG .translate ' translate token - in other language
XLONG .address ' address in memory
XLONG .akind[15] ' argument kinds
XLONG .atype[15] ' argument data-types
GIANT .ivalue ' any integer-type value
DOUBLE .fvalue ' floating-point value
XLONG .lineq ' function source line - QB
XLONG .linex ' function source line - XB
XLONG .reserve54 '
XLONG .reserve55 '
XLONG .reserve56 '
XLONG .reserve57 '
XLONG .reserve58 '
XLONG .reserve59 '
XLONG .reserve60 '
XLONG .reserve61 '
XLONG .reserve62 '
XLONG .reserve63 '
END TYPE
'
'
' #######################
' ##### functions #####
' #######################
'
DECLARE FUNCTION Entry ()
DECLARE FUNCTION Initialize ()
DECLARE FUNCTION InitializeVariables ()
DECLARE FUNCTION InitializeQBasicTokens ()
DECLARE FUNCTION InitializeXBasicTokens ()
DECLARE FUNCTION LoadQBasicProgram (@qbasic$[]) ' find and load QBasic program
DECLARE FUNCTION QBasicToXBasic (@qbasic$[], @xbasic$[]) ' translate QBasic to XBasic
DECLARE FUNCTION ParseQBasic () ' parse QBasic program to create tokens
DECLARE FUNCTION Translate () ' translate program tokens to XBasic source
DECLARE FUNCTION TranslateLine (@line[]) ' translate line of tokens to XBasic source
DECLARE FUNCTION TranslateStatement (@line[], @offset) ' translate statement on line to XBasic source
'
DECLARE FUNCTION DeparseTokens (@token[], @line$) ' convert tokens into line of source
DECLARE FUNCTION ParseSourceLine (@line$, @line[]) ' parse source line into tokens
DECLARE FUNCTION ParseWhitespace (@line$, @offset) ' parse whitespace characters
DECLARE FUNCTION ParseCharacter (@line$, @offset) ' parse special character (operators, etc)
DECLARE FUNCTION ParseNumber (@line$, @offset) ' parse numeric string
DECLARE FUNCTION ParseSymbol (@line$, @offset) ' parse symbol
DECLARE FUNCTION GetSymbol (@line$, @offset, @symbol$) ' get symbol
DECLARE FUNCTION OutputToken (@token) ' output token
DECLARE FUNCTION TestForKeyword (@symbol$) ' keyword?
DECLARE FUNCTION MinTypeFromGiant (value$$) ' integer type
DECLARE FUNCTION MinTypeFromDouble (value#) ' float type
'
DECLARE FUNCTION AddKeyword (translate, function, scope, kind, type, atype1, atype2, atype3, @string$)
DECLARE FUNCTION FindToken (@match[], function, scope, kind, type, atype1, atype2, atype3, @string$)
DECLARE FUNCTION AddToken (@token, function, scope, kind, type, atype1, atype2, atype3, @string$)
DECLARE FUNCTION OutputXBasic (@text$[])
DECLARE FUNCTION TokenRestOfLine ()
DECLARE FUNCTION PrintTokens ()
DECLARE FUNCTION PrintHash ()
DECLARE FUNCTION Terminate ()
'
'
'
' ##############################
' ##### shared constants #####
' ##############################
'
$$TYPE_NONE = 0x00000000 ' NONE - type unknown
$$TYPE_VOID = 0x00000001 ' VOID - type prohibited
$$TYPE_SBYTE = 0x00000002 ' SBYTE - 8-bit signed integer
$$TYPE_UBYTE = 0x00000003 ' UBYTE - 8-bit unsigned integer
$$TYPE_SSHORT = 0x00000004 ' SSHORT - 16-bit signed integer
$$TYPE_USHORT = 0x00000005 ' USHORT - 16-bit unsigned integer
$$TYPE_SLONG = 0x00000006 ' SLONG - 32-bit signed integer
$$TYPE_ULONG = 0x00000007 ' ULONG - 32-bit unsigned integer
$$TYPE_XLONG = 0x00000008 ' XLONG - CPU integer
$$TYPE_GOADDR = 0x00000009 ' GOADDR - label address
$$TYPE_SUBADDR = 0x0000000A ' SUBADDR - subroutine address
$$TYPE_FUNCADDR = 0x0000000B ' FUNCADDR - function address
$$TYPE_GIANT = 0x0000000C ' GIANT - 64-bit signed integer
$$TYPE_SINGLE = 0x0000000D ' SINGLE - IEEE 32-bit
$$TYPE_DOUBLE = 0x0000000E ' DOUBLE - IEEE 64-bit
$$TYPE_UNDEFINED = 0x0000000F '
$$TYPE_STRING = 0x00000013 ' STRING - string/array of UBYTEs
$$TYPE_STRING_ASCII = 0x00000013 ' STRING - string/array of UBYTEs
$$TYPE_STRING_UNICODE = 0x00000015 ' UNICODE - string/array of USHORTs
$$TYPE_COMPOSITE_FIRST = 0x00000020 ' first composite type
$$TYPE_COMPOSITE_FINAL = 0x0000FFFF ' final composite type
'
$$FORM_BIT = 0x00010001 ' 0b01001101
$$FORM_OCTAL = 0x00010002 ' 0o01234567
$$FORM_DECIMAL = 0x00010003 ' 1234567890
$$FORM_HEXADECIMAL = 0x00010004 ' 0x0123456789ABCDEF or &H0123456789ABCDEF
'
$$KIND_NONE = 0x00000000 ' kind unknown
$$KIND_STATEMENT = 0x00000001 ' language statement
$$KIND_INTRINSIC = 0x00000002 ' intrinsic function
$$KIND_OPERATOR = 0x00000004 ' OR AND XOR + - * \ / etc.
$$KIND_KEYWORD = 0x00000008 '
$$KIND_LABEL = 0x00000010 ' GOTO label
$$KIND_SUBNAME = 0x00000020 ' GOSUB subname
$$KIND_FUNCTION = 0x00000040 ' function in program
$$KIND_TYPE = 0x00000080 ' data-type
$$KIND_SYMBOL = 0x00000100 ' unknown kind of symbol
$$KIND_LITERAL = 0x00000200 ' number or string
$$KIND_CHARCON = 0x00000400 ' character constant - as in 'a'
$$KIND_CONSTANT = 0x00000800 ' user-defined constant
$$KIND_VARIABLE = 0x00001000 ' simple variable
$$KIND_ARRAY = 0x00002000 ' array variable
$$KIND_COMPOSITE = 0x00004000 ' structure symbol
$$KIND_ELEMENT = 0x00008000 ' structure element
$$KIND_COMMENT = 0x00010000 ' rest of the line
$$KIND_CHARACTER = 0x00020000 ' : ; , ( )
$$KIND_WHITESTRING = 0x00040000 ' string of whitespace
$$KIND_AVAILABLE_19 = 0x00080000 '
$$KIND_AVAILABLE_20 = 0x00100000 '
$$KIND_AVAILABLE_21 = 0x00200000 '
$$KIND_AVAILABLE_22 = 0x00400000 '
$$KIND_AVAILABLE_23 = 0x00800000 '
$$KIND_AVAILABLE_24 = 0x01000000 '
$$KIND_AVAILABLE_25 = 0x02000000 '
$$KIND_AVAILABLE_26 = 0x04000000 '
$$KIND_AVAILABLE_27 = 0x08000000 '
$$KIND_AVAILABLE_28 = 0x10000000 '
$$KIND_AVAILABLE_29 = 0x20000000 '
$$KIND_QBASIC = 0x40000000 ' QBasic language element
$$KIND_XBASIC = 0x80000000 ' XBasic language element
'
$$SCOPE_NONE = 0x00000000 ' scope unknown
$$SCOPE_AUTO = 0x00000001 ' function and temporary
$$SCOPE_AUTOX = 0x00000002 ' function and temporary
$$SCOPE_STATIC = 0x00000003 ' function and permanent
$$SCOPE_SHARED = 0x00000004 ' program and permanent
$$SCOPE_SHARED_NAME = 0x00000005 ' program and permanent - sharename
$$SCOPE_EXTERNAL = 0x00000006 ' modules and permanent - static linked modules
$$SCOPE_EXTERNAL_NAME = 0x00000007 ' modules and permanent - static linked modules - sharename
'
$$MIN_SBYTE = -128
$$MAX_SBYTE = 127
$$MIN_UBYTE = 0
$$MAX_UBYTE = 255
$$MIN_SSHORT = -32768
$$MAX_SSHORT = 32767
$$MIN_USHORT = 0
$$MAX_USHORT = 65535
$$MIN_SLONG = -2147483648
$$MAX_SLONG = 2147483647
$$MIN_ULONG = 0
$$MAX_ULONG = 4294967395$$
$$MIN_XLONG = $$MIN_SLONG
$$MAX_XLONG = $$MAX_ULONG
$$MIN_GOADDR = $$MIN_XLONG
$$MAX_GOADDR = $$MAX_XLONG
$$MIN_SUBADDR = $$MIN_XLONG
$$MAX_SUBADDR = $$MAX_XLONG
$$MIN_FUNCADDR = $$MIN_XLONG
$$MAX_FUNCADDR = $$MAX_XLONG
$$MIN_SINGLE = 0sFF7FFFFF
$$MAX_SINGLE = 0s7F7FFFFF
$$MIN_DOUBLE = 0dFFEFFFFFFFFFFFFF
$$MAX_DOUBLE = 0d7FEFFFFFFFFFFFFF
$$MIN_GIANT = 0x8000000000000000
$$MAX_GIANT = 0x7FFFFFFFFFFFFFFF
'
'
' ##############################
' ##### shared variables #####
' ##############################
'
TOKEN #toktemp ' temporary - for compiler tests
XLONG #print ' temporary - for debugging
'
XLONG #pass ' pass # for parse or compile
XLONG #line ' current line in function
XLONG #token ' current token on line
XLONG #function ' function being parsed or translated
XLONG #whitebyte ' whitestring # = entry in #whitestring$[]
'
XLONG #ustring ' upper-bound of #string$[]
XLONG #nstring ' next slot in #string$[]
XLONG #utoken ' upper-bound of #token[]
XLONG #ntoken ' next slot in #token[]
'
XLONG #quline ' upper QBasic source-code line
XLONG #qnline ' next QBasic source-code line
XLONG #xuline ' upper XBasic source-code line
XLONG #xnline ' next XBasic source-code line
'
XLONG #qatoken ' first QBasic keyword token-number
XLONG #qztoken ' final QBasic keyword token-number
XLONG #xatoken ' first XBasic keyword token-number
XLONG #xztoken ' final XBasic keyword token-number
'
USHORT #hx[] ' hash mixer
XLONG #hash[] ' hash table
XLONG #kind[] ' first token of each kind
TOKEN #token[] ' holds all symbol-table tokens
STRING #string$[] ' holds all symbol-table strings
XLONG #program[] ' holds token-numbers for entire program : #program[function,line,token]
XLONG #functoken[] ' holds token-number of every function in the program
XLONG #whitetoken[] ' token-numbers of 256 leading-whitespace strings representable in upper-byte of tokens
'
STRING #qbasic$[] ' holds entire QBasic source program
STRING #xbasic$[] ' holds entire XBasic source program
'
' the following arrays test and/or convert characters in a single array access
'
UBYTE #charsetSymbolFirst[]
UBYTE #charsetSymbolInner[]
UBYTE #charsetSymbolFinal[]
UBYTE #charsetSymbol[]
UBYTE #charsetUpper[]
UBYTE #charsetLower[]
UBYTE #charsetNumeric[]
UBYTE #charsetUpperLower[]
UBYTE #charsetUpperNumeric[]
UBYTE #charsetLowerNumeric[]
UBYTE #charsetUpperLowerNumeric[]
UBYTE #charsetUpperToLower[]
UBYTE #charsetLowerToUpper[]
UBYTE #charsetVex[]
UBYTE #charsetHexUpper[]
UBYTE #charsetHexLower[]
UBYTE #charsetHexUpperLower[]
UBYTE #charsetHexUpperToLower[]
UBYTE #charsetHexLowerToUpper[]
UBYTE #charsetBackslash[]
UBYTE #charsetBackslashByte[]
UBYTE #charsetBackslashChar[]
UBYTE #charsetNormalChar[]
UBYTE #charsetOctal[]
UBYTE #charsetPrintChar[]
UBYTE #charsetSuffix[]
UBYTE #charsetSpaceTab[]
UBYTE #charsetWhitespace[]
'
'
' ######################
' ##### Entry () #####
' ######################
'
FUNCTION Entry ()
'
XstGetConsoleGrid (@console)
XgrGetDisplaySize ("", @#displayWidth, @#displayHeight, @#windowBorderWidth, @#windowTitleHeight)
maxwidth = #displayWidth - #windowBorderWidth - #windowBorderWidth
XuiSendStringMessage (console, @"GetSize", @x, @y, @w, @h, 0, 0)
width = MIN (maxwidth, 1016)
height = h
'
' set console width for printing speed efficiency and smoothness
'
XuiSendStringMessage (console, @"Resize", 0, 0, width, height, 0, 0)
'
LoadQBasicProgram (@qbasic$[]) ' load QBasic program into qbasic$[]
QBasicToXBasic (@qbasic$[], @xbasic$[]) ' translate qbasic$[] into xbasic$[]
END FUNCTION
'
'
' ###########################
' ##### Initialize () #####
' ###########################
'
FUNCTION Initialize ()
'
#print = 1
'
#pass = 0 '
InitializeVariables () ' create arrays for tokens, symbols, etc.
'
#pass = 1
#ntoken = 0 ' zero token number
#nstring = 0 ' zero string number
InitializeXBasicTokens () ' pass 1 cannot fill-in equivalent QBasic tokens
InitializeQBasicTokens () ' pass 1 cannot fill-in equivalent XBasic tokens
'
#pass = 2
#ntoken = 0 ' zero token number
#nstring = 0 ' zero string number
InitializeXBasicTokens () ' pass 2 can fill-in equivalent QBasic tokens
InitializeQBasicTokens () ' pass 2 can fill-in equivalent XBasic tokens
'
#pass = 0 '
IF #print THEN PrintTokens () ' look at the tokens
'
IF #print THEN
PRINT " "; HEX$(#xatoken,4);; HEX$(#xztoken,4);; HEX$(#qatoken,4);; HEX$(#qztoken,4)
PRINT
PrintHash () ' look at hash table
END IF
END FUNCTION
'
'
' ####################################
' ##### InitializeVariables () #####
' ####################################
'
FUNCTION InitializeVariables ()
'
#nwhite = 0 ' start at white 0
#ntoken = 0 ' start at token 0
#nstring = 0 ' start at string 0
#function = 0 ' start with PROLOG
'
#uhash = 255 ' 8-bit hash size for now
#uwhite = 255 ' maximum of 255 whitestrings
#utoken = 4095 ' start with room for 4096 tokens
#ustring = 4095 ' start with room for 4096 strings
#ufunction = 1023 ' start with room for 1024 functions
#uwhitestring = 255 ' never more than 255 leading-whitestring tokens
'
DIM #hx[255] ' dimension hash mix
DIM #hash[#uhash] ' dimension hash array
DIM #token[#utoken] ' dimension token array
DIM #string$[#ustring] ' dimension string array
DIM #program[#ufunction,] ' dimension program array
DIM #functoken[#ufunction] ' dimension function array
DIM #whitetoken[#uwhitestring] ' dimension whitetoken array
DIM #whitestring$[#uwhitestring] ' dimension whitestring array
'
#hx[ 0] = 0xF3C9 : #hx[ 64] = 0x811D : #hx[128] = 0x199C : #hx[192] = 0xD0C8
#hx[ 1] = 0xE034 : #hx[ 65] = 0xC6E3 : #hx[129] = 0x1299 : #hx[193] = 0x3C07
#hx[ 2] = 0xB37C : #hx[ 66] = 0xCA5D : #hx[130] = 0xA314 : #hx[194] = 0xDDCA
#hx[ 3] = 0x4E31 : #hx[ 67] = 0x5AF2 : #hx[131] = 0xEF45 : #hx[195] = 0xB2C1
#hx[ 4] = 0xC0DE : #hx[ 68] = 0xB2F3 : #hx[132] = 0xEFC3 : #hx[196] = 0x6A7C
#hx[ 5] = 0x2487 : #hx[ 69] = 0xCF28 : #hx[133] = 0x8A2D : #hx[197] = 0x5E02
#hx[ 6] = 0x98E2 : #hx[ 70] = 0x4714 : #hx[134] = 0x2553 : #hx[198] = 0x4C8B
#hx[ 7] = 0x557C : #hx[ 71] = 0x32B0 : #hx[135] = 0x8CA6 : #hx[199] = 0x6652
#hx[ 8] = 0xA6CB : #hx[ 72] = 0x9A76 : #hx[136] = 0x60B8 : #hx[200] = 0x3C50
#hx[ 9] = 0x410D : #hx[ 73] = 0xB2A4 : #hx[137] = 0x2192 : #hx[201] = 0x02B8
#hx[ 10] = 0x7767 : #hx[ 74] = 0xDE9B : #hx[138] = 0xA15C : #hx[202] = 0x7B70
#hx[ 11] = 0x3861 : #hx[ 75] = 0xE0E1 : #hx[139] = 0xA527 : #hx[203] = 0x118F
#hx[ 12] = 0x5517 : #hx[ 76] = 0xA7C3 : #hx[140] = 0x1FAC : #hx[204] = 0xEF65
#hx[ 13] = 0x0918 : #hx[ 77] = 0x0E48 : #hx[141] = 0xC554 : #hx[205] = 0x3D6E
#hx[ 14] = 0xF3AF : #hx[ 78] = 0xFABE : #hx[142] = 0x5ECB : #hx[206] = 0xCAB2
#hx[ 15] = 0x2EAB : #hx[ 79] = 0xE351 : #hx[143] = 0x7941 : #hx[207] = 0x23F0
#hx[ 16] = 0x210D : #hx[ 80] = 0x4419 : #hx[144] = 0x3EA2 : #hx[208] = 0x927F
#hx[ 17] = 0xDF19 : #hx[ 81] = 0x5AB4 : #hx[145] = 0xE73D : #hx[209] = 0x1F12
#hx[ 18] = 0x2F0B : #hx[ 82] = 0xDDF9 : #hx[146] = 0xDE62 : #hx[210] = 0xEDCE
#hx[ 19] = 0x269A : #hx[ 83] = 0x513E : #hx[147] = 0x9FFA : #hx[211] = 0x0D52
#hx[ 20] = 0xE171 : #hx[ 84] = 0x1BDF : #hx[148] = 0x0CE8 : #hx[212] = 0x69B5
#hx[ 21] = 0x8D07 : #hx[ 85] = 0xA0BC : #hx[149] = 0x8683 : #hx[213] = 0x9DC4
#hx[ 22] = 0x0AF1 : #hx[ 86] = 0xC2E5 : #hx[150] = 0x481C : #hx[214] = 0x910F
#hx[ 23] = 0x4627 : #hx[ 87] = 0x5917 : #hx[151] = 0x80E4 : #hx[215] = 0xEE6D
#hx[ 24] = 0x7C4B : #hx[ 88] = 0x0448 : #hx[152] = 0xC43E : #hx[216] = 0xA0E7
#hx[ 25] = 0xA59A : #hx[ 89] = 0xE110 : #hx[153] = 0x7830 : #hx[217] = 0xF2ED
#hx[ 26] = 0x561F : #hx[ 90] = 0xA4C8 : #hx[154] = 0x3952 : #hx[218] = 0x6EA2
#hx[ 27] = 0x1F90 : #hx[ 91] = 0x5BC6 : #hx[155] = 0x2BBA : #hx[219] = 0xFEFC
#hx[ 28] = 0x9407 : #hx[ 92] = 0x1250 : #hx[156] = 0x476D : #hx[220] = 0x0A20
#hx[ 29] = 0xAAAA : #hx[ 93] = 0x3D09 : #hx[157] = 0xF307 : #hx[221] = 0xA568
#hx[ 30] = 0x404B : #hx[ 94] = 0xD230 : #hx[158] = 0x5A6A : #hx[222] = 0xB90E
#hx[ 31] = 0xCCB2 : #hx[ 95] = 0x19F1 : #hx[159] = 0x232A : #hx[223] = 0xFA26
#hx[ 32] = 0xB6B8 : #hx[ 96] = 0x28D0 : #hx[160] = 0x36DA : #hx[224] = 0xFB8E
#hx[ 33] = 0x93E5 : #hx[ 97] = 0x0FD7 : #hx[161] = 0x1448 : #hx[225] = 0x3091
#hx[ 34] = 0xCD83 : #hx[ 98] = 0x79BD : #hx[162] = 0x016A : #hx[226] = 0x56A1
#hx[ 35] = 0x8392 : #hx[ 99] = 0xE856 : #hx[163] = 0xF0CC : #hx[227] = 0x184A
#hx[ 36] = 0x951B : #hx[100] = 0xDDDE : #hx[164] = 0x5328 : #hx[228] = 0xDEC0
#hx[ 37] = 0x983F : #hx[101] = 0xBD28 : #hx[165] = 0x8B83 : #hx[229] = 0xC39F
#hx[ 38] = 0x1BB3 : #hx[102] = 0xD9F7 : #hx[166] = 0x1566 : #hx[230] = 0xBED3
#hx[ 39] = 0x40A7 : #hx[103] = 0xCBB9 : #hx[167] = 0xB0D3 : #hx[231] = 0x51F5
#hx[ 40] = 0x5D7E : #hx[104] = 0x9B85 : #hx[168] = 0xCE2F : #hx[232] = 0xC0E9
#hx[ 41] = 0x65A1 : #hx[105] = 0x82DC : #hx[169] = 0x30FA : #hx[233] = 0x617B
#hx[ 42] = 0x8576 : #hx[106] = 0x67B0 : #hx[170] = 0x49C6 : #hx[234] = 0xF6E9
#hx[ 43] = 0xAC39 : #hx[107] = 0x8720 : #hx[171] = 0x94D9 : #hx[235] = 0x9775
#hx[ 44] = 0xFE04 : #hx[108] = 0x0CDF : #hx[172] = 0xE69B : #hx[236] = 0xD5A5
#hx[ 45] = 0x6C6F : #hx[109] = 0xA884 : #hx[173] = 0x7B2C : #hx[237] = 0xF7D3
#hx[ 46] = 0x838F : #hx[110] = 0x238D : #hx[174] = 0x340B : #hx[238] = 0x2BD5
#hx[ 47] = 0xDA44 : #hx[111] = 0xACED : #hx[175] = 0x2E46 : #hx[239] = 0xBB3D
#hx[ 48] = 0x7B93 : #hx[112] = 0x773B : #hx[176] = 0xFD83 : #hx[240] = 0x1483
#hx[ 49] = 0x851E : #hx[113] = 0x84F1 : #hx[177] = 0xB1A9 : #hx[241] = 0x5906
#hx[ 50] = 0xD23F : #hx[114] = 0xB1A6 : #hx[178] = 0x6F78 : #hx[242] = 0x6D25
#hx[ 51] = 0x1F47 : #hx[115] = 0x049F : #hx[179] = 0xF3FE : #hx[243] = 0x0BEE
#hx[ 52] = 0x7C74 : #hx[116] = 0x8B30 : #hx[180] = 0x387B : #hx[244] = 0xE76B
#hx[ 53] = 0xBF9D : #hx[117] = 0xB545 : #hx[181] = 0xCCC2 : #hx[245] = 0x6751
#hx[ 54] = 0x7646 : #hx[118] = 0x48EC : #hx[182] = 0x762C : #hx[246] = 0x2A06
#hx[ 55] = 0xC9FF : #hx[119] = 0xF885 : #hx[183] = 0x603E : #hx[247] = 0x49E3
#hx[ 56] = 0x7944 : #hx[120] = 0x3985 : #hx[184] = 0x02F9 : #hx[248] = 0x9854
#hx[ 57] = 0x953D : #hx[121] = 0x3D6A : #hx[185] = 0x3F51 : #hx[249] = 0x11F4
#hx[ 58] = 0xE666 : #hx[122] = 0x6871 : #hx[186] = 0x6C2E : #hx[250] = 0xA655
#hx[ 59] = 0xB2DA : #hx[123] = 0x2F08 : #hx[187] = 0x0777 : #hx[251] = 0x742F
#hx[ 60] = 0x743C : #hx[124] = 0x94DE : #hx[188] = 0xE456 : #hx[252] = 0x8C19
#hx[ 61] = 0xDB99 : #hx[125] = 0x4CA5 : #hx[189] = 0x7AA0 : #hx[253] = 0xB74A
#hx[ 62] = 0x48BB : #hx[126] = 0xD5EA : #hx[190] = 0x0766 : #hx[254] = 0xD219
#hx[ 63] = 0xF794 : #hx[127] = 0xAD4C : #hx[191] = 0x4882 : #hx[255] = 0x63DD
'
'
' dimension charset arrays - all have 256 entries, one for each byte/character value
'
DIM #charsetSymbolFirst[255]
DIM #charsetSymbolInner[255]
DIM #charsetSymbolFinal[255]
DIM #charsetSymbol[255]
DIM #charsetUpper[255]
DIM #charsetLower[255]
DIM #charsetNumeric[255]
DIM #charsetUpperLower[255]
DIM #charsetUpperNumeric[255]
DIM #charsetLowerNumeric[255]
DIM #charsetUpperLowerNumeric[255]
DIM #charsetUpperToLower[255]
DIM #charsetLowerToUpper[255]
DIM #charsetVex[255]
DIM #charsetHexUpper[255]
DIM #charsetHexLower[255]
DIM #charsetHexUpperLower[255]
DIM #charsetHexUpperToLower[255]
DIM #charsetHexLowerToUpper[255]
DIM #charsetBackslash[255]
DIM #charsetBackslashByte[255]
DIM #charsetBackslashChar[255]
DIM #charsetNormalChar[255]
DIM #charsetOctal[255]
DIM #charsetPrintChar[255]
DIM #charsetSuffix[255]
DIM #charsetSpaceTab[255]
DIM #charsetWhitespace[255]
'
'
' ***********************************
' ***** #charsetSymbolFirst[] ***** A-Z a-z (others 0)
' ***********************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= 'A') AND (i <= 'Z')) : #charsetSymbolFirst[i] = i
CASE ((i >= 'a') AND (i <= 'z')) : #charsetSymbolFirst[i] = i
CASE (i = '_') : #charsetSymbolFirst[i] = i
CASE ELSE : #charsetSymbolFirst[i] = 0
END SELECT
NEXT i
'
'
' ***********************************
' ***** #charsetSymbolInner[] ***** A-Z a-z 0-9 "_" (others 0)
' ***********************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetSymbolInner[i] = i
CASE ((i >= 'A') AND (i <= 'Z')) : #charsetSymbolInner[i] = i
CASE ((i >= 'a') AND (i <= 'z')) : #charsetSymbolInner[i] = i
CASE (i = '_') : #charsetSymbolInner[i] = i
CASE ELSE : #charsetSymbolInner[i] = 0
END SELECT
NEXT i
'
'
' ***********************************
' ***** #charsetSymbolFinal[] ***** A-Z a-z 0-9 "_" (others 0)
' ***********************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetSymbolFinal[i] = i
CASE ((i >= 'A') AND (i <= 'Z')) : #charsetSymbolFinal[i] = i
CASE ((i >= 'a') AND (i <= 'z')) : #charsetSymbolFinal[i] = i
CASE (i = '_') : #charsetSymbolFinal[i] = i
CASE ELSE : #charsetSymbolFinal[i] = 0
END SELECT
NEXT i
'
'
' ******************************
' ***** #charsetSymbol[] ***** A-Z a-z 0-9 "_" (others 0)
' ******************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetSymbol[i] = i
CASE ((i >= 'A') AND (i <= 'Z')) : #charsetSymbol[i] = i
CASE ((i >= 'a') AND (i <= 'z')) : #charsetSymbol[i] = i
CASE (i = '_') : #charsetSymbol[i] = i
CASE ELSE : #charsetSymbol[i] = 0
END SELECT
NEXT i
'
'
' *****************************
' ***** #charsetUpper[] ***** A-Z (others 0)
' *****************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= 'A') AND (i <= 'Z')) : #charsetUpper[i] = i
CASE ELSE : #charsetUpper[i] = 0
END SELECT
NEXT i
'
'
' *****************************
' ***** #charsetLower[] ***** a-z (others 0)
' *****************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= 'a') AND (i <= 'z')) : #charsetLower[i] = i
CASE ELSE : #charsetLower[i] = 0
END SELECT
NEXT i
'
'
' *******************************
' ***** #charsetNumeric[] ***** 0-9 (others 0)
' *******************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetNumeric[i] = i
CASE ELSE : #charsetNumeric[i] = 0
END SELECT
NEXT i
'
'
' **********************************
' ***** #charsetUpperLower[] ***** A-Z a-z (others 0)
' **********************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= 'A') AND (i <= 'Z')) : #charsetUpperLower[i] = i
CASE ((i >= 'a') AND (i <= 'z')) : #charsetUpperLower[i] = i
CASE ELSE : #charsetUpperLower[i] = 0
END SELECT
NEXT i
'
'
' ************************************
' ***** #charsetUpperNumeric[] ***** A-Z 0-9 (others 0)
' ************************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetUpperNumeric[i] = i
CASE ((i >= 'A') AND (i <= 'Z')) : #charsetUpperNumeric[i] = i
CASE ELSE : #charsetUpperNumeric[i] = 0
END SELECT
NEXT i
'
'
' ************************************
' ***** #charsetLowerNumeric[] ***** a-z 0-9 (others 0)
' ************************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetLowerNumeric[i] = i
CASE ((i >= 'a') AND (i <= 'z')) : #charsetLowerNumeric[i] = i
CASE ELSE : #charsetLowerNumeric[i] = 0
END SELECT
NEXT i
'
'
' *****************************************
' ***** #charsetUpperLowerNumeric[] ***** A-Z a-z 0-9 (others 0)
' *****************************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetUpperLowerNumeric[i] = i
CASE ((i >= 'A') AND (i <= 'Z')) : #charsetUpperLowerNumeric[i] = i
CASE ((i >= 'a') AND (i <= 'z')) : #charsetUpperLowerNumeric[i] = i
CASE ELSE : #charsetUpperLowerNumeric[i] = 0
END SELECT
NEXT i
'
'
' ************************************
' ***** #charsetUpperToLower[] ***** A-Z ==>> a-z (others unchanged)
' ************************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= 'A') AND (i <= 'Z')) : #charsetUpperToLower[i] = i + 32
CASE ELSE : #charsetUpperToLower[i] = i
END SELECT
NEXT i
'
'
' ************************************
' ***** #charsetLowerToUpper[] ***** a-z ==>> A-Z (others unchanged)
' ************************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= 'a') AND (i <= 'z')) : #charsetLowerToUpper[i] = i - 32
CASE ELSE : #charsetLowerToUpper[i] = i
END SELECT
NEXT i
'
'
' ***************************
' ***** #charsetVex[] ***** 0-9 A-V (others 0)
' ***************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetVex[i] = i
CASE ((i >= 'A') AND (i <= 'V')) : #charsetVex[i] = i
CASE ELSE : #charsetVex[i] = 0
END SELECT
NEXT i
'
'
' *****************************
' ***** #charsetOctal[] ***** 0-7
' *****************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '7')) : #charsetHexUpper[i] = i
CASE ELSE : #charsetHexUpper[i] = 0
END SELECT
NEXT i
'
'
' ********************************
' ***** #charsetHexUpper[] ***** 0-9 A-F (others 0)
' ********************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetHexUpper[i] = i
CASE ((i >= 'A') AND (i <= 'F')) : #charsetHexUpper[i] = i
CASE ELSE : #charsetHexUpper[i] = 0
END SELECT
NEXT i
'
'
' ********************************
' ***** #charsetHexLower[] ***** 0-9 a-f (others 0)
' ********************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetHexLower[i] = i
CASE ((i >= 'a') AND (i <= 'f')) : #charsetHexLower[i] = i
CASE ELSE : #charsetHexLower[i] = 0
END SELECT
NEXT i
'
'
' *************************************
' ***** #charsetHexUpperLower[] ***** 0-9 A-F a-f (others 0)
' *************************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetHexUpperLower[i] = i
CASE ((i >= 'A') AND (i <= 'F')) : #charsetHexUpperLower[i] = i
CASE ((i >= 'a') AND (i <= 'f')) : #charsetHexUpperLower[i] = i
CASE ELSE : #charsetHexUpperLower[i] = 0
END SELECT
NEXT i
'
'
' *************************************** 0-9
' ***** #charsetHexUpperToLower[] ***** A-F ==>> a-f (others 0)
' *************************************** a-f
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetHexUpperToLower[i] = i
CASE ((i >= 'A') AND (i <= 'F')) : #charsetHexUpperToLower[i] = i + 32
CASE ((i >= 'a') AND (i <= 'f')) : #charsetHexUpperToLower[i] = i
CASE ELSE : #charsetHexUpperToLower[i] = 0
END SELECT
NEXT i
'
'
' *************************************** 0-9
' ***** #charsetHexLowerToUpper[] ***** a-f ==>> A-F (others 0)
' *************************************** A-F
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetHexLowerToUpper[i] = i
CASE ((i >= 'A') AND (i <= 'F')) : #charsetHexLowerToUpper[i] = i
CASE ((i >= 'a') AND (i <= 'f')) : #charsetHexLowerToUpper[i] = i - 32
CASE ELSE : #charsetHexLowerToUpper[i] = 0
END SELECT
NEXT i
'
'
' ********************************* \a \b \d \f \n \r \v \\ \" \z
' ***** #charsetBackslash[] ***** \0 - \V
' ********************************* (others unchanged)
'
' Convert character following a \ into the proper binary value
' For all characters without special binary values, return the character
'
offset = 10 - 'A'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE ((i >= '0') AND (i <= '9')) : #charsetBackslash[i] = i - '0'
CASE ((i >= 'A') AND (i <= 'V')) : #charsetBackslash[i] = i + offset
CASE ELSE : #charsetBackslash[i] = i
END SELECT
NEXT i
'
FOR i = 0 TO 255
SELECT CASE i
CASE '\\' : #charsetBackslash[i] = 0x5C ' backslash
CASE '"' : #charsetBackslash[i] = 0x22 ' double-quote
CASE 'a' : #charsetBackslash[i] = 0x07 ' alarm (bell)
CASE 'b' : #charsetBackslash[i] = 0x08 ' backspace
CASE 'd' : #charsetBackslash[i] = 0x7F ' delete
CASE 'e' : #charsetBackslash[i] = 0x1B ' escape
CASE 'f' : #charsetBackslash[i] = 0x0C ' form-feed
CASE 'n' : #charsetBackslash[i] = 0x0A ' newline
CASE 'r' : #charsetBackslash[i] = 0x0D ' return
CASE 't' : #charsetBackslash[i] = 0x09 ' tab
CASE 'v' : #charsetBackslash[i] = 0x0B ' vertical-tab
CASE 'z' : #charsetBackslash[i] = 0xFF ' finale (highest UBYTE)
END SELECT
NEXT i
'
'
' ************************************* \a \b \d \e \f \n \r \t \v
' ***** #charsetBackslashByte[] ***** \\ \"
' *************************************
'
' Return printable character intended to follow \ backslash character for
' SIMPLE (only simple) 1 character backslash codes, as understood by dumb
' assemblers, for example. Otherwise, return zero.
'
FOR i = 0 TO 255
SELECT CASE i
CASE 0x5C : #charsetBackslashByte[i] = '\\' ' backslash
CASE 0x22 : #charsetBackslashByte[i] = '"' ' double-quote
CASE 0x07 : #charsetBackslashByte[i] = 'a' ' alarm (bell)
CASE 0x08 : #charsetBackslashByte[i] = 'b' ' backspace
CASE 0x7F : #charsetBackslashByte[i] = 'd' ' delete
CASE 0x1B : #charsetBackslashByte[i] = 'e' ' escape
CASE 0x0C : #charsetBackslashByte[i] = 'f' ' form-feed
CASE 0x0A : #charsetBackslashByte[i] = 'n' ' newline
CASE 0x0D : #charsetBackslashByte[i] = 'r' ' return
CASE 0x09 : #charsetBackslashByte[i] = 't' ' tab
CASE 0x0B : #charsetBackslashByte[i] = 'v' ' vertical-tab
CASE 0x00 : #charsetBackslashByte[i] = '0' ' null
CASE ELSE : #charsetBackslashByte[i] = 0 ' non-simple backslash
END SELECT
NEXT i
'
'
' ************************************* \a \b \d \e \f \n \r \t \v
' ***** #charsetBackslashChar[] ***** \\ \"
' *************************************
'
' Return printable character intended to follow \ backslash character
' Return bytes that are normal, printable, non-backslash characters
'
FOR i = 0 TO 255
SELECT CASE i
CASE 0x5C : #charsetBackslashChar[i] = '\\' ' backslash
CASE 0x22 : #charsetBackslashChar[i] = '"' ' double-quote
CASE 0x07 : #charsetBackslashChar[i] = 'a' ' alarm (bell)
CASE 0x08 : #charsetBackslashChar[i] = 'b' ' backspace
CASE 0x7F : #charsetBackslashChar[i] = 'd' ' delete
CASE 0x1B : #charsetBackslashChar[i] = 'e' ' escape
CASE 0x0C : #charsetBackslashChar[i] = 'f' ' form-feed
CASE 0x0A : #charsetBackslashChar[i] = 'n' ' newline
CASE 0x0D : #charsetBackslashChar[i] = 'r' ' return
CASE 0x09 : #charsetBackslashChar[i] = 't' ' tab
CASE 0x0B : #charsetBackslashChar[i] = 'v' ' vertical-tab
CASE ELSE : #charsetBackslashChar[i] = 0 ' not a backslash char
END SELECT
NEXT i
'
'
' ********************************** 0x00 - 0x1F ===>> 0
' ***** #charsetNormalChar[] ***** 0x7F - 0xFF ===>> 0 (others unchanged)
' ********************************** \ and " ===>> 0
'
' Normal printable characters = the character, all others = 0
' NOTE: tab, newline, etc... not considered normal printable characters
' NOTE: backslash not considered normal printable character (need \\)
' NOTE: double-quote not considered normal printable character (need \")
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE (i <= 31) : #charsetNormalChar[i] = 0
CASE (i >= 127) : #charsetNormalChar[i] = 0
CASE (i = '\\') : #charsetNormalChar[i] = 0
CASE (i = '"') : #charsetNormalChar[i] = 0
CASE ELSE : #charsetNormalChar[i] = i
END SELECT
NEXT i
'
'
' ********************************* 0x00 - 0x1F ===>> 0
' ***** #charsetPrintChar[] ***** 0x7F - 0xFF ===>> 0
' ********************************* (others unchanged)
'
' Printable characters = the character, all others = 0
' NOTE: tab, newline, etc... not considered normal printable characters
' NOTE: backslash is a printable character
' NOTE: double-quote is a printable character
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE (i <= 31) : #charsetPrintChar[i] = 0
CASE (i >= 127) : #charsetPrintChar[i] = 0
CASE ELSE : #charsetPrintChar[i] = i
END SELECT
NEXT i
'
'
' ******************************
' ***** #charsetSuffix[] ***** valid type suffixes
' ******************************
'
#charsetSuffix['%'] = '%'
#charsetSuffix['&'] = '&'
#charsetSuffix['!'] = '!'
#charsetSuffix['#'] = '#'
#charsetSuffix['$'] = '$'
'
'
' ********************************
' ***** #charsetSpaceTab[] ***** only <space> and <tab> are true
' ********************************
'
#charsetSpaceTab[0x09] = 0x09 ' <tab> = '\t'
#charsetSpaceTab[0x20] = 0x20 ' <space> = ' '
'
'
' **********************************
' ***** #charsetWhitespace[] ***** all whitespace characters (space, tab, garbage)
' **********************************
'
FOR i = 0 TO 255
SELECT CASE TRUE
CASE (i <= 0x20) : #charsetWhitespace[i] = i ' from 0x00 to 0x20 (tab, space, trash)
CASE (i >= 0x80) : #charsetWhitespace[i] = i ' from 0x80 to 0xFF (unprintable trash)
END SELECT
NEXT i
END FUNCTION
'
'
' #######################################
' ##### InitializeQBasicTokens () #####
' #######################################
'
FUNCTION InitializeQBasicTokens ()
'
' define some shorthand variables
'
' common types
'
t0 = 0
tw = $$TYPE_SSHORT ' word
ti = $$TYPE_XLONG ' integer
tg = $$TYPE_GIANT ' giant-integer
tf = $$TYPE_DOUBLE ' floating-point
ts = $$TYPE_STRING ' nominal string
'
' common kinds
'
k0 = 0
ks = $$KIND_QBASIC | $$KIND_STATEMENT
ki = $$KIND_QBASIC | $$KIND_INTRINSIC
ko = $$KIND_QBASIC | $$KIND_OPERATOR
kk = $$KIND_QBASIC | $$KIND_KEYWORD
kt = $$KIND_QBASIC | $$KIND_TYPE
kl = $$KIND_QBASIC | $$KIND_LITERAL
kf = $$KIND_QBASIC | $$KIND_FUNCTION
ky = $$KIND_QBASIC | $$KIND_SYMBOL
kv = $$KIND_QBASIC | $$KIND_VARIABLE
ka = $$KIND_QBASIC | $$KIND_ARRAY
kc = $$KIND_QBASIC | $$KIND_COMPOSITE
ke = $$KIND_QBASIC | $$KIND_ELEMENT
kh = $$KIND_QBASIC | $$KIND_CHARACTER
kq = $$KIND_QBASIC
'
' common scopes
'
s0 = 0
sa = $$SCOPE_AUTO
sl = $$SCOPE_STATIC
ss = $$SCOPE_SHARED
se = $$SCOPE_EXTERNAL
'
q0 = 0
x0 = 0
'
'
' token_number = AddKeyword (translate, function, scope, kind, rtype, arg0, arg1, arg2, string$)
'
#qatoken = #ntoken + 1
#Q_ABS = AddKeyword (#X_ABS , f0, s0, ki, tf, tf, t0, t0, "ABS")
#Q_ABSOLUTE = AddKeyword ( x0, f0, s0, ki, tf, tf, t0, t0, "ABSOLUTE")
#Q_ACCESS = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "ACCESS")
#Q_ALIAS = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "ALIAS")
#Q_AND = AddKeyword (#X_AND , f0, s0, ko, t0, t0, t0, t0, "AND")
#Q_ANY = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "ANY")
#Q_APPEND = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "APPEND")
#Q_AS = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "AS")
#Q_ASC = AddKeyword (#X_ASC , f0, s0, ki, t0, t0, t0, t0, "ASC")
#Q_ATN = AddKeyword (#X_ATAN , f0, s0, ki, t0, t0, t0, t0, "ATN")
#Q_BASE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "BASE")
#Q_BEEP = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "BEEP")
#Q_BINARY = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "BINARY")
#Q_BLOAD = AddKeyword ( x0, f0, s0, ks, t0, t0, t0, t0, "BLOAD")
#Q_BSAVE = AddKeyword ( x0, f0, s0, ks, t0, t0, t0, t0, "BSAVE")
#Q_BYVAL = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "BYVAL")
#Q_CALL = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "CALL")
#Q_CALLS = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "CALLS")
#Q_CASE = AddKeyword (#X_CASE , f0, s0, ks, t0, t0, t0, t0, "CASE")
#Q_CCUR = AddKeyword (#X_GIANT , f0, s0, ki, t0, t0, t0, t0, "CCUR")
#Q_CDBL = AddKeyword (#X_DOUBLE , f0, s0, ki, t0, t0, t0, t0, "CDBL")
#Q_CDECL = AddKeyword (#X_CFUNCTION , f0, s0, k0, t0, t0, t0, t0, "CDECL")
#Q_CHAIN = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "CHAIN")
#Q_CHDIR = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "CHDIR")
#Q_CHDRIVE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "CHDRIVE")
#Q_CHR_D = AddKeyword (#X_CHR_D , f0, s0, ki, t0, t0, t0, t0, "CHR$")
#Q_CINT = AddKeyword (#X_SSHORT , f0, s0, ki, t0, t0, t0, t0, "CINT")
#Q_CIRCLE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "CIRCLE")
#Q_CLEAR = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "CLEAR")
#Q_CLNG = AddKeyword (#X_SLONG , f0, s0, ki, t0, t0, t0, t0, "CLNG")
#Q_CLOSE = AddKeyword (#X_CLOSE , f0, s0, k0, t0, t0, t0, t0, "CLOSE")
#Q_CLS = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "CLS")
#Q_COLOR = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "COLOR")
#Q_COM = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "COM")
#Q_COMMAND_D = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "COMMAND$")
#Q_COMMON = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "COMMON")
#Q_CONST = AddKeyword ( x0, f0, s0, ks, t0, t0, t0, t0, "CONST")
#Q_COS = AddKeyword (#X_COS , f0, s0, ki, t0, t0, t0, t0, "COS")
#Q_CSNG = AddKeyword (#X_SINGLE , f0, s0, ki, t0, t0, t0, t0, "CSNG")
#Q_CSRLIN = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "CSRLIN")
#Q_CURDIR_D = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "CURDIR$")
#Q_CURRENCY = AddKeyword (#X_GIANT , f0, s0, k0, t0, t0, t0, t0, "CURRENCY")
#Q_CVC = AddKeyword (#X_GIANT , f0, s0, ki, t0, t0, t0, t0, "CVC")
#Q_CVD = AddKeyword (#X_DOUBLE , f0, s0, ki, t0, t0, t0, t0, "CVD")
#Q_CVI = AddKeyword (#X_SSHORT , f0, s0, ki, t0, t0, t0, t0, "CVI")
#Q_CVL = AddKeyword (#X_SLONG , f0, s0, ki, t0, t0, t0, t0, "CVL")
#Q_CVS = AddKeyword (#X_SINGLE , f0, s0, ki, t0, t0, t0, t0, "CVS")
#Q_CVSMBF = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "CVSMBF")
#Q_DATA = AddKeyword ( x0, f0, s0, ks, t0, t0, t0, t0, "DATA")
#Q_DATE_D = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "DATE$")
#Q_DECLARE = AddKeyword (#X_DECLARE , f0, s0, ks, t0, t0, t0, t0, "DECLARE")
#Q_DEF = AddKeyword ( x0, f0, s0, ks, t0, t0, t0, t0, "DEF")
#Q_DEFCUR = AddKeyword (#X_GIANT , f0, s0, ks, t0, t0, t0, t0, "DEFCUR")
#Q_DEFDBL = AddKeyword (#X_DOUBLE , f0, s0, ks, t0, t0, t0, t0, "DEFDBL")
#Q_DEFINT = AddKeyword (#X_SSHORT , f0, s0, ks, t0, t0, t0, t0, "DEFINT")
#Q_DEFLNG = AddKeyword (#X_SLONG , f0, s0, ks, t0, t0, t0, t0, "DEFLNG")
#Q_DEFSNG = AddKeyword (#X_SINGLE , f0, s0, ks, t0, t0, t0, t0, "DEFSNG")
#Q_DEFSTR = AddKeyword (#X_STRING , f0, s0, ks, t0, t0, t0, t0, "DEFSTR")
#Q_DELETE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "DELETE")
#Q_DIM = AddKeyword (#X_DIM , f0, s0, ks, t0, t0, t0, t0, "DIM")
#Q_DIR_D = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "DIR$")
#Q_DO = AddKeyword (#X_DO , f0, s0, ks, t0, t0, t0, t0, "DO")
#Q_DOUBLE = AddKeyword (#X_DOUBLE , f0, s0, k0, t0, t0, t0, t0, "DOUBLE")
#Q_DRAW = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "DRAW")
#Q_DYNAMIC = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "DYNAMIC")
#Q_ELSE = AddKeyword (#X_ELSE , f0, s0, ks, t0, t0, t0, t0, "ELSE")
#Q_ELSEIF = AddKeyword ( x0, f0, s0, ks, t0, t0, t0, t0, "ELSEIF")
#Q_END = AddKeyword (#X_END , f0, s0, ks, t0, t0, t0, t0, "END")
#Q_ENDIF = AddKeyword (#X_ENDIF , f0, s0, ks, t0, t0, t0, t0, "ENDIF")
#Q_ENVIRON = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "ENVIRON")
#Q_ENVIRON_D = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "ENVIRON$")
#Q_EOF = AddKeyword (#X_EOF , f0, s0, ki, t0, t0, t0, t0, "EOF")
#Q_EQV = AddKeyword ( x0, f0, s0, ko, t0, t0, t0, t0, "EQV")
#Q_ERASE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "ERASE")
#Q_ERDEV = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "ERDEV")
#Q_ERDEV_D = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "ERDEV$")
#Q_ERL = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "ERL")
#Q_ERR = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "ERR")
#Q_ERROR = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "ERROR")
#Q_EVENT = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "EVENT")
#Q_EXIT = AddKeyword (#X_EXIT , f0, s0, ks, t0, t0, t0, t0, "EXIT")
#Q_EXP = AddKeyword (#X_EXP , f0, s0, ki, t0, t0, t0, t0, "EXP")
#Q_FIELD = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "FIELD")
#Q_FILEATTR = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "FILEATTR")
#Q_FILES = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "FILES")
#Q_FIX = AddKeyword (#X_FIX , f0, s0, ki, t0, t0, t0, t0, "FIX")
#Q_FN = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "FN")
#Q_FOR = AddKeyword (#X_FOR , f0, s0, ks, t0, t0, t0, t0, "FOR")
#Q_FRE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "FRE")
#Q_FREEFILE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "FREEFILE")
#Q_FUNCTION = AddKeyword (#X_FUNCTION , f0, s0, ks, t0, t0, t0, t0, "FUNCTION")
#Q_GET = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "GET")
#Q_GOSUB = AddKeyword (#X_GOSUB , f0, s0, ks, t0, t0, t0, t0, "GOSUB")
#Q_GOTO = AddKeyword (#X_GOTO , f0, s0, ks, t0, t0, t0, t0, "GOTO")
#Q_HEX_D = AddKeyword (#X_HEX_D , f0, s0, ki, t0, t0, t0, t0, "HEX$")
#Q_IF = AddKeyword (#X_IF , f0, s0, ks, t0, t0, t0, t0, "IF")
#Q_IMP = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "IMP")
#Q_INCLUDE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "INCLUDE")
#Q_INKEY_D = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "INKEY$")
#Q_INP = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "INP")
#Q_INPUT = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "INPUT")
#Q_INPUT_D = AddKeyword (#X_INLINE_D , f0, s0, k0, t0, t0, t0, t0, "INPUT$")
#Q_INSTR = AddKeyword (#X_INSTR , f0, s0, ki, t0, t0, t0, t0, "INSTR")
#Q_INT = AddKeyword (#X_INT , f0, s0, ki, t0, t0, t0, t0, "INT")
#Q_INTEGER = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "INTEGER")
#Q_INTERRUPT = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "INTERRUPT")
#Q_IOCTL = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "IOCTL")
#Q_IOCTL_D = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "IOCTL$")
#Q_IS = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "IS")
#Q_KEY = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "KEY")
#Q_KILL = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "KILL")
#Q_LBOUND = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "LBOUND")
#Q_LCASE_D = AddKeyword (#X_LCASE_D , f0, s0, ki, t0, t0, t0, t0, "LCASE$")
#Q_LEFT_D = AddKeyword (#X_LEFT_D , f0, s0, ki, t0, t0, t0, t0, "LEFT$")
#Q_LEN = AddKeyword (#X_LEN , f0, s0, ki, t0, t0, t0, t0, "LEN")
#Q_LET = AddKeyword ( x0, f0, s0, ks, t0, t0, t0, t0, "LET")
#Q_LINE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "LINE")
#Q_LIST = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "LIST")
#Q_LOC = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "LOC")
#Q_LOCAL = AddKeyword (#X_AUTO , f0, s0, k0, t0, t0, t0, t0, "LOCAL")
#Q_LOCATE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "LOCATE")
#Q_LOCK = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "LOCK")
#Q_LOF = AddKeyword (#X_LOF , f0, s0, ki, t0, t0, t0, t0, "LOF")
#Q_LOG = AddKeyword (#X_LOG , f0, s0, ki, t0, t0, t0, t0, "LOG")
#Q_LONG = AddKeyword (#X_SLONG , f0, s0, k0, t0, t0, t0, t0, "LONG")
#Q_LOOP = AddKeyword (#X_LOOP , f0, s0, ks, t0, t0, t0, t0, "LOOP")
#Q_LPOS = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "LPOS")
#Q_LPRINT = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "LPRINT")
#Q_LSET = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "LSET")
#Q_LTRIM_D = AddKeyword (#X_LTRIM_D , f0, s0, ki, t0, t0, t0, t0, "LTRIM$")
#Q_MID_D = AddKeyword (#X_MID_D , f0, s0, ki, t0, t0, t0, t0, "MID$")
#Q_MKC_D = AddKeyword (#X_STRING_D , f0, s0, ki, t0, t0, t0, t0, "MKC$")
#Q_MKDIR = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "MKDIR")
#Q_MKDMBF_D = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "MKDMBF$")
#Q_MKD_D = AddKeyword (#X_STRING_D , f0, s0, ki, t0, t0, t0, t0, "MKD$")
#Q_MKI_D = AddKeyword (#X_STRING_D , f0, s0, ki, t0, t0, t0, t0, "MKI$")
#Q_MKL_D = AddKeyword (#X_STRING_D , f0, s0, ki, t0, t0, t0, t0, "MKL$")
#Q_MKS_D = AddKeyword (#X_STRING_D , f0, s0, ki, t0, t0, t0, t0, "MKS$")
#Q_MKSMBF_D = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "MKSMBF$")
#Q_MOD = AddKeyword (#X_MOD , f0, s0, ko, t0, t0, t0, t0, "MOD")
#Q_NAME = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "NAME")
#Q_NEXT = AddKeyword (#X_NEXT , f0, s0, ks, t0, t0, t0, t0, "NEXT")
#Q_NOT = AddKeyword (#X_NOT , f0, s0, ko, t0, t0, t0, t0, "NOT")
#Q_OCT_D = AddKeyword (#X_OCT_D , f0, s0, ki, t0, t0, t0, t0, "OCT$")
#Q_OFF = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "OFF")
#Q_ON = AddKeyword ( x0, f0, s0, ks, t0, t0, t0, t0, "ON")
#Q_OPEN = AddKeyword (#X_OPEN , f0, s0, k0, t0, t0, t0, t0, "OPEN")
#Q_OPTION = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "OPTION")
#Q_OR = AddKeyword (#X_OR , f0, s0, ko, t0, t0, t0, t0, "OR")
#Q_OUT = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "OUT")
#Q_OUTPUT = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "OUTPUT")
#Q_PAINT = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "PAINT")
#Q_PALETTE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "PALETTE")
#Q_PCOPY = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "PCOPY")
#Q_PEEK = AddKeyword (#X_UBYTE_AT , f0, s0, ki, t0, t0, t0, t0, "PEEK")
#Q_PEN = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "PEN")
#Q_PLAY = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "PLAY")
#Q_PMAP = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "PMAP")
#Q_POINT = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "POINT")
#Q_POKE = AddKeyword (#X_UBYTE_AT , f0, s0, ks, t0, t0, t0, t0, "POKE")
#Q_POS = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "POS")
#Q_PRESET = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "PRESET")
#Q_PRINT = AddKeyword (#X_PRINT , f0, s0, ks, t0, t0, t0, t0, "PRINT")
#Q_PSET = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "PSET")
#Q_PUT = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "PUT")
#Q_RANDOM = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "RANDOM")
#Q_RANDOMIZE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "RANDOMIZE")
#Q_READ = AddKeyword (#X_READ , f0, s0, ks, t0, t0, t0, t0, "READ")
#Q_REDIM = AddKeyword (#X_REDIM , f0, s0, ks, t0, t0, t0, t0, "REDIM")
#Q_REM = AddKeyword (#X_REMARK , f0, s0, ks, t0, t0, t0, t0, "REM")
#Q_RESET = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "RESET")
#Q_RESTORE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "RESTORE")
#Q_RESUME = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "RESUME")
#Q_RETURN = AddKeyword ( x0, f0, s0, ks, t0, t0, t0, t0, "RETURN")
#Q_RIGHT_D = AddKeyword (#X_RIGHT_D , f0, s0, ki, t0, t0, t0, t0, "RIGHT$")
#Q_RMDIR = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "RMDIR")
#Q_RND = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "RND")
#Q_RSET = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "RSET")
#Q_RTRIM_D = AddKeyword (#X_RTRIM_D , f0, s0, ki, t0, t0, t0, t0, "RTRIM$")
#Q_RUN = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "RUN")
#Q_SADD = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "SADD")
#Q_SCREEN = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "SCREEN")
#Q_SEEK = AddKeyword (#X_SEEK , f0, s0, ki, t0, t0, t0, t0, "SEEK")
#Q_SEG = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "SEG")
#Q_SELECT = AddKeyword (#X_SELECT , f0, s0, ks, t0, t0, t0, t0, "SELECT")
#Q_SETMEM = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "SETMEM")
#Q_SGN = AddKeyword (#X_SGN , f0, s0, ki, t0, t0, t0, t0, "SGN")
#Q_SHARED = AddKeyword (#X_SHARED , f0, s0, ks, t0, t0, t0, t0, "SHARED")
#Q_SHELL = AddKeyword (#X_SHELL , f0, s0, k0, t0, t0, t0, t0, "SHELL")
#Q_SIGNAL = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "SIGNAL")
#Q_SIN = AddKeyword (#X_SIN , f0, s0, ki, t0, t0, t0, t0, "SIN")
#Q_SINGLE = AddKeyword (#X_SINGLE , f0, s0, ks, t0, t0, t0, t0, "SINGLE")
#Q_SLEEP = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "SLEEP")
#Q_SOUND = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "SOUND")
#Q_SPACE_D = AddKeyword (#X_SPACE_D , f0, s0, ki, t0, t0, t0, t0, "SPACE$")
#Q_SPC = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "SPC")
#Q_SQR = AddKeyword (#X_SQRT , f0, s0, ki, t0, t0, t0, t0, "SQR")
#Q_SSEG = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "SSEG")
#Q_SSEGADD = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "SSEGADD")
#Q_STACK = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "STACK")
#Q_STATIC = AddKeyword (#X_STATIC , f0, s0, ks, t0, t0, t0, t0, "STATIC")
#Q_STEP = AddKeyword (#X_STEP , f0, s0, ks, t0, t0, t0, t0, "STEP")
#Q_STICK = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "STICK")
#Q_STOP = AddKeyword (#X_STOP , f0, s0, ks, t0, t0, t0, t0, "STOP")
#Q_STR_D = AddKeyword (#X_STR_D , f0, s0, ki, t0, t0, t0, t0, "STR$")
#Q_STRIG = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "STRIG")
#Q_STRING = AddKeyword (#X_STRING , f0, s0, k0, t0, t0, t0, t0, "STRING")
#Q_STRING_D = AddKeyword (#X_CHR_D , f0, s0, ki, t0, t0, t0, t0, "STRING$")
#Q_SUB = AddKeyword (#X_FUNCTION , f0, s0, ks, t0, t0, t0, t0, "SUB")
#Q_SWAP = AddKeyword (#X_SWAP , f0, s0, ks, t0, t0, t0, t0, "SWAP")
#Q_SYSTEM = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "SYSTEM")
#Q_TAB = AddKeyword (#X_TAB , f0, s0, ki, t0, t0, t0, t0, "TAB")
#Q_TAN = AddKeyword (#X_TAN , f0, s0, ki, t0, t0, t0, t0, "TAN")
#Q_THEN = AddKeyword (#X_THEN , f0, s0, ks, t0, t0, t0, t0, "THEN")
#Q_TIME_D = AddKeyword ( x0, f0, s0, ki, t0, t0, t0, t0, "TIME$")
#Q_TIMER = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "TIMER")
#Q_TO = AddKeyword (#X_TO , f0, s0, ks, t0, t0, t0, t0, "TO")
#Q_TROFF = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "TROFF")
#Q_TRON = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "TRON")
#Q_TYPE = AddKeyword (#X_TYPE , f0, s0, ks, t0, t0, t0, t0, "TYPE")
#Q_UBOUND = AddKeyword (#X_UBOUND , f0, s0, ki, t0, t0, t0, t0, "UBOUND")
#Q_UCASE_D = AddKeyword (#X_UCASE_D , f0, s0, ki, t0, t0, t0, t0, "UCASE$")
#Q_UEVENT = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "UEVENT")
#Q_UNLOCK = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "UNLOCK")
#Q_UNTIL = AddKeyword (#X_UNTIL , f0, s0, ks, t0, t0, t0, t0, "UNTIL")
#Q_UPDATE = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "UPDATE")
#Q_USING = AddKeyword (#X_FORMAT_D , f0, s0, ks, t0, t0, t0, t0, "USING")
#Q_VAL = AddKeyword (#X_DOUBLE , f0, s0, ki, t0, t0, t0, t0, "VAL")
#Q_VARPTR = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "VARPTR")
#Q_VARPTR_D = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "VARPTR$")
#Q_VARSEG = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "VARSEG")
#Q_VIEW = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "VIEW")
#Q_WAIT = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "WAIT")
#Q_WEND = AddKeyword (#X_LOOP , f0, s0, ks, t0, t0, t0, t0, "WEND")
#Q_WHILE = AddKeyword (#X_DO , f0, s0, ks, t0, t0, t0, t0, "WHILE")
#Q_WIDTH = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "WIDTH")
#Q_WINDOW = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "WINDOW")
#Q_WRITE = AddKeyword (#X_WRITE , f0, s0, ks, t0, t0, t0, t0, "WRITE")
#Q_XOR = AddKeyword (#X_XOR , f0, s0, ko, t0, t0, t0, t0, "XOR")
'
' #Q_POST_SSHORT = AddKeyword (#X_POST_SSHORT, f0, s0, kc, 4, t0, t0, t0, "%") ' part of string ???
' #Q_POST_SLONG = AddKeyword (#X_POST_SLONG , f0, s0, kc, 6, t0, t0, t0, "&") ' part of string ???
' #Q_POST_SINGLE = AddKeyword (#X_POST_SINGLE, f0, s0, kc, 13, t0, t0, t0, "!") ' part of string ???
' #Q_POST_DOUBLE = AddKeyword (#X_POST_DOUBLE, f0, s0, kc, 14, t0, t0, t0, "#") ' part of string ???
' #Q_POST_STRING = AddKeyword (#X_POST_STRING, f0, s0, kc, 15, t0, t0, t0, "$") ' part of string ???
'
#Q_PLUS = AddKeyword (#X_PLUS , f0, s0, ko, t0, t0, t0, t0, "+") ' unary
#Q_MINUS = AddKeyword (#X_MINUS , f0, s0, ko, t0, t0, t0, t0, "-") ' unary
' #Q_ADDRESS = AddKeyword ( q0, f0, s0, ko, t0, t0, t0, t0, "&") ' unary
'
#Q_ADD = AddKeyword (#X_ADD , f0, s0, ko, t0, t0, t0, t0, "+")
#Q_SUBTRACT = AddKeyword (#X_SUBTRACT , f0, s0, ko, t0, t0, t0, t0, "-")
#Q_MULTIPLY = AddKeyword (#X_MULTIPLY , f0, s0, ko, t0, t0, t0, t0, "*")
#Q_DIVIDE = AddKeyword (#X_DIVIDE , f0, s0, ko, t0, t0, t0, t0, "/")
#Q_POWER = AddKeyword (#X_POWER , f0, s0, ko, t0, t0, t0, t0, "^")
#Q_IDIVIDE = AddKeyword (#X_IDIVIDE , f0, s0, ko, t0, t0, t0, t0, "\\")
#Q_REMAINDER = AddKeyword (#X_MOD , f0, s0, ko, t0, t0, t0, t0, "%")
'
#Q_NOTBIT = AddKeyword (#X_NOT , f0, s0, ko, t0, t0, t0, t0, "~") ' unary
#Q_ANDBIT = AddKeyword (#X_AND , f0, s0, ko, t0, t0, t0, t0, "&")
#Q_ORBIT = AddKeyword (#X_OR , f0, s0, ko, t0, t0, t0, t0, "|")
#Q_EQ = AddKeyword (#X_EQ , f0, s0, ko, t0, t0, t0, t0, "=")
#Q_NE = AddKeyword (#X_NE , f0, s0, ko, t0, t0, t0, t0, "<>")
#Q_LT = AddKeyword (#X_LT , f0, s0, ko, t0, t0, t0, t0, "<")
#Q_LE = AddKeyword (#X_LE , f0, s0, ko, t0, t0, t0, t0, "<=")
#Q_GE = AddKeyword (#X_GE , f0, s0, ko, t0, t0, t0, t0, ">=")
#Q_GT = AddKeyword (#X_GT , f0, s0, ko, t0, t0, t0, t0, ">")
'
#Q_LPAREN = AddKeyword (#X_LPAREN , f0, s0, kc, t0, t0, t0, t0, "(")
#Q_RPAREN = AddKeyword (#X_RPAREN , f0, s0, kc, t0, t0, t0, t0, ")")
#Q_LBRAK = AddKeyword (#X_LBRAK , f0, s0, kc, t0, t0, t0, t0, "[")
#Q_RBRAK = AddKeyword (#X_RBRAK , f0, s0, kc, t0, t0, t0, t0, "]")
#Q_COMMA = AddKeyword (#X_COMMA , f0, s0, kc, t0, t0, t0, t0, ",")
#Q_COLON = AddKeyword (#X_COLON , f0, s0, kc, t0, t0, t0, t0, ":")
#Q_SEMI = AddKeyword (#X_SEMI , f0, s0, kc, t0, t0, t0, t0, ";")
'
' #Q_KEYWORD = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "")
' #Q_KEYWORD = AddKeyword ( x0, f0, s0, k0, t0, t0, t0, t0, "")
#qztoken = #ntoken
END FUNCTION
'
'
' #######################################
' ##### InitializeXBasicTokens () #####
' #######################################
'
FUNCTION InitializeXBasicTokens ()
'
' define shorthand variables to make function calls readable
'
' common data-types
'
t0 = 0
ti = $$TYPE_XLONG ' integer
tg = $$TYPE_GIANT ' giant-integer
tf = $$TYPE_DOUBLE ' floating-point
ts = $$TYPE_STRING ' nominal string
'
' common kinds
'
k0 = 0
ks = $$KIND_XBASIC | $$KIND_STATEMENT
ki = $$KIND_XBASIC | $$KIND_INTRINSIC
ko = $$KIND_XBASIC | $$KIND_OPERATOR
kk = $$KIND_XBASIC | $$KIND_KEYWORD
kt = $$KIND_XBASIC | $$KIND_TYPE
kl = $$KIND_XBASIC | $$KIND_LITERAL
kf = $$KIND_XBASIC | $$KIND_FUNCTION
ky = $$KIND_XBASIC | $$KIND_SYMBOL
kv = $$KIND_XBASIC | $$KIND_VARIABLE
ka = $$KIND_XBASIC | $$KIND_ARRAY
kc = $$KIND_XBASIC | $$KIND_COMPOSITE
ke = $$KIND_XBASIC | $$KIND_ELEMENT
kh = $$KIND_XBASIC | $$KIND_CHARACTER
km = $$KIND_XBASIC | $$KIND_FUNCTION ' math library functions look like intrinsics
kx = $$KIND_XBASIC
'
' common kinds
'
s0 = 0
sa = $$SCOPE_AUTO
sx = $$SCOPE_AUTOX
sl = $$SCOPE_STATIC
ss = $$SCOPE_SHARED
se = $$SCOPE_EXTERNAL
'
q0 = 0
x0 = 0
'
'
' token_number = AddKeyword (translate, function, scope, kind, rtype, arg0, arg1, arg2, string$)
'
#xatoken = #ntoken + 1
#X_ABS = AddKeyword (#Q_ABS , f0, s0, ki, tf, tf, t0, t0, "ABS")
#X_ALL = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "ALL")
#X_AND = AddKeyword (#Q_AND , f0, s0, ko, t0, t0, t0, t0, "AND")
#X_ANY = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "ANY")
#X_ASC = AddKeyword (#Q_ASC , f0, s0, ki, t0, t0, t0, t0, "ASC")
#X_ATAN = AddKeyword (#Q_ATN , f0, s0, km, t0, t0, t0, t0, "ATAN")
#X_ATTACH = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "ATTACH")
#X_AUTO = AddKeyword ( q0, f0, sa, ks, t0, t0, t0, t0, "AUTO")
#X_AUTOX = AddKeyword ( q0, f0, sx, ks, t0, t0, t0, t0, "AUTOX")
#X_BIN_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "BIN$")
#X_BINB_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "BINB$")
#X_BITFIELD = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "BITFIELD")
#X_CASE = AddKeyword (#Q_CASE , f0, s0, ks, t0, t0, t0, t0, "CASE")
#X_CFUNCTION = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "CFUNCTION")
#X_CHR_D = AddKeyword (#Q_CHR_D , f0, s0, ki, t0, t0, t0, t0, "CHR$")
#X_CJUST_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "CJUST$")
#X_CLOSE = AddKeyword (#Q_CLOSE , f0, s0, ki, t0, t0, t0, t0, "CLOSE")
#X_CLR = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "CLR")
#X_CSIZE = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "CSIZE")
#X_CSIZE_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "CSIZE$")
#X_CSTRING_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "CSTRING$")
#X_DEC = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "DEC")
#X_DECLARE = AddKeyword (#Q_DECLARE , f0, s0, ks, t0, t0, t0, t0, "DECLARE")
#X_DHIGH = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "DHIGH")
#X_DIM = AddKeyword (#Q_DIM , f0, s0, ki, t0, t0, t0, t0, "DIM")
#X_DLOW = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "DLOW")
#X_DMAKE = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "DMAKE")
#X_DO = AddKeyword (#Q_DO , f0, s0, ks, t0, t0, t0, t0, "DO")
#X_DOUBLE = AddKeyword (#Q_DOUBLE , f0, s0, ks, t0, t0, t0, t0, "DOUBLE")
#X_DOUBLE = AddKeyword (#Q_DOUBLE , f0, s0, ki, t0, t0, t0, t0, "DOUBLE")
#X_DOUBLEAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "DOUBLEAT")
#X_ELSE = AddKeyword (#Q_ELSE , f0, s0, ks, t0, t0, t0, t0, "ELSE")
#X_END = AddKeyword (#Q_END , f0, s0, ks, t0, t0, t0, t0, "END")
#X_ENDIF = AddKeyword (#Q_ENDIF , f0, s0, ks, t0, t0, t0, t0, "ENDIF")
#X_EOF = AddKeyword (#Q_EOF , f0, s0, ki, t0, t0, t0, t0, "EOF")
#X_ERROR = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "ERROR")
#X_EXIT = AddKeyword (#Q_EXIT , f0, s0, ks, t0, t0, t0, t0, "EXIT")
#X_EXP = AddKeyword (#Q_EXP , f0, s0, km, t0, t0, t0, t0, "EXP")
#X_EXTERNAL = AddKeyword ( q0, f0, se, ks, t0, t0, t0, t0, "EXTERNAL")
#X_EXTS = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "EXTS")
#X_EXTU = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "EXTU")
#X_FALSE = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "FALSE")
#X_FIX = AddKeyword (#Q_FIX , f0, s0, ki, t0, t0, t0, t0, "FIX")
#X_FOR = AddKeyword (#Q_FOR , f0, s0, ks, t0, t0, t0, t0, "FOR")
#X_FORMAT_D = AddKeyword (#Q_USING , f0, s0, ki, t0, t0, t0, t0, "FORMAT$")
#X_FUNCADDR = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "FUNCADDR")
#X_FUNCADDR = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "FUNCADDR")
#X_FUNCADDRAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "FUNCADDRAT")
#X_FUNCADDRESS = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "FUNCADDRESS")
#X_FUNCTION = AddKeyword (#Q_FUNCTION , f0, s0, ks, t0, t0, t0, t0, "FUNCTION")
#X_GHIGH = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "GHIGH")
#X_GIANT = AddKeyword (#Q_GIANT , f0, s0, ks, t0, t0, t0, t0, "GIANT")
#X_GIANT = AddKeyword (#Q_GIANT , f0, s0, ki, t0, t0, t0, t0, "GIANT")
#X_GIANTAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "GIANTAT")
#X_GLOW = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "GLOW")
#X_GMAKE = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "GMAKE")
#X_GOADDR = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "GOADDR")
#X_GOADDR = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "GOADDR")
#X_GOADDRAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "GOADDRAT")
#X_GOADDRESS = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "GOADDRESS")
#X_GOSUB = AddKeyword (#Q_GOSUB , f0, s0, ks, t0, t0, t0, t0, "GOSUB")
#X_GOTO = AddKeyword (#Q_GOTO , f0, s0, ks, t0, t0, t0, t0, "GOTO")
#X_HEX_D = AddKeyword (#Q_HEX_D , f0, s0, ki, t0, t0, t0, t0, "HEX$")
#X_HEXX_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "HEXX$")
#X_HIGH0 = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "HIGH0")
#X_HIGH1 = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "HIGH1")
#X_IF = AddKeyword (#Q_IF , f0, s0, ks, t0, t0, t0, t0, "IF")
#X_IFF = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "IFF")
#X_IFT = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "IFT")
#X_IFZ = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "IFZ")
#X_INC = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "INC")
#X_INCHR = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "INCHR")
#X_INCHRI = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "INCHRI")
#X_INT = AddKeyword (#Q_INT , f0, s0, ki, t0, t0, t0, t0, "INT")
#X_INTERNAL = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "INTERNAL")
#X_LCASE_D = AddKeyword (#Q_LCASE_D , f0, s0, ki, t0, t0, t0, t0, "LCASE$")
#X_LCLIP_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "LCLIP$")
#X_LEFT_D = AddKeyword (#Q_LEFT_D , f0, s0, ki, t0, t0, t0, t0, "LEFT$")
#X_LEN = AddKeyword (#Q_LEN , f0, s0, ki, t0, t0, t0, t0, "LEN")
#X_LJUST_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "LJUST$")
#X_LOF = AddKeyword (#Q_LOF , f0, s0, ki, t0, t0, t0, t0, "LOF")
#X_LOG = AddKeyword (#Q_LOG , f0, s0, km, t0, t0, t0, t0, "LOG")
#X_LOOP = AddKeyword (#Q_LOOP , f0, s0, ks, t0, t0, t0, t0, "LOOP")
#X_LTRIM_D = AddKeyword (#Q_LTRIM_D , f0, s0, ki, t0, t0, t0, t0, "LTRIM$")
#X_MAKE = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "MAKE")
#X_MAX = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "MAX")
#X_MID_D = AddKeyword (#Q_MID_D , f0, s0, ki, t0, t0, t0, t0, "MID$")
#X_MIN = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "MIN")
#X_MOD = AddKeyword (#Q_MOD , f0, s0, ko, t0, t0, t0, t0, "MOD")
#X_NEXT = AddKeyword (#Q_NEXT , f0, s0, ks, t0, t0, t0, t0, "NEXT")
#X_NOT = AddKeyword (#Q_NOT , f0, s0, ko, t0, t0, t0, t0, "NOT")
#X_NULL_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "NULL$")
#X_OCT_D = AddKeyword (#Q_OCT_D , f0, s0, ki, t0, t0, t0, t0, "OCT$")
#X_OCTO_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "OCTO$")
#X_OPEN = AddKeyword (#Q_OPEN , f0, s0, ki, t0, t0, t0, t0, "OPEN")
#X_OR = AddKeyword (#Q_OR , f0, s0, ko, t0, t0, t0, t0, "OR")
#X_POF = AddKeyword (#Q_POF , f0, s0, ki, t0, t0, t0, t0, "POF")
#X_PRINT = AddKeyword (#Q_PRINT , f0, s0, ks, t0, t0, t0, t0, "PRINT")
#X_PROGRAM = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "PROGRAM")
#X_QUIT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "QUIT")
#X_RCLIP_D = AddKeyword (#Q_RCLIP_D , f0, s0, ki, t0, t0, t0, t0, "RCLIP$")
#X_READ = AddKeyword (#Q_READ , f0, s0, ks, t0, t0, t0, t0, "READ")
#X_REDIM = AddKeyword (#Q_REDIM , f0, s0, ks, t0, t0, t0, t0, "REDIM")
#X_RETURN = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "RETURN")
#X_RIGHT_D = AddKeyword (#Q_RIGHT_D , f0, s0, ki, t0, t0, t0, t0, "RIGHT$")
#X_RINCHR = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "RINCHR")
#X_RINCHRI = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "RINCHRI")
#X_RINSTR = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "RINSTR")
#X_RINSTRI = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "RINSTRI")
#X_RJUST_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "RJUST$")
#X_ROTATER = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "ROTATER")
#X_RTRIM_D = AddKeyword (#Q_RTRIM_D , f0, s0, ki, t0, t0, t0, t0, "RTRIM$")
#X_SBYTE = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "SBYTE")
#X_SBYTE = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SBYTE")
#X_SBYTEAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SBYTEAT")
#X_SEEK = AddKeyword (#Q_SEEK , f0, s0, ki, t0, t0, t0, t0, "SEEK")
#X_SELECT = AddKeyword (#Q_SELECT , f0, s0, ks, t0, t0, t0, t0, "SELECT")
#X_SET = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SET")
#X_SGN = AddKeyword (#Q_SGN , f0, s0, ki, t0, t0, t0, t0, "SGN")
#X_SFUNCTION = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "SFUNCTION")
#X_SHARED = AddKeyword (#Q_SHARED , f0, s0, ks, t0, t0, t0, t0, "SHARED")
#X_SHELL = AddKeyword (#Q_SHELL , f0, ss, ki, t0, t0, t0, t0, "SHELL")
#X_SIGN = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SIGN")
#X_SIGNED_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SIGNED$")
#X_SIN = AddKeyword (#Q_SIN , f0, s0, km, t0, t0, t0, t0, "SIN")
#X_SINGLE = AddKeyword (#Q_SINGLE , f0, s0, ks, t0, t0, t0, t0, "SINGLE")
#X_SINGLE = AddKeyword (#Q_SINGLE , f0, s0, ki, t0, t0, t0, t0, "SINGLE")
#X_SINGLEAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SINGLEAT")
#X_SIZE = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SIZE")
#X_SLONG = AddKeyword (#Q_LONG , f0, s0, ks, t0, t0, t0, t0, "SLONG")
#X_SLONG = AddKeyword (#Q_LONG , f0, s0, ki, t0, t0, t0, t0, "SLONG")
#X_SLONGAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SLONGAT")
#X_SMAKE = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SMAKE")
#X_SPACE_D = AddKeyword (#Q_SPACE_D , f0, s0, ki, t0, t0, t0, t0, "SPACE$")
#X_SSHORT = AddKeyword (#Q_SHORT , f0, s0, ks, t0, t0, t0, t0, "SSHORT")
#X_SSHORT = AddKeyword (#Q_SHORT , f0, s0, ki, t0, t0, t0, t0, "SSHORT")
#X_SSHORTAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SSHORTAT")
#X_SQRT = AddKeyword (#Q_INTEGER , f0, s0, km, t0, t0, t0, t0, "SQRT")
#X_STATIC = AddKeyword (#Q_STATIC , f0, sl, ks, t0, t0, t0, t0, "STATIC")
#X_STEP = AddKeyword (#Q_STEP , f0, s0, ks, t0, t0, t0, t0, "STEP")
#X_STOP = AddKeyword (#Q_STOP , f0, s0, ks, t0, t0, t0, t0, "STOP")
#X_STR_D = AddKeyword (#Q_STR_D , f0, s0, ki, t0, t0, t0, t0, "STR$")
#X_STRING = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "STRING")
#X_STRING = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "STRING")
#X_STRING_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "STRING$")
#X_STUFF_D = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "STUFF$")
#X_SUB = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "SUB")
#X_SUBADDR = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "SUBADDR")
#X_SUBADDR = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SUBADDR")
#X_SUBADDRAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SUBADDRAT")
#X_SUBADDRESS = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "SUBADDRESS")
#X_SWAP = AddKeyword (#Q_SWAP , f0, s0, ki, t0, t0, t0, t0, "SWAP")
#X_TAB = AddKeyword (#Q_TAB , f0, s0, ki, t0, t0, t0, t0, "TAB")
#X_TAN = AddKeyword (#Q_TAN , f0, s0, km, t0, t0, t0, t0, "TAN")
#X_THEN = AddKeyword (#Q_THEN , f0, s0, ks, t0, t0, t0, t0, "THEN")
#X_TO = AddKeyword (#Q_TO , f0, s0, ks, t0, t0, t0, t0, "TO")
#X_TRIM_D = AddKeyword (#Q_TRIM_D , f0, s0, ki, t0, t0, t0, t0, "TRIM$")
#X_TYPE = AddKeyword (#Q_TYPE , f0, s0, ks, t0, t0, t0, t0, "TYPE")
#X_UBOUND = AddKeyword (#Q_UBOUND , f0, s0, ki, t0, t0, t0, t0, "UBOUND")
#X_UBYTE = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "UBYTE")
#X_UBYTE = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "UBYTE")
#X_UBYTEAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "UBYTEAT")
#X_UCASE_D = AddKeyword (#Q_UCASE_D , f0, s0, ki, t0, t0, t0, t0, "UCASE$")
#X_ULONG = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "ULONG")
#X_ULONG = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "ULONG")
#X_ULONGAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "ULONGAT")
#X_UNION = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "UNION")
#X_UNTIL = AddKeyword (#Q_UNTIL , f0, s0, ks, t0, t0, t0, t0, "UNTIL")
#X_USHORT = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "USHORT")
#X_USHORT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "USHORT")
#X_USHORTAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "USHORTAT")
#X_VOID = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "VOID")
#X_WHILE = AddKeyword (#Q_WHILE , f0, s0, ks, t0, t0, t0, t0, "WHILE")
#X_WRITE = AddKeyword (#Q_WRITE , f0, s0, ks, t0, t0, t0, t0, "WRITE")
#X_XLONG = AddKeyword ( q0, f0, s0, ks, t0, t0, t0, t0, "XLONG")
#X_XLONG = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "XLONG")
#X_XLONGAT = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "XLONGAT")
#X_XMAKE = AddKeyword ( q0, f0, s0, ki, t0, t0, t0, t0, "XMAKE")
#X_XOR = AddKeyword (#Q_XOR , f0, s0, ko, t0, t0, t0, t0, "XOR")
'
#X_PRE_BYREF = AddKeyword ( q0, f0, s0, kh, t0, t0, t0, t0, "@")
#X_PRE_SHARED = AddKeyword ( q0, f0, s5, kh, t0, t0, t0, t0, "#")
#X_PRE_EXTERNAL = AddKeyword ( q0, f0, s7, kh, t0, t0, t0, t0, "##")
'
' #X_POST_SBYTE = AddKeyword ( q0, f0, s0, kh, 2, t0, t0, t0, "@") ' part of symbol
' #X_POST_UBYTE = AddKeyword ( q0, f0, s0, kh, 3, t0, t0, t0, "@@") ' part of symbol
' #X_POST_SSHORT = AddKeyword (#Q_POST_SSHORT, f0, s0, kh, 4, t0, t0, t0, "%") ' part of symbol
' #X_POST_USHORT = AddKeyword ( q0, f0, s0, kh, 5, t0, t0, t0, "%%") ' part of symbol
' #X_POST_SLONG = AddKeyword (#Q_POST_SLONG , f0, s0, kh, 6, t0, t0, t0, "&") ' part of symbol
' #X_POST_ULONG = AddKeyword ( q0, f0, s0, kh, 7, t0, t0, t0, "&&") ' part of symbol
' #X_POST_XLONG = AddKeyword ( q0, f0, s0, kh, 8, t0, t0, t0, "~") ' part of symbol
' #X_POST_GIANT = AddKeyword ( q0, f0, s0, kh, 12, t0, t0, t0, "$$") ' part of symbol
' #X_POST_SINGLE = AddKeyword (#Q_POST_SINGLE, f0, s0, kh, 13, t0, t0, t0, "!") ' part of symbol
' #X_POST_DOUBLE = AddKeyword (#Q_POST_DOUBLE, f0, s0, kh, 14, t0, t0, t0, "#") ' part of symbol
' #X_POST_STRING = AddKeyword (#Q_POST_STRING, f0, s0, kh, 15, t0, t0, t0, "$") ' part of symbol
'
#X_PLUS = AddKeyword (#Q_PLUS , f0, s0, ko, t0, t0, t0, t0, "+") ' unary
#X_MINUS = AddKeyword (#Q_MINUS , f0, s0, ko, t0, t0, t0, t0, "-") ' unary
#X_ADDRESS = AddKeyword ( q0, f0, s0, ko, t0, t0, t0, t0, "&") ' unary
'
#X_ADD = AddKeyword (#Q_ADD , f0, s0, ko, t0, t0, t0, t0, "+")
#X_SUBTRACT = AddKeyword (#Q_SUBTRACT , f0, s0, ko, t0, t0, t0, t0, "-")
#X_MULTIPLY = AddKeyword (#Q_MULTIPLY , f0, s0, ko, t0, t0, t0, t0, "*")
#X_DIVIDE = AddKeyword (#Q_DIVIDE , f0, s0, ko, t0, t0, t0, t0, "/")
#X_POWER = AddKeyword (#Q_POWER , f0, s0, ko, t0, t0, t0, t0, "**")
#X_IDIVIDE = AddKeyword (#Q_IDIVIDE , f0, s0, ko, t0, t0, t0, t0, "\\")
#X_REMAINDER = AddKeyword (#Q_MOD , f0, s0, ko, t0, t0, t0, t0, "%")
'
#X_USHIFT = AddKeyword ( q0, f0, s0, ko, t0, t0, t0, t0, "<<<")
#X_DSHIFT = AddKeyword ( q0, f0, s0, ko, t0, t0, t0, t0, ">>>")
#X_LSHIFT = AddKeyword ( q0, f0, s0, ko, t0, t0, t0, t0, "<<")
#X_RSHIFT = AddKeyword ( q0, f0, s0, ko, t0, t0, t0, t0, ">>")
#X_NOTBIT = AddKeyword (#Q_NOT , f0, s0, ko, t0, t0, t0, t0, "~")
#X_ANDBIT = AddKeyword (#Q_AND , f0, s0, ko, t0, t0, t0, t0, "&")
#X_ORBIT = AddKeyword (#Q_OR , f0, s0, ko, t0, t0, t0, t0, "|")
#X_TESTL = AddKeyword ( q0, f0, s0, ko, t0, t0, t0, t0, "!!")
#X_NOTL = AddKeyword ( q0, f0, s0, ko, t0, t0, t0, t0, "!")
#X_ANDL = AddKeyword ( q0, f0, s0, ko, t0, t0, t0, t0, "&&")
#X_XORL = AddKeyword ( q0, f0, s0, ko, t0, t0, t0, t0, "^^")
#X_ORL = AddKeyword ( q0, f0, s0, ko, t0, t0, t0, t0, "||")
#X_EQ = AddKeyword (#Q_EQ , f0, s0, ko, t0, t0, t0, t0, "=")
#X_NE = AddKeyword (#Q_NE , f0, s0, ko, t0, t0, t0, t0, "<>")
#X_LT = AddKeyword (#Q_LT , f0, s0, ko, t0, t0, t0, t0, "<")
#X_LE = AddKeyword (#Q_LE , f0, s0, ko, t0, t0, t0, t0, "<=")
#X_GE = AddKeyword (#Q_GE , f0, s0, ko, t0, t0, t0, t0, ">=")
#X_GT = AddKeyword (#Q_GT , f0, s0, ko, t0, t0, t0, t0, ">")
#X_EQU = AddKeyword (#Q_EQ , f0, s0, ko, t0, t0, t0, t0, "==")
#X_NEQ = AddKeyword (#Q_NE , f0, s0, ko, t0, t0, t0, t0, "!=")
#X_NGE = AddKeyword (#Q_LT , f0, s0, ko, t0, t0, t0, t0, "!>=")
#X_NGT = AddKeyword (#Q_LE , f0, s0, ko, t0, t0, t0, t0, "!>")
#X_NLE = AddKeyword (#Q_GE , f0, s0, ko, t0, t0, t0, t0, "!<")
#X_NLT = AddKeyword (#Q_GT , f0, s0, ko, t0, t0, t0, t0, "!<=")
'
' #X_KEYWORD = AddKeyword ( q0, f0, s0, k0, t0, t0, t0, t0, "")
' #X_KEYWORD = AddKeyword ( q0, f0, s0, k0, t0, t0, t0, t0, "")
#xztoken = #ntoken
END FUNCTION
'
'
' ##################################
' ##### LoadQBasicProgram () #####
' ##################################
'
FUNCTION LoadQBasicProgram (@qbasic$[])
'
DIM qbasic$[] ' empty qbasic$[]
' print = $$TRUE ' print for debugging
XstGetCommandLineArguments (@count, @arg$[]) ' arg$[1] = QBasic program filename
'
' input filename of QBasic program if no command line argument
'
IF (count < 2) THEN
qfile$ = INLINE$ ("input filename of QuickBasic file ===>> ")
IFZ qfile$ THEN qfile$ = "qbasic.bas"
ELSE
qfile$ = arg$[1]
END IF
'
' qfile$ = filename of QBasic program - must be ASCII
'
IFZ qbasic$[] THEN
XstLoadStringArray (@qfile$, @qbasic$[]) ' qbasic$[] = QBasic program
END IF
'
IFZ qbasic$[] THEN
dot = RINSTR (qfile$, ".")
IF dot THEN file$ = LEFT$ (qfile$, dot-1)
END IF
'
IFZ qbasic$[] THEN
qfile$ = file$ + ".bas"
XstLoadStringArray (@qfile$, @qbasic$[]) ' qbasic$[] = QBasic program
END IF
'
IFZ qbasic$[] THEN
qfile$ = file$ + ".x"
XstLoadStringArray (@qfile$, @qbasic$[]) ' qbasic$[] = QBasic program
END IF
'
' print QBasic program during testing
'
uline = UBOUND (qbasic$[]) ' upper bound of QBasic array
FOR line = 0 TO uline ' for all lines of QBasic source
line$ = RTRIM$(qbasic$[line]) ' line$ = next line of QBasic program
IF line$ THEN topline = line ' this could be the final QBasic line
IF print THEN PRINT line$ ' perhaps print the QBasic line
qbasic$[line] = line$ ' replace trimmed line
NEXT line
'
IF (topline != uline) THEN REDIM qbasic$[topline]
END FUNCTION
'
'
' ###############################
' ##### QBasicToXBasic () #####
' ###############################
'
FUNCTION QBasicToXBasic (@qb$[], @xb$[])
'
DIM xb$[] ' no XBasic source
IFZ qb$[] THEN RETURN ' no QBasic source
'
Initialize () ' initialize everything
'
DIM #qbasic$[] '
DIM #xbasic$[] ' no XBasic source yet
SWAP #qbasic$[], qb$[] ' make QBasic source SHARED
'
ParseQBasic () ' convert #qbasic$[] source into tokens in #program[]
Translate () ' translate #program[] tokens into xbasic$[] source code
'
SWAP #qbasic$[], qb$[] ' restore QBasic source
SWAP #xbasic$[], xb$[] ' return XBasic source
END FUNCTION
'
'
' ############################
' ##### ParseQBasic () #####
' ############################
'
FUNCTION ParseQBasic ()
'
IFZ #qbasic$[] THEN RETURN ' no QBasic source program
#quline = UBOUND (#qbasic$[]) ' last line in QBasic source
'
' parse QBasic program into tokens-numbers in #program[function,line,token]
' creates symbol table in #token[] and #string$[]
'
line = 0
uline = 4095
DIM line[uline,]
'
#function = 0
'
FOR i = 0 TO #quline ' for all QBasic lines
DIM token[] ' start with zero tokens
function = #function ' remember this function-number
qbasic$ = #qbasic$[i] ' next line of QBasic source-code
qbasicline$ = qbasic$ '
ParseSourceLine (@qbasic$, @token[]) ' parse this line into tokens
IF #print THEN PRINT '
IF #print THEN PRINT qbasic$ '
IF #print THEN DeparseTokens (@token[], @line$) : PRINT line$
IF token[] THEN
IF (function != #function) THEN ' first executable line of new function
DEC line ' this line goes in the next function
REDIM line[line,] ' array size = number of lines in function
IF (#ufunction < #function) THEN
#ufunction = #ufunction + 1024 ' add 1024 lines to this function
REDIM #program[#ufunction,] ' make room for new lines of tokens in function
END IF
SWAP #program[#function,], line[] ' attach lines of tokens to program function
INC #function ' next function number
line = 0 ' first line in new function
uline = 4095 ' default number of lines in new function
DIM line[uline,] ' make room for lines of tokens in new function
END IF
END IF
IF (line > uline) THEN ' more lines than array space
uline = uline + 256 ' allow room for 256 more lines
REDIM line[uline,] ' make room for more lines of tokens
END IF
SWAP line[line,], token[] ' add tokens to program
NEXT i
END FUNCTION
'
'
' ##########################
' ##### Translate () #####
' ##########################
'
FUNCTION Translate ()
XLONG function[]
XLONG line[]
'
#xline = 0 ' start at beginning
DIM #xbasic$[] ' start with no XBasic
IFZ #program[] THEN RETURN ' no QBasic program tokens
XstLoadStringArray (@"start.txt", @start$[]) ' get standard XBasic startup
IFZ start$[] THEN RETURN ' support text-file missing
#xuline = #quline << 1 ' double room for XBasic
DIM xbasic$[#xuline] ' array to hold XBasic
OutputXBasic (@start$[]) ' startup #xbasic$[]
'
'
' translate QBasic tokens in #program[function,line,token] into XBasic source
'
line = 0
token = 0
#function = 0
#ufunction = UBOUND (#program[])
'
DIM func[]
DIM line[]
'
FOR function = 0 TO ufunction ' for all functions in program
SWAP #program[#function,], function[] ' function[] = tokens for function
uline = UBOUND (function[]) ' # of lines in this function
#function = function ' #function = this function
FOR line = 0 TO uline ' for all lines in function
SWAP function[line,], line[] ' line[] = tokens for next line
TranslateLine (@line[]) ' translate QBasic tokens to XBasic source
NEXT line '
NEXT function
END FUNCTION
'
'
' ##############################
' ##### TranslateLine () #####
' ##############################
'
FUNCTION TranslateLine (line[])
'
ntoken = 0
IFZ line[] THEN RETURN
utoken = UBOUND (line[])
'
' translate all statements on line
'
DO
done = TranslateStatement (@line[], @ntoken)
IF (ntoken > utoken) THEN EXIT DO
LOOP UNTIL done
END FUNCTION
'
'
' ###################################
' ##### TranslateStatement () #####
' ###################################
'
FUNCTION TranslateStatement (line[], ntoken)
END FUNCTION
'
'
' ##############################
' ##### DeparseTokens () #####
' ##############################
'
FUNCTION DeparseTokens (token[], line$)
'
line$ = ""
IFZ token[] THEN RETURN
'
upper = UBOUND (token[])
'
FOR i = 0 TO upper
token = token[i]
IFZ token THEN DO NEXT
whitestring = token >> 24
token = token AND 0x00FFFFFF
IF whitestring THEN line$ = line$ + #whitestring$[whitestring]
IF (token <= #utoken) THEN
line$ = line$ + #string$[#token[token].string]
END IF
NEXT i
END FUNCTION
'
'
' ################################
' ##### ParseSourceLine () ##### parse line of QBasic source into tokens
' ################################
'
FUNCTION ParseSourceLine (@line$, @line[])
STATIC FUNCADDR XLONG parseFunction[] (STRING, XLONG)
'
IFZ parseFunction[] THEN GOSUB LoadParseFunctionArray
'
offset = 0 ' offset to next character in line$
DIM line[] ' start with nothing on line
DIM #line[] ' start with no tokens on line
#whitebyte = 0 ' leading whitespace byte = zero
#nlinetoken = 0 ' where to put next token in #line[]
#ulinetoken = 255 ' upper bound of #line[] of tokens
DIM #line[#ulinetoken] ' make room for plenty of tokens
#functionLine = $$FALSE ' not function definition line
'
IFZ line$ THEN RETURN ' empty line
uchar = UBOUND (line$) ' uchar = upper character in line$
'
' parse the line - one language element at a time
'
DO ' all characters on line
char = line${offset} ' get next character on line
token = @parseFunction[char] (@line$, @offset) ' call appropriate function to process
token = token AND 0x00FFFFFF ' remove whitestring from token
IFZ token THEN EXIT DO ' zero token means end of line
'
IF (#ntoken == 1) THEN ' first important token on line
IF ((token == #Q_FUNCTION) OR (token == #Q_SUB)) THEN ' first line of new function
INC #function ' next function
END IF
END IF
LOOP WHILE (offset <= uchar)
'
IFZ #nlinetoken THEN ' nothing but whitespace = blank line
DIM #line[] '
DIM line[] '
ELSE '
REDIM #line[#nlinetoken] ' resize token array to minimum
#line[#nlinetoken] = 0 ' null terminate just in case
SWAP line[], #line[] ' return line[] of tokens
END IF '
'
RETURN ' end of function
'
'
'
' ****************************************
' ***** SUB LoadParseFunctionArray *****
' ****************************************
'
' Array parseFunction[] contains the addresses of the functions that
' should parse the next language-element, based on its 1st character.
' For example, if the first character of a language-element is "0"-"9",
' the language-element is some kind of number. "+","-",etc = operators.
' "A"-"Z", "a"-"z", "_" = some kind of symbol. space & tab = whitespace.
'
' ##### NOTE #####
'
' The following character ranges are more-or-less correct for XBasic,
' but almost certainly need a little modification for QBasic.
'
SUB LoadParseFunctionArray
DIM parseFunction[255]
FOR c = 0 TO 255
SELECT CASE TRUE
CASE (c >= 128) : parseFunction[c] = &ParseWhitespace() ' convert trash to spaces
CASE (c >= 123) : parseFunction[c] = &ParseCharacter() ' character or operator
CASE (c >= 97) : parseFunction[c] = &ParseSymbol() ' "a-z"
CASE (c == 95) : parseFunction[c] = &ParseSymbol() ' "_"
CASE (c >= 91) : parseFunction[c] = &ParseCharacter() ' character or operator
CASE (c >= 65) : parseFunction[c] = &ParseSymbol() ' "A-Z"
CASE (c >= 58) : parseFunction[c] = &ParseCharacter() ' character or operator
CASE (c >= 48) : parseFunction[c] = &ParseNumber() ' "0-9"
CASE (c == 36) : parseFunction[c] = &ParseSymbol() ' "$con" or "$$con
CASE (c == 35) : parseFunction[c] = &ParseSymbol() ' "#var" or "##var"
CASE (c >= 33) : parseFunction[c] = &ParseCharacter() ' character / operator
CASE (c == 32) : parseFunction[c] = &ParseWhitespace() ' space chars
CASE (c == 9) : parseFunction[c] = &ParseWhitespace() ' tab chars
CASE (c <= 8) : parseFunction[c] = &ParseWhitespace() ' convert trash to spaces
END SELECT
NEXT c
END SUB
END FUNCTION
'
'
' ################################
' ##### ParseWhitespace () ##### parse whitespace characters into a whitespace-string token
' ################################
'
' This function collects consecutive whitespace characters starting
' at offset in line$. This function then looks for the whitespace-string
' it collected in the 255 element #whitestring$[] array. If it finds an
' identical whitestring, it returns the element # of the matching element
' in #whitestring$[]. If it doesn't find a match, it adds the whitestring
' to #whitestring$[] and returns the element # of the new whitestring.
' If a program is wacko enough to have more than 255 different whitespace
' strings, this function will return one of the 255 existing whitespaces.
'
' The 255 whitespace values are designed to be imbedded in whatever token
' follows to indicate "leading whitespace".
'
FUNCTION ParseWhitespace (@line$, @offset)
'
token = 0
first = offset
#whitebyte = 0
'
DO
char = line${offset} ' char = next character
white = #charsetWhitespace[char] ' is character whitespace
IFZ char THEN RETURN #whitebyte ' clip trailing whitespace
IFZ white THEN EXIT DO ' exit unless whitespace
INC offset ' next character on line
LOOP
'
token = 0
past = offset
length = past - first
IFZ length THEN RETURN #whitebyte ' no whitespace
'
whitestring$ = MID$ (line$, first+1, length)
IFZ whitestring$ THEN RETURN #whitebyte
'
FOR i = 1 TO #nwhite
IF (whitestring$ == #whitestring$[i]) THEN #whitebyte = i : RETURN #whitebyte
NEXT i
'
' this whitestring is not yet in whitestring array, so add it
'
IF (#nwhite < #uwhite) THEN
INC #nwhite
#whitestring$[#nwhite] = whitestring$
#whitebyte = #nwhite
ELSE
#whitebyte = 1 ' no room for another whitestring, so fake one
END IF
'
RETURN #whitebyte
END FUNCTION
'
'
' ###############################
' ##### ParseCharacter () ##### parse special characters into the appropriate token
' ###############################
'
' This function parses 1 or more consecutive non-alphanumeric
' characters starting at offset in line$ into a symbol-token.
' Examples include operators ("<>", "<", "<=", "+", "*", "/")
' and other language elements ("[" "]" "(" ")" "'"), etc.
'
FUNCTION ParseCharacter (@line$, @offset)
STATIC SUBADDR parseCharacter[]
STATIC XLONG characterToken[]
'
IFZ characterToken[] THEN GOSUB Initialize
'
linelength = LEN (line$)
char = line${offset}
start = offset
INC offset
'
token = characterToken[char] ' this one character generates a token
IFZ token THEN GOSUB @parseCharacter[char] ' GOSUB a subroutine to parse this token
IF token THEN OutputToken (@token) ' add token to program
RETURN token
'
'
' characters that have their own tokens
'
SUB Character
symbol$ = CHR$ (char)
token = AddToken (0, 0, 0, $$KIND_CHARACTER, 0, 0, 0, 0, @symbol$)
IF token THEN #token[token].ivalue = char
END SUB
'
'
' *************************************************************************
' ***** Parse characters that may be part of 1+ character sequences *****
' *************************************************************************
'
'
'
' ***** & *****
'
' &O = prefix for octal literal : &O17777777777 = max-long : &O37777777777 = -1
' &H = prefix for hexadecimal literal
'
SUB Ampersand
value = 0 ' value = 0
digits = 0 ' hex digits
char = line${offset} ' char after &
'
INC offset ' offset to character after &O or &H prefix
'
SELECT CASE char
CASE 'O'
char = line${offset} ' but only if next character is 0-7
DO WHILE #charsetOctal[char] ' while character is 0-7
INC digits ' count valid hexadecimal digits
INC offset ' offset to next hexadecimal digit
SELECT CASE TRUE
CASE ((char >= '0') AND (char <= '7')) : octal = char - '0'
END SELECT
char = line${offset} ' next character
value = (value << 3) OR octal ' create cumulative hex value
LOOP UNTIL (value AND 0xE0000000) ' quit before 32-bits overflows
CASE 'H'
char = line${offset} ' but only if next character is 0-9 or A-F
DO WHILE #charsetHexUpper[char] ' while character is 0-9 or A-F
INC digits ' count valid hexadecimal digits
INC offset ' offset to next hexadecimal digit
SELECT CASE TRUE
CASE ((char >= '0') AND (char <= '9')) : hex = char - '0'
CASE ((char >= 'A') AND (char <= 'F')) : hex = char - 'A' + 10
' CASE ((char >= 'a') AND (char <= 'f')) : hex = char - 'a' + 10 ' always upper-case in QBasic
END SELECT
char = line${offset} ' next character
value = (value << 4) OR hex ' create cumulative hex value
LOOP UNTIL (value AND 0xF0000000) ' quit before 32-bits overflows
END SELECT
'
IFZ digits THEN
offset = start + 1
token = AddToken (0, 0, 0, $$KIND_CHARACTER, 0, 0, 0, 0, @"&")
ELSE
symbol$ = MID$ (line$, start+1, digits+2)
token = AddToken (0, 0, 0, $$KIND_LITERAL, $$TYPE_XLONG, 0, 0, 0, @symbol$)
IF token THEN #token[token].ivalue = value
END IF
END SUB
'
'
' ***** " ***** Literal string *****
'
SUB DoubleQuote
scans = offset ' 0 offset to character after opening double-quote
start = offset ' 1 offset to opening double-quote
final = linelength ' 0 offset to null-terminator
'
IF (scans < final) THEN
rawchar = line${scans}
DO UNTIL (rawchar = '"')
IF (rawchar = '\\') THEN
INC scans
rawchar = line${scans}
END IF
INC scans
rawchar = line${scans}
LOOP WHILE (scans < final)
END IF
'
IF (scans < final) THEN
INC scans
offset = scans ' terminated by " character - normal case
ELSE
offset = scans ' terminated by end-of-line null-terminator, not "
INC scans
END IF
'
lit$ = MID$ (line$, start, (scans-start)) + "\""
token = AddToken (0, 0, 0, $$KIND_LITERAL, $$TYPE_STRING, 0, 0, 0, @lit$)
END SUB
'
'
' ***** ' *****
'
SUB SingleQuote
comment$ = MID$ (line$, offset)
token = AddToken (0, 0, 0, $$KIND_COMMENT, $$TYPE_STRING, 0, 0, 0, @comment$)
offset = linelength
END SUB
'
'
' ***** . ***** .2345e3 (a number) or .component of composite
'
SUB Dot
two = line${offset}
SELECT CASE TRUE
CASE #charsetNumeric[two] ' a number, like .234567
DEC offset
token = ParseNumber (@line$, @offset)
CASE #charsetUpperLower[two] ' composite element, like .ssn in variable.ssn
DEC offset
token = ParseSymbol (@line$, @offset)
CASE ELSE ' standalone . is a syntax error
token = AddToken (0, 0, 0, $$KIND_CHARACTER, $$TYPE_UBYTE, 0, 0, 0, ".")
IF token THEN #token[token].ivalue = '.'
token = #Q_DOT
END SELECT
END SUB
'
'
' ***** < ***** < <> <=
'
SUB LessThan
two = line${offset} ' char after <
SELECT CASE two
CASE '>' : token = #Q_NE : INC offset ' <>
CASE '=' : token = #Q_LE : INC offset ' <=
CASE ELSE : token = #Q_LT ' <
END SELECT
END SUB
'
'
' ***** > ***** > >=
'
SUB GreaterThan
two = line${offset}
SELECT CASE two
CASE '=' : token = #Q_GE : INC offset ' >=
CASE ELSE : token = #Q_GT ' >
END SELECT
END SUB
'
'
'
' **********************************************************************************
' ***** load characterToken[] with tokens for 1-character length tokens only *****
' ***** load parseCharacter[] with addresses of routines to parse characters *****
' **********************************************************************************
'
SUB Initialize
DIM characterToken[255]
DIM parseCharacter[255]
'
' The following single characters get parsed into a token.
' In other words, whenever the first character a parse routine
' encounters is one of these characters, the single character
' always gets parsed into a token.
'
characterToken [ '+' ] = #Q_PLUS
characterToken [ '-' ] = #Q_MINUS
characterToken [ '*' ] = #Q_MULTIPLY
characterToken [ '/' ] = #Q_DIVIDE
characterToken [ '^' ] = #Q_POWER
characterToken [ '=' ] = #Q_EQ
' characterToken [ '&' ] = #Q_AMPERSAND ' does QuickBasic support & operator ???
characterToken ['\\' ] = #Q_IDIVIDE
characterToken [ '(' ] = #Q_LPAREN
characterToken [ ')' ] = #Q_RPAREN
characterToken [ '[' ] = #Q_LBRAK
characterToken [ ']' ] = #Q_RBRAK
characterToken [ ':' ] = #Q_COLON
characterToken [ ';' ] = #Q_SEMI
characterToken [ ',' ] = #Q_COMMA
'
' subroutines to process tokens starting with any character
'
' ' 00-32 handled elsewhere
parseCharacter [ '!' ] = SUBADDRESS (Character) ' !
parseCharacter [ '"' ] = SUBADDRESS (DoubleQuote) ' "
parseCharacter [ '#' ] = SUBADDRESS (Character) ' #
parseCharacter [ '$' ] = SUBADDRESS (Character) ' $
parseCharacter [ '%' ] = SUBADDRESS (Character) ' %
parseCharacter [ '&' ] = SUBADDRESS (Ampersand) ' &
parseCharacter [ ''' ] = SUBADDRESS (SingleQuote) ' '
parseCharacter [ '.' ] = SUBADDRESS (Dot) ' .
' ' 48-57 handled elsewhere
parseCharacter [ '<' ] = SUBADDRESS (LessThan) ' < <= <>
parseCharacter [ '>' ] = SUBADDRESS (GreaterThan) ' > >=
parseCharacter [ '?' ] = SUBADDRESS (Character) ' ?
parseCharacter [ '@' ] = SUBADDRESS (Character) ' @
' ' 65-90 handled elsewhere
parseCharacter [ '_' ] = SUBADDRESS (Character) ' _
parseCharacter [ '`' ] = SUBADDRESS (Character) ' `
' ' 97-122 handled elsewhere
parseCharacter [ '{' ] = SUBADDRESS (Character) ' {
parseCharacter [ '|' ] = SUBADDRESS (Character) ' |
parseCharacter [ '}' ] = SUBADDRESS (Character) ' }
parseCharacter [ '~' ] = SUBADDRESS (Character) ' ~
parseCharacter [ 127 ] = SUBADDRESS (Character) ' CHR$(127)
' ' 128-255 are white trash
END SUB
END FUNCTION
'
'
' ############################
' ##### ParseNumber () ##### parse a number into the appropriate number token
' ############################
'
FUNCTION ParseNumber (@line$, @offset)
'
enter = offset
start = offset
specType = XstStringToNumber (@line$, @start, @offset, @rtype, @value$$)
vhi = GHIGH (value$$)
vlo = GLOW (value$$)
value = vlo
'
suffix = line${offset}
IF (specType < 0) THEN specType = 0
'
' see if number is followed by a type-suffix
'
IFZ specType THEN
SELECT CASE suffix
CASE '%' : specType = $$TYPE_SSHORT : INC offset
CASE '&' : specType = $$TYPE_SLONG : INC offset
CASE '!' : specType = $$TYPE_SINGLE : INC offset
CASE '#' : specType = $$TYPE_DOUBLE : INC offset
END SELECT
END IF
'
number$ = MID$ (line$, start+1, offset-start)
'
' if type not specified by anything yet, decide on basis of the value
'
IFZ specType THEN
SELECT CASE rtype
CASE 0 : specType = $$SLONG ' zero
CASE $$TYPE_XLONG : specType = $$SLONG ' "0x..."
CASE $$TYPE_SINGLE : specType = $$SINGLE ' "0s..."
CASE $$TYPE_GIANT : specType = MinTypeFromGiant (value$$)
CASE $$TYPE_DOUBLE : value# = DMAKE (vhi, vlo)
specType = MinTypeFromDouble (value#)
CASE ELSE : PRINT "ParseNumber() : error" : RETURN ($$FALSE)
END SELECT
END IF
'
' add the literal number token to the token stream
'
type = specType
kind = $$KIND_LITERAL
token = AddToken (0, 0, 0, kind, type, 0, 0, 0, @number$)
IF token THEN
IF (type < $$TYPE_SINGLE) THEN #token[token].ivalue = value$$ ELSE #token[token].fvalue = value#
END IF
OutputToken (@token)
RETURN (token)
END FUNCTION
'
'
' ############################
' ##### ParseSymbol () ##### parse a symbol into the appropriate token
' ############################
'
FUNCTION ParseSymbol (@line$, @offset)
'
' collect the symbol
'
token = 0
start = offset
GetSymbol (@line$, @offset, @symbol$)
IFZ symbol$ THEN RETURN token
'
' is symbol a keyword or component of composite
'
firstchar = line${start}
afterchar = line${offset}
finalchar = line${offset-1}
'
' ??? keyword symbol ???
'
IF (firstchar != '.') THEN
token = TestForKeyword (@symbol$)
IF token THEN
OutputToken (token)
RETURN (token)
END IF
END IF
'
' 1st and 2nd tokens on line need special attention
'
SELECT CASE #tokenptr
CASE 0 : IF ((afterchar == ':') AND (LEN(symbol$) == offset)) THEN ' label:
INC offset
token = AddToken (0, 0, 0, $$KIND_LABEL, $$TYPE_GOADDR, 0, 0, 0, @symbol$)
OutputToken (@token)
RETURN (token)
END IF
CASE 1 : IF (#lasttoken == #Q_TYPE) THEN
IF #charsetUpperLower[firstchar] THEN
IF #charsetUpperLowerNumeric[finalchar] THEN
token = AddToken (0, 0, 0, $$KIND_TYPE, 0, 0, 0, 0, @symbol$)
OutputToken (@token)
RETURN (token)
END IF
END IF
END IF
END SELECT
'
' certain symbols are interpreted differently if following certain tokens
'
SELECT CASE #lasttoken
CASE #Q_GOTO ' GOTO label
token = AddToken (0, 0, 0, $$KIND_LABEL, $$TYPE_GOADDR, 0, 0, 0, @symbol$)
OutputToken (@token)
RETURN (token)
CASE #Q_GOSUB, #Q_SUB ' SUB subname or GOSUB subname
token = AddToken (0, 0, 0, $$KIND_LABEL, $$TYPE_SUBADDR, 0, 0, 0, @symbol$)
OutputToken (@token)
RETURN (token)
CASE #Q_LPAREN
SELECT CASE #backtoken
CASE T_GOADDRESS ' GOADDRESS (label)
token = AddToken (0, 0, 0, $$KIND_LABEL, $$TYPE_GOADDR, 0, 0, 0, @symbol$)
OutputToken (@token)
RETURN (token)
CASE T_SUBADDRESS ' SUBADDRESS (subname)
token = AddToken (0, 0, 0, $$KIND_LABEL, $$TYPE_SUBADDR, 0, 0, 0, @symbol$)
OutputToken (@token)
RETURN (token)
END SELECT
CASE ELSE
END SELECT
'
' symbols that begin with certain characters require special attention
'
' .components of composites
'
IF (firstchar = '.') THEN ' .COMPONENT name
token = AddToken (0, 0, 0, $$KIND_SYMBOL, 0, 0, 0, 0, @symbol$)
OutputToken (@token)
RETURN (token)
END IF
'
' normal symbols can have type suffix characters
'
SELECT CASE afterchar
CASE '@' : symbol$ = symbol$ + "@"
type = $$SBYTE
INC offset
CASE '%' : symbol$ = symbol$ + "%"
type = $$SSHORT
INC offset
CASE '&' : symbol$ = symbol$ + "&"
type = $$SLONG
INC offset
CASE '!' : symbol$ = symbol$ + "!"
type = $$SINGLE
INC offset
CASE '#' : symbol$ = symbol$ + "#"
type = $$DOUBLE
INC offset
CASE '$' : symbol$ = symbol$ + "$"
type = $$STRING
INC offset
CASE ELSE : type = 0
END SELECT
'
' see what follows trailing spaces/tabs
'
sx = 0
test = line${offset + sx}
DO WHILE (#charsetSpaceTab[test])
INC sx
test = line${offset + sx}
LOOP
'
' see if this is an array or function symbol
'
SELECT CASE test
CASE '(' : kind = $$KIND_FUNCTION
CASE '[' : kind = $$KIND_ARRAY
CASE ELSE : kind = $$KIND_VARIABLE
END SELECT
'
token = AddToken (0, 0, 0, kind, type, scope, 0, 0, @symbol$)
OutputToken (@token)
RETURN (token)
END FUNCTION
'
'
' ##########################
' ##### GetSymbol () #####
' ##########################
'
FUNCTION GetSymbol (line$, offset, symbol$)
'
start = offset
char = line${offset}
IF (char == '.') THEN INC offset : char = line${offset} ' .component symbol
'
DO WHILE (#charsetSymbolInner[char]) ' TRUE while A-Z, a-z, 0-9, "_"
INC offset
char = line${offset}
LOOP
'
symbol$ = MID$ (line$, start+1, offset-start)
END FUNCTION
'
'
' ############################
' ##### OutputToken () ##### parse a symbol into the appropriate token
' ############################
'
FUNCTION OutputToken (token)
'
#backtoken = #lasttoken
#lasttoken = token
'
IF (#nlinetoken > #ulinetoken) THEN
#ulinetoken = #ulinetoken + 256
REDIM #line[#ulinetoken]
END IF
'
IF (#whitebyte > 255) THEN #whitebyte = 1 ' disaster catcher
token = (#whitebyte << 24) + token ' put whitebyte in token
#line[#nlinetoken] = token ' add complete token to line of tokens
INC #nlinetoken ' next token in this line of tokens
#whitebyte = 0 ' whitestring output so cancel it
'
IF #print THEN PRINT " "; HEX$(token,8);
END FUNCTION
'
'
' ###############################
' ##### TestForKeyword () #####
' ###############################
'
FUNCTION TestForKeyword (string$)
'
token = 0
IFZ string$ THEN RETURN token
'
firstchar = string${0}
IF (firstchar = '_') THEN RETURN token
'
length = LEN (string$)
upper = length - 1
hash = 0
'
FOR i = 0 TO upper ' for all bytes in string
hash = hash + #hx[string${i}] ' add hash for that byte
NEXT i ' next byte in string
'
hash = hash AND 0x000000FF ' clip hash to byte
token = 0
'
' is symbol a QBasic keyword ???
'
FOR t = #qatoken TO #qztoken
IF (hash == #token[t].hash) THEN
IF (#string$[#token[t].string] == string$) THEN ' found keyword
token = t
EXIT FOR
END IF
END IF
NEXT t
RETURN token
END FUNCTION
'
'
' #################################
' ##### MinTypeFromGiant () #####
' #################################
'
FUNCTION MinTypeFromGiant (v$$)
'
SELECT CASE TRUE
CASE ((v$$ >= $$MIN_USHORT) AND (v$$ <= $$MAX_USHORT)) : rt = $$USHORT
CASE ((v$$ >= $$MIN_SSHORT) AND (v$$ <= $$MAX_SSHORT)) : rt = $$SSHORT
CASE ((v$$ >= $$MIN_SLONG) AND (v$$ <= $$MAX_SLONG)) : rt = $$SLONG
CASE ELSE : rt = $$GIANT
END SELECT
RETURN (rt)
END FUNCTION
'
'
' ##################################
' ##### MinTypeFromDouble () #####
' ##################################
'
FUNCTION MinTypeFromDouble (value#)
'
IF (value# < 0) THEN value# = -value#
minSingleExponent# = 0s00800000
maxSingleExponent# = 0s7F000000
IF (value# < minSingleExponent#) THEN RETURN ($$TYPE_DOUBLE)
IF (value# > maxSingleExponent#) THEN RETURN ($$TYPE_DOUBLE)
svalue! = value#
dvalue# = svalue!
IF (value# == dvalue#) THEN RETURN ($$TYPE_SINGLE)
RETURN ($$TYPE_DOUBLE)
END FUNCTION
'
'
' ###########################
' ##### AddKeyword () #####
' ###########################
'
FUNCTION AddKeyword (translate, function, scope, kind, type, atype1, atype2, atype3, string$)
'
ntoken = 0 ' 0 means failure
IFZ string$ THEN RETURN ntoken ' empty string is no keyword
'
IF (kind AND $$KIND_QBASIC) THEN qbasic = $$TRUE ELSE qbasic = $$FALSE
IF (kind AND $$KIND_XBASIC) THEN xbasic = $$TRUE ELSE xbasic = $$FALSE
'
length = LEN (string$) ' length of string
upper = length - 1 ' upper bound
hash = 0 ' initialize
'
FOR i = 0 TO upper ' for all bytes in string
hash = hash + #hx[string${i}] ' add hash for that byte
NEXT i ' next byte in string
'
hash = hash AND 0x000000FF ' clip hash to byte
hashtoken = #hash[hash] ' see if any tokens with this hash exist yet
INC #nstring ' store string in next string-number
INC #ntoken ' store token in next token-number
'
SELECT CASE #pass
CASE 1 : GOSUB PassOne ' establish token and string
CASE 2 : GOSUB PassTwo ' add translate token and string
END SELECT
RETURN ntoken '
'
'
' *********************
' ***** PassOne ***** update hash-links in tokens
' *********************
'
SUB PassOne
IFZ hashtoken THEN ' first string with this hash value
#hash[hash] = #ntoken ' remember first token with this hash
hashback = #ntoken ' this is also the last string with this hash
hashnext = 0 ' no more strings with this hash value yet
ELSE '
last = #token[hashtoken].hashback ' last contains last entry with this hash
next = #token[hashtoken].hashnext ' next contains second entry with this hash
IF #token[last].hashnext THEN STOP ' error if last token already points forward
#token[hashtoken].hashback = #ntoken ' point first token with this hash at this one
#token[last].hashnext = #ntoken ' last token with this hash becomes next-to-last
hashback = last ' previous token with this hash value
hashnext = 0 ' last token with this hash value
END IF
'
' add token information and symbol string
'
#string$[#nstring] = string$ ' add new symbol to string table
'
#token[#ntoken].translate = translate ' token in other language - QBasic or XBasic
#token[#ntoken].function = function ' function this token is defined in
#token[#ntoken].string = #nstring ' string that contains this symbol
#token[#ntoken].length = length ' length of this token symbol
#token[#ntoken].token = #ntoken ' token number of this token
#token[#ntoken].scope = scope ' scope of token
#token[#ntoken].kind = kind ' kind of token
#token[#ntoken].type = type ' type of token
#token[#ntoken].hash = hash ' hash of token
#token[#ntoken].hashback = hashback ' previous token with this hash
#token[#ntoken].hashnext = hashnext ' next token with this hash
#token[#ntoken].akind[0] = 0 ' kind of argument 0
#token[#ntoken].akind[1] = 0 ' kind of argument 1
#token[#ntoken].akind[2] = 0 ' kind of argument 2
#token[#ntoken].atype[0] = atype1 ' type of argument 0
#token[#ntoken].atype[1] = atype2 ' type of argument 1
#token[#ntoken].atype[2] = atype3 ' type of argument 2
#token[#ntoken].first = 0 '
#token[#ntoken].final = 0 '
#token[#ntoken].ivalue = 0$$ '
#token[#ntoken].fvalue = 0.00# '
ntoken = #ntoken
END SUB
'
'
' *********************
' ***** PassTwo ***** update hash-links in tokens
' *********************
'
SUB PassTwo
IF (#string$[#token[#ntoken].string] != string$) THEN PRINT "##### disaster #####" : EXIT SUB
IF (#token[#ntoken].function != function) THEN PRINT "##### disaster #####" : EXIT SUB
IF (#token[#ntoken].length != length) THEN PRINT "##### disaster #####" : EXIT SUB
IF (#token[#ntoken].token != #ntoken) THEN PRINT "##### disaster #####" : EXIT SUB
IF (#token[#ntoken].scope != scope) THEN PRINT "##### disaster #####" : EXIT SUB
IF (#token[#ntoken].kind != kind) THEN PRINT "##### disaster #####" : EXIT SUB
IF (#token[#ntoken].type != type) THEN PRINT "##### disaster #####" : EXIT SUB
'
#token[#ntoken].translate = translate
ntoken = #ntoken
END SUB
END FUNCTION
'
'
' ##########################
' ##### FindToken () #####
' ##########################
'
FUNCTION FindToken (@match[], function, scope, kind, type, atype1, atype2, atype3, string$)
'
ntoken = 0 ' token not found
DIM match[] ' no matches found yet
IFZ string$ THEN RETURN ntoken ' empty symbol is no symbol
'
IF (kind AND $$KIND_QBASIC) THEN qbasic = $$TRUE ELSE qbasic = $$FALSE
IF (kind AND $$KIND_XBASIC) THEN xbasic = $$TRUE ELSE xbasic = $$FALSE
'
length = LEN (string$) ' length of string in bytes
upper = length - 1 ' upper bound of string
hash = 0 ' initialize hash
'
FOR i = 0 TO upper ' for all bytes in string
hash = hash + #hx[string${i}] ' add hash for that byte
NEXT i
'
hash = hash AND 0x000000FF ' clip hash to byte value
'
ntoken = #hash[hash] ' first entry with this hash
IFZ ntoken THEN RETURN $$FALSE ' no symbol with this hash
'
' check all symbols with this hash for a match
'
'
nmatch = 0 ' number of matches
umatch = 15 ' maximum match number
DIM match[umatch] ' upper bound of match[]
'
DO
symbol = #token[ntoken].string ' entry in string table
IF (symbol$ == #string$[string]) THEN ' symbols match
IF (function == #token[ntoken].function) THEN ' functions match
IF (nmatch > umatch) THEN ' make more room
umatch = umatch + 16 ' 16 more now
REDIM match[umatch] ' make room
END IF '
match[nmatch] = ntoken ' return the token
INC nmatch ' next match number
END IF '
END IF
ntoken = #token[ntoken].hashnext ' next token with same hash
LOOP WHILE ntoken ' no more tokens with this hash
END FUNCTION
'
'
' #########################
' ##### AddToken () #####
' #########################
'
FUNCTION AddToken (@token, function, scope, kind, type, atype1, atype2, atype3, string$)
'
ntoken = 0 ' token not added
IFZ string$ THEN RETURN ntoken ' empty string is no symbol
'
IF (kind AND $$KIND_QBASIC) THEN qbasic = $$TRUE ELSE qbasic = $$FALSE
IF (kind AND $$KIND_XBASIC) THEN xbasic = $$TRUE ELSE xbasic = $$FALSE
'
length = LEN (string$) ' length of string in bytes
upper = length - 1 ' upper bound of string
hash = 0 ' initialize hash
'
FOR i = 0 TO upper ' for all bytes in string
hash = hash + #hx[string${i}] ' add hash for that byte
NEXT i ' next byte in string
'
hash = hash AND 0x000000FF ' clip hash to byte
hashtoken = #hash[hash] ' see if any tokens with this hash exist yet
ntoken = 0 ' no token yet
'
' If no token has this hash, this must be a new token, and
' therefore this token is definitely added to symbol-table.
'
IFZ hashtoken THEN GOSUB NewHash
IF ntoken THEN RETURN ntoken
'
' If token already exists, return the existing token
'
GOSUB FindToken
IF ntoken THEN RETURN ntoken
'
' otherwise create and return a new token
'
GOSUB AddToken
RETURN ntoken
'
'
' *********************
' ***** NewHash ***** token must be new because hash-value is zero
' *********************
'
SUB NewHash
ntoken = 0
INC #ntoken ' store token in next token-number
INC #nstring ' store string in next string-number
#hash[hash] = #ntoken ' remember base-token with this hash
#token[#ntoken].hashback = #ntoken ' this is also the last string with this hash
#token[#ntoken].hashnext = #ntoken ' this is also the next string with this hash
'
#token[#ntoken].hash = hash '
#token[#ntoken].kind = kind '
#token[#ntoken].type = type '
#token[#ntoken].scope = scope '
#token[#ntoken].token = #ntoken '
#token[#ntoken].length = length '
#token[#ntoken].string = #nstring '
#token[#ntoken].function = function '
#token[#ntoken].atype[1] = atype1 '
#token[#ntoken].atype[2] = atype2 '
#token[#ntoken].atype[3] = atype3 '
#string$[#nstring] = string$ '
ntoken = #ntoken ' return token number of this new token
token = ntoken
END SUB
'
'
' ***********************
' ***** FindToken *****
' ***********************
'
SUB FindToken
ntoken = 0
last = #token[hashtoken].hashback ' last contains last entry with this hash
next = #token[hashtoken].hashnext ' next contains second entry with this hash
token = last ' start with last token with this hash value
'
DO
IF (kind == #token[token].kind) THEN
IF (hash == #token[token].hash) THEN
IF (scope == #token[token].scope) THEN
IF (length == #token[token].length) THEN
IF (string$ == #string$[#token[token].string]) THEN ' found token
ntoken = token
EXIT DO
END IF
END IF
END IF
END IF
END IF
IF (token == hashtoken) THEN EXIT DO ' no more tokens with this hash value
token = #token[token].hashback ' next token to test
LOOP
END SUB
'
'
' **********************
' ***** AddToken *****
' **********************
'
SUB AddToken
ntoken = 0 ' new token not added yet
INC #ntoken ' store token in next token-number
INC #nstring ' store string in next string-number
last = #token[hashtoken].hashback ' last contains last entry with this hash
'
#token[#ntoken].hashback = last ' new last-entry points back to old last-entry
#token[#ntoken].hashnext = hashtoken ' new last-entry points back at first-entry
#token[last].hashnext = #ntoken ' old last-entry points next to new last-entry
#token[hashtoken].hashback = #ntoken ' the base-entry points back at new last-entry
'
#hash[hash] = #ntoken ' remember first token with this hash
#token[#ntoken].hash = hash '
#token[#ntoken].kind = kind '
#token[#ntoken].type = type '
#token[#ntoken].scope = scope '
#token[#ntoken].token = #ntoken '
#token[#ntoken].length = length '
#token[#ntoken].string = #nstring '
#token[#ntoken].function = function '
#token[#ntoken].atype[1] = atype1 '
#token[#ntoken].atype[2] = atype2 '
#token[#ntoken].atype[3] = atype3 '
#string$[#nstring] = string$ '
ntoken = #ntoken ' return token number of this new token
token = ntoken
END SUB
END FUNCTION
'
'
' #############################
' ##### OutputXBasic () #####
' #############################
'
FUNCTION OutputXBasic (text$[])
IFZ text$[] THEN RETURN
upper = UBOUND (text$[])
lines = upper + 1
'
new = #xline + lines
'
IF (new > (#xuline - 256)) THEN
#xuline = #xuline + 1024
REDIM #xbasic$[#xuline]
END IF
'
FOR i = 0 TO upper
#xbasic$[#xline] = text$[i]
INC #xline
NEXT i
END FUNCTION
'
'
' ################################
' ##### TokenRestOfLine () #####
' ################################
'
FUNCTION TokenRestOfLine ()
'
' xxxxx
'
END FUNCTION
'
'
' ############################
' ##### PrintTokens () #####
' ############################
'
FUNCTION PrintTokens ()
'
FOR i = 0 TO #ntoken+1
IFZ (i AND 0x000F) THEN PRINT " tok# trantok# hash back next func kind datatype scope integer-value length symbol-string translate-symbol"
PRINT " ";
PRINT HEX$(#token[i].token,4);;
PRINT HEX$(#token[i].translate,8);;
PRINT HEX$(#token[i].hash,4);;
PRINT HEX$(#token[i].hashback,4);;
PRINT HEX$(#token[i].hashnext,4);;
PRINT HEX$(#token[i].function,4);;
PRINT HEX$(#token[i].kind,8);;
PRINT HEX$(#token[i].type,8);;
PRINT HEX$(#token[i].scope,5);;
PRINT HEX$(#token[i].ivalue,16);;
' PRINT HEX$(#token[i].fvalue,16);;
PRINT HEX$(#token[i].length,6);;;
PRINT FORMAT$("<<<<<<<<<<<<<<<<", #string$[#token[i].string]);;
'
translate = #token[i].translate
IF translate THEN PRINT #string$[#token[translate].string] ELSE PRINT
NEXT i
END FUNCTION
'
'
' ##########################
' ##### PrintHash () #####
' ##########################
'
FUNCTION PrintHash ()
'
FOR i = 0 TO 255
PRINT HEX$(i,2); " : ";
n = #hash[i]
DO WHILE n
PRINT HEX$(n,4);;
n = #token[n].hashnext
LOOP
PRINT
NEXT i
END FUNCTION
'
'
' ##########################
' ##### Terminate () #####
' ##########################
'
FUNCTION Terminate ()
'
' xxxxx
'
END FUNCTION
END PROGRAM
