Unit FCUtils

*************************************************************} { } { Formula Compiler Pack for Delphi ( 16 & 32-bit ) ver 3.0 } { } { Copyright (c) 1996, 1997 Dimak & Vlad.S } { } { e-mail: dimak@uniyar.ac.ru & vlads@uniyar.ac.ru } { } {

Classes

TArray - TArray class } { array of items which size is FItemSize } { TArray holds items in on chunk of memory, can be } { used to hold record, integers, .
TCodeArray - TCodeArray - this class is used to hold machine code
TIntArray - TIntArray -- array of integer
TInternalExprArray - TInternalExprArray - internal representation of expression to be compiled

Functions

Arguments - Getting arguments count

Get number of arguments in S , Lib - user aliases library
ContainsIdent - Check if a Source contains identifier Ident

Check if a Source contains identifier Ident
MakeInternalExpr - Makes InternalExpr } { S - expression to compile, InternalExpr - internal representation } { NameList - list of unknown names (funtions which are not defined in the } { library Lib

Parse S and put its internal representation into InternalExpr
MakeItem - Makes TInternalExprItem
MakePostfix - Makes RPN from InternalExpr } { Produces Reverse Polish Notation of InternalExpr and put it into Postfix

Makes RPN from InternalExpr and put it to Postfix } { It is a modification of well known algorithm to convert usual expression } { to Reverse Polish Notaton (RPN)
Optimize - Optimize InternalExpr } { Performs some optimization procedures : convert unary '-' .
ValidBIFName - Checks the validity of function or constant name given in S

Checks the validity of function or constant name given in S } { Merely look up for S in the BuiltInFuncs
ValidLogicOpName - Checks the validity of logic operator given in S

Checks the validity of logic operator given in S } { Merely look up for S in the BuiltInOperators

Types

TBIFArgs
TBIFCode
TBIFD
TBIFName
TInternalExprItem
TLogicOp
TLogicOpCode
TLogicOpName

Constants

aArray
aCapacity
aIndex
ArgumentMarker
ArgumentSeparator
aTypecast
BIFCount
BuiltInFuncs
BuiltInOperators
DecimalSeparator
FCCheck
fcInternal
fcInvalidId
fcOk
fcReservedId
fcUnknownFunc
fcUnknownVar
fcUsedName
Letters
LogicOpCount
MaxArraySize
Numbers
Operations
Operators
UserFuncBase

Variables


Functions


function Arguments(const S: String; Lib: TFormulaLib): Integer;

Getting arguments count

Get number of arguments in S , Lib - user aliases library


function ContainsIdent(const Source, Ident: String): Integer;

Check if a Source contains identifier Ident

Check if a Source contains identifier Ident


function MakeInternalExpr(S: String; InternalExpr: TInternalExprArray; NameList: TStringList; Lib: TFormulaLib): Integer;

Makes InternalExpr } { S - expression to compile, InternalExpr - internal representation } { NameList - list of unknown names (funtions which are not defined in the } { library Lib

Parse S and put its internal representation into InternalExpr


function MakeItem(AElem: Char; AID: Integer; ACnst: Extended): TInternalExprItem;

Makes TInternalExprItem

procedure MakePostfix(InternalExpr, Postfix: TInternalExprArray);

Makes RPN from InternalExpr } { Produces Reverse Polish Notation of InternalExpr and put it into Postfix

Makes RPN from InternalExpr and put it to Postfix } { It is a modification of well known algorithm to convert usual expression } { to Reverse Polish Notaton (RPN)


procedure Optimize(InternalExpr: TInternalExprArray);

Optimize InternalExpr } { Performs some optimization procedures : convert unary '-' ...

Valid - logical value means whether formula is valid or not


function ValidBIFName(const S: String): Integer;

Checks the validity of function or constant name given in S

Checks the validity of function or constant name given in S } { Merely look up for S in the BuiltInFuncs


function ValidLogicOpName(const S: String): Integer;

Checks the validity of logic operator given in S

Checks the validity of logic operator given in S } { Merely look up for S in the BuiltInOperators


Types


TBIFArgs = -1..3
function code
TBIFCode = PChar
functon name
TBIFD = record
Name : TBIFName;
Args : TBIFArgs;
Code : TBIFCode;
end;
number of arguments
TBIFName = String[7]
Built in Functions and Constants
TInternalExprItem = record
Elem : Char;
ID : Integer;
Cnst : Extended;
end;
TInternalItem holds different elements of expression
TLogicOp = record
Name : TLogicOpName;
Code : TLogicOpCode;
end;
machine code
TLogicOpCode = PChar
examples <>, <=, ...
TLogicOpName = String[2]
Built-in logic operators

Constants

aArray = fcInternal - 10

aCapacity = aArray - 3

aIndex = aArray - 1

ArgumentMarker = '%'

ArgumentSeparator = ','

aTypecast = aArray - 2

BIFCount = 38

array of available built-in functions and their machine code } { Structure of Code: } { First byte: Code length } { .... : FPU code } { Note: 16 and 32 bit code is different in some cases

BuiltInFuncs = ( {*}(Name:'CHS'; Args: 1; Code: #$02#$D9#$E0), { FCHS (D9E0) } {*}(Name:'ZERO'; Args: 0; Code: #$02#$D9#$EE), { FLDZ (D9EE) } {*}(Name:'ONE'; Args: 0; Code: #$02#$D9#$E8), { FLD1 (D9E8) } {*}(Name:'PI'; Args: 0; Code: #$02#$D9#$EB), { FLDPI (D9EB) } {*}(Name:'LN2'; Args: 0; Code: #$02#$D9#$ED), { FLDLN2 (D9ED) } {$IFDEF WIN32} {*}(Name:'NOT'; Args: 1; Code: #$12#$50#$D9#$E4#$DF#$E0#$DD#$D8#$9B#$9E#$74#$04 + #$D9#$EE#$EB#$02#$D9#$E8#$58), { PUSH ax (50); FTST (D9E4); FNSTSW ax (DFE0); FSTP st(0) (DDD8); FWAIT (9B); { SAHF (9E); JE (7404); FLDZ (D9EE); JMP (EB02), FLD1 (D9E8); POP ax (58) } {*}(Name:'POW'; Args: 2; Code: #$14#$D9#$F1#$D9#$C0#$D9#$FC + #$D9#$C9#$D8#$E1#$D9#$F0#$D9#$E8 + #$DE#$C1#$D9#$FD#$DD#$D9), { FYL2X (D9F1); FLD ST(0) (D9C0); FRNDINT (D9FC) } { FXCH (D9C9); FSUB ST,ST(1) (D8E1); F2XM1 (D9F0); FLD1 (D9E8); } { FADDP ST(1),ST(0) (DEC1); FSCALE (D9FD); FSTP ST(1) (DDD9); } { }(Name:'SIN'; Args: 1; Code: #$02#$D9#$FE), { FSIN (D9FE) } { }(Name:'COS'; Args: 1; Code: #$02#$D9#$FF), { FCOS (D9FF) } { }(Name:'TAN'; Args: 1; Code: #$04#$D9#$F2#$DD#$D8), { FPTAN (D9F2); FSTP ST(0) (DDD8) } { }(Name:'COTAN'; Args: 1; Code: #$04#$D9#$F2#$DE#$F1), { FPTAN (D9F2); FDIVRP (DEF1) } { }(Name:'ATAN'; Args: 1; Code: #$04#$D9#$E8#$D9#$F3), { FLD1 (D9E8); FPATAN (D9F3) } { }(Name:'ACOS'; Args: 1; Code: #$0E#$D9#$C0#$D8#$C8#$D9#$E8#$DE#$E1 + #$D9#$FA#$D9#$C9#$D9#$F3), { FLD ST(0) (D9C0); FMUL ST(0), ST (D8C8); FLD1 (D9E8); } { FSUBRP ST(1), ST (DEE1); FSQRT (D9FA); FXCH (D9C9); FPATAN (D9F3); } { }(Name:'ASIN'; Args: 1; Code: #$0C#$D9#$C0#$D8#$C8#$D9#$E8#$DE#$E1 + #$D9#$FA#$D9#$F3), { FLD ST(0) (D9C0); FMUL ST(0), ST (D8C8); FLD1 (D9E8); } { FSUBRP ST(1), ST (DEE1); FSQRT (D9FA); FPATAN (D9F3); } { }(Name:'ABS'; Args: 1; Code: #$02#$D9#$E1), { }(Name:'SQRT'; Args: 1; Code: #$02#$D9#$FA), { }(Name:'EXP'; Args: 1; Code: #$16#$D9#$EA#$DE#$C9#$D9#$C0#$D9#$FC + #$D9#$C9#$D8#$E1#$D9#$F0#$D9#$E8 + #$DE#$C1#$D9#$FD#$DD#$D9), { FLDL2E (D9EA); FMULP ST(1),ST(0) (DEC9); FLD ST(0) (D9C0); } { FRNDINT (D9FC); FXCH (D9C9); FSUB ST,ST(1) (D8E1) } { F2XM1 (D9F0); FLD1 (D9E8); FADDP ST(1),ST(0) (DEC1); } { FSCALE (D9FD); FSTP ST(1) (DDD9); } { }(Name:'LN'; Args: 1;Code: #$06#$D9#$ED#$D9#$C9#$D9#$F1), { FLDLN2 (D9ED); FXCH ST(1) (D9C9); FYL2X (D9F1) } { }(Name:'LG'; Args: 1;Code: #$06#$D9#$EC#$D9#$C9#$D9#$F1), { FLDLG2 (D9ED); FXCH ST(1) (D9C9); FYL2X (D9F1) } {$IFDEF WIN32} { }(Name:'INT';Args: 1; Code: #$17#$D9#$7C#$24#$FC#$9B#$66#$C7#$44#$24 + #$F8#$32#$1F#$D9#$6C#$24#$F8#$D9#$FC + #$9B#$D9#$6C#$24#$FC), { FSTCW mem0 (D97C24FC); FWAIT (9B); } { MOV mem2, $1F32 (66C74424F8321F); FLDCW mem2 (D96C24F8); } { FRNDINT (D9FC); FWAIT (9B); FLDCW mem0 (D96C24FC) } { }(Name:'FRAC';Args: 1; Code: #$1B#$D9#$C0#$D9#$7C#$24#$FC#$9B + #$66#$C7#$44#$24#$F8#$32#$1F + #$D9#$6C#$24#$F8#$D9#$FC#$9B + #$D9#$6C#$24#$FC#$DE#$E9), { FLD ST(0) (D9C0); FSTCW mem0 (D97C24FC); FWAIT (9B); } { MOV mem2, $1F32 (66C74424F8321F); } { FLDCW mem2 (D96C24F8); FRNDINT (D9FC); FWAIT (9B); } { FLDCW mem0 (D96C24FC) FSUBP st(0),st(1) (DEE9); } { }(Name:'SQR'; Args: 1; Code: #$02#$D8#$C8), { }(Name:'CUBE'; Args: 1; Code: #$06#$D9#$C0#$D8#$C8#$DE#$C9), {$IFDEF WIN32} { }(Name:'ROUND';Args: 1; Code: #$08#$DB#$5C#$24#$FC#$DB#$44#$24#$FC), { FISTP mem0 (DB5C24FC); FILD mem0 (DB4424FC); } {$IFDEF WIN32} { }(Name:'IIF'; Args: 3; Code: #$10#$50#$D9#$E4#$DF#$E0#$9B#$9E#$74#$04 + #$D9#$C9#$D9#$CA#$DE#$D9#$58), { PUSH ax (50); FTST (D9E4); FNSTSW ax (DFE0); FWAIT (9B); SAHF (9E); } { JE @CONT (7704); FXCH ST(1) (D9C9); FXCH ST(2) (D9CA); } { @CONT: FCOMPP (DED9); POP ax (58) } { }(Name:'SIGN'; Args: 1; Code: #$18#$50#$D9#$E4#$DF#$E0#$9B#$9E#$74#$08 + #$D9#$E8#$77#$06#$D9#$E0#$EB#$02#$D9#$EE + #$D9#$C9#$D8#$D9#$58), { PUSH ax (50); FTST (D9E4); FNSTSW AX (DFE0); FWAIT (9B); SAHF (9E); } { JE @EQZERO (7408); FLD1 (D9E8); JA @EXIT (7706); FCHS (D9E0); } { JMP @EXIT (EB02); @EQZERO: FLDZ (D9EE); @MYEXIT: FXCH ST(1) (D9C9); } { FCOMP ST(1) (D8D9); POP ax (58) } {$IFDEF WIN32} (Name:'FACT'; Args: 1; Code: #$26#$D9#$E1#$D9#$FC#$DB#$54#$24#$FC#$8B#$4C + #$24#$FC#$83#$F9#$01#$77#$06#$DD#$D8#$D9#$E8 + #$EB#$0F#$D9#$E8#$D9#$E8#$D8#$EA#$49#$DC#$CA + #$D8#$E1#$E2#$FA#$DE#$D9), { FABS (D9E1); FRNDINT (D9FC); FIST mem0 (DB5424FC); } { MOV ecx, mem0 (8B4C24FC); CMP ecx, 1 (83F901); JG @BIG (7F06); } { FSTP ST(0) (DDD8); FLD1 (D9E8); JMP @EXIT (EB0F) } { @BIG: FLD1 (D9E8); FLD1 (D9E8); FSUBR ST, ST(2) (D8EA); DEC ecx (49) } { @LOOP: FMUL ST(2), ST (DCCA); FSUB ST, ST(1) (D8E1); LOOP @LOOP (E2FA);} { FCOMPP (DED9); @EXIT: } (Name:'BINOM'; Args: 2; Code: #$64#$50#$D9#$E1#$D9#$FC#$D9#$C9#$D9#$E1#$D9#$FC + #$D8#$D1#$9B#$DF#$E0#$9E#$76#$06#$DE#$D9 + #$D9#$EE#$EB#$4A#$DB#$54#$24#$FC#$8B#$4C#$24#$FC + #$83#$F9#$01#$77#$10#$0B#$C9#$74#$06#$DD#$D8 + #$D9#$E8#$EB#$15#$D9#$D9#$D9#$E8#$EB#$2D + #$D9#$E8#$D9#$E8#$D8#$EA#$49#$DC#$CA#$D8#$E1 + #$E2#$FA#$DE#$D9#$D9#$C9#$8B#$4C#$24#$FC + #$83#$F9#$01#$77#$02#$EB#$0F#$D9#$E8#$D9#$E8 + #$D8#$EA#$49#$DC#$CA#$D8#$E1#$E2#$FA#$DE#$D9#$DE#$F1#$58), { PUSH ax (50); FABS (D9E1); FRNDINT (D9FC); FXCH(D9C9); FABS (D9E1); } { FRNDINT (D9FC); FCOM (D8D1); FWAIT (9B); FNSTSW ax (DFE0); SAHF (9E); } { JNA @CONT (7606); FCOMPP (DED9); FLDZ (D9EE); JMP @EXIT (EB4A) } { @CONT: FIST mem0 (DB5424FC); MOV ecx, mem0 (8B4C24FC); } { CMP ecx, 1 (83F901); JA @BIG1 (7710); OR ecx, ecx (0BC9); } { JZ @EXIT0 (7406); FSTP ST(0) (DDD8); FLD1 (D9E8); JMP @EXIT1 (EB15) } { EXIT0: FCOMPP (D9D9); FLD1 (D9E8); JMP EXIT (EB2D) } { @BIG1: FLD1 (D9E8); FLD1 (D9E8); FSUBR ST, ST(2) (D8EA); DEC ecx (49) } { @LOOP1: FMUL ST(2), ST (DCCA); FSUB ST, ST(1) (D8E1); } { LOOP @LOOP1 (E2FA); FCOMPP (DED9); @EXIT1: FXCH (D9C9); } { MOV ecx, mem0 (8B4C24FC); CMP ecx, 1 (83F901); JA @BIG2 (7702) } { JMP @EXIT2 (EB0F) } { @BIG2: FLD1 (D9E8); FLD1 (D9E8); FSUBR ST, ST(2) (D8EA); DEC ecx (49) } { @LOOP2: FMUL ST(2), ST (DCCA); FSUB ST, ST(1) (D8E1); } { LOOP @LOOP2 (E2FA); FCOMPP (DED9); @EXIT2: FDIVPR (DEF1) } { @EXIT: POP ax (58) } (Name:'COSH'; Args: 1; Code: #$2A#$D9#$EA#$DE#$C9#$D9#$C0#$D9#$FC + #$DC#$E9#$D9#$E8#$D9#$FD#$DD#$D9 + #$D9#$C9#$D9#$F0#$D9#$E8#$DE#$C1 + #$DE#$C9#$D9#$C0#$D9#$E8#$DE#$F1 + #$DE#$C1#$D9#$E8#$D9#$E8#$DE#$C1#$DE#$F9), { FLDL2E (D9EA); FMULP ST(1),ST(0) (DEC9); FLD ST(0) (D9C0); } { FRNDINT (D9FC); FSUB ST(1),ST(0) (DCE9) FLD1 (D9E8); } { FSCALE (D9FD); FSTP ST(1) (DDD9); FXCH ST(1) (D9C9); } { F2XM1 (D9F0); FLD1 (D9E8); FADDP ST(1),ST(0) (DEC1); } { FMULP ST(1),ST(0) (DEC9); FLD ST(0) (D9C0); FLD1 (D9E8); } { FDIVR (DEF1); FADD (DEC1); FLD1(D9E8); FLD1(D9E8); FADD (DEC1); } { FDIV (DEF9) } (Name:'SINH'; Args: 1; Code: #$2A#$D9#$EA#$DE#$C9#$D9#$C0#$D9#$FC + #$DC#$E9#$D9#$E8#$D9#$FD#$DD#$D9 + #$D9#$C9#$D9#$F0#$D9#$E8#$DE#$C1 + #$DE#$C9#$D9#$C0#$D9#$E8#$DE#$F1 + #$DE#$E9#$D9#$E8#$D9#$E8#$DE#$C1#$DE#$F9), { FLDL2E (D9EA); FMULP ST(1),ST(0) (DEC9); FLD ST(0) (D9C0); } { FRNDINT (D9FC); FSUB ST(1),ST(0) (DCE9) FLD1 (D9E8); } { FSCALE (D9FD); FSTP ST(1) (DDD9); FXCH ST(1) (D9C9); } { F2XM1 (D9F0); FLD1 (D9E8); FADDP ST(1),ST(0) (DEC1); } { FMULP ST(1),ST(0) (DEC9); FLD ST(0) (D9C0); FLD1 (D9E8); } { FDIVR (DEF1); FSUB (D9E9); FLD1(D9E8); FLD1(D9E8); FADD (DEC1); } { FDIV (DEF9) } (Name:'TANH'; Args: 1; Code: #$26#$D9#$EA#$DE#$C9#$D9#$C0#$D9#$FC + #$DC#$E9#$D9#$E8#$D9#$FD#$DD#$D9 + #$D9#$C9#$D9#$F0#$D9#$E8#$DE#$C1 + #$DE#$C9#$D8#$C8#$D9#$C0#$D9#$E8 + #$DC#$C2#$DE#$E9#$DE#$F1), { FLDL2E (D9EA); FMULP ST(1),ST(0) (DEC9); FLD ST(0) (D9C0); } { FRNDINT (D9FC); FSUB ST(1),ST(0) (DCE9) FLD1 (D9E8); } { FSCALE (D9FD); FSTP ST(1) (DDD9); FXCH ST(1) (D9C9); } { F2XM1 (D9F0); FLD1 (D9E8); FADDP ST(1),ST(0) (DEC1); } { FMULP ST(1),ST(0) (DEC9); FMUL ST, ST(0) (D8C8); FLD ST(0) (D9C0) } { FLD1 (D9E8); FADD ST(2), ST (DCC2); FSUBP ST(1), ST (DEE9); } { FDIVRP (DEF1) } (Name:'ACOSH'; Args: 1; Code: #$12#$D9#$C0#$D8#$C8#$D9#$E8#$DE + #$E9#$D9#$FA#$DE#$C1#$D9#$ED + #$D9#$C9#$D9#$F1), { FLD ST(0) (D9C0); FMUL ST,ST(0) (D8C8); FLD1 (D9E8); } { FSUBP ST(1),ST (DEE9); FSQRT (D9FA); FADDP ST(1),ST (DEC1); } { FLDLN2 (D9ED); FXCH ST(1) (D9C9); FYL2X (D9F1) } (Name:'ASINH'; Args: 1; Code: #$12#$D9#$C0#$D8#$C8#$D9#$E8#$DE + #$C1#$D9#$FA#$DE#$C1#$D9#$ED + #$D9#$C9#$D9#$F1), { FLD ST(0) (D9C0); FMUL ST,ST(0) (D8C8); FLD1 (D9E8); } { FADDP ST(1),ST (DEC1); FSQRT (D9FA); FADDP ST(1),ST (DEC1); } { FLDLN2 (D9ED); FXCH ST(1) (D9C9); FYL2X (D9F1) } { }(Name:'ATANH'; Args: 1; Code: #$14#$D9#$C0#$D9#$E8#$DC#$E2#$DE + #$C1#$DE#$F1#$D9#$FA#$D9#$ED#$D9#$C9 + #$D9#$F1), { FLD ST(0) (D9C0); FLD1 (D9E8); FSUBR ST(2),ST (DCE2); } { FADDP ST(1),ST (DEC1); FDIVRP ST(1),ST (DEF1); FSQRT (D9FA) } { FLDLN2 (D9ED); FXCH ST(1) (D9C9); FYL2X (D9F1); } {$IFDEF WIN32} { }(Name:'MIN'; Args: -1; Code: #$0E#$50#$D8#$D1#$9B#$DF#$E0#$9E#$77#$02 + #$D9#$C9#$DD#$D8#$58), { PUSH ax (50); FCOM (D8D1); FWAIT (9B); FNSTSW ax (DFE0); SAHF (9E); } { JA @CONT (7702); FXCH ST(1) (D9C9); @CONT: FSTP (DDD8); POP ax (58); } { }(Name:'MAX'; Args: -1; Code: #$0E#$50#$D8#$D1#$9B#$DF#$E0#$9E#$72#$02 + #$D9#$C9#$DD#$D8#$58), { PUSH ax (50); FCOM (D8D1); FWAIT (9B); FNSTSW ax (DFE0); SAHF (9E); } { JB @CONT (7202); FXCH ST(1) (D9C9); @CONT: FSTP (DDD8); POP ax (58); } { }(Name:'SUM'; Args: -1; Code: #$02#$DE#$C1), { FADDP (DEC1) } { }(Name:'PROD'; Args: -1; Code: #$02#$DE#$C9) { FADDP (DEC9) } )

BuiltInOperators = ( {$IFDEF WIN32} (Name: '>'; Code: #$10#$50#$DE#$D9#$9B#$DF#$E0#$9E#$77#$04#$D9+ #$EE#$EB#$02#$D9#$E8#$58), { PUSH ax (50); FCOMPP (DED9); FWAIT (9B); FNSTSW AX (DFE0); SAHF (9E); } { JA (7704); FLDZ (D9EE); JMP (EB02), FLD1 (D9E8); POP ax (58) } (Name: '<'; Code: #$10#$50#$DE#$D9#$DF#$E0#$9B#$9E#$72#$04#$D9+ #$EE#$EB#$02#$D9#$E8#$58), { PUSH ax (50); FCOMPP (DED9); FNSTSW AX (DFE0); FWAIT (9B); SAHF (9E); } { JB (7204); FLDZ (D9EE); JMP (EB02), FLD1 (D9E8); POP ax (58) } (Name: '>='; Code: #$10#$50#$DE#$D9#$DF#$E0#$9B#$9E#$73#$04#$D9+ #$EE#$EB#$02#$D9#$E8#$58), { PUSH ax (50); FCOMPP (DED9); FNSTSW AX (DFE0); FWAIT (9B); SAHF (9E); } { JAE (7304); FLDZ (D9EE); JMP (EB02), FLD1 (D9E8); POP ax (58) } (Name: '<='; Code: #$10#$50#$DE#$D9#$DF#$E0#$9B#$9E#$76#$04#$D9+ #$EE#$EB#$02#$D9#$E8#$58), { PUSH ax (50); FCOMPP (DED9); FNSTSW AX (DFE0); FWAIT (9B); SAHF (9E); } { JBE (7604); FLDZ (D9EE); JMP (EB02), FLD1 (D9E8); POP ax (58) } (Name: '='; Code: #$10#$50#$DE#$D9#$9B#$DF#$E0#$9E#$74#$04#$D9+ #$EE#$EB#$02#$D9#$E8#$58), { PUSH ax (50); FCOMPP (DED9); FWAIT (9B); FNSTSW AX (DFE0); SAHF (9E); } { JE (7404); FLDZ (D9EE); JMP (EB02), FLD1 (D9E8); POP ax (58) } (Name: '<>'; Code: #$10#$50#$DE#$D9#$DF#$E0#$9B#$9E#$75#$04#$D9+ #$EE#$EB#$02#$D9#$E8#$58) { PUSH ax (50); FCOMPP (DED9); FNSTSW AX (DFE0); FWAIT (9B); SAHF (9E); } { JNE (7504); FLDZ (D9EE); JMP (EB02), FLD1 (D9E8); POP ax (58) } )

DecimalSeparator = '.'

FCCheck = nil

Error handler

fcInternal = -1

fcInvalidId = fcInternal - 1

fcOk = 0

Error codes

fcReservedId = fcInternal - 2

fcUnknownFunc = fcInternal - 5

fcUnknownVar = fcInternal - 4

fcUsedName = fcInternal - 3

Letters = ['A'..'Z','_', 'a'..'z', '$']

LogicOpCount = 6

array of available precedence operators and their machine code } { Structure of Code: } { First byte: Code length } { .... : FPU code

MaxArraySize = MaxInt - 1

Maximum Array size

Numbers = ['0'..'9']

Settings for analyzer (parser)

Operations = ['+', '-', '*', '/', '^', '!']

Operators = ['<', '>', '=']

UserFuncBase = $100

User functions and constants must have Index >= UserFuncBase

Variables