17 Bit Software 2: Collection B/17Bit_Collection_B.iso/files/2235.dms/in.adf/Cursor/Cursor.bas

BASIC Source File | 1990-04-16 | 130.7 KB | 4,233 lines

'
' Cursor V1.0 - A Basic-Compiler
' (c) 1990 by Jürgen Forster
'

 DEFINT a-z

' In Pass 1 werden alle Variablen gemerkt, Unterprogrammparameter
' festgestellt, wenn ein Fehler gefunden wird, wird abgebrochen
' In Pass 2 werden die Länge des Codes und die Labelwerte berechnet
' Pass 3 kann schließlich den fertigen Code ausgeben

' Z = Zeile, I = Int, L = Long, R = Real, D = Double, T = Text
' F = Feld von Feldelementen+deren Anzahl, P = Zeiger auf Feld-Info-Struktur
' kleingeschrieben: Zeiger darauf

' 0: einfache Variable
' 1: Monadischer Operator
' 2: Dyadischer Operator
' 3: Funktion

'Prioritäten
'  1: Funktion
'  2: Potenzierung
'  3: Negation
'  4: Multiplikation/Division
'  5: Ganzzahldivision
'  6: Modulo Arithmetik
'  7: Addition und Subtraktion
'  8: <=>
'  9: NOT
' 10: AND
' 11: OR
' 12: XOR
' 13: EQV
' 14: IMP

'************************************************************
'*                                                          *
'* Variablen/Konstanten-Definitionen                        *
'*                                                          *
'************************************************************

' Globale Vars
 DIM SHARED Ergebnis,Ergebnis$,SourceLine$,ErrorInThisLine
 DIM SHARED ThisLine,IsDebugUsed,FileName$,Pass,StringBase

 DIM SHARED MaxStrings
 MaxStrings = 1000
 DIM SHARED SString$(MaxStrings)
 DIM SHARED NumStrings
 NumStrings = -1

 DIM SHARED MaxWords
 MaxWords = 100
 DIM SHARED Word$(MaxWords),WordPos(MaxWords),WordVarFlags(MaxWords)
 DIM SHARED OperatorNum(MaxWords),IsVar(MaxWords)

 DIM SHARED VarTEXT,VarINT,VarLONG,VarREAL,VarDOUB,VarCONST
 VarTEXT = 1 : VarINT = 2 : VarLONG = 4 : VarREAL = 8 : VarDOUB = 16
 VarCONST = 128
 DIM SHARED VarTypeMask
 VarTypeMask = VarTEXT OR VarINT OR VarLONG OR VarREAL OR VarDOUB

 DIM SHARED MaxLabels,NumLabels
 MaxLabels = 2000
 DIM SHARED Label$(MaxLabels),LabelLine(MaxLabels),LabelOffset&(MaxLabels)
 NumLabels = -1

 DIM SHARED SubNumber,SubCounter
' SubNumber: Nummer des Unterprogramms (0 bedeutet SHARED, 1 Hauptprogramm)

' Defaulteinstellungen fuer Variable ohne Typ

 DIM SHARED CharLetter$,CharNumber$,CharTypes$
 CharLetter$ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 CharNumber$ = "0123456789"
 CharTypes$ = "$%&!#"

 DIM SHARED CharVarBegin$,CharVarMid$
 CharVarBegin$ = "abcdefghijklmnopqrstuvwxyz"+CharLetter$+CharNumber$+".&"
 CharVarMid$ =   "abcdefghijklmnopqrstuvwxyz"+CharLetter$+CharNumber$+"."

 DIM SHARED MaxLevel,MaxParameter
 MaxLevel = 30 : MaxParameter = 10
 DIM SHARED Von(MaxLevel),Bis(MaxLevel),NumPars(MaxLevel)
 DIM SHARED FoundOperator(MaxLevel),ReturnType(MaxLevel)
 DIM SHARED OldLevel(MaxLevel),ReadPointer(MaxLevel)
 DIM SHARED VarianteNum(MaxLevel)
 DIM SHARED ParType(MaxLevel,MaxParameter),CallLevel(MaxLevel,MaxParameter)

 DIM SHARED TRUE,FALSE
 TRUE = -1 : FALSE = 0

 DIM SHARED TypeWHILE,TypeIF,TypeFOR
 TypeWHILE = 1 : TypeIF = 2 : TypeFOR = 3

' Stack fuer FOR/WHILE/IF
 DIM SHARED MaxStack
 MaxStack = 100
 DIM SHARED StackLine(MaxStack),StackType(MaxStack),Stack$(MaxStack,2)
' Noch ist nichts auf dem Stack
 DIM SHARED StackPointer
 StackPointer = -1

' fuer READ/DATA
 DIM SHARED MaxData,NumData,NumDataPass2
 MaxData = 4000
 DIM SHARED DataStringOffset(MaxData),DataLine(MaxData)
' Noch keine Datas vorhanden
 NumData = -1 : NumDataPass2 = -1

' Variablen-Speicher
 DIM SHARED MaxVars,NumVars
 MaxVars = 2000
 DIM SHARED VarName$(MaxVars),VarFlags(MaxVars),VarType(MaxVars)
 DIM SHARED VarSubNum(MaxVars),VarOffset(MaxVars)
' Noch keine Variable gespeichert
 NumVars = -1

' Noch keine Uebersetzungsfehler
 DIM SHARED NumErrors
 NumErrors = 0

' Nummern zum erzeugen von Labels
 DIM SHARED LabelCounter

' Höchstanzahl an Subs
 DIM SHARED MaxSubs,MaxSubPars
 MaxSubs = 40 : MaxSubPars = 20
 DIM SHARED SubSize(MaxSubs,1)
' SubNummer von SubSize entspricht der von SubName$ und folgenden nicht!
 DIM SHARED SubName$(MaxSubs)
 DIM SHARED NumSubPars(MaxSubs)
 DIM SHARED SubParType(MaxSubs,MaxSubPars)
 DIM SHARED IsSubDef(MaxSubs)
 DIM SHARED ParPos(MaxSubPars)
 DIM SHARED NumSubs
 NumSubs = -1
' Labels für die SUB-Anweisung
 DIM SHARED LeaveSubLabel$,SkipSubLabel$

' Fuer die DEFTyp-Anweisung
 DIM SHARED CharVarType(ASC("Z")-ASC("A"))

' Position im Hunk / Größe des Hunks
 DIM SHARED HunkOffset&,HunkSize&

'************************************************************
'*                                                          *
'* Alle Schluesselwoerter einlesen                          *
'*                                                          *
'************************************************************

 DIM SHARED NumKeyWords
 READ NumKeyWords
 DIM SHARED KeyWord$(NumKeyWords)
 FOR a = 0 TO NumKeyWords
   READ KeyWord$(a)
 NEXT a

 DATA 199
 DATA "ABS","ALL","AND","APPEND","AREA","AREAFILL","AS","ASC","ATN","BASE","BEEP"
 DATA "BREAK","CALL","CDBL","CHAIN","CHDIR","CHR$","CINT","CIRCLE","CLEAR"
 DATA "CLNG","CLOSE","CLS","COLLISION","COLOR","COMMON","CONT","COS","CSNG"
 DATA "CSRLIN","CVD","CVI","CVL","CVS","DATA","DATE$","DECLARE","DEF"
 DATA "DEFDBL","DEFINT","DEFLNG","DEFSNG","DEFSTR","DELETE","DIM","EDIT"
 DATA "ELSE","ELSEIF","END","EOF","EQV","ERASE","ERL","ERR","ERROR","EXIT","EXP"
 DATA "FIELD","FILES","FIX","FN","FOR","FRE","FUNCTION","GET","GOSUB"
 DATA "GOTO","HEX$","IF","IMP","INKEY$","INPUT","INPUT$","INSTR","INT"
 DATA "KILL","LBOUND","LEFT$","LEN","LET","LIBRARY","LINE","LIST","LLIST"
 DATA "LOAD","LOC","LOCATE","LOF","LOG","LPOS","LPRINT","LSET","MENU"
 DATA "MERGE","MID$","MKD$","MKI$","MKL$","MKS$","MOD","MOUSE","NAME"
 DATA "NEW","NEXT","NOT","OBJECT.AX","OBJECT.AY","OBJECT.CLIP"
 DATA "OBJECT.CLOSE","OBJECT.HIT","OBJECT.OFF","OBJECT.ON","OBJECT.PLANES"
 DATA "OBJECT.PRIORITY","OBJECT.SHAPE","OBJECT.START","OBJECT.STOP"
 DATA "OBJECT.VX.OBJECT.VY","OBJECT.X","OBJEXT.Y","OCT$","OFF","ON","OPEN"
 DATA "OPTION","OR","OUTPUT","PAINT","PALETTE","PATTERN","PEEK","PEEKL"
 DATA "PEEKW","POINT","POKE","POKEL","POKEW","POS","PRESET","PRINT","PSET"
 DATA "PTAB","PUT","RANDOMIZE","READ","REM","RESET","RESTORE","RESUME","RETURN"
 DATA "RIGHT$","RND","RSET","RUN","SADD","SAVE","SAY","SCREEN","SCROLL"
 DATA "SGN","SHARED","SIN","SLEEP","SOUND","SPACE$","SPC","SQR","STATIC","STEP"
 DATA "STICK","STOP","STR$","STRIG","STRING$","SUB","SWAP","SYSTEM","TAB"
 DATA "TAN","THEN","TIME$","TIMER","TO","TRANSLATE$","TROFF","TRON"
 DATA "UBOUND","UCASE$","USING","USR","VAL","VARPTR","WAIT","WAVE"
 DATA "WEND","WHILE","WIDTH","WINDOW","WRITE","XOR"

'************************************************************
'*                                                          *
'* Definition aller System-Funktionen                       *
'*                                                          *
'************************************************************

 DIM SHARED NumFuncs
 READ NumFuncs
 DIM SHARED Func$(NumFuncs),FuncType(NumFuncs),FuncHierachie(NumFuncs)
 DIM SHARED NumVarianten(NumFuncs)
 DIM SHARED MaxVarianten
 MaxVarianten = 4
 DIM SHARED NumParameter(NumFuncs,MaxVarianten)
 DIM SHARED VariantenOffset(NumFuncs,MaxVarianten)
 DIM SHARED ResultType(NumFuncs,MaxVarianten)
 MaxParameter = 5
 DIM SHARED Possible(NumFuncs,MaxVarianten,MaxParameter)
 DIM SHARED MakeTo(NumFuncs,MaxVarianten,MaxParameter)
 FOR a = 0 TO NumFuncs
   READ Func$(a),FuncType(a),FuncHierachie(a),NumVarianten(a)
   FOR b = 0 TO NumVarianten(a)
     READ NumParameter(a,b)
     FOR c = 0 TO NumParameter(a,b)
       READ Possible(a,b,c),MakeTo(a,b,c)
     NEXT c
     READ VariantenOffset(a,b),ResultType(a,b)
   NEXT b
 NEXT a

 DATA 89

 DATA "*",2,4,3
 DATA 1, 2, 2, 2, 2,-1290, 4 :'MUL_II_L
 DATA 1, 6, 4, 6, 4,-1296, 4 :'MUL_LL_L
 DATA 1,14, 8,14, 8,-1302, 8 :'MUL_RR_R
 DATA 1,30,16,30,16,-1284,16 :'MUL_DD_D

 DATA "+",2,7,4
 DATA 1, 1, 1, 1, 1,-90, 1 :'ADD_TT_T
 DATA 1, 2, 2, 2, 2,-72, 2 :'ADD_II_I
 DATA 1, 6, 4, 6, 4,-78, 4 :'ADD_LL_L
 DATA 1,14, 8,14, 8,-84, 8 :'ADD_RR_R
 DATA 1,30,16,30,16,-66,16 :'ADD_DD_D

 DATA "++",1,3,3
 DATA 0, 2, 2,0, 2 :'NOTHING__
 DATA 0, 4, 4,0, 4 :'NOTHING__
 DATA 0, 8, 8,0, 8 :'NOTHING__
 DATA 0,16,16,0,16 :'NOTHING__

 DATA "-",2,7,3
 DATA 1, 2, 2, 2, 2,-2112, 2 :'SUB_II_I
 DATA 1, 6, 4, 6, 4,-2118, 4 :'SUB_LL_L
 DATA 1,14, 8,14, 8,-2124, 8 :'SUB_RR_R
 DATA 1,30,16,30,16,-2100,16 :'SUB_DD_D

 DATA "--",1,3,3
 DATA 0, 2, 2,-1320, 2 :'NEG_I_I
 DATA 0, 4, 4,-1326, 4 :'NEG_L_L
 DATA 0, 8, 8,-1332, 8 :'NEG_R_R
 DATA 0,16,16,-1314,16 :'NEG_D_D

 DATA "/",2,4,1
 DATA 1,14, 8,14, 8,-474, 8 :'DIV_RR_R
 DATA 1,30,16,30,16,-456,16 :'DIV_DD_D

 DATA "<",2,8,4
 DATA 1, 1, 1, 1, 1,-1164, 2 :'LT_TT_I
 DATA 1, 2, 2, 2, 2,-1146, 2 :'LT_II_I
 DATA 1, 6, 4, 6, 4,-1152, 2 :'LT_LL_I
 DATA 1,14, 8,14, 8,-1158, 2 :'LT_RR_R
 DATA 1,30,16,30,16,-1140, 2 :'LT_DD_D

 DATA "<=",2,8,4
 DATA 1, 1, 1, 1, 1,-1014, 2 :'LE_TT_I
 DATA 1, 2, 2, 2, 2,-996, 2 :'LE_II_I
 DATA 1, 6, 4, 6, 4,-1002, 2 :'LE_LL_I
 DATA 1,14, 8,14, 8,-1008, 2 :'LE_RR_R
 DATA 1,30,16,30,16,-990, 2 :'LE_DD_D

 DATA "<>",2,8,4
 DATA 1, 1, 1, 1, 1,-1386, 2 :'NE_TT_I
 DATA 1, 2, 2, 2, 2,-1368, 2 :'NE_II_I
 DATA 1, 6, 4, 6, 4,-1374, 2 :'NE_LL_I
 DATA 1,14, 8,14, 8,-1380, 2 :'NE_RR_R
 DATA 1,30,16,30,16,-1362, 2 :'NE_DD_D

 DATA "=",2,8,4
 DATA 1, 1, 1, 1, 1,-558, 2 :'EQ_TT_I
 DATA 1, 2, 2, 2, 2,-540, 2 :'EQ_II_I
 DATA 1, 6, 4, 6, 4,-546, 2 :'EQ_LL_I
 DATA 1,14, 8,14, 8,-552, 2 :'EQ_RR_R
 DATA 1,30,16,30,16,-534, 2 :'EQ_DD_D

 DATA "=>",2,8,4
 DATA 1, 1, 1, 1, 1,-822, 2 :'GE_TT_I
 DATA 1, 2, 2, 2, 2,-804, 2 :'GE_II_I
 DATA 1, 6, 4, 6, 4,-810, 2 :'GE_LL_I
 DATA 1,14, 8,14, 8,-816, 2 :'GE_RR_R
 DATA 1,30,16,30,16,-798, 2 :'GE_DD_D

 DATA ">",2,8,4
 DATA 1, 1, 1, 1, 1,-870, 2 :'GT_TT_I
 DATA 1, 2, 2, 2, 2,-852, 2 :'GT_II_I
 DATA 1, 6, 4, 6, 4,-858, 2 :'GT_LL_I
 DATA 1,14, 8,14, 8,-864, 2 :'GT_RR_R
 DATA 1,30,16,30,16,-846, 2 :'GT_DD_D

 DATA "ABS",3,1,3
 DATA 0, 2, 2,-48, 2 :'ABS_I_I
 DATA 0, 4, 4,-54, 4 :'ABS_L_L
 DATA 0, 8, 8,-60, 8 :'ABS_R_R
 DATA 0,16,16,-42,16 :'ABS_D_D

 DATA "AND",2,10,1
 DATA 1, 2, 2, 2, 2,-96, 2 :'AND_II_I
 DATA 1,30, 4,30, 4,-102, 4 :'AND_LL_L

 DATA "ASC",3,1,0
 DATA 0, 1, 1,-126, 2 :'ASC_T_I

 DATA "ATN",3,1,1
 DATA 0,14, 8,-138, 8 :'ATN_R_R
 DATA 0,16,16,-132,16 :'ATN_D_D

 DATA "CDBL",3,1,0
 DATA 0,30,16,0,16 :'NOTHING__

 DATA "CHR$",3,1,0
 DATA 0,30, 2,-186, 1 :'CHR_I_T

 DATA "CINT",3,1,0
 DATA 0,30, 2,0, 2 :'NOTHING__

 DATA "CLNG",3,1,0
 DATA 0,30, 4,0, 4 :'NOTHING__

 DATA "COLLISION",3,1,0
 DATA 0,30, 2,-258, 2 :'COLLISION_I_I

 DATA "COS",3,1,1
 DATA 0,14, 8,-354, 8 :'COS_R_R
 DATA 0,16,16,-348,16 :'COS_D_D

 DATA "CSNG",3,1,0
 DATA 0,30, 8,0, 8 :'NOTHING__

 DATA "CSRLIN",3,1,0
 DATA -1,-360, 2 :'CSRLIN__I

 DATA "CVD",3,1,0
 DATA 0, 1, 1,-366,16 :'CVD_T_D

 DATA "CVI",3,1,0
 DATA 0, 1, 1,-372, 2 :'CVI_T_I

 DATA "CVL",3,1,0
 DATA 0, 1, 1,-378, 4 :'CVL_T_L

 DATA "CVS",3,1,0
 DATA 0, 1, 1,-384, 8 :'CVL_T_R

 DATA "DATE$",3,1,0
 DATA -1,-390, 1 :'DATE__T

 DATA "EOF",3,1,0
 DATA 0,30, 2,-516, 2 :'EOF_I_I

 DATA "EQV",2,13,1
 DATA 1, 2, 2, 2, 2,-522, 2 :'EQV_II_I
 DATA 1,30, 4,30, 4,-528, 4 :'EQV_LL_L

 DATA "ERL",3,1,0
 DATA -1,-570, 2 :'ERL__I

 DATA "ERR",3,1,0
 DATA -1,-582, 2 :'ERR__I

 DATA "EXP",3,1,1
 DATA 0,14, 8,-594, 8 :'EXP_R_R
 DATA 0,16,16,-588,16 :'EXP_D_D

 DATA "FIX",3,1,3
 DATA 0, 2, 2,0, 2 :'NOTHING__
 DATA 0, 4, 4,0, 4 :'NOTHING__
 DATA 0, 8, 8,-672, 8 :'FIX_R_R
 DATA 0,16,16,-666,16 :'FIX_D_D

 DATA "FRE",3,1,0
 DATA 0,30, 2,-708, 4 :'FRE_I_L

 DATA "HEX$",3,1,0
 DATA 0,30, 4,-876, 1 :'HEX_L_T

 DATA "IF",3,1,4
 DATA 2,30, 2, 1, 1, 1, 1,-906, 1 :'IF_ITT_T
 DATA 2,30, 2, 2, 2, 2, 2,-888, 2 :'IF_III_I
 DATA 2,30, 2, 6, 4, 6, 4,-894, 4 :'IF_ILL_L
 DATA 2,30, 2,14, 8,14, 8,-900, 8 :'IF_IRR_R
 DATA 2,30, 2,30,16,30,16,-882,16 :'IF_IDD_D

 DATA "IMP",2,14,1
 DATA 1, 2, 2, 2, 2,-918, 2 :'IMP_II_I
 DATA 1,30, 4,30, 4,-924, 4 :'IMP_LL_L

 DATA "INKEY$",3,1,0
 DATA -1,-930, 1 :'INKEY__T

 DATA "INPUT$",3,1,0
 DATA 1,30, 2,30, 2,-936, 1 :'INPUT_II_T

 DATA "INSTR",3,1,1
 DATA 1, 1, 1, 1, 1,-954, 2 :'INSTR_TT_I
 DATA 2,30, 2, 1, 1, 1, 1,-948, 2 :'INSTR_ITT_I

 DATA "INT",3,1,3
 DATA 0, 2, 2,0, 2 :'NOTHING__
 DATA 0, 4, 4,0, 4 :'NOTHING__
 DATA 0, 8, 8,-966, 8 :'INT_R_R
 DATA 0,16,16,-960,16 :'INT_D_D

 DATA "LEFT$",3,1,0
 DATA 1, 1, 1,30, 2,-978, 1 :'LEFT_TI_T

 DATA "LEN",3,1,0
 DATA 0, 1, 1,-984, 2 :'LEN_T_I

 DATA "LOC",3,1,0
 DATA 0, 2, 2,-1068, 4 :'LOC_I_L

 DATA "LOF",3,1,0
 DATA 0, 2, 2,-1074, 4 :'LOF_I_L

 DATA "LOG",3,1,1
 DATA 0,14, 8,-1086, 8 :'LOG_R_R
 DATA 0,16,16,-1080,16 :'LOG_D_D

 DATA "LPOS",3,1,0
 DATA 0,30, 2,-1092, 2 :'LPOS_I_I

 DATA "MENU",3,1,0
 DATA 0,30, 2,-1206, 2 :'MENU_I_I

 DATA "MID$",3,1,1
 DATA 2, 1, 1,30, 2,30, 2,-1212, 1 :'MID_TII_T
 DATA 1, 1, 1,30, 2,-1218, 1 :'MID_TI_T

 DATA "MKD$",3,1,0
 DATA 0,30,16,-1224, 1 :'MKD_D_T

 DATA "MKI$",3,1,0
 DATA 0,30, 2,-1230, 1 :'MKI_I_T

 DATA "MKL$",3,1,0
 DATA 0,30, 4,-1236, 1 :'MKL_L_T

 DATA "MKS$",3,1,0
 DATA 0,30, 8,-1242, 1 :'MKS_R_T

 DATA "MOD",2,6,1
 DATA 1, 2, 2, 2, 2,-1248, 2 :'MOD_II_I
 DATA 1,30, 4,30, 4,-1254, 4 :'MOD_LL_L

 DATA "MOUSE",3,1,0
 DATA 0,30, 2,-1278, 2 :'MOUSE_I_I

 DATA "NOT",1,9,1
 DATA 0, 2, 2,-1392, 2 :'NOT_I_I
 DATA 0,30, 4,-1398, 4 :'NOT_L_L

 DATA "OBJECT.VX",3,1,0
 DATA 0,30, 2,-1530, 2 :'OBJECT.VX_I_I

 DATA "OBJECT.VY",3,1,0
 DATA 0,30, 2,-1542, 2 :'OBJECT.VY_I_I

 DATA "OBJECT.X",3,1,0
 DATA 0,30, 2,"OBJECT.X", 2

 DATA "OBJECT.Y",3,1,0
 DATA 0,30, 2,"OBJECT.Y", 2

 DATA "OCT$",3,1,0
 DATA 0,30, 4,-1560, 1 :'OCT_L_T

 DATA "OR",2,11,1
 DATA 1, 2, 2, 2, 2,-1638, 2 :'OR_II_I
 DATA 1,30, 4,30, 4,-1644, 4 :'OR_LL_L

 DATA "PEEK",3,1,0
 DATA 0,30, 4,-1686, 2 :'PEEK_L_I

 DATA "PEEKL",3,1,0
 DATA 0,30, 4,-1674, 4 :'PEEKL_L_L

 DATA "PEEKW",3,1,0
 DATA 0,30, 4,-1680, 2 :'PEEKW_L_I

 DATA "POINT",3,1,0
 DATA 1,30, 2,30, 2,-1692, 2 :'POINT_II_I

 DATA "POS",3,1,0
 DATA 0,30, 2,-1716, 2 :'POS_I_I

 DATA "RIGHT$",3,1,0
 DATA 1, 1, 1,30, 2,-1854, 1 :'RIGHT_TI_T

 DATA "RND",3,1,1
 DATA 0, 2, 2,-1860, 8 :'RND_I_R
 DATA -1,-1866,8 :'RND__R

 DATA "SADD",3,1,0
 DATA 0, 1, 1,-1884, 4 :'SADD_T_L

 DATA "SGN",3,1,3
 DATA 0, 2, 2,-1974, 2 :'SGN_I_I
 DATA 0, 4, 4,-1980, 2 :'SGN_L_I
 DATA 0, 8, 8,-1986, 2 :'SGN_R_I
 DATA 0,16,16,-1968, 2 :'SGN_D_I

 DATA "SIN",3,1,1
 DATA 0,14, 8,-1998, 8 :'SIN_R_R
 DATA 0,16,16,-1992,16 :'SIN_D_D

 DATA "SPACE$",3,1,0
 DATA 0,30, 2,-2028, 1 :'SPACE_I_T

 DATA "SQR",3,1,1
 DATA 0,14, 8,-2046, 8 :'SQR_R_R
 DATA 0,16,16,-2034,16 :'SQR_D_D

 DATA "STICK",3,1,0
 DATA 0,30, 2,-2052, 2 :'STICK_I_I

 DATA "STR$",3,1,3
 DATA 0, 2, 2,-2082, 1 :'STR_I_T
 DATA 0, 4, 4,-2088, 1 :'STR_L_T
 DATA 0, 8, 8,-2094, 1 :'STR_R_T
 DATA 0,16,16,-2076, 1 :'STR_D_T

 DATA "STRIG",3,1,0
 DATA 0,30, 2,-2058, 2 :'STRIG_I_I

 DATA "STRING$",3,1,1
 DATA 1,30, 2,30, 2,-2064, 1 :'STRING_II_T
 DATA 1,30, 2, 1, 1,-2070, 1 :'STRING_IT_T

 DATA "TAN",3,1,1
 DATA 0,14, 8,-2172, 8 :'TAN_R_R
 DATA 0,16,16,-2166,16 :'TAN_D_D

 DATA "TIME$",3,1,0
 DATA -1,-2202, 1 :'TIME__T

 DATA "TIMER",3,1,0
 DATA -1,-2196, 4 :'TIMER__L

 DATA "TRANSLATE$",3,1,0
 DATA 0, 1, 1,-2208, 1 :'TRANSLATE_T_T

 DATA "UCASE$",3,1,0
 DATA 0, 1, 1,-2226, 1 :'UCASE_T_T

 DATA "VAL",3,1,0
 DATA 0, 1, 1,-2232,16 :'VAL_T_D

 DATA "WINDOW",3,1,0
 DATA 0,30, 2,-2256, 4 :'WINDOW_I_L

 DATA "XOR",2,12,1
 DATA 1, 2, 2, 2, 2,-2262, 2 :'XOR_II_I
 DATA 1,30, 4,30, 4,-2268, 4 :'XOR_LL_L

 DATA "\",2,5,1
 DATA 1, 2, 2, 2, 2,-462, 2 :'DIV_II_I
 DATA 1,30, 4,30, 4,-468, 4 :'DIV_LL_L

 DATA "^",2,2,1
 DATA 1,14, 8,14, 8,-1728, 8 :'POT_RR_R
 DATA 1,30,16,30,16,-1722,16 :'POT_DD_D

'************************************************************
'*                                                          *
'* Konvertierungstabelle                                    *
'*                                                          *
'************************************************************

 DIM SHARED NumConv
 READ NumConv
 DIM SHARED CConvFrom(NumConv),CConvTo(NumConv),CConvOffset(NumConv)
 FOR a = 0 TO NumConv
   READ CConvFrom(a),CConvTo(a),CConvOffset(a)
 NEXT a

 DATA 11
 DATA  2, 4,-300 :'CONVERT_I_L
 DATA  2, 8,-306 :'CONVERT_I_R
 DATA  2,16,-294 :'CONVERT_I_D
 DATA  4, 2,-318 :'CONVERT_L_I
 DATA  4, 8,-324 :'CONVERT_L_R
 DATA  4,16,-312 :'CONVERT_L_D
 DATA  8, 2,-336 :'CONVERT_R_I
 DATA  8, 4,-342 :'CONVERT_R_L
 DATA  8,16,-330 :'CONVERT_R_D
 DATA 16, 2,-276 :'CONVERT_D_I
 DATA 16, 4,-282 :'CONVERT_D_L
 DATA 16, 8,-288 :'CONVERT_D_R

'************************************************************
'*                                                          *
'* Parametereingaben                                        *
'*                                                          *
'************************************************************

 PRINT "Cursor V1.0 - A Basic-Compiler"
 PRINT "(c) 1990 by Jürgen Forster"
 PRINT

 PRINT "Write linenumbers into executable (Y/N)? ";
 a$ = ""
 WHILE INSTR("YN",a$) = 0 OR a$ = ""
   a$ = UCASE$(INKEY$)
 WEND
 IsDebugUsed = a$ = "Y"
 PRINT a$

 PRINT "Filename (without '.bas')? ";
 LINE INPUT FileName$

'***********************************************************
'*                                                          *
'* Hauptprogramm, ruft alles auf                            *
'*                                                          *
'************************************************************

' Anfangszeit nehmen
 BeginTime& = TIMER

' Nur Eingabefile öffnen, 1. Pass
 Pass = 1
 OPEN (FileName$+".bas") FOR INPUT AS 1
 GOSUB GoThroughPass
 CLOSE 1

' Stack ueberpruefen
 CALL TestStack (-1)

' Label ueberpruefen
 FOR a = 0 TO NumLabels
   IF LabelLine(a) = FALSE THEN
     IF INSTR(Label$(a),"_") = 0 THEN
       PRINT : PRINT "Undefined label: "+Label$(a)
       NumErrors = NumErrors+1
     END IF
   END IF
 NEXT a

' Variablenoffsets berechnen
 GOSUB CalcVarOffsets

' fehlt ein END SUB?
 IF SubNumber <> 1 THEN CALL SomeError ("END SUB missing",-1)

' Ist ein Fehler aufgetreten? Wenn ja, abbrechen
 IF NumErrors <> 0 THEN
   PRINT : PRINT "Found";NumErrors;" error(s) in pass 1 - aborting!"
   CALL EndPrg
 END IF

' Nur Eingabefile öffnen, 2. Pass
 Pass = 2
 OPEN (FileName$+".bas") FOR INPUT AS 1
 GOSUB WriteHeader
 GOSUB GoThroughPass
 CLOSE 1
 IF (HunkOffset& AND 2) = 0 THEN
   HunkSize& = HunkOffset&
 ELSE
   HunkSize& = HunkOffset&+2
 END IF

' Ist ein Fehler aufgetreten? Wenn ja, abbrechen
 IF NumErrors <> 0 THEN
   PRINT : PRINT "Found";NumErrors;" error(s) in pass 2 - aborting!"
   CALL EndPrg
 END IF

' Aus- und Eingabe öffnen, 3. Pass
 Pass = 3
 OPEN (FileName$+".bas") FOR INPUT AS 1
 OPEN (FileName$) FOR OUTPUT AS 2
 OPEN ("T:Reloc32") FOR OUTPUT AS 3
 GOSUB WriteHeader
 GOSUB GoThroughPass
 GOSUB WriteEnd
 CLOSE 3
 CLOSE 2
 CLOSE 1

' temporäres File löschen
 KILL "T:Reloc32"

' Zeitdauer ausgeben
 PRINT : PRINT "Finished:";TIMER-BeginTime&;" s."

' Fertig!
 CALL EndPrg

'************************************************************
'*                                                          *
'* Den Anfang des Object-Files schreiben                    *
'*                                                          *
'************************************************************

WriteHeader:

' Hunkheader
 HunkOffset& = 0
 CALL PrintToFile MKL$(1011)
 CALL PrintToFile MKL$(0)
 CALL PrintToFile MKL$(1)
 CALL PrintToFile MKL$(0)
 CALL PrintToFile MKL$(0)
 CALL PrintToFile MKL$(HunkSize&\4)
 CALL PrintToFile MKL$(1001)
 CALL PrintToFile MKL$(HunkSize&\4)
 HunkOffset& = 0

Header1:
 DATA 40,0,42,8,44,120,0,4,118,0,38,110,1,20,74,171,0,172,102,18
 DATA 65,235,0,92,78,174,254,128,65,235,0,92,78,174,254,140,38,0
 DATA 67,250,0,50,78,174,254,104,74,128,102,2,78,117,44,64,69,250
 DATA 0,54
 DATA -1

Header2:
 DATA 34,78,44,120,0,4,78,174,254,98,74,131,103,10,78,174,255,124
 DATA 34,67,78,174,254,134,32,7,78,117
 DATA -1

 RESTORE Header1
 READ a
 WHILE a <> -1
   CALL PrintToFile CHR$(a)
   READ a
 WEND
 CALL CallLib (-30)'INIT__
 CALL SubSetLabel ("_EndPrg")
 RESTORE Header2
 READ a
 WHILE a <> -1
   CALL PrintToFile CHR$(a)
   READ a
 WEND
 CALL PrintToFile "bas_runtime.library"
 CALL PrintToFile CHR$(0)

' Startup-Struktur ausgeben
 CALL PrintToFile MKI$(0)              ' ST_Flags
 CALL PrintToFile MKI$(44)             ' ST_Size
 CALL PrintToFile MKI$(SubSize(0,0))   ' ST_GlobalStringsSize
 CALL PrintToFile MKI$(SubSize(0,1))   ' ST_GlobalVarsSize
 CALL PrintToFile MKI$(NumStrings*4+4) ' ST_GlobalConstStringsSize
 CALL SubDumpOnlyLabel "_ConstStrings" ' ST_ConstStringsPointer
 CALL SubDumpOnlyLabel "_DataStart"    ' ST_DataPointer
 CALL PrintToFile MKI$(NumData)        ' ST_NumData
 CALL PrintToFile MKL$(200000&)        ' ST_StringsMemSize
 CALL PrintToFile MKL$(4000)           ' ST_StackMemSize
 CALL SubDumpOnlyLabel "_EndPrg"       ' ST_EndPrg
 CALL SubDumpOnlyLabel "_Start"

' konstante Strings ausgeben
 CALL SubSetLabel "_ConstStrings"
 FOR a = 0 TO NumStrings
   CALL PrintToFile MKI$(LEN(SString$(a)))
   CALL PrintToFile SString$(a)
   IF LEN(SString$(a)) AND 1 THEN
     CALL PrintToFile CHR$(0)
   ELSE
     CALL PrintToFile MKI$(0)
   END IF
 NEXT a

' DATAs ausgeben
 CALL SubSetLabel "_DataStart"
 FOR a = 0 TO NumData
   CALL PrintToFile MKI$(DataStringOffset(a))
 NEXT a

' Einsprungadresse
 CALL SubSetLabel "_Start"

 RETURN

'************************************************************
'*                                                          *
'* Das Ende des Object-Files schreiben                      *
'*                                                          *
'************************************************************

WriteEnd:
 IF HunkOffset& <> HunkSize& THEN CALL PrintToFile MKI$(0)
 CLOSE 3
 CALL PrintToFile MKL$(1004)
 OPEN ("T:Reloc32") FOR INPUT AS #3
 CALL PrintToFile MKL$(LOF(3)\4)
 CALL PrintToFile MKL$(0)
 WHILE NOT EOF(3)
   CALL PrintToFile INPUT$(4,3)
 WEND
 CALL PrintToFile MKL$(0)
 CALL PrintToFile MKL$(1010)
 RETURN

'************************************************************
'*                                                          *
'* Variablenadressen berechnen                              *
'*                                                          *
'************************************************************

CalcVarOffsets:
' Size löschen
 FOR a = 0 TO MaxSubs
   SubSize(a,0) = 0
   SubSize(a,1) = 0
 NEXT a

' Größen berechnen
 FOR a = 0 TO NumVars
   IF VarType(a) >= 0 THEN
     SubSize(VarSubNum(a),1) = SubSize(VarSubNum(a),1)+24+VarType(a)*2
     VarOffset(a) = 0-SubSize(VarSubNum(a),1)
   ELSE
     IF VarFlags(a) = VarTEXT THEN
       SubSize(VarSubNum(a),0) = SubSize(VarSubNum(a),0)+4
       VarOffset(a) = 0-SubSize(VarSubNum(a),0)
     ELSEIF VarFlags(a) = VarINT THEN
       SubSize(VarSubNum(a),1) = SubSize(VarSubNum(a),1)+2
       VarOffset(a) = 0-SubSize(VarSubNum(a),1)
     ELSEIF VarFlags(a) = VarLONG THEN
       SubSize(VarSubNum(a),1) = SubSize(VarSubNum(a),1)+4
       VarOffset(a) = 0-SubSize(VarSubNum(a),1)
     ELSEIF VarFlags(a) = VarREAL THEN
       SubSize(VarSubNum(a),1) = SubSize(VarSubNum(a),1)+4
       VarOffset(a) = 0-SubSize(VarSubNum(a),1)
     ELSEIF VarFlags(a) = VarDOUB THEN
       SubSize(VarSubNum(a),1) = SubSize(VarSubNum(a),1)+8
       VarOffset(a) = 0-SubSize(VarSubNum(a),1)
     END IF
   END IF
 NEXT a

' Wirkliche Adressen berechnen
 FOR a = 0 TO NumVars
   IF VarType(a) >= 0 OR VarFlags(a) <> VarTEXT THEN
     VarOffset(a) = VarOffset(a)-SubSize(VarSubNum(a),0)
   END IF
 NEXT a

 StringBase = SubSize(0,0)+SubSize(0,1)

 RETURN

'************************************************************
'*                                                          *
'* Einen Pass ganz durchgehen                               *
'*                                                          *
'************************************************************

GoThroughPass:
 PRINT

' Label-Zähler auf Null setzen
 LabelCounter = 0

' Zu Anfang sind wir im Hauptprogramm
 SubNumber = 1

' Zähler für Unterprogramme (1. hat die Nummer 2)
 SubCounter = 1

' Zeilennummer setzen
 ThisLine = 0

' Defaulteinstellung setzen
 FOR a = 0 TO ASC("Z")-ASC("A")
   CharVarType(a) = VarREAL
 NEXT a

' Stack fuer lokale Variable des Hauptprogramms reservieren
 IF Pass > 1 THEN
   CALL SubIntToString (SubSize(1,0))
   CALL SubDumpVar (Ergebnis$,VarINT+VarCONST,-1)
   CALL SubIntToString (SubSize(1,1))
   CALL SubDumpVar (Ergebnis$,VarINT+VarCONST,-1)
   CALL CallLib (-2106)'SUB_II_
 END IF

' Schleife ueber das ganze File
 WHILE EOF(1) = 0

' Ausgabe auf den Bildschirm
   LINE INPUT #1,SourceLine$
   ThisLine = ThisLine+1
   PRINT "Pass";Pass;":";ThisLine;CHR$(13);

' gesamte Zeile 'aufsplitten'
   ErrorInThisLine = FALSE
   FirstWord = 0
   LastWord = -1
   EndOfSourceLinePointer = 1
   LinePointer = 1
   WHILE LinePointer <= LEN(SourceLine$) AND ErrorInThisLine = FALSE
     a$ = MID$(SourceLine$,LinePointer,1)
     IF a$ = " " OR a$ = CHR$(9) THEN
       GOSUB SkipSpaces
     ELSEIF a$ = "'" THEN
       LinePointer = LEN(SourceLine$)+1
     ELSEIF INSTR("+-*/\^(),;:#%$!",a$) THEN
       LastWord = LastWord+1
       Word$(LastWord) = a$
       WordPos(LastWord) = EndOfSourceLinePointer
       IsVar(LastWord) = FALSE
       CALL GetOperatorNum (a$)
       OperatorNum(LastWord) = Ergebnis
       EndOfSourceLinePointer = EndOfSourceLinePointer+1
       LinePointer = LinePointer+1
     ELSEIF INSTR(CharVarBegin$,a$) THEN
       LastWord = LastWord+1
       WordPos(LastWord) = EndOfSourceLinePointer
       a = 1
       WHILE a+LinePointer <= LEN(SourceLine$) AND INSTR(CharVarMid$,MID$(SourceLine$,a+LinePointer,1))
         a = a+1
       WEND
       Word$(LastWord) = UCASE$(MID$(SourceLine$,LinePointer,a))
       CALL IsKeyWord (Word$(LastWord))
       IF Ergebnis = FALSE THEN
         IF a+LinePointer <= LEN(SourceLine$) AND INSTR(CharTypes$,MID$(SourceLine$,a+LinePointer,1)) <> 0 THEN
           a = a+1
         END IF
         Word$(LastWord) = UCASE$(MID$(SourceLine$,LinePointer,a))
         CALL IsKeyWord (Word$(LastWord))
       ELSE
         IF a+LinePointer <= LEN(SourceLine$) AND INSTR(CharTypes$,MID$(SourceLine$,a+LinePointer,1)) <> 0 THEN
           try$ = UCASE$(MID$(SourceLine$,LinePointer,a+1))
           CALL IsKeyWord (try$)
           IF Ergebnis = TRUE THEN
             Word$(LastWord) = try$
             a = a+1
           ELSE
             Ergebnis = TRUE
           END IF
         END IF
       END IF
       IF Ergebnis THEN
         IsVar(LastWord) = FALSE
       ELSE
         CALL GetVarFlags (Word$(LastWord))
         WordVarFlags(LastWord) = Ergebnis
         IsVar(LastWord) = TRUE
       END IF
       CALL GetOperatorNum (Word$(LastWord))
       OperatorNum(LastWord) = Ergebnis
       EndOfSourceLinePointer = EndOfSourceLinePointer+a
       LinePointer = LinePointer+a
       IF Word$(LastWord) = "REM" THEN
         LastWord = LastWord-1
         LinePointer = LEN(SourceLine$)+1
       ELSEIF Word$(LastWord) = "DATA" THEN
         GOSUB SkipSpaces
         AddData = TRUE
         WHILE AddData
           IF LinePointer <= LEN(SourceLine$) THEN
             IF MID$(SourceLine$,LinePointer,1) = CHR$(34) THEN
               EndOfSourceLinePointer = EndOfSourceLinePointer+1
               LinePointer = LinePointer+1
               Abort$ = CHR$(34) : GOSUB AddStringTillAbort
               IF LinePointer <= LEN(SourceLine$) THEN
                 EndOfSourceLinePointer = EndOfSourceLinePointer+1
                 LinePointer = LinePointer+1
               END IF
             ELSE
               Abort$ = ",:" : GOSUB AddStringTillAbort
               WHILE LEFT$(Add$,1) = " "
                 Add$ = RIGHT$(Add$,LEN(Add$)-1)
               WEND
               WHILE RIGHT$(Add$,1) = " "
                 Add$ = LEFT$(Add$,LEN(Add$)-1)
               WEND
             END IF
             CALL AddData (Add$)
             GOSUB SkipSpaces
             IF LinePointer <= LEN(SourceLine$) THEN
               IF MID$(SourceLine$,LinePointer,1) = ":" THEN
                 AddData = FALSE
               ELSEIF MID$(SourceLine$,LinePointer,1) = "," THEN
                 EndOfSourceLinePointer = EndOfSourceLinePointer+1
                 LinePointer = LinePointer+1
                 GOSUB SkipSpaces
               ELSE
                 CALL SomeError ("syntaxerror after DATA-command",EndOfSourceLinePointer)
                 LinePointer = LEN(SourceLine$)+1
                 AddData = FALSE
               END IF
             ELSE
               AddData = FALSE
             END IF
           ELSE
             CALL AddData ("")
             AddData = FALSE
           END IF
         WEND
       END IF
     ELSEIF a$ = CHR$(34) THEN
       LastWord = LastWord+1
       WordPos(LastWord) = EndOfSourceLinePointer
       IsVar(LastWord) = TRUE
       OperatorNum(LastWord) = -1
       WordVarFlags(LastWord) = VarTEXT OR VarCONST
       EndOfSourceLinePointer = EndOfSourceLinePointer+1
       LinePointer = LinePointer+1
       Abort$ = CHR$(34) : GOSUB AddStringTillAbort
       Word$(LastWord) = CHR$(34)+Add$
       IF LinePointer <= LEN(SourceLine$) THEN
         EndOfSourceLinePointer = EndOfSourceLinePointer+1
         LinePointer = LinePointer+1
       END IF
     ELSEIF INSTR("<>=",a$) THEN
       LastWord = LastWord+1
       Word$(LastWord) = ""
       WordPos(LastWord) = EndOfSourceLinePointer
       IsVar(LastWord) = FALSE
       LessUsed = FALSE : EquUsed = FALSE : MoreUsed = FALSE
       a = 0
       WHILE a+LinePointer <= LEN(SourceLine$) AND INSTR("<=>",MID$(SourceLine$,a+LinePointer,1)) <> 0
         IF MID$(SourceLine$,a+LinePointer,1) = "<" THEN
           LessUsed = TRUE
         ELSEIF MID$(SourceLine$,a+LinePointer,1) = "=" THEN
           EquUsed = TRUE
         ELSE
           MoreUsed = TRUE
         END IF
         a = a+1
       WEND
       IF LessUsed THEN Word$(LastWord) = Word$(LastWord)+"<"
       IF EquUsed THEN  Word$(LastWord) = Word$(LastWord)+"="
       IF MoreUsed THEN Word$(LastWord) = Word$(LastWord)+">"
       IF Word$(LastWord) = "<=>" THEN
         CALL SomeError ("'<=>' is nonsense",EndOfSourceLinePointer) : LinePointer = LEN(SourceLine$)+1
       ELSE
         CALL GetOperatorNum (Word$(LastWord))
         OperatorNum(LastWord) = Ergebnis
         EndOfSourceLinePointer = EndOfSourceLinePointer+a
         LinePointer = LinePointer+a
       END IF
     ELSE
       CALL SomeError ("Syntax error",EndOfSourceLinePointer)
       LinePointer = LEN(SourceLine$)+1
     END IF
     IF LastWord+10 >= MaxWords THEN
       CALL SomeError ("Line too long",EnfOfSourceLinePointer)
       LinePointer = LEN(SourceLine$)+1
     END IF
   WEND
   WordPos(LastWord+1) = EndOfSourceLinePointer

' Ist eine Zeile durch eine Zahl definiert?
   IF ErrorInThisLine = FALSE THEN
     IF FirstWord <= LastWord THEN
       IF IsVar(FirstWord) THEN
         IF WordVarFlags(FirstWord) AND VarCONST THEN
           CALL CouldThisBeALabel (FirstWord)
           IF Ergebnis THEN
             CALL SubSetLabel (Word$(FirstWord))
             FirstWord = FirstWord+1
           END IF
         END IF
       END IF
     END IF
   END IF

' Ist eine Zeile alphanumerisch deklariert?
   IF ErrorInThisLine = FALSE THEN
     IF FirstWord < LastWord THEN
       IF IsVar(FirstWord) = TRUE AND (WordVarFlags(FirstWord) AND VarCONST)= FALSE AND Word$(FirstWord+1) = ":" THEN
         CALL CouldThisBeALabel (FirstWord)
         IF Ergebnis THEN
           CALL SubSetLabel (Word$(FirstWord))
           FirstWord = FirstWord+2
         END IF
       END IF
     END IF
   END IF

' Zeilennummern ggf. in File einfgen
   IF IsDebugUsed THEN
     CALL SubDumpVar (STR$(ThisLine),VarLONG+VarCONST,-1)
     CALL CallLib (-1920)'SETLINE_L_
   END IF

' Soviele END IFs muessen ergänzt werden
   IfsToClose = 0

' IF ... THEN oder ELSEIF ... THEN behandeln
   WHILE FirstWord <= LastWord AND ErrorInThisLine = FALSE
     IF Word$(FirstWord) = "IF" OR Word$(FirstWord) = "ELSEIF" THEN
       LastCommWord = FirstWord
       CContSearch = TRUE
       WHILE CContSearch
         IF LastCommWord < LastWord THEN
           IF Word$(LastCommWord+1) = "THEN" OR Word$(LastCommWord+1) = "GOTO" THEN
             CContSearch = FALSE
           ELSE
             LastCommWord = LastCommWord+1
           END IF
         ELSE
           CALL SomeError ("'THEN' or 'GOTO' expected after IF/ELSEIF",WordPos(FirstWord))
           CContSearch = FALSE
         END IF
       WEND
       IF ErrorInThisLine = FALSE THEN
         CALL DumpCommand (FirstWord,LastCommWord)
         FirstWord = LastCommWord+1
         IF Word$(FirstWord) = "THEN" THEN
           ForceGoto = FALSE
           IF FirstWord < LastWord THEN
             IF FirstWord+1 = LastWord OR Word$(FirstWord+2) = "ELSE" OR Word$(FirstWord+2) = ":" THEN CALL CouldThisBeALabel (FirstWord+1) : ForceGoto = Ergebnis
           END IF
           IF ForceGoto THEN
             Word$(FirstWord) = "GOTO"
             IfsToClose = IfsToClose+1
           ELSE
             FirstWord = FirstWord+1
             IF FirstWord <= LastWord THEN IfsToClose = IfsToClose+1
           END IF
         END IF
       END IF
     ELSEIF Word$(FirstWord) = ":" THEN
       FirstWord = FirstWord+1
     ELSEIF Word$(FirstWord) = "ELSE" THEN
       CALL DumpCommand (FirstWord,FirstWord)
       FirstWord = FirstWord+1
     ELSE
       LastCommWord = FirstWord-1
       WHILE LastCommWord < LastWord AND Word$(LastCommWord+1) <> ":" AND Word$(LastCommWord+1) <> "ELSE"
         LastCommWord = LastCommWord+1
       WEND
       CALL DumpCommand (FirstWord,LastCommWord)
       FirstWord = LastCommWord+1
     END IF
   WEND

' fehlende END IFs ergänzen
   WHILE ErrorInThisLine = FALSE AND IfsToClose > 0
     FirstWord = 0 : LastWord = 1
     Word$(FirstWord) = "END" : IsVar(LastWord) = FALSE : WordPos(FirstWord) = -1
     Word$(LastWord) = "IF" : IsVar(LastWord) = FALSE : WordPos(LastWord) = -1
     WordPos(2) = -1
     CALL DumpCommand (FirstWord,LastWord)
     IfsToClose = IfsToClose-1
   WEND

 WEND

 FirstWord = 0 : LastWord = 0
 Word$(FirstWord) = "END" : IsVar(FirstWord) = FALSE : WordPos(LastWord) = -1
 WordPos(1) = -1
 CALL DumpCommand (FirstWord,LastWord)
 RETURN

SkipSpaces:
 WHILE LinePointer <= LEN(SourceLine$) AND INSTR(" "+CHR$(9),MID$(SourceLine$,LinePointer,1)) <> 0
   IF MID$(SourceLine$,LinePointer,1) = " " THEN
     EndOfSourceLinePointer = EndOfSourceLinePointer+1
     LinePointer = LinePointer+1
   ELSE
     EndOfSourceLinePointer = INT((EndOfSourceLinePointer+8)\8)*8
     LinePointer = LinePointer+1
   END IF
 WEND
 RETURN

AddStringTillAbort:
 Add$ = ""
 CContAdding = TRUE
 WHILE CContAdding
   IF LinePointer <= LEN(SourceLine$) THEN
     a$ = MID$(SourceLine$,LinePointer,1)
     IF INSTR(Abort$,a$) THEN
       CContAdding = FALSE
     ELSEIF a$ = CHR$(9) THEN
       NewEndOfSourceLinePointer = INT((EndOfSourceLinePointer+8)\8)*8
       Add$ = Add$+SPACE$(NewEndOfSourceLinePointer-EndOfSourceLinePointer)
       EndOfSourceLinePointer = NewEndOfSourceLinePointer
       LinePointer = LinePointer+1
     ELSE
       Add$ = Add$+a$
       EndOfSourceLinePointer = EndOfSourceLinePointer+1
       LinePointer = LinePointer+1
     END IF
   ELSE
     CContAdding = FALSE
   END IF
 WEND
 RETURN

'************************************************************
'*                                                          *
'* Wertet einen Befehl aus                                  *
'*                                                          *
'************************************************************

SUB DumpCommand (Word1,Word2) STATIC
 FirstWord = Word1 : LastWord = Word2
 IF FirstWord > LastWord THEN
   CALL SomeError ("Command expected",WordPos(FirstWord)) : EXIT SUB
 END IF

' Ist das 1. Wort kein Schlueßelwort, so mueßen wir CALL oder LET erraten
 CALL IsKeyWord (Word$(FirstWord))
 IF Ergebnis = FALSE THEN
   CommandPos = -1
   Command$ = "LET"
   CALL GetVarEnd (FirstWord,LastWord,FALSE)
   IF Ergebnis = -1 OR Ergebnis = LastWord THEN
     Command$ = "CALL"
   ELSE
     IF Word$(Ergebnis+1) <> "=" THEN
       Command$ = "CALL"
     END IF
   END IF
 ELSE
   CommandPos = WordPos(FirstWord)
   Command$ = Word$(FirstWord)
   GOSUB SkipOneWord
 END IF

'
' Von hier ab werden alle Befehle ausgewertet
'

 NotFound = 0

' AREA [STEP] (x,y)
 IF Command$ = "AREA" THEN
   GOSUB DumpGfxPoint
   CALL CallLib (-120)'AREA_II_

' AREAFILL [Modus]
 ELSEIF Command$ = "AREAFILL" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-114)'AREAFILL__
   ELSE
     ExprFlags = VarINT : GOSUB DumpExpr
     CALL CallLib (-108)'AREAFILL_I_
   END IF

' BEEP
 ELSEIF Command$ = "BEEP" THEN
   CALL CallLib (-144)'BEEP__

' BREAK ON / BREAK OFF / BREAK STOP
 ELSEIF Command$ = "BREAK" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) = "ON" THEN
     GOSUB SkipOneWord
     CALL CallLib (-156)'BREAKON__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "OFF" THEN
     GOSUB SkipOneWord
     CALL CallLib (-150)'BREAKOFF__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "STOP" THEN
     GOSUB SkipOneWord
     CALL CallLib (-162)'BREAKSTOP__
   ELSE
     GOTO SyntaxError
   END IF

' [CALL] Sprungmarke [(Argumentliste)] / [CALL] num Var [(Argumentliste)]
 ELSEIF Command$ = "CALL" THEN
   IF FirstWord > LastWord THEN CALL SomeError ("Expected a label",WordPos(FirstWord)) : EXIT SUB
   CALL CouldThisBeALabel (FirstWord)
   IF Ergebnis = FALSE THEN CALL SomeError ("Expected a label",WordPos(FirstWord)) : EXIT SUB
   LabelPointer = FirstWord
   GOSUB SkipOneWord
   CALL TryRemBrackets (FirstWord,LastWord)
   FirstWord = FirstWord+Ergebnis
   LastWord = LastWord-Ergebnis
   IF Pass = 1 THEN
     ExpectKomma = FALSE
     WHILE FirstWord <= LastWord
       IF ExpectKomma THEN
         GOSUB SkipKomma
       ELSE
         ExpectKomma = TRUE
       END IF
       ExprFlags = VarTEXT OR VarINT OR VarLONG OR VarREAL OR VarDOUB : GOSUB DumpExpr
     WEND
   ELSE
     CALL GetMySubNum (Word$(LabelPointer),FALSE)
     IF Ergebnis = -1 THEN EXIT SUB
     MySubNumber = Ergebnis
     ExpectKomma = FALSE
     FOR a = 0 TO NumSubPars(MySubNumber)
       IF ExpectKomma THEN
         GOSUB SkipKomma
       ELSE
         ExpectKomma = TRUE
       END IF
       ParPos(a) = FirstWord
       SaveConvErrorPos = WordPos(FirstWord)
       ExprFlags = VarTEXT OR VarINT OR VarLONG OR VarREAL OR VarDOUB : GOSUB DumpExpr
       CALL TryConv (Ergebnis,SubParType(MySubNumber,a),SaveConvErrorPos)
       IF Ergebnis = FALSE THEN EXIT SUB
     NEXT a
     IF FirstWord <= LastWord THEN CALL SomeError ("CALL: Too many parameters",WordPos(FirstWord)) : EXIT SUB
     CALL SubDumpLabel ("_"+Word$(LabelPointer))
     CALL CallLib (-168)'CALL_Z_
     FOR a = NumSubPars(MySubNumber) TO 0 STEP -1
       FirstWord = ParPos(a)
       CALL GetExprEnd (FirstWord,LastWord)
       IF Ergebnis = -1 THEN EXIT SUB
       EndOfExpr = Ergebnis
       CALL GetVarEnd (FirstWord,LastWord,FALSE)
       IF Ergebnis = -1 OR Ergebnis <> EndOfExpr THEN
         IF SubParType(MySubNumber,a) = VarTEXT THEN
           CALL CallLib (-702)'FORGET_T_
         ELSEIF SubParType(MySubNumber,a) = VarINT THEN
           CALL CallLib (-684)'FORGET_I_
         ELSEIF SubParType(MySubNumber,a) = VarLONG THEN
           CALL CallLib (-690)'FORGET_L_
         ELSEIF SubParType(MySubNumber,a) = VarREAL THEN
           CALL CallLib (-696)'FORGET_R_
         ELSEIF SubParType(MySubNumber,a) = VarDOUB THEN
           CALL CallLib (-678)'FORGET_D_
         END IF
       ELSE
         CALL SubDumpSetVar (FirstWord,Ergebnis,SubParType(MySubNumber,a))
         IF Ergebnis = FALSE THEN EXIT SUB
       END IF
     NEXT a
     FirstWord = LastWord+1
   END IF

' CHAIN [MERGE] Dateiangabe[,[Zeile][,[ALL][,DELETE Bereich]]]
 ELSEIF Command$ = "CHAIN" THEN
   GOTO NotCompilable

' CHDIR Pfad
 ELSEIF Command$ = "CHDIR" THEN
   ExprFlags = VarTEXT : GOSUB DumpExpr
   CALL CallLib (-174)'CHDIR_T_

' CIRCLE [STEP] (x,y),r[,Farbe[,Start,Ende[,Bild]]]
 ELSEIF Command$ = "CIRCLE" THEN
   GOSUB DumpGfxPoint
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   IF FirstWord > LastWord THEN
     CALL CallLib (-210)'CIRCLE_III_
   ELSE
     GOSUB SkipKomma
     ExprFlags = VarINT : GOSUB DumpExpr
     IF FirstWord > LastWord THEN
       CALL CallLib (-204)'CIRCLE_IIII_
     ELSE
       GOSUB SkipKomma
       ExprFlags = VarREAL : GOSUB DumpExpr
       GOSUB SkipKomma
       ExprFlags = VarREAL : GOSUB DumpExpr
       IF FirstWord > LastWord THEN
         CALL CallLib (-198)'CIRCLE_IIIIRR_
       ELSE
         GOSUB SkipKomma
         ExprFlags = VarREAL : GOSUB DumpExpr
         CALL CallLib (-192)'CIRCLE_IIIIRRR_
       END IF
     END IF
   END IF

' CLEAR [,[Prg][,Stap]]
 ELSEIF Command$ = "CLEAR" THEN
   CALL CallLib (-216)'CLEAR__
   IF FirstWord <= LastWord THEN GOSUB SkipKomma
   IF FirstWord <= LastWord THEN
     IF Word$(FirstWord) <> "," THEN
       ExprFlags = VarLONG : GOSUB DumpExpr
       CALL CallLib (-1932)'SETMEM_L_
     END IF
   END IF
   IF FirstWord <= LastWord THEN GOSUB SkipKomma
   IF FirstWord <= LastWord THEN
     ExprFlags = VarLONG : GOSUB DumpExpr
     CALL CallLib (-1956)'SETSTACK_L_
   END IF

' CLOSE [Dateinr[,Dateinr]...]
 ELSEIF Command$ = "CLOSE" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-228)'CLOSE__
   ELSE
     ExpectKomma = FALSE
     WHILE FirstWord <= LastWord
       IF Word$(FirstWord) = "#" THEN GOSUB SkipOneWord
       IF ExpectKomma THEN
         GOSUB SkipKomma
       ELSE
         ExpectKomma = TRUE
       END IF
       ExprFlags = VarINT : GOSUB DumpExpr
       CALL CallLib (-222)'CLOSE_I_
     WEND
   END IF

' CLS
 ELSEIF Command$ = "CLS" THEN
   CALL CallLib (-234)'CLS__

' COLLISION ON / COLLISION OFF / COLLISION STOP
 ELSEIF Command$ = "COLLISION" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) = "ON" THEN
     GOSUB SkipOneWord
     CALL CallLib (-246)'COLLISIONON__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "OFF" THEN
     GOSUB SkipOneWord
     CALL CallLib (-240)'COLLISIONOFF__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "STOP" THEN
     GOSUB SkipOneWord
     CALL CallLib (-252)'COLLISIONSTOP__
   ELSE
     GOTO SyntaxError
   END IF

' COLOR [Vordergrund][,Hintergrund]
 ELSEIF Command$ = "COLOR" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) <> "," THEN
     ExprFlags = VarINT : GOSUB DumpExpr
   ELSE
     CALL SubDumpVar ("0",VarINT+VarCONST,-1)
   END IF
   CALL CallLib (-264)'COLOR1_I_
   IF FirstWord <= LastWord THEN GOSUB SkipKomma
   IF FirstWord <= LastWord THEN
     ExprFlags = VarINT : GOSUB DumpExpr
   ELSE
     CALL SubDumpVar ("1",VarINT+VarCONST,-1)
   END IF
   CALL CallLib (-270)'COLOR2_I_

' COMMON Varibale[,Variable]...
 ELSEIF Command$ = "COMMON" THEN
   GOTO NotCompilable

' CONT
 ELSEIF Command$ = "CONT" THEN
   GOTO NotCompilable

' DATA Konstante[,Konstante]...
' DATA-Anweisung wird schon vorher behandelt
 ELSEIF Command$ = "DATA" THEN

' DECLARE FUNCTION Name [(Parameterliste)] LIBRARY
 ELSEIF Command$ = "DECLARE" THEN
   GOTO NotImplemented

' DEF FNName[(Arg[,Arg]...)] = Funktionsdefinition
 ELSEIF Command$ = "DEF" THEN
   GOTO NotImplemented

' DEFDBL Buchst[-Buchst][,Buchst[-Buchst]]...
 ELSEIF Command$ = "DEFDBL" THEN
   DefType = VarDOUB : GOSUB HandleDefType

' DEFINT Buchst[-Buchst][,Buchst[-Buchst]]...
 ELSEIF Command$ = "DEFINT" THEN
   DefType = VarINT : GOSUB HandleDefType

' DEFLNG Buchst[-Buchst][,Buchst[-Buchst]]...
 ELSEIF Command$ = "DEFLNG" THEN
   DefType = VarLONG : GOSUB HandleDefType

' DEFSNG Buchst[-Buchst][,Buchst[-Buchst]]...
 ELSEIF Command$ = "DEFSNG" THEN
   DefType = VarREAL : GOSUB HandleDefType

' DEFSTR Buchst[-Buchst][,Buchst[-Buchst]]...
 ELSEIF Command$ = "DEFSTR" THEN
   DefType = VarTEXT : GOSUB HandleDefType

' DELETE [Marke1][-[Marke2]]
 ELSEIF Command$ = "DELETE" THEN
   GOTO NotCompilable

' DIM [SHARED] Var[(Ind)][,Var[(Ind)]]...
 ELSEIF Command$ = "DIM" THEN
   IsShared = FALSE
   IF FirstWord <= LastWord AND Word$(FirstWord) = "SHARED" THEN GOSUB SkipOneWord : IsShared = TRUE
   ExpectKomma = FALSE
   WHILE FirstWord <= LastWord OR ExpectKomma = FALSE
     IF ExpectKomma THEN
       GOSUB SkipKomma
     ELSE
       ExpectKomma = TRUE
     END IF
     CALL GetVarEnd (FirstWord,LastWord,TRUE)
     IF Ergebnis = -1 THEN EXIT SUB
     EndOfVar = Ergebnis
     IF FirstWord = EndOfVar THEN
       IF IsShared = FALSE THEN SyntaxError
       CALL GetVarNum (Word$(FirstWord),WordVarFlags(FirstWord),-1,0)
       GOSUB SkipOneWord
     ELSE
       IF IsShared THEN
         CALL GetVarNum (Word$(FirstWord),WordVarFlags(FirstWord),0,0)
       ELSE
         CALL GetVarNum (Word$(FirstWord),WordVarFlags(FirstWord),0,SubNumber)
       END IF
       VarNumber = Ergebnis
       CALL SubDumpField (FirstWord,EndOfVar)
       IF Ergebnis = FALSE THEN EXIT SUB
       IF VarSubNum(VarNumber) = 0 THEN
         IF Ergebnis = VarTEXT THEN
           CALL CallLib (-450)'DIMSHAREDTEXT_FP_
         ELSEIF Ergebnis = VarINT THEN
           CALL CallLib (-432)'DIMSHAREDINT_FP_
         ELSEIF Ergebnis = VarLONG THEN
           CALL CallLib (-438)'DIMSHAREDLONG_FP_
         ELSEIF Ergebnis = VarREAL THEN
           CALL CallLib (-444)'DIMSHAREDREAL_FP_
         ELSEIF Ergebnis = VarDOUB THEN
           CALL CallLib (-426)'DIMSHAREDDOUB_FP_
         END IF
       ELSE
         IF Ergebnis = VarTEXT THEN
           CALL CallLib (-420)'DIMTEXT_FP_
         ELSEIF Ergebnis = VarINT THEN
           CALL CallLib (-402)'DIMINT_FP_
         ELSEIF Ergebnis = VarLONG THEN
           CALL CallLib (-408)'DIMLONG_FP_
         ELSEIF Ergebnis = VarREAL THEN
           CALL CallLib (-414)'DIMREAL_FP_
         ELSEIF Ergebnis = VarDOUB THEN
           CALL CallLib (-396)'DIMDOUB_FP_
         END IF
       END IF
       FirstWord = EndOfVar+1
     END IF
   WEND

' ELSE
 ELSEIF Command$ = "ELSE" THEN
   StackType = TypeIF : GOSUB Pull
   StackType = TypeIF : GOSUB Push
   CALL SubDumpLabel (Stack$(StackPointer,0))
   CALL CallLib (-840)'GOTO_Z_
   CALL SubSetLabel (Stack$(StackPointer,1))
   IF Ergebnis = FALSE THEN EXIT SUB
   CALL CreateLabel
   Stack$(StackPointer,1) = Ergebnis$

' ELSEIF Ausdr THEN
' das "THEN" wird nicht erwartet, es wurde schon zuvor entfernt
 ELSEIF Command$ = "ELSEIF" THEN
   StackType = TypeIF : GOSUB Pull
   StackType = TypeIF : GOSUB Push
   CALL SubDumpLabel (Stack$(StackPointer,0))
   CALL CallLib (-840)'GOTO_Z_
   CALL SubSetLabel (Stack$(StackPointer,1))
   IF Ergebnis = FALSE THEN EXIT SUB
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL CreateLabel
   Stack$(StackPointer,1) = Ergebnis$
   CALL SubDumpLabel (Stack$(StackPointer,1))
   CALL CallLib (-912)'IF_IZ_

' END / END SUB / END IF
 ELSEIF Command$ = "END" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-36)'END__
   ELSEIF Word$(FirstWord) = "SUB" THEN
     GOSUB SkipOneWord
     IF SubNumber = 1 THEN CALL SomeError ("END SUB without SUB",CommandPos) : EXIT SUB
     CALL SubDumpLabel (LeaveSubLabel$)
     CALL CallLib (-840)'GOTO_Z_
     CALL SubSetLabel (SkipSubLabel$)
     SubNumber = 1
   ELSEIF Word$(FirstWord) = "IF" THEN
     GOSUB SkipOneWord
     StackType = TypeIF : GOSUB Pull
     CALL SubSetLabel (Stack$(StackPointer+1,0))
     IF Ergebnis = FALSE THEN EXIT SUB
     CALL SubSetLabel (Stack$(StackPointer+1,1))
     IF Ergebnis = FALSE THEN EXIT SUB
   ELSE
     GOTO SyntaxError
   END IF

' ERASE Fledvar[,Feldvar]...
 ELSEIF Command$ = "ERASE" THEN
   ExpectKomma = FALSE
   WHILE FirstWord <= LastWord OR ExpectKomma = FALSE
     IF ExpectKomma THEN
       GOSUB SkipKomma
     ELSE
       ExpectKomma = TRUE
     END IF
     GOSUB DumpFieldPointer
     CALL CallLib (-564)'ERASE_f_
   WEND

' ERROR n
 ELSEIF Command$ = "ERROR" THEN
   ExprFlags = VarLONG : GOSUB DumpExpr
   CALL CallLib (-576)'ERROR_L_

' EXIT SUB
 ELSEIF Command$ = "EXIT" THEN
   IF FirstWord = LastWord AND Word$(FirstWord) = "SUB" THEN
     GOSUB SkipOneWord
     IF SubNumber = 1 THEN CALL SomeError ("EXIT SUB without SUB",CommandPos) : EXIT SUB
     CALL SubDumpLabel (LeaveSubLabel$)
     CALL CallLib (-840)'GOTO_Z_
   ELSE
     GOTO SyntaxError
   END IF

' FIELD Dateinr,Länge AS Zeikettvar [,Länge AS Zeikettvar]...
 ELSEIF Command$ = "FIELD" THEN
   GOTO NotImplemented

' FILES [Dateiangabe]
 ELSEIF Command$ = "FILES" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-660)'FILES__
   ELSE
     ExprFlags = VarTEXT : GOSUB DumpExpr
     CALL CallLib (-654)'FILES_T_
   END IF

' FOR Var = x TO y [STEP z]
 ELSEIF Command$ = "FOR" THEN
   IF FirstWord > LastWord THEN NeedSomethingError
   IF IsVar(FirstWord) = FALSE OR (WordVarFlags(FirstWord) AND VarCONST) <> 0 THEN CALL SomeError ("Expected a variable",WordPos(FirstWord)) : EXIT SUB
   IF WordVarFlags(FirstWord) AND VarTEXT THEN CALL SomeError ("No TEXT-variable allowed here",WordPos(FirstWord)) : EXIT SUB
   VarPointer = FirstWord
   GOSUB SkipOneWord
   IF FirstWord > LastWord OR Word$(FirstWord) <> "=" THEN CALL SomeError ("Expected '='",WordPos(FirstWord)) : EXIT SUB
   GOSUB SkipOneWord
   ExprFlags = WordVarFlags(VarPointer) : GOSUB DumpExpr
   CALL SubDumpSetSimpleVar (Word$(VarPointer),WordVarFlags(VarPointer),-1)
   IF FirstWord > LastWord THEN NeedSomethingError
   IF Word$(FirstWord) <> "TO" THEN SyntaxError
   GOSUB SkipOneWord
   ExprFlags = WordVarFlags(VarPointer) : GOSUB DumpExpr
   CALL SubDumpSetSimpleVar (Word$(VarPointer),WordVarFlags(VarPointer),-2)
   IF FirstWord > LastWord THEN
     CALL SubDumpVar ("1",WordVarFlags(VarPointer)+VarCONST,-1)
   ELSE
     IF Word$(FirstWord) <> "STEP" THEN SyntaxError
     GOSUB SkipOneWord
     ExprFlags = WordVarFlags(VarPointer) : GOSUB DumpExpr
   END IF
   CALL SubDumpSetSimpleVar (Word$(VarPointer),WordVarFlags(VarPointer),-3)
   StackType = TypeFOR : GOSUB Push
   CALL CreateLabel
   Stack$(StackPointer,0) = Ergebnis$
   Stack$(StackPointer,1) = Word$(VarPointer)
   CALL CreateLabel
   Stack$(StackPointer,2) = Ergebnis$
   CALL SubDumpLabel (Stack$(StackPointer,2))
   CALL CallLib (-840)'GOTO_Z_
   CALL SubSetLabel (Stack$(StackPointer,0))
   IF Ergebnis = FALSE THEN EXIT SUB

' GET Dateinr,Satznr / GET (x1,y1)-(x2,y2), Fledvar [(Index[,Index...])]
 ELSEIF Command$ = "GET" THEN
   GOTO NotImplemented

' GOSUB Marke
 ELSEIF Command$ = "GOSUB" THEN
   GOSUB DumpLabel
   CALL CallLib (-834)'GOSUB_Z_

' GOTO Marke
 ELSEIF Command$ = "GOTO" THEN
   GOSUB DumpLabel
   CALL CallLib (-840)'GOTO_Z_

' IF Ausdr THEN
' das "THEN" wird nicht erwartet, es wurde schon zuvor entfernt
 ELSEIF Command$ = "IF" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   StackType = TypeIF : GOSUB Push
   CALL CreateLabel
   Stack$(StackPointer,0) = Ergebnis$
   CALL CreateLabel
   Stack$(StackPointer,1) = Ergebnis$
   CALL SubDumpLabel (Stack$(StackPointer,1))
   CALL CallLib (-912)'IF_IZ_

' INPUT ["Text";] Var[,Var]...
 ELSEIF Command$ = "INPUT" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) = "#" THEN
     GOSUB SkipOneWord
     ExprFlags = VarINT : GOSUB DumpExpr
     GOSUB SkipKomma
     DidRead = FALSE
     WHILE FirstWord <= LastWord OR DidRead = FALSE
       IF DidRead THEN
         GOSUB SkipKomma
       ELSE
         DidRead = TRUE
       END IF
       CALL CallLib (-600)'FILEINPUT_I_IT
       StackFlags = VarTEXT : GOSUB DumpSetVar
     WEND
     CALL CallLib (-684)'FORGET_I_
   ELSE
     IF FirstWord <= LastWord AND LEFT$(Word$(FirstWord),1) = CHR$(34) THEN
       ExprFlags = VarTEXT : GOSUB DumpExpr
       CALL CallLib (-1782)'PRINT_T_
       IF FirstWord <= LastWord AND INSTR(";,",Word$(FirstWord)) THEN
         IF Word$(FirstWord) = ";" THEN CALL CallLib (-1740)'PRINTQMARK__
         GOSUB SkipOneWord
         GOSUB HandleInputLine
       ELSE
         GOTO SyntaxError
       END IF
     ELSE
       CALL CallLib (-1740)'PRINTQMARK__
       GOSUB HandleInputLine
     END IF
   END IF

' KILL Dateiangabe
 ELSEIF Command$ = "KILL" THEN
   ExprFlags = VarTEXT : GOSUB DumpExpr
   CALL CallLib (-972)'KILL_T_

' [LET] Var = Ausdruck
 ELSEIF Command$ = "LET" THEN
   SafeFirstWord = FirstWord
   GOSUB SkipOneVar
   IF FirstWord > LastWord OR Word$(FirstWord) <> "=" THEN CALL SomeError ("Expected '='",WordPos(FirstWord)) : EXIT SUB
   GOSUB SkipOneWord
   ExprFlags = VarTEXT OR VarINT OR VarLONG OR VarREAL OR VarDOUB : GOSUB DumpExpr
   FirstWord = SafeFirstWord
   StackFlags = Ergebnis : GOSUB DumpSetVar
   FirstWord = LastWord+1

' LIBRARY "Dateiname" / LIBRARY CLOSE
 ELSEIF Command$ = "LIBRARY" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) = "CLOSE" THEN
     GOSUB SkipOneWord
     CALL CallLib (-1020)'LIBRARYCLOSE__
   ELSE
     ExprFlags = VarTEXT : GOSUB DumpExpr
     CALL CallLib (-1026)'LIBRARY_T_
   END IF

' LINE INPUT #Dateinr,Zeikettenvar
' LINE INPUT ["Text";]Zeikettvar
' LINE [[STEP] (x1,y1)-[STEP] (x2,y2)[,Farbe][,B[F]]]
 ELSEIF Command$ = "LINE" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) = "INPUT" THEN
     GOSUB SkipOneWord
     IF FirstWord <= LastWord AND Word$(FirstWord) = "#" THEN
       GOSUB SkipOneWord
       ExprFlags = VarINT : GOSUB DumpExpr
       GOSUB SkipKomma
       CALL CallLib (-606)'FILELINEINPUT_I_T
       StackFlags = VarTEXT : GOSUB DumpSetVar
     ELSE
       IF FirstWord <= LastWord AND LEFT$(Word$(FirstWord),1) = CHR$(34) THEN
         ExprFlags = VarTEXT : GOSUB DumpExpr
         CALL CallLib (-1782)'PRINT_T_
         IF FirstWord > LastWord OR (Word$(FirstWord) <> ";" AND Word$(FirstWord) <> ",") THEN SyntaxError
         GOSUB SkipOneWord
       END IF
       CALL CallLib (-1044)'LINEINPUT__T
       StackFlags = VarTEXT : GOSUB DumpSetVar
     END IF
   ELSE
     IF FirstWord > LastWord OR Word$(FirstWord) <> "-" THEN
       GOSUB DumpGfxPoint
     ELSE
       CALL SubDumpVar ("0",VarINT+VarCONST,-1)
       CALL SubDumpVar ("0",VarINT+VarCONST,-1)
       CALL CallLib (-828)'GFXSTEP_II_II
     END IF
     IF FirstWord > LastWord OR Word$(FirstWord) <> "-" THEN SyntaxError
     GOSUB SkipOneWord
     GOSUB DumpGfxPoint
     IF FirstWord <= LastWord THEN GOSUB SkipKomma
     IF FirstWord > LastWord OR Word$(FirstWord) = "," THEN
       CALL CallLib (-714)'FRONTCOLOR__I
     ELSE
       ExprFlags = VarINT : GOSUB DumpExpr
     END IF
     IF FirstWord > LastWord THEN
       CALL CallLib (-1050)'LINE_IIIII_
     ELSE
       GOSUB SkipKomma
       IF FirstWord = LastWord AND Word$(FirstWord) = "B" THEN
         GOSUB SkipOneWord
         CALL CallLib (-1038)'LINEB_IIIII_
       ELSEIF FirstWord = LastWord AND Word$(FirstWord) = "BF" THEN
         GOSUB SkipOneWord
         CALL CallLib (-1032)'LINEBF_IIIII_
       ELSE
         GOTO SyntaxError
       END IF
     END IF
   END IF

' LIST [Zeile1][-[Zeile2]][,Dateinang]
 ELSEIF Command$ = "LIST" THEN
   GOTO NotCompilable

' LLIST [Zeile1][-[Zeile2]]
 ELSEIF Command$ = "LLIST" THEN
   GOTO NotCompilable

' LOAD [Dateiangabe[,R]]
 ELSEIF Command$ = "LOAD" THEN
   GOTO NotCompilable

' LOCATE [Zeile][,Spalte]
 ELSEIF Command$ = "LOCATE" THEN
   IF FirstWord <= LastWord THEN
     IF Word$(FirstWord) <> "," THEN
       ExprFlags = VarINT : GOSUB DumpExpr
       CALL CallLib (-1062)'LOCATEY_I_
     END IF
     IF FirstWord <= LastWord THEN GOSUB SkipKomma
     IF FirstWord <= LastWord THEN
       ExprFlags = VarINT : GOSUB DumpExpr
       CALL CallLib (-1056)'LOCATEX_I_
     END IF
   END IF

' LPRINT [Liste von Ausdr][;]
 ELSEIF Command$ = "LPRINT" THEN
   SendReturn = TRUE
   WHILE FirstWord <= LastWord
     IF Word$(FirstWord) = ";" THEN
       GOSUB SkipOneWord
       SendReturn = FALSE
     END IF
     IF FirstWord <= LastWord AND Word$(FirstWord) = "," THEN
       GOSUB SkipOneWord
       CALL CallLib (-1104)'LPRINTTAB__
       SendReturn = FALSE
     END IF
     IF FirstWord <= LastWord THEN
       ExprFlags = VarTEXT OR VarINT OR VarLONG OR VarREAL OR VarDOUB : GOSUB DumpExpr
       IF Ergebnis = VarTEXT THEN
         CALL CallLib (-1134)'LPRINT_T_
       ELSEIF Ergebnis = VarINT THEN
         CALL CallLib (-1116)'LPRINT_I_
       ELSEIF Ergebnis = VarLONG THEN
         CALL CallLib (-1122)'LPRINT_L_
       ELSEIF Ergebnis = VarREAL THEN
         CALL CallLib (-1128)'LPRINT_R_
       ELSEIF Ergebnis = VarDOUB THEN
         CALL CallLib (-1110)'LPRINT_D_
       END IF
       SendReturn = TRUE
     END IF
   WEND
   IF SendReturn THEN CALL CallLib (-1098)'LPRINTRETURN__

' MENU Kennung,Punkt,Status[,Titel] / MENU ON / MENU OFF / MENU STOP
 ELSEIF Command$ = "MENU" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) = "ON" THEN
     GOSUB SkipOneWord
     CALL CallLib (-1176)'MENUON__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "OFF" THEN
     GOSUB SkipOneWord
     CALL CallLib (-1170)'MENUOFF__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "STOP" THEN
     GOSUB SkipOneWord
     CALL CallLib (-1188)'MENUSTOP__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "RESET" THEN
     GOSUB SkipOneWord
     CALL CallLib (-1182)'MENURESET__
   ELSE
     ExprFlags = VarINT : GOSUB DumpExpr
     GOSUB SkipKomma
     ExprFlags = VarINT : GOSUB DumpExpr
     GOSUB SkipKomma
     ExprFlags = VarINT : GOSUB DumpExpr
     IF FirstWord > LastWord THEN
       CALL CallLib (-1200)'MENU_III_
     ELSE
       GOSUB SkipKomma
       ExprFlags = VarTEXT : GOSUB DumpExpr
       CALL CallLib (-1194)'MENU_IIIT_
     END IF
   END IF

' MERGE
 ELSEIF Command$ = "MERGE" THEN
   GOTO NotCompilable

' MID$(v$,n[,m]) = x$
 ELSEIF Command$ = "MID$" THEN
   ThreePars = FALSE
   IF FirstWord > LastWord OR Word$(FirstWord) <> "(" THEN SyntaxError
   GOSUB SkipOneWord
   VarFlags = VarTEXT : GOSUB DumpVarPointer
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   IF FirstWord <= LastWord AND Word$(FirstWord) = "," THEN
     GOSUB SkipKomma
     ThreePars = TRUE
     ExprFlags = VarINT : GOSUB DumpExpr
   END IF
   IF FirstWord > LastWord OR Word$(FirstWord) <> ")" THEN SyntaxError
   GOSUB SkipOneWord
   IF FirstWord > LastWord OR Word$(FirstWord) <> "=" THEN SyntaxError
   GOSUB SkipOneWord
   ExprFlags = VarTEXT : GOSUB DumpExpr
   IF ThreePars THEN
     CALL CallLib (-1938)'SETMID_tIIT_
   ELSE
     CALL CallLib (-1944)'SETMID_tIT_
   END IF

' MOUSE ON / MOUSE OFF / MOUSE STOP
 ELSEIF Command$ = "MOUSE" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) = "ON" THEN
     GOSUB SkipOneWord
     CALL CallLib (-1266)'MOUSEON__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "OFF" THEN
     GOSUB SkipOneWord
     CALL CallLib (-1260)'MOUSEOFF__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "STOP" THEN
     GOSUB SkipOneWord
     CALL CallLib (-1272)'MOUSESTOP__
   ELSE
     GOTO SyntaxError
   END IF

' NAME Dateiangabe AS Dateiname
 ELSEIF Command$ = "NAME" THEN
   ExprFlags = VarTEXT : GOSUB DumpExpr
   IF FirstWord > LastWord OR Word$(FirstWord) <> "AS" THEN SyntaxError
   GOSUB SkipOneWord
   ExprFlags = VarTEXT : GOSUB DumpExpr
   CALL CallLib (-1308)'NAME_TT_

' Damit IF ... THEN nicht zu lang wird
 ELSE
   NotFound = NotFound+1
 END IF

' NEW
 IF Command$ = "NEW" THEN
   GOTO NotCompilable

' NEXT [Var][,Var]...
 ELSEIF Command$ = "NEXT" THEN
   ExpectKomma = FALSE
   WHILE FirstWord <= LastWord OR ExpectKomma = FALSE
     IF ExpectKomma THEN
       GOSUB SkipKomma
     ELSE
       ExpectKomma = TRUE
     END IF
     StackType = TypeFOR : GOSUB Pull
     IF FirstWord <= LastWord AND Word$(FirstWord) <> "," THEN
       IF IsVar(FirstWord) = FALSE OR (WordVarFlags(FirstWord) AND (VarCONST OR VarTEXT)) <> 0 THEN CALL SomeError ("Expected numeric variable",WordPos(FirstWord)) : EXIT SUB
       IF Word$(FirstWord) <> Stack$(StackPointer+1,1) THEN CALL SomeError ("Not the same variable like that in the FOR-command",WordPos(FirstWord)) : EXIT SUB
       GOSUB SkipOneWord
     END IF
     CALL GetVarFlags (Stack$(StackPointer+1,1))
     CountVarFlags = Ergebnis
' Zählvariable erhöhen
     CALL SubDumpVar (Stack$(StackPointer+1,1),CountVarFlags,-1)
     CALL SubDumpVar (Stack$(StackPointer+1,1),CountVarFlags,-3)
     IF CountVarFlags = VarINT THEN
       CALL CallLib (-72)'ADD_II_I
     ELSEIF CountVarFlags = VarLONG THEN
       CALL CallLib (-78)'ADD_LL_L
     ELSEIF CountVarFlags = VarREAL THEN
       CALL CallLib (-84)'ADD_RR_R
     ELSEIF CountVarFlags = VarDOUB THEN
       CALL CallLib (-66)'ADD_DD_D
     END IF
     CALL SubDumpSetSimpleVar (Stack$(StackPointer+1,1),CountVarFlags,-1)
' Label fuer FOR setzen
     CALL SubSetLabel (Stack$(StackPointer+1,2))
     IF Ergebnis = FALSE THEN EXIT SUB
' NEXT-Abfrage
     CALL SubDumpVar (Stack$(StackPointer+1,1),CountVarFlags,-1)
     CALL SubDumpVar (Stack$(StackPointer+1,1),CountVarFlags,-2)
     CALL SubDumpVar (Stack$(StackPointer+1,1),CountVarFlags,-3)
     CALL SubDumpLabel (Stack$(StackPointer+1,0))
     IF CountVarFlags = VarINT THEN
       CALL CallLib (-1344)'NEXT_IIIZ_
     ELSEIF CountVarFlags = VarLONG THEN
       CALL CallLib (-1350)'NEXT_LLLZ_
     ELSEIF CountVarFlags = VarREAL THEN
       CALL CallLib (-1356)'NEXT_RRRZ_
     ELSEIF CountVarFlags = VarDOUB THEN
       CALL CallLib (-1338)'NEXT_DDDZ_
     END IF
   WEND

' OBJECT.AX Objekt,Wert
 ELSEIF Command$ = "OBJECT.AX" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL CallLib (-1404)'OBJECT.AX_II_

' OBJECT.AY Objekt,Wert
 ELSEIF Command$ = "OBJECT.AY" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL CallLib (-1410)'OBJECT.AY_II_

' OBJECT.CLIP (x1,y1)-(x2,y2)
 ELSEIF Command$ = "OBJECT.CLIP" THEN
   GOSUB DumpGfxPoint
   IF FirstWord > LastWord OR Word$(FirstWord) <> "-" THEN SyntaxError
   GOSUB DumpGfxPoint
   CALL CallLib (-1416)'OBJECT.CLIP_IIII_

' OBJECT.CLOSE [Object[,Objekt...]]
 ELSEIF Command$ = "OBJECT.CLOSE" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-1428)'OBJECT.CLOSE__
   ELSE
     ExpectKomma = FALSE
     WHILE FirstWord <= LastWord
       IF ExpectKomma THEN
         GOSUB SkipKomma
       ELSE
         ExpectKomma = TRUE
       END IF
       ExprFlags = VarINT : GOSUB DumpExpr
       CALL CallLib (-1422)'OBJECT.CLOSE_I_
     WEND
   END IF

' OBJECT.HIT Objekt[,[Selbst][,[Fremd]]]
 ELSEIF Command$ = "OBJECT.HIT" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   IF FirstWord <= LastWord AND Word$(FirstWord) <> "," THEN
     ExprFlags = VarLONG : GOSUB DumpExpr
     CALL CallLib (-1434)'OBJECT.HIT1_II_I
   END IF
   IF FirstWord <= LastWord THEN GOSUB SkipKomma
   IF FirstWord <= LastWord THEN
     ExprFlags = VarLONG : GOSUB DumpExpr
     CALL CallLib (-1440)'OBJECT.HIT2_II_I
   END IF
   CALL CallLib (-684)'FORGET_I_

' OBJECT.OFF [Objekt[,Objekt...]]
 ELSEIF Command$ = "OBJECT.OFF" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-1452)'OBJECT.OFF__
   ELSE
     ExpectKomma = FALSE
     WHILE FirstWord <= LastWord
       IF ExpectKomma THEN
         GOSUB SkipKomma
       ELSE
         ExpectKomma = TRUE
       END IF
       ExprFlags = VarINT : GOSUB DumpExpr
       CALL CallLib (-1446)'OBJECT.OFF_I_
     WEND
   END IF

' OBJECT.ON [Objekt[,Objekt...]]
 ELSEIF Command$ = "OBJECT.ON" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-1464)'OBJECT.ON__
   ELSE
     ExpectKomma = FALSE
     WHILE FirstWord <= LastWord
       IF ExpectKomma THEN
         GOSUB SkipKomma
       ELSE
         ExpectKomma = TRUE
       END IF
       ExprFlags = VarINT : GOSUB DumpExpr
       CALL CallLib (-1458)'OBJECT.ON_I_
     WEND
   END IF

' OBJECT.PLANES Objekt[,[Bitebene][,[Ebene-Ein-Aus]]]
 ELSEIF Command$ = "OBJECT.PLANES" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   IF FirstWord <= LastWord AND Word$(FirstWord) <> "," THEN
     ExprFlags = VarINT : GOSUB DumpExpr
     CALL CallLib (-1470)'OBJECT.PLANES1_II_I
   END IF
   IF FirstWord <= LastWord THEN GOSUB SkipKomma
   IF FirstWord <= LastWord THEN
     ExprFlags = VarINT : GOSUB DumpExpr
     CALL CallLib (-1476)'OBJECT.PLANES2_II_I
   END IF
   CALL CallLib (-684)'FORGET_I_

' OBJECT.PRIORITY Objekt,Prior
 ELSEIF Command$ = "OBJECT.PRIORITY" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL CallLib (-1482)'OBJECT.PRIORITY_II_

' OBJECT.SHAPE Objekt,Definition / OBJECT.SHAPE Objekt1,Objekt2
 ELSEIF Command$ = "OBJECT.SHAPE" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarINT OR VarTEXT : GOSUB DumpExpr
   IF Ergebnis = VarINT THEN
     CALL CallLib (-1488)'OBJECT.SHAPE_II_
   ELSE
     CALL CallLib (-1494)'OBJECT.SHAPE_IT_
   END IF

' OBJECT.START [Objekt[,Objekt...]]
 ELSEIF Command$ = "OBJECT.START" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-1506)'OBJECT.START__
   ELSE
     ExpectKomma = FALSE
     WHILE FirstWord <= LastWord
       IF ExpectKomma THEN
         GOSUB SkipKomma
       ELSE
         ExpectKomma = TRUE
       END IF
       ExprFlags = VarINT : GOSUB DumpExpr
       CALL CallLib (-1500)'OBJECT.START_I_
     WEND
   END IF

' OBJECT.STOP [Objekt[,Objekt...]]
 ELSEIF Command$ = "OBJECT.STOP" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-1518)'OBJECT.STOP__
   ELSE
     ExpectKomma = FALSE
     WHILE FirstWord <= LastWord
       IF ExpectKomma THEN
         GOSUB SkipKomma
       ELSE
         ExpectKomma = TRUE
       END IF
       ExprFlags = VarINT : GOSUB DumpExpr
       CALL CallLib (-1512)'OBJECT.STOP_I_
     WEND
   END IF

' OBJECT.VX Objekt,Geschw
 ELSEIF Command$ = "OBJECT.VX" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL CallLib (-1524)'OBJECT.VX_II_

' OBJECT.VY Objekt,Geschw
 ELSEIF Command$ = "OBJECT.VY" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL CallLib (-1536)'OBJECT.VY_II_

' OBJECT.X Objekt,x
 ELSEIF Command$ = "OBJECT.X" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL CallLib (-1548)'OBJECT.X_II_

' OBJECT.Y Objekt,y
 ELSEIF Command$ = "OBJECT.Y" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL CallLib (-1554)'OBJECT.Y_II_

 ELSEIF Command$ = "ON" THEN

' ON BREAK GOSUB Marke
   IF FirstWord <= LastWord AND Word$(FirstWord) = "BREAK" THEN
     GOSUB SkipOneWord
     IF FirstWord > LastWord OR Word$(FirstWord) <> "GOSUB" THEN SyntaxError
     GOSUB SkipOneWord
     GOSUB DumpLabel
     CALL CallLib (-1566)'ONBREAKGOSUB_Z_

' ON COLLISION GOSUB Marke
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "COLLISION" THEN
     GOSUB SkipOneWord
     IF FirstWord > LastWord OR Word$(FirstWord) <> "GOSUB" THEN SyntaxError
     GOSUB SkipOneWord
     GOSUB DumpLabel
     CALL CallLib (-1572)'ONCOLLISIONGOSUB_Z_

' ON ERROR GOTO Marke
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "ERROR" THEN
     GOSUB SkipOneWord
     IF FirstWord > LastWord OR Word$(FirstWord) <> "GOTO" THEN SyntaxError
     GOSUB SkipOneWord
     GOSUB DumpLabel
     CALL CallLib (-1578)'ONERRORGOTO_Z_

' ON MENU GOSUB Marke
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "MENU" THEN
     GOSUB SkipOneWord
     IF FirstWord > LastWord OR Word$(FirstWord) <> "GOSUB" THEN SyntaxError
     GOSUB SkipOneWord
     GOSUB DumpLabel
     CALL CallLib (-1596)'ONMENUGOSUB_Z_

' ON MOUSE GOSUB Marke
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "MOUSE" THEN
     GOSUB SkipOneWord
     IF FirstWord > LastWord OR Word$(FirstWord) <> "GOSUB" THEN SyntaxError
     GOSUB SkipOneWord
     GOSUB DumpLabel
     CALL CallLib (-1602)'ONMOUSEGOSUB_Z_

' ON TIMER (n) GOSUB Marke
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "TIMER" THEN
     GOSUB SkipOneWord
     ExprFlags = VarINT : GOSUB DumpExpr
     IF FirstWord > LastWord OR Word$(FirstWord) <> "GOSUB" THEN SyntaxError
     GOSUB SkipOneWord
     GOSUB DumpLabel
     CALL CallLib (-1608)'ONTIMERGOSUB_IZ_

' ON ... GOSUB / GOTO Marke[,Marke]...
   ELSE
     CALL SubDumpVar ("0",VarINT+VarCONST,-1)
     ExprFlags = VarINT : GOSUB DumpExpr
     IF FirstWord > LastWord OR (Word$(FirstWord) <> "GOSUB" AND Word$(FirstWord) <> "GOTO") THEN CALL SomeError ("Expected GOTO or GOSUB",WordPos(FirstWord)) : EXIT SUB
     IsGoto = Word$(FirstWord) = "GOTO"
     GOSUB SkipOneWord
     ExpectKomma = FALSE
     WHILE FirstWord <= LastWord OR ExpectKomma = FALSE
       IF ExpectKomma THEN
         GOSUB SkipKomma
       ELSE
         ExpectKomma = TRUE
       END IF
       IF FirstWord > LastWord THEN NeedSomethingError
       CALL CouldThisBeALabel (FirstWord)
       IF Ergebnis = FALSE THEN CALL SomeError ("Expected a label",WordPos(FirstWord)) : EXIT SUB
       CALL SubDumpLabel (Word$(FirstWord))
       GOSUB SkipOneWord
       IF IsGoto THEN
         CALL CallLib (-1590)'ONGOTO_IIZ_II
       ELSE
         CALL CallLib (-1584)'ONGOSUB_IIZ_II
       END IF
     WEND
     CALL CallLib (-684)'FORGET_I_
     CALL CallLib (-684)'FORGET_I_
  END IF

' OPEN Dateinang FOR Modus1 AS Dateinr
 ELSEIF Command$ = "OPEN" THEN
   ExprFlags =  VarTEXT : GOSUB DumpExpr
   OpenModus = 0
   IF FirstWord <= LastWord AND Word$(FirstWord) = "FOR" THEN
     GOSUB SkipOneWord
     IF FirstWord <= LastWord AND Word$(FirstWord) = "OUTPUT" THEN
       GOSUB SkipOneWord
       OpenModus = 1
     ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "APPEND" THEN
       GOSUB SkipOneWord
       OpenModus = 2
     ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "INPUT" THEN
       GOSUB SkipOneWord
       OpenModus = 3
     ELSE
       GOTO SyntaxError
     END IF
   END IF
   IF FirstWord > LastWord OR Word$(FirstWord) <> "AS" THEN SyntaxError
   GOSUB SkipOneWord
   IF FirstWord <= LastWord AND Word$(FirstWord) = "#" THEN GOSUB SkipOneWord
   ExprFlags = VarINT : GOSUB DumpExpr
   IF OpenModus = 0 THEN
     CALL CallLib (-1632)'OPENREADWRITE_TI_
   ELSEIF OpenModus = 1 THEN
     CALL CallLib (-1626)'OPENOUTPUT_TI_
   ELSEIF OpenModus = 2 THEN
     CALL CallLib (-1614)'OPENAPPEND_TI_
   ELSEIF OpenModus = 3 THEN
     CALL CallLib (-1620)'OPENINPUT_TI_
   END IF

' OPTION BASE n
 ELSEIF Command$ = "OPTION" THEN
   IF FirstWord > LastWord OR Word$(FirstWord) <> "BASE" THEN SyntaxError
   GOSUB SkipOneWord
   ExprFlags = VarINT : GOSUB DumpExpr
   GOTO NotImplemented

' PAINT [STEP](x,y) [,Farbe[,Rand]]
 ELSEIF Command$ = "PAINT" THEN
   GOSUB DumpGfxPoint
   IF FirstWord <= LastWord THEN GOSUB SkipKomma
   IF FirstWord <= LastWord THEN
     ExprFlags = VarINT : GOSUB DumpExpr
   ELSE
     CALL CallLib (-720)'GETCOLOR0__I
   END IF
   IF FirstWord <= LastWord THEN GOSUB SkipKomma
   IF FirstWord <= LastWord THEN
     ExprFlags = VarINT : GOSUB DumpExpr
   ELSE
     CALL CallLib (-486)'DOUBLE_I_II
   END IF
   CALL CallLib (-1650)'PAINT_IIII_

' PALETTE Farbe,Rot,Grn,Blau
 ELSEIF Command$ = "PALETTE" THEN
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarREAL : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarREAL : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarREAL : GOSUB DumpExpr
   CALL CallLib (-1656)'PALETTE_IRRR_

' PATTERN [Lmuster][,Fmuster]
 ELSEIF Command$ = "PATTERN" THEN
   IF FirstWord <= LastWord THEN
     ExprFlags = VarLONG : GOSUB DumpExpr
     CALL CallLib (-1662)'PATTERN1_L_
   END IF
   IF FirstWord <= LastWord THEN GOSUB SkipKomma
   IF FirstWord <= LastWord THEN
     ExprFlags = VarLONG : GOSUB DumpExpr
     CALL CallLib (-1668)'PATTERN2_L_
   END IF

' POKE Adresse,m
 ELSEIF Command$ = "POKE" THEN
   ExprFlags = VarLONG : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL CallLib (-1710)'POKE_LI_

' POKEL Adresse,m
 ELSEIF Command$ = "POKEL" THEN
   ExprFlags = VarLONG : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarLONG : GOSUB DumpExpr
   CALL CallLib (-1698)'POKEL_LL_

' POKEW Adresse,m
 ELSEIF Command$ = "POKEW" THEN
   ExprFlags = VarLONG : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL CallLib (-1704)'POKEW_LI_

' PRESET [STEP] (x,y)[,Farbe]
 ELSEIF Command$ = "PRESET" THEN
   GOSUB DumpGfxPoint
   IF FirstWord <= LastWord THEN GOSUB SkipKomma
   IF FirstWord <= LastWord THEN
     ExprFlags = VarINT : GOSUB DumpExpr
   ELSE
     CALL CallLib (-720)'GETCOLOR0__I
   END IF
   CALL CallLib (-1734)'PRESET_III_

' PRINT [List von Ausdr]
 ELSEIF Command$ = "PRINT" THEN
   DoPrintToFile = FirstWord <= LastWord AND Word$(FirstWord) = "#"
   IF DoPrintToFile THEN
     GOSUB SkipOneWord
     ExprFlags = VarINT : GOSUB DumpExpr
     GOSUB SkipKomma
   END IF
   SendReturn = TRUE
   WHILE FirstWord <= LastWord
     IF Word$(FirstWord) = ";" THEN
       GOSUB SkipOneWord
       SendReturn = FALSE
     ELSEIF Word$(FirstWord) = "," THEN
       GOSUB SkipOneWord
       IF DoPrintToFile THEN
         CALL CallLib (-618)'FILEPRINTTAB_I_I
       ELSE
         CALL CallLib (-1752)'PRINTTAB__
       END IF
       SendReturn = FALSE
     ELSE
       ExprFlags = VarTEXT OR VarINT OR VarLONG OR VarREAL OR VarDOUB : GOSUB DumpExpr
       IF DoPrintToFile THEN
         IF Ergebnis = VarTEXT THEN
           CALL CallLib (-648)'FILEPRINT_IT_I
         ELSEIF Ergebnis = VarINT THEN
           CALL CallLib (-630)'FILEPRINT_II_I
         ELSEIF Ergebnis = VarLONG THEN
           CALL CallLib (-636)'FILEPRINT_IL_I
         ELSEIF Ergebnis = VarREAL THEN
           CALL CallLib (-642)'FILEPRINT_IR_I
         ELSEIF Ergebnis = VarDOUB THEN
           CALL CallLib (-624)'FILEPRINT_ID_I
         END IF
       ELSE
         IF Ergebnis = VarTEXT THEN
           CALL CallLib (-1782)'PRINT_T_
         ELSEIF Ergebnis = VarINT THEN
           CALL CallLib (-1764)'PRINT_I_
         ELSEIF Ergebnis = VarLONG THEN
           CALL CallLib (-1770)'PRINT_L_
         ELSEIF Ergebnis = VarREAL THEN
           CALL CallLib (-1776)'PRINT_R_
         ELSEIF Ergebnis = VarDOUB THEN
           CALL CallLib (-1758)'PRINT_D_
         END IF
       END IF
       SendReturn = TRUE
     END IF
   WEND
   IF SendReturn THEN
     IF DoPrintToFile THEN
       CALL CallLib (-612)'FILEPRINTRETURN_I_I
     ELSE
       CALL CallLib (-1746)'PRINTRETURN__
     END IF
   END IF
   IF DoPrintToFile THEN CALL CallLib (-684)'FORGET_I_

' PSET [STEP] (x,y)[,Farbe]
 ELSEIF Command$ = "PSET" THEN
   GOSUB DumpGfxPoint
   IF FirstWord <= LastWord THEN GOSUB SkipKomma
   IF FirstWord <= LastWord THEN
     ExprFlags = VarINT : GOSUB DumpExpr
   ELSE
     CALL CallLib (-720)'GETCOLOR0__I
   END IF
   CALL CallLib (-1788)'PSET_III_

' PUT [#]Dateinr[,Satznr]
 ELSEIF Command$ = "PUT" THEN
   GOTO NotImplemented

' RANDOMIZE [n]
 ELSEIF Command$ = "RANDOMIZE" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-1800)'RANDOMIZE__
   ELSE
     ExprFlags = VarINT : GOSUB DumpExpr
     CALL CallLib (-1794)'RANDOMIZE_I_
   END IF

' READ Var[,Var]...
 ELSEIF Command$ = "READ" THEN
   ExpectKomma = FALSE
   WHILE FirstWord <= LastWord OR ExpectKomma = FALSE
     IF ExpectKomma THEN
       GOSUB SkipKomma
     ELSE
       ExpectKomma = TRUE
     END IF
     CALL CallLib (-1806)'READ__T
     CALL GetVarEnd (FirstWord,LastWord,TRUE)
     IF Ergebnis = -1 THEN EXIT SUB
     IF WordVarFlags(FirstWord) = VarTEXT THEN
     ELSEIF WordVarFlags(FirstWord) = VarINT THEN
       CALL CallLib (-2232)'VAL_T_D
       CALL CallLib (-276)'CONVERT_D_I
     ELSEIF WordVarFlags(FirstWord) = VarLONG THEN
       CALL CallLib (-2232)'VAL_T_D
       CALL CallLib (-282)'CONVERT_D_L
     ELSEIF WordVarFlags(FirstWord) = VarREAL THEN
       CALL CallLib (-2232)'VAL_T_D
       CALL CallLib (-288)'CONVERT_D_R
     ELSEIF WordVarFlags(FirstWord) = VarDOUB THEN
       CALL CallLib (-2232)'VAL_T_D
     END IF
     StackFlags = WordVarFlags(FirstWord) : GOSUB DumpSetVar
   WEND

' REM Kommentartext
' wurde schon vorher abgefangen

' RESTORE [Marke]
 ELSEIF Command$ = "RESTORE" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-1818)'RESTORE__
   ELSE
     IF FirstWord > LastWord THEN CALL SomeError ("Expected a label",WordPos(FirstWord)) : EXIT SUB
     CALL CouldThisBeALabel (FirstWord)
     IF Ergebnis = FALSE THEN CALL SomeError ("Expected a label",WordPos(FirstWord)) : EXIT SUB
     CALL GetLabelNum (Word$(FirstWord),FALSE)
     IF Ergebnis = -1 THEN EXIT SUB
     IF Pass > 1 THEN
       a = 0
       WHILE a <= NumData AND DataLine(a) < LabelLine(Ergebnis)
         a = a+1
       WEND
       CALL SubIntToString (a)
       CALL SubDumpVar (Ergebnis$,VarINT+VarCONST,-1)
     END IF
     CALL CallLib (-1812)'RESTORE_I_
     GOSUB SkipOneWord
  END IF

' RESUME [0] / RESUME NEXT / RESUME Marke
 ELSEIF Command$ = "RESUME" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-1836)'RESUME__
   ELSE
     IF FirstWord <= LastWord AND Word$(FirstWord) = "NEXT" THEN
       GOSUB SkipOneWord
       CALL CallLib (-1824)'RESUMENEXT__
     ELSE
       GOSUB DumpLabel
       CALL CallLib (-1830)'RESUME_Z_
     END IF
   END IF

' RETURN [Marke]
 ELSEIF Command$ = "RETURN" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-1848)'RETURN__
   ELSE
     GOSUB DumpLabel
     CALL CallLib (-1842)'RETURN_Z_
   END IF

' RSET Zeichenkettenvariable = x$
 ELSEIF Command$ = "RSET" THEN
   GOTO NotImplemented

' RUN [Marke]
 ELSEIF Command$ = "RUN" THEN
   IF FirstWord > LastWord THEN
     CALL CallLib (-1878)'RUN__
   ELSE
     GOSUB DumpLabel
     CALL CallLib (-1872)'RUN_Z_
   END IF

' SAVE [Dateinangabe][,A][,P][,B]
 ELSEIF Command$ = "SAVE" THEN
   GOTO NotCompilable

' SAY Zeichenkette[,Modus]
 ELSEIF Command$ = "SAY" THEN
   GOTO NotImplemented

' SCREEN n,Breite,Höhe,Tiefe,Modus / SCREEN CLOSE n
 ELSEIF Command$ = "SCREEN" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) = "CLOSE" THEN
     GOSUB SkipOneWord
     ExprFlags = VarINT : GOSUB DumpExpr
     CALL CallLib (-1890)'SCREENCLOSE_I_
   ELSE
     ExprFlags = VarINT : GOSUB DumpExpr
     GOSUB SkipKomma
     ExprFlags = VarINT : GOSUB DumpExpr
     GOSUB SkipKomma
     ExprFlags = VarINT : GOSUB DumpExpr
     GOSUB SkipKomma
     ExprFlags = VarINT : GOSUB DumpExpr
     GOSUB SkipKomma
     ExprFlags = VarINT : GOSUB DumpExpr
     CALL CallLib (-1896)'SCREEN_IIIII_
   END IF

' SCROLL (x1,y1)-(x2,y2),deltax,deltay
 ELSEIF Command$ = "SCROLL" THEN
   GOSUB DumpGfxPoint
   IF FirstWord > LastWord OR Word$(FirstWord) <> "-" THEN SyntaxError
   GOSUB SkipOneWord
   GOSUB DumpGfxPoint
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   GOSUB SkipKomma
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL CallLib (-1902)'SCROLL_IIIIII_

' SHARED Varibale[()][,Varibale[()]]...
 ELSEIF Command$ = "SHARED" THEN
   IF SubNumber = 1 THEN CALL SomeError ("SHARED not allowed in the main program",CommandPos) : EXIT SUB
   ExpectKomma = FALSE
   WHILE FirstWord <= LastWord OR ExpectKomma = FALSE
     IF ExpectKomma THEN
       GOSUB SkipKomma
     ELSE
       ExpectKomma = TRUE
     END IF
     IF FirstWord > LastWord THEN NeedSomethingError
     IF IsVar(FirstWord) = FALSE OR (WordVarFlags(FirstWord) AND VarCONST) <> 0 THEN CALL SomeError ("Expected a variable",WordPos(FirstWord)) : EXIT SUB
     IF FirstWord < LastWord AND Word$(FirstWord+1) = "(" THEN
       CALL GetVarNum (Word$(FirstWord),WordVarFlags(FirstWord),0,0)
       GOSUB SkipOneWord
       GOSUB SkipOneWord
       IF FirstWord > LastWord OR Word$(FirstWord) <> ")" THEN CALL SomeError ("Expected ')'",WordPos(FirstWord)) : EXIT SUB
       GOSUB SkipOneWord
     ELSE
       CALL GetVarNum (Word$(FirstWord),WordVarFlags(FirstWord),-1,0)
       GOSUB SkipOneWord
     END IF
   WEND

' SLEEP
 ELSEIF Command$ = "SLEEP" THEN
   CALL CallLib (-2004)'SLEEP__

' SOUND Frequenz,Dauer[,[Laut][,Kanal]]
 ELSEIF Command$ = "SOUND" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) = "WAIT" THEN
     CALL CallLib (-2016)'SOUNDWAIT__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "RESUME" THEN
     CALL CallLib (-2010)'SOUNDRESUME__
   ELSE
     ExprFlags = VarINT : GOSUB DumpExpr
     GOSUB SkipKomma
     ExprFlags = VarINT : GOSUB DumpExpr
     IF FirstWord <= LastWord THEN GOSUB SkipKomma
     IF FirstWord <= LastWord THEN
       ExprFlags = VarINT : GOSUB DumpExpr
     ELSE
       CALL SubDumpVar ("127",VarINT+VarCONST,-1)
     END IF
     IF FirstWord <= LastWord THEN GOSUB SkipKomma
     IF FirstWord <= LastWord THEN
       ExprFlags = VarINT : GOSUB DumpExpr
     ELSE
       CALL SubDumpVar ("0",VarINT+VarCONST,-1)
     END IF
     CALL CallLib (-2022)'SOUND_IIII_
   END IF

' STOP
 ELSEIF Command$ = "STOP" THEN
   GOTO NotCompilable

' SUB Name [(Liste form. Param.)] STATIC
 ELSEIF Command$ = "SUB" THEN
   IF SubNumber <> 1 THEN CALL SomeError ("SUB within another SUB",CommandPos) : EXIT SUB
   CALL TestStack (CommandPos)
   SubCounter = SubCounter+1
   SubNumber = SubCounter
   CALL CreateLabel
   SkipSubLabel$ = Ergebnis$
   CALL CreateLabel
   LeaveSubLabel$ = Ergebnis$
   CALL SubDumpLabel (SkipSubLabel$)
   CALL CallLib (-840)'GOTO_Z_
' Auf Zeilenmarkierung testen und Sub-Nummer holen
   IF FirstWord > LastWord THEN CALL SomeError ("Expected a label",WordPos(FirstWord)) : EXIT SUB
   CALL CouldThisBeALabel (FirstWord)
   IF Ergebnis = FALSE THEN CALL SomeError ("Expected a label",WordPos(FirstWord)) : EXIT SUB
   LabelPointer = FirstWord
   GOSUB SkipOneWord
   CALL GetMySubNum (Word$(LabelPointer),TRUE)
   IF Ergebnis = -1 THEN EXIT SUB
   MySubNumber = Ergebnis
' STATIC suchen und vergessen
   FOR a = FirstWord TO LastWord
     IF Word$(a) = "STATIC" THEN FoundStatic
   NEXT a
   CALL SomeError ("STATIC missing in SUB-command",CommandPos) : EXIT SUB
 FoundStatic:
   IF a <> LastWord THEN CALL SomeError ("STATIC must be the end of the SUB-command",WordPos(a+1)) : EXIT SUB
   LastWord = LastWord-1
' ggf. Klammern entfernen
   CALL TryRemBrackets (FirstWord,LastWord)
   FirstWord = FirstWord+Ergebnis
   LastWord = LastWord-Ergebnis
' Fuer die Rueckgabe die Parameter auf dem Stack ablegen
   CALL SubSetLabel (LeaveSubLabel$)
   ExpectKomma = FALSE
   a = 0
   WHILE FirstWord <= LastWord
     IF ExpectKomma THEN
       GOSUB SkipKomma
     ELSE
       ExpectKomma = TRUE
     END IF
     ParPos(a) = FirstWord
     CALL GetVarEnd (FirstWord,LastWord,TRUE)
     IF Ergebnis = -1 THEN EXIT SUB
     EndOfVar = Ergebnis
     CALL GetExprEnd (FirstWord,LastWord)
     IF Ergebnis = -1 THEN EXIT SUB
     IF Ergebnis <> EndOfVar THEN CALL SomeError ("Expected a variable",WordPos(FirstWord)) : EXIT SUB
     ErrorPos = WordPos(FirstWord)
     ExprFlags = VarTEXT OR VarINT OR VarLONG OR VarREAL OR VarDOUB : GOSUB DumpExpr
     IF Pass = 1 THEN
       IF NumSubPars(MySubNumber) = MaxSubPars THEN CALL SomeError ("SUB: Too many parameters",ErrorPos) : EXIT SUB
       NumSubPars(MySubNumber) = NumSubPars(MySubNumber)+1
       SubParType(MySubNumber,NumSubPars(MySubNumber)) = Ergebnis
     END IF
     a = a+1
   WEND
   CALL CallLib (-510)'ENDSUB__
   CALL SubSetLabel ("_"+Word$(LabelPointer))
   IF Pass > 1 THEN
     CALL SubIntToString (SubSize(SubNumber,0))
     CALL SubDumpVar (Ergebnis$,VarINT+VarCONST,-1)
     CALL SubIntToString (SubSize(SubNumber,1))
     CALL SubDumpVar (Ergebnis$,VarINT+VarCONST,-1)
     CALL CallLib (-2106)'SUB_II_
   END IF
   FOR a = NumSubPars(MySubNumber) TO 0 STEP -1
     FirstWord = ParPos(a)
     CALL GetVarEnd (FirstWord,LastWord,FALSE)
     CALL SubDumpSetVar (FirstWord,Ergebnis,SubParType(MySubNumber,a))
     IF Ergebnis = FALSE THEN EXIT SUB
   NEXT a
   FirstWord = LastWord+1

' SWAP Var1,Var2
 ELSEIF Command$ = "SWAP" THEN
   StartPos = WordPos(FirstWord)
   VarFlags = VarTEXT OR VarINT OR VarLONG OR VarREAL OR VarDOUB : GOSUB DumpVarPointer : Pointer1 = Ergebnis
   GOSUB SkipKomma
   VarFlags = VarTEXT OR VarINT OR VarLONG OR VarREAL OR VarDOUB : GOSUB DumpVarPointer : Pointer2 = Ergebnis
   IF Pointer1 <> Pointer2 THEN
     CALL SomeError ("SWAP: variables must have exactly the same type",StartPos) : EXIT SUB
   ELSE
     IF Pointer1 = VarTEXT THEN
       CALL CallLib (-2154)'SWAP_tt_
     ELSEIF Pointer1 = VarINT THEN
       CALL CallLib (-2136)'SWAP_ii_
     ELSEIF Pointer1 = VarLONG THEN
       CALL CallLib (-2142)'SWAP_ll_
     ELSEIF Pointer1 = VarREAL THEN
       CALL CallLib (-2148)'SWAP_rr_
     ELSEIF Pointer1 = VarDOUB THEN
       CALL CallLib (-2130)'SWAP_dd_
     END IF
   END IF

' SYSTEM
 ELSEIF Command$ = "SYSTEM" THEN
   CALL CallLib (-2160)'SYSTEM__

' TIMER ON / TIMER OFF / TIMER STOP
 ELSEIF Command$ = "TIMER" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) = "ON" THEN
     GOSUB SkipOneWord
     CALL CallLib (-2184)'TIMERON__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "OFF" THEN
     GOSUB SkipOneWord
     CALL CallLib (-2178)'TIMEROFF__
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "STOP" THEN
     GOSUB SkipOneWord
     CALL CallLib (-2190)'TIMERSTOP__
   ELSE
     GOTO SyntaxError
   END IF

' TRON
 ELSEIF Command$ = "TRON" THEN
   IF IsDebugUsed THEN
     CALL CallLib (-2220)'TRON__
   END IF

' TROFF
 ELSEIF Command$ = "TROFF" THEN
   IF IsDebugUsed THEN
     CALL CallLib (-2214)'TROFF__
   END IF

' WAVE Kanal,Definition
 ELSEIF Command$ = "WAVE" THEN
   GOTO NotImplemented

' WHILE Ausdruck
 ELSEIF Command$ = "WHILE" THEN
   StackType = TypeWHILE : GOSUB Push
   CALL CreateLabel : Stack$(StackPointer,0) = Ergebnis$
   CALL CreateLabel : Stack$(StackPointer,1) = Ergebnis$
   CALL SubSetLabel (Stack$(StackPointer,0))
   IF Ergebnis = FALSE THEN EXIT SUB
   ExprFlags = VarINT : GOSUB DumpExpr
   CALL SubDumpLabel (Stack$(StackPointer,1))
   CALL CallLib (-912)'IF_IZ_

' WEND
 ELSEIF Command$ = "WEND" THEN
   StackType = TypeWHILE : GOSUB Pull
   CALL SubDumpLabel (Stack$(StackPointer+1,0))
   CALL CallLib (-840)'GOTO_Z_
   CALL SubSetLabel (Stack$(StackPointer+1,1))
   IF Ergebnis = FALSE THEN EXIT SUB

' WIDTH [LPRINT] [Breite][,Druckzone] / WIDTH #Dateinr [,Breite][,Druckzone] / WIDTH Gerät[,Breite][,Druckzone]
 ELSEIF Command$ = "WIDTH" THEN
   GOTO NotImplemented

' WINDOW Kennung [,[Titel][,[(x1,y1)-(x2,y2)][,[Typ][,Schirm]]]] / WINDOW OUTPUT Kennung / WINDOW CLOSE Kennung
 ELSEIF Command$ = "WINDOW" THEN
   IF FirstWord <= LastWord AND Word$(FirstWord) = "OUTPUT" THEN
     GOSUB SkipOneWord
     ExprFlags = VarINT : GOSUB DumpExpr
     CALL CallLib (-2244)'WINDOWOUTPUT_I_
   ELSEIF FirstWord <= LastWord AND Word$(FirstWord) = "CLOSE" THEN
     GOSUB SkipOneWord
     ExprFlags = VarINT : GOSUB DumpExpr
     CALL CallLib (-2238)'WINDOWCLOSE_I_
   ELSE
     ExprFlags = VarINT : GOSUB DumpExpr
     IF FirstWord <= LastWord THEN GOSUB SkipKomma
     IF FirstWord <= LastWord AND Word$(FirstWord) <> "," THEN
       ExprFlags = VarTEXT : GOSUB DumpExpr
     ELSE
       CALL SubDumpVar ("Cursor V1.0 (c) 1990 Jürgen Forster",VarTEXT+VarCONST,-1)
     END IF
     IF FirstWord <= LastWord THEN GOSUB SkipKomma
     IF FirstWord <= LastWord AND Word$(FirstWord) <> "," THEN
       GOSUB DumpGfxPoint
       IF FirstWord > LastWord OR Word$(FirstWord) <> "-" THEN SyntaxError
       GOSUB SkipOneWord
       GOSUB DumpGfxPoint
     ELSE
       CALL CallLib (-792)'GETWINDOWSIZE__II
     END IF
     IF FirstWord <= LastWord THEN GOSUB SkipKomma
     IF FirstWord <= LastWord AND Word$(FirstWord) <> "," THEN
       ExprFlags = VarINT : GOSUB DumpExpr
     ELSE
       CALL SubDumpVar ("15",VarINT+VarCONST,-1)
     END IF
     IF FirstWord <= LastWord THEN GOSUB SkipKomma
     IF FirstWord <= LastWord THEN
       ExprFlags = VarINT : GOSUB DumpExpr
     ELSE
       CALL SubDumpVar ("1",VarINT+VarCONST,-1)
     END IF
     CALL CallLib (-2250)'WINDOW_ITIIIIII_
   END IF

' WRITE [#Dateinr,][Liste von Ausdr]
 ELSEIF Command$ = "WRITE" THEN
   GOTO NotImplemented

 ELSE
   NotFound = NotFound+1
 END IF

 IF NotFound = 2 THEN
   CALL SomeError ("Keyword not expected here",CommandPos) : EXIT SUB
 END IF

 GOSUB CheckRest
 EXIT SUB

'************************************************************
'*                                                          *
'* Routinen, die von ähnlichen Befehlen genutzt werden      *
'*                                                          *
'************************************************************

'
' Fuer die DEFTyp-Anweisung
'

HandleDefType:
 ExpectKomma = FALSE
 WHILE FirstWord <= LastWord
   IF ExpectKomma THEN
     GOSUB SkipKomma
   ELSE
     ExpectKomma = TRUE
   END IF
   ErrorPos = WordPos(FirstWord)
   GOSUB GetCharNumber : Char1 = Ergebnis
   IF FirstWord <= LastWord AND Word$(FirstWord) = "-" THEN
     GOSUB SkipOneWord
     GOSUB GetCharNumber : Char2 = Ergebnis
   ELSE
     Char2 = Char1
   END IF
   IF Char1 > Char2 THEN
     CALL SomeError ("Source greater than target",ErrorPos) : EXIT SUB
   ELSE
     FOR a = Char1 TO Char2
       CharVarType(a) = DefType
     NEXT a
   END IF
 WEND
 RETURN

GetCharNumber:
 IF FirstWord > LastWord THEN CALL SomeError ("Expected a letter",WordPos(FirstWord)) : EXIT SUB
 IF LEN(Word$(FirstWord)) <> 1 THEN SyntaxError
 IF ASC(Word$(FirstWord)) > ASC("Z") OR ASC(Word$(FirstWord)) < ASC("A") THEN SyntaxError
 Ergebnis = ASC(Word$(FirstWord))-ASC("A")
 GOSUB SkipOneWord
 RETURN

'
' Fuer die INPUT-Anweisung
'

HandleInputLine:
 CALL CallLib (-942)'INPUT__
 ExpectKomma = FALSE
 WHILE FirstWord <= LastWord OR ExpectKomma = FALSE
   IF ExpectKomma THEN
     GOSUB SkipKomma
   ELSE
     ExpectKomma = TRUE
   END IF
   CALL CallLib (-738)'GETINPUTPART__T
   StackFlags = VarTEXT : GOSUB DumpSetVar
 WEND
 CALL CallLib (-180)'CHECKINPUTEND__
 RETURN

'************************************************************
'*                                                          *
'* Routinen zum Auswerten der Befehle                       *
'*                                                          *
'************************************************************

'
' Ein Wort ueberlesen
'

SkipOneWord:
 IF FirstWord > LastWord THEN CALL SomeError ("Expected something",WordPos(FirstWord)) : EXIT SUB
 FirstWord = FirstWord+1
 RETURN

'
' Pruefen noch etwas vorhanden ist, wenn nicht Fehlermeldung ausgeben
'

CheckRest:
 IF FirstWord <= LastWord THEN CALL SomeError ("Expected end of command",WordPos(FirstWord)) : EXIT SUB
 RETURN

'
' Einen Ausdruck auswerten. Die angeforderten Eigenschaften werden
' in ExprFlags bergeben, das tatsächliche Ergebnis steht dann in Ergebnis
'

DumpExpr:
 CALL GetExprEnd (FirstWord,LastWord)
 IF Ergebnis = -1 THEN EXIT SUB
 EndOfExpr = Ergebnis
 CALL SubDumpExpr (FirstWord,EndOfExpr,ExprFlags)
 IF Ergebnis = FALSE THEN EXIT SUB
 FirstWord = EndOfExpr+1
 RETURN

'
' Den Wert vom Stack in eine Variable schreiben
'

DumpSetVar:
 CALL GetVarEnd (FirstWord,LastWord,TRUE)
 IF Ergebnis = -1 THEN EXIT SUB
 EndOfVar = Ergebnis
 CALL SubDumpSetVar (FirstWord,EndOfVar,StackFlags)
 IF Ergebnis = FALSE THEN EXIT SUB
 FirstWord = EndOfVar+1
 RETURN

'
' Eine Zeilenmarkierung ablegen
'

DumpLabel:
 IF FirstWord > LastWord THEN CALL SomeError ("Expected a label",WordPos(FirstWord)) : EXIT SUB
 CALL CouldThisBeALabel (FirstWord)
 IF Ergebnis = FALSE THEN CALL SomeError ("Expected a label",WordPos(FirstWord)) : EXIT SUB
 CALL SubDumpLabel (Word$(FirstWord))
 GOSUB SkipOneWord
 RETURN

'
' Koordinaten eines Bildschirmpunktes ausgeben
'

DumpGfxPoint:
 GOSUB TestGfxEnd
 FoundStep = Word$(FirstWord) = "STEP"
 IF FoundStep THEN FirstWord = FirstWord+1 : GOSUB TestGfxEnd
 IF Word$(FirstWord) <> "(" THEN CALL SomeError ("Expected '('",WordPos(FirstWord)) : EXIT SUB
 GOSUB SkipOneWord
 ExprFlags = VarINT : GOSUB DumpExpr
 GOSUB SkipKomma
 ExprFlags = VarINT : GOSUB DumpExpr
 GOSUB TestGfxEnd
 IF Word$(FirstWord) <> ")" THEN CALL SomeError ("Expected ')'",WordPos(FirstWord)) : EXIT SUB
 GOSUB SkipOneWord
 IF FoundStep THEN CALL CallLib (-828)'GFXSTEP_II_II
 RETURN

TestGfxEnd:
 IF FirstWord > LastWord THEN CALL SomeError ("Expecting point-coordinates",WordPos(FirstWord)) : EXIT SUB
 RETURN

'
' Prueft auf ein Komma und ueberliest es
'

SkipKomma:
 IF FirstWord > LastWord OR Word$(FirstWord) <> "," THEN CALL SomeError ("Expected comma",WordPos(FirstWord)) : EXIT SUB
 GOSUB SkipOneWord
 RETURN

'
' Ausgabe von Fehlermeldungen
'

NeedSomethingError:
 CALL SomeError (Command$+": Expected something",WordPos(FirstWord)) : EXIT SUB

SyntaxError:
 CALL SomeError (Command$+": Syntax error",WordPos(FirstWord)) : EXIT SUB

NotCompilable:
 CALL SomeError (Command$+"-command cannot be compiled",CommandPos) : EXIT SUB

NotImplemented:
 CALL SomeError (Command$+"-command is not yet implemented",CommandPos) : EXIT SUB

'
' Prueft, ob zu einer END IF / WEND / NEXT - Anweisung eine IF / WHILE / FOR-
' Anweisung existiert
'

Push:
 IF StackPointer = MaxStack THEN CALL SomeError ("Too many IF/WHILE/FOR-commands",-1) : CALL EndPrg
 StackPointer = StackPointer+1
 StackType(StackPointer) = StackType
 StackLine(StackPointer) = ThisLine
 RETURN

Pull:
 StackError = FALSE
 IF StackPointer < 0 THEN
   StackError = TRUE
 ELSE
   IF StackType(StackPointer) <> StackType THEN
     StackError = TRUE
   END IF
 END IF
 IF StackError THEN
   IF StackType = TypeWHILE THEN
     CALL SomeError ("WEND without WHILE",-1)
   ELSEIF StackType = TypeIF THEN
     CALL SomeError ("END IF without IF",-1)
   ELSEIF StackType = TypeFOR THEN
     CALL SomeError ("NEXT without FOR",-1)
   END IF
   IF StackPointer >= 0 THEN
     IF StackType(StackPointer) = TypeWHILE THEN
       PRINT "see: WHILE-command in line";StackLine(StackPointer)
     ELSEIF StackType(StackPointer) = TypeIF THEN
       PRINT "see: IF-command in line";StackLine(StackPointer)
     ELSEIF StackType(StackPointer) = TypeFOR THEN
       PRINT "see: FOR-command in line";StackLine(StackPointer)
     END IF
   END IF
   EXIT SUB
 END IF
 StackPointer = StackPointer-1
 RETURN

'
' Prueft, ob zu einer END IF / WEND / NEXT - Anweisung eine IF / WHILE / FOR-
' Anweisung existiert
'

SkipOneVar:
 CALL GetVarEnd (FirstWord,LastWord,TRUE)
 IF Ergebnis = -1 THEN EXIT SUB
 FirstWord = Ergebnis+1
 RETURN

'
' Legt den Zeiger auf eine Variable auf dem Stack ab
'

DumpVarPointer:
 CALL GetVarEnd (FirstWord,LastWord,TRUE)
 IF Ergebnis = -1 THEN EXIT SUB
 VarEndPointer = Ergebnis
 CALL SubDumpVarPointer (FirstWord,VarEndPointer)
 IF Ergebnis = FALSE THEN EXIT SUB
 IF (Ergebnis AND VarFlags) = 0 THEN CALL SomeError ("Expected a variable with another type",WordPos(FirstWord)) : EXIT SUB
 FirstWord = VarEndPointer+1
 RETURN

'
' Legt nur den Zeiger auf ein Feld ab
'

DumpFieldPointer:
 IF FirstWord > LastWord THEN CALL SomeError ("Expected name of a field",WordPos(FirstWord)) : EXIT SUB
 CALL SubDumpSimpleVarPointer (Word$(FirstWord),WordVarFlags(FirstWord),0)
 GOTO SkipOneWord

END SUB

'************************************************************
'*                                                          *
'* Ist der Parameter eine Zeilenmarkierung?                 *
'*                                                          *
'************************************************************

SUB CouldThisBeALabel (WordNumber) STATIC
 IF IsVar(WordNumber) THEN
   IF (WordVarFlags(WordNumber) AND VarCONST) = FALSE THEN
     CALL IsKeyWord (Word$(WordNumber))
     IF Ergebnis = FALSE THEN
       Ergebnis = TRUE : EXIT SUB
     END IF
   ELSE
     FOR a = 1 TO LEN(Word$(WordNumber))
       IF INSTR(CharNumber$,MID$(Word$(WordNumber),a,1)) = 0 THEN Ergebnis = FALSE : EXIT SUB
     NEXT a
     Ergebnis = TRUE : EXIT SUB
   END IF
 END IF
 Ergebnis = FALSE
END SUB

'************************************************************
'*                                                          *
'* Fehlermeldung ausgeben                                   *
'*                                                          *
'************************************************************

SUB SomeError (Fehler$,Position) STATIC
 PRINT
 PRINT FileName$;".bas, line";ThisLine;":"
 PRINT SourceLine$
 IF Position > 0 THEN
   PRINT SPACE$(Position-1);"^"
 ELSE
   PRINT
 END IF
 PRINT Fehler$
 NumErrors = NumErrors+1
 ErrorInThisLine = TRUE
 IF Pass = 3 THEN
   PRINT : PRINT "Error in pass 3 - Aborting"
   CLOSE
   KILL FileName$
   KILL "T:Reloc32"
   CALL EndPrg
 END IF
END SUB

'************************************************************
'*                                                          *
'* Ist das Wort ein Schluesselwort?                         *
'*                                                          *
'************************************************************

SUB IsKeyWord (Word$) STATIC
 Von = 0 : Bis = NumKeyWords
 WHILE Von <= Bis
   Mitte = INT((Von+Bis)\2)
   IF KeyWord$(Mitte) > Word$ THEN
     Bis = Mitte-1
   ELSE
     IF KeyWord$(Mitte) = Word$ THEN Ergebnis = TRUE : EXIT SUB
     Von = Mitte+1
   END IF
 WEND
 Ergebnis = FALSE
END SUB

'************************************************************
'*                                                          *
'* Funktionsnummer suchen                                   *
'*                                                          *
'************************************************************

SUB GetOperatorNum (Func$) STATIC
 Von = 0 : Bis = NumFuncs
 WHILE Von <= Bis
   Mitte = INT((Von+Bis)\2)
   IF Func$(Mitte) > Func$ THEN
     Bis = Mitte-1
   ELSE
     IF Func$(Mitte) = Func$ THEN Ergebnis = Mitte : EXIT SUB
     Von = Mitte+1
   END IF
 WEND
 Ergebnis = -1
END SUB

'************************************************************
'*                                                          *
'* Welchen Typ hat der Uebergebene String?                  *
'*                                                          *
'************************************************************

SUB GetVarFlags (Var$) STATIC
 a$ = Var$
 Ergebnis = 0
 IF INSTR(CharLetter$,LEFT$(a$,1)) THEN
   IF INSTR(CharTypes$,RIGHT$(a$,1)) = 0 THEN
     Ergebnis = CharVarType(ASC(a$)-ASC("A"))
   END IF
 ELSE
   IF INSTR(CharTypes$,RIGHT$(a$,1)) = 0 THEN
     IF INSTR(a$,".") THEN
       Ergebnis = VarREAL
     ELSE
       Ergebnis = VarINT
     END IF
   END IF
   Ergebnis = Ergebnis OR VarCONST
 END IF

 IF RIGHT$(a$,1) = "$" THEN
   Ergebnis = Ergebnis OR VarTEXT
 ELSEIF RIGHT$(a$,1) = "%" THEN
   Ergebnis = Ergebnis OR VarINT
 ELSEIF RIGHT$(a$,1) = "&" THEN
   Ergebnis = Ergebnis OR VarLONG
 ELSEIF RIGHT$(a$,1) = "!" THEN
   Ergebnis = Ergebnis OR VarREAL
 ELSEIF RIGHT$(a$,1) = "#" THEN
   Ergebnis = Ergebnis OR VarDOUB
 END IF
END SUB

'************************************************************
'*                                                          *
'* Zeilenmarkierung erzeugen                                *
'*                                                          *
'************************************************************

SUB CreateLabel STATIC
 LabelCounter = LabelCounter+1
 Ergebnis$ = STR$(LabelCounter)
 Ergebnis$ = "L_"+RIGHT$(Ergebnis$,LEN(Ergebnis$)-1)
END SUB

'************************************************************
'*                                                          *
'* Gibt die Länge eines Ausdrucks zurueck                   *
'*                                                          *
'************************************************************

SUB GetExprEnd (Word1,Word2) STATIC
 FirstWord = Word1 : LastWord = Word2

 WHILE TRUE
SearchAgain:
   SearchingForExpr = TRUE
   IF FirstWord > LastWord THEN StopSearching
   IF Word$(FirstWord) = ";" THEN StopSearching
   IF Word$(FirstWord) = "," THEN StopSearching
   IF Word$(FirstWord) = ")" THEN StopSearching
   IF Word$(FirstWord) = "-" THEN FirstWord = FirstWord+1 : GOTO SearchAgain
   IF Word$(FirstWord) = "+" THEN FirstWord = FirstWord+1 : GOTO SearchAgain
   IF Word$(FirstWord) = "(" THEN
     FirstWord = FirstWord+1
     GOSUB SkipAfterBracket2
   ELSE
' haben wir einen Operator?
     IF OperatorNum(FirstWord) = -1 THEN
' jetzt mueßte eigentlich eine Variable vorhanden sein
       IF IsVar(FirstWord) = FALSE THEN CALL SomeError ("Word/Char not expected in an expression",WordPos(FirstWord)) : Ergebnis = -1 : EXIT SUB
       FirstWord = FirstWord+1
       IF FirstWord <= LastWord AND Word$(FirstWord) = "(" THEN
         FirstWord = FirstWord+1
         GOSUB SkipAfterBracket2
       END IF
     ELSE
       IF FuncType(OperatorNum(FirstWord)) = 1 THEN FirstWord = FirstWord+1 : GOTO SearchAgain
       IF FuncType(OperatorNum(FirstWord)) = 2 THEN CALL SomeError ("Dyadic operator needs two parameters",WordPos(FirstWord)) : Ergebnis = -1 : EXIT SUB
       IF FuncType(OperatorNum(FirstWord)) = 3 THEN
         FirstWord = FirstWord+1
         IF FirstWord <= LastWord AND Word$(FirstWord) = "(" THEN
           FirstWord = FirstWord+1
           GOSUB SkipAfterBracket2
         END IF
       END IF
     END IF
   END IF
' geht der Audruck noch weiter (nur bei einem dyadischen Operator)?
   SearchingForExpr = FALSE
   IF FirstWord > LastWord THEN StopSearching
   IF OperatorNum(FirstWord) = -1 THEN StopSearching
   IF FuncType(OperatorNum(FirstWord)) <> 2 THEN StopSearching
   FirstWord = FirstWord+1
 WEND

SkipAfterBracket2:
 BLevel = 2
 WHILE BLevel <> 1
   IF FirstWord > LastWord THEN CALL SomeError ("Did not find end of brackets",WordPos(FirstWord)) : Ergebnis = -1 : EXIT SUB
   IF Word$(FirstWord) = "(" THEN BLevel = BLevel+1
   IF Word$(FirstWord) = ")" THEN BLevel = BLevel-1
   FirstWord = FirstWord+1
 WEND
 RETURN

StopSearching:
 IF SearchingForExpr THEN
   CALL SomeError ("Expected expression",WordPos(FirstWord)) : Ergebnis = -1
 ELSE
   Ergebnis = FirstWord-1
 END IF
END SUB

'************************************************************
'*                                                          *
'* Prueft den Stack und gibt ggf. Fehlermeldungen aus       *
'*                                                          *
'************************************************************

SUB TestStack (FromWhere) STATIC
 IF StackPointer <> -1 THEN
   WHILE StackPointer <> -1
     IF StackType(StackPointer) = TypeWHILE THEN
       CALL SomeError ("WHILE-command in line"+STR$(StackLine(StackPointer))+" without WEND",FromWhere)
     ELSEIF StackType(StackPointer) = TypeIF THEN
       CALL SomeError ("IF-command in line"+STR$(StackLine(StackPointer))+" without END IF",FromWhere)
     ELSEIF StackType(StackPointer) = TypeFOR THEN
       CALL SomeError ("FOR-command in line"+STR$(StackLine(StackPointer))+" without NEXT",FromWhere)
     END IF
     StackPointer = StackPointer-1
   WEND
 END IF
END SUB

'************************************************************
'*                                                          *
'* String ausrechnen und Type (auf Stack) zurueckgeben      *
'*                                                          *
'************************************************************

SUB SubDumpExpr (Par1,Par2,Par3) STATIC
 FirstWord = Par1 : LastWord = Par2 : Flags = Par3

 Level = 0
 Von(Level) = FirstWord
 Bis(Level) = LastWord

 FOR a = Von(Level) TO Bis(Level)
   IF INSTR("+-",Word$(a)) THEN
     AddOrSub = TRUE
     IF a = 0 THEN
       AddOrSub = FALSE
     ELSE
       IF Word$(a-1) = "(" THEN
         AddOrSub = FALSE
       ELSEIF Word$(a-1) = "," THEN
         AddOrSub = FALSE
       ELSEIF OperatorNum(a-1) <> -1 THEN
         IF FuncType(OperatorNum(a-1)) <> 3 THEN
           AddOrSub = FALSE
         END IF
       ELSEIF IsVar(a-1) THEN
       ELSE
         CALL IsKeyWord (Word$(a-1))
         IF Ergebnis THEN AddOrSub = FALSE
       END IF
     END IF
     IF AddOrSub = FALSE THEN
       IF Word$(a) = "+" THEN
         Word$(a) = "++"
       ELSE
         Word$(a) = "--"
       END IF
       CALL GetOperatorNum (Word$(a))
       OperatorNum(a) = Ergebnis
     END IF
   END IF
 NEXT a

'
' Erste Rekursionstufe: Ergebnistypen bestimmen und verarbeiten
'

NextLevel = 1
 GOSUB GetReturnType

Level = 0
 GOSUB DumpCalculation

' letzte Konvertierung versuchen
 IF (ReturnType(0) AND Flags) = 0 THEN
   IF Flags <> VarTEXT AND Flags <> VarINT AND Flags <> VarLONG AND Flags <> VarREAL AND Flags <> VarDOUB THEN
     IF ReturnType(0) AND VarTEXT THEN
       CALL SomeError ("Cannot convert TEXT to numeric variable",WordPos(FirstWord)) : Ergebnis = FALSE : EXIT SUB
     ELSE
       NumericFlag = Flags AND (VarINT+VarLONG+VarREAL+VarDOUB)
       CALL TryConv (ReturnType(0),NumericFlag,WordPos(FirstWord))
       IF Ergebnis = FALSE THEN
         EXIT SUB
       ELSE
         Ergebnis = NumericFlag
       END IF
     END IF
   ELSE
     CALL TryConv (ReturnType(0),Flags,WordPos(FirstWord))
     IF Ergebnis = FALSE THEN
       EXIT SUB
     ELSE
       Ergebnis = Flags
     END IF
   END IF
 ELSE
   Ergebnis = ReturnType(0)
 END IF
 Ergebnis = Ergebnis AND VarTypeMask
 EXIT SUB

GetReturnType:
' initialisieren
' Von(Level)/Bis(Level) werden uebergeben
 NumPars(Level) = -1
' Noch kein Operator wurde gefunden
 FoundOperator(Level) = -1
' OldLevel ist ggf. schon gesetzt
' ReadPointer wird nur kurzzeitig benutzt
' VariateNum wird später gesetzt
' ReturnType wird zum Schluß gesetzt

' Erwarteter Parameter nicht gefunden?
 IF Von(Level) > Bis(Level) THEN
   CALL SomeError ("Expected parameter",WordPos(Von(Level))) : Ergebnis = FALSE : EXIT SUB
 END IF

 CALL TryRemBrackets (Von(Level),Bis(Level))
 Von(Level) = Von(Level)+Ergebnis
 Bis(Level) = Bis(Level)-Ergebnis
 IF Von(Level) > Bis(Level) THEN CALL SomeError ("Expected expression",WordPos(Von(Level))) : Ergebnis = FALSE : EXIT SUB

' Operator mit höchster FuncHierachie suchen
 BLevel = 0
 FOR a = Von(Level) TO Bis(Level)
   IF Word$(a) = "(" THEN
     BLevel = BLevel+1
   ELSEIF Word$(a) = ")" THEN
     BLevel = BLevel-1
     IF BLevel < 0 THEN CALL SomeError ("')' without '('",WordPos(a)) : Ergebnis = FALSE : EXIT SUB
   END IF
   IF BLevel = 0 AND OperatorNum(a) <> -1 THEN
     IF FoundOperator(Level) = -1 THEN
       FoundOperator(Level) = a
     ELSE
       IF FuncHierachie(OperatorNum(a)) => FuncHierachie(OperatorNum(FoundOperator(Level))) THEN
         FoundOperator(Level) = a
       END IF
     END IF
   END IF
 NEXT a
 IF BLevel <> 0 THEN CALL SomeError ("')' missing",WordPos(Bis(Level)+1)) : Ergebnis = FALSE : EXIT SUB
 IF FoundOperator(Level) = -1 THEN
   IF IsVar(Von(Level)) THEN
     IF Von(Level) < Bis(Level) THEN
' Nur noch ein Feld wäre sinnvoll
       IF Word$(Von(Level)+1) <> "(" THEN CALL SomeError ("Syntax error",WordPos(Von(Level)+1)) : Ergebnis = FALSE : EXIT SUB
       IF Word$(Bis(Level)) <> ")" THEN CALL SomeError ("Expected ')'",WordPos(Bis(Level))) : Ergebnis = FALSE : EXIT SUB
       IF (WordVarFlags(Von(Level)) AND VarCONST) <> 0 THEN CALL SomeError ("Expected name of a field",WordPos(Von(Level))) : Ergebnis = FALSE : EXIT SUB
       ReturnType(Level) = WordVarFlags(Von(Level))
       ReadPointer(Level) = Von(Level)+2
' Ist erste Dimension vorhanden
       IF Word$(ReadPointer(Level)) = "," THEN
         CALL SomeError ("Did not expect a comma here",WordPos(ReadPointer(Level))) : Ergebnis = FALSE : EXIT SUB
       END IF
' Schleife ueber die Dimensionen
       WHILE ReadPointer(Level) <= Bis(Level)-1
         IF Word$(ReadPointer(Level)) = "," THEN ReadPointer(Level) = ReadPointer(Level)+1
         GOSUB GetNewLevel
         Von(NewLevel) = ReadPointer(Level)
         CALL GetExprEnd (ReadPointer(Level),Bis(Level)-1)
         IF Ergebnis = -1 THEN Ergebnis = FALSE : EXIT SUB
         Bis(NewLevel) = Ergebnis
         ReadPointer(Level) = Ergebnis+1
         GOSUB AddNewLevelReturnType
         IF ReadPointer(Level) <= Bis(Level)-1 AND Word$(ReadPointer(Level)) <> "," THEN
           CALL SomeError ("Expected comma",WordPos(ReadPointer(Level))) : Ergebnis = FALSE : EXIT SUB
         END IF
       WEND
       RETURN
     ELSE
       ReturnType(Level) = WordVarFlags(Von(Level)) : RETURN
     END IF
   END IF
 END IF

 IF FoundOperator(Level) = -1 THEN CALL SomeError ("Operator missing",WordPos(Von(Level))) : Ergebnis = FALSE : EXIT SUB

' Monadischer Operator
 IF FuncType(OperatorNum(FoundOperator(Level))) = 1 THEN
   IF FoundOperator(Level) <> Von(Level) THEN CALL SomeError ("Parameter before monadic operator not allowed",WordPos(FoundOperator(Level))) : Ergebnis = FALSE : EXIT SUB
   GOSUB GetNewLevel
   Von(NewLevel) = FoundOperator(Level)+1
   Bis(NewLevel) = Bis(Level)
   GOSUB AddNewLevelReturnType
 END IF

' Dyadischer Operator
 IF FuncType(OperatorNum(FoundOperator(Level))) = 2 THEN
   GOSUB GetNewLevel
   Von(NewLevel) = Von(Level)
   Bis(NewLevel) = FoundOperator(Level)-1
   GOSUB AddNewLevelReturnType
   GOSUB GetNewLevel
   Von(NewLevel) = FoundOperator(Level)+1
   Bis(NewLevel) = Bis(Level)
   GOSUB AddNewLevelReturnType
 END IF

' Eine Funktion oder Systemvariable
 IF FuncType(OperatorNum(FoundOperator(Level))) = 3 THEN
   IF FoundOperator(Level) <> Von(Level) THEN CALL SomeError ("Parameter before function not allowed",FoundOperator(Level)) : Ergebnis = FALSE : EXIT SUB

   ReadPointer(Level) = FoundOperator(Level)+1

' sind Parameter vorhanden?
   IF ReadPointer(Level) <= Bis(Level) THEN

' Klammern entfernen
     IF Word$(ReadPointer(Level)) <> "(" THEN CALL SomeError ("Expected '('",WordPos(ReadPointer(Level))) : Ergebnis = FALSE : EXIT SUB
     ReadPointer(Level) = ReadPointer(Level)+1
     IF Word$(Bis(Level)) <> ")" THEN CALL SomeError ("Expected ')'",WordPos(Bis(Level))) : Ergebnis = FALSE : EXIT SUB
     Bis(Level) = Bis(Level)-1

' sind noch immer Parameter vorhanden?
     IF ReadPointer(Level) <= Bis(Level) THEN

' Testen, ob gleich ein Komma kommt
       IF Word$(ReadPointer(Level)) = "," THEN
         CALL SomeError ("Empty expression at the beginning of the "+Func$(Von(Level))+"-function",WordPos(ReadPointer(Level))) : Ergebnis = FALSE : EXIT SUB
       END IF

       WHILE ReadPointer(Level) <= Bis(Level)
         IF Word$(ReadPointer(Level)) = "," THEN ReadPointer(Level) = ReadPointer(Level)+1
         GOSUB GetNewLevel
         Von(NewLevel) = ReadPointer(Level)
         CALL GetExprEnd (ReadPointer(Level),Bis(Level))
         IF Ergebnis = -1 THEN Ergebnis = FALSE : EXIT SUB
         Bis(NewLevel) = Ergebnis
         ReadPointer(Level) = Ergebnis+1
         GOSUB AddNewLevelReturnType
         IF ReadPointer(Level) <= Bis(Level) AND Word$(ReadPointer(Level)) <> "," THEN
           CALL SomeError ("Expected comma",WordPos(ReadPointer(Level))) : Ergebnis = FALSE : EXIT SUB
         END IF
       WEND

' waren Parameter vorhanden?
     END IF
   END IF

 END IF

 FOR a = 0 TO NumVarianten(OperatorNum(FoundOperator(Level)))
   IF NumPars(Level) = NumParameter(OperatorNum(FoundOperator(Level)),a) THEN
     FOR b = 0 TO NumPars(Level)
       c = Possible(OperatorNum(FoundOperator(Level)),a,b)
       d = ParType(Level,b)
       IF (c AND d) = 0 THEN NotYetFound
     NEXT b
     VarianteNum(Level) = a
     GOTO FoundIt
   END IF
NotYetFound:
 NEXT a
 CALL SomeError (Func$(OperatorNum(FoundOperator(Level)))+"-function is not possible with these parameters",WordPos(FoundOperator(Level))) : Ergebnis = FALSE : EXIT SUB
FoundIt:

 ReturnType(Level) = ResultType(OperatorNum(FoundOperator(Level)),VarianteNum(Level))
 RETURN

GetNewLevel:
 IF NextLevel = MaxLevel+1 THEN CALL SomeError ("Expression to complex",-1) : Ergebnis = FALSE : EXIT SUB
 NewLevel = NextLevel
 NextLevel = NextLevel+1
 RETURN

AddNewLevelReturnType:
 OldLevel(NewLevel) = Level
 Level = NewLevel
 GOSUB GetReturnType
 NewLevel = Level
 Level = OldLevel(NewLevel)
 NumPars(Level) = NumPars(Level)+1
 ParType(Level,NumPars(Level)) = ReturnType(NewLevel)
 CallLevel(Level,NumPars(Level)) = NewLevel
 RETURN

DumpCalculation:
 IF FoundOperator(Level) <> -1 THEN
   ReadPointer(Level) = 0
   WHILE ReadPointer(Level) <= NumPars(Level)
     Level = CallLevel(Level,ReadPointer(Level))
     GOSUB DumpCalculation
     Level = OldLevel(Level)
     Flags1 = ParType(Level,ReadPointer(Level)) AND VarTypeMask
     Flags2 = MakeTo(OperatorNum(FoundOperator(Level)),VarianteNum(Level),ReadPointer(Level)) AND VarTypeMask
     CALL TryConv (Flags1,Flags2,WordPos(FoundOperator(Level)))
     IF Ergebnis = FALSE THEN EXIT SUB
     ReadPointer(Level) = ReadPointer(Level)+1
   WEND
   CALL CallLib (VariantenOffset(OperatorNum(FoundOperator(Level)),VarianteNum(Level)))
 ELSE
   IF Von(Level) = Bis(Level) THEN
     CALL SubDumpVar (Word$(Von(Level)),WordVarFlags(Von(Level)),-1)
   ELSE
     ReadPointer(Level) = 0
     WHILE ReadPointer(Level) <= NumPars(Level)
       Level = CallLevel(Level,ReadPointer(Level))
       GOSUB DumpCalculation
       CALL TryConv (ReturnType(Level),VarINT,WordPos(Von(Level)))
       IF Ergebnis = FALSE THEN EXIT SUB
       Level = OldLevel(Level)
       ReadPointer(Level) = ReadPointer(Level)+1
     WEND
     CALL SubIntToString (NumPars(Level))
     CALL SubDumpVar (Ergebnis$,VarINT+VarCONST,-1)
     CALL SubDumpSimpleVarPointer (Word$(Von(Level)),WordVarFlags(Von(Level)),NumPars(Level))
     IF WordVarFlags(Von(Level)) = VarTEXT THEN
       CALL CallLib (-786)'GETTEXTELEM_FP_T
     ELSEIF WordVarFlags(Von(Level)) = VarINT THEN
       CALL CallLib (-750)'GETINTELEM_FP_I
     ELSEIF WordVarFlags(Von(Level)) = VarLONG THEN
       CALL CallLib (-762)'GETLONGELEM_FP_L
     ELSEIF WordVarFlags(Von(Level)) = VarREAL THEN
       CALL CallLib (-774)'GETREALELEM_FP_R
     ELSEIF WordVarFlags(Von(Level)) = VarDOUB THEN
       CALL CallLib (-732)'GETDOUBELEM_FP_D
     END IF
   END IF
 END IF
 RETURN

END SUB

'************************************************************
'*                                                          *
'* Versucht, rechts und links Klammern zu entfernen         *
'*                                                          *
'************************************************************

SUB TryRemBrackets (Par1,Par2) STATIC
 FirstWord = Par1 : LastWord = Par2
 BLevel = 0
TryNextPair:
 IF FirstWord < LastWord THEN
   IF Word$(FirstWord) = "(" AND Word$(LastWord) = ")" THEN
     BLevel = BLevel+1
     FirstWord = FirstWord+1
     LastWord = LastWord-1
     GOTO TryNextPair
   END IF
 END IF
 Ergebnis = BLevel
 SafeLevel = BLevel
 FOR a = FirstWord TO LastWord
   IF Word$(a) = "(" THEN
     BLevel = BLevel+1
   ELSEIF Word$(a) = ")" THEN
     BLevel = BLevel-1
     IF BLevel < Ergebnis THEN Ergebnis = BLevel
   END IF
 NEXT a
 IF SafeLevel <> BLevel THEN Ergebnis = 0
END SUB

'************************************************************
'*                                                          *
'* Definiert ein Label an dieser Stelle                     *
'*                                                          *
'************************************************************

SUB SubSetLabel (LabelName$) STATIC
 CALL GetLabelNum (LabelName$,TRUE)
 IF Ergebnis = -1 THEN
   Ergebnis = FALSE
 ELSE
   IF Pass = 2 THEN
     LabelOffset&(Ergebnis) = HunkOffset&
   ELSEIF Pass = 3 THEN
     IF LabelOffset&(Ergebnis) <> HunkOffset& THEN CALL SomeError ("Internal error: phase error",-1)
   END IF
   Ergebnis = TRUE
 END IF
END SUB

'************************************************************
'*                                                          *
'* Legt ein Label auf dem Stack ab                          *
'*                                                          *
'************************************************************

SUB SubDumpLabel (LabelName$) STATIC
 CALL GetLabelNum (LabelName$,FALSE) : LabelNumber = Ergebnis
 IF Pass > 1 THEN
   CALL PrintToFile MKI$(18553)        ' pea Wert.l
   IF Pass = 3 THEN
     PRINT #3,MKL$(HunkOffset&);
   END IF
   CALL PrintToFile MKL$(LabelOffset&(LabelNumber))
 END IF
END SUB

SUB SubDumpOnlyLabel (LabelName$) STATIC
 CALL GetLabelNum (LabelName$,FALSE) : LabelNumber = Ergebnis
 IF Pass > 1 THEN
   IF Pass = 3 THEN
     PRINT #3,MKL$(HunkOffset&);
   END IF
   CALL PrintToFile MKL$(LabelOffset&(LabelNumber))
 END IF
END SUB

'************************************************************
'*                                                          *
'* Besorgt die Ablagenummer eines Labels                    *
'*                                                          *
'************************************************************

SUB GetLabelNum (LabelName$,IsDefinition) STATIC
 FOR a = 0 TO NumLabels
   IF Label$(a) = LabelName$ THEN LabelFound
 NEXT a
 IF NumLabels = MaxLabels THEN PRINT : PRINT "Too many labels - Aborting!" : CALL EndPrg
 NumLabels = NumLabels+1
 Label$(NumLabels) = LabelName$
 LabelLine(NumLabels) = FALSE
 a = NumLabels
LabelFound:
 IF Pass = 1 AND IsDefinition = TRUE AND LabelLine(a) <> FALSE THEN
   CALL SomeError ("Label "+LabelName$+" is already defined",-1)
   Ergebnis = -1
 ELSE
   IF IsDefinition THEN LabelLine(a) = ThisLine
   Ergebnis = a
 END IF
END SUB

'************************************************************
'*                                                          *
'* Versucht die Konvertierung von einem Typ zu einem anderen*
'*                                                          *
'************************************************************

SUB TryConv (Par1,Flags2,ErrorPos) STATIC
 Flags1 = Par1 AND VarTypeMask
 IF Flags1 <> Flags2 THEN
   FOR a = 0 TO NumConv
     IF CConvFrom(a) = Flags1 AND CConvTo(a) = Flags2 THEN CALL CallLib (CConvOffset(a)) : Ergebnis = TRUE : EXIT SUB
   NEXT a
   CALL SomeError ("Cannot convert from/to TEXT",ErrorPos) : Ergebnis = FALSE : EXIT SUB
 END IF
 Ergebnis = TRUE
END SUB

'************************************************************
'*                                                          *
'* Holt Variablennummer aus der Variablentabelle            *
'*                                                          *
'************************************************************

SUB GetVarNum (Par1$,VarFlags,VarType,VarSubNum) STATIC
 VarName$ = Par1$
' Typzeichen ggf. entfernen
 IF INSTR(CharTypes$,RIGHT$(VarName$,1)) THEN
   VarName$ = LEFT$(VarName$,LEN(VarName$)-1)
 END IF
' Variable suchen
 FOR a = 0 TO NumVars
   IF VarName$ = VarName$(a) THEN
     IF VarFlags = VarFlags(a) THEN
       IF VarSubNum = VarSubNum(a) OR VarSubNum(a) = 0 OR VarSubNum = 0 THEN
         IF VarType = VarType(a) OR (VarType >= 0 AND VarType(a) >= 0) THEN FoundThisVar
       END IF
     END IF
   END IF
 NEXT a
 IF NumVars = MaxVars THEN PRINT : PRINT "Too many variables - Aborting!" : CALL EndPrg
 NumVars = NumVars+1
 VarName$(NumVars) = VarName$
 VarFlags(NumVars) = VarFlags
 VarType(NumVars) = VarType
 VarSubNum(NumVars) = VarSubNum
 a = NumVars
FoundThisVar:
' ggf. Type und SubNum korrigieren
 IF VarType(a) >= 0 AND VarType > VarType(a) THEN VarType(a) = VarType
 IF VarSubNum = 0 THEN VarSubNum(a) = 0
 Ergebnis = a
END SUB

'************************************************************
'*                                                          *
'* Das Ende einer Variablen suchen                          *
'*                                                          *
'************************************************************

SUB GetVarEnd (Word1,Word2,PrintErrors) STATIC
 FirstWord = Word1 : LastWord = Word2
 IF FirstWord > LastWord THEN VarLengthError
 IF IsVar(FirstWord) = FALSE THEN VarLengthError
 IF WordVarFlags(FirstWord) AND VarCONST THEN VarLengthError
 IF FirstWord = LastWord THEN
   Ergebnis = FirstWord : EXIT SUB
 ELSE
   IF Word$(FirstWord+1) = "(" THEN
     Ergebnis = FirstWord+1
     BLevel = 1
     WHILE BLevel <> 0
       Ergebnis = Ergebnis+1
       IF Ergebnis > LastWord THEN
         IF PrintErrors THEN CALL SomeError ("')' missing",WordPos(Ergebnis))
         Ergebnis = -1 : EXIT SUB
       END IF
       IF Word$(Ergebnis) = ")" THEN BLevel = BLevel-1
       IF Word$(Ergebnis) = "(" THEN BLevel = BLevel+1
     WEND
     EXIT SUB
   ELSE
     Ergebnis = FirstWord : EXIT SUB
   END IF
 END IF

VarLengthError:
 IF PrintErrors THEN CALL SomeError ("Expected a variable",WordPos(FirstWord))
 Ergebnis = -1 : EXIT SUB
END SUB

'************************************************************
'*                                                          *
'* Zuweisung zu einer Variablen                             *
'*                                                          *
'************************************************************

' GetVarEnd wurde schon durchgefuehrt
SUB SubDumpSetVar (Word1,Word2,Par3) STATIC
 FirstWord = Word1 : LastWord = Word2 : StackFlags = (Par3 AND VarTypeMask)
 IF WordVarFlags(FirstWord) <> StackFlags THEN
   CALL TryConv (StackFlags,WordVarFlags(FirstWord),WordPos(FirstWord))
   IF Ergebnis = FALSE THEN EXIT SUB
 END IF
 IF FirstWord = LastWord THEN
   CALL SubDumpSetSimpleVar (Word$(FirstWord),WordVarFlags(FirstWord),-1)
 ELSE
   CALL SubDumpField (FirstWord,LastWord)
   IF Ergebnis = FALSE THEN EXIT SUB
   SafeErgebnis = Ergebnis
   IF Ergebnis = VarTEXT THEN
     CALL CallLib (-1962)'SETTEXTELEM_TFP_
   ELSEIF Ergebnis = VarINT THEN
     CALL CallLib (-1914)'SETINTELEM_IFP_
   ELSEIF Ergebnis = VarLONG THEN
     CALL CallLib (-1926)'SETLONGELEM_LFP_
   ELSEIF Ergebnis = VarREAL THEN
     CALL CallLib (-1950)'SETREALELEM_RFP_
   ELSEIF Ergebnis = VarDOUB THEN
     CALL CallLib (-1908)'SETDOUBELEM_DFP_
   END IF
   Ergebnis = SafeErgebnis
 END IF
END SUB

'************************************************************
'*                                                          *
'* Zeiger auf eine Variable ausgeben                        *
'*                                                          *
'************************************************************

SUB SubDumpVarPointer (Word1,Word2) STATIC
' Vorher wurde GetVarEnd aufgerufen, d.h. die Parameter sind in Ordnung
 FirstWord = Word1 : LastWord = Word2
 IF FirstWord = LastWord THEN
   CALL SubDumpSimpleVarPointer (Word$(FirstWord),WordVarFlags(FirstWord),-1)
   Ergebnis = WordVarFlags(FirstWord)
 ELSE
   CALL SubDumpField (FirstWord,LastWord)
   IF Ergebnis = FALSE THEN EXIT SUB
   SafeErgebnis = Ergebnis
   IF Ergebnis = VarTEXT THEN
     CALL CallLib (-780)'GETTEXTELEMPOINTER_FP_L
   ELSEIF Ergebnis = VarINT THEN
     CALL CallLib (-744)'GETINTELEMPOINTER_FP_L
   ELSEIF Ergebnis = VarLONG THEN
     CALL CallLib (-756)'GETLONGELEMPOINTER_FP_L
   ELSEIF Ergebnis = VarREAL THEN
     CALL CallLib (-768)'GETREALELEMPOINTER_FP_L
   ELSEIF Ergebnis = VarDOUB THEN
     CALL CallLib (-726)'GETDOUBELEMPOINTER_FP_L
   END IF
   Ergebnis = SafeErgebnis
 END IF
END SUB

'************************************************************
'*                                                          *
'* Ein ganzes Feld ablegen                                  *
'*                                                          *
'************************************************************

' GetVarEnd wurde schon aufgerufen
SUB SubDumpField (Par1,Par2) STATIC
 FirstWord = Par1 : LastWord = Par2
 FieldNamePointer = FirstWord
' F dumpen
 NumberOfFields = -1
 FirstWord = FirstWord+2
 LastWord = LastWord-1
 ExpectKomma = FALSE
 WHILE FirstWord <= LastWord OR ExpectKomma = FALSE
   IF ExpectKomma THEN
     IF Word$(FirstWord) <> "," THEN CALL SomeError ("Expected ','",WordPos(FirstWord)) : Ergebnis = FALSE : EXIT SUB
     FirstWord = FirstWord+1
   ELSE
     ExpectKomma = TRUE
   END IF
   NumberOfFields = NumberOfFields+1
   CALL GetExprEnd (FirstWord,LastWord)
   IF Ergebnis = -1 THEN Ergebnis = FALSE : EXIT SUB
   EndOfExpr = Ergebnis
   CALL SubDumpExpr (FirstWord,EndOfExpr,VarINT)
   IF Ergebnis = FALSE THEN EXIT SUB
   FirstWord = EndOfExpr+1
 WEND
' Anzahl dumpen
 CALL SubIntToString (NumberOfFields)
 CALL SubDumpVar (Ergebnis$,VarINT+VarCONST,-1)
' P dumpen
 CALL SubDumpSimpleVarPointer (Word$(FieldNamePointer),WordVarFlags(FieldNamePointer),NumberOfFields)
 Ergebnis = WordVarFlags(FieldNamePointer)
END SUB

'************************************************************
'*                                                          *
'* Zeiger auf Variable auf dem Stack ablegen                *
'*                                                          *
'************************************************************

SUB SubDumpSimpleVarPointer (VarName$,VarFlags,VarType) STATIC
 CALL GetVarNum (VarName$,VarFlags,VarType,SubNumber) : VarNumber = Ergebnis
 IF Pass > 1 THEN
   IF VarSubNum(VarNumber) <> 0 THEN
     CALL PrintToFile MKI$(18540)      ' pea Offset(a4)
   ELSE
     CALL PrintToFile MKI$(18541)      ' pea Offset(a5)
   END IF
   CALL PrintToFile MKI$(VarOffset(VarNumber))
 END IF
END SUB

'************************************************************
'*                                                          *
'* Variable auf dem Stack ablegen                           *
'*                                                          *
'************************************************************

SUB SubDumpVar (VarName$,VarFlags,VarType) STATIC
 IF VarFlags AND VarCONST THEN
   IF VarFlags AND VarTEXT THEN
     CALL SubGetStringOffset (RIGHT$(VarName$,LEN(VarName$)-1)) : StringOffset = Ergebnis
     IF Pass > 1 THEN
       CALL PrintToFile MKI$(18541)    ' pea Offset(a5)
       CALL PrintToFile MKI$(StringOffset)
     END IF
   ELSEIF VarFlags AND VarINT  THEN
     IF Pass > 1 THEN
       CALL PrintToFile MKI$(16188)    ' move.w #Wert,-(sp)
       CALL PrintToFile MKI$(VAL(VarName$))
     END IF
   ELSEIF VarFlags AND VarLONG THEN
     IF Pass > 1 THEN
       CALL PrintToFile MKI$(18553)    ' pea Wert.l
       CALL PrintToFile MKL$(VAL(VarName$))
     END IF
   ELSEIF VarFlags AND VarREAL THEN
     IF Pass > 1 THEN
       CALL PrintToFile MKI$(18553)    ' pea Wert.l
       CALL PrintToFile MKS$(VAL(VarName$))
     END IF
   ELSEIF VarFlags AND VarDOUB THEN
     IF Pass > 1 THEN
       CALL PrintToFile MKI$(18553)    ' pea Wert.l
       CALL PrintToFile RIGHT$(MKD$(VAL(VarName$)),4)
       CALL PrintToFile MKI$(18553)    ' pea Wert.l
       CALL PrintToFile LEFT$(MKD$(VAL(VarName$)),4)
     END IF
   END IF
 ELSE
   CALL GetVarNum (VarName$,VarFlags,VarType,SubNumber) : VarNumber = Ergebnis
   IF Pass > 1 THEN
     IF VarFlags AND VarTEXT THEN
       IF VarSubNum(VarNumber) <> 0 THEN
         CALL PrintToFile MKI$(18540)  ' pea Offset(a4)
       ELSE
         CALL PrintToFile MKI$(18541)  ' pea Offset(a5)
       END IF
       CALL PrintToFile MKI$(VarOffset(VarNumber))
     ELSEIF VarFlags AND VarINT  THEN
       IF VarSubNum(VarNumber) <> 0 THEN
         CALL PrintToFile MKI$(16172)  ' move.w Offset(a4),-(sp)
       ELSE
         CALL PrintToFile MKI$(16173)  ' move.w Offset(a5),-(sp)
       END IF
       CALL PrintToFile MKI$(VarOffset(VarNumber))
     ELSEIF VarFlags AND VarLONG THEN
       IF VarSubNum(VarNumber) <> 0 THEN
         CALL PrintToFile MKI$(12076)  ' move.l Offset(a4),-(sp)
       ELSE
         CALL PrintToFile MKI$(12077)  ' move.l Offset(a5),-(sp)
       END IF
       CALL PrintToFile MKI$(VarOffset(VarNumber))
     ELSEIF VarFlags AND VarREAL THEN
       IF VarSubNum(VarNumber) <> 0 THEN
         CALL PrintToFile MKI$(12076)  ' move.l Offset(a4),-(sp)
       ELSE
         CALL PrintToFile MKI$(12077)  ' move.l Offset(a5),-(sp)
       END IF
       CALL PrintToFile MKI$(VarOffset(VarNumber))
     ELSEIF VarFlags AND VarDOUB THEN
       IF VarSubNum(VarNumber) <> 0 THEN
         CALL PrintToFile MKI$(19692)  ' movem.l Offset(a4),RegList
       ELSE
         CALL PrintToFile MKI$(19693)  ' movem.l Offset(a5),RegList
       END IF
       CALL PrintToFile MKI$(3)        ' d0/d1 Muß zuerst kommen
       CALL PrintToFile MKI$(VarOffset(VarNumber))
       CALL PrintToFile MKI$(12033)    ' move.l d1,-(sp)
       CALL PrintToFile MKI$(12032)    ' move.l d0,-(sp)
     END IF
   END IF
 END IF
END SUB

'************************************************************
'*                                                          *
'* Variable auf dem Stack ablegen                           *
'*                                                          *
'************************************************************

' VarName$ darf keine Konstante sein
SUB SubDumpSetSimpleVar (VarName$,VarFlags,VarType) STATIC
 CALL GetVarNum (VarName$,VarFlags,VarType,SubNumber) : VarNumber = Ergebnis
 IF Pass > 1 THEN
   IF VarFlags = VarTEXT THEN
     CALL PrintToFile MKI$(8287)       ' move.l (sp)+,a0
     IF VarSubNum(VarNumber) <> 0 THEN
       CALL PrintToFile MKI$(10576)    ' move.l (a0),Offset(a4)
     ELSE
       CALL PrintToFile MKI$(11088)    ' move.l (a0),Offset(a5)
     END IF
     CALL PrintToFile MKI$(VarOffset(VarNumber))
   ELSEIF VarFlags = VarINT  THEN
     IF VarSubNum(VarNumber) <> 0 THEN
       CALL PrintToFile MKI$(14687)    ' move.w (sp)+,Offset(a4)
     ELSE
       CALL PrintToFile MKI$(15199)    ' move.w (sp)+,Offset(a5)
     END IF
     CALL PrintToFile MKI$(VarOffset(VarNumber))
   ELSEIF VarFlags = VarLONG THEN
     IF VarSubNum(VarNumber) <> 0 THEN
       CALL PrintToFile MKI$(10591)    ' move.w (sp)+,Offset(a4)
     ELSE
       CALL PrintToFile MKI$(11103)    ' move.w (sp)+,Offset(a5)
     END IF
     CALL PrintToFile MKI$(VarOffset(VarNumber))
   ELSEIF VarFlags = VarREAL THEN
     IF VarSubNum(VarNumber) <> 0 THEN
       CALL PrintToFile MKI$(10591)    ' move.w (sp)+,Offset(a4)
     ELSE
       CALL PrintToFile MKI$(11103)    ' move.w (sp)+,Offset(a5)
     END IF
     CALL PrintToFile MKI$(VarOffset(VarNumber))
   ELSEIF VarFlags = VarDOUB THEN
     CALL PrintToFile MKI$(8223)       ' move.l (sp)+,d0
     CALL PrintToFile MKI$(8735)       ' move.l (sp)+,d1
     IF VarSubNum(VarNumber) <> 0 THEN
       CALL PrintToFile MKI$(18668)    ' movem.l RegList,Offset(a4)
     ELSE
       CALL PrintToFile MKI$(18669)    ' movem.l RegList,Offset(a5)
     END IF
     CALL PrintToFile MKI$(3)          ' d0/d1
     CALL PrintToFile MKI$(VarOffset(VarNumber))
   END IF
 END IF
 Ergebnis = TRUE
END SUB

'************************************************************
'*                                                          *
'* Libraryaufruf                                            *
'*                                                          *
'************************************************************

SUB CallLib (FuncOffset) STATIC
 IF FuncOffset <> 0 THEN
   IF Pass > 1 THEN
     CALL PrintToFile MKI$(20142)     ' jsr Offset(a6)
     CALL PrintToFile MKI$(FuncOffset)
   END IF
 END IF
END SUB

'************************************************************
'*                                                          *
'* String in Ausgabefile schreiben                          *
'*                                                          *
'************************************************************

SUB PrintToFile (PrintVar$) STATIC
 IF Pass = 3 THEN
   PRINT #2,PrintVar$;
 END IF
 HunkOffset& = HunkOffset&+LEN(PrintVar$)
END SUB

'************************************************************
'*                                                          *
'* Stringnummer zurueckgeben                                *
'*                                                          *
'************************************************************

SUB SubGetStringOffset (SConst$) STATIC
 Von = 0 : Bis = NumStrings+1
 WHILE Von < Bis
   Mitte = (Von+Bis)\2
   IF SConst$ > SString$(Mitte) THEN
     Von = Mitte+1
   ELSE
     Bis = Mitte
   END IF
 WEND
 IF Von <= NumStrings THEN
   AddNewOne = SString$(Von) <> SConst$
 ELSE
   AddNewOne = TRUE
 END IF
 IF AddNewOne THEN
   IF NumStrings = MaxStrings THEN PRINT : PRINT "Too many strings - Aborting!" : CALL EndPrg
   FOR a = NumStrings TO Von STEP -1
     SString$(a+1) = SString$(a)
   NEXT a
   NumStrings = NumStrings+1
   SString$(Von) = SConst$
 END IF
 IF Pass > 1 THEN
   Ergebnis = 0-StringBase-NumStrings*4-4+Von*4
 ELSE
   Ergebnis = FALSE
 END IF
END SUB

'************************************************************
'*                                                          *
'* Fuehrendes Leerzeichen entfernen                         *
'*                                                          *
'************************************************************

SUB SubIntToString (IntNum) STATIC
 Ergebnis$ = STR$(IntNum)
 IF IntNum >= 0 THEN
   Ergebnis$ = RIGHT$(Ergebnis$,LEN(Ergebnis$)-1)
 END IF
END SUB

'************************************************************
'*                                                          *
'* Einen Data-String ablegen                                *
'*                                                          *
'************************************************************

SUB AddData (ToAdd$) STATIC
 IF Pass = 1 THEN
   CALL SubGetStringOffset (ToAdd$)
   IF NumData = MaxData THEN PRINT : PRINT "Too many DATAs. Aborting!" : CALL EndPrg
   NumData = NumData+1
   DataLine(NumData) = ThisLine
 END IF
 IF Pass = 2 THEN
   CALL SubGetStringOffset (ToAdd$)
   NumDataPass2 = NumDataPass2+1
   DataStringOffset(NumDataPass2) = Ergebnis
 END IF
 Ergebnis = TRUE
END SUB

'************************************************************
'*                                                          *
'* Besorgt die Nummer eines Unterprogramms                  *
'*                                                          *
'************************************************************

SUB GetMySubNum (SubName$,IsDefinition) STATIC
 FOR a = 0 TO NumSubs
   IF SubName$ = SubName$(a) THEN FoundMySub
 NEXT a
 IF NumSubs = MaxSubs THEN PRINT : PRINT "Too many subprograms - Aborting!" : CALL EndPrg
 NumSubs = NumSubs+1
 SubName$(NumSubs) = SubName$
 NumSubPars(NumSubs) = -1
 IsSubDef(NumSubs) = FALSE
 a = NumSubs
FoundMySub:
 IF IsDefinition THEN
   IF IsSubDef(NumSubs) AND Pass = 1 THEN
     CALL SomeError ("Subprogram is already defined",-1)
   ELSE
     IsSubDef(NumSubs) = TRUE
   END IF
 ELSE
   IF IsSubDef(NumSubs) = FALSE AND Pass > 1 THEN CALL SomeError ("Subprogram ist not defined",-1) : Ergebnis = -1 : EXIT SUB
 END IF
 Ergebnis = a
END SUB

'************************************************************
'*                                                          *
'* Programm beenden                                         *
'*                                                          *
'************************************************************

SUB EndPrg STATIC
 BEEP
 PRINT
 PRINT "Press any key..."
 WHILE INKEY$ = ""
 WEND
 END
END SUB