*************************************************************} { } { 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 } { } {
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
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
TBIFArgs
TBIFCode
TBIFD
TBIFName
TInternalExprItem
TLogicOp
TLogicOpCode
TLogicOpName
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
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
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
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