pkg://xbasic-6.2.2-src.tar.gz:1523631/
xbasic-6.2.2/
src/
linux/xcol.x
downloads
'
'
' #################### Max Reason
' ##### PROLOG ##### copyright 1988-2000
' #################### Linux XBasic compiler
'
' subject to GPL license - see COPYING
'
' maxreason@maxreason.com
'
' for Linux XBasic
'
'
PROGRAM "xcol"
VERSION "0.0210"
'
IMPORT "xst"
IMPORT "xgr"
IMPORT "elf32"
IMPORT "kernel32"
'
' ##### IMPORTANT #####
'
' To run and debug this program in the XBasic development environment,
' you must first replace all occurences of "/xxx/" with the upper-case
' equivalent, and when you rebuild a new XBasic executable, you must
' replace all occurences of "/XXX/" with the lower-case equivalent.
' Otherwise total disaster will strike!
'
' ##########################################################
'
' OBJECT contains all information about an object except parallel arrays
' symbol$[], string$[], label$[] hold symbol, literal, and label strings.
' OBJECT is defined below, but is unimplemented in the code so far !!!
'
TYPE OBJECT
XLONG .id ' redundant object #
XLONG .alias ' id # of master copy of object (master instance of shared objects)
XLONG .kind ' variable, array, function, statement, operator...
XLONG .sharename ' ditto
XLONG .section ' code, data, bss...
XLONG .program ' program number (0 = system/environment)
XLONG .function ' function number (0 = shared/external)
XLONG .register ' allocation register or base register
XLONG .address ' memory address or offset
XLONG .addressMode ' addressing mode
XLONG .type ' data type (system defined or user defined)
XLONG .visibleType ' data type specified by suffix (a%, a#, a$)
XLONG .scope ' scope (AUTO, AUTOX, STATIC, SHARED, EXTERNAL)
XLONG .visibleScope ' scope specified by prefix... #Shared, ##External
XLONG .hash ' hash value (sum of hash[char] for all char)
XLONG .hashRaw ' hash value (sum of all characters)
XLONG .xlongValue ' SBYTE, UBYTE, SSHORT, USHORT, SLONG, ULONG, XLONG
GIANT .giantValue ' GIANT
SINGLE .singleValue ' SINGLE
DOUBLE .doubleValue ' DOUBLE
XLONG .whomask ' system/user (keep system objects across programs)
XLONG .name4 ' 1st four characters in name (quick test)
GIANT .name8 ' 1st eight characters in name (quick test)
XLONG .flags ' misc flags (declared, referenced, system, etc)
XLONG .res27
XLONG .res28
XLONG .res29
XLONG .res30
XLONG .res31
END TYPE
'
TYPE FUNCARG
XLONG .token
XLONG .varType
XLONG .argType
SBYTE .stack
SBYTE .byRef
UBYTE .kind
UBYTE .res
END TYPE
'
'
' OPCODE86 : 80486 opcode
'
TYPE OPCODE86
UBYTE .nbytes ' number of bytes in opcode
UBYTE .byte1 ' first byte
UBYTE .byte2 ' second byte
UBYTE .param ' special (usually "reg" from mod-reg-rm) for assembling
GOADDR .optype ' address in Code() to assemble opcode of this type
END TYPE
'
'
' ********************************
' ***** Compiler Functions *****
' ********************************
'
DECLARE FUNCTION Xnt ()
DECLARE FUNCTION XxxXBasic ()
'
INTERNAL FUNCTION AddLabel (label$, token, action)
INTERNAL FUNCTION AddSymbol (symbol$, token, funcNumber)
INTERNAL FUNCTION AlloToken (token)
INTERNAL FUNCTION AssemblerSymbol (symbol$)
INTERNAL FUNCTION AssignAddress (token)
INTERNAL FUNCTION AssignComposite (dreg, dtype, sreg, stype)
INTERNAL FUNCTION AtOps (xtype, opcode, mode, base, offset, sourceData)
INTERNAL FUNCTION BinStringToAsmString$ (rawString$)
INTERNAL FUNCTION CheckOneLine ()
INTERNAL FUNCTION CheckState (token)
INTERNAL FUNCTION CloneArrayXLONG (dest[], source[])
INTERNAL FUNCTION Code (op, mode, dreg, sreg, xreg, dtype, label$, remark$)
INTERNAL FUNCTION CodeLabelAbs (label$, offset)
INTERNAL FUNCTION CodeLabelDisp (label$)
INTERNAL FUNCTION Compile ()
INTERNAL FUNCTION CompileFile (file$)
INTERNAL FUNCTION Component (com, varToken, base, off, theType, tok, length)
INTERNAL FUNCTION Composite (com, theType, theReg, theOffset, theLength)
INTERNAL FUNCTION Conv (rad, toType, ras, fromType)
INTERNAL FUNCTION Deallocate (ptr)
INTERNAL FUNCTION EmitAsm (@line$)
INTERNAL FUNCTION Deparse$ (prefix$)
INTERNAL FUNCTION EmitData ()
INTERNAL FUNCTION EmitFunctionLabel (funcName$)
INTERNAL FUNCTION EmitLabel (labelName$)
INTERNAL FUNCTION EmitLine (lineNum)
INTERNAL FUNCTION EmitNull (comment$)
INTERNAL FUNCTION EmitString (theLabel$, theString$)
INTERNAL FUNCTION EmitText ()
INTERNAL FUNCTION EmitUserLabel (labelToken)
INTERNAL FUNCTION Eval (rtype)
INTERNAL FUNCTION ExpressArray (oldOp, oldPrec, newData, newType, accArray, excess, theType, sourceReg)
INTERNAL FUNCTION Expresso (oldTest, oldOp, oldPrec, oldData, oldType)
INTERNAL FUNCTION FloatLoad (dreg, stoken, stype)
INTERNAL FUNCTION FloatStore (sreg, stoken, stype)
INTERNAL FUNCTION FunctionCallPrep ()
INTERNAL FUNCTION FunctionCallPost ()
INTERNAL FUNCTION GetArg (dreg, dtype, source)
INTERNAL FUNCTION GetExternalAddresses ()
INTERNAL FUNCTION GetFuncaddrInfo (token, eleElements, argInfo[], dataPtr)
INTERNAL FUNCTION GetSubPath (sub$, file$, path$[])
INTERNAL FUNCTION GetSymbol$ (info)
INTERNAL FUNCTION GetTokenOrAddress (token, style, nextToken, dataType, nType, base, offset, length)
INTERNAL FUNCTION GetWords (source, dtype, w3, w2, w1, w0)
INTERNAL FUNCTION InitArrays ()
INTERNAL FUNCTION InitComplex ()
INTERNAL FUNCTION InitEntry ()
INTERNAL FUNCTION InitErrors ()
INTERNAL FUNCTION InitOptions ()
INTERNAL FUNCTION InitProgram ()
INTERNAL FUNCTION InitVariables ()
INTERNAL FUNCTION InvalidExternalSymbol (symbol$)
INTERNAL FUNCTION LastElement (token, lastPlace, excessComma)
INTERNAL FUNCTION Literal (xx)
INTERNAL FUNCTION LoadLitnum (dreg, dtype, source, stype)
INTERNAL FUNCTION MakeToken (keyword$, kind, dataType)
INTERNAL FUNCTION MinTypeFromDouble (value#)
INTERNAL FUNCTION MinTypeFromGiant (value$$)
INTERNAL FUNCTION Move (dest, dtype, source, stype)
INTERNAL FUNCTION NextToken ()
INTERNAL FUNCTION Op (rad, ras, theOp, rax, dtype, stype, otype, xtype)
INTERNAL FUNCTION OpenAccForType (theType)
INTERNAL FUNCTION OpenBothAccs ()
INTERNAL FUNCTION OpenOneAcc ()
INTERNAL FUNCTION ParseChar ()
INTERNAL FUNCTION ParseLine (tok[])
INTERNAL FUNCTION ParseNumber ()
INTERNAL FUNCTION ParseOutError (token)
INTERNAL FUNCTION ParseOutToken (token)
INTERNAL FUNCTION ParseSymbol ()
INTERNAL FUNCTION ParseWhite ()
INTERNAL FUNCTION PeekToken ()
INTERNAL FUNCTION Pop (dreg, dtype)
INTERNAL FUNCTION PrintError (errNumber)
INTERNAL FUNCTION PrintTokens ()
INTERNAL FUNCTION Printoid ()
INTERNAL FUNCTION Push (sreg, stype)
INTERNAL FUNCTION PushFuncArg (FUNCARG arg)
INTERNAL FUNCTION RangeCheck (ctype, symbol$)
INTERNAL FUNCTION Reg (token)
INTERNAL FUNCTION RegOnly (token)
INTERNAL FUNCTION ReturnValue (rtype)
INTERNAL FUNCTION ScopeToken (token)
INTERNAL FUNCTION Shuffle (oreg, areg, atype, ptype, atoken, pkind, mode, argOffset)
INTERNAL FUNCTION StackIt (toType, theData, fromType, offset)
INTERNAL FUNCTION StatementExport (token)
INTERNAL FUNCTION StatementImport (token)
INTERNAL FUNCTION StatementProgram (token)
INTERNAL FUNCTION StatementVersion (token)
INTERNAL FUNCTION StripExtent (filename$)
INTERNAL FUNCTION StripNonSymbol (name$)
INTERNAL FUNCTION StripSuffix$ (symbol$)
INTERNAL FUNCTION TestForKeyword (symbol$)
INTERNAL FUNCTION TheType (token)
INTERNAL FUNCTION Tok (symbol$, token, kind, raddr, value, value$)
INTERNAL FUNCTION TokenRestOfLine ()
INTERNAL FUNCTION TokensDefined ()
INTERNAL FUNCTION Top ()
INTERNAL FUNCTION Topax1 ()
INTERNAL FUNCTION Topax2 (topa, topb)
INTERNAL FUNCTION Topaccs (topa, topb)
INTERNAL FUNCTION Topx (tr, trx, nr, nrx)
INTERNAL FUNCTION TypeToken (token)
INTERNAL FUNCTION TypenameToken (token)
INTERNAL FUNCTION Uop (rad, theOp, rax, dtype, otype, xtype)
INTERNAL FUNCTION UpdateToken (token)
INTERNAL FUNCTION Value (label$, addrmode)
INTERNAL FUNCTION WriteDeclarationFile (string$)
INTERNAL FUNCTION WriteDefinitionFile (string$)
'
DECLARE FUNCTION XxxXBasicVersion$ ()
DECLARE FUNCTION XxxCheckLine (lineNumber, tok[])
DECLARE FUNCTION XxxCloseCompileFiles ()
DECLARE FUNCTION XxxCompilePrep ()
DECLARE FUNCTION XxxCreateCompileFiles ()
DECLARE FUNCTION XxxDeleteFunction (funcNumber)
DECLARE FUNCTION XxxDeparseFunction (func$, func[], lastLine, flags)
DECLARE FUNCTION XxxDeparser (tok[], deparsed$)
DECLARE FUNCTION XxxEmitXProfilerCall (funcNumber, lineNumber)
DECLARE FUNCTION XxxErrorInfo (xerror, rawPtr, srcPtr, srcLine$)
DECLARE FUNCTION XxxFunctionName (command, funcName$, funcToken)
DECLARE FUNCTION XxxGetAddressGivenLabel (label$)
DECLARE FUNCTION XxxGetFunctionVariables (funcNumber, kinds[], tok[], symbol$[], reg[], addr[])
DECLARE FUNCTION XxxGetLabelGivenAddress (addr, labels$[])
DECLARE FUNCTION XxxGetPatchErrors (symbol$[], token[], addr[])
DECLARE FUNCTION XxxGetProgramName (@name$)
DECLARE FUNCTION XxxGetSymbolInfo (tokNumber, token, theType, symbol$, reg, addr)
DECLARE FUNCTION XxxGetUserTypes (varTypes$[])
DECLARE FUNCTION XxxGetXerror$ (xerror)
DECLARE FUNCTION XxxInitAll ()
DECLARE FUNCTION XxxInitParse ()
DECLARE FUNCTION XxxInitVariablesPass1 ()
DECLARE FUNCTION XxxLibraryAPI (libname$)
DECLARE FUNCTION XxxLoadLibrary (token)
DECLARE FUNCTION XxxParseSourceLine (sourceLine$, tok[])
DECLARE FUNCTION XxxPassFunctionArrays (command, symbol$[], token[], scope[])
DECLARE FUNCTION XxxParseLibrary (token)
DECLARE FUNCTION XxxPassTypeArrays (command, pSize[], pSize$[], pAlias[], pAlign[], pSymbol$[], pToken[], pEleCount[], pEleSymbol$[], pEleToken[], pEleAddr[], pEleSize[], pEleType[], pEleStringSize[], pEleUBound[])
DECLARE FUNCTION XxxSetProgramName (name$)
DECLARE FUNCTION XxxTheType (token, funcNumber)
DECLARE FUNCTION XxxUndeclaredFunction (funcToken)
DECLARE FUNCTION XxxXntBlowback ()
DECLARE FUNCTION XxxXntFreeLibraries ()
'
' xdis functions
'
EXTERNAL FUNCTION XxxDisassemble$ (addr, bytes)
'
' xst functions
'
EXTERNAL FUNCTION XxxXstLoadLibrary (libname$)
'
'
' ********************************
' ***** EXTERNAL VARIABLES ***** Also referenced by "xit.x"
' ********************************
'
EXTERNAL /xxx/ i486asm
EXTERNAL /xxx/ i486bin
EXTERNAL /xxx/ library
EXTERNAL /xxx/ freezeFlag
EXTERNAL /xxx/ bogusFunction
EXTERNAL /xxx/ freezeFunction
EXTERNAL /xxx/ checkattach
EXTERNAL /xxx/ checkBounds
EXTERNAL /xxx/ entryFunction
EXTERNAL /xxx/ maxFuncNumber
EXTERNAL /xxx/ xpc
EXTERNAL /xxx/ errorCount
EXTERNAL /xxx/ litStringAddr
'
'
' ******************************
' ***** SHARED VARIABLES *****
' ******************************
'
SHARED pass0source
SHARED pass0tokens
SHARED pass1source
SHARED pass1tokens
SHARED pass2errors
SHARED XERROR
SHARED charPtr
SHARED rawline$
SHARED rawLength
SHARED tokenPtr
SHARED xit
SHARED hfn$
SHARED pass
SHARED inlevel
SHARED section
SHARED charV
SHARED makevalue$
SHARED defaultType
'
SHARED inPrint
SHARED markLine
SHARED tab_sym_ptr
SHARED utab
SHARED ulabel
SHARED labelPtr
SHARED pastSystemLabels
SHARED pastSystemSymbols
SHARED uFunc
SHARED uType
SHARED typePtr
SHARED externalAddr
SHARED sharename$
SHARED tab_sys_ptr
SHARED upatch
SHARED patchPtr
SHARED lineNumber
SHARED ofile
SHARED tokenCount
SHARED backToken
SHARED lastToken
SHARED programTypeChunk
SHARED functionTypeChunk
'
SHARED decFile$[]
SHARED cop[]
SHARED tokens[]
SHARED charpos[]
SHARED stackData[]
SHARED stackType[]
SHARED alphaFirst[]
SHARED alphaLast[]
SHARED r_addr[]
SHARED r_addr$[]
SHARED m_reg[]
SHARED m_addr[]
SHARED m_addr$[]
SHARED hash%[]
SHARED tab_sym$[]
SHARED tab_sym[]
SHARED tabType[]
SHARED tabArg[]
SHARED labhash[]
SHARED labaddr[]
SHARED tab_lab[]
SHARED tab_lab$[]
SHARED funcFrameSize[]
SHARED funcSymbol$[]
SHARED funcLabel$[]
SHARED funcToken[]
SHARED funcScope[]
SHARED funcType[]
SHARED funcKind[]
SHARED funcArgSize[]
SHARED funcArg[]
SHARED pastArgsAddr[]
SHARED xargNum
SHARED xargAddr[]
SHARED xargName$[]
SHARED autoAddr[]
SHARED autoxAddr[]
SHARED inargAddr[]
SHARED defaultType[]
SHARED tab_sys$[]
SHARED tab_sys[]
SHARED patchType[]
SHARED patchAddr[]
SHARED patchDest[]
SHARED q_type_long[]
SHARED typeName$[] ' "sbyte", "ubyte"...
SHARED typeSize[] ' size in bytes
SHARED typeSize$[] ' "1", "2", "4", "8", "16"...
SHARED typeAlias[] ' normal type that user-type is alias for
SHARED typeAlign[] ' alignment for this type
SHARED typeSuffix$[] ' @ @@ % %% & && ~ ! # $$ $
SHARED typeSymbol$[] ' SBYTE, UBYTE... SCOMPLEX, DCOMPLEX, USERTYPE...
SHARED typeToken[] ' T_TYPE token, low word = type #
SHARED typeEleCount[] ' # of elements in this type
SHARED typeEleSymbol$[] ' symbol for each n elements
SHARED typeEleToken[] ' token for each n elements
SHARED typeEleAddr[] ' offset address of each n elements
SHARED typeEleSize[] ' size of each n elements ([]: typesize*(dim+1))
SHARED typeEleType[] ' type of each n elements
SHARED typeEleArg[] ' kind/type of funcaddr component arguments
SHARED typeElePtr[] ' # indirection levels for each n elements
SHARED typeEleVal[] ' init value of each n elements
SHARED typeEleStringSize[] ' # bytes in fixed string for element n
SHARED typeEleUBound[] ' Upper bound of 1D array for element n
SHARED compositeNumber[] ' number of composite
SHARED compositeToken[] ' token of composite
SHARED compositeStart[] ' starting address of composite
SHARED compositeNext[] ' next available address after composite
SHARED minval#[]
SHARED maxval#[]
SHARED blanks[]
SHARED charToken[] ' tokens for single characters where they exist
SHARED subToken[]
SHARED nestVar[]
SHARED nestInfo[]
SHARED nestStep[]
SHARED nestLimit[]
SHARED nestCount[]
SHARED nestToken[]
SHARED nestLevel[]
SHARED SSHORT typeConvert[]
SHARED typeHigher[]
'
' ***** Common "charset" Arrays *****
'
SHARED assemblerBackslashAsm$[]
SHARED UBYTE charsetSymbolFirst[]
SHARED UBYTE charsetSymbolInner[]
SHARED UBYTE charsetSymbolFinal[]
SHARED UBYTE charsetUpper[]
SHARED UBYTE charsetLower[]
SHARED UBYTE charsetNumeric[]
SHARED UBYTE charsetUpperLower[]
SHARED UBYTE charsetUpperNumeric[]
SHARED UBYTE charsetLowerNumeric[]
SHARED UBYTE charsetUpperLowerNumeric[]
SHARED UBYTE charsetUpperToLower[]
SHARED UBYTE charsetLowerToUpper[]
SHARED UBYTE charsetVex[]
SHARED UBYTE charsetHexUpper[]
SHARED UBYTE charsetHexLower[]
SHARED UBYTE charsetHexUpperLower[]
SHARED UBYTE charsetHexUpperToLower[]
SHARED UBYTE charsetHexLowerToUpper[]
SHARED UBYTE charsetBackslash[]
SHARED UBYTE charsetBackslashByte[]
SHARED UBYTE charsetBackslashChar[]
SHARED UBYTE charsetNormalChar[]
SHARED UBYTE charsetPrintChar[]
SHARED UBYTE charsetSpaceTab[]
SHARED UBYTE charsetSuffix[]
SHARED xerror$[]
SHARED uerror
'
' *****
'
SHARED toms
SHARED toes
SHARED a0
SHARED a1
SHARED a0_type
SHARED a1_type
SHARED oos
SHARED UBYTE oos[]
'
SHARED header
SHARED infunc
SHARED got_declare
SHARED got_function
SHARED got_object_declaration
SHARED got_executable
SHARED got_expression
SHARED end_program
SHARED parse_got_function
'
SHARED labelNumber
'
SHARED insub
SHARED insub$
SHARED subCount
SHARED nestLevel ' nestXXXX used by DO and FOR
SHARED nestCount
SHARED compositeArg
SHARED crvtoken
'
SHARED ifLine
SHARED caseCount
SHARED func_number
SHARED function_line
SHARED declareAlloTypeLine
SHARED declareFuncaddrLine
SHARED funcaddrFuncNumber
SHARED dim_array
'
SHARED nullstring$
SHARED nullstringer
'
SHARED lastmax
SHARED lastlabmax
'
'
' ***** KEYWORD TOKENS *****
'
SHARED T_ABS
SHARED T_ALL
SHARED T_AND
SHARED T_ANY
SHARED T_ASC
SHARED T_ATTACH
SHARED T_AUTO
SHARED T_AUTOX
SHARED T_BIN_D
SHARED T_BINB_D
SHARED T_BITFIELD
SHARED T_CASE
SHARED T_CFUNCTION
SHARED T_CHR_D
SHARED T_CJUST_D
SHARED T_CLOSE
SHARED T_CLR
SHARED T_CSIZE
SHARED T_CSIZE_D
SHARED T_CSTRING_D
SHARED T_DEC
SHARED T_DECLARE
SHARED T_DEF
SHARED T_DHIGH
SHARED T_DIM
SHARED T_DLOW
SHARED T_DMAKE
SHARED T_DO
SHARED T_DOUBLE
SHARED T_DOUBLEAT
SHARED T_ELSE
SHARED T_END
SHARED T_ENDIF
SHARED T_EOF
SHARED T_EXIT
SHARED T_EXTERNAL
SHARED T_EXTS
SHARED T_EXTU
SHARED T_FALSE
SHARED T_FIX
SHARED T_FOR
SHARED T_FORMAT_D
SHARED T_FUNCADDR
SHARED T_FUNCADDRAT
SHARED T_FUNCADDRESS
SHARED T_FUNCTION
SHARED T_GHIGH
SHARED T_GIANT
SHARED T_GIANTAT
SHARED T_GLOW
SHARED T_GMAKE
SHARED T_GOADDR
SHARED T_GOADDRAT
SHARED T_GOADDRESS
SHARED T_GOSUB
SHARED T_GOTO
SHARED T_HEX_D
SHARED T_HEXX_D
SHARED T_HIGH0
SHARED T_HIGH1
SHARED T_IF
SHARED T_IFF
SHARED T_IFT
SHARED T_IFZ
SHARED T_INC
SHARED T_INCHR
SHARED T_INCHRI
SHARED T_INFILE_D
SHARED T_INLINE_D
SHARED T_INSTR
SHARED T_INSTRI
SHARED T_INT
SHARED T_INTERNAL
SHARED T_LCASE_D
SHARED T_LCLIP_D
SHARED T_LEFT_D
SHARED T_LEN
SHARED T_LJUST_D
SHARED T_LOF
SHARED T_LOOP
SHARED T_LTRIM_D
SHARED T_MAKE
SHARED T_MAX
SHARED T_MID_D
SHARED T_MIN
SHARED T_MOD
SHARED T_NEXT
SHARED T_NOT
SHARED T_NULL_D
SHARED T_OCT_D
SHARED T_OCTO_D
SHARED T_OPEN
SHARED T_OR
SHARED T_POF
SHARED T_PRINT
SHARED T_PROGRAM
SHARED T_QUIT
SHARED T_RCLIP_D
SHARED T_READ
SHARED T_REDIM
SHARED T_RETURN
SHARED T_RIGHT_D
SHARED T_RINCHR
SHARED T_RINCHRI
SHARED T_RINSTR
SHARED T_RINSTRI
SHARED T_RJUST_D
SHARED T_ROTATEL
SHARED T_ROTATER
SHARED T_RTRIM_D
SHARED T_SBYTE
SHARED T_SBYTEAT
SHARED T_SEEK
SHARED T_SELECT
SHARED T_SET
SHARED T_SGN
SHARED T_SFUNCTION
SHARED T_SHARED
SHARED T_SHELL
SHARED T_SIGN
SHARED T_SIGNED_D
SHARED T_SINGLE
SHARED T_SINGLEAT
SHARED T_SIZE
SHARED T_SLONG
SHARED T_SLONGAT
SHARED T_SMAKE
SHARED T_SPACE_D
SHARED T_SSHORT
SHARED T_SSHORTAT
SHARED T_STATIC
SHARED T_STEP
SHARED T_STOP
SHARED T_STR_D
SHARED T_STRING
SHARED T_STRING_D
SHARED T_STUFF_D
SHARED T_SUB
SHARED T_SUBADDR
SHARED T_SUBADDRAT
SHARED T_SUBADDRESS
SHARED T_SWAP
SHARED T_TAB
SHARED T_THEN
SHARED T_TO
SHARED T_TRIM_D
SHARED T_TRUE
SHARED T_TYPE
SHARED T_UBOUND
SHARED T_UBYTE
SHARED T_UBYTEAT
SHARED T_UCASE_D
SHARED T_ULONG
SHARED T_ULONGAT
SHARED T_UNION
SHARED T_UNTIL
SHARED T_USHORT
SHARED T_USHORTAT
SHARED T_VOID
SHARED T_WHILE
SHARED T_WRITE
SHARED T_XLONG
SHARED T_XLONGAT
SHARED T_XMAKE
SHARED T_XOR
'
' characters and character combos
'
SHARED T_LPAREN ' (
SHARED T_RPAREN ' )
SHARED T_LBRAK ' [
SHARED T_RBRAK ' ]
SHARED T_LBRACE ' {
SHARED T_RBRACE ' }
SHARED T_LBRACES ' {{
SHARED T_COMMA ' ,
SHARED T_SEMI ' ;
SHARED T_COLON ' :
SHARED T_REM ' '
SHARED T_RSHIFT ' >>
SHARED T_LSHIFT ' <<
SHARED T_DSHIFT ' >>> (sign extend signed types)
SHARED T_USHIFT ' <<<
SHARED T_NOTBIT, T_TILDA ' ~
SHARED T_ANDBIT ' &
SHARED T_XORBIT ' ^
SHARED T_ORBIT ' |
SHARED T_TESTL ' !!
SHARED T_NOTL ' !
SHARED T_ANDL ' &&
SHARED T_XORL ' ^^
SHARED T_ORL ' ||
SHARED T_CMP ' ::
SHARED T_EQL ' ==
SHARED T_EQ, T_NNE ' = !<>
SHARED T_NE, T_NEQ ' <> !=
SHARED T_LT, T_NGE ' < !>=
SHARED T_LE, T_NGT ' <= !>
SHARED T_GE, T_NLT ' >= !<
SHARED T_GT, T_NLE ' > !<=
SHARED T_SUBTRACT ' -
SHARED T_ADD ' +
SHARED T_IDIV ' \
SHARED T_MUL ' *
SHARED T_DIV ' /
SHARED T_REMAINDER ' %
SHARED T_POWER ' ** (not ^, ^ is bitwise XOR)
SHARED T_PLUS ' +
SHARED T_MINUS ' -
SHARED T_ADDR_OP ' &
SHARED T_HANDLE_OP ' &&
SHARED T_STORE_OP ' (internal)
SHARED T_ETC ' ...
SHARED T_PERCENT ' %
SHARED T_XMARK ' !
SHARED T_ATSIGN ' @
SHARED T_POUND ' #
SHARED T_DOLLAR ' $
SHARED T_DQUOTE ' "
SHARED T_DOT ' .
SHARED T_VBAR ' |
SHARED T_ULINE ' _
SHARED T_QMARK ' ?
SHARED T_TICK ' `
SHARED T_MARK ' \x7F
'
SHARED ERROR_AFTER_ELSE
SHARED ERROR_BAD_CASE_ALL
SHARED ERROR_BAD_GOSUB
SHARED ERROR_BAD_GOTO
SHARED ERROR_BAD_SYMBOL
SHARED ERROR_BITSPEC
SHARED ERROR_BYREF
SHARED ERROR_BYVAL
SHARED ERROR_COMPILER
SHARED ERROR_COMPONENT
SHARED ERROR_CROSSED_FUNCTIONS
SHARED ERROR_DECLARE
SHARED ERROR_DECLARE_FUNCS_FIRST
SHARED ERROR_DUP_DECLARATION
SHARED ERROR_DUP_DEFINITION
SHARED ERROR_DUP_LABEL
SHARED ERROR_DUP_TYPE
SHARED ERROR_ELSE_IN_CASE_ALL
SHARED ERROR_ENTRY_FUNCTION
SHARED ERROR_EXPECT_ASSIGNMENT
SHARED ERROR_EXPRESSION_STACK
SHARED ERROR_INTERNAL_EXTERNAL
SHARED ERROR_KIND_MISMATCH
SHARED ERROR_LITERAL
SHARED ERROR_NEST
SHARED ERROR_OUTSIDE_FUNCTIONS
SHARED ERROR_OVERFLOW
SHARED ERROR_REGADDR
SHARED ERROR_RETYPED
SHARED ERROR_SCOPE_MISMATCH
SHARED ERROR_SHARENAME
SHARED ERROR_SYNTAX
SHARED ERROR_TOO_FEW_ARGS
SHARED ERROR_TOO_LATE
SHARED ERROR_TOO_MANY_ARGS
SHARED ERROR_TYPE_MISMATCH
SHARED ERROR_UNDECLARED
SHARED ERROR_UNDEFINED
SHARED ERROR_UNIMPLEMENTED
SHARED ERROR_VOID
SHARED ERROR_WITHIN_FUNCTION
'
' Compiler Constants
'
$$VALUEABS = 0 ' addressing modes for Value ()
$$VALUEDISP = 1
$$TEXTSECTION = 0
$$DATASECTION = 1
$$USERSECTION = 2
$$STACKSECTION = 3
$$XGET = 0 ' get token (also generic GET)
$$XSET = 1 ' set token (also generic SET)
$$XADD = 1 ' add token
$$XNEW = 2 ' add token (override existing)
$$GETADDR = 0 ' see Composite()
$$GETHANDLE = 1 ' see Composite()
$$GETDATAADDR = 2 ' see Composite()
$$GETDATA = 3 ' see Composite()
$$NORMAL_SYMBOL = 0 ' see GetSymbol() normalSymbol
$$LOCAL_CONSTANT = 1 ' see GetSymbol() $LOCAL_CONSTANT
$$GLOBAL_CONSTANT = 2 ' see GetSymbol() $$GLOBAL_CONSTANT
$$SHARED_VARIABLE = 3 ' see GetSymbol() #SharedVariable
$$EXTERNAL_VARIABLE = 4 ' see GetSymbol() ##ExternalVariable
$$SOLO_POUND = 5 ' see GetSymbol() solo #
$$DUAL_POUND = 6 ' see GetSymbol() dual ##
$$COMPONENT = 7 ' see GetSymbol() .component
$$NONE = 0 ' not data kind
$$VAR_TOKEN = 1 ' variable (built-in or user-defined)
$$ARRAY_TOKEN = 2 ' whole array of any type
$$ARRAY_NODE = 3 ' array node of any type
$$DATA_ADDR = 4 ' data address of any type
'
' r30 offsets for system variables:
' replace with computed values as soon as available
'
$$xerrorOffset = 0x0180 ' &($$XERROR) - r30
$$walkbaseOffset = 0x01B8
$$walkoffsetOffset = 0x01BC
$$softBreakOffset = 0x01C0
'
$$BREAKPOINT = 0x80000000 ' Start token: indicates BP at this line
$$CURRENTEXE = 0x40000000 ' " : marks current execution line
'
'
' ***** BITFIELD TOKENS *****
'
$$SPACE = BITFIELD ( 3, 29) ' spaces following token symbol
$$KIND = BITFIELD ( 5, 24) ' kind of token
$$ALLO = BITFIELD ( 3, 21) ' allocation of data objects
$$ARGS = BITFIELD ( 3, 21) ' max # of args to intrinsics
$$TYPE = BITFIELD ( 5, 16) ' data type
$$PREC = BITFIELD ( 4, 16) ' precedence of operators
$$NUMBER = BITFIELD (16, 0) ' token #
$$RAWTYPE = BITFIELD ( 8, 16) ' type and allo field
$$RAWALLO = BITFIELD ( 8, 16) ' type and allo field
$$BYTE0 = BITFIELD ( 8, 0) ' byte 0 (low byte)
$$BYTE1 = BITFIELD ( 8, 8) ' byte 1
$$BYTE2 = BITFIELD ( 8, 16) ' byte 2
$$BYTE3 = BITFIELD ( 8, 24) ' byte 3 (high byte)
$$WORD0 = BITFIELD (16, 0) ' word 0 (low word)
$$WORD1 = BITFIELD (16, 16) ' word 1 (high word)
$$CLEAR_BP_EXE = BITFIELD (30, 0) ' clear BP/EXE from start token
'
'
' ***** PROTOTYPE TOKENS *****
'
$$T_SYMBOLS = 0x00000000
$$T_VARIABLES = 0x01000000
$$T_ARRAYS = 0x02000000
$$T_LITERALS = 0x03000000
$$T_CONSTANTS = 0x04000000
$$T_COMPOSITES = 0x05000000
$$T_LABELS = 0x06000000
$$T_FUNCTIONS = 0x07000000
$$T_ARRAY_SYMBOLS = 0x08000000
$$T_CHARCONS = 0x0B000000
$$T_SYSCONS = 0x0C000000
$$T_STATEMENTS = 0x0D000000
$$T_INTRINSICS = 0x0E000000
$$T_STATE_INTRIN = 0x0F000000
$$T_TYPES = 0x10000000
$$T_STARTS = 0x11000000
$$T_SEPARATORS = 0x12000000
$$T_TERMINATORS = 0x13000000
$$T_LPARENS = 0x14000000
$$T_RPARENS = 0x15000000
$$T_BINARY_OPS = 0x16000000
$$T_UNARY_OPS = 0x17000000
$$T_ADDR_OPS = 0x18000000
$$T_COMMENTS = 0x19000000
$$T_CHARACTERS = 0x1A000000
$$T_WHITES = 0x1B000000
'
'
' ***** KIND TOKENS *****
'
$$KIND_SYMBOLS = 0x00
$$KIND_VARIABLES = 0x01
$$KIND_ARRAYS = 0x02
$$KIND_LITERALS = 0x03
$$KIND_CONSTANTS = 0x04
' $$KIND_COMPOSITES = 0x05 ' not used
$$KIND_LABELS = 0x06
$$KIND_FUNCTIONS = 0x07
$$KIND_ARRAY_SYMBOLS = 0x08
$$KIND_CHARCONS = 0x0B
$$KIND_SYSCONS = 0x0C
$$KIND_STATEMENTS = 0x0D
$$KIND_INTRINSICS = 0x0E
$$KIND_STATE_INTRIN = 0x0F
'
$$KIND_STATEMENTS_INTRINSICS = 0x0F ' long name duplicate
'
$$KIND_TYPES = 0x10
$$KIND_STARTS = 0x11
$$KIND_SEPARATORS = 0x12
$$KIND_TERMINATORS = 0x13
$$KIND_LPARENS = 0x14
$$KIND_RPARENS = 0x15
$$KIND_BINARY_OPS = 0x16
$$KIND_UNARY_OPS = 0x17
$$KIND_ADDR_OPS = 0x18
$$KIND_COMMENTS = 0x19
$$KIND_CHARACTERS = 0x1A
$$KIND_WHITES = 0x1B
'
'
' ***** PRECEDENCE *****
'
$$PREC_NONE = 0
$$PREC_ORL = 1: $$PREC_LOR = 1
$$PREC_XORL = 1: $$PREC_LXOR = 1
$$PREC_ANDL = 2
$$PREC_EQ = 3: $$PREC_NNE = 3: $$PREC_EQL = 3
$$PREC_NE = 3: $$PREC_NEQ = 3
$$PREC_LT = 4: $$PREC_NGE = 4
$$PREC_LE = 4: $$PREC_NGT = 4
$$PREC_GE = 4: $$PREC_NLT = 4
$$PREC_GT = 4: $$PREC_NLE = 4
$$PREC_OR = 5: $$PREC_ORBIT = 5
$$PREC_XOR = 5: $$PREC_XORBIT = 5
$$PREC_AND = 6: $$PREC_ANDBIT = 6
$$PREC_SUBTRACT = 7
$$PREC_ADD = 7
$$PREC_MOD = 8
$$PREC_REMAINDER = 8
$$PREC_IDIV = 8
$$PREC_MUL = 8
$$PREC_DIV = 8
$$PREC_POWER = 9
$$PREC_RSHIFT = 10
$$PREC_LSHIFT = 10
$$PREC_DSHIFT = 10
$$PREC_USHIFT = 10
$$PREC_UNARY = 11
$$PREC_MINUS = 11
$$PREC_PLUS = 11
$$PREC_NOT = 11: $$PREC_NOTBIT = 11: $$PREC_TILDA = 11
$$PREC_TESTL = 11
$$PREC_NOTL = 11
$$PREC_ADDR_OP = 11
$$PREC_HANDLE_OP = 11
$$PREC_STORE_OP = 11
'
'
' ***** OPERATOR CONVERSION TABLE NUMBERS *****
'
$$COP0 = 0x00
$$COP1 = 0x10
$$COP2 = 0x20
$$COP3 = 0x30
$$COP4 = 0x40
$$COP5 = 0x50
$$COP6 = 0x60
$$COP7 = 0x70
$$COP8 = 0x80
$$COP9 = 0x90
$$COPA = 0xA0
$$COPB = 0xB0
'
$$R0 = 0: $$R8 = 8: $$R16 = 16: $$R24 = 24
$$R1 = 1: $$R9 = 9: $$R17 = 17: $$R25 = 25
$$R2 = 2: $$R10 = 10: $$R18 = 18: $$R26 = 26
$$R3 = 3: $$R11 = 11: $$R19 = 19: $$R27 = 27
$$R4 = 4: $$R12 = 12: $$R20 = 20: $$R28 = 28
$$R5 = 5: $$R13 = 13: $$R21 = 21: $$R29 = 29
$$R6 = 6: $$R14 = 14: $$R22 = 22: $$R30 = 30
$$R7 = 7: $$R15 = 15: $$R23 = 23: $$R31 = 31
'
$$RA0 = $$R10
$$RA1 = $$R12
$$IMM16 = 32
$$NEG16 = 33
$$LITNUM = 34
$$CONNUM = 35
'
$$TYPE_ALLO = 0xE0 ' allocation TYPE_MASK
$$TYPE_TYPE = 0x1F ' data type TYPE_MASK
$$TYPE_DECLARED = 0x80 ' for functions, go_labels, sub_labels
$$TYPE_DEFINED = 0x40 ' for functions, go_labels, sub_labels
$$TYPE_INPUT = 0x11
'
$$MASK_ALLO = 0xE00000
$$MASK_DECDEF = 0xC00000 ' declared | defined mask
$$MASK_DECLARED = 0x800000 ' declared in DECLARE, EXTERNAL, INTERNAL
$$MASK_DEFINED = 0x400000 ' defined in FUNCTION block
'
$$XFUNC = 0x01 ' Native function (see funcKind[])
$$SFUNC = 0x02 ' System function (see funcKind[])
$$CFUNC = 0x03 ' C function (see funcKind[])
'
' DECLARE FUNCTION STYLES
'
$$FUNC_DECLARE = 2
$$FUNC_INTERNAL = 1
$$FUNC_EXTERNAL = 0
'
$$ARGS0 = 0x00
$$ARGS1 = 0x20
$$ARGS2 = 0x40
$$ARGS3 = 0x60
$$ARGS4 = 0x80
'
$$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
$$outdisk = 2
$$errors = 3
$$infile = 4
$$termfile = 0
$$diskfile = 1
'
'
' i486 register equivalences
'
$$al = $$R2
$$dl = $$R3
$$bl = $$R4
$$cl = $$R5
$$ax = $$R6
$$dx = $$R7
$$bx = $$R8
$$cx = $$R9
$$eax = $$R10
$$edx = $$R11
$$ebx = $$R12
$$ecx = $$R13
$$esi = $$R26
$$edi = $$R27
$$ebp = $$R31
$$esp = $$R1
'
$$o0 = 0x0000
$$o1 = 0x0001
$$o2 = 0x0002
$$o3 = 0x0003
$$o4 = 0x0004
$$o5 = 0x0005
$$o6 = 0x0006
$$o7 = 0x0007
$$o8 = 0x0008
$$o9 = 0x0009
$$o10 = 0x000A
$$o11 = 0x000B
$$o12 = 0x000C
$$o13 = 0x000D
$$o14 = 0x000E
$$o15 = 0x000F
$$o16 = 0x0010
$$o17 = 0x0011
$$o18 = 0x0012
$$o19 = 0x0013
$$o20 = 0x0014
$$o21 = 0x0015
$$o22 = 0x0016
$$o23 = 0x0017
$$o24 = 0x0018
$$o25 = 0x0019
$$o26 = 0x001A
$$o27 = 0x001B
$$o28 = 0x001C
$$o29 = 0x001D
$$o30 = 0x001E
$$o31 = 0x001F
$$o32 = 0x0000
'
' 80486 machine instructions
'
$$nope = 0
$$adc = 1
$$add = 2
$$and = 3
$$bsf = 4
$$bsr = 5
$$bt = 6
$$btc = 7
$$btr = 8
$$bts = 9
$$call = 10
$$cbw = 11
$$cdq = 12
$$clc = 13
$$cld = 14
$$cmc = 15
$$cmp = 16
$$cmpsb = 17
$$cmpsw = 18
$$cmpsd = 19
$$cwd = 20
$$cwde = 21
$$dec = 22
$$div = 23
$$f2xm1 = 24
$$fabs = 25
$$fadd = 26
$$faddp = 27
$$fchs = 28
$$fclex = 29
$$fnclex = 30
$$fcom = 31
$$fcomp = 32
$$fcompp = 33
$$fcos = 34
$$fdecstp = 35
$$fdiv = 36
$$fdivp = 37
$$fdivr = 38
$$fdivrp = 39
$$fild = 40
$$fincstp = 41
$$fist = 42
$$fistp = 43
$$fld = 44
$$fldlg2 = 45
$$fldln2 = 46
$$fldl2e = 47
$$fldl2t = 48
$$fldpi = 49
$$fldz = 50
$$fld1 = 51
$$fmul = 52
$$fmulp = 53
$$fnop = 54
$$fpatan = 55
$$fprem = 56
$$fprem1 = 57
$$fptan = 58
$$frndint = 59
$$fscale = 60
$$fsin = 61
$$fsincos = 62
$$fsqrt = 63
$$fst = 64
$$fstp = 65
$$fstsw = 66
$$fnstsw = 67
$$fsub = 68
$$fsubp = 69
$$fsubr = 70
$$fsubrp = 71
$$ftst = 72
$$fucom = 73
$$fucomp = 74
$$fucompp = 75
$$fxam = 76
$$fxch = 77
$$fxtract = 78
$$fyl2x = 79
$$fyl2xp1 = 80
$$f2xn1 = 81
$$idiv = 82
$$imul = 83
$$inc = 84
$$int = 85
$$ja = 86
$$jae = 87
$$jbe = 88
$$jc = 89
$$jcxz = 90
$$jecxz = 91
$$je = 92
$$jg = 93
$$jge = 94
$$jl = 95
$$jle = 96
$$jna = 97
$$jnae = 98
$$jnb = 99
$$jnbe = 100
$$jnc = 101
$$jne = 102
$$jng = 103
$$jnge = 104
$$jnl = 105
$$jnle = 106
$$jno = 107
$$jnp = 108
$$jns = 109
$$jnz = 110
$$jo = 111
$$jp = 112
$$jpe = 113
$$jpo = 114
$$js = 115
$$jz = 116
$$jmp = 117
$$lahf = 118
$$ld = 119
$$lea = 120
$$lodsb = 121
$$lodsw = 122
$$lodsd = 123
$$loop = 124
$$loopz = 125
$$loopnz = 126
$$movsb = 127
$$movsw = 128
$$movsd = 129
$$mul = 130
$$neg = 131
$$nop = 132
$$not = 133
$$or = 134
$$pop = 135
$$popad = 136
$$popfd = 137
$$push = 138
$$pushad = 139
$$pushfd = 140
$$rcl = 141
$$rcr = 142
$$rol = 143
$$ror = 144
$$rep = 145
$$repz = 146
$$repnz = 147
$$ret = 148
$$sahf = 149
$$sal = 150
$$sar = 151
$$sll = 152
$$slr = 153
$$sbb = 154
$$scasb = 155
$$scasw = 156
$$scasd = 157
$$shld = 158
$$shrd = 159
$$st = 160
$$stc = 161
$$std = 162
$$stosb = 163
$$stosw = 164
$$stosd = 165
$$sub = 166
$$test = 167
$$xchg = 168
$$xor = 169
$$jb = 170
$$into = 171
$$mov = 172
$$movsx = 173
$$movzx = 174
$$zlast = 175
$$ufld = 0x002C0000 ' make = $$fld << 16
$$ufstp = 0x00410000 ' make = $$fstp << 16
$$uld = 0x00770000 ' make = $$ld << 16
$$ulda = 0x00780000 ' make = $$lda << 16
$$ust = 0x00A00000 ' make = $$st << 16
'
' 80486 addressing modes
'
$$none = 0
$$abs = 1
$$rel = 2
$$reg = 3
$$imm = 4
$$r0 = 5
$$ro = 6
$$rr = 7
$$rs = 8
$$regreg = 9
$$regimm = 10
$$regabs = 11
$$regr0 = 12
$$regro = 13
$$regrr = 14
$$regrs = 15
$$absreg = 16
$$r0reg = 17
$$roreg = 18
$$rrreg = 19
$$rsreg = 20
$$absimm = 21
$$r0imm = 22
$$roimm = 23
$$rrimm = 24
$$rsimm = 25
$$regimm8 = 26 ' special bogus addressing modes for
$$absimm8 = 27 ' bit-twiddling instructions in Code()
$$r0imm8 = 28
$$roimm8 = 29
$$rrimm8 = 30
$$rsimm8 = 31
'
'
' ####################
' ##### Xnt () ##### If running as the user program in the environment,
' #################### the entry function should start running the program.
'
FUNCTION Xnt ()
'
a$ = "Max Reason"
a$ = "copyright 1988-2000"
a$ = "Linux XBasic compiler"
a$ = "maxreason@maxreason.com"
a$ = ""
'
addr = &Xnt ()
IF ((addr > ##UCODE) AND (addr < ##UCODEZ)) THEN XxxXBasic ()
END FUNCTION
'
'
' ##########################
' ##### XxxXBasic () #####
' ##########################
'
FUNCTION XxxXBasic ()
EXTERNAL /xxx/ maxFuncNumber, errorCount, library, i486bin, i486asm
SHARED tab_sym_ptr, labelPtr
SHARED lastmax, lastlabmax
SHARED XERROR
'
' ***** Initialize everything, then start the compiler *****
'
oldLibrary = library
library = $$FALSE
i486bin = $$FALSE
i486asm = $$FALSE
XxxInitAll ()
InitOptions ()
library = oldLibrary
c = Compile ()
IFF c THEN
IF XERROR THEN PrintError (XERROR)
PRINT "***** ERRORS: "; errorCount
' PRINT "tab_sym_ptr = "; tab_sym_ptr
' PRINT "labelPtr = "; labelPtr
' PRINT "lastmax = "; lastmax
' PRINT "lastlabmax = "; lastlabmax
' PRINT "maxFuncNum = "; maxFuncNumber
END IF
RETURN (errorCount)
END FUNCTION
'
'
' #########################
' ##### AddLabel () #####
' #########################
'
' action = XGET (0): Get label token if label has been defined.
' XADD (1): Add label token if label not defined (else error).
' XNEW (2): Add label token if label not defined this program.
' (XNEW is for functions only at this time).
'
FUNCTION AddLabel (label$, token, action)
SHARED tab_lab[], tab_lab$[], labhash[], labaddr[]
SHARED XERROR, ERROR_COMPILER
SHARED labelPtr, ulabel, lastlabmax, pastSystemLabels
SHARED USHORT hx[]
'
IFZ label$ THEN PRINT "AddLabel(): Error: (label$ = empty string)" : RETURN
labelLength = LEN (label$)
labhash = 0
x = 0
DO
labhash = labhash + hx[label${x}]
INC x
LOOP WHILE (x < labelLength)
labhash = labhash AND 0x00FF
last = labhash[labhash, 0]
ulabhash = UBOUND(labhash[labhash, ])
IF (last >= ulabhash) THEN
ATTACH labhash[labhash, ] TO temp[]
ulabhash = ulabhash + (ulabhash >> 1) + 3
REDIM temp[ulabhash]
ATTACH temp[] TO labhash[labhash, ]
END IF
'
' there are labels with this hash in label symbol table
'
IF last THEN
found = $$FALSE
i = last
DO
check = labhash[labhash, i]
IF (action = $$XNEW) THEN
IF (check < pastSystemLabels) THEN EXIT DO
END IF
IF (labelLength = LEN (tab_lab$[check])) THEN
IF (tab_lab$[check] = label$) THEN found = $$TRUE: EXIT DO
END IF
DEC i
LOOP WHILE (i)
IF action THEN
IF found THEN
RETURN (tab_lab[check])
ELSE
INC last
labhash[labhash, 0] = last
labhash[labhash, last] = labelPtr
token = (token AND 0xFFFF0000) OR labelPtr
IF (labelPtr >= ulabel) THEN
' PRINT "ulabel increased from"; ulabel; " to"; ulabel + ulabel + 1
ulabel = ulabel + ulabel + 1
REDIM labaddr[ulabel]
REDIM tab_lab[ulabel]
REDIM tab_lab$[ulabel]
END IF
tab_lab[labelPtr] = token
tab_lab$[labelPtr] = label$
INC labelPtr
RETURN (token)
END IF
ELSE
IF found THEN RETURN (check) ELSE RETURN ($$FALSE)
END IF
ELSE
'
' there are no labels with this hash in label symbol table
'
IF action THEN
labhash[labhash, 0] = 1
labhash[labhash, 1] = labelPtr
token = (token AND 0xFFFF0000) OR labelPtr
IF (labelPtr >= ulabel) THEN
' PRINT "ulabel increased from"; ulabel; " to"; ulabel + ulabel + 1
ulabel = ulabel + ulabel
REDIM labaddr[ulabel]
REDIM tab_lab[ulabel]
REDIM tab_lab$[ulabel]
END IF
tab_lab[labelPtr] = token
tab_lab$[labelPtr] = label$
INC labelPtr
RETURN (token)
END IF
END IF
RETURN ($$FALSE)
'
eeeCompiler:
XERROR = ERROR_COMPILER
EXIT FUNCTION
END FUNCTION
'
'
' ##########################
' ##### AddSymbol () #####
' ##########################
'
FUNCTION AddSymbol (symbol$, tokoid, f_number)
EXTERNAL /xxx/ maxFuncNumber
EXTERNAL /xxx/ bogusFunction, freezeFlag, freezeFunction
SHARED hash%[]
SHARED funcSymbol$[], funcLabel$[], funcToken[]
SHARED funcScope[], funcType[], funcKind[], funcArgSize[], funcArg[]
SHARED defaultType[]
SHARED funcFrameSize[]
SHARED autoAddr[], autoxAddr[], inargAddr[]
SHARED compositeToken[], compositeNumber[]
SHARED compositeNext[], compositeStart[]
SHARED r_addr[], r_addr$[], m_reg[], m_addr[], m_addr$[]
SHARED tabType[], tab_sym$[], tab_sym[], tabArg[], tokens[]
SHARED typeSize[], typeSize$[], typeAlias[], typeAlign[]
SHARED typeSuffix$[], typeSymbol$[], typeToken[]
SHARED typeEleCount[], typeEleSymbol$[], typeEleToken[], typeEleAddr[]
SHARED typeEleSize[], typeEleType[], typeEleArg[]
SHARED typeEleVal[], typeElePtr[]
SHARED typeEleStringSize[], typeEleUBound[]
SHARED XERROR, ERROR_COMPILER
SHARED T_EXTERNAL, T_SHARED
SHARED T_FUNCTION, T_SFUNCTION, T_CFUNCTION
SHARED func_number, function_line
SHARED parse_got_function, got_function, hfn$
SHARED tab_sym_ptr, typePtr, uFunc, uType
SHARED lastmax, tokenPtr
SHARED USHORT hx[]
SHARED pass
'
' IFZ symbol$ THEN GOTO eeeCompiler
'
scope = 0
found = 0
token = tokoid
f_num = f_number
kind = token{$$KIND}
rtype = token{$$TYPE}
slength = LEN (symbol$)
spaces = token AND 0xE0000000
token = token AND 0x1FFF0000
k = tokens[1] AND 0x1FFFFFFF
'
' see if symbol has explicit scope prefix - # or ##
' see if first token on source line is a scope keyword
' see if first token on source line is a built-in data-type
' see if first token on source line is a user-defined data-type
'
kk = k{$$KIND}
typetoken = TypeToken(k)
scopetoken = ScopeToken(k)
IF typetoken THEN intypes = $$TRUE
IF (kk = $$KIND_TYPES) THEN intypes = $$TRUE
'
IF symbol$ THEN
IF (symbol${0} == '#') THEN
IF (symbol${1} == '#') THEN scope = $$EXTERNAL ELSE scope = $$SHARED
END IF
END IF
'
' catch scope mismatches during compilation
'
' IF scope THEN
' IF scopetoken THEN
' IF (scope != scopetoken) THEN PRINT "scope mismatch"
' END IF
' END IF
'
'
IF (k = T_SHARED) THEN inshared = $$TRUE
'
IF (k = T_EXTERNAL) THEN
kk = tokens[2] AND 0x1FFFFFFF
kkk = kk{$$KIND}
IF (kkk = $$KIND_WHITES) THEN kk = tokens[3] AND 0x1FFFFFFF
IF (kk != T_FUNCTION) THEN
IF (kk != T_SFUNCTION) THEN
IF (kk != T_CFUNCTION) THEN inshared = $$TRUE
END IF
END IF
END IF
'
SELECT CASE kind
CASE $$KIND_FUNCTIONS
GOTO add_function_symbol
CASE $$KIND_TYPES
GOTO add_type_symbol
CASE $$KIND_VARIABLES
IFZ got_function THEN
IFZ (parse_got_function OR inshared OR intypes OR scope) THEN
kind = $$KIND_SYMBOLS
token = (token AND 0xE0FFFFFF) + $$T_SYMBOLS
END IF
END IF
CASE $$KIND_ARRAYS
IFZ got_function THEN
IFZ (parse_got_function OR inshared OR intypes OR scope) THEN
kind = $$KIND_ARRAY_SYMBOLS
token = (token AND 0xE0FFFFFF) + $$T_ARRAY_SYMBOLS
END IF
END IF
END SELECT
GOTO add_normal_symbol
'
'
' ******************************
' ***** FUNCTION SYMBOLS *****
' ******************************
'
add_function_symbol:
FOR x = 0 TO maxFuncNumber
funcLength = LEN (funcSymbol$[x])
IF (slength = funcLength) THEN
IF (symbol$ = funcSymbol$[x]) THEN found = $$TRUE: EXIT FOR
END IF
NEXT x
'
IF found THEN
token = spaces OR funcToken[x]
ELSE
INC maxFuncNumber
IF (maxFuncNumber >= uFunc) THEN
uFunc = uFunc + 64
REDIM compositeNumber[uFunc]
REDIM compositeStart[uFunc, ]
REDIM compositeToken[uFunc, ]
REDIM compositeNext[uFunc, ]
REDIM funcFrameSize[uFunc]
REDIM defaultType[uFunc]
REDIM funcSymbol$[uFunc]
REDIM funcLabel$[uFunc]
REDIM inargAddr[uFunc]
REDIM autoxAddr[uFunc]
REDIM autoAddr[uFunc]
REDIM funcToken[uFunc]
REDIM funcScope[uFunc]
REDIM funcKind[uFunc]
REDIM funcType[uFunc]
REDIM funcArgSize[uFunc]
REDIM funcArg[uFunc, ]
REDIM hash%[uFunc, ]
END IF
DIM temp%[255, ]
ATTACH temp%[] TO hash%[maxFuncNumber, ] ' hash array for new function
token = token OR maxFuncNumber
funcSymbol$[maxFuncNumber] = symbol$
funcToken[maxFuncNumber] = token
token = spaces OR token
END IF
'
IF function_line THEN
parse_got_function = $$TRUE
checkNumber = token{$$NUMBER}
IF freezeFlag AND (checkNumber != freezeFunction) THEN
bogusFunction = $$TRUE
token = funcToken[freezeFunction]
ELSE
func_number = checkNumber
hfn$ = HEX$(func_number)
END IF
END IF
RETURN (token)
'
'
' **************************
' ***** TYPE SYMBOLS *****
' **************************
'
add_type_symbol:
' usymbol$ = UCASE$ (symbol$)
' FOR i = 1 TO typePtr
' IF (usymbol$ = typeSymbol$[i]) THEN GOTO eeeDupType
' NEXT i
'
IF (typePtr >= uType) THEN
uType = uType + 32
REDIM typeSize[uType]
REDIM typeSize$[uType]
REDIM typeAlias[uType]
REDIM typeAlign[uType]
REDIM typeToken[uType]
REDIM typeSuffix$[uType]
REDIM typeSymbol$[uType]
REDIM typeEleCount[uType]
REDIM typeEleSymbol$[uType,]
REDIM typeEleToken[uType,]
REDIM typeEleAddr[uType,]
REDIM typeEleSize[uType,]
REDIM typeEleType[uType,]
REDIM typeEleArg[uType,]
REDIM typeEleVal[uType,]
REDIM typeElePtr[uType,]
REDIM typeEleStringSize[uType,]
REDIM typeEleUBound[uType,]
END IF
typeToken = $$T_TYPES + typePtr
typeSymbol$[typePtr] = symbol$
typeToken[typePtr] = typeToken
INC typePtr
RETURN (spaces + typeToken)
'
'
' ****************************
' ***** NORMAL SYMBOLS *****
' ****************************
'
add_normal_symbol:
SELECT CASE kind
CASE $$KIND_SYMBOLS, $$KIND_ARRAY_SYMBOLS: f_num = 0
CASE $$KIND_LITERALS, $$KIND_SYSCONS, $$KIND_CHARCONS: f_num = 0
END SELECT
'
' 2000/12/30 - ??? maybe not necessary ???
'
IF scope THEN
token = token AND 0xFF1FFFFF
token = token OR (scope << 21)
END IF
'
hash = 0
FOR x = 0 TO slength - 1
hash = hash + hx[symbol${x}]
NEXT x
hash = hash AND 0x00FF
'
' no symbol with this hash yet ???
'
IFZ hash%[f_num, hash, ] THEN
DIM temp%[7]
temp%[0] = 1
temp%[1] = tab_sym_ptr
token = token OR tab_sym_ptr
tab_sym[tab_sym_ptr] = token
tabType[tab_sym_ptr] = rtype
tab_sym$[tab_sym_ptr] = symbol$
ATTACH temp%[] TO hash%[f_num, hash, ]
INC tab_sym_ptr
IF (tab_sym_ptr > UBOUND(tab_sym[])) THEN
uTab = tab_sym_ptr + (tab_sym_ptr >> 2) OR 7
' PRINT "uTab0: "; UBOUND(tab_sym[]); " -> "; uTab
REDIM r_addr[uTab]
REDIM r_addr$[uTab]
REDIM m_reg[uTab]
REDIM m_addr[uTab]
REDIM m_addr$[uTab]
REDIM tab_sym$[uTab]
REDIM tabType[uTab]
REDIM tab_sym[uTab]
REDIM tabArg[uTab, ]
END IF
RETURN (spaces OR token)
END IF
'
' already a symbol with this hash
'
ATTACH hash%[f_num, hash, ] TO temp%[]
uhash = UBOUND(temp%[])
last = temp%[0]
IF (last = uhash) THEN
uhash = uhash + 8
REDIM temp%[uhash]
END IF
'
' Look for object in symbol table
'
found = $$FALSE
FOR hash_ptr = 1 TO last
entry = temp%[hash_ptr]
checks = tab_sym[entry]
IF (kind != checks{$$KIND}) THEN DO NEXT
IF (slength = LEN(tab_sym$[entry])) THEN
IF (symbol$ = tab_sym$[entry]) THEN found = $$TRUE: EXIT FOR
END IF
NEXT hash_ptr
'
' if symbol was found, return its token, otherwise make a symbol table entry
'
IF found THEN
ATTACH temp%[] TO hash%[f_num, hash, ]
token = tab_sym[entry]
ELSE
temp%[0] = last + 1
temp%[hash_ptr] = tab_sym_ptr
ATTACH temp%[] TO hash%[f_num, hash, ]
token = token OR tab_sym_ptr
tabType[tab_sym_ptr] = rtype
tab_sym[tab_sym_ptr] = token
tab_sym$[tab_sym_ptr] = symbol$
INC tab_sym_ptr
IF (tab_sym_ptr > UBOUND(tab_sym[])) THEN
uTab = tab_sym_ptr + (tab_sym_ptr >> 2) OR 7
' PRINT "uTab1: "; UBOUND(tab_sym[]); " -> "; uTab
REDIM r_addr[uTab]
REDIM r_addr$[uTab]
REDIM m_reg[uTab]
REDIM m_addr[uTab]
REDIM m_addr$[uTab]
REDIM tab_sym$[uTab]
REDIM tabType[uTab]
REDIM tab_sym[uTab]
REDIM tabArg[uTab, ]
END IF
END IF
RETURN (spaces OR token)
'
eeeCompiler:
XERROR = ERROR_COMPILER
EXIT FUNCTION
END FUNCTION
'
'
' ##########################
' ##### AlloToken () #####
' ##########################
'
FUNCTION AlloToken (token)
SHARED T_AUTO, T_AUTOX, T_STATIC, T_SHARED, T_EXTERNAL
'
SELECT CASE token
CASE T_AUTO, T_AUTOX, T_STATIC, T_SHARED, T_EXTERNAL: RETURN (token)
END SELECT
RETURN (0)
END FUNCTION
'
'
' ################################
' ##### AssemblerSymbol () #####
' ################################
'
FUNCTION AssemblerSymbol (symbol$)
SHARED UBYTE charsetSymbolInner[]
'
IFZ symbol$ THEN GOTO eeeCompiler
offset = LEN(symbol$) - 1
charz = symbol${offset}
IF charsetSymbolInner[charz] THEN RETURN
IF (offset <= 0) THEN RETURN
DEC offset
chary = symbol${offset}
IF charsetSymbolInner[chary] THEN
SELECT CASE charz
CASE '@': symbol$ = RCLIP$(symbol$, 1) + "_SBYTE"
CASE '%': symbol$ = RCLIP$(symbol$, 1) + "_SSHORT"
CASE '&': symbol$ = RCLIP$(symbol$, 1) + "_SLONG"
CASE '~': symbol$ = RCLIP$(symbol$, 1) + "_XLONG"
CASE '!': symbol$ = RCLIP$(symbol$, 1) + "_SINGLE"
CASE '#': symbol$ = RCLIP$(symbol$, 1) + "_DOUBLE"
CASE ELSE: GOTO eeeCompiler
END SELECT
ELSE
SELECT CASE chary
CASE '@': symbol$ = RCLIP$(symbol$, 2) + "_UBYTE"
CASE '%': symbol$ = RCLIP$(symbol$, 2) + "_USHORT"
CASE '&': symbol$ = RCLIP$(symbol$, 2) + "_ULONG"
CASE '$': symbol$ = RCLIP$(symbol$, 2) + "_GIANT"
CASE ELSE: GOTO eeeCompiler
END SELECT
END IF
RETURN
'
eeeCompiler:
XERROR = ERROR_COMPILER
EXIT FUNCTION
END FUNCTION
'
'
' #############################
' ##### AssignAddress () #####
' #############################
'
FUNCTION AssignAddress (token)
EXTERNAL /xxx/ i486asm, i486bin, xpc, library
SHARED reg86$[], reg86c$[]
SHARED autoAddr[], autoxAddr[], inargAddr[]
SHARED xargNum, xargAddr[], xargName$[]
SHARED r_addr[], r_addr$[], m_reg[], m_addr[], m_addr$[]
SHARED tabType[], tab_sym[], tab_sym$[], labaddr[]
SHARED uType, typeAlias[], typeAlign[]
SHARED typeSize[], typeSize$[], typeSymbol$[], typeToken[]
SHARED XERROR, ERROR_BAD_CHARCON, ERROR_BAD_SYMBOL, ERROR_COMPILER
SHARED ERROR_DUP_DECLARATION, ERROR_DUP_DEFINITION, ERROR_SCOPE_MISMATCH
SHARED ERROR_TOO_MANY_ARGS, ERROR_TYPE_MISMATCH, ERROR_UNDEFINED
SHARED func_number, hfn$, sharename$, xframe$
SHARED section, externalAddr
SHARED programTypeChunk, functionTypeChunk
SHARED compositeNumber[], compositeToken[]
SHARED compositeStart[], compositeNext[]
SHARED UBYTE charsetSymbolInner[]
SHARED UBYTE charsetBackslash[]
STATIC GOADDR makeAddrKind[]
STATIC GOADDR makeAddrAllo[]
'
IFZ makeAddrKind[] THEN GOSUB InitArrays
d_allo = token{$$ALLO}
kind = token{$$KIND}
e = token{$$NUMBER}
d_type = tabType[e]
IFZ d_type THEN d_type = TheType (token)
'
' handle explicit #Shared and ##External scope
'
a = d_allo ' scope
stealtype = 0 ' # : ##
IF tab_sym$[e] THEN ' symbol$
IF (tab_sym$[e]{0} = '#') THEN ' # 1st byte
a = $$SHARED ' #SharedVariable
stealtype = $$TRUE '
IF (tab_sym$[e]{1} = '#') THEN a = $$EXTERNAL ' ##ExternalVariable
IF d_allo THEN ' e
