paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-08-16 23:01:55 +02:00
Code Issues Packages Projects Releases Wiki Activity

fcl-passrc: fixed MaxPrecInt to TMaxPrecInt, using TMaxPrecInt instead of int64

Browse Source 
git-svn-id: trunk@39940 -
This commit is contained in:
Mattias Gaertner 2018-10-15 21:58:04 +00:00
parent c7675335a6
commit d9be52c759
6 changed files with 299 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

399
packages/fcl-passrc/src/pasresolveeval.pas
View File

File diff suppressed because it is too large Load Diff

48
packages/fcl-passrc/src/pasresolver.pp
View File

@ -1776,7 +1776,7 @@ type
function ProcNeedsParams(El: TPasProcedureType): boolean; function ProcNeedsParams(El: TPasProcedureType): boolean;
function IsProcOverride(AncestorProc, DescendantProc: TPasProcedure): boolean; function IsProcOverride(AncestorProc, DescendantProc: TPasProcedure): boolean;
function GetTopLvlProc(El: TPasElement): TPasProcedure; function GetTopLvlProc(El: TPasElement): TPasProcedure;
function GetRangeLength(RangeExpr: TPasExpr): MaxPrecInt; function GetRangeLength(RangeExpr: TPasExpr): TMaxPrecInt;
function EvalRangeLimit(RangeExpr: TPasExpr; Flags: TResEvalFlags; function EvalRangeLimit(RangeExpr: TPasExpr; Flags: TResEvalFlags;
EvalLow: boolean; ErrorEl: TPasElement): TResEvalValue; virtual; // compute low() or high() EvalLow: boolean; ErrorEl: TPasElement): TResEvalValue; virtual; // compute low() or high()
function EvalTypeRange(Decl: TPasType; Flags: TResEvalFlags): TResEvalValue; virtual; // compute low() and high() function EvalTypeRange(Decl: TPasType; Flags: TResEvalFlags): TResEvalValue; virtual; // compute low() and high()
@ -1785,9 +1785,9 @@ type
function GetCombinedBoolean(Bool1, Bool2: TResolverBaseType; ErrorEl: TPasElement): TResolverBaseType; virtual; function GetCombinedBoolean(Bool1, Bool2: TResolverBaseType; ErrorEl: TPasElement): TResolverBaseType; virtual;
function GetCombinedInt(const Int1, Int2: TPasResolverResult; ErrorEl: TPasElement): TResolverBaseType; virtual; function GetCombinedInt(const Int1, Int2: TPasResolverResult; ErrorEl: TPasElement): TResolverBaseType; virtual;
procedure GetIntegerProps(bt: TResolverBaseType; out Precision: word; out Signed: boolean); procedure GetIntegerProps(bt: TResolverBaseType; out Precision: word; out Signed: boolean);
function GetIntegerRange(bt: TResolverBaseType; out MinVal, MaxVal: MaxPrecInt): boolean; function GetIntegerRange(bt: TResolverBaseType; out MinVal, MaxVal: TMaxPrecInt): boolean;
function GetIntegerBaseType(Precision: word; Signed: boolean; ErrorEl: TPasElement): TResolverBaseType; function GetIntegerBaseType(Precision: word; Signed: boolean; ErrorEl: TPasElement): TResolverBaseType;
function GetSmallestIntegerBaseType(MinVal, MaxVal: MaxPrecInt): TResolverBaseType; function GetSmallestIntegerBaseType(MinVal, MaxVal: TMaxPrecInt): TResolverBaseType;
function GetCombinedChar(const Char1, Char2: TPasResolverResult; ErrorEl: TPasElement): TResolverBaseType; virtual; function GetCombinedChar(const Char1, Char2: TPasResolverResult; ErrorEl: TPasElement): TResolverBaseType; virtual;
function GetCombinedString(const Str1, Str2: TPasResolverResult; ErrorEl: TPasElement): TResolverBaseType; virtual; function GetCombinedString(const Str1, Str2: TPasResolverResult; ErrorEl: TPasElement): TResolverBaseType; virtual;
function IsElementSkipped(El: TPasElement): boolean; virtual; function IsElementSkipped(El: TPasElement): boolean; virtual;
@ -6818,7 +6818,7 @@ end;
procedure TPasResolver.ResolveImplCaseOf(CaseOf: TPasImplCaseOf); procedure TPasResolver.ResolveImplCaseOf(CaseOf: TPasImplCaseOf);
type type
TRangeItem = record TRangeItem = record
RangeStart, RangeEnd: MaxPrecInt; RangeStart, RangeEnd: TMaxPrecInt;
Expr: TPasExpr; Expr: TPasExpr;
aString: UnicodeString; aString: UnicodeString;
// Note: for case-of-string: // Note: for case-of-string:
@ -6888,7 +6888,7 @@ type
end; end;
end; end;
function AddRangeItem(Values: TFPList; const RangeStart, RangeEnd: MaxPrecInt; function AddRangeItem(Values: TFPList; const RangeStart, RangeEnd: TMaxPrecInt;
Expr: TPasExpr): PRangeItem; Expr: TPasExpr): PRangeItem;
begin begin
New(Result); New(Result);
@ -6927,7 +6927,7 @@ type
Result:=true; Result:=true;
end; end;
function AddStringRange(CharStart, CharEnd: MaxPrecInt): boolean; function AddStringRange(CharStart, CharEnd: TMaxPrecInt): boolean;
var var
i, o: Integer; i, o: Integer;
s: UnicodeString; s: UnicodeString;
@ -6957,7 +6957,7 @@ type
end; end;
var var
RangeStart, RangeEnd: MaxPrecInt; RangeStart, RangeEnd: TMaxPrecInt;
i: Integer; i: Integer;
Item: PRangeItem; Item: PRangeItem;
begin begin
@ -6981,7 +6981,7 @@ type
// Note: when FPC compares int64 with qword it converts the qword to an int64 // Note: when FPC compares int64 with qword it converts the qword to an int64
if TResEvalUInt(Value).UInt>HighIntAsUInt then if TResEvalUInt(Value).UInt>HighIntAsUInt then
ExprEvaluator.EmitRangeCheckConst(20180424212414,Value.AsString, ExprEvaluator.EmitRangeCheckConst(20180424212414,Value.AsString,
'0',IntToStr(High(MaxPrecInt)),Expr,mtError); '0',IntToStr(High(TMaxPrecInt)),Expr,mtError);
RangeStart:=TResEvalUInt(Value).UInt; RangeStart:=TResEvalUInt(Value).UInt;
RangeEnd:=RangeStart; RangeEnd:=RangeStart;
end; end;
@ -7023,7 +7023,7 @@ type
// Note: when FPC compares int64 with qword it converts the qword to an int64 // Note: when FPC compares int64 with qword it converts the qword to an int64
if TResEvalRangeUInt(Value).RangeEnd>HighIntAsUInt then if TResEvalRangeUInt(Value).RangeEnd>HighIntAsUInt then
ExprEvaluator.EmitRangeCheckConst(20180424212648,Value.AsString, ExprEvaluator.EmitRangeCheckConst(20180424212648,Value.AsString,
'0',IntToStr(High(MaxPrecInt)),Expr,mtError); '0',IntToStr(High(TMaxPrecInt)),Expr,mtError);
RangeStart:=TResEvalRangeUInt(Value).RangeStart; RangeStart:=TResEvalRangeUInt(Value).RangeStart;
RangeEnd:=TResEvalRangeUInt(Value).RangeEnd; RangeEnd:=TResEvalRangeUInt(Value).RangeEnd;
end; end;
@ -11674,9 +11674,9 @@ end;
function TPasResolver.EvalBaseTypeCast(Params: TParamsExpr; function TPasResolver.EvalBaseTypeCast(Params: TParamsExpr;
bt: TResolverBaseType): TResEvalvalue; bt: TResolverBaseType): TResEvalvalue;
procedure TCFloatToInt(Value: TResEvalValue; Flo: MaxPrecFloat); procedure TCFloatToInt(Value: TResEvalValue; Flo: TMaxPrecFloat);
var var
Int, MinIntVal, MaxIntVal: MaxPrecInt; Int, MinIntVal, MaxIntVal: TMaxPrecInt;
begin begin
if bt in (btAllInteger-[btQWord]) then if bt in (btAllInteger-[btQWord]) then
begin begin
@ -11747,9 +11747,9 @@ function TPasResolver.EvalBaseTypeCast(Params: TParamsExpr;
var var
Value: TResEvalValue; Value: TResEvalValue;
Int: MaxPrecInt; Int: TMaxPrecInt;
MinIntVal, MaxIntVal: int64; MinIntVal, MaxIntVal: int64;
Flo: MaxPrecFloat; Flo: TMaxPrecFloat;
c: Char; c: Char;
w: WideChar; w: WideChar;
begin begin
@ -11768,7 +11768,7 @@ begin
begin begin
// int to qword // int to qword
{$R-} {$R-}
Result:=TResEvalUInt.CreateValue(MaxPrecUInt(Int)); Result:=TResEvalUInt.CreateValue(TMaxPrecUInt(Int));
{$IFDEF RangeCheckOn}{$R+}{$ENDIF} {$IFDEF RangeCheckOn}{$R+}{$ENDIF}
end end
else if bt in (btAllInteger-[btQWord]) then else if bt in (btAllInteger-[btQWord]) then
@ -12655,7 +12655,7 @@ var
Value: TResEvalValue; Value: TResEvalValue;
EnumType: TPasEnumType; EnumType: TPasEnumType;
aSet: TResEvalSet; aSet: TResEvalSet;
Int: MaxPrecInt; Int: TMaxPrecInt;
bt: TResolverBaseType; bt: TResolverBaseType;
MinInt, MaxInt: int64; MinInt, MaxInt: int64;
i: Integer; i: Integer;
@ -13600,7 +13600,7 @@ var
i: Integer; i: Integer;
ArrayEl: TPasArrayType; ArrayEl: TPasArrayType;
bt: TResolverBaseType; bt: TResolverBaseType;
MinInt, MaxInt: MaxPrecInt; MinInt, MaxInt: TMaxPrecInt;
begin begin
Evaluated:=nil; Evaluated:=nil;
Param:=Params.Params[0]; Param:=Params.Params[0];
@ -16111,7 +16111,7 @@ var
LRangeValue, RValue: TResEvalValue; LRangeValue, RValue: TResEvalValue;
MinVal, MaxVal: int64; MinVal, MaxVal: int64;
RangeExpr: TBinaryExpr; RangeExpr: TBinaryExpr;
Int: MaxPrecInt; Int: TMaxPrecInt;
C: TClass; C: TClass;
EnumType: TPasEnumType; EnumType: TPasEnumType;
bt: TResolverBaseType; bt: TResolverBaseType;
@ -16193,9 +16193,9 @@ begin
fExprEvaluator.EmitRangeCheckConst(20170530093126, fExprEvaluator.EmitRangeCheckConst(20170530093126,
IntToStr(TResEvalInt(RValue).Int),MinVal,MaxVal,RHS); IntToStr(TResEvalInt(RValue).Int),MinVal,MaxVal,RHS);
revkUInt: revkUInt:
if (TResEvalUInt(RValue).UInt>High(MaxPrecInt)) if (TResEvalUInt(RValue).UInt>High(TMaxPrecInt))
or (MinVal>MaxPrecInt(TResEvalUInt(RValue).UInt)) or (MinVal>TMaxPrecInt(TResEvalUInt(RValue).UInt))
or (MaxVal<MaxPrecInt(TResEvalUInt(RValue).UInt)) then or (MaxVal<TMaxPrecInt(TResEvalUInt(RValue).UInt)) then
fExprEvaluator.EmitRangeCheckConst(20170530093616, fExprEvaluator.EmitRangeCheckConst(20170530093616,
IntToStr(TResEvalUInt(RValue).UInt),IntToStr(MinVal),IntToStr(MaxVal),RHS); IntToStr(TResEvalUInt(RValue).UInt),IntToStr(MinVal),IntToStr(MaxVal),RHS);
revkFloat: revkFloat:
@ -20027,7 +20027,7 @@ begin
end; end;
end; end;
function TPasResolver.GetRangeLength(RangeExpr: TPasExpr): MaxPrecInt; function TPasResolver.GetRangeLength(RangeExpr: TPasExpr): TMaxPrecInt;
var var
Range: TResEvalValue; Range: TResEvalValue;
begin begin
@ -20259,7 +20259,7 @@ begin
end; end;
function TPasResolver.GetIntegerRange(bt: TResolverBaseType; out MinVal, function TPasResolver.GetIntegerRange(bt: TResolverBaseType; out MinVal,
MaxVal: MaxPrecInt): boolean; MaxVal: TMaxPrecInt): boolean;
begin begin
Result:=true; Result:=true;
if bt=btExtended then bt:=BaseTypeExtended; if bt=btExtended then bt:=BaseTypeExtended;
@ -20327,10 +20327,10 @@ begin
RaiseRangeCheck(20170420100336,ErrorEl); RaiseRangeCheck(20170420100336,ErrorEl);
end; end;
function TPasResolver.GetSmallestIntegerBaseType(MinVal, MaxVal: MaxPrecInt function TPasResolver.GetSmallestIntegerBaseType(MinVal, MaxVal: TMaxPrecInt
): TResolverBaseType; ): TResolverBaseType;
var var
V: MaxPrecInt; V: TMaxPrecInt;
begin begin
if MinVal>MaxVal then if MinVal>MaxVal then
MinVal:=MaxVal; MinVal:=MaxVal;

18
packages/fcl-passrc/src/pparser.pp
View File

@ -273,10 +273,12 @@ type
FTokenRingCur: Integer; // index of current token in FTokenBuffer FTokenRingCur: Integer; // index of current token in FTokenBuffer
FTokenRingStart: Integer; // first valid ring index in FTokenBuffer, if FTokenRingStart=FTokenRingEnd the ring is empty FTokenRingStart: Integer; // first valid ring index in FTokenBuffer, if FTokenRingStart=FTokenRingEnd the ring is empty
FTokenRingEnd: Integer; // first invalid ring index in FTokenBuffer FTokenRingEnd: Integer; // first invalid ring index in FTokenBuffer
{$ifdef VerbosePasParser}
FDumpIndent : String; FDumpIndent : String;
procedure DumpCurToken(Const Msg : String; IndentAction : TIndentAction = iaNone);
{$endif}
function CheckOverloadList(AList: TFPList; AName: String; out OldMember: TPasElement): TPasOverloadedProc; function CheckOverloadList(AList: TFPList; AName: String; out OldMember: TPasElement): TPasOverloadedProc;
function DoCheckHint(Element: TPasElement): Boolean; function DoCheckHint(Element: TPasElement): Boolean;
procedure DumpCurToken(Const Msg : String; IndentAction : TIndentAction = iaNone);
function GetCurrentModeSwitches: TModeSwitches; function GetCurrentModeSwitches: TModeSwitches;
Procedure SetCurrentModeSwitches(AValue: TModeSwitches); Procedure SetCurrentModeSwitches(AValue: TModeSwitches);
function GetVariableModifiers(Parent: TPasElement; function GetVariableModifiers(Parent: TPasElement;
@ -2425,7 +2427,9 @@ begin
AllowedBinaryOps:=BinaryOP; AllowedBinaryOps:=BinaryOP;
if Not AllowEqual then if Not AllowEqual then
Exclude(AllowedBinaryOps,tkEqual); Exclude(AllowedBinaryOps,tkEqual);
{$ifdef VerbosePasParser}
//DumpCurToken('Entry',iaIndent); //DumpCurToken('Entry',iaIndent);
{$endif}
Result:=nil; Result:=nil;
ExpStack := TFPList.Create; ExpStack := TFPList.Create;
SetLength(OpStack,4); SetLength(OpStack,4);
@ -2543,10 +2547,12 @@ begin
Result.Parent:=AParent; Result.Parent:=AParent;
finally finally
{if Not Assigned(Result) then {$ifdef VerbosePasParser}
if Not Assigned(Result) then
DumpCurToken('Exiting (no result)',iaUndent) DumpCurToken('Exiting (no result)',iaUndent)
else else
DumpCurtoken('Exiting (Result: "'+Result.GetDeclaration(true)+'") ',iaUndent);} DumpCurtoken('Exiting (Result: "'+Result.GetDeclaration(true)+'") ',iaUndent);
{$endif}
if not Assigned(Result) then begin if not Assigned(Result) then begin
// expression error! // expression error!
for i:=0 to ExpStack.Count-1 do for i:=0 to ExpStack.Count-1 do
@ -4958,7 +4964,9 @@ begin
IsCurTokenHint() or IsCurTokenHint() or
TokenIsCallingConvention(CurTokenString,cc) or TokenIsCallingConvention(CurTokenString,cc) or
(CurToken=tkIdentifier) and (CompareText(CurTokenText,'alias')=0)); (CurToken=tkIdentifier) and (CompareText(CurTokenText,'alias')=0));
// DumpCurToken('Done '+IntToStr(Ord(Done))); {$ifdef VerbosePasParser}
DumpCurToken('Done '+IntToStr(Ord(Done)));
{$endif}
UngetToken; UngetToken;
end; end;
@ -6098,6 +6106,7 @@ begin
Until Done; Until Done;
end; end;
{$ifdef VerbosePasParser}
procedure TPasParser.DumpCurToken(const Msg: String; IndentAction: TIndentAction procedure TPasParser.DumpCurToken(const Msg: String; IndentAction: TIndentAction
); );
begin begin
@ -6114,6 +6123,7 @@ begin
{$endif} {$endif}
{AllowWriteln-} {AllowWriteln-}
end; end;
{$endif}
function TPasParser.GetCurrentModeSwitches: TModeSwitches; function TPasParser.GetCurrentModeSwitches: TModeSwitches;
begin begin

50
packages/pastojs/src/fppas2js.pp
View File

@ -1511,7 +1511,7 @@ type
Function GetExpressionValueType(El: TPasExpr; AContext: TConvertContext ): TJSType; virtual; Function GetExpressionValueType(El: TPasExpr; AContext: TConvertContext ): TJSType; virtual;
Function GetPasIdentValueType(AName: String; AContext: TConvertContext): TJSType; virtual; Function GetPasIdentValueType(AName: String; AContext: TConvertContext): TJSType; virtual;
Function ComputeConstString(Expr: TPasExpr; AContext: TConvertContext; NotEmpty: boolean): String; virtual; Function ComputeConstString(Expr: TPasExpr; AContext: TConvertContext; NotEmpty: boolean): String; virtual;
Function IsLiteralInteger(El: TJSElement; out Number: MaxPrecInt): boolean; Function IsLiteralInteger(El: TJSElement; out Number: TMaxPrecInt): boolean;
Function IsLiteralNumber(El: TJSElement; out n: TJSNumber): boolean; Function IsLiteralNumber(El: TJSElement; out n: TJSNumber): boolean;
// Name mangling // Name mangling
Function GetOverloadName(El: TPasElement; AContext: TConvertContext): string; Function GetOverloadName(El: TPasElement; AContext: TConvertContext): string;
@ -1577,8 +1577,8 @@ type
Procedure ConvertCharLiteralToInt(Lit: TJSLiteral; ErrorEl: TPasElement; AContext: TConvertContext); virtual; Procedure ConvertCharLiteralToInt(Lit: TJSLiteral; ErrorEl: TPasElement; AContext: TConvertContext); virtual;
Function ClonePrimaryExpression(El: TJSPrimaryExpression; Src: TPasElement): TJSPrimaryExpression; Function ClonePrimaryExpression(El: TJSPrimaryExpression; Src: TPasElement): TJSPrimaryExpression;
// simple JS expressions // simple JS expressions
Function CreateMulNumber(El: TPasElement; JS: TJSElement; n: MaxPrecInt): TJSElement; virtual; Function CreateMulNumber(El: TPasElement; JS: TJSElement; n: TMaxPrecInt): TJSElement; virtual;
Function CreateDivideNumber(El: TPasElement; JS: TJSElement; n: MaxPrecInt): TJSElement; virtual; Function CreateDivideNumber(El: TPasElement; JS: TJSElement; n: TMaxPrecInt): TJSElement; virtual;
Function CreateMathFloor(El: TPasElement; JS: TJSElement): TJSElement; virtual; Function CreateMathFloor(El: TPasElement; JS: TJSElement): TJSElement; virtual;
Function CreateDotExpression(aParent: TPasElement; Left, Right: TJSElement; Function CreateDotExpression(aParent: TPasElement; Left, Right: TJSElement;
CheckRightIntfRef: boolean = false): TJSElement; virtual; CheckRightIntfRef: boolean = false): TJSElement; virtual;
@ -1786,7 +1786,7 @@ type
otSIntDouble, // 6 NativeInt otSIntDouble, // 6 NativeInt
otUIntDouble // 7 NativeUInt otUIntDouble // 7 NativeUInt
); );
Function GetOrdType(MinValue, MaxValue: MaxPrecInt; ErrorEl: TPasElement): TOrdType; virtual; Function GetOrdType(MinValue, MaxValue: TMaxPrecInt; ErrorEl: TPasElement): TOrdType; virtual;
Public Public
Constructor Create; Constructor Create;
destructor Destroy; override; destructor Destroy; override;
@ -5588,7 +5588,7 @@ begin
end; end;
function TPasToJSConverter.IsLiteralInteger(El: TJSElement; out function TPasToJSConverter.IsLiteralInteger(El: TJSElement; out
Number: MaxPrecInt): boolean; Number: TMaxPrecInt): boolean;
var var
Value: TJSValue; Value: TJSValue;
begin begin
@ -7353,7 +7353,7 @@ var
Arg, ArrJS: TJSElement; Arg, ArrJS: TJSElement;
OldAccess: TCtxAccess; OldAccess: TCtxAccess;
Ranges: TPasExprArray; Ranges: TPasExprArray;
Int: MaxPrecInt; Int: TMaxPrecInt;
Param: TPasExpr; Param: TPasExpr;
JSAdd: TJSAdditiveExpression; JSAdd: TJSAdditiveExpression;
LowRg: TResEvalValue; LowRg: TResEvalValue;
@ -8522,7 +8522,7 @@ var
JSBaseType:=JSBaseTypeData.JSBaseType; JSBaseType:=JSBaseTypeData.JSBaseType;
end; end;
function CreateBitWiseAnd(Value: TJSElement; const Mask: MaxPrecInt; Shift: integer): TJSElement; function CreateBitWiseAnd(Value: TJSElement; const Mask: TMaxPrecInt; Shift: integer): TJSElement;
// ig sign=false: Value & Mask // ig sign=false: Value & Mask
// if sign=true: Value & Mask << ZeroBits >> ZeroBits // if sign=true: Value & Mask << ZeroBits >> ZeroBits
var var
@ -8570,7 +8570,7 @@ var
AddExpr: TJSAdditiveExpressionPlus; AddExpr: TJSAdditiveExpressionPlus;
TypeEl: TPasType; TypeEl: TPasType;
C: TClass; C: TClass;
Int, MinVal, MaxVal: MaxPrecInt; Int, MinVal, MaxVal: TMaxPrecInt;
aResolver: TPas2JSResolver; aResolver: TPas2JSResolver;
ShiftEx: TJSURShiftExpression; ShiftEx: TJSURShiftExpression;
begin begin
@ -8954,7 +8954,7 @@ var
ParamResolved: TPasResolverResult; ParamResolved: TPasResolverResult;
Ranges: TPasExprArray; Ranges: TPasExprArray;
Call: TJSCallExpression; Call: TJSCallExpression;
RgLen: MaxPrecInt; RgLen: TMaxPrecInt;
begin begin
Result:=nil; Result:=nil;
Param:=El.Params[0]; Param:=El.Params[0];
@ -9477,7 +9477,7 @@ var
Value: TResEvalValue; Value: TResEvalValue;
Call: TJSCallExpression; Call: TJSCallExpression;
MinusExpr: TJSAdditiveExpressionMinus; MinusExpr: TJSAdditiveExpressionMinus;
MinVal, MaxVal: MaxPrecInt; MinVal, MaxVal: TMaxPrecInt;
begin begin
Result:=nil; Result:=nil;
if AContext.Resolver=nil then if AContext.Resolver=nil then
@ -10376,7 +10376,7 @@ var
Param: TPasExpr; Param: TPasExpr;
TypeEl: TPasType; TypeEl: TPasType;
Value: TResEvalValue; Value: TResEvalValue;
MinVal, MaxVal: MaxPrecInt; MinVal, MaxVal: TMaxPrecInt;
C: TClass; C: TClass;
begin begin
Result:=nil; Result:=nil;
@ -11889,7 +11889,7 @@ var
TIObj: TJSObjectLiteral; TIObj: TJSObjectLiteral;
Call: TJSCallExpression; Call: TJSCallExpression;
MinVal, MaxVal: TResEvalValue; MinVal, MaxVal: TResEvalValue;
MinInt, MaxInt: MaxPrecInt; MinInt, MaxInt: TMaxPrecInt;
OrdType: TOrdType; OrdType: TOrdType;
TIProp: TJSObjectLiteralElement; TIProp: TJSObjectLiteralElement;
fn: TPas2JSBuiltInName; fn: TPas2JSBuiltInName;
@ -12109,7 +12109,7 @@ var
ElType: TPasType; ElType: TPasType;
RangeEl: TPasExpr; RangeEl: TPasExpr;
Call: TJSCallExpression; Call: TJSCallExpression;
RgLen, RangeEnd: MaxPrecInt; RgLen, RangeEnd: TMaxPrecInt;
List: TJSStatementList; List: TJSStatementList;
Func: TJSFunctionDeclarationStatement; Func: TJSFunctionDeclarationStatement;
Src: TJSSourceElements; Src: TJSSourceElements;
@ -12264,10 +12264,10 @@ begin
end; end;
end; end;
function TPasToJSConverter.GetOrdType(MinValue, MaxValue: MaxPrecInt; function TPasToJSConverter.GetOrdType(MinValue, MaxValue: TMaxPrecInt;
ErrorEl: TPasElement): TOrdType; ErrorEl: TPasElement): TOrdType;
var var
V: MaxPrecInt; V: TMaxPrecInt;
begin begin
if MinValue<0 then if MinValue<0 then
begin begin
@ -12373,7 +12373,7 @@ var
BodyJS.A:=FirstSt; BodyJS.A:=FirstSt;
end; end;
procedure AddRangeCheck(Arg: TPasArgument; MinVal, MaxVal: MaxPrecInt; procedure AddRangeCheck(Arg: TPasArgument; MinVal, MaxVal: TMaxPrecInt;
RTLFunc: TPas2JSBuiltInName); RTLFunc: TPas2JSBuiltInName);
var var
Call: TJSCallExpression; Call: TJSCallExpression;
@ -12431,7 +12431,7 @@ Var
Call: TJSCallExpression; Call: TJSCallExpression;
ClassPath: String; ClassPath: String;
ArgResolved: TPasResolverResult; ArgResolved: TPasResolverResult;
MinVal, MaxVal: MaxPrecInt; MinVal, MaxVal: TMaxPrecInt;
Lit: TJSLiteral; Lit: TJSLiteral;
ConstSrcElems: TJSSourceElements; ConstSrcElems: TJSSourceElements;
ArgTypeEl: TPasType; ArgTypeEl: TPasType;
@ -13986,7 +13986,7 @@ var
Path: String; Path: String;
FuncContext: TFunctionContext; FuncContext: TFunctionContext;
DotExpr: TJSDotMemberExpression; DotExpr: TJSDotMemberExpression;
i: MaxPrecInt; i: TMaxPrecInt;
JSExpr: TJSElement; JSExpr: TJSElement;
begin begin
if ArrayExpr is TJSArrayLiteral then if ArrayExpr is TJSArrayLiteral then
@ -15105,7 +15105,7 @@ function TPasToJSConverter.ConvertAssignStatement(El: TPasImplAssign;
end; end;
function CreateRangeCheck(AssignSt: TJSElement; function CreateRangeCheck(AssignSt: TJSElement;
MinVal, MaxVal: MaxPrecInt; RTLFunc: TPas2JSBuiltInName): TJSElement; MinVal, MaxVal: TMaxPrecInt; RTLFunc: TPas2JSBuiltInName): TJSElement;
var var
Call: TJSCallExpression; Call: TJSCallExpression;
begin begin
@ -15165,7 +15165,7 @@ Var
Flags: TPasResolverComputeFlags; Flags: TPasResolverComputeFlags;
LeftIsProcType, NeedClone: Boolean; LeftIsProcType, NeedClone: Boolean;
Call: TJSCallExpression; Call: TJSCallExpression;
MinVal, MaxVal: MaxPrecInt; MinVal, MaxVal: TMaxPrecInt;
RightTypeEl, LeftTypeEl: TPasType; RightTypeEl, LeftTypeEl: TPasType;
aResolver: TPas2JSResolver; aResolver: TPas2JSResolver;
NewMemE, NewME: TJSNewMemberExpression; NewMemE, NewME: TJSNewMemberExpression;
@ -15651,7 +15651,7 @@ var
end; end;
end; end;
function GetOrd(Value: TResEvalValue; ErrorEl: TPasElement): MaxPrecInt; overload; function GetOrd(Value: TResEvalValue; ErrorEl: TPasElement): TMaxPrecInt; overload;
var var
OrdValue: TResEvalValue; OrdValue: TResEvalValue;
begin begin
@ -15667,7 +15667,7 @@ var
ReleaseEvalValue(OrdValue); ReleaseEvalValue(OrdValue);
end; end;
function GetEnumValue(EnumType: TPasEnumType; Int: MaxPrecInt): TResEvalValue; overload; function GetEnumValue(EnumType: TPasEnumType; Int: TMaxPrecInt): TResEvalValue; overload;
begin begin
if (coEnumNumbers in Options) or (Int<0) or (Int>=EnumType.Values.Count) then if (coEnumNumbers in Options) or (Int<0) or (Int>=EnumType.Values.Count) then
Result:=TResEvalInt.CreateValue(Int) Result:=TResEvalInt.CreateValue(Int)
@ -15679,7 +15679,7 @@ var
FuncContext: TConvertContext; FuncContext: TConvertContext;
VarResolved, InResolved: TPasResolverResult; VarResolved, InResolved: TPasResolverResult;
StartValue, EndValue, InValue: TResEvalValue; StartValue, EndValue, InValue: TResEvalValue;
StartInt, EndInt: MaxPrecInt; StartInt, EndInt: TMaxPrecInt;
HasLoopVar, HasEndVar, HasInVar: Boolean; HasLoopVar, HasEndVar, HasInVar: Boolean;
InKind: TInKind; InKind: TInKind;
ForScope: TPasForLoopScope; ForScope: TPasForLoopScope;
@ -17094,7 +17094,7 @@ begin
end; end;
function TPasToJSConverter.CreateMulNumber(El: TPasElement; JS: TJSElement; function TPasToJSConverter.CreateMulNumber(El: TPasElement; JS: TJSElement;
n: MaxPrecInt): TJSElement; n: TMaxPrecInt): TJSElement;
// create JS*n // create JS*n
var var
Mul: TJSMultiplicativeExpressionMul; Mul: TJSMultiplicativeExpressionMul;
@ -17141,7 +17141,7 @@ begin
end; end;
function TPasToJSConverter.CreateDivideNumber(El: TPasElement; JS: TJSElement; function TPasToJSConverter.CreateDivideNumber(El: TPasElement; JS: TJSElement;
n: MaxPrecInt): TJSElement; n: TMaxPrecInt): TJSElement;
// create JS/n // create JS/n
var var
Mul: TJSMultiplicativeExpressionDiv; Mul: TJSMultiplicativeExpressionDiv;

24
packages/pastojs/src/pas2jsfiler.pp
View File

@ -1035,10 +1035,10 @@ function ComparePCUSrcFiles(File1, File2: Pointer): integer;
function ComparePCUFilerElementRef(Ref1, Ref2: Pointer): integer; function ComparePCUFilerElementRef(Ref1, Ref2: Pointer): integer;
function CompareElWithPCUFilerElementRef(El, Ref: Pointer): integer; function CompareElWithPCUFilerElementRef(El, Ref: Pointer): integer;
function EncodeVLQ(i: MaxPrecInt): string; overload; function EncodeVLQ(i: TMaxPrecInt): string; overload;
function EncodeVLQ(i: MaxPrecUInt): string; overload; function EncodeVLQ(i: TMaxPrecUInt): string; overload;
function DecodeVLQ(const s: string): MaxPrecInt; // base256 Variable Length Quantity function DecodeVLQ(const s: string): TMaxPrecInt; // base256 Variable Length Quantity
function DecodeVLQ(var p: PByte): MaxPrecInt; // base256 Variable Length Quantity function DecodeVLQ(var p: PByte): TMaxPrecInt; // base256 Variable Length Quantity
function ComputeChecksum(p: PChar; Cnt: integer): TPCUSourceFileChecksum; function ComputeChecksum(p: PChar; Cnt: integer): TPCUSourceFileChecksum;
function crc32(crc: cardinal; buf: Pbyte; len: cardinal): cardinal; function crc32(crc: cardinal; buf: Pbyte; len: cardinal): cardinal;
@ -1086,7 +1086,7 @@ begin
Result:=ComparePointer(Element,Reference.Element); Result:=ComparePointer(Element,Reference.Element);
end; end;
function EncodeVLQ(i: MaxPrecInt): string; function EncodeVLQ(i: TMaxPrecInt): string;
{ Convert signed number to base256-VLQ: { Convert signed number to base256-VLQ:
Each byte has 8bit, where the least significant bit is the continuation bit Each byte has 8bit, where the least significant bit is the continuation bit
(1=there is a next byte). (1=there is a next byte).
@ -1104,9 +1104,9 @@ begin
digits:=0; digits:=0;
if i<0 then if i<0 then
begin begin
if i=Low(MaxPrecInt) then if i=Low(TMaxPrecInt) then
begin begin
Result:=EncodeVLQ(High(MaxPrecInt)+1); Result:=EncodeVLQ(High(TMaxPrecInt)+1);
Result[1]:=chr(ord(Result[1]) or 1); Result[1]:=chr(ord(Result[1]) or 1);
exit; exit;
end; end;
@ -1128,7 +1128,7 @@ begin
end; end;
end; end;
function EncodeVLQ(i: MaxPrecUInt): string; function EncodeVLQ(i: TMaxPrecUInt): string;
var var
digits: integer; digits: integer;
begin begin
@ -1147,7 +1147,7 @@ begin
end; end;
end; end;
function DecodeVLQ(const s: string): MaxPrecInt; function DecodeVLQ(const s: string): TMaxPrecInt;
var var
p: PByte; p: PByte;
begin begin
@ -1159,7 +1159,7 @@ begin
raise EConvertError.Create('DecodeVLQ waste'); raise EConvertError.Create('DecodeVLQ waste');
end; end;
function DecodeVLQ(var p: PByte): MaxPrecInt; function DecodeVLQ(var p: PByte): TMaxPrecInt;
{ Convert base256-VLQ to signed number, { Convert base256-VLQ to signed number,
For the fomat see EncodeVLQ For the fomat see EncodeVLQ
} }
@ -1170,7 +1170,7 @@ function DecodeVLQ(var p: PByte): MaxPrecInt;
end; end;
const const
MaxShift = 63; // actually log2(High(MaxPrecInt)) MaxShift = 63; // actually log2(High(TMaxPrecInt))
var var
digit, Shift: Integer; digit, Shift: Integer;
Negated: Boolean; Negated: Boolean;
@ -1186,7 +1186,7 @@ begin
inc(p); inc(p);
if Shift>MaxShift then if Shift>MaxShift then
RaiseInvalid; RaiseInvalid;
inc(Result,MaxPrecInt(digit and %1111111) shl Shift); inc(Result,TMaxPrecInt(digit and %1111111) shl Shift);
inc(Shift,7); inc(Shift,7);
end; end;
if Negated then if Negated then

16
packages/pastojs/tests/tcfiler.pas
View File

@ -1541,11 +1541,11 @@ end;
procedure TTestPrecompile.Test_Base256VLQ; procedure TTestPrecompile.Test_Base256VLQ;
procedure Test(i: MaxPrecInt); procedure Test(i: TMaxPrecInt);
var var
s: String; s: String;
p: PByte; p: PByte;
j: MaxPrecInt; j: TMaxPrecInt;
begin begin
s:=EncodeVLQ(i); s:=EncodeVLQ(i);
p:=PByte(s); p:=PByte(s);
@ -1554,7 +1554,7 @@ procedure TTestPrecompile.Test_Base256VLQ;
Fail('Encode/DecodeVLQ OrigIndex='+IntToStr(i)+' Code="'+s+'" NewIndex='+IntToStr(j)); Fail('Encode/DecodeVLQ OrigIndex='+IntToStr(i)+' Code="'+s+'" NewIndex='+IntToStr(j));
end; end;
procedure TestStr(i: MaxPrecInt; Expected: string); procedure TestStr(i: TMaxPrecInt; Expected: string);
var var
Actual: String; Actual: String;
begin begin
@ -1570,11 +1570,11 @@ begin
TestStr(-1,#3); TestStr(-1,#3);
for i:=-8200 to 8200 do for i:=-8200 to 8200 do
Test(i); Test(i);
Test(High(MaxPrecInt)); Test(High(TMaxPrecInt));
Test(High(MaxPrecInt)-1); Test(High(TMaxPrecInt)-1);
Test(Low(MaxPrecInt)+2); Test(Low(TMaxPrecInt)+2);
Test(Low(MaxPrecInt)+1); Test(Low(TMaxPrecInt)+1);
//Test(Low(MaxPrecInt)); such a high number is not needed by pastojs //Test(Low(TMaxPrecInt)); such a high number is not needed by pastojs
end; end;
procedure TTestPrecompile.TestPC_EmptyUnit; procedure TTestPrecompile.TestPC_EmptyUnit;