text stringlengths 14 6.51M |
|---|
unit cn_dt_Orders_Unit_AE;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ibase, cxLookAndFeelPainters, StdCtrls, cxButtons,
cnConsts, cxButtonEdit, cxMaskEdit, cxDropDownEdit, cxCalendar,
cxContainer, cxEdit, cxTextEdit, cxControls, cxGroupBox,
cn_Common_Types, cn_Common_Loader, cn_Common_Funcs, Registry, Buttons;
type TOrderCookies = record
OrderDate : TDate;
ORDER_NUM : String;
OrderType : String;
id_order : Int64;
Comments : String;
end;
type
TfrmOrdersAE = class(TForm)
OkButton: TcxButton;
CancelButton: TcxButton;
ord_ae_GroupBox: TcxGroupBox;
ord_ae_TypeOrder_Label: TLabel;
ord_ae_NomOrder_Label: TLabel;
ord_ae_DateOrder_Label: TLabel;
ord_ae_Comments_Label: TLabel;
ord_ae_Nom_Ord: TcxTextEdit;
ord_ae_Comments: TcxTextEdit;
ord_ae_Date_Ord: TcxDateEdit;
ord_ae_Type_Ord: TcxButtonEdit;
SpeedButton: TSpeedButton;
procedure CancelButtonClick(Sender: TObject);
procedure ord_ae_Type_OrdKeyPress(Sender: TObject; var Key: Char);
procedure ord_ae_Nom_OrdKeyPress(Sender: TObject; var Key: Char);
procedure ord_ae_Date_OrdKeyPress(Sender: TObject; var Key: Char);
procedure ord_ae_CommentsKeyPress(Sender: TObject; var Key: Char);
procedure FormShow(Sender: TObject);
procedure ord_ae_Type_OrdPropertiesButtonClick(Sender: TObject;
AButtonIndex: Integer);
procedure OkButtonClick(Sender: TObject);
procedure SpeedButtonClick(Sender: TObject);
private
PLanguageIndex : byte;
DB_Handle : TISC_DB_HANDLE;
procedure FormIniLanguage();
procedure SaveCookies (OrderCookies: TOrderCookies);
function LoadCookies (): TOrderCookies;
public
id_order : int64;
is_admin : boolean;
constructor Create(AOwner:TComponent; DBHandle: TISC_DB_HANDLE; LanguageIndex : byte);reintroduce;
end;
var
frmOrdersAE: TfrmOrdersAE;
implementation
{$R *.dfm}
procedure TfrmOrdersAE.SaveCookies (OrderCookies: TOrderCookies);
var
reg: TRegistry;
begin
reg := TRegistry.Create;
try
reg.RootKey:=HKEY_CURRENT_USER;
if reg.OpenKey('\Software\Contracts\Cookies\Orders',True) then
begin
reg.WriteString('OrderDate', DateToStr(OrderCookies.OrderDate));
reg.WriteString('ORDER_NUM', OrderCookies.ORDER_NUM);
reg.WriteString('OrderType', OrderCookies.OrderType);
reg.WriteString('id_order', IntToStr(OrderCookies.id_order));
reg.WriteString('Comments', OrderCookies.Comments);
end
finally
reg.Free;
end;
end;
function TfrmOrdersAE.LoadCookies (): TOrderCookies;
var
reg: TRegistry;
OrderCookies : TOrderCookies;
begin
reg := TRegistry.Create;
try
reg.RootKey:=HKEY_CURRENT_USER;
if reg.OpenKey('\Software\Contracts\Cookies\Orders',False) then
begin
OrderCookies.OrderDate := StrToDate(reg.ReadString('OrderDate')) ;
OrderCookies.ORDER_NUM := reg.ReadString('ORDER_NUM') ;
OrderCookies.OrderType := reg.ReadString('OrderType') ;
OrderCookies.id_order := StrToInt (reg.ReadString('id_order')) ;
OrderCookies.Comments := reg.ReadString('Comments') ;
Result := OrderCookies;
end
finally
reg.Free;
end;
end;
constructor TfrmOrdersAE.Create(AOwner:TComponent; DBHandle: TISC_DB_HANDLE; LanguageIndex : byte);
begin
Screen.Cursor:=crHourGlass;
inherited Create(AOwner);
PLanguageIndex:= LanguageIndex;
DB_Handle := DBHandle;
FormIniLanguage();
Screen.Cursor:=crDefault;
end;
procedure TfrmOrdersAE.FormIniLanguage();
begin
ord_ae_TypeOrder_Label.Caption := cnConsts.cn_OrderType[PLanguageIndex];
ord_ae_NomOrder_Label.Caption := cnConsts.cn_NumOrd[PLanguageIndex];
ord_ae_DateOrder_Label.Caption := cnConsts.cn_DateOrd[PLanguageIndex];
ord_ae_Comments_Label.Caption := cnConsts.cn_CommentDiss[PLanguageIndex];
OkButton.Caption := cnConsts.cn_Accept[PLanguageIndex];
CancelButton.Caption := cnConsts.cn_Cancel[PLanguageIndex];
end;
procedure TfrmOrdersAE.CancelButtonClick(Sender: TObject);
begin
close;
end;
procedure TfrmOrdersAE.ord_ae_Type_OrdKeyPress(Sender: TObject;
var Key: Char);
begin
if key=#13 then ord_ae_Nom_Ord.SetFocus;
end;
procedure TfrmOrdersAE.ord_ae_Nom_OrdKeyPress(Sender: TObject;
var Key: Char);
begin
if key=#13 then ord_ae_Date_Ord.SetFocus;
end;
procedure TfrmOrdersAE.ord_ae_Date_OrdKeyPress(Sender: TObject;
var Key: Char);
begin
if key=#13 then ord_ae_Comments.SetFocus;
end;
procedure TfrmOrdersAE.ord_ae_CommentsKeyPress(Sender: TObject;
var Key: Char);
begin
if key=#13 then OkButton.SetFocus;
end;
procedure TfrmOrdersAE.FormShow(Sender: TObject);
begin
ord_ae_Type_Ord.SetFocus;
end;
procedure TfrmOrdersAE.ord_ae_Type_OrdPropertiesButtonClick(
Sender: TObject; AButtonIndex: Integer);
var
AParameter:TcnSimpleParams;
res: Variant;
begin
AParameter:= TcnSimpleParams.Create;
AParameter.Owner:=self;
AParameter.Db_Handle:=DB_Handle;
AParameter.Formstyle:=fsNormal;
AParameter.WaitPakageOwner:=self;
AParameter.is_admin := is_admin;
res:=RunFunctionFromPackage(AParameter, 'Contracts\cn_sp_OrderTypes.bpl','ShowSPOrderTypes');
AParameter.Free;
if VarArrayDimCount(Res)>0 then
begin
id_order := res[0];
ord_ae_Type_Ord.Text := res[2];
end;
end;
procedure TfrmOrdersAE.OkButtonClick(Sender: TObject);
var OrderCookies : TOrderCookies;
begin
if CheckControls(self, PLanguageIndex) then exit;
OrderCookies.OrderDate := ord_ae_Date_Ord.Date;
OrderCookies.ORDER_NUM := ord_ae_Nom_Ord.Text;
OrderCookies.OrderType := ord_ae_Type_Ord.Text;
OrderCookies.id_order := id_order;
OrderCookies.Comments := ord_ae_Comments.Text;
SaveCookies(OrderCookies);
ModalResult := MrOk;
end;
procedure TfrmOrdersAE.SpeedButtonClick(Sender: TObject);
var
Cookies : TOrderCookies;
begin
Cookies := LoadCookies();
ord_ae_Date_Ord.Date := Cookies.OrderDate;
ord_ae_Nom_Ord.Text := Cookies.ORDER_NUM;
ord_ae_Type_Ord.Text := Cookies.OrderType;
ord_ae_Comments.Text := Cookies.Comments;
id_order := Cookies.id_order;
end;
end.
|
program camera_circle;
{$mode objfpc}{$H+}
uses
{$IFDEF UNIX}{$IFDEF UseCThreads}
cthreads,
{$ENDIF}{$ENDIF}
Classes, SysUtils, glfw31, gl, GLext, shader_m, UMyFPImage, matrix, UMyMatrixExt, Math;
const
// settings
SCR_WIDTH = 800;
SCR_HEIGHT = 600;
// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
procedure processInput(window: pGLFWwindow); cdecl;
begin
if glfwGetKey(window, GLFW_KEY_ESCAPE) = GLFW_PRESS then
begin
glfwSetWindowShouldClose(window, GLFW_TRUE);
end;
end;
// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
procedure framebuffer_size_callback(window: pGLFWwindow; width, height: Integer); cdecl;
begin
// make sure the viewport matches the new window dimensions; note that width and
// height will be significantly larger than specified on retina displays.
glViewport(0, 0, width, height);
end;
procedure showError(error: GLFW_INT; description: PChar); cdecl;
begin
Writeln(description);
end;
var
window: pGLFWwindow;
ourShader :TShader;
// set up vertex data
// ------------------
vertices: array [0..179] of GLfloat = (
// positions // texture coords
-0.5, -0.5, -0.5, 0.0, 0.0,
0.5, -0.5, -0.5, 1.0, 0.0,
0.5, 0.5, -0.5, 1.0, 1.0,
0.5, 0.5, -0.5, 1.0, 1.0,
-0.5, 0.5, -0.5, 0.0, 1.0,
-0.5, -0.5, -0.5, 0.0, 0.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
0.5, -0.5, 0.5, 1.0, 0.0,
0.5, 0.5, 0.5, 1.0, 1.0,
0.5, 0.5, 0.5, 1.0, 1.0,
-0.5, 0.5, 0.5, 0.0, 1.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
-0.5, 0.5, 0.5, 1.0, 0.0,
-0.5, 0.5, -0.5, 1.0, 1.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
-0.5, 0.5, 0.5, 1.0, 0.0,
0.5, 0.5, 0.5, 1.0, 0.0,
0.5, 0.5, -0.5, 1.0, 1.0,
0.5, -0.5, -0.5, 0.0, 1.0,
0.5, -0.5, -0.5, 0.0, 1.0,
0.5, -0.5, 0.5, 0.0, 0.0,
0.5, 0.5, 0.5, 1.0, 0.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
0.5, -0.5, -0.5, 1.0, 1.0,
0.5, -0.5, 0.5, 1.0, 0.0,
0.5, -0.5, 0.5, 1.0, 0.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
-0.5, 0.5, -0.5, 0.0, 1.0,
0.5, 0.5, -0.5, 1.0, 1.0,
0.5, 0.5, 0.5, 1.0, 0.0,
0.5, 0.5, 0.5, 1.0, 0.0,
-0.5, 0.5, 0.5, 0.0, 0.0,
-0.5, 0.5, -0.5, 0.0, 1.0
);
cubePositions : array of Tvector3_single;
VBO, VAO: GLuint;
texture1, texture2: GLuint;
ImageRGB: TMyRGB8BitImage;
ImageRGBA: TMyRGBA8BitImage;
model: Tmatrix4_single;
view: Tmatrix4_single;
projection: Tmatrix4_single;
I: Integer;
angle: Single;
radius: Single;
camX, camZ: Single;
PosVec3, TargetVec3, WorldUpVec3: Tvector3_single;
begin
// glfw: initialize and configure
// ------------------------------
glfwInit;
glfwSetErrorCallback(@showError);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
{$ifdef DARWIN}
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
{$endif}
// glfw window creation
// --------------------
window := glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, 'LearnOpenGL', nil, nil);
if window = nil then
begin
Writeln('Failed to create GLFW window');
glfwTerminate;
Exit;
end;
glfwMakeContextCurrent(window);
glfwSetFramebufferSizeCallback(window, @framebuffer_size_callback);
// GLext: load all OpenGL function pointers
// ----------------------------------------
if Load_GL_version_3_3_CORE = false then
begin
Writeln('OpenGL 3.3 is not supported!');
glfwTerminate;
Exit;
end;
// configure global opengl state
// -----------------------------
glEnable(GL_DEPTH_TEST);
// build and compile our shader zprogram
// -------------------------------------
ourShader := TShader.Create('7.1.camera.vs', '7.1.camera.fs');
// set up buffer(s) and configure vertex attributes
// ------------------------------------------------
// world space positions of our cubes
SetLength(cubePositions, 10);
cubePositions[0].init(0.0, 0.0, 0.0);
cubePositions[1].init(2.0, 5.0, -15.0);
cubePositions[2].init(-1.5, -2.2, -2.5);
cubePositions[3].init(-3.8, -2.0, -12.3);
cubePositions[4].init(2.4, -0.4, -3.5);
cubePositions[5].init(-1.7, 3.0, -7.5);
cubePositions[6].init(1.3, -2.0, -2.5);
cubePositions[7].init(1.5, 2.0, -2.5);
cubePositions[8].init(1.5, 0.2, -1.5);
cubePositions[9].init(-1.3, 1.0, -1.5);
glGenVertexArrays(1, @VAO);
glGenBuffers(1, @VBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), @vertices, GL_STATIC_DRAW);
// position attribute
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), PGLvoid(0));
glEnableVertexAttribArray(0);
// color attribute
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), PGLvoid(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
// load and create a texture
// -------------------------
// texture 1
// ---------
glGenTextures(1, @texture1);
glBindTexture(GL_TEXTURE_2D, texture1); // all upcoming GL_TEXTURE_2D operations now have effect on this texture object
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// load image, create texture and generate mipmaps
ImageRGB := LoadJpegImage('../../../resources/textures/container.jpg', true);
try
if ImageRGB<> nil then
begin
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ImageRGB.Width, ImageRGB.Height, 0, GL_RGB, GL_UNSIGNED_BYTE, ImageRGB.Data);
glGenerateMipmap(GL_TEXTURE_2D);
end;
finally
FreeAndNil(ImageRGB);
end;
// texture 2
// ---------
glGenTextures(1, @texture2);
glBindTexture(GL_TEXTURE_2D, texture2); // all upcoming GL_TEXTURE_2D operations now have effect on this texture object
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// load image, create texture and generate mipmaps
ImageRGBA := LoadPNGImage('../../../resources/textures/awesomeface.png', true);
try
if ImageRGBA<> nil then
begin
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ImageRGBA.Width, ImageRGBA.Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, ImageRGBA.Data);
glGenerateMipmap(GL_TEXTURE_2D);
end;
finally
FreeAndNil(ImageRGBA);
end;
// tell opengl for each sampler to which texture unit it belongs to (only has to be done once)
// -------------------------------------------------------------------------------------------
ourShader.use(); // don't forget to activate/use the shader before setting uniforms!
// either set it manually like so:
ourShader.setInt('texture1', 0);
// or set it via the texture class
ourShader.setInt('texture2', 1);
projection.init_identity;
projection := Perspective(DegToRad(45), SCR_WIDTH / SCR_HEIGHT, 0.1, 100);
ourShader.setMat4('projection', projection);
// render loop
// -----------
while glfwWindowShouldClose(window) = GLFW_FALSE do
begin
// input
// -----
processInput(window);
// render
// ------
glClearColor(0.2, 0.3, 0.3, 1.0);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT); // also clear the depth buffer now!
// bind textures on corresponding texture units
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture2);
// activate shader
ourShader.use();
// camera/view transformation
radius := 10.0;
camX := sin(glfwGetTime) * radius;
camZ := cos(glfwGetTime) * radius;
TargetVec3.init(0.0, 0.0, 0.0);
WorldUpVec3.init(0.0, 1.0, 0.0);
PosVec3.init(camX, 0.0, camZ);
view := LookAt(PosVec3, TargetVec3, WorldUpVec3);
ourShader.setMat4('view', view);
// render boxes
glBindVertexArray(VAO);
for i := Low(cubePositions) to High(cubePositions) do
begin
model.init_identity;
model := TranslateMatrix4(model, cubePositions[i]);
angle := 20.0 * i;
model := RotateMatrix4(model, DegToRad(angle), Vector3(1.0, 0.3, 0.5));
ourShader.setMat4('model', model);
glDrawArrays(GL_TRIANGLES, 0, 36);
end;
// glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
// -------------------------------------------------------------------------------
glfwSwapBuffers(window);
glfwPollEvents;
end;
// optional: de-allocate all resources once they've outlived their purpose:
// ------------------------------------------------------------------------
glDeleteVertexArrays(1, @VAO);
glDeleteBuffers(1, @VBO);
FreeAndNil(ourShader);
// glfw: terminate, clearing all previously allocated GLFW resources.
// ------------------------------------------------------------------
glfwTerminate;
end.
|
unit unixlib;
{$mode objfpc}{$H+}
interface
uses
BaseUnix, fpmimetypes;
procedure SetExecutePermission(const FileName: string);
function GetOSEXEExt():String;
function GetMimeType(const Ext:string):string;
function InstallExitHandler():boolean;
implementation
Uses twexemain; //For CleanupOnExit()
var
FMimeLoaded: boolean;
FMimeTypesFile: string;
function GetMimeType(const Ext:string):string;
begin
if (not FMimeLoaded) then
begin
MimeTypes.LoadFromFile('/etc/mime.types');
FMimeLoaded := True;
end;
Result:=MimeTypes.GetMimeType(Ext);
end;
procedure SetExecutePermission(const FileName: string);
begin
fpChmod(FileName,&751);
end;
function GetOSEXEExt():String;
begin
Result:='';
end;
procedure UnixHandleSignal(Sig : cint);cdecl;
begin
CleanupOnExit();
//Now end the process
//This will not cause infinite recursion because we
//installed the Signal Handler with the SA_ONESHOT flag
FpKill(GetProcessID(),SIGTERM);
end;
function InstallExitHandler():boolean;
Var
oa,na : PSigActionRec;
begin
Result := False;
new(na);
new(oa);
na^.sa_Handler:=SigActionHandler(@UnixHandleSignal);
fillchar(na^.Sa_Mask,sizeof(na^.sa_mask),#0);
na^.Sa_Flags:=SA_ONESHOT or SA_RESTART;
{$ifdef Linux} // Linux specific
na^.Sa_Restorer:=Nil;
{$endif}
if (fpSigAction(SIGINT, na, oa)<>0)
or (fpSigAction(SIGTERM, na, oa) <> 0)
or (fpSigAction(SIGHUP, na, oa) <> 0)
or (fpSigAction(SIGPIPE, na, oa) <> 0) then
Result := False
else
Result := True;
end;
end.
|
Unit BinaryLogHeader;
Interface
Const
LOGHEADER_SIGNATURE = $474f4c4e4d505249;
LOGHEADER_VERSION = 1;
LOGHEADER_ARCHITECTURE_X86 = 1;
LOGHEADER_ARCHITECTURE_X64 = 2;
Type
TBinaryLogHeader = Packed Record
Signature : UInt64;
Version : Cardinal;
Architecture : Cardinal;
Class Function ArchitectureSupported(Var AHeader:TBinaryLogHeader):Boolean; Static;
Class Function SignatureValid(Var AHeader:TBinaryLogHeader):Boolean; Static;
Class Function VersionSupported(Var AHeader:TBinaryLogHeader):Boolean; Static;
Class Procedure Fill(Var AHeader:TBinaryLogHeader); Static;
end;
PBinaryLogHeader = ^TBinaryLogHeader;
Implementation
Class Function TBinaryLogHeader.ArchitectureSupported(Var AHeader:TBinaryLogHeader):Boolean;
Var
arch : Cardinal;
begin
{$IFDEF WIN32}
arch := LOGHEADER_ARCHITECTURE_X86;
{$ELSE}
arch := LOGHEADER_ARCHITECTURE_X64;
{$ENDIF}
Result := (arch = AHeader.Architecture);
end;
Class Function TBinaryLogHeader.SignatureValid(Var AHeader:TBinaryLogHeader):Boolean;
begin
Result := (AHeader.Signature = LOGHEADER_SIGNATURE);
end;
Class Procedure TBinaryLogHeader.Fill(Var AHeader:TBinaryLogHeader);
Var
arch : Cardinal;
begin
AHeader.Signature := LOGHEADER_SIGNATURE;
AHeader.Version := LOGHEADER_VERSION;
{$IFDEF WIN32}
arch := LOGHEADER_ARCHITECTURE_X86;
{$ELSE}
arch := LOGHEADER_ARCHITECTURE_X64;
{$ENDIF}
AHeader.Architecture := arch;
end;
Class Function TBinaryLogHeader.VersionSupported(Var AHeader:TBinaryLogHeader):Boolean;
begin
Result := (AHeader.Version = LOGHEADER_VERSION);
end;
End.
|
PROGRAM bla;
USES sysutils;
const
max = 10;
TYPE
IntegerArray = array of integer;
ProcPtr = function(left, right : integer): integer;
FUNCTION compareTo(left, right : integer) : integer;
BEGIN
if left < right then
begin
exit(-1);
end
else if left > right then
begin
exit(1);
end
else
begin
exit(0);
end
END;
{ Note: "var" means a parameter is passed by REFERENCE }
PROCEDURE qsort(VAR a: IntegerArray; sort_function : ProcPtr);
{ sort array a using quicksort }
procedure sort(l, r: integer);
{ local procedure to sort a[l..r] }
procedure swap(var x, y: integer);
{ local procedure to swap x and y. }
var
tmp : integer;
begin
tmp := x;
x := y;
y := tmp;
end; { swap }
var
i, j, x: integer;
begin
i := l;
j := r;
x := a[Random(r - l) + l];
REPEAT
while sort_function(a[i], x) < 0 do
i := i + 1;
while sort_function(a[j], x) > 0 do
j := j - 1;
if not(i > j) then
begin
swap(a[i], a[j]);
i := i + 1;
j := j - 1;
end;
until i > j;
if l < j then
sort(l, j);
if i < r then
sort(i, r);
end; { sort }
begin
sort(0, Length(a));
end; { qsort }
{ Counts the occurences of separator in str
Taken and modified from: http://lists.freepascal.org/fpc-pascal/2007-July/014721.html}
function Occurs(const str, separator: string): integer;
var
i, nSep: integer;
begin
nSep:= 0;
for i:= 1 to Length(str) do
if str[i] = separator then Inc(nSep);
exit(nSep);
end;
{ Taken and modified from: http://lists.freepascal.org/fpc-pascal/2007-July/014719.html
Splits string containing Integers separated by separator into array of Integer }
function Split(const str, separator: string): IntegerArray;
var
i, n: Integer;
strline, strfield: string;
begin
{ Number of occurences of the separator }
n:= Occurs(str, separator);
{ Size of the array to be returned is the number of occurences of the separator }
SetLength(Split, n + 1);
i := 0;
strline:= str;
repeat
if Pos(separator, strline) > 0 then
begin
strfield:= Copy(strline, 1, Pos(separator, strline) - 1);
strline:= Copy(strline, Pos(separator, strline) + 1, Length(strline) - pos(separator,strline));
end
else
begin
strfield:= strline;
strline:= '';
end;
Split[i]:= StrToInt(strfield);
Inc(i);
until strline= '';
end;
var
data: IntegerArray;
i: integer;
numbersString: String;
numbersArray: IntegerArray;
begin
writeLn('Creating random numbers between 1 and 500000');
randomize;
ReadLn (numbersString);
numbersArray := Split(numbersString, ' ');
writeln('Sorting...');
qsort(numbersArray, @compareTo);
writeln('Printing the numbers:');
for i := 0 to Length(numbersArray) - 1 do
begin
writeln(numbersArray[i]);
end;
end. |
unit FlashEdit;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, ExtCtrls;
type
TFlashEdit = class(TEdit)
private
{ Private declarations }
Text1,Text2 : string;
OldRD : boolean;
AllVisible : boolean;
FFlashPos : string;
FBoutPerSec : byte;
FTimer : TTimer;
FFlashSymb : char;
procedure SetFlashPos( Value: string );
procedure SetBoutPerSec( Value: byte );
procedure HandlerTimer( Sender : TObject );
protected
{ Protected declarations }
public
{ Public declarations }
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
published
{ Published declarations }
property FlashPos : string read FFlashPos write SetFlashPos;
property BoutPerSec : byte read FBoutPerSec write SetBoutPerSec;
property FlashSymb : char read FFlashSymb write FFlashSymb;
procedure CompStr( S1, S2 : string );
end;
procedure Register;
implementation
procedure Register;
begin
RegisterComponents('Losev Controls', [TFlashEdit]);
end;
constructor TFlashEdit.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FTimer:=TTimer.Create(Self);
AllVisible:=true;
FlashPos:='';
BoutPerSec:=5;
FlashSymb:=' ';
FTimer.OnTimer:=HandlerTimer;
end;
destructor TFlashEdit.Destroy;
begin
FTimer.Free;
inherited Destroy;
end;
procedure TFlashEdit.SetFlashPos( Value: string );
var
i : byte;
begin
FTimer.Enabled:=false;
If length(Value)>0 then begin
OldRD:=ReadOnly;
ReadOnly:=true;
Text1:=Text;
Text2:=Text;
For i:=1 to length(Value) do
If byte(Value[i])<=length(Text2) then Text2[byte(Value[i])]:=FlashSymb;
FTimer.Enabled:=true;
end
else begin
If not AllVisible then begin
Text:=Text1;
AllVisible:=true;
end;
if length(FFlashPos)>0 then ReadOnly:=OldRD;
end;
FFlashPos:=Value;
end;
procedure TFlashEdit.SetBoutPerSec( Value: byte );
begin
FBoutPerSec:=Value;
FTimer.Interval:=1000 div FBoutPerSec;
end;
procedure TFlashEdit.CompStr( S1, S2 : string );
var
FP : string;
i,c : byte;
begin
FP:='';
if length(S1)>length(S2) then c:=length(S2) else c:=length(S1);
for i:=1 to c do
if S1[i]<>S2[i] then begin
SetLength( FP, length(FP)+1 );
FP[length(FP)]:=char(i);
end;
FlashPos:=FP;
end;
procedure TFlashEdit.HandlerTimer( Sender : TObject );
begin
AllVisible:=not AllVisible;
If AllVisible then Text:=Text1 else Text:=Text2;
end;
end.
|
unit Grijjy.Http;
{ Windows and Linux Cross-platform HTTP/S client class using scalable sockets }
{$I Grijjy.inc}
interface
uses
System.Classes,
System.SysUtils,
System.StrUtils,
System.SyncObjs,
System.DateUtils,
Grijjy.Uri,
{$IF Defined(MSWINDOWS)}
Grijjy.SocketPool.Win,
{$ELSEIF Defined(LINUX)}
Grijjy.SocketPool.Linux,
{$ELSE}
{$MESSAGE Error 'Unsupported Platform'}
{$ENDIF}
Grijjy.BinaryCoding;
const
{ Socket recv buffer size }
RECV_BUFFER_SIZE = 32768;
{ Timeout for operations }
TIMEOUT_CONNECT = 5000;
TIMEOUT_SEND = 5000;
DEFAULT_TIMEOUT_RECV = 5000;
{ Strings }
S_CONTENT_LENGTH = 'content-length:';
S_TRANSFER_ENCODING = 'transfer-encoding:';
S_CHUNKED = 'chunked';
{ End of line }
CRLF = #13#10;
{ Ports }
DEFAULT_HTTP_PORT = 80;
DEFAULT_HTTPS_PORT = 443;
type
{ HTTP events }
TOnRedirect = procedure(Sender: TObject; var ALocation: UnicodeString; const AFollow: Boolean) of object;
TOnPassword = procedure(Sender: TObject; var AAgain: Boolean) of object;
{ Socket activity state }
TSocketState = (None, Sending, Receiving, Success, Failure);
{ HTTP client }
TgoHTTPClient = class(TObject)
private
FConnection: TgoSocketConnection;
FConnectionLock: TCriticalSection;
{ Recv }
FRecvBuffer: TBytes;
FRecvSize: Integer;
FLastRecv: TDateTime;
{ Send }
FLastSent: TDateTime;
{ Http request }
FURL: UnicodeString;
FMethod: UnicodeString;
FURI: TgoURI;
FLastURI: TgoURI;
FContentLength: Int64;
FTransferEncoding: UnicodeString;
FHTTPVersion: UnicodeString;
FFollowRedirects: Boolean;
FSentCookies: TStrings;
FCookies: TStrings;
FAuthorization: UnicodeString;
FUserName: UnicodeString;
FPassword: UnicodeString;
FContentType: UnicodeString;
FConnected: TEvent;
FRequestHeader: UnicodeString;
FRequestHeaders: TStrings;
FRequestBody: UnicodeString;
FRequestData: TBytes;
FRequestSent: TSocketState;
FUserAgent: UnicodeString;
{ Http response }
FResponseHeaders: TStrings;
FResponseStatusCode: Integer;
FResponseIndexEndOfHeader: Integer;
FResponseRecv: TSocketState;
protected
FOnPassword: TOnPassword;
FOnRedirect: TOnRedirect;
procedure SetCookies(const AValue: TStrings);
private
function GetCookies: TStrings;
private
function BytePos(const ASubStr: AnsiString; AOffset: Integer = 0): Integer;
procedure Reset;
procedure CreateRequest;
procedure SendRequest;
function ResponseHeaderReady: Boolean;
function ResponseContentReady: Boolean;
function ReadResponse: UnicodeString;
function WaitForSendSuccess: Boolean;
function WaitForRecvSuccess(const ARecvTimeout: Integer): Boolean;
function DoResponse(var AAgain: Boolean): UnicodeString;
function DoRequest(const AMethod, AURL: UnicodeString;
const ARecvTimeout: Integer): UnicodeString;
protected
{ Socket routines }
procedure OnSocketConnected;
procedure OnSocketDisconnected;
procedure OnSocketSent(const ABuffer: Pointer; const ASize: Integer);
procedure OnSocketRecv(const ABuffer: Pointer; const ASize: Integer);
public
constructor Create;
destructor Destroy; override;
public
{ Add a header and value to a list of headers }
procedure AddHeader(AHTTPHeaders: TStrings; const AHeader, AValue: UnicodeString);
{ Find the index of a header from a list of headers }
function IndexOfHeader(AHTTPHeaders: TStrings; const AHeader: UnicodeString): Integer;
{ Get the value associated with a header from a list of headers }
function GetHeaderValue(AHTTPHeaders: TStrings; const AHeader: UnicodeString): UnicodeString;
{ Get method }
function Get(const AURL: UnicodeString;
const ARecvTimeout: Integer = DEFAULT_TIMEOUT_RECV): UnicodeString;
{ Post method }
function Post(const AURL: UnicodeString;
const ARecvTimeout: Integer = DEFAULT_TIMEOUT_RECV): UnicodeString;
{ Put method }
function Put(const AURL: UnicodeString;
const ARecvTimeout: Integer = DEFAULT_TIMEOUT_RECV): UnicodeString;
{ Delete method }
function Delete(const AURL: UnicodeString;
const ARecvTimeout: Integer = DEFAULT_TIMEOUT_RECV): UnicodeString;
{ Options method }
function Options(const AURL: UnicodeString;
const ARecvTimeout: Integer = DEFAULT_TIMEOUT_RECV): UnicodeString;
{ Cookies sent to the server and received from the server }
property Cookies: TStrings read GetCookies write SetCookies;
{ Optional body for a request.
You can either use RequestBody or RequestData. If both are specified then
only RequestBody is used. }
property RequestBody: UnicodeString read FRequestBody write FRequestBody;
{ Optional binary body data for a request.
You can either use RequestBody or RequestData. If both are specified then
only RequestBody is used. }
property RequestData: TBytes read FRequestData write FRequestData;
{ Request headers }
property RequestHeaders: TStrings read FRequestHeaders;
{ Response headers from the server }
property ResponseHeaders: TStrings read FResponseHeaders;
{ Response status code }
property ResponseStatusCode: Integer read FResponseStatusCode;
{ Allow 301 and other redirects }
property FollowRedirects: Boolean read FFollowRedirects write FFollowRedirects;
{ Called when a redirect is requested }
property OnRedirect: TOnRedirect read FOnRedirect write FOnRedirect;
{ Called when a password is needed }
property OnPassword: TOnPassword read FOnPassword write FOnPassword;
{ Username and password for Basic Authentication }
property UserName: UnicodeString read FUserName write FUserName;
property Password: UnicodeString read FPassword write FPassword;
{ Content type }
property ContentType: UnicodeString read FContentType write FContentType;
{ User agent }
property UserAgent: UnicodeString read FUserAgent write FUserAgent;
{ Authorization }
property Authorization: UnicodeString read FAuthorization write FAuthorization;
end;
implementation
var
_HTTPClientSocketManager: TgoClientSocketManager;
{ TgoHTTPClient }
constructor TgoHTTPClient.Create;
begin
inherited Create;
FHTTPVersion := '1.1';
FAuthorization := '';
FContentType := '';
FUserAgent := '';
FConnection := nil;
FConnectionLock := TCriticalSection.Create;
FConnected := TEvent.Create(nil, False, False, '');
FFollowRedirects := True;
SetLength(FRecvBuffer, RECV_BUFFER_SIZE);
FRecvSize := 0;
FRequestHeaders := TStringList.Create;
FResponseHeaders := TStringList.Create;
end;
destructor TgoHTTPClient.Destroy;
var
Connection: TgoSocketConnection;
begin
FConnectionLock.Enter;
try
Connection := FConnection;
FConnection := nil;
finally
FConnectionLock.Leave;
end;
if Connection <> nil then
_HTTPClientSocketManager.Release(Connection);
FreeAndNil(FRequestHeaders);
FreeAndNil(FResponseHeaders);
FreeAndNil(FCookies);
FreeAndNil(FSentCookies);
FConnected.Free;
FConnectionLock.Free;
inherited Destroy;
end;
{ Cookies received from the server }
function TgoHTTPClient.GetCookies: TStrings;
begin
if FCookies = nil then
FCookies := TStringList.Create;
Result := FCookies;
end;
{ Cookies sent to the server }
procedure TgoHTTPClient.SetCookies(const AValue: TStrings);
begin
if GetCookies = AValue then
Exit;
GetCookies.Assign(AValue);
end;
{ Add a header and value to a list of headers }
procedure TgoHTTPClient.AddHeader(AHTTPHeaders: TStrings; const AHeader, AValue: UnicodeString);
var
Index: Integer;
begin
Index := IndexOfHeader(AHTTPHeaders, AHeader);
if (Index <> -1) then
AHTTPHeaders.Delete(Index);
AHTTPHeaders.Add(AHeader + ': ' + AValue);
end;
{ Find the index of a header from a list of headers }
function TgoHTTPClient.IndexOfHeader(AHTTPHeaders: TStrings; const AHeader: UnicodeString): Integer;
begin
Result := AHTTPHeaders.Count - 1;
while (Result >= 0) and
(AHTTPHeaders[Result].Substring(0, AHeader.Length).ToLower <> AHeader.ToLower) do
Dec(Result);
end;
{ Get the value associated with a header from a list of headers }
function TgoHTTPClient.GetHeaderValue(AHTTPHeaders: TStrings; const AHeader: UnicodeString): UnicodeString;
var
Index, Pos1: Integer;
begin
Index := IndexOfHeader(AHTTPHeaders, AHeader);
if (Index = -1) then
Result := ''
else
begin
Pos1 := AHTTPHeaders[Index].IndexOf(':');
if Pos1 = -1 then
Result := ''
else
Result := AHTTPHeaders[Index].Substring(Pos1 + 1).TrimLeft;
end;
end;
procedure TgoHTTPClient.Reset;
begin
FRecvSize := 0;
FRequestSent := TSocketState.None;
FResponseRecv := TSocketState.None;
FResponseStatusCode := 0;
FResponseHeaders.Clear;
end;
procedure TgoHTTPClient.CreateRequest;
var
_Username: UnicodeString;
_Password: UnicodeString;
_Cookies: UnicodeString;
Index: Integer;
begin
{ parse the URL into a URI }
FURI := TgoURI.Create(FURL);
{ http or https }
if (FURI.Port = 0) then
begin
if FURI.Scheme.ToLower = 'https' then
FURI.Port := DEFAULT_HTTPS_PORT
else
FURI.Port := DEFAULT_HTTP_PORT;
end;
{ add header status line }
FRequestHeader := FMethod.ToUpper + ' ' + FURI.ToString + ' ' + 'HTTP/' + FHTTPVersion + CRLF;
{ use credentials in URI, if provided }
_Username := FURI.Username;
_Password := FURI.Password;
if (_Username = '') then
begin
{ credentials provided? }
_Username := FUserName;
_Password := FPassword;
end;
if (_Username <> '') then
begin
{ add basic authentication }
FRequestHeader := FRequestHeader + 'Authorization: Basic ' +
TEncoding.Utf8.GetString(goBase64Encode(TEncoding.Utf8.GetBytes(_Username + ':' + _Password))) + CRLF;
{ remove any existing credentials }
Index := IndexOfHeader(FRequestHeaders, 'Authorization');
if Index <> -1 then
FRequestHeaders.Delete(Index);
end
else
{ add authorization }
if (FAuthorization <> '') then
FRequestHeader := FRequestHeader + 'Authorization: ' + FAuthorization + CRLF;
{ add host }
FRequestHeader := FRequestHeader + 'Host: ' + FURI.Host;
if (FURI.Port <> 0) then
FRequestHeader := FRequestHeader + ':' + FURI.Port.ToString;
FRequestHeader := FRequestHeader + CRLF;
{ add user-agent }
if (FUserAgent <> '') then
FRequestHeader := FRequestHeader + 'User-Agent: ' + FUserAgent + CRLF;
{ add content type }
if (FContentType <> '') then
FRequestHeader := FRequestHeader + 'Content-Type: ' + FContentType + CRLF;
{ add content length }
if (FRequestBody <> '') then
FRequestHeader := FRequestHeader + 'Content-Length: ' + IntToStr(Length(FRequestBody)) + CRLF
else if (FRequestData <> nil) then
FRequestHeader := FRequestHeader + 'Content-Length: ' + IntToStr(Length(FRequestData)) + CRLF;
{ add additional request headers, if any }
for Index := 0 to FRequestHeaders.Count - 1 do
FRequestHeader := FRequestHeader + FRequestHeaders[Index] + CRLF;
{ add cookies, if any }
if Assigned(FCookies) then
begin
_Cookies := 'Cookie:';
for Index := 0 to FCookies.Count-1 do
begin
if Index > 0 then
_Cookies := _Cookies + '; ';
_Cookies := _Cookies + FCookies[Index];
end;
FRequestHeader := FRequestHeader + _Cookies + CRLF;
end;
FreeAndNil(FSentCookies);
FSentCookies := FCookies;
FCookies := nil;
FRequestHeader := FRequestHeader + CRLF;
end;
procedure TgoHTTPClient.SendRequest;
var
OK: Boolean;
begin
FConnectionLock.Enter;
try
if (FConnection <> nil) then
begin
OK := FConnection.Send(TEncoding.Utf8.GetBytes(FRequestHeader));
if (FRequestBody <> '') then
OK := OK and FConnection.Send(TEncoding.Utf8.GetBytes(FRequestBody))
else
OK := OK and FConnection.Send(FRequestData);
if OK then
begin
FResponseRecv := TSocketState.Receiving;
FRequestSent := TSocketState.Success;
end
else
FRequestSent := TSocketState.Failure;
end;
finally
FConnectionLock.Leave;
end;
end;
function TgoHTTPClient.BytePos(const ASubStr: AnsiString; AOffset: Integer = 0): Integer;
var
Size: Integer;
begin
Size := Length(ASubStr);
for Result := AOffset to FRecvSize - Size do
if CompareMem(@FRecvBuffer[Result], @ASubStr[1], Size) then
Exit;
Result := -1;
end;
function TgoHTTPClient.ResponseHeaderReady: Boolean;
var
Index: Integer;
Strings: TArray<UnicodeString>;
begin
Index := BytePos(CRLF + CRLF);
if Index > 0 then
begin
Result := True; { header received }
{ headers }
FResponseIndexEndOfHeader := Index + 3;
FResponseHeaders.Text := TEncoding.UTF8.GetString(FRecvBuffer, 0, FResponseIndexEndOfHeader);
{ response status code }
Strings := FResponseHeaders[0].ToLower.Substring(FResponseHeaders[0].ToLower.LastIndexOf('http:/')).Split([#32]);
if Length(Strings) >= 2 then
FResponseStatusCode := StrToInt64Def(Strings[1], -1)
else
FResponseStatusCode := -1;
{ content length or transfer encoding? }
FContentLength := StrToInt64Def(GetHeaderValue(FResponseHeaders, S_CONTENT_LENGTH).Trim, -1);
if FContentLength < 0 then
{ chunked encoding }
FTransferEncoding := GetHeaderValue(FResponseHeaders, S_TRANSFER_ENCODING).Trim;
end
else
Result := False;
end;
function TgoHTTPClient.ResponseContentReady: Boolean;
var
Index: Integer;
S: UnicodeString;
Pos1, Pos2: Integer;
ChunkSize: Integer;
begin
Index := FResponseIndexEndOfHeader + 1;
if FContentLength >= 0 then
begin
if FContentLength = (FRecvSize - Index) then
Result := True
else
Result := False;
end
else
begin
{ chunked encoding }
Result := False;
if FTransferEncoding = S_CHUNKED then
begin
while True do
begin
Pos1 := BytePos(CRLF, Index);
if (Pos1 > 0) then
begin
S := TEncoding.Default.GetString(FRecvBuffer, Index, Pos1 - Index);
Pos2 := S.IndexOf(';'); { skip optional chunk parameters }
if Pos2 > 0 then
S := TEncoding.Default.GetString(FRecvBuffer, Index, Pos2 - Index + 1);
ChunkSize := StrToInt64Def('$' + S, -1);
if ChunkSize = 0 then
begin
Result := True;
Break;
end
else
if ChunkSize > 0 then
begin
{ ChunkSize + Params + CRLF + Chunk + CRLF }
Index := Pos1 + 2 + ChunkSize + 2; { next chunk }
if Index >= FRecvSize then
Break;
end;
end
else
Break;
end;
end;
end;
end;
function TgoHTTPClient.ReadResponse: UnicodeString;
var
Index: Integer;
S: UnicodeString;
Pos1, Pos2: Integer;
ChunkSize: Integer;
begin
Index := FResponseIndexEndOfHeader + 1;
if FContentLength >= 0 then
Result := TEncoding.Default.GetString(FRecvBuffer, Index, FRecvSize - Index)
else
begin
{ chunked encoding }
Result := '';
if FTransferEncoding = S_CHUNKED then
begin
repeat
Pos1 := BytePos(CRLF, Index);
if (Pos1 > 0) then
begin
S := TEncoding.Default.GetString(FRecvBuffer, Index, Pos1 - Index);
Pos2 := S.IndexOf(';'); { skip optional chunk parameters }
if Pos2 > 0 then
S := TEncoding.Default.GetString(FRecvBuffer, Index, Pos2 - Index + 1);
ChunkSize := StrToInt64Def('$' + S, -1);
if ChunkSize > 0 then
begin
{ ChunkSize + Params + CRLF + Chunk + CRLF }
Index := Pos1 + 2; { start of chunk }
Result := Result + TEncoding.Default.GetString(FRecvBuffer, Index, ChunkSize);
Index := Index + ChunkSize + 2; { next chunk }
end;
end
else ChunkSize := -1;
until (ChunkSize <= 0);
end;
end;
end;
function TgoHTTPClient.WaitForSendSuccess: Boolean;
begin
FLastSent := Now;
while (MillisecondsBetween(Now, FLastSent) < TIMEOUT_SEND) and
(FRequestSent = TSocketState.Sending) do
Sleep(5);
Result := FRequestSent = TSocketState.Success;
end;
function TgoHTTPClient.WaitForRecvSuccess(const ARecvTimeout: Integer): Boolean;
begin
FLastRecv := Now;
while (MillisecondsBetween(Now, FLastRecv) < ARecvTimeout) and
(FResponseRecv = TSocketState.Receiving) do
Sleep(5);
Result := FResponseRecv = TSocketState.Success;
end;
function TgoHTTPClient.DoResponse(var AAgain: Boolean): UnicodeString;
var
Location: UnicodeString;
begin
Result := ReadResponse;
case FResponseStatusCode of
301,
302,
303,
307,
308,
808: { redirect? }
begin
if FFollowRedirects then
begin
Location := GetHeaderValue(FResponseHeaders, 'Location');
try
if not Assigned(FOnRedirect) then
begin
FURL := Location;
AAgain := True;
end
else
begin
AAgain := True;
FOnRedirect(Self, Location, AAgain);
if AAgain then
FURL := Location;
end;
if (FResponseStatusCode = 303) then
FMethod := 'GET';
finally
FreeAndNil(FCookies);
FCookies := FSentCookies;
FSentCookies := nil;
end;
end;
end;
401: { password required? }
begin
if Assigned(FOnPassword) then
FOnPassword(Self, AAgain);
end;
end;
end;
function TgoHTTPClient.DoRequest(const AMethod: UnicodeString;
const AURL: UnicodeString; const ARecvTimeout: Integer): UnicodeString;
var
Again: Boolean;
function Connect: Boolean;
begin
FConnectionLock.Enter;
try
if (FConnection <> nil) and
((FURI.Scheme.ToLower <> FLastURI.Scheme) or
(FURI.Host <> FLastURI.Host ) or
(FURI.Port <> FLastURI.Port)) then
begin
_HTTPClientSocketManager.Release(FConnection);
FConnection := nil;
end;
if FConnection = nil then
begin
FConnection := _HTTPClientSocketManager.Request(FURI.Host, FURI.Port);
FConnection.OnConnected := OnSocketConnected;
FConnection.OnDisconnected := OnSocketDisconnected;
FConnection.OnRecv := OnSocketRecv;
if FURI.Scheme.ToLower = 'https' then
FConnection.SSL := True
else
FConnection.SSL := False;
end;
Result := FConnection.State = TgoConnectionState.Connected;
if not Result then
if FConnection.Connect then
Result := FConnected.WaitFor(TIMEOUT_CONNECT) <> wrTimeout;
finally
FConnectionLock.Leave;
end;
end;
begin
Result := '';
FURL := AURL;
FMethod := AMethod;
repeat
Again := False;
Reset;
CreateRequest;
if Connect then
begin
SendRequest;
if (WaitForSendSuccess) and (WaitForRecvSuccess(ARecvTimeout)) then
Result := DoResponse(Again);
FLastURI := FURI;
end;
until not Again;
end;
procedure TgoHTTPClient.OnSocketConnected;
begin
FRequestSent := TSocketState.Sending;
FConnected.SetEvent;
end;
procedure TgoHTTPClient.OnSocketDisconnected;
begin
FRequestSent := TSocketState.None;
FResponseRecv := TSocketState.None;
end;
procedure TgoHTTPClient.OnSocketSent(const ABuffer: Pointer;
const ASize: Integer);
begin
FLastSent := Now;
end;
procedure TgoHTTPClient.OnSocketRecv(const ABuffer: Pointer; const ASize: Integer);
begin
FLastRecv := Now;
{ expand the buffer if we are at capacity }
if FRecvSize + ASize >= Length(FRecvBuffer) then
SetLength(FRecvBuffer, (FRecvSize + ASize) * 2);
{ append the new buffer }
Move(ABuffer^, FRecvBuffer[FRecvSize], ASize);
FRecvSize := FRecvSize + ASize;
{ received both a complete header and content? }
if ResponseHeaderReady and ResponseContentReady then
FResponseRecv := TSocketState.Success;
end;
function TgoHTTPClient.Get(const AURL: UnicodeString;
const ARecvTimeout: Integer): UnicodeString;
begin
Result := DoRequest('GET', AURL, ARecvTimeout);
end;
function TgoHTTPClient.Post(const AURL: UnicodeString;
const ARecvTimeout: Integer): UnicodeString;
begin
Result := DoRequest('POST', AURL, ARecvTimeout);
end;
function TgoHTTPClient.Put(const AURL: UnicodeString;
const ARecvTimeout: Integer): UnicodeString;
begin
Result := DoRequest('PUT', AURL, ARecvTimeout);
end;
function TgoHTTPClient.Delete(const AURL: UnicodeString;
const ARecvTimeout: Integer): UnicodeString;
begin
Result := DoRequest('DELETE', AURL, ARecvTimeout);
end;
function TgoHTTPClient.Options(const AURL: UnicodeString;
const ARecvTimeout: Integer): UnicodeString;
begin
Result := DoRequest('OPTIONS', AURL, ARecvTimeout);
end;
initialization
_HTTPClientSocketManager := TgoClientSocketManager.Create;
finalization
_HTTPClientSocketManager.Free;
end.
|
unit uCollectionUtils;
interface
uses
Generics.Defaults,
Generics.Collections,
System.Classes,
System.SysUtils,
UnitDBDeclare,
UnitINI,
uMemory,
uTranslate,
uCollectionEvents,
uShellUtils;
type
TDatabaseDirectory = class(TDataObject)
private
FPath: string;
FName: string;
FSortOrder: Integer;
public
constructor Create(Path, Name: string; SortOrder: Integer);
function Clone: TDataObject; override;
procedure Assign(Source: TDataObject); override;
property Path: string read FPath write FPath;
property Name: string read FName write FName;
property SortOrder: Integer read FSortOrder write FSortOrder;
end;
procedure SaveDatabaseSyncDirectories(FolderList: TList<TDatabaseDirectory>; CollectionFile: string);
procedure ReadDatabaseSyncDirectories(FolderList: TList<TDatabaseDirectory>; CollectionFile: string);
function IsFileInCollectionDirectories(CollectionFile: string; FileName: string; IsDirectory: Boolean): Boolean;
procedure CheckDefaultSyncDirectoryForCollection(CollectionFile: string);
implementation
{ TDatabaseDirectory }
procedure TDatabaseDirectory.Assign(Source: TDataObject);
var
DD: TDatabaseDirectory;
begin
DD := Source as TDatabaseDirectory;
Self.Path := DD.Path;
Self.Name := DD.Name;
Self.SortOrder := DD.SortOrder;
end;
function TDatabaseDirectory.Clone: TDataObject;
begin
Result := TDatabaseDirectory.Create(Path, Name, SortOrder);
end;
constructor TDatabaseDirectory.Create(Path, Name: string; SortOrder: Integer);
begin
Self.Path := Path;
Self.Name := Name;
Self.SortOrder := SortOrder;
end;
procedure ReadDatabaseSyncDirectories(FolderList: TList<TDatabaseDirectory>; CollectionFile: string);
var
Reg: TBDRegistry;
FName, FPath, FIcon: string;
I, SortOrder: Integer;
S: TStrings;
DD: TDatabaseDirectory;
begin
FolderList.Clear;
Reg := TBDRegistry.Create(REGISTRY_CURRENT_USER);
try
Reg.OpenKey(GetCollectionRootKey(CollectionFile) + '\Directories', True);
S := TStringList.Create;
try
Reg.GetKeyNames(S);
for I := 0 to S.Count - 1 do
begin
Reg.CloseKey;
Reg.OpenKey(GetCollectionRootKey(CollectionFile) + '\Directories\' + S[I], True);
FName := S[I];
FPath := '';
FIcon := '';
SortOrder := 0;
if Reg.ValueExists('Name') then
FName := Reg.ReadString('Name');
if Reg.ValueExists('Path') then
FPath := Reg.ReadString('Path');
if Reg.ValueExists('SortOrder') then
SortOrder := Reg.ReadInteger('SortOrder');
if (FName <> '') and (FPath <> '') then
begin
DD := TDatabaseDirectory.Create(FPath, FName, SortOrder);
FolderList.Add(DD);
end;
end;
finally
F(S);
end;
finally
F(Reg);
end;
FolderList.Sort(TComparer<TDatabaseDirectory>.Construct(
function (const L, R: TDatabaseDirectory): Integer
begin
Result := L.SortOrder - R.SortOrder;
end
));
end;
procedure CheckDefaultSyncDirectoryForCollection(CollectionFile: string);
var
FolderList: TList<TDatabaseDirectory>;
DD: TDatabaseDirectory;
begin
FolderList := TList<TDatabaseDirectory>.Create;
try
ReadDatabaseSyncDirectories(FolderList, CollectionFile);
if (FolderList.Count = 0) then
begin
DD := TDatabaseDirectory.Create(GetMyPicturesPath, TA('My Pictures', 'Explorer'), 0);
FolderList.Add(DD);
SaveDatabaseSyncDirectories(FolderList, CollectionFile);
end;
finally
FreeList(FolderList);
end;
end;
procedure SaveDatabaseSyncDirectories(FolderList: TList<TDatabaseDirectory>; CollectionFile: string);
var
Folder: TDatabaseDirectory;
Reg: TBDRegistry;
S: TStrings;
I: Integer;
EventValue: TEventValues;
begin
Reg := TBDRegistry.Create(REGISTRY_CURRENT_USER);
try
Reg.OpenKey(GetCollectionRootKey(CollectionFile) + '\Directories', True);
S := TStringList.Create;
try
Reg.GetKeyNames(S);
for I := 0 to S.Count - 1 do
Reg.DeleteKey(S[I]);
for I := 0 to FolderList.Count - 1 do
begin
Folder := FolderList[I];
Reg.CloseKey;
Reg.OpenKey(GetCollectionRootKey(CollectionFile) + '\Directories\' + IntToStr(I), True);
Reg.WriteString('Name', Folder.Name);
Reg.WriteString('Path', Folder.Path);
Reg.WriteInteger('SortOrder', Folder.SortOrder);
end;
finally
F(S);
end;
finally
F(Reg);
end;
CollectionEvents.DoIDEvent(nil, 0, [EventID_CollectionFoldersChanged], EventValue);
end;
function IsFileInCollectionDirectories(CollectionFile: string; FileName: string; IsDirectory: Boolean): Boolean;
var
FolderList: TList<TDatabaseDirectory>;
I: Integer;
S, FileDirectory: string;
begin
Result := False;
FileName := ExcludeTrailingPathDelimiter(FileName);
if FileName = '' then
Exit;
if IsDirectory then
FileDirectory := FileName
else
FileDirectory := AnsiLowerCase(ExtractFileDir(FileName));
FolderList := TList<TDatabaseDirectory>.Create;
try
ReadDatabaseSyncDirectories(FolderList, CollectionFile);
for I := 0 to FolderList.Count - 1 do
begin
S := ExcludeTrailingPathDelimiter(AnsiLowerCase(FolderList[I].Path));
if AnsiLowerCase(FileDirectory).StartsWith(S) then
Exit(True);
end;
finally
FreeList(FolderList);
end;
end;
end.
|
unit ThGraphicButton;
interface
uses
Windows, Classes, Controls, StdCtrls, ExtCtrls, Graphics, Messages, SysUtils,
Types,
ThInterfaces, ThCssStyle, ThStyledCtrl, ThWebControl, ThPicture, ThTag,
ThAnchor, ThTextPaint, ThLabel, ThAttributeList, ThStyleList, ThImage;
type
TThGraphicButton = class(TThCustomImage, IThFormInput)
private
Bits: TBitmap;
LeftBits: TBitmap;
MidBits: TBitmap;
RightBits: TBitmap;
FPixelFormat: TPixelFormat;
FTextOffset: Integer;
protected
procedure SetTextOffset(const Value: Integer);
protected
procedure BuildBits; virtual;
procedure CreateSections;
procedure CssStyleChanged; override;
procedure FreeSections;
procedure ImagesToBits;
procedure PaintImage; override;
procedure PerformAutoSize; override;
procedure PictureChange(inSender: TObject); override;
procedure Resize; override;
procedure Tag(inTag: TThTag); override;
procedure TextToBits;
public
constructor Create(inOwner: TComponent); override;
destructor Destroy; override;
property PixelFormat: TPixelFormat read FPixelFormat write FPixelFormat;
published
property Align;
property AltText;
property Anchor;
//property AutoAspect;
property AutoSize;
property Border;
property Caption;
property HAlign;
property Picture;
property Style;
property StyleClass;
property TextOffset: Integer read FTextOffset write SetTextOffset;
property VAlign;
property Visible;
end;
implementation
constructor TThGraphicButton.Create(inOwner: TComponent);
begin
inherited;
Bits := TBitmap.Create;
Pixelformat := pf24bit;
end;
destructor TThGraphicButton.Destroy;
begin
Bits.Free;
inherited;
end;
procedure TThGraphicButton.CssStyleChanged;
begin
inherited;
BuildBits;
end;
procedure TThGraphicButton.PictureChange(inSender: TObject);
begin
inherited;
BuildBits;
end;
procedure TThGraphicButton.Resize;
begin
inherited;
BuildBits;
end;
procedure TThGraphicButton.PerformAutoSize;
begin
if (Picture.Height <> 0) then
Height := Picture.Height;
end;
procedure TThGraphicButton.PaintImage;
begin
with CalcPaintPosition(Bits.Width, Bits.Height) do
Canvas.Draw(x, y, Bits);
end;
procedure TThGraphicButton.BuildBits;
begin
if Bits <> nil then
begin
with Bits do
begin
Width := Self.Width;
Height := Self.Height;
PixelFormat := Self.PixelFormat;
end;
try
if (Picture.HasGraphic) then
begin
CreateSections;
ImagesToBits;
end;
TextToBits;
finally
FreeSections;
end
end;
end;
procedure TThGraphicButton.CreateSections;
var
w, h: Integer;
begin
w := Picture.Width div 2;
h := Picture.Height;
Picture.Graphic.Transparent := true;
//
LeftBits := TBitmap.Create;
with LeftBits do
begin
Width := w;
Height := h;
PixelFormat := Self.PixelFormat;
Canvas.Brush.Color := Self.Color;
Canvas.FillRect(Rect(0, 0, Width, Height));
Canvas.Draw(0, 0, Picture.Graphic);
//FImageList.Draw(Canvas, 0, 0, PaintIndex);
end;
//
MidBits := TBitmap.Create;
with MidBits do
begin
Width := 1;
Height := h;
PixelFormat := Self.PixelFormat;
Canvas.Brush.Color := Self.Color;
Canvas.FillRect(Rect(0, 0, Width, Height));
Canvas.Draw(-w, 0, Picture.Graphic);
//FImageList.Draw(Canvas, -w, 0, PaintIndex);
end;
//
RightBits := TBitmap.Create;
with RightBits do
begin
Width := w;
Height := h;
PixelFormat := Self.PixelFormat;
Canvas.Brush.Color := Self.Color;
Canvas.FillRect(Rect(0, 0, Width, Height));
Canvas.Draw(-w - 1, 0, Picture.Graphic);
//FImageList.Draw(Canvas, -w - 1, 0, PaintIndex);
end;
end;
procedure TThGraphicButton.FreeSections;
begin
FreeAndNil(LeftBits);
FreeAndNil(MidBits);
FreeAndNil(RightBits);
end;
procedure TThGraphicButton.ImagesToBits;
var
w, i, x: Integer;
begin
if (MidBits.Width > 0) then
begin
w := Width - LeftBits.Width - RightBits.Width;
w := w div MidBits.Width;
with Bits do
begin
Width := LeftBits.Width + RightBits.Width + w * MidBits.Width;
Height := Self.Height;
//
Transparent := false;
//
{
with Canvas do
begin
Draw(0, 0, LeftBits);
for i := 0 to w - 1 do
Draw(LeftBits.Width + MidBits.Width * i, 0, MidBits);
Draw(Width - RightBits.Width, 0, RightBits);
end;
}
with Canvas do
begin
StretchDraw(Rect(0, 0, LeftBits.Width, Height), LeftBits);
for i := 0 to w - 1 do
begin
x := LeftBits.Width + MidBits.Width * i;
StretchDraw(Rect(x, 0, x + MidBits.Width, Height), MidBits);
end;
StretchDraw(Rect(Width - RightBits.Width, 0, Width, Height),
RightBits);
end;
end;
end;
end;
procedure TThGraphicButton.TextToBits;
var
h: Integer;
size: TSize;
begin
with Bits, Bits.Canvas do
begin
Font := Self.Font;
Brush.Style := bsClear;
h := Height + TextOffset;
size := TextExtent(Caption);
TextRect(Rect(0, 0, Width, Height),
(Width - size.cx) div 2, (h - size.cy) div 2,
Caption);
end;
end;
procedure TThGraphicButton.Tag(inTag: TThTag);
begin
inherited;
with inTag do
begin
Element := 'input';
Add('type', 'image');
end;
end;
procedure TThGraphicButton.SetTextOffset(const Value: Integer);
begin
FTextOffset := Value;
BuildBits;
Invalidate;
end;
end.
|
(* Generate names and plot elements *)
unit plot_gen;
{$mode objfpc}{$H+}{$R+}
interface
var
playerName: string;
firstSyllable: array[0..73] of
string = ('A', 'Ag', 'Ar', 'Ara', 'Anu', 'Bal', 'Bil', 'Boro',
'Bern', 'Bra', 'Cas', 'Cere', 'Co', 'Con', 'Cor', 'Dag', 'Doo',
'Elen', 'El', 'En', 'Eo', 'Faf', 'Fan', 'Fara', 'Fre', 'Fro',
'Ga', 'Gala', 'Has', 'He', 'Heim', 'Ho', 'Isil', 'In', 'Ini',
'Is', 'Ka', 'Kuo', 'Lance', 'Lo', 'Ma', 'Mag', 'Mi', 'Mo', 'Moon',
'Mor', 'Mora', 'Nin', 'O', 'Obi', 'Og', 'Pelli', 'Por', 'Ran',
'Rud', 'Sam', 'She', 'Sheel', 'Shin', 'Shog', 'Son', 'Sur', 'Theo',
'Tho', 'Tris', 'U', 'Uh', 'Ul', 'Vap', 'Vish', 'Vor', 'Ya', 'Yo', 'Yyr');
secondSyllable: array[0..62] of
string = ('ba', 'bis', 'bo', 'bus', 'da', 'dal', 'dagz', 'den',
'di', 'dil', 'dinn', 'do', 'dor', 'dra', 'dur', 'gi', 'gauble',
'gen', 'glum', 'go', 'gorn', 'goth', 'had', 'hard', 'is', 'karrl',
'ki', 'koon', 'ku', 'lad', 'ler', 'li', 'lot', 'ma', 'man', 'mir',
'mus', 'nan', 'ni', 'nor', 'nu', 'pian', 'ra', 'rakh', 'ric',
'rin', 'rum', 'rus', 'rut', 'sekh', 'sha', 'thos', 'thur', 'toa',
'tu', 'tur', 'tred', 'varl', 'wain', 'wan', 'win', 'wise', 'ya');
(* Generate a name for the player *)
procedure generateName;
implementation
procedure generateName;
var
a, b: byte;
begin
a := Random(73);
b := Random(62);
playerName := firstSyllable[a] + secondSyllable[b];
end;
end.
|
unit UBorrowList;
interface
var
borrowsLen: Integer = 0;
type
// Запись о взятии книги из библиотеки
TBorrow = packed record
code: Integer;
visitorID: Integer;
bookCode: Integer;
borrowDate: TDateTime;
expReturnDate: TDateTime;
realReturnDate: TDateTime;
end;
TBorrows = array of TBorrow;
// Конструктор TBorrow
function toBorrow(const code,
visitorID,
bookCode: Integer;
const borrowDate,
expReturnDate,
realReturnDate:
TDateTime):TBorrow;
// Добавление записи о взятии книги
procedure addBorrow(borrow: TBorrow);
// Возвращает записи о всех взятых книгах библиотеки
function returnAllBorrows:TBorrows;
// Возвращает записи о открытых записях
function returnOpenBorrows:TBorrows;
// Возвращает записи о закрытых записях
function returnClosedBorrows:TBorrows;
// Изменение записи по коду
procedure changeByBorrowCode(code: Integer; newBorrow: TBorrow);
// Поиск записи по коду
function findByBorrowCode(code: Integer):TBorrow;
// Поиск записи по коду посетителя
procedure deleteByVisitorCode(code: Integer);
// Поиск записи по коду книги
procedure deleteByBookCode(code: Integer);
// Удаление записи по коду
procedure deleteByBorrowCode(code: Integer);
// Проверяет, существует ли запись с кодом
function borrowExist(code: Integer):Boolean;
implementation
type
TBorrowList = ^TBorrowElem;
TBorrowElem = packed record
borrow: TBorrow;
next: TBorrowList;
end;
var
borrows: TBorrowList;
// Конструктор TBorrow
function toBorrow(const code,
visitorID,
bookCode: Integer;
const borrowDate,
expReturnDate,
realReturnDate:
TDateTime):TBorrow;
begin
result.code := code;
result.visitorID := visitorID;
result.bookCode := bookCode;
result.borrowDate := borrowDate;
result.expReturnDate := expReturnDate;
result.realReturnDate := realReturnDate;
end;
// Добавление записи о взятии книги
procedure addBorrow(borrow: TBorrow);
var
temp: TBorrowList;
begin
new(temp);
temp^.borrow := borrow;
temp^.next := borrows^.next;
borrows^.next := temp;
inc(borrowsLen);
end;
// Возвращает записи о всех взятых книгах библиотеки
function returnAllBorrows:TBorrows;
var
list: TBorrowList;
begin
list := borrows;
SetLength(result, 0);
while list^.next <> nil do
begin
list := list^.next;
SetLength(result, length(result) + 1);
result[length(result) - 1] := list^.borrow;
end;
end;
// Возвращает записи о открытых записях
function returnOpenBorrows:TBorrows;
var
list: TBorrowList;
begin
list := borrows;
SetLength(result, 0);
while list^.next <> nil do
begin
list := list^.next;
if list^.borrow.realReturnDate = -1 then
begin
SetLength(result, length(result) + 1);
result[length(result) - 1] := list^.borrow;
end;
end;
end;
// Возвращает записи о закрытых записях
function returnClosedBorrows:TBorrows;
var
list: TBorrowList;
begin
list := borrows;
SetLength(result, 0);
while list^.next <> nil do
begin
list := list^.next;
if list^.borrow.realReturnDate <> -1 then
begin
SetLength(result, length(result) + 1);
result[length(result) - 1] := list^.borrow;
end;
end;
end;
// Изменение записи по коду
procedure changeByBorrowCode(code: Integer; newBorrow: TBorrow);
var
list: TBorrowList;
begin
list := borrows;
while (list^.next <> nil) and (list^.next^.borrow.code <> code) do
list := list^.next;
if list^.next <> nil then
list^.next^.borrow := newBorrow;
end;
// Поиск записи по коду
function findByBorrowCode(code: Integer):TBorrow;
var
list: TBorrowList;
begin
list := borrows;
result.code := code - 1;
while list^.next <> nil do
begin
list := list^.next;
if list^.borrow.code = code then
result := list^.borrow;
end;
end;
// Удаление элемента из списка
procedure delete(list: TBorrowList);
var
temp: TBorrowList;
begin
if list^.next <> nil then
begin
temp := list^.next;
list^.next := temp^.next;
dispose(temp);
end;
end;
// Удаление записи по коду
procedure deleteByBorrowCode(code: Integer);
var
list: TBorrowList;
begin
list := borrows;
while list^.next <> nil do
begin
if list^.next^.borrow.code = code then
delete(list)
else
list := list^.next;
end;
end;
// Удаление записи по коду посетителя
procedure deleteByVisitorCode(code: Integer);
var
list: TBorrowList;
begin
list := borrows;
while list^.next <> nil do
begin
if list^.next^.borrow.visitorID = code then
delete(list)
else
list := list^.next;
end;
end;
// Удаление записи по коду книги
procedure deleteByBookCode(code: Integer);
var
list: TBorrowList;
begin
list := borrows;
while list^.next <> nil do
begin
if list^.next^.borrow.bookCode = code then
delete(list)
else
list := list^.next;
end;
end;
// Проверяет, существует ли запись с кодом
function borrowExist(code: Integer):Boolean;
var
list: TBorrowList;
begin
list := borrows;
result := false;
while list^.next <> nil do
begin
list := list^.next;
if list^.borrow.code = code then
result := true;
end;
end;
// Очистка списка
procedure clear(list: TBorrowList);
begin
while list^.next <> nil do
delete(list);
end;
// Создание списка
procedure create(var list: TBorrowList);
begin
new(list);
list^.next := nil;
end;
// Удаление списка
procedure destroy(var list: TBorrowList);
begin
clear(list);
dispose(list);
list := nil;
end;
initialization
create(borrows);
finalization
destroy(borrows);
end.
|
unit main;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls;
type
TfrmMain = class(TForm)
pnlBottom: TPanel;
pnlClient: TPanel;
chkEnter: TCheckBox;
lblTime: TLabel;
edtTime: TEdit;
btnStart: TButton;
btnEnd: TButton;
procedure btnStartClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure btnEndClick(Sender: TObject);
procedure FormDestroy(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
procedure doProcess();
var
frmMain: TfrmMain;
implementation
var
hMutex: THandle;
time: Integer;
withEnter: Boolean;
{$R *.dfm}
procedure TfrmMain.btnStartClick(Sender: TObject);
var
sTime: string;
begin
sTime := Trim(edtTime.Text);
if (sTime <> '') then
begin
time := StrToInt(sTime);
end;
withEnter := chkEnter.Checked;
ReleaseMutex(hMutex);
end;
procedure doProcess();
begin
//
while True do
begin
if WaitForSingleObject(hMutex, INFINITE) = WAIT_OBJECT_0 then
begin
try
sleep(time);
mouse_event(MOUSEEVENTF_RIGHTDOWN,0,0,0,0);//模拟按下鼠标右键。
mouse_event(MOUSEEVENTF_RIGHTUP,0,0,0,0);//模拟放开鼠标右键。
sleep(10);
if withEnter then
begin
keybd_event(VK_RETURN,MapVirtualKey(VK_RETURN,0),0,0);//按下回车键。
keybd_event(VK_RETURN,MapVirtualKey(VK_RETURN,0),KEYEVENTF_KEYUP,0);//放开回车键。
end;
finally
ReleaseMutex(hMutex);
end;
end;
end;
end;
procedure TfrmMain.FormCreate(Sender: TObject);
var
td: THandle;
dw: DWORD;
begin
time := 5000;
withEnter := False;
hMutex := CreateMutex(nil, false, 'autoClick');
WaitForSingleObject(hMutex,INFINITE);
td := CreateThread(nil, 0, @doProcess, nil, 0, dw); //创建一个线程，同时调用线程函数
end;
procedure TfrmMain.btnEndClick(Sender: TObject);
begin
WaitForSingleObject(hMutex,INFINITE);
end;
procedure TfrmMain.FormDestroy(Sender: TObject);
begin
CloseHandle(hMutex);
end;
end.
|
//
// VXScene Component Library, based on GLScene http://glscene.sourceforge.net
//
{
Base classes and logic for DelphiWebScript enabled objects
}
unit VXS.DwsObjects;
interface
uses
System.Classes,
System.SysUtils,
DwsComp,
DwsExprs,
DwsSymbols,
VXS.Scene,
VXS.XCollection,
VXS.ScriptDws,
VXS.BaseClasses,
VXS.Manager;
type
{ A DelphiWebScript enabled behaviour. This behaviour also calls
on the OnProgress and OnBeginProgram procedures in the script if
they are found. Once compiled and executed the program remains
active until killed, deactivated or the script is invalidated. }
TVXDwsActiveBehaviour = class (TVXBehaviour)
private
FActive : Boolean;
FScript : TStringList;
FDwsProgram : TProgram;
FCompiler : TVXDelphiWebScriptII;
FCompilerName : String;
procedure SetActive(const Value : Boolean);
procedure SetScript(const Value : TStringList);
procedure SetCompiler(const Value : TVXDelphiWebScript);
procedure CompileProgram;
procedure BeginProgram;
procedure EndProgram;
procedure KillProgram;
protected
procedure WriteToFiler(writer : TWriter); override;
procedure ReadFromFiler(reader : TReader); override;
procedure Loaded; override;
public
constructor Create(AOwner : TXCollection); override;
destructor Destroy; override;
class function FriendlyName : String; override;
procedure DoProgress(const ProgressTimes : TProgressTimes); override;
procedure InvalidateScript;
property DwsProgram : TProgram read FDwsProgram;
published
property Active : Boolean read FActive write SetActive;
property Script : TStringList read FScript write SetScript;
property Compiler : TVXDelphiWebScriptII read FCompiler write SetCompiler;
end;
procedure Register;
// --------------------------------------------------
implementation
// --------------------------------------------------
// ----------
// ---------- Miscellaneous ----------
// ----------
procedure Register;
begin
RegisterClasses([TVXDwsActiveBehaviour]);
end;
// ----------
// ---------- TVXDwsActiveBehaviour ----------
// ----------
constructor TVXDwsActiveBehaviour.Create(AOwner: TXCollection);
begin
inherited;
FScript:=TStringList.Create;
end;
destructor TVXDwsActiveBehaviour.Destroy;
begin
KillProgram;
FScript.Free;
inherited;
end;
class function TVXDwsActiveBehaviour.FriendlyName: String;
begin
Result:='DWS Active Script';
end;
procedure TVXDwsActiveBehaviour.DoProgress(const ProgressTimes: TProgressTimes);
var
Symbol : TSymbol;
begin
inherited;
if Assigned(FDwsProgram) then begin
if FDwsProgram.ProgramState = psRunning then begin
Symbol:=DwsProgram.Table.FindSymbol('OnProgress');
if Assigned(Symbol) then
if Symbol is TFuncSymbol then
DwsProgram.Info.Func['OnProgress'].Call([ProgressTimes.newTime, ProgressTimes.deltaTime]);
end;
end;
end;
procedure TVXDwsActiveBehaviour.Loaded;
var
temp : TComponent;
begin
inherited;
if FCompilerName<>'' then begin
temp:=FindManager(TVXDelphiWebScript, FCompilerName);
if Assigned(temp) then
Compiler:=TVXDelphiWebScript(temp);
FCompilerName:='';
CompileProgram;
if Active then BeginProgram;
end;
end;
procedure TVXDwsActiveBehaviour.ReadFromFiler(reader: TReader);
begin
inherited;
with reader do begin
Assert(ReadInteger = 0); // Archive version
Active:=ReadBoolean;
FCompilerName:=ReadString;
Script.Text:=ReadString;
end;
end;
procedure TVXDwsActiveBehaviour.WriteToFiler(writer: TWriter);
begin
inherited;
with writer do begin
WriteInteger(0); // Archive version
WriteBoolean(FActive);
if Assigned(FCompiler) then
WriteString(FCompiler.GetNamePath)
else WriteString('');
WriteString(Script.Text);
end;
end;
procedure TVXDwsActiveBehaviour.CompileProgram;
begin
if Assigned(Compiler) then begin
KillProgram;
FDwsProgram:=Compiler.Compile(Script.Text);
if Active then
BeginProgram;
end;
end;
procedure TVXDwsActiveBehaviour.BeginProgram;
var
Symbol : TSymbol;
ObjectID : Variant;
Obj : TVXBaseSceneObject;
begin
if Assigned(DwsProgram) then begin
if DwsProgram.ProgramState = psReadyToRun then begin
DwsProgram.BeginProgram;
if FDwsProgram.ProgramState = psRunning then begin
Symbol:=DwsProgram.Table.FindSymbol('OnBeginProgram');
if Assigned(Symbol) then
if Symbol is TFuncSymbol then begin
Obj:=OwnerBaseSceneObject;
if Assigned(Obj) then begin
ObjectID:=DwsProgram.Info.RegisterExternalObject(Obj, False, False);
DwsProgram.Info.Func['OnBeginProgram'].Call([ObjectID]);
end;
end;
end;
end;
end;
end;
procedure TVXDwsActiveBehaviour.EndProgram;
begin
if Assigned(DwsProgram) then begin
if DwsProgram.ProgramState = psRunning then
DwsProgram.EndProgram;
end;
end;
procedure TVXDwsActiveBehaviour.KillProgram;
begin
if Assigned(DwsProgram) then begin
EndProgram;
FreeAndNil(FDwsProgram);
end;
end;
procedure TVXDwsActiveBehaviour.InvalidateScript;
begin
KillProgram;
CompileProgram;
end;
procedure TVXDwsActiveBehaviour.SetActive(const Value: Boolean);
begin
if Value<>FActive then begin
EndProgram;
FActive:=Value;
if Active then
BeginProgram;
end;
end;
procedure TVXDwsActiveBehaviour.SetScript(const Value: TStringList);
begin
if Assigned(Value) then begin
KillProgram;
FScript.Assign(Value);
if Assigned(Compiler) then begin
CompileProgram;
if Active then BeginProgram;
end;
end;
end;
procedure TVXDwsActiveBehaviour.SetCompiler(const Value: TVXDelphiWebScriptII);
begin
if Value<>FCompiler then begin
if Assigned(FCompiler) then
KillProgram;
FCompiler:=Value;
if Assigned(FCompiler) then begin
RegisterManager(FCompiler);
CompileProgram;
if Active then BeginProgram;
end;
end;
end;
// --------------------------------------------------
initialization
// --------------------------------------------------
RegisterXCollectionItemClass(TVXDwsActiveBehaviour);
// --------------------------------------------------
finalization
// --------------------------------------------------
UnregisterXCollectionItemClass(TVXDwsActiveBehaviour);
end.
|
unit SettingFonts;
interface
uses Graphics,Classes,Controls,StdCtrls,Dialogs;
type
TFontSet=class
private
GroupsNames : TStringList;
GroupsItems : TList;
procedure WriteFont( var f : textfile; Font : TFont; Title : string );
procedure ReadFont( var f : textfile; Font : TFont );
public
constructor Create;
destructor Destroy;
procedure AddGroup( N : string );
procedure AddItem( F : TFont );
function GetFontGroup( G : integer ) : TFont;
procedure SetFontGroup( G : integer; F : TFont );
procedure AssignGroupsNames( LB : TStrings );
procedure DialogSetFontGroup( G : integer );
procedure LoadFonts( NF : string );
procedure SaveFonts( NF : string );
end;
implementation
constructor TFontSet.Create;
begin
inherited Create;
GroupsNames:=TStringList.Create;
GroupsItems:=TList.Create;
end;
destructor TFontSet.Destroy;
var
i : integer;
begin
inherited Destroy;
GroupsNames.Free;
for i:=0 to GroupsItems.Count-1 do TList(GroupsItems.Items[i]).Free;
GroupsItems.Free;
end;
procedure TFontSet.AddGroup( N : string );
var
T : TList;
begin
GroupsNames.Add( N );
T:=TList.Create;
GroupsItems.Add( T );
end;
procedure TFontSet.AddItem( F : TFont );
begin
TList(GroupsItems.Items[GroupsItems.Count-1]).Add( F );
end;
procedure TFontSet.AssignGroupsNames( LB : TStrings );
begin
LB.Assign(GroupsNames);
end;
function TFontSet.GetFontGroup( G : integer ) : TFont;
begin
GetFontGroup:=TFont(TList(GroupsItems.Items[G]).Items[0]);
end;
procedure TFontSet.SetFontGroup( G : integer; F : TFont );
var
i : integer;
ItemsList : TList;
begin
ItemsList:=TList(GroupsItems.Items[G]);
for i:=0 to ItemsList.Count-1 do
TFont(ItemsList.Items[i]).Assign( F );
end;
procedure TFontSet.LoadFonts( NF : string );
var
f : textfile;
G : integer;
Fn : TFont;
begin
Fn:=TFont.Create;
{$I-}
AssignFile( f, NF );
ReSet( f );
If IOResult=0 then begin
for G:=0 to GroupsItems.Count-1 do begin
ReadFont( f, Fn );
SetFontGroup( G, Fn );
end;
IOResult;
end;
CloseFile( f );
IOResult;
Fn.Free;
end;
procedure TFontSet.SaveFonts( NF : string );
var
f : textfile;
G : integer;
begin
{$I-}
AssignFile( f, NF );
Rewrite( f );
If IOResult=0 then begin
for G:=0 to GroupsItems.Count-1 do
WriteFont( f, TFont(TList(GroupsItems.Items[G]).Items[0]), GroupsNames[G] );
IOResult;
end;
CloseFile( f );
IOResult;
end;
procedure TFontSet.DialogSetFontGroup( G : integer );
var
FD : TFontDialog;
begin
FD:=TFontDialog.Create( nil );
FD.Font.Assign( GetFontGroup( G ) );
FD.Execute;
SetFontGroup( G, FD.Font );
FD.Free;
end;
procedure TFontSet.WriteFont( var f : textfile; Font : TFont; Title : string );
begin
{$I-}
with Font do begin
writeln( f, '[', Title, ']' );
writeln( f, Name );
writeln( f, Height );
writeln( f, CharSet );
If fsBold in Style then write( f, 'fsBold ' );
If fsItalic in Style then write( f, 'fsItalic ' );
If fsUnderline in Style then write( f, 'fsUnderline ' );
If fsStrikeout in Style then write( f, 'fsStrikeout ' );
writeln( f );
writeln( f, Color );
writeln( f );
end;
end;
procedure TFontSet.ReadFont( var f : textfile; Font : TFont );
var
N : TFontName;
H : integer;
CS : TFontCharSet;
T : string;
C : TColor;
begin
{$I-}
with Font do begin
readln( f );
readln( f, N ); Name:=N;
readln( f, H ); Height:=H;
readln( f, CS ); CharSet:=CS;
readln( f, T );
Style:=[];
If pos( 'fsBold', T )>0 then Style:=Style+[fsBold];
If pos( 'fsItalic', T )>0 then Style:=Style+[fsItalic];
If pos( 'fsUnderline', T )>0 then Style:=Style+[fsUnderline];
If pos( 'fsStrikeout', T )>0 then Style:=Style+[fsStrikeout];
readln( f, C ); Color:=C;
readln( f );
end;
end;
end.
|
(*
Category: SWAG Title: OOP/TURBO VISION ROUTINES
Original name: 0005.PAS
Description: FILEDLG2.PAS
Author: SWAG SUPPORT TEAM
Date: 05-28-93 13:53
*)
{
>Really like to see is a Real world example. In particular a
>collection of Filenames in the current directory sorted and the
>ability to scroll these Strings vertically. I don't want to go
I don't know if this will help that much, but it does what you requested
<g>... This Compiled in Real mode under BP7 and ran without problems. Although
untested in TP6, it should run fine.
}
Program Example;
Uses
App,
Dialogs,
Drivers,
Menus,
MsgBox,
Objects,
StdDlg,
Views;
Const
cmAbout = 101;
Type
TExampleApp = Object(TApplication)
Procedure CM_About;
Procedure CM_Open;
Procedure HandleEvent(Var Event: TEvent); Virtual;
Constructor Init;
Procedure InitStatusLine; Virtual;
end;
Procedure TExampleApp.CM_About;
begin
MessageBox(
^C'Example O-O Program' + #13 + #13 +
^C'by Bill Himmelstoss (1:112/57)', nil, mfInFormation + mfOkButton
);
end;
Procedure TExampleApp.CM_Open;
Var
FileDialog: PFileDialog;
Filename: FNameStr;
Result: Word;
begin
FileDialog := New(PFileDialog, Init('*.*', 'Open a File', '~N~ame',
fdOpenButton, 100));
Result := ExecuteDialog(FileDialog, @Filename);
if Result <> cmCancel then
MessageBox(^C'You chose '+Filename+'.', nil, mfInFormation + mfOkButton);
end;
Procedure TExampleApp.HandleEvent(Var Event: TEvent); begin
inherited HandleEvent(Event);
Case Event.What of
evCommand:
begin
Case Event.Command of
cmAbout: CM_About;
cmOpen: CM_Open;
else
Exit;
end;
ClearEvent(Event);
end;
end;
end;
Constructor TExampleApp.Init;
Var
Event: TEvent;
begin
inherited Init;
ClearEvent(Event);
Event.What := evCommand;
Event.Command := cmAbout;
PutEvent(Event);
end;
Procedure TExampleApp.InitStatusLine;
Var
R: TRect;
begin
GetExtent(R);
R.A.Y := R.B.Y - 1;
StatusLine := New(PStatusLine, Init(R,
NewStatusDef($0000, $FFFF,
NewStatusKey('~F3~ Open', kbF3, cmOpen,
NewStatusKey('~Alt+X~ Exit', kbAltX, cmQuit,
nil)),
nil)));
end;
Var
ExampleApp: TExampleApp;
begin
ExampleApp.Init;
ExampleApp.Run;
ExampleApp.Done;
end.
|
unit sshbn;
interface
type
BN_STRUCT = record
d: Pointer;
top, dmax, neg, flags: integer;
end;
BIGNUM = ^BN_STRUCT;
PBIGNUM = ^BIGNUM;
function BN_new: BIGNUM; cdecl; external 'libeay32.dll';
procedure BN_init(bn: BIGNUM); cdecl; external 'libeay32.dll';
procedure BN_clear_free(bn: BIGNUM); cdecl; external 'libeay32.dll';
procedure BN_free(bn: BIGNUM); cdecl; external 'libeay32.dll';
function BN_rand(rnd: BIGNUM; bits, top, bottom: integer): BIGNUM;
cdecl; external 'libeay32.dll';
function BN_num_bits(a: BIGNUM): integer; cdecl; external 'libeay32.dll';
//function BN_num_bytes(a:BIGNUM):integer; cdecl ;external 'libeay32.dll';
function BN_bin2bn(s: PChar; len: integer; ret: BIGNUM): BIGNUM; cdecl;
external 'libeay32.dll';
function BN_bn2bin(a: BIGNUM; dest: PChar): integer; cdecl; external 'libeay32.dll';
// this is no use function char * BN_bn2hex(const BIGNUM *a):PChar;
function BN_hex2bn(a: PBIGNUM; str: PChar): integer; cdecl; external 'libeay32.dll';
function BN_bn2hex(a: BIGNUM): PChar; cdecl; external 'libeay32.dll';
function BN_is_bit_set(a: BIGNUM; bit: integer): boolean; cdecl; external 'libeay32.dll';
function BN_cmp(a, b: BIGNUM): integer; cdecl; external 'libeay32.dll';
procedure BN_set_word(a: BIGNUM; w: integer); cdecl; external 'libeay32.dll';
procedure BN_add_word(a: BIGNUM; w: integer); cdecl; external 'libeay32.dll';
procedure BN_lshift(a, b: BIGNUM; len: integer); cdecl; external 'libeay32.dll';
function BN_is_odd(a: BIGNUM): boolean;
function BN_num_bytes(a: BIGNUM): integer;
implementation
uses windows;
function BN_is_odd(a: BIGNUM): boolean;
begin
Result := (a.top > 0) and ((PDWORD(a.d)^ and 1) <> 0);
end;
function BN_num_bytes(a: BIGNUM): integer;
begin
Result := (BN_num_bits(a) + 7) div 8;
end;
end.
|
unit URepositorioStatus;
interface
uses
UStatus
,UEntidade
,URepositorioDB
,SqlExpr
;
type
TRepositorioStatus = class (TRepositorioDB<TSTATUS>)
public
Constructor Create;
procedure AtribuiDBParaEntidade (const coStatus: TSTATUS); override;
procedure AtribuiEntidadeParaDB (const coStatus: TSTATUS;
const coSQLQuery: TSQLQuery); override;
end;
implementation
uses
UDM
;
{ TRepositorioStatus }
procedure TRepositorioStatus.AtribuiDBParaEntidade(const coStatus: TSTATUS);
begin
inherited;
with FSQLSelect do
begin
coStatus.NOME := FieldByName(FLD_STATUS_NOME).AsString;
end;
end;
procedure TRepositorioStatus.AtribuiEntidadeParaDB(const coStatus: TSTATUS;
const coSQLQuery: TSQLQuery);
begin
inherited;
with coSQLQuery do
begin
ParamByName(FLD_STATUS_NOME).AsString := coStatus.NOME;
end;
end;
constructor TRepositorioStatus.Create;
begin
inherited Create (TSTATUS, TBL_STATUS, FLD_ENTIDADE_ID, STR_STATUS);
end;
end.
|
{*******************************************************}
{ }
{ Borland Delphi Visual Component Library }
{ }
{ Copyright (c) 1995-2001 Borland Software Corporation }
{ }
{*******************************************************}
unit Consts;
interface
resourcestring
SOpenFileTitle = 'Abrir';
SCantWriteResourceStreamError = 'Não é possível gravar em um fluxo de recusos somente de leitura';
SDuplicateReference = 'Objeto chamado duas vezes pela mesma instância';
SClassMismatch = 'Arquivo de recursos %s é de classe incorreta';
SInvalidTabIndex = 'Indexador de tabulação fora de faixa';
SInvalidTabPosition = 'Posição da aba incompatível com Estilo da aba corrente';
SInvalidTabStyle = 'Estilo da aba incompatível com a posição da aba corrente';
SInvalidBitmap = 'Bitmap não é válido';
SInvalidIcon = 'Ícone não é válido';
SInvalidMetafile = 'Metafile não é válido';
SInvalidPixelFormat = 'Formato de pixel inválido';
SInvalidImage = 'Formato de fluxo inválido';
SBitmapEmpty = 'Bitmap está vazio';
SScanLine = 'Procura de indexador de linha fora de faixa';
SChangeIconSize = 'Não é possível trocar o tamanho do ícone';
SOleGraphic = 'Operação inválida em TOleGraphic';
SUnknownExtension = 'Arquivo de imagem com extenção (.%s) ignorado';
SUnknownClipboardFormat = 'Formato não suportado';
SOutOfResources = 'Sistema sem recursos';
SNoCanvasHandle = 'O canvas não esta permitindo desenhar';
SInvalidImageSize = 'Tamanho de imagem inválido';
STooManyImages = 'Muitas imagens';
SDimsDoNotMatch = 'Dimensões da imagem diferente da lista de imagens';
SInvalidImageList = 'ImageList inválido';
SReplaceImage = 'Impossibilitado de trocar a imagem';
SImageIndexError = 'Indexador do ImageList inválido';
SImageReadFail = 'Falha ao ler os dados do ImageList para o fluxo';
SImageWriteFail = 'Falha ao gravar dados no ImageList para o fluxo';
SWindowDCError = 'Erro ao criar a janela de contexto do dispositivo';
SClientNotSet = 'Cliente do TDrag não inicializado';
SWindowClass = 'Erro criando a classe da janela';
SWindowCreate = 'Erro criando a janela';
SCannotFocus = 'Não é possível focar uma janela invisível ou não permitida';
SParentRequired = 'Controle ''%s'' não tem antecessor na janela';
SParentGivenNotAParent = 'Controle requerido não é um ancestral de ''%s''';
SMDIChildNotVisible = 'Não é possível esconder um formulário filho MDI';
SVisibleChanged = 'Não é possível trocar a propriedade Visible em OnShow ou OnHide';
SCannotShowModal = 'Não é possível marcar uma janela visível como modal';
SScrollBarRange = 'Propriedade Scrollbar fora de faixa';
SPropertyOutOfRange = 'Propriedade %s fora de faixa';
SMenuIndexError = 'Índice de menu fora de faixa';
SMenuReinserted = 'Menu inserido duas vezes';
SMenuNotFound = 'Sub-menu não está em um menu';
SNoTimers = 'Não há timers suficientes';
SNotPrinting = 'Impressora não está imprimindo agora';
SPrinting = 'Impressão em progresso';
SPrinterIndexError = 'Indice da impressora fora de faixa';
SInvalidPrinter = 'Impressora selecionada não é válida';
SDeviceOnPort = '%s em %s';
SGroupIndexTooLow = 'GroupIndex não pode ser menor que o ítem de menu anterior ao GroupIndex';
STwoMDIForms = 'Não é possível ter mais que um formulário MDI por aplicação';
SNoMDIForm = 'Não é possível criar formulário. Não há formulários MDI ativos neste momento';
SImageCanvasNeedsBitmap = 'Não é possível modificar um TImage que contém um bitmap';
SControlParentSetToSelf = 'Um controle não pode ter ele mesmo como seu antecessor';
SOKButton = 'OK';
SCancelButton = 'Cancelar';
SYesButton = '&Sim';
SNoButton = '&Não';
SHelpButton = '&Ajuda';
SCloseButton = '&Fechar';
SIgnoreButton = '&Ignorar';
SRetryButton = '&Repetir';
SAbortButton = 'Abortar';
SAllButton = '&Todos';
SCannotDragForm = 'Não é possível arrastar um formulário';
SPutObjectError = 'PutObject não definido para ítem';
SCardDLLNotLoaded = 'Não posso carregar CARDS.DLL';
SDuplicateCardId = 'Encontrado uma duplicata de CardId';
SDdeErr = 'Um erro retornado pelo DDE ($0%x)';
SDdeConvErr = 'Erro no DDE - conversação não estabelecida ($0%x)';
SDdeMemErr = 'Erro ocorrido quando DDE rodou sem memória ($0%x)';
SDdeNoConnect = 'Incapaz de conectar conversação DDE';
SFB = 'FB';
SFG = 'FG';
SBG = 'BG';
SOldTShape = 'Não posso carregar uma versão antiga de TShape';
SVMetafiles = 'Metafiles';
SVEnhMetafiles = 'Metafiles realçado';
SVIcons = 'Ícone';
SVBitmaps = 'Bitmaps';
SGridTooLarge = 'Grid muito larga para esta operação';
STooManyDeleted = 'Muitas linhas ou colunas deletadas';
SIndexOutOfRange = 'Índice do grid fora de faixa';
SFixedColTooBig = 'Contador de colunas fixas deve ser menor ou igual que o número de colunas';
SFixedRowTooBig = 'Contador de linhas fixas deve ser menor ou igual ao número de linhas';
SInvalidStringGridOp = 'Não é possível inserir ou deletar linhas da grade';
SInvalidEnumValue = 'Valor Enum inválido';
SInvalidNumber = 'Valor numérico inválido';
SOutlineIndexError = 'Índice de contorno não encontrado';
SOutlineExpandError = 'Antecessor deve ser expandido';
SInvalidCurrentItem = 'Valor inválido para o ítem corrente';
SMaskErr = 'Valor de entrada inválido';
SMaskEditErr = 'Valor de entrada inválido. Use a tecla Esc para abandonar as alterações';
SOutlineError = 'Índice de contorno inválido';
SOutlineBadLevel = 'Nível de transferência incorreto';
SOutlineSelection = 'Seleção inválida';
SOutlineFileLoad = 'Erro ao carregar arquivo';
SOutlineLongLine = 'Linha muito longa';
SOutlineMaxLevels = 'Máxima profundidade do contorno excedida';
SMsgDlgWarning = 'Aviso';
SMsgDlgError = 'Erro';
SMsgDlgInformation = 'Informação';
SMsgDlgConfirm = 'Confirmação';
SMsgDlgYes = '&Sim';
SMsgDlgNo = '&Não';
SMsgDlgOK = 'OK';
SMsgDlgCancel = 'Cancela';
SMsgDlgHelp = '&Ajuda';
SMsgDlgHelpNone = 'Ajuda não disponível';
SMsgDlgHelpHelp = 'Ajuda';
SMsgDlgAbort = '&Abortar';
SMsgDlgRetry = '&Repetir';
SMsgDlgIgnore = '&Ignorar';
SMsgDlgAll = '&Todos';
SMsgDlgNoToAll = 'N&ão para todos';
SMsgDlgYesToAll = 'S&im para todos';
SmkcBkSp = 'BkSp';
SmkcTab = 'Tab';
SmkcEsc = 'Esc';
SmkcEnter = 'Enter';
SmkcSpace = 'Space';
SmkcPgUp = 'PgUp';
SmkcPgDn = 'PgDn';
SmkcEnd = 'End';
SmkcHome = 'Home';
SmkcLeft = 'Left';
SmkcUp = 'Up';
SmkcRight = 'Right';
SmkcDown = 'Down';
SmkcIns = 'Ins';
SmkcDel = 'Del';
SmkcShift = 'Shift+';
SmkcCtrl = 'Ctrl+';
SmkcAlt = 'Alt+';
srUnknown = '(Ignorado)';
srNone = '(Nenhum)';
SOutOfRange = 'Valor deve estar entre %d e %d';
SDateEncodeError = 'Arqumento inválido para decodificar data';
SDefaultFilter = 'Todos os arquivos (*.*)|*.*';
sAllFilter = 'Todos';
SNoVolumeLabel = ': [ - sem rótulo - ]';
SInsertLineError = 'Não é possível inserir linhas';
SConfirmCreateDir = 'O diretório especificado não existe. Criá-lo?';
SSelectDirCap = 'Selecione o diretório';
SDirNameCap = 'Diretório &Nome:';
SDrivesCap = 'D&rives:';
SDirsCap = '&Diretorios:';
SFilesCap = '&Arquivos: (*.*)';
SNetworkCap = 'R&ede...';
SColorPrefix = 'Cor'; //!! obsolete - delete in 5.0
SColorTags = 'ABCDEFGHIJKLMNOP'; //!! obsolete - delete in 5.0
SInvalidClipFmt = 'Formato na área de transferência inválido';
SIconToClipboard = 'Área de transferência não suporta ícones';
SCannotOpenClipboard = 'Problema ao abrir a área de transferência';
SDefault = 'Padrão';
SInvalidMemoSize = 'Texto excedeu a capacidade de 32K';
SCustomColors = 'Personalizar Cores';
SInvalidPrinterOp = 'Operação não suportada ao selecionar impressora';
SNoDefaultPrinter = 'Esta impressora selecionada não é a default';
SIniFileWriteError = 'Incapaz de gravar para %s';
SBitsIndexError = 'Índice de Bits fora de faixa';
SUntitled = '(Sem Título)';
SInvalidRegType = 'Tipo de dado inválido para ''%s''';
SUnknownConversion = 'Incapaz de converter arquivo de extenção (.%s) para RichEdit';
SDuplicateMenus = 'Menu ''%s'' já está inicializado e usado por outro formulário';
SPictureLabel = 'Imagem:';
SPictureDesc = ' (%dx%d)';
SPreviewLabel = 'Visualizar';
SCannotOpenAVI = 'Não é possível abrir arquivo AVI';
SNotOpenErr = 'Dispositivo MCI não aberto';
SMPOpenFilter = 'Todos arquivos (*.*)|*.*|Arquivos wave (*.wav)|*.wav|Arquivos Midi (*.mid)|*.mid|Vídeo para Windows (*.avi)|*.avi';
SMCINil = '';
SMCIAVIVideo = 'AVIVídeo';
SMCICDAudio = 'CDAudio';
SMCIDAT = 'DAT';
SMCIDigitalVideo = 'Vídeo Digital';
SMCIMMMovie = 'MMMovie';
SMCIOther = 'Outro';
SMCIOverlay = 'Sobreposto';
SMCIScanner = 'Scanner';
SMCISequencer = 'Seqüência';
SMCIVCR = 'VCR';
SMCIVideodisc = 'Vídeo disco';
SMCIWaveAudio = 'Áudio Wave';
SMCIUnknownError = 'Código de erro desconhecido';
SBoldItalicFont = 'Negrito Itálico';
SBoldFont = 'Negrito';
SItalicFont = 'Itálico';
SRegularFont = 'Normal';
SPropertiesVerb = 'Propriedades';
SServiceFailed = 'Falha de serviço em %s: %s';
SExecute = 'Executar';
SStart = 'Iniciar';
SStop = 'Parar';
SPause = 'pausa';
SContinue = 'continuar';
SInterrogate = 'interrogar';
SShutdown = 'Reiniciar';
SCustomError = 'Falha de serviço sob a mensagem (%d): %s';
SServiceInstallOK = 'Serviço instalado com sucesso';
SServiceInstallFailed = 'Serviço "%s" falho ou instalado com erro: "%s"';
SServiceUninstallOK = 'Serviço desinstalado com successo';
SServiceUninstallFailed = 'Serviço "%s" falho ou desinstalado com erro: "%s"';
SInvalidActionRegistration = 'Registo de ação inválido';
SInvalidActionUnregistration = 'Ação inválida ao desregistrar';
SInvalidActionEnumeration = 'Ação de enumeração inválida';
SInvalidActionCreation = 'Ação de criação inválida';
SDockedCtlNeedsName = 'O controle acoplado deve ter um conhecido';
SDockTreeRemoveError = 'Erro removendo controle da árvore';
SDockZoneNotFound = ' - Zona da doca não encontrada';
SDockZoneHasNoCtl = ' - Zona da doca não tem controle';
SAllCommands = 'Todos Comandos';
SDuplicateItem = 'Lista não permite duplicados ($0%x)';
STextNotFound = 'Texto não encontrado: "%s"';
SBrowserExecError = 'Nenhum navegador padrão é especificado';
SColorBoxCustomCaption = 'Customizar...';
SMultiSelectRequired = 'Mode multiseleção deve be on for this feature';
SKeyCaption = 'Chave';
SValueCaption = 'Valor';
SKeyConflict = 'Uma chave com o nome de "%s" já existe';
SKeyNotFound = 'Chave "%s" não encontrada';
SNoColumnMoving = 'goColMoving não é uma opção suportada';
SNoEqualsInKey = 'Chave não pode conter sinal igual a ("=")';
SSendError = 'Erro enviando email';
SAssignSubItemError = 'Cannot assign a subitem to an actionbar when one of it''s parent''s is already assigned to an actionbar';
SDeleteItemWithSubItems = 'Item %s possue subitens, apagar mesmo assim?';
SDeleteNotAllowed = 'Você não tem permissão de apagar este item';
SMoveNotAllowed = 'Item %s não tem permissão de ser movido';
SMoreButtons = 'Mais Botões';
SErrorDownloadingURL = 'Erro carregando URL: %s';
SUrlMonDllMissing = 'Impossível carregar %s';
SAllActions = '(Todas as Ações)';
SNoCategory = '(Sem Categoria)';
SExpand = 'Expandir';
SErrorSettingPath = 'Erro ajustando path: "%s"';
SLBPutError = 'Attempting to put items into a virtual style listbox';
SErrorLoadingFile = 'Erro carregando arquivo de ajustes salvos anteriormente: %s'#13'Você gostaria de apagá-lo?';
SResetUsageData = 'Restaurar todos os dados usados?';
SFileRunDialogTitle = 'Executar';
SNoName = '(Sem Nome Name)';
SErrorActionManagerNotAssigned = 'ActionManager deve primeiro ser atribuído';
SAddRemoveButtons = '&Adiciona ou Remove Botões';
SResetActionToolBar = 'Restaurar Toolbar';
SCustomize = '&Customizar';
SSeparator = 'Separador';
SCirularReferencesNotAllowed = 'Referências circulares não permitidas';
SCannotHideActionBand = '%s não permite esconder';
SErrorSettingCount = 'Erro ajustando %s.Count';
SListBoxMustBeVirtual = 'Listbox (%s) stilo deve ser virtual na ordem para ajustar Count';
SUnableToSaveSettings = 'Impossível salvar ajustes';
SRestoreDefaultSchedule = 'Você gostaria de restaurar para a Programação Prioritária padrão?';
SNoGetItemEventHandler = 'Nemhum manipulador de evento OnGetItem atribuído';
SInvalidColorMap = 'Invalid Colormap deste ActionBand requer ColorMaps do tipo TCustomActionBarColorMapEx';
SDuplicateActionBarStyleName = 'Um estilo chamado %s já foi registrado';
SStandardStyleActionBars = 'Estilo Standard';
SXPStyleActionBars = 'Estilo XP';
SActionBarStyleMissing = 'Unit sem nenhum estilo ActionBand presente na cláusula uses.'#13 +
'Sua aplicação deve incluir qualquer XPStyleActnCtrls, StdStyleActnCtrls ou ' +
'um componente ActionBand de terceiros presente na cláusula uses.';
implementation
end.
|
(*
Category: SWAG Title: MATH ROUTINES
Original name: 0050.PAS
Description: Nice Expression Parser
Author: LARS FOSDAL
Date: 11-26-93 17:05
*)
PROGRAM Expr;
{
Simple recursive expression parser based on the TCALC example of TP3.
Written by Lars Fosdal 1987
Released to the public domain 1993
}
PROCEDURE Eval(Formula : String; { Expression to be evaluated}
VAR Value : Real; { Return value }
VAR ErrPos : Integer); { error position }
CONST
Digit: Set of Char = ['0'..'9'];
VAR
Posn : Integer; { Current position in Formula}
CurrChar : Char; { character at Posn in Formula }
PROCEDURE ParseNext; { returnerer neste tegn i Formulaen }
BEGIN
REPEAT
Posn:=Posn+1;
IF Posn<=Length(Formula) THEN CurrChar:=Formula[Posn]
ELSE CurrChar:=^M;
UNTIL CurrChar<>' ';
END { ParseNext };
FUNCTION add_subt: Real;
VAR
E : Real;
Opr : Char;
FUNCTION mult_DIV: Real;
VAR
S : Real;
Opr : Char;
FUNCTION Power: Real;
VAR
T : Real;
FUNCTION SignedOp: Real;
FUNCTION UnsignedOp: Real;
TYPE
StdFunc = (fabs, fsqrt, fsqr, fsin, fcos,
farctan, fln, flog, fexp, ffact);
StdFuncList = ARRAY[StdFunc] of String[6];
CONST
StdFuncName: StdFuncList =
('ABS','SQRT','SQR','SIN','COS',
'ARCTAN','LN','LOG','EXP','FACT');
VAR
E, L, Start : Integer;
Funnet : Boolean;
F : Real;
Sf : StdFunc;
FUNCTION Fact(I: Integer): Real;
BEGIN
IF I > 0 THEN BEGIN Fact:=I*Fact(I-1); END
ELSE Fact:=1;
END { Fact };
BEGIN { FUNCTION UnsignedOp }
IF CurrChar in Digit THEN
BEGIN
Start:=Posn;
REPEAT ParseNext UNTIL not (CurrChar in Digit);
IF CurrChar='.' THEN REPEAT ParseNext UNTIL not (CurrChar in Digit);
IF CurrChar='E' THEN
BEGIN
ParseNext;
REPEAT ParseNext UNTIL not (CurrChar in Digit);
END;
Val(Copy(Formula,Start,Posn-Start),F,ErrPos);
END ELSE
IF CurrChar='(' THEN
BEGIN
ParseNext;
F:=add_subt;
IF CurrChar=')' THEN ParseNext ELSE ErrPos:=Posn;
END ELSE
BEGIN
Funnet:=False;
FOR sf:=fabs TO ffact DO
IF not Funnet THEN
BEGIN
l:=Length(StdFuncName[sf]);
IF Copy(Formula,Posn,l)=StdFuncName[sf] THEN
BEGIN
Posn:=Posn+l-1; ParseNext;
f:=UnsignedOp;
CASE sf of
fabs: f:=abs(f);
fsqrt: f:=SqrT(f);
fsqr: f:=Sqr(f);
fsin: f:=Sin(f);
fcos: f:=Cos(f);
farctan: f:=ArcTan(f);
fln : f:=LN(f);
flog: f:=LN(f)/LN(10);
fexp: f:=EXP(f);
ffact: f:=fact(Trunc(f));
END;
Funnet:=True;
END;
END;
IF not Funnet THEN
BEGIN
ErrPos:=Posn;
f:=0;
END;
END;
UnsignedOp:=F;
END { UnsignedOp};
BEGIN { SignedOp }
IF CurrChar='-' THEN
BEGIN
ParseNext; SignedOp:=-UnsignedOp;
END ELSE SignedOp:=UnsignedOp;
END { SignedOp };
BEGIN { Power }
T:=SignedOp;
WHILE CurrChar='^' DO
BEGIN
ParseNext;
IF t<>0 THEN t:=EXP(LN(abs(t))*SignedOp) ELSE t:=0;
END;
Power:=t;
END { Power };
BEGIN { mult_DIV }
s:=Power;
WHILE CurrChar in ['*','/'] DO
BEGIN
Opr:=CurrChar; ParseNext;
CASE Opr of
'*': s:=s*Power;
'/': s:=s/Power;
END;
END;
mult_DIV:=s;
END { mult_DIV };
BEGIN { add_subt }
E:=mult_DIV;
WHILE CurrChar in ['+','-'] DO
BEGIN
Opr:=CurrChar; ParseNext;
CASE Opr of
'+': e:=e+mult_DIV;
'-': e:=e-mult_DIV;
END;
END;
add_subt:=E;
END { add_subt };
BEGIN {PROC Eval}
IF Formula[1]='.'
THEN Formula:='0'+Formula;
IF Formula[1]='+'
THEN Delete(Formula,1,1);
FOR Posn:=1 TO Length(Formula)
DO Formula[Posn] := Upcase(Formula[Posn]);
Posn:=0;
ParseNext;
Value:=add_subt;
IF CurrChar=^M THEN ErrPos:=0 ELSE ErrPos:=Posn;
END {PROC Eval};
VAR
Formula : String;
Value : Real;
i, Err : Integer;
BEGIN
REPEAT
Writeln;
Write('Enter formula (empty exits): '); Readln(Formula);
IF Formula='' THEN Exit;
Eval(Formula, Value, Err);
Write(Formula);
IF Err=0
THEN Writeln(' = ',Value:0:5)
ELSE BEGIN
Writeln;
FOR i:=1 TO Err-1 DO Write(' ');
Writeln('^-- Error in formula');
END;
UNTIL False;
END.
|
// Cette unité sert à effectuer la lecture d'un fichier de n'importe quel format
// afin de lire sa taille en octets, son type MIME et son contenu. De plus, il
// construit un en-tête contenant des informations sur le fichier.
unit uniteLecteurFichier;
interface
uses SysUtils;
type
// Nom de la classe.
LecteurFichier = class
protected
chemin : String; // Conserve le chemin d'accès d'un fichier.
private
// Cette fonction privée retourne la taille d'un fichier.
// fileName : Chaîne de caractères représentant une chaîne de caractères.
// Retourne une valeur entière de 64 bits.
function fileSize( fileName : String) : Int64;
public
// Ce constructeur sert pour la construction d'un lecteur de fichier.
//@param : Chemin: c'est le chemin d'accès au fichier.
constructor create( unChemin : String );
// Cette fonction permet de retourner la taille d'un fichier en 64 bits.
//@return une valeur entière de 64 bits représentant la taille d'un fichier.
function getTaille : Int64;
// Cette fonction retourne le type MIME d'un fichier de n'importe quel type.
//@return une chaîne de caractères représentant le type MIME.
function getType : String; virtual;
// Cette fonction retourne une en-tête représentant des informations sur le fichier.
//@return une chaîne de caractères représentant des informations sur le fichier.
function getEntete : String;
// Cette fonction retourne le contenu d'un fichier. Elle n'est pas définie
// dans cette classe mais elle doit être définie dans les sous-classes de
// celle-ci.
//@return une chaîne de caractères du contenu d'un fichier.
function lireContenu : WideString; virtual; abstract;
end;
implementation
constructor LecteurFichier.create( unChemin : String );
begin
// Chemin d'accès au fichier.
chemin := unChemin;
end;
function LecteurFichier.fileSize( fileName : String ) : Int64;
var
// Résultat d'une recherche sur le disque.
sr : TSearchRec;
begin
// Trouve la première occurence correspondant à la requête demandée.
// Cette fonction prend en paramètres le nom d'un fichier, un attribut et
// une variable pour le résultat de la recherche. faAnyFile signifie que
// c'est n'importe quel fichier. La fonction retourne 0 si le fichier
// est trouvée.
if FindFirst( fileName, faAnyFile, sr ) = 0 then
// retourne le résultat de la taille du ficher.
result := Int64( sr.FindData.nFileSizeHigh ) shl Int64(32) + Int64( sr.FindData.nFileSizeLow )
else
begin
// Le fichier n'a pas été trouvé.
result := -1;
// Fermeture de la recherche sur le disque.
FindClose( sr ) ;
end;
end;
function LecteurFichier.getTaille : Int64;
begin
// Le fichier n'a pas été trouvé. Une exception est lancée.
if fileSize( chemin ) = -1 then
raise Exception.create( 'Le fichier est inexistant' );
// Le fichier a été trouvée et la taille du fichier est retournée.
result := fileSize( chemin );
end;
function LecteurFichier.getType : String;
begin
// La valeur par défaut du type d'un fichier est application/octet.stream;
result := 'application/octet.stream';
end;
function LecteurFichier.getEntete : String;
begin
// Retourne un en-tête contenant des informations dans un fichier.
result := 'Accept-Ranges: bytes ' + #13#10 + 'Content-Length: ' +
floatToStr( getTaille ) + #13#10 + 'Content-Type: ' + getType + #13#10 + #13#10;
end;
end.
|
unit uSafeRegistry;
interface
uses
SysUtils, Windows, Messages, Classes, StdCtrls, ComCtrls, Registry, Math, Graphics,
Forms;
type
TSafeRegistry = class(TRegistry)
public
procedure ReadListViewWidths(ListView:TListView);
procedure WriteListViewWidths(ListView:TListView);
procedure ReadComboBoxHistory(Key:string; ItemPrefix:string; ComboBox:TComboBox; MaxItems: integer);
procedure WriteComboBoxHistory(Key:string; ItemPrefix:string; ComboBox:TComboBox; MaxItems: integer);
procedure ReadFontData(KeyNamePrefix: string; Font: TFont);
procedure WriteFontData(KeyNamePrefix: string; Font: TFont);
procedure ReadFormLayout(Form: TForm);
procedure WriteFormLayout(Form: TForm);
function ReadString(Name:string; Default:string):string; reintroduce;
function ReadInteger(Name:string; Default:integer):integer; reintroduce;
function ReadBool(Name:string; Default:boolean):boolean; reintroduce;
function ReadFloat(Name:string; Default:double):double; reintroduce;
function ReadBinaryData(Name:string; var Buffer; BufferSize:integer):integer; reintroduce;
end;
implementation
////////////////////////////////////////////////////////////////////////////////////////////
// TSafeRegistry
////////////////////////////////////////////////////////////////////////////////////////////
//------------------------------------------------------------------------------------------
function TSafeRegistry.ReadString(Name:string; Default:string):string;
begin
if ValueExists(Name) then
result:=inherited ReadString(Name)
else
result:=Default;
end;
//------------------------------------------------------------------------------------------
function TSafeRegistry.ReadInteger(Name: string; Default: integer): integer;
begin
if ValueExists(Name) then
result:=inherited ReadInteger(Name)
else
result:=Default;
end;
//------------------------------------------------------------------------------------------
function TSafeRegistry.ReadBool(Name: string; Default: boolean): boolean;
begin
if ValueExists(Name) then
result:=inherited ReadBool(Name)
else
result:=Default;
end;
//------------------------------------------------------------------------------------------
function TSafeRegistry.ReadFloat(Name:string; Default:double):double;
begin
if ValueExists(Name) then
result:=inherited ReadFloat(Name)
else
result:=Default;
end;
//------------------------------------------------------------------------------------------
function TSafeRegistry.ReadBinaryData(Name:string; var Buffer; BufferSize:integer):integer;
begin
if ValueExists(Name) then
result:=inherited ReadBinaryData(Name, Buffer, BufferSize)
else
result:=0;
end;
//------------------------------------------------------------------------------------------
procedure TSafeRegistry.ReadListViewWidths(ListView: TListView);
var
i :integer;
begin
for i:=0 to ListView.Columns.Count-1 do
ListView.Columns[i].Width:=ReadInteger(ListView.Name+IntToStr(i), ListView.Columns[i].Width);
end;
//------------------------------------------------------------------------------------------
procedure TSafeRegistry.WriteListViewWidths(ListView: TListView);
var
i :integer;
begin
for i:=0 to ListView.Columns.Count-1 do
WriteInteger(ListView.Name+IntToStr(i), ListView.Columns[i].Width);
end;
//------------------------------------------------------------------------------------------
procedure TSafeRegistry.ReadComboBoxHistory(Key, ItemPrefix: string; ComboBox: TComboBox; MaxItems: integer);
var
i: integer;
s: string;
n: integer;
begin
ComboBox.Items.Clear;
ComboBox.Items.BeginUpdate;
try
OpenKey(Key, TRUE);
n:=ReadInteger('Count', 0);
n:=Min(n, MaxItems);
for i:=0 to n-1 do begin
s:=ReadString(ItemPrefix+IntToStr(i), '');
if (Length(s)>0) then
ComboBox.Items.Add(s);
end;
ComboBox.Text:=ReadString(ItemPrefix+'Active', '');
finally
ComboBox.Items.EndUpdate;
end;
end;
//------------------------------------------------------------------------------------------
procedure TSafeRegistry.WriteComboBoxHistory(Key, ItemPrefix: string; ComboBox: TComboBox; MaxItems: integer);
var
i: integer;
s: string;
n: integer;
begin
s:=ComboBox.Text;
n:=ComboBox.Items.IndexOf(s);
if (n<>-1) then
ComboBox.Items.Delete(n);
ComboBox.Items.Insert(0, s);
while (ComboBox.Items.Count>MaxItems) do
ComboBox.Items.Delete(ComboBox.Items.Count-1);
OpenKey(Key, TRUE);
n:=Min(ComboBox.Items.Count, MaxItems);
for i:=0 to n-1 do
if (Length(ComboBox.Items[i])>0) then
WriteString(ItemPrefix+IntToStr(i), ComboBox.Items[i]);
WriteInteger('Count', n);
WriteString(ItemPrefix+'Active', s);
end;
//------------------------------------------------------------------------------------------
procedure TSafeRegistry.ReadFontData(KeyNamePrefix: string; Font: TFont);
begin
with Font do begin
Name:=ReadString(KeyNamePrefix+'Name', 'Courier New');
Size:=ReadInteger(KeyNamePrefix+'Size', 10);
Color:=ReadInteger(KeyNamePrefix+'Color', clWindowText);
Style:=TFontStyles(byte(ReadInteger(KeyNamePrefix+'Style', 0)));
end;
end;
//------------------------------------------------------------------------------------------
procedure TSafeRegistry.WriteFontData(KeyNamePrefix: string; Font: TFont);
begin
with Font do begin
WriteString(KeyNamePrefix+'Name', Name);
WriteInteger(KeyNamePrefix+'Size', Size);
WriteInteger(KeyNamePrefix+'Color', Color);
WriteInteger(KeyNamePrefix+'Style', byte(Style));
end;
end;
//------------------------------------------------------------------------------------------
procedure TSafeRegistry.ReadFormLayout(Form: TForm);
var
WinPos: TWindowPlacement;
begin
WinPos.length:=SizeOf(TWindowPlacement);
GetWindowPlacement(Form.Handle, @WinPos);
WinPos.rcNormalPosition.Left:=ReadInteger('FormLeft', Form.Left);
WinPos.rcNormalPosition.Top:=ReadInteger('FormTop', Form.Top);
WinPos.rcNormalPosition.Right:=ReadInteger('FormWidth', Form.Width)+WinPos.rcNormalPosition.Left;
WinPos.rcNormalPosition.Bottom:=ReadInteger('FormHeight', Form.Height)+WinPos.rcNormalPosition.Top;
WinPos.showCmd:=SW_HIDE; // da ne bljesne pri maksimizaciji
SetWindowPlacement(Form.Handle, @WinPos);
if ReadBool('FormMaximized', FALSE) then
Form.WindowState:=wsMaximized;
end;
//------------------------------------------------------------------------------------------
procedure TSafeRegistry.WriteFormLayout(Form: TForm);
var
WinPos: TWindowPlacement;
begin
WinPos.length:=SizeOf(TWindowPlacement);
GetWindowPlacement(Form.Handle, @WinPos);
WriteInteger('FormLeft', WinPos.rcNormalPosition.Left);
WriteInteger('FormTop', WinPos.rcNormalPosition.Top);
WriteInteger('FormWidth', WinPos.rcNormalPosition.Right-WinPos.rcNormalPosition.Left);
WriteInteger('FormHeight', WinPos.rcNormalPosition.Bottom-WinPos.rcNormalPosition.Top);
WriteBool('FormMaximized', Form.WindowState=wsMaximized);
end;
//------------------------------------------------------------------------------------------
end.
|
{******************************************************************************}
{ }
{ WiRL: RESTful Library for Delphi }
{ }
{ Copyright (c) 2015-2019 WiRL Team }
{ }
{ https://github.com/delphi-blocks/WiRL }
{ }
{******************************************************************************}
unit Forms.Main;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs,
WiRL.Client.CustomResource, WiRL.Client.Resource,
WiRL.Client.Application, WiRL.http.Client, FireDAC.Stan.Intf,
FireDAC.Stan.Option, FireDAC.Stan.Param, FireDAC.Stan.Error, FireDAC.DatS,
FireDAC.Phys.Intf, FireDAC.DApt.Intf, System.Rtti, Data.Bind.EngExt,
Fmx.Bind.DBEngExt, Fmx.Bind.Grid, System.Bindings.Outputs, Fmx.Bind.Editors,
Data.Bind.Components, Data.Bind.Grid, Data.Bind.DBScope, FMX.Layouts,
FMX.Grid, Data.DB, FireDAC.Comp.DataSet, FireDAC.Comp.Client,
FMX.Controls.Presentation, FMX.StdCtrls, Data.Bind.Controls,
Fmx.Bind.Navigator, FMX.ListView.Types, FMX.ListView, FMX.Grid.Style,
FMX.ScrollBox, FMX.Memo, WiRL.http.Client.Indy, System.Net.HttpClient.Win,
FMX.Memo.Types, WiRL.Core.MessageBody.Default, WiRL.Data.MessageBody.Default{,
WiRL.Data.FireDAC.MessageBody.Default};
type
TForm1 = class(TForm)
WiRLClient1: TWiRLClient;
WiRLClientApplication1: TWiRLClientApplication;
StringGrid1: TStringGrid;
BindingsList1: TBindingsList;
btnPUT: TButton;
BindNavigator1: TBindNavigator;
Layout1: TLayout;
employee: TFDMemTable;
BindSourceDB2: TBindSourceDB;
LinkGridToDataSourceBindSourceDB2: TLinkGridToDataSource;
btnGETALL: TButton;
memoLog: TMemo;
WiRLClientResource1: TWiRLClientResource;
customers: TFDMemTable;
WiRLClientResource2: TWiRLClientResource;
employeeEmployeeID: TIntegerField;
employeeFirstName: TStringField;
employeeLastName: TStringField;
StringGrid2: TStringGrid;
BindSourceDB1: TBindSourceDB;
LinkGridToDataSourceBindSourceDB1: TLinkGridToDataSource;
customersCompanyName: TStringField;
customersCustomerID: TStringField;
BtnGET: TButton;
procedure btnGETALLClick(Sender: TObject);
procedure btnPUTClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure BtnGETClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.fmx}
procedure TForm1.btnGETALLClick(Sender: TObject);
begin
// Close and clear the datasets
employee.Close;
customers.Close;
WiRLClientResource2.Get<TArray<TDataSet>>([employee,customers]);
end;
procedure TForm1.BtnGETClick(Sender: TObject);
begin
// Close and clear the datasets
employee.Close;
customers.Close;
// DataSet should be open
employee.Open;
WiRLClientResource1.Get(employee);
end;
procedure TForm1.btnPUTClick(Sender: TObject);
begin
// Todo
raise Exception.Create('Not yet implemented');
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
WiRLClientApplication1.SetReaders('*.*');
WiRLClientApplication1.SetWriters('*.*');
end;
end.
|
unit Camera;
interface
uses System.Math.Vectors;
type
TCamera = class
public
canvasDist: Word;
pos: TVector;
look: TVector;
constructor Create(pos, look: TVector; canvasDist: Word);
end;
implementation
{ TCamera }
constructor TCamera.Create(pos, look: TVector; canvasDist: Word);
begin
Self.pos := pos;
Self.look := look;
Self.canvasDist := canvasDist;
end;
end.
|
unit QuickGeneratorForm;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls;
type
TForm4 = class(TForm)
btnMP4: TButton;
btnWEBM: TButton;
btnMP3: TButton;
fps60: TCheckBox;
BestQuality: TRadioButton;
HighQuality: TRadioButton;
MediumQuality: TRadioButton;
LowQuality: TRadioButton;
VideoSettingsGroup: TGroupBox;
VideoAudio: TRadioButton;
AudioSettingsGroup: TGroupBox;
AudioOnly: TRadioButton;
FormatGroup: TGroupBox;
RecodeMP4: TRadioButton;
RecodeAVI: TRadioButton;
RecodeFLV: TRadioButton;
RecodeMKV: TRadioButton;
RecodeWEBM: TRadioButton;
RecodeVideo: TCheckBox;
AudioBest: TRadioButton;
AudioMP3: TRadioButton;
AudioAAC: TRadioButton;
AudioM4A: TRadioButton;
MoreSettingsGroup: TGroupBox;
OneClickGroup: TGroupBox;
BottomButtonPanel: TPanel;
GenerateSettingsBt: TButton;
CancelBt: TButton;
AudioOpus: TRadioButton;
procedure btnMP4Click(Sender: TObject);
procedure btnWEBMClick(Sender: TObject);
procedure btnMP3Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure CancelBtClick(Sender: TObject);
procedure GenerateSettingsBtClick(Sender: TObject);
procedure VideoAudioClick(Sender: TObject);
procedure RecodeVideoClick(Sender: TObject);
procedure AudioOnlyClick(Sender: TObject);
private
{ Private declarations }
public
procedure SettingsSetter;
end;
var
Form4: TForm4;
implementation
{$R *.dfm}
uses MainForm, FormatGeneratorForm;
procedure TForm4.SettingsSetter;
begin
if VideoAudio.Checked then
begin
BestQuality.Enabled := True;
HighQuality.Enabled := True;
MediumQuality.Enabled := True;
LowQuality.Enabled := True;
fps60.Enabled := True;
RecodeVideo.Enabled := True;
BestQuality.Checked := True;
end else
begin
BestQuality.Enabled := false;
HighQuality.Enabled := false;
MediumQuality.Enabled := false;
LowQuality.Enabled := false;
fps60.Enabled := false;
RecodeVideo.Enabled := False;
BestQuality.Checked := false;
HighQuality.Checked := false;
MediumQuality.Checked := false;
LowQuality.Checked := false;
fps60.Checked := false;
RecodeVideo.Checked := False;
end;
if RecodeVideo.Checked then
begin
RecodeMP4.Enabled := true;
RecodeAVI.Enabled := true;
RecodeFLV.Enabled := true;
RecodeMKV.Enabled := true;
RecodeWEBM.Enabled := true;
RecodeMP4.Checked := True;
end else
begin
RecodeMP4.Enabled := false;
RecodeAVI.Enabled := false;
RecodeFLV.Enabled := false;
RecodeMKV.Enabled := false;
RecodeWEBM.Enabled := false;
RecodeMP4.Checked := false;
RecodeAVI.Checked := false;
RecodeFLV.Checked := false;
RecodeMKV.Checked := false;
RecodeWEBM.Checked := false;
end;
if AudioOnly.Checked then
begin
AudioBest.Enabled := true;
AudioMP3.Enabled := true;
AudioAAC.Enabled := true;
AudioM4A.Enabled := true;
AudioOpus.Enabled := true;
AudioBest.Checked := True;
end else
begin
AudioBest.Enabled := false;
AudioMP3.Enabled := false;
AudioAAC.Enabled := false;
AudioM4A.Enabled := false;
AudioOpus.Enabled := false;
AudioBest.Checked := false;
AudioMP3.Checked := false;
AudioAAC.Checked := false;
AudioM4A.Checked := false;
AudioOpus.Checked := false;
end;
end;
procedure TForm4.VideoAudioClick(Sender: TObject);
begin
SettingsSetter;
end;
procedure TForm4.btnMP4Click(Sender: TObject);
begin
Form1.ResetAll(true);
Form1.ignoreerrors.Checked := true;
Form1.outputtemplate_text.Text := '%(title)s.%(ext)s';
Form1.outputtemplate.Checked := true;
Form1.preferffmpeg.Checked := true;
Form1.nocheckcertificate.Checked := true;
Form3.mp4.Checked := true;
Form3.donebtnClick(Form4);
Form1.format.Checked := true;
Form4.Close;
end;
procedure TForm4.btnWEBMClick(Sender: TObject);
begin
Form1.ResetAll(true);
Form1.ignoreerrors.Checked := true;
Form1.outputtemplate_text.Text := '%(title)s.%(ext)s';
Form1.outputtemplate.Checked := true;
Form1.preferffmpeg.Checked := true;
Form1.nocheckcertificate.Checked := true;
Form3.webm9.Checked := true;
Form3.BestQuality.Checked := true;
Form3.donebtnClick(Form4);
Form1.format.Checked := true;
Form4.Close;
end;
procedure TForm4.CancelBtClick(Sender: TObject);
begin
Form4.Hide;
end;
procedure TForm4.AudioOnlyClick(Sender: TObject);
begin
SettingsSetter;
end;
procedure TForm4.btnMP3Click(Sender: TObject);
begin
Form1.ResetAll(true);
Form1.ignoreerrors.Checked := true;
Form1.extractaudio.Checked := true;
Form1.audioformat.Checked := true;
Form1.audioformat_text.Text := 'mp3';
Form4.Close;
end;
procedure TForm4.FormCreate(Sender: TObject);
begin
BestQuality.Checked := true;
VideoAudio.Checked := true;
end;
procedure TForm4.GenerateSettingsBtClick(Sender: TObject);
begin
Form1.ResetAll(true);
Form1.ignoreerrors.Checked := true;
Form1.outputtemplate_text.Text := '%(title)s.%(ext)s';
Form1.outputtemplate.Checked := true;
Form1.preferffmpeg.Checked := true;
Form1.nocheckcertificate.Checked := true;
if VideoAudio.Checked then
begin
Form3.mp4.Checked := True;
if RecodeVideo.Checked then
Form1.recodevideo.Checked := True;
begin
if RecodeMP4.Checked then
begin
Form1.recodevideo_text.Text := 'mp4';
end;
if RecodeAVI.Checked then
begin
Form1.recodevideo_text.Text := 'avi';
end;
if RecodeFLV.Checked then
begin
Form1.recodevideo_text.Text := 'flv';
end;
if RecodeMKV.Checked then
begin
Form1.recodevideo_text.Text := 'mkv';
end;
if RecodeWEBM.Checked then
begin
Form1.recodevideo_text.Text := 'webm';
end;
end;
if BestQuality.Checked then
begin
Form3.BestQuality.Checked := true;
if fps60.Checked then
Form3.fps60.Checked := true;
end;
if HighQuality.Checked then
begin
Form3.p1080.Checked := true;
if fps60.Checked then
Form3.fps60.Checked := true;
end;
if MediumQuality.Checked then
begin
Form3.p720.Checked := true;
if fps60.Checked then
Form3.fps60.Checked := true;
end;
if LowQuality.Checked then
begin
Form3.p480.Checked := true;
if fps60.Checked then
Form3.fps60.Checked := true;
end;
Form3.donebtn.Click;
end;
if AudioOnly.Checked then
begin
Form1.extractaudio.Checked := true;
Form1.audioformat.Checked := true;
Form1.audioquality.Checked := true;
Form1.audioquality_text.Text := '0';
if AudioBest.Checked then
begin
Form1.audioformat_text.Text := 'best';
end;
if AudioMP3.Checked then
begin
Form1.audioformat_text.Text := 'mp3';
end;
if AudioAAC.Checked then
begin
Form1.audioformat_text.Text := 'aac';
end;
if AudioM4A.Checked then
begin
Form1.audioformat_text.Text := 'm4a';
end;
if AudioOpus.Checked then
begin
Form1.audioformat_text.Text := 'opus';
end;
end;
Form4.Close;
end;
procedure TForm4.RecodeVideoClick(Sender: TObject);
begin
SettingsSetter;
end;
end.
|
unit uMyController;
interface
uses System.SysUtils,System.Classes, controller;
type
MyController = class (TController)
public
function hello : String;
function helloWithParam(param : String) : String;
end;
implementation
function MyController.hello: String;
begin
result := 'Hello!';
end;
function MyController.helloWithParam(param: String): String;
begin
result := 'Hello '+param+'!';
end;
initialization
RegisterClass(MyController);
finalization
UnRegisterClass(MyController);
end.
|
unit UIconData;
interface
type
TDevice = (iPhone, iPad);
TiOS = (iOS5, iOS6, iOS7, iOS8);
TiOSSet = set of TiOS;
TIconSizes = (Size1, Size2, Size3);
TIconSizesSet = Set of TIconSizes;
TIconInstance = record
public
Name: string;
Width: Integer;
Height: Integer;
Sizes: TIconSizesSet;
Device: TDevice;
iOS: TiOSSet;
end;
const
iOSIcons: array[0..10] of TIconInstance =
(
//iphone ios5
(Name: 'Spotlight and Settings'; Width: 29; Height: 29; Sizes: [Size1, Size2]; Device: iPhone; iOS: [iOS5..iOS6]),
(Name: 'App'; Width: 57; Height: 57; Sizes: [Size1, Size2]; Device: iPhone; iOS: [iOS5..iOS6]),
//iphone ios7
(Name: 'Settings'; Width: 29; Height: 29; Sizes: [Size2, Size3]; Device: iPhone; iOS: [iOS7..iOS8]),
(Name: 'Spotlight'; Width: 40; Height: 40; Sizes: [Size2, Size3]; Device: iPhone; iOS: [iOS7..iOS8]),
(Name: 'App'; Width: 60; Height: 60; Sizes: [Size2, Size3]; Device: iPhone; iOS: [iOS7..iOS8]),
//iPad ios5
(Name: 'Settings'; Width: 29; Height: 29; Sizes: [Size1, Size2]; Device: iPad; iOS: [iOS5..iOS6]),
(Name: 'Spotlight'; Width: 50; Height: 50; Sizes: [Size1, Size2]; Device: iPad; iOS: [iOS5..iOS6]),
(Name: 'App'; Width: 72; Height: 72; Sizes: [Size1, Size2]; Device: iPad; iOS: [iOS5..iOS6]),
//iPad ios7
(Name: 'Settings'; Width: 29; Height: 29; Sizes: [Size1, Size2]; Device: iPad; iOS: [iOS7..iOS8]),
(Name: 'Spotlight'; Width: 40; Height: 40; Sizes: [Size1, Size2]; Device: iPad; iOS: [iOS7..iOS8]),
(Name: 'App'; Width: 76; Height: 76; Sizes: [Size1, Size2]; Device: iPad; iOS: [iOS7..iOS8])
);
IOSLaunch: array[0..10] of TIconInstance =
(
//iPhone ios5
(Name: 'Portrait'; Width: 320; Height: 480; Sizes: [Size1, Size2]; Device: iPhone; iOS: [iOS5..iOS6]),
(Name: 'Retina 4'; Width: 640; Height: 1136; Sizes: [Size1]; Device: iPhone; iOS: [iOS5..iOS6]),
//iPhone ios7
(Name: 'Portrait'; Width: 320; Height: 480; Sizes: [Size2]; Device: iPhone; iOS: [iOS7..iOS8]),
(Name: 'Portrait Retina 4'; Width: 640; Height: 1136; Sizes: [Size1]; Device: iPhone; iOS: [iOS7..iOS8]),
//iPhone ios8
(Name: 'Portrait Retina HD 4.7'; Width: 750; Height: 1334; Sizes: [Size1]; Device: iPhone; iOS: [iOS8]),
(Name: 'Portrait Retina HD 5.5'; Width: 1242; Height: 2208; Sizes: [Size1]; Device: iPhone; iOS: [iOS8]),
(Name: 'Landscape Retina HD 5.5'; Width: 2208; Height: 1242; Sizes: [Size1]; Device: iPhone; iOS: [iOS8]),
//iPad ios5 / 8
(Name: 'Portrait'; Width: 768; Height: 1024; Sizes: [Size1, Size2]; Device: iPad; iOS: [iOS5..iOS8]),
(Name: 'Portrait without status bar'; Width: 768; Height: 1004; Sizes: [Size1, Size2]; Device: iPad; iOS: [iOS5..iOS6]),
(Name: 'Landscape'; Width: 1024; Height: 768; Sizes: [Size1, Size2]; Device: iPad; iOS: [iOS5..iOS8]),
(Name: 'Landscape without status bar'; Width: 1024; Height: 748; Sizes: [Size1, Size2]; Device: iPad; iOS: [iOS5..iOS6])
);
implementation
end.
|
unit uTranslate;
interface
{$WARN SYMBOL_PLATFORM OFF}
uses
System.Classes,
System.SysUtils,
System.SyncObjs,
System.Win.Registry,
Winapi.Windows,
MSXML2_TLB,
uLogger,
uMemory,
uConstants,
uRuntime,
uTime,
uXMLUtils;
type
TTranslate = class(TObject)
private
FOriginal: string;
FTranslate: string;
public
constructor Create(Node: IXMLDOMNode);
property Original: string read FOriginal write FOriginal;
property Translate: string read FTranslate write FTranslate;
end;
TLanguageScope = class(TObject)
private
FScope: string;
FTranslateList: TList;
FParced: Boolean;
FScopeNode: IXMLDOMNode;
function GetTranslate(index: Integer): TTranslate;
protected
procedure LoadTranslateList(ScopeNode: IXMLDOMNode);
public
constructor Create(ScopeNode: IXMLDOMNode);
destructor Destroy; override;
function Translate(Original: string; out ATranslate: string): Boolean;
property Scope: string read FScope write FScope;
property Items[index: Integer]: TTranslate read GetTranslate; default;
end;
type
TLanguage = class(TObject)
private
FTranslate: IXMLDOMDocument;
FTranslateList: TList;
FName: string;
FImageName: string;
FAutor: string;
FCode: string;
FLangCode: Integer;
FLastScope: TLanguageScope;
public
constructor Create(FileName: string; Flags: Integer = 0);
constructor CreateFromXML(XML: string);
procedure Init;
destructor Destroy; override;
procedure LoadTranslationList;
function LocateString(Original, Scope: string): string;
property name: string read FName;
property ImageName: string read FImageName;
property Autor: string read FAutor;
property Code: string read FCode;
property LangCode: Integer read FLangCode;
end;
TTranslateManager = class(TObject)
private
FSync: TCriticalSection;
FLanguage: TLanguage;
FLanguageCode: string;
FIsTranslating: Boolean;
constructor Create;
function GetLanguage: string;
procedure SetLanguage(const Value: string);
protected
function LocateString(const Original, Scope: string): string;
public
destructor Destroy; override;
class function Instance: TTranslateManager;
procedure BeginTranslate;
procedure EndTranslate;
function TA(const StringToTranslate, Scope: string): string; overload;
function TA(const StringToTranslate: string): string; overload;
function Translate(const StringToTranslate: string): string; overload;
function Translate(const StringToTranslate, Scope: string): string; overload;
function SmartTranslate(const StringToTranslate, Scope: string): string;
property Language: string read GetLanguage write SetLanguage;
property IsTranslating: Boolean read FIsTranslating write FIsTranslating;
end;
TLanguageInitCallBack = procedure(var Language: TLanguage; var LanguageCode: string);
function TA(const StringToTranslate, Scope: string): string; overload;
function TA(const StringToTranslate: string): string; overload;
procedure LoadLanguageFromFile(var Language: TLanguage; var LanguageCode: string);
function ResolveLanguageString(S: string): string;
var
LanguageInitCallBack: TLanguageInitCallBack = LoadLanguageFromFile;
procedure UnloadTranslateModule;
implementation
var
TranslateManager: TTranslateManager = nil;
procedure UnloadTranslateModule;
begin
F(TranslateManager);
end;
function ResolveLanguageString(S: string): string;
begin
Result := StringReplace(S, '{LNG}', AnsiLowerCase(TTranslateManager.Instance.Language), [RfReplaceAll, RfIgnoreCase]);
end;
procedure LoadLanguageFromFile(var Language: TLanguage; var LanguageCode: string);
var
LanguagePath: string;
Reg: TRegistry;
begin
TW.I.Start('LoadLanguageFromFile - START');
if LanguageCode = '--' then
begin
Reg := TRegistry.Create(KEY_READ);
try
Reg.RootKey := HKEY_LOCAL_MACHINE;
Reg.OpenKey(RegRoot, False);
LanguageCode := Reg.ReadString('Language');
finally
F(Reg);
end;
end;
if LanguageCode = '' then
LanguageCode := 'en';
LanguagePath := ExtractFilePath(ParamStr(0)) + Format('Languages\%s%s.xml', [LanguageFileMask, LanguageCode]);
try
TW.I.Start(' TLanguage.Create - START');
Language := TLanguage.Create(LanguagePath);
TW.I.Start(' TLanguage.Create - END');
except
on e : Exception do
EventLog(e.Message);
end;
end;
function TA(const StringToTranslate, Scope: string): string; overload;
begin
Result := TTranslateManager.Instance.TA(StringToTranslate, Scope);
end;
function TA(const StringToTranslate: string): string; overload;
begin
Result := TTranslateManager.Instance.TA(StringToTranslate);
end;
{ TTranslateManager }
procedure TTranslateManager.BeginTranslate;
begin
FSync.Enter;
FIsTranslating := True;
end;
constructor TTranslateManager.Create;
begin
TW.I.Start('TTranslateManager.Create - START');
FIsTranslating := True;
FLanguageCode := '--';
FSync := TCriticalSection.Create;
FSync.Enter;
try
FLanguage := nil;
TW.I.Start('TTranslateManager.Create - LOAD');
LanguageInitCallBack(FLanguage, FLanguageCode);
finally
FSync.Leave;
end;
TW.I.Start('TTranslateManager.Create - END');
end;
destructor TTranslateManager.Destroy;
begin
FSync.Enter;
try
F(FLanguage);
TranslateManager := nil;
finally
FSync.Leave;
end;
F(FSync);
inherited;
end;
procedure TTranslateManager.EndTranslate;
begin
FIsTranslating := False;
FSync.Leave;
end;
function TTranslateManager.GetLanguage: string;
begin
Result := FLanguageCode;
end;
class function TTranslateManager.Instance: TTranslateManager;
begin
if TranslateManager = nil then
TranslateManager := TTranslateManager.Create;
Result := TranslateManager;
end;
function TTranslateManager.LocateString(const Original, Scope: string): string;
begin
Result := FLanguage.LocateString(Original, Scope);
end;
procedure TTranslateManager.SetLanguage(const Value: string);
begin
FLanguageCode := Value;
F(FLanguage);
LanguageInitCallBack(FLanguage, FLanguageCode);
end;
function TTranslateManager.SmartTranslate(const StringToTranslate,
Scope: string): string;
begin
if FIsTranslating then
Result := Translate(StringToTranslate, Scope)
else
Result := TA(StringToTranslate, Scope);
end;
function TTranslateManager.TA(const StringToTranslate, Scope: string): string;
begin
BeginTranslate;
try
Result := Translate(StringToTranslate, Scope);
finally
EndTranslate;
end;
end;
function TTranslateManager.TA(const StringToTranslate: string): string;
begin
BeginTranslate;
try
Result := Translate(StringToTranslate);
finally
EndTranslate;
end;
end;
function TTranslateManager.Translate(const StringToTranslate, Scope: string): string;
begin
Result := LocateString(StringToTranslate, Scope);
end;
function TTranslateManager.Translate(const StringToTranslate: string): string;
begin
Result := LocateString(StringToTranslate, '');
end;
{ TLanguageScope }
constructor TLanguageScope.Create(ScopeNode: IXMLDOMNode);
var
NameAttr: IXMLDOMNode;
begin
FScopeNode := ScopeNode;
FTranslateList := TList.Create;
NameAttr := ScopeNode.attributes.getNamedItem('name');
if NameAttr <> nil then
FScope := NameAttr.text;
FParced := False;
end;
destructor TLanguageScope.Destroy;
begin
FreeList(FTranslateList);
inherited;
end;
function TLanguageScope.GetTranslate(Index: Integer): TTranslate;
begin
if not FParced then
begin
FParced := True;
LoadTranslateList(FScopeNode);
end;
Result := FTranslateList[Index];
end;
function TLanguageScope.Translate(Original: string; out ATranslate : string): Boolean;
var
I: Integer;
Translate: TTranslate;
begin
Result := False;
ATranslate := Original;
if not FParced then
begin
FParced := True;
LoadTranslateList(FScopeNode);
end;
for I := 0 to FTranslateList.Count - 1 do
begin
Translate := FTranslateList[I];
if Translate.FOriginal = Original then
begin
ATranslate := Translate.FTranslate;
Result := True;
Exit;
end;
end;
end;
procedure TLanguageScope.LoadTranslateList(ScopeNode: IXMLDOMNode);
var
I: Integer;
TranslateList: IXMLDOMNodeList;
TranslateNode: IXMLDOMNode;
Translate: TTranslate;
begin
TranslateList := ScopeNode.childNodes;
if TranslateList <> nil then
begin
for I := 0 to TranslateList.length - 1 do
begin
TranslateNode := TranslateList.item[I];
Translate := TTranslate.Create(TranslateNode);
FTranslateList.Add(Translate);
end;
end;
end;
{ TTranslate }
constructor TTranslate.Create(Node: IXMLDOMNode);
var
NameAttr: IXMLDOMNode;
ValueAttr: IXMLDOMNode;
begin
NameAttr := Node.attributes.getNamedItem('name');
if NameAttr <> nil then
FOriginal := StringReplace(NameAttr.text, '$nl$', #13, [rfReplaceAll]);
ValueAttr := Node.attributes.getNamedItem('value');
if ValueAttr <> nil then
FTranslate := StringReplace(ValueAttr.text, '$nl$', #13, [rfReplaceAll]);
end;
{ TLanguage }
constructor TLanguage.Create(FileName: string; Flags: Integer = 0);
begin
Init;
if FTranslate.load(FileName) then
LoadTranslationList;
end;
constructor TLanguage.CreateFromXML(XML: string);
begin
Init;
FTranslate.loadXML(XML);
LoadTranslationList;
end;
destructor TLanguage.Destroy;
begin
FTranslate := nil;
FreeList(FTranslateList);
inherited;
end;
procedure TLanguage.Init;
begin
FLastScope := nil;
FTranslateList := TList.Create;
FTranslate := CreateXMLDocument;
FLangCode := 0;
FCode := '--';
FAutor := '';
end;
procedure TLanguage.LoadTranslationList;
var
DocumentElement: IXMLDOMElement;
ScopeList: IXMLDOMNodeList;
ScopeNode: IXMLDOMNode;
AutorNameAttr,
NameAttr,
CodeAttr,
LangCodeAttr,
ImageNameAttr: IXMLDOMNode;
I: Integer;
Scope: TLanguageScope;
begin
FTranslateList.Clear;
DocumentElement := FTranslate.documentElement;
if DocumentElement <> nil then
begin
NameAttr := DocumentElement.attributes.getNamedItem('name');
if NameAttr <> nil then
FName := NameAttr.text;
ImageNameAttr := DocumentElement.attributes.getNamedItem('image');
if ImageNameAttr <> nil then
FImageName := ImageNameAttr.text;
AutorNameAttr := DocumentElement.attributes.getNamedItem('autor');
if AutorNameAttr <> nil then
FAutor := AutorNameAttr.text;
CodeAttr := DocumentElement.attributes.getNamedItem('code');
if CodeAttr <> nil then
FCode := CodeAttr.text;
LangCodeAttr := DocumentElement.attributes.getNamedItem('langCode');
if LangCodeAttr <> nil then
FLangCode := StrToIntDef(LangCodeAttr.text, 0);
ScopeList := DocumentElement.childNodes;
if ScopeList <> nil then
begin
for I := 0 to ScopeList.length - 1 do
begin
ScopeNode := ScopeList.item[I];
Scope := TLanguageScope.Create(ScopeNode);
FTranslateList.Add(Scope);
end;
end;
end;
end;
function TLanguage.LocateString(Original, Scope: string): string;
var
I: Integer;
FScope: TLanguageScope;
begin
Original := StringReplace(Original, '$nl$', #13, [rfReplaceAll]);
Result := Original;
//if some form uses a lot of translations - try to cache form scope
if (Scope <> '') and (FLastScope <> nil) and (FLastScope.Scope = Scope) then
begin
if FLastScope.Translate(Original, Result) then
Exit;
end;
for I := 0 to FTranslateList.Count - 1 do
begin
FScope := TLanguageScope(FTranslateList[I]);
if FScope.Scope = Scope then
begin
if FScope.Translate(Original, Result) then
begin
FLastScope := FScope;
Break
end else
if Scope <> '' then
Result := LocateString(Original, '');
end;
end;
end;
initialization
finalization
UnloadTranslateModule;
end.
|
unit uMainDM;
interface
uses
System.SysUtils, System.Classes, FireDAC.Stan.Intf, FireDAC.Stan.Option,
FireDAC.Stan.Param, FireDAC.Stan.Error, FireDAC.DatS, FireDAC.Phys.Intf,
FireDAC.DApt.Intf, Data.DB, FireDAC.Comp.DataSet, FireDAC.Comp.Client,
FireDAC.Stan.StorageBin;
type
TMainDM = class(TDataModule)
FDMemTable1: TFDMemTable;
FDStanStorageBinLink1: TFDStanStorageBinLink;
procedure DataModuleCreate(Sender: TObject);
private
{ Private declarations }
public
procedure InternalDisplayData;
procedure InternalSaveData;
end;
procedure DisplayData;
procedure SaveDataTXT;
implementation
{%CLASSGROUP 'System.Classes.TPersistent'}
{$R *.dfm}
uses
IOUtils;
procedure DisplayData;
var
DataModule14: TMainDM;
begin
DataModule14 := TMainDM.Create(nil);
DataModule14.InternalDisplayData;
DataModule14.Free;
end;
procedure SaveDataTXT;
var
DataModule14: TMainDM;
begin
DataModule14 := TMainDM.Create(nil);
DataModule14.InternalSaveData;
DataModule14.Free;
end;
procedure TMainDM.DataModuleCreate(Sender: TObject);
var
filename: string;
begin
filename := './employee.fds';
if not FileExists(filename) then
writeln('Missing file ' + filename)
else
begin
FDMemTable1.LoadFromFile(filename);
FDMemTable1.Open;
end;
end;
procedure TMainDM.InternalDisplayData;
begin
if FDMemTable1.Active = False then
Exit;
FDMemTable1.First;
while not FDMemTable1.EOF do
begin
writeln(FDMemTable1['FirstName'] + ' ' + FDMemTable1['LastName']);
FDMemTable1.Next;
end;
end;
procedure TMainDM.InternalSaveData;
var
sl: TStringList;
begin
if FDMemTable1.Active = False then
Exit;
sl := TStringList.Create;
FDMemTable1.First;
while not FDMemTable1.EOF do
begin
sl.Add(FDMemTable1['FirstName'] + ' ' + FDMemTable1['LastName']);
FDMemTable1.Next;
end;
sl.SaveToFile(TPath.GetHomePath + PathDelim + 'list.txt');
writeln('Data saved to' + TPath.GetHomePath);
end;
end.
|
unit uPlotOverrides;
{
*****************************************************************************
* This file is part of Multiple Acronym Math and Audio Plot - MAAPlot *
* *
* See the file COPYING. *
* for details about the copyright. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. *
* *
* MAAplot for Lazarus/fpc *
* (C) 2014 Stefan Junghans *
*****************************************************************************
}
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, FPimage, IntfGraphics, math;
type
{ TLazIntfImage_debug }
TLazIntfImage_debug = class (TLazIntfImage)
private
//procedure _SetAlpha_BPP32_A8R8G8B8(x, y: integer; const Value: TFPColor);
protected
//FSetAlphaProc: TLazIntfImageSetPixelProc;
public
//constructor Create; override;
//destructor Destroy; override;
procedure AlphaBlend(ASource, ASourceAlpha: TLazIntfImage; const ADestX, ADestY: Integer);reintroduce;
procedure ApplyAlpha(ASourceAlpha: TLazIntfImage; const ADestX, ADestY: Integer);
end;
implementation
{ TLazIntfImage_debug }
//procedure TLazIntfImage_debug._SetAlpha_BPP32_A8R8G8B8(x, y: integer;
// const Value: TFPColor);
//var
// VBytes: TFPColorBytes absolute Value;
//begin
// with PFourBytes(FRawImage.Data+FLineStarts^.Positions[y].Byte+(x shl 2))^ do
// begin
// VBytes.Ah := B0;
// VBytes.Al := B0;
// VBytes.Rh := B1;
// VBytes.Rl := B1;
// VBytes.Gh := B2;
// VBytes.Gl := B2;
// VBytes.Bh := B3;
// VBytes.Bl := B3;
// end;
//end;
//constructor TLazIntfImage_debug.Create;
//begin
// inherited Create;
//end;
//
//destructor TLazIntfImage_debug.Destroy;
//begin
// FSetAlphaProc:=nil;
// inherited Destroy;
//end;
procedure TLazIntfImage_debug.AlphaBlend(ASource, ASourceAlpha: TLazIntfImage;
const ADestX, ADestY: Integer);
var
x, y, CurX, CurY: Integer;
MaskValue, InvMaskValue: Word;
CurColor: TFPColor;
lDrawWidth, lDrawHeight: Integer;
begin
//writeln('AlphaBlend_debug');
// Take care not to draw outside the destination area
lDrawWidth := Min(Self.Width - ADestX, ASource.Width);
lDrawHeight := Min(Self.Height - ADestY, ASource.Height);
for y := 0 to lDrawHeight - 1 do
begin
for x := 0 to lDrawWidth - 1 do
begin
CurX := ADestX + x;
CurY := ADestY + y;
// Never draw outside the destination
if (CurX < 0) or (CurY < 0) then Continue;
if ASourceAlpha <> nil then
MaskValue := ASourceAlpha.Colors[x, y].alpha
else
MaskValue := ASource.Colors[x, y].alpha;
InvMaskValue := $FFFF - MaskValue;
if MaskValue = $FFFF then
begin
Self.Colors[CurX, CurY] := ASource.Colors[x, y];
end
else if MaskValue > $00 then
begin
CurColor := Self.Colors[CurX, CurY];
CurColor.Red := Round(
CurColor.Red * InvMaskValue / $FFFF +
ASource.Colors[x, y].Red * MaskValue / $FFFF);
CurColor.Green := Round(
CurColor.Green * InvMaskValue / $FFFF +
ASource.Colors[x, y].Green * MaskValue / $FFFF);
CurColor.Blue := Round(
CurColor.Blue * InvMaskValue / $FFFF +
ASource.Colors[x, y].Blue * MaskValue / $FFFF);
Self.Colors[CurX, CurY] := CurColor;
end;
end;
end;
end;
procedure TLazIntfImage_debug.ApplyAlpha(ASourceAlpha: TLazIntfImage;
const ADestX, ADestY: Integer);
var
x, y, CurX, CurY: Integer;
MaskValue: Word;
CurColor: TFPColor;
lDrawWidth, lDrawHeight: Integer;
//alphaprec, alphashift: byte;
begin
//writeln('ApplyAlpha_debug');
// Take care not to draw outside the destination area
if ASourceAlpha = nil then exit;
lDrawWidth := Min(Self.Width - ADestX, ASourceAlpha.Width);
lDrawHeight := Min(Self.Height - ADestY, ASourceAlpha.Height);
//alphaprec := Self.DataDescription.AlphaPrec;
//alphashift := Self.DataDescription.AlphaShift;
for y := 0 to lDrawHeight - 1 do
begin
for x := 0 to lDrawWidth - 1 do
begin
CurX := ADestX + x;
CurY := ADestY + y;
// Never draw outside the destination
if (CurX < 0) or (CurY < 0) then Continue;
MaskValue := ASourceAlpha.Colors[x, y].alpha;
CurColor := Self.Colors[CurX, CurY];
if (MaskValue = $0) or (CurColor.alpha = $00) or (CurColor.alpha < $FFFF-MaskValue) then continue;
//else if CurColor.alpha > $00 then
begin
//CurColor := Self.Colors[CurX, CurY];
// following line multiplies current alpha.... not good for fadeout in update mode
//CurColor.alpha := round((CurColor.alpha) * (MaskValue / $FFFF));
// for fixed fadeout, use only mask alpha
// problem: function does not know if we are in the masked area or not
// solution: make an inverse mask and subtract the alpha mask values here
CurColor.alpha := $FFFF-MaskValue;
Self.Colors[CurX, CurY] := CurColor;
end;
end;
end;
end;
end.
|
unit uFrm_ImportXLS_Base;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, uBaseEditFrm, Menus, cxLookAndFeelPainters, ADODB, DB,
cxMaskEdit, cxSpinEdit, ExtCtrls, cxProgressBar, cxButtons, cxControls, DBClient,
ActnList, cxContainer, cxEdit, cxTextEdit, StdCtrls, Buttons, jpeg,
comobj;
type
TFrmImportXlSBase = class(TSTBaseEdit)
EdFileName: TcxTextEdit;
PB: TcxProgressBar;
cxedtNo: TcxSpinEdit;
OpenDg: TOpenDialog;
actList: TActionList;
actXLSImport: TAction;
btOK: TcxButton;
btCancel: TcxButton;
Panel2: TPanel;
MMLog: TMemo;
Btbrowse: TcxButton;
Image2: TImage;
Label3: TLabel;
Label1: TLabel;
Label4: TLabel;
Panel1: TPanel;
Panel3: TPanel;
Image1: TImage;
procedure actXLSImportExecute(Sender: TObject);
procedure BtbrowseClick(Sender: TObject);
procedure FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
Bill_Sign : String;
_Detail : TClientDataSet;
function ImportExcelSheets(Path, xlsName: string; Sheetobj: variant): boolean;
function ImportExcel(Path, xlsName: string; Excelobj: variant): boolean; //导入单个excel中的每个工作表
public
{ Public declarations }
end;
var
FrmImportXlSBase: TFrmImportXlSBase;
function ImportXLS_Frm(Bill_Sign,KeyValues : string;DataSet : TClientDataSet):Boolean; //打开盘点单开单界面
implementation
uses Pub_Fun,FrmCliDM,Frm_BillEditBase, uFrm_MoveIssueBill,
uFrmFillFreightFrm;
{$R *.dfm}
function ImportXLS_Frm(Bill_Sign,KeyValues : string;DataSet : TClientDataSet):Boolean; //打开盘点单开单界面
begin
Application.CreateForm(TFrmImportXlSBase, FrmImportXlSBase);
FrmImportXlSBase._Detail := DataSet;
FrmImportXlSBase.cxedtNo.Value := UserInfo.SizeGroupCount;
FrmImportXlSBase.Bill_Sign := Bill_Sign;
FrmImportXlSBase.ShowModal;
FrmImportXlSBase.Free;
end;
procedure TFrmImportXlSBase.actXLSImportExecute(Sender: TObject);
var xlsName : string;
Excelobj: variant; //必须加入comobj单元
begin
inherited;
xlsName := Trim(EdFileName.Text);
if xlsName='' then
begin
ShowMsg(Handle,'请选择导入的盘点单文件！',[]);
Btbrowse.SetFocus;
exit;
end;
screen.Cursor := crHourGlass;
try
try
Excelobj := Createoleobject('Excel.application');
Excelobj.workbooks.close; // Excelobj对象必须关闭，否则下次的Open方法会失效，保持的是第一次打开的excel
Excelobj.workbooks.open(xlsName); //打开excel
except
application.MessageBox('文件打开失败,您的机器里可能未安装Microsoft Excel或安装异常 ', '金蝶提示', 64);
exit;
end;
ImportExcel('', xlsName, Excelobj);
finally
Excelobj.Quit;
Excelobj:= Unassigned;
screen.Cursor := crDefault;
EdFileName.Text := '';
end;
end;
function TFrmImportXlSBase.ImportExcel(Path, xlsName: string;
Excelobj: variant): boolean;
//1.传入xls对象，逐表处理
//2.同时ImportExcel也返回false， xlsName 文件不再执行导入，导入的数据进行回滚
var sheetobj: variant; //工作表对象
SheetCount, i: integer;
begin
Result := True; //默认导入成功，如果出错则返回false
sheetobj := Excelobj.workbooks[1].worksheets[1];
sheetobj.Activate; //打开一个工作表
if not ImportExcelSheets(Path, xlsName, sheetobj) then
begin
Result := False;
Exit; //出错退出整个EXCEL导入
end
end;
function TFrmImportXlSBase.ImportExcelSheets(Path, xlsName: string;
Sheetobj: variant): boolean;
var
MATERIALFiledName,COLORFiledName,SIZEFiledName,CUPFiledName,QTYFiledName,InWarehouseFiledName : string;
gMaterialID,gColorID, gSizeGroupID,SheetName,sqlstr,gCupID,gSizeID,gInWarehouseID: string;
StyleCode,ColorName,CupName,InWarehouseCode : string;
Rows,cols,R, c, i, SizeEndCol, SizeCount, StyleSizeCount, StyleCount, ImportCount,SizeGroupColumn,BeginRow,SizeColBegin: integer;
fieldname, val, FilePath, cellValue: string;
fAmount : Double;
MaterialIndex,ColorIndex,CupIndex,InWarehouseIndex : Integer;
begin
Result := True;
ImportCount := 0; //导入数量
SheetName := Sheetobj.Name; //获取表名
Rows := SheetObj.UsedRange.Rows.Count;
if Rows < cxedtNo.Value+1 then //从cxedtNo+1行开始导入
begin
MMLog.lines.add('第['+inttostr(cxedtNo.Value)+']行之后没有数据，请调整导入开始行数，！');
Result := False;
Exit;
end;
cols := SheetObj.UsedRange.Columns.count;
try
SizeCount := UserInfo.MaxSizeCount;
SizeEndCol := SizeCount + 8;
pb.Position := 0;
pb.Properties.Max := Rows - cxedtNo.Value;
BeginRow := cxedtNo.Value;
//获取尺码列开始位置 SizeColBegin
for i := 1 to cols do
begin
if vartostr(Trim(sheetobj.cells[1, i]))<>'' then
begin
// SizeGroupColumn := i;
SizeColBegin := i;
break;
end;
end;
//获取商品、颜色、内长在EXCEL中的位置
for i := 1 to cols do
begin
cellValue := vartostr(Trim(sheetobj.cells[BeginRow, i]));
if cellValue='商品编号' then MaterialIndex := i;
if cellValue='颜色' then ColorIndex := i;
if cellValue='内长' then CupIndex := i;
if cellValue='入库仓库编码' then InWarehouseIndex := i;
//if (MaterialIndex>0) and (ColorIndex>0) and (CupIndex>0) then Break;
end;
if SizeColBegin=0 then
begin
MMLog.lines.add('第['+inttostr(BeginRow)+']行为标题行，请检查EXCEL标题行位置，调整从第**行开始导入！');
Result := False;
Exit;
end;
for r := BeginRow+1 to rows do //逐个读取单元，从第cxedtNo.Value+1行开始读
begin
StyleCode := '';
ColorName := '';
CupName := '';
InWarehouseCode := '';
gInWarehouseID :='';
gMaterialID := '';
gSizeGroupID := '';
gCupID := '';
fAmount := 0;
if MaterialIndex>0 then
StyleCode := vartostr(Trim(sheetobj.cells[r, MaterialIndex])); //商品编号
if StyleCode ='' then
begin
MMLog.lines.add('第'+inttostr(r)+'行商品为空,导入程序跳过此行！');
Result := False;
Continue;
end;
if ColorIndex>0 then
ColorName := vartostr(Trim(sheetobj.cells[r, ColorIndex])); //获取颜色（名称）
if ColorName='' then
begin
MMLog.lines.add('第'+inttostr(r)+'行商品['+StyleCode+']颜色为空！');
Result := False;
Exit;
end;
if CupIndex>0 then
CupName := vartostr(Trim(sheetobj.cells[r, CupIndex])); //获取内长（名称）
if InWarehouseIndex>0 then
InWarehouseCode := vartostr(Trim(sheetobj.cells[r, InWarehouseIndex])); //获取入库仓库编号
/////////////////////////////////////////获取入库仓库begin//////////////////////////////////////////////
if InWarehouseCode='' then
if UpperCase(Bill_Sign)=UpperCase('T_IM_MoveIssueBill') then //调拨出库单
begin
MMLog.lines.add('第'+inttostr(r)+'行入库仓库编码为空，导入程序跳过此行！');
// Result := False;
Continue;
end;
if InWarehouseCode<>'' then
begin
gInWarehouseID := CliDM.Client_QuerySQL('SELECT FID FROM T_DB_WAREHOUSE(nolock) WHERE FNUMBER='+QuotedStr(InWarehouseCode)).FieldByName('FID').AsString;
if gInWarehouseID='' then
if UpperCase(Bill_Sign)=UpperCase('T_IM_MoveIssueBill') then //调拨出库单
begin
MMLog.lines.add('第'+inttostr(r)+'行入库仓库['+InWarehouseCode+']不存在，导入程序跳过此行！');
Result := False;
Exit;
end;
end;
/////////////////////////////////////////获取入库仓库 end////////////////////////////////////////////////
/////////////////////////////////////////检查商品 begin//////////////////////////////////////////////
CliDM.qryTemp.Close;
CliDM.qryTemp.SQL.Clear;
CliDM.qryTemp.SQL.Add('select FID,CFSIZEGROUPID from t_Bd_Material(nolock) where fnumber='+QuotedStr(StyleCode));
CliDM.qryTemp.Open;
gSizeGroupID := CliDM.qryTemp.fieldbyname('CFSIZEGROUPID').AsString; //尺码组
gMaterialID := CliDM.qryTemp.fieldbyname('FID').AsString;
if gMaterialID='' then
begin
MMLog.lines.add('第'+inttostr(r)+'行款号['+StyleCode+']不存在！');
pb.Refresh;
Pb.Position := Pb.Position + 1;
Result := False;
Continue;
end;
/////////////////////////////////////////检查商品 end//////////////////////////////////////////////
/////////////////////////////////////////检查颜色 begin//////////////////////////////////////////////
CliDM.qryTemp.Close;
CliDM.qryTemp.SQL.Clear;
CliDM.qryTemp.SQL.Add('select bb.FID as ColorID ,Bb.Fnumber as ColorNo,bb.fname_l2 as ColorName '+
' from t_Bd_Material M(nolock) left join CT_MS_MATERIALCOLORPG G(nolock) on M.FID=G.Fparentid '+
' left join T_BD_AsstAttrValue BB(nolock) on G.CFColorID=BB.FID where M.fnumber='+QuotedStr(StyleCode)); //颜色
CliDM.qryTemp.Open;
if CliDM.qryTemp.Locate('ColorName',ColorName,[]) then
begin
gColorID := CliDM.qryTemp.fieldbyname('ColorID').AsString;
end
else
begin
gColorID := '';
end;
if (Trim(ColorName)<>'' ) and (trim(gColorID)='' ) then
begin
MMLog.Lines.Add(' 文件【' + xlsName + '】工作表[' + sheetobj.Name + ']商品 ['+StyleCode+']的颜色['+ColorName+']不存在！');
pb.Refresh;
Pb.Position := Pb.Position + 1;
Result := False;
Continue;
end;
/////////////////////////////////////////检查颜色 end//////////////////////////////////////////////
/////////////////////////////////////////检查内长 begin/////////////////////////////////////////
if CupName<>'' then
begin
CliDM.qryTemp.Close;
CliDM.qryTemp.SQL.Clear;
CliDM.qryTemp.SQL.Add(' select M.FID,M.fnumber,M.Fname_L2, bb.FID as CupID ,Bb.Fnumber as CupNo,bb.fname_l2 as CupName '+
' from t_Bd_Material M(nolock) left join CT_MS_MATERIALCUPPG G(nolock) on M.FID=G.Fparentid '+
' left join T_BD_AsstAttrValue '+
' BB(nolock) on G.CFCuPID=BB.FID where M.fnumber='+QuotedStr(StyleCode));
CliDM.qryTemp.Open;
if CliDM.qryTemp.Locate('CupName',CupName,[]) then
begin
gCupID := CliDM.qryTemp.fieldbyname('CupID').AsString;
end
else
begin
gCupID :='';
end;
end;
if (Trim(CupName)<>'' ) and (trim(gCupID)='' ) then
begin
MMLog.Lines.Add(' 文件【' + xlsName + '】工作表[' + sheetobj.Name + ']商品 ['+StyleCode+']的内长['+CupName+']不存在');
pb.Refresh;
Pb.Position := Pb.Position + 1;
Result := False;
Continue;
end;
/////////////////////////////////////////检查内长 end/////////////////////////////////////////
/////////////////////////////////////////导入尺码数量 begin/////////////////////////////////////////
sqlstr := 'select count(*) as StyleSizeCount from ct_bas_sizegroupentry(NOLOCK) where FPARENTID='+QuotedStr(gSizeGroupID);
StyleSizeCount := CliDM.Client_QuerySQL(sqlstr).FieldByName('StyleSizeCount').AsInteger;
fAmount := 0;
i :=0;
try
_Detail.OnCalcFields := nil;
_Detail.BeforePost := nil;
if _Detail.FindField('CFMATERIALID')<>nil then MATERIALFiledName := 'CFMATERIALID' else if _Detail.FindField('FMATERIALID')<>nil then MATERIALFiledName := 'FMATERIALID';
if _Detail.FindField('CFCOLORID')<>nil then COLORFiledName := 'CFCOLORID' else if _Detail.FindField('FCOLORID')<>nil then COLORFiledName := 'FCOLORID';
if _Detail.FindField('CFCUPID')<>nil then CUPFiledName := 'CFCUPID' else if _Detail.FindField('FCUPID')<>nil then CUPFiledName := 'FCUPID';
if _Detail.FindField('CFInWarehouseID')<>nil then InWarehouseFiledName := 'CFInWarehouseID';
for c := SizeColBegin to StyleSizeCount+SizeColBegin-1 do
begin
cellValue := trim(vartostr(sheetobj.cells[r, c]));
inc(i);
if cellValue <> '' then
begin
try
fAmount := StrToFloat(cellValue);
except
MMLog.Lines.Add(' 第['+inttostr(r)+']行商品 ['+StyleCode+']的尺码数量['+cellValue+']不是数字类型，跳过当前行继续导入！');
Continue;
end;
if fAmount <0 then
begin
MMLog.Lines.Add(' 第['+inttostr(r)+']行商品 ['+StyleCode+']的尺码数量['+cellValue+']小于0，跳过当前行继续导入！');
Continue;
end;
QTYFiledName := 'fAmount_'+inttostr(I);
_Detail.First;
if _Detail.Locate(MATERIALFiledName+';'+COLORFiledName+';'+CUPFiledName,VarArrayOf([gMaterialID,gColorID,gCupID]),[]) then
begin
if not (_Detail.State in DB.dsEditModes) then _Detail.Edit;
if _Detail.FindField(QTYFiledName)<> nil then
_Detail.FieldByName(QTYFiledName).AsFloat := _Detail.FieldByName(QTYFiledName).AsFloat+fAmount;
end
else
begin
_Detail.Edit;
_Detail.Append;
if _Detail.FindField(MATERIALFiledName)<> nil then
_Detail.FieldByName(MATERIALFiledName).AsString := gMaterialID;
if _Detail.FindField(COLORFiledName)<> nil then
_Detail.FieldByName(COLORFiledName).AsString := gColorID;
if _Detail.FindField(CUPFiledName)<> nil then
_Detail.FieldByName(CUPFiledName).AsString := gCupID;
if _Detail.FindField(QTYFiledName)<> nil then
_Detail.FieldByName(QTYFiledName).AsFloat := fAmount;
if _Detail.FindField(InWarehouseFiledName)<> nil then //调拨出库单有入库仓库
_Detail.FieldByName(InWarehouseFiledName).AsString := gInWarehouseID;
end;
end;
end;
finally
if UpperCase(Bill_Sign)=UpperCase('T_IM_MoveIssueBill') then //调拨出库单
begin
_Detail.OnCalcFields := FM_BillEditMoveIssue.cdsDetailAmountCalcFields;
_Detail.BeforePost := FM_BillEditBase.cdsDetailAmountBeforePost;
end;
if UpperCase(Bill_Sign)=UpperCase('t_sd_subsidyapplybill') then //补货申请单
begin
_Detail.OnCalcFields := FrmFillFreight.cdsDetailAmountCalcFields;
_Detail.BeforePost := FrmFillFreight.cdsDetailAmountBeforePost;
end;
_Detail.First;
_Detail.Edit;
end;
/////////////////////////////////////////导入尺码数量 end/////////////////////////////////////////
ImportCount := ImportCount+1;
pb.Refresh;
Pb.Position := Pb.Position + 1;
end; //结束行读取 for
Pb.Position := pb.Properties.Max;
except
on E :Exception do
MMLog.Lines.Add('导入 Excel 文件出错:'+E.Message)
end;
MMLog.Lines.Add('共计['+inttostr(Rows-BeginRow)+']行记录，成功导入['+inttostr(ImportCount)+']行横排EXCEL记录!');
Pb.Position := 0;
Result := True;
end;
procedure TFrmImportXlSBase.BtbrowseClick(Sender: TObject);
begin
inherited;
if OpenDg.Execute then
begin
EdFileName.Text := OpenDg.FileName;
end;
end;
procedure TFrmImportXlSBase.FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
inherited;
if (shift = [ssCtrl]) and (key = 69) then Btbrowse.Click;
if (shift = [ssCtrl]) and (key = 89) then btOK.Click;
if Key=27 then btCancel.Click; //ESC
end;
procedure TFrmImportXlSBase.FormCreate(Sender: TObject);
begin
inherited;
LoadImage(UserInfo.ExePath+'\Img\SetFrmBackGroup.jpg',Image1);
LoadImage(UserInfo.ExePath+'\Img\SetFrmBackGroup.jpg',Image2);
end;
end.
|
//
// Generated by JavaToPas v1.5 20150831 - 132343
////////////////////////////////////////////////////////////////////////////////
unit android.provider.Telephony_Mms_Rate;
interface
uses
AndroidAPI.JNIBridge,
Androidapi.JNI.JavaTypes,
android.net.Uri;
type
JTelephony_Mms_Rate = interface;
JTelephony_Mms_RateClass = interface(JObjectClass)
['{915CAB94-7360-4730-86B2-2A391D84B5ED}']
function _GetCONTENT_URI : JUri; cdecl; // A: $19
function _GetSENT_TIME : JString; cdecl; // A: $19
property CONTENT_URI : JUri read _GetCONTENT_URI; // Landroid/net/Uri; A: $19
property SENT_TIME : JString read _GetSENT_TIME; // Ljava/lang/String; A: $19
end;
[JavaSignature('android/provider/Telephony_Mms_Rate')]
JTelephony_Mms_Rate = interface(JObject)
['{24A0FB42-2C6A-4AF0-8124-6F521AB3775B}']
end;
TJTelephony_Mms_Rate = class(TJavaGenericImport<JTelephony_Mms_RateClass, JTelephony_Mms_Rate>)
end;
const
TJTelephony_Mms_RateSENT_TIME = 'sent_time';
implementation
end.
|
// ************************************************************************
// ***************************** CEF4Delphi *******************************
// ************************************************************************
//
// CEF4Delphi is based on DCEF3 which uses CEF3 to embed a chromium-based
// browser in Delphi applications.
//
// The original license of DCEF3 still applies to CEF4Delphi.
//
// For more information about CEF4Delphi visit :
// https://www.briskbard.com/index.php?lang=en&pageid=cef
//
// Copyright © 2017 Salvador Díaz Fau. All rights reserved.
//
// ************************************************************************
// ************ vvvv Original license and comments below vvvv *************
// ************************************************************************
(*
* Delphi Chromium Embedded 3
*
* Usage allowed under the restrictions of the Lesser GNU General Public License
* or alternatively the restrictions of the Mozilla Public License 1.1
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific language governing rights and limitations under the License.
*
* Unit owner : Henri Gourvest <hgourvest@gmail.com>
* Web site : http://www.progdigy.com
* Repository : http://code.google.com/p/delphichromiumembedded/
* Group : http://groups.google.com/group/delphichromiumembedded
*
* Embarcadero Technologies, Inc is not permitted to use or redistribute
* this source code without explicit permission.
*
*)
unit uJSDialogBrowser;
{$I cef.inc}
interface
uses
{$IFDEF DELPHI16_UP}
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls, System.SyncObjs,
{$ELSE}
Windows, Messages, SysUtils, Variants, Classes, Graphics,
Controls, Forms, Dialogs, StdCtrls, ExtCtrls, SyncObjs,
{$ENDIF}
uCEFChromium, uCEFWindowParent, uCEFChromiumWindow, uCEFInterfaces, uCEFTypes, uCEFConstants;
const
CEFBROWSER_SHOWJSDIALOG = WM_APP + $101;
type
TJSDialogBrowserFrm = class(TForm)
ChromiumWindow1: TChromiumWindow;
AddressPnl: TPanel;
AddressEdt: TEdit;
GoBtn: TButton;
Timer1: TTimer;
procedure GoBtnClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure ChromiumWindow1AfterCreated(Sender: TObject);
procedure Timer1Timer(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
protected
FJSDialogInfoCS : TCriticalSection;
FOriginUrl : ustring;
FMessageText : ustring;
FDefaultPromptText : ustring;
FPendingDlg : boolean;
FDialogType : TCefJsDialogType;
FCallback : ICefJsDialogCallback;
procedure ChromiumBrowser_OnJsdialog(Sender: TObject; const browser: ICefBrowser; const originUrl: ustring; dialogType: TCefJsDialogType; const messageText, defaultPromptText: ustring; const callback: ICefJsDialogCallback; out suppressMessage: Boolean; out Result: Boolean);
procedure WMMove(var aMessage : TWMMove); message WM_MOVE;
procedure WMMoving(var aMessage : TMessage); message WM_MOVING;
procedure WMEnterMenuLoop(var aMessage: TMessage); message WM_ENTERMENULOOP;
procedure WMExitMenuLoop(var aMessage: TMessage); message WM_EXITMENULOOP;
procedure ShowJSDialogMsg(var aMessage: TMessage); message CEFBROWSER_SHOWJSDIALOG;
end;
var
JSDialogBrowserFrm: TJSDialogBrowserFrm;
implementation
{$R *.dfm}
uses
uCEFApplication;
// This is a demo with custom JS dialogs
procedure TJSDialogBrowserFrm.FormCreate(Sender: TObject);
begin
FJSDialogInfoCS := TCriticalSection.Create;
FOriginUrl := '';
FMessageText := '';
FDefaultPromptText := '';
FPendingDlg := False;
FDialogType := JSDIALOGTYPE_ALERT;
FCallback := nil;
end;
procedure TJSDialogBrowserFrm.FormDestroy(Sender: TObject);
begin
FreeAndNil(FJSDialogInfoCS);
FCallback := nil;
end;
procedure TJSDialogBrowserFrm.FormShow(Sender: TObject);
begin
ChromiumWindow1.ChromiumBrowser.OnJsdialog := ChromiumBrowser_OnJsdialog;
// GlobalCEFApp.GlobalContextInitialized has to be TRUE before creating any browser
// If it's not initialized yet, we use a simple timer to create the browser later.
if not(ChromiumWindow1.CreateBrowser) then Timer1.Enabled := True;
end;
procedure TJSDialogBrowserFrm.ChromiumWindow1AfterCreated(Sender: TObject);
begin
Caption := 'JS Dialog Browser';
AddressPnl.Enabled := True;
GoBtn.Click;
end;
procedure TJSDialogBrowserFrm.GoBtnClick(Sender: TObject);
begin
ChromiumWindow1.LoadURL(AddressEdt.Text);
end;
procedure TJSDialogBrowserFrm.Timer1Timer(Sender: TObject);
begin
Timer1.Enabled := False;
if not(ChromiumWindow1.CreateBrowser) and not(ChromiumWindow1.Initialized) then
Timer1.Enabled := True;
end;
procedure TJSDialogBrowserFrm.WMMove(var aMessage : TWMMove);
begin
inherited;
if (ChromiumWindow1 <> nil) then ChromiumWindow1.NotifyMoveOrResizeStarted;
end;
procedure TJSDialogBrowserFrm.WMMoving(var aMessage : TMessage);
begin
inherited;
if (ChromiumWindow1 <> nil) then ChromiumWindow1.NotifyMoveOrResizeStarted;
end;
procedure TJSDialogBrowserFrm.WMEnterMenuLoop(var aMessage: TMessage);
begin
inherited;
if (aMessage.wParam = 0) and (GlobalCEFApp <> nil) then GlobalCEFApp.OsmodalLoop := True;
end;
procedure TJSDialogBrowserFrm.WMExitMenuLoop(var aMessage: TMessage);
begin
inherited;
if (aMessage.wParam = 0) and (GlobalCEFApp <> nil) then GlobalCEFApp.OsmodalLoop := False;
end;
procedure TJSDialogBrowserFrm.ChromiumBrowser_OnJsdialog(Sender : TObject;
const browser : ICefBrowser;
const originUrl : ustring;
dialogType : TCefJsDialogType;
const messageText : ustring;
const defaultPromptText : ustring;
const callback : ICefJsDialogCallback;
out suppressMessage : Boolean;
out Result : Boolean);
begin
// In this event we must store the dialog information and post a message to the main form to show the dialog
FJSDialogInfoCS.Acquire;
if FPendingDlg then
begin
Result := False;
suppressMessage := True;
end
else
begin
FOriginUrl := originUrl;
FMessageText := messageText;
FDefaultPromptText := defaultPromptText;
FDialogType := dialogType;
FCallback := callback;
FPendingDlg := True;
Result := True;
suppressMessage := False;
PostMessage(Handle, CEFBROWSER_SHOWJSDIALOG, 0, 0);
end;
FJSDialogInfoCS.Release;
end;
procedure TJSDialogBrowserFrm.ShowJSDialogMsg(var aMessage: TMessage);
var
TempCaption : string;
begin
// Here we show the dialog and reset the information.
// showmessage, MessageDlg and InputBox should be replaced by nicer custom forms with the same functionality.
FJSDialogInfoCS.Acquire;
if FPendingDlg then
begin
TempCaption := 'JavaScript message from : ' + FOriginUrl;
case FDialogType of
JSDIALOGTYPE_ALERT : showmessage(TempCaption + CRLF + CRLF + FMessageText);
JSDIALOGTYPE_CONFIRM : FCallback.cont((MessageDlg(TempCaption + CRLF + CRLF + FMessageText, mtConfirmation, [mbYes, mbNo], 0, mbYes) = mrYes), '');
JSDIALOGTYPE_PROMPT : FCallback.cont(True, InputBox(TempCaption, FMessageText, FDefaultPromptText));
end;
end;
FOriginUrl := '';
FMessageText := '';
FDefaultPromptText := '';
FPendingDlg := False;
FDialogType := JSDIALOGTYPE_ALERT;
FCallback := nil;
FJSDialogInfoCS.Release;
end;
end.
|
unit Unit1;
interface
uses
Windows,
Messages,
SysUtils,
Classes,
Graphics,
Controls,
Forms,
Dialogs,
StdCtrls,
GLWin32Viewer,
GLScene,
GLObjects,
GLHUDObjects,
GLTexture,
GLSelection,
GLGeomObjects,
GLCanvas,
GLCadencer,
GLCoordinates,
GLCrossPlatform,
GLBaseClasses;
type
TForm1 = class(TForm)
GLScene1: TGLScene;
GLSceneViewer1: TGLSceneViewer;
GLCamera1: TGLCamera;
GLAnnulus1: TGLAnnulus;
GLTorus1: TGLTorus;
Memo1: TMemo;
GLCadencer1: TGLCadencer;
procedure GLSceneViewer1MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure GLSceneViewer1MouseMove(Sender: TObject; Shift: TShiftState;
X, Y: Integer);
procedure GLSceneViewer1MouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure GLCadencer1Progress(Sender: TObject;
const deltaTime, newTime: Double);
procedure GLSceneViewer1PostRender(Sender: TObject);
public
x1, y1: Integer;
btn: boolean;
R: TRect;
end;
var
Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.GLSceneViewer1MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
// **********************************************
if ssLeft in Shift then
begin
R := rect(0, 0, 0, 0); // reset the rectangle
x1 := X;
y1 := Y;
btn := true;
end;
end;
procedure TForm1.GLSceneViewer1MouseMove(Sender: TObject; Shift: TShiftState;
X, Y: Integer);
begin
if (btn) then
begin
if (X > x1) and (Y > y1) then
begin
R.Top := y1;
R.Left := x1;
R.Right := X;
R.Bottom := Y;
end;
if (Y < y1) and (X > x1) then
begin
R.Top := Y;
R.Left := x1;
R.Right := X;
R.Bottom := y1;
end;
if (X < x1) and (Y > y1) then
begin
R.Top := y1;
R.Left := X;
R.Right := x1;
R.Bottom := Y;
end;
if (X < x1) and (Y < y1) then
begin
R.Top := Y;
R.Left := X;
R.Right := x1;
R.Bottom := y1;
end;
Caption := 'Top: ' + IntToStr(R.Top) + ' Left: ' + IntToStr(R.Left) +
' Right: ' + IntToStr(R.Right) + ' Bottom: ' + IntToStr(R.Bottom);
end;
end;
procedure TForm1.GLSceneViewer1MouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
var
List: TGLPickList;
i: Integer;
begin
btn := false;
List := GLSceneViewer1.Buffer.GetPickedObjects(R);
Memo1.Lines.Clear;
for i := 0 to List.Count - 1 do
Memo1.Lines.Add(List.Hit[i].ClassName);
end;
procedure TForm1.GLCadencer1Progress(Sender: TObject;
const deltaTime, newTime: Double);
begin
GLSceneViewer1.Invalidate;
end;
procedure TForm1.GLSceneViewer1PostRender(Sender: TObject);
var
glc: TGLCanvas;
begin
if btn then
begin
glc := TGLCanvas.Create(GLSceneViewer1.Width, GLSceneViewer1.Height);
with glc do
begin
PenWidth := 1;
PenColor := clBlack;
FrameRect(R.Left + 1, R.Top + 1, R.Right, R.Bottom);
PenColor := clLime;
FrameRect(R.Left, R.Top, R.Right - 1, R.Bottom - 1);
end;
glc.Free;
end;
end;
end.
|
unit uBASE_SelectForm;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, uBASE_Form, Menus, cxLookAndFeelPainters, StdCtrls, cxButtons,
ExtCtrls, cxClasses, dxRibbon, cxControls, uFrameBaseGrid, cxGridDBBandedTableView, DB, uParams, cxGridTableView;
type
TBASE_SelectForm = class(TBASE_Form)
pnlSelect: TPanel;
btnCancel: TcxButton;
btnOK: TcxButton;
btnEdit: TcxButton;
procedure btnOKClick(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure btnEditClick(Sender: TObject);
private
FSelector: boolean;
procedure SetSelector(const Value: boolean);
function GetReadOnly: boolean;
procedure SetReadOnly(const Value: boolean);
protected
procedure Check; virtual;
public
property Selector: boolean read FSelector write SetSelector;
property ReadOnly: boolean read GetReadOnly write SetReadOnly;
procedure ApplyParamsBeforeOpen; virtual;
procedure ApplyParamsAfterOpen; virtual;
procedure OpenData; virtual;
procedure LocateByPrimaryKey(PKValue: variant); virtual;
function MainView: TcxGridTableView; virtual;
function CreateCurRecordValues: TParamCollection; virtual;
end;
implementation
uses
uAccess, uDlgFind, cxTableViewCds;
{$R *.dfm}
procedure TBASE_SelectForm.btnOKClick(Sender: TObject);
begin
inherited;
Check;
ModalResult:=mrOK;
end;
procedure TBASE_SelectForm.Check;
begin
//abstract
end;
procedure TBASE_SelectForm.SetSelector(const Value: boolean);
begin
FSelector:=Value;
pnlSelect.Visible:=Value;
end;
procedure TBASE_SelectForm.FormClose(Sender: TObject; var Action: TCloseAction);
begin
if not Selector and (AccessManager <> nil) then begin
Action:=caFree;
(AccessManager as TAccessSelectorForm).Form:=nil;
end;
end;
procedure TBASE_SelectForm.ApplyParamsBeforeOpen;
begin
//abstract
end;
procedure TBASE_SelectForm.ApplyParamsAfterOpen;
begin
//abstract
end;
procedure TBASE_SelectForm.OpenData;
begin
//abstract
end;
function TBASE_SelectForm.MainView: TcxGridTableView;
begin
result:=nil;
end;
function TBASE_SelectForm.CreateCurRecordValues: TParamCollection;
var
i, r: integer;
p: pointer;
view: TcxGridDBBandedTableView;
viewch: TcxGridBandedTableViewCds;
begin
result:=nil;
p:=MainView;
if not Assigned(p) then exit;
result:=TParamCollection.Create(TParamItem);
if MainView is TcxGridDBBandedTableView then begin
view:=MainView as TcxGridDBBandedTableView;
with view.DataController.DataSource do
for i:=0 to DataSet.FieldCount-1 do
result.Add(DataSet.Fields[i].DisplayName).Value:=DataSet.Fields[i].Value;
end
else
if MainView is TcxGridBandedTableViewCds then begin
viewch:=MainView as TcxGridBandedTableViewCds;
r:=viewch.DataController.FocusedRecordIndex;
with viewch.DataController.CashDataSource do
for i:=0 to FieldCount-1 do
result.Add(Fields[i].FieldName).Value:=Values[r, i];
end;
end;
procedure TBASE_SelectForm.LocateByPrimaryKey(PKValue: variant);
var
p: pointer;
view: TcxGridDBBandedTableView;
viewch: TcxGridBandedTableViewCds;
begin
p:=MainView;
if not Assigned(p) then exit;
if MainView is TcxGridDBBandedTableView then begin
view:=MainView as TcxGridDBBandedTableView;
with view.DataController.DataSource do
DataSet.Locate(DataSet.Fields[0].DisplayName, PKValue, []);
end
else
if MainView is TcxGridBandedTableViewCds then begin
raise Exception.Create('При появлении данного сообщения немедленно обратитесь к разработчику!'+#10#13+'procedure TBASE_SelectForm.LocateByPrimaryKey(PKValue: variant);');
viewch:=MainView as TcxGridBandedTableViewCds;
end;
end;
function TBASE_SelectForm.GetReadOnly: boolean;
begin
result:=not btnOK.Visible;
end;
procedure TBASE_SelectForm.SetReadOnly(const Value: boolean);
begin
if Value then begin
btnOK.Visible:=false;
btnCancel.Caption:='Закрыть';
btnEdit.Visible:=true;
end
else begin
btnOK.Visible:=true;
btnCancel.Caption:='Отмена';
end;
end;
procedure TBASE_SelectForm.btnEditClick(Sender: TObject);
begin
inherited;
ReadOnly:=false;
btnEdit.Visible:=false;
Caption:=Caption + ' (режим редактирования)';
end;
end.
|
unit uFrmFuncionario;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, uFrmCrudBase, DB, DBClient, StdCtrls, Grids, DBGrids, Buttons,
ExtCtrls, uFuncionarioDAOClient, Funcionario, Cargo;
type
TFrmFuncionario = class(TFrmCrudBase)
cdsCrudCODIGO: TStringField;
cdsCrudNOME: TStringField;
cdsCrudCARGO_ID: TIntegerField;
cdsCrudCARGO_DESCRICAO: TStringField;
private
{ Private declarations }
DAOClient: TFuncionarioDAOClient;
protected
procedure CreateDAOClient; override;
procedure DestroyDAOClient; override;
procedure OnShow; override;
procedure OnInsert; override;
procedure OnEdit; override;
procedure OnDelete; override;
procedure OnPesquisar; override;
public
{ Public declarations }
end;
var
FrmFuncionario: TFrmFuncionario;
implementation
uses DataUtils, MensagensUtils, uFrmDadosFuncionario, TypesUtils;
{$R *.dfm}
{ TFrmFuncionario }
procedure TFrmFuncionario.CreateDAOClient;
begin
inherited;
DAOClient := TFuncionarioDAOClient.Create(DBXConnection);
end;
procedure TFrmFuncionario.DestroyDAOClient;
begin
DAOClient.Free;
inherited;
end;
procedure TFrmFuncionario.OnDelete;
begin
inherited;
if (Confirma('Deseja excluir este funcionário?')) then
if (DAOClient.Delete(TFuncionario.Create(cdsCrudCODIGO.AsString))) then
cdsCrud.Delete
else
Erro('Ocorreu algum erro durante a exlusão.');
end;
procedure TFrmFuncionario.OnEdit;
var
f: TFrmDadosFuncionario;
begin
inherited;
f := TFrmDadosFuncionario.Create(Self);
try
f.Funcionario.Codigo := cdsCrudCODIGO.AsString;
f.Funcionario.Nome := cdsCrudNOME.AsString;
f.Funcionario.Cargo := TCargo.Create(cdsCrudCARGO_ID.AsInteger,
cdsCrudCARGO_DESCRICAO.AsString);
f.Operacao := opEdit;
f.ShowModal;
finally
f.Free;
end;
end;
procedure TFrmFuncionario.OnInsert;
var
f: TFrmDadosFuncionario;
begin
inherited;
f := TFrmDadosFuncionario.Create(Self);
try
f.Operacao := opInsert;
f.ShowModal;
finally
f.Free;
end;
end;
procedure TFrmFuncionario.OnPesquisar;
begin
inherited;
cdsCrud.Filtered := False;
cdsCrud.Filter := 'UPPER(NOME) LIKE ' + QuotedStr('%'+UpperCase(edtPesquisar.Text)+'%');
cdsCrud.Filtered := True;
end;
procedure TFrmFuncionario.OnShow;
begin
inherited;
CopyReaderToClientDataSet(DAOClient.List, cdsCrud);
end;
end.
|
Unit FilmUnit;
Interface
Uses CRT;
Type
TLetter=object
x,y:integer;
symb:char;
procedure Init(ax,ay:integer; asymb:char);
procedure Hide;
procedure Show;
procedure Moveto(ax,ay,t:integer);
procedure Blink(n,t:integer);
end;
Implementation
procedure TLetter.Init(ax,ay:integer; asymb:char);
begin
x:=ax;
y:=ay;
symb:=asymb;
end;
procedure TLetter.Hide;
begin
GotoXY(x,y);
Write(' ');
end;
procedure TLetter.Show;
begin
GotoXY(x,y);
Write(symb);
end;
procedure TLetter.Moveto(ax,ay,t:integer);
begin
Hide;
x:=ax;
y:=ay;
Show;
delay(t);
end;
procedure TLetter.Blink(n,t:integer);
var i:integer;
begin
for i:=1 to n do
begin
delay(t div 2);
Hide;
delay(t div 2);
Show;
end;
end;
end.
|
unit Invoice.Controller.Security.Default;
interface
uses Invoice.Controller.Interfaces, System.Classes, System.SysUtils, System.IOUtils, Vcl.Forms, Vcl.Dialogs,
Invoice.Model.Interfaces;
type
TControllerSecurityDefault = class(TInterfacedObject, iControllerSecurityDefault)
private
FEntity: iEntity;
FListLog: TStrings;
FFileName: String;
procedure SaveLog;
public
constructor Create;
destructor Destroy; Override;
class function New: iControllerSecurityDefault;
function Login(aUsername, aPasswood: String): Integer;
function ShowLog: TStrings;
function AddLog(aLog: String): iControllerSecurityDefault;
function EnCrypt(InString: String): String;
function DeCrypt(InString: String): String;
end;
implementation
{ TControllerSecurityDefault }
uses Invoice.Controller.DataModule, Invoice.Model.Entity.User;
const
KeyCrypt = 'YUQL23KL23DF90WI5E1JAS467NMCXXL6JAOAUWWMCL0AOMM4A4VZYW9KHJUI2347EJHJKDF3424SKL K3LAKDJSL9RTIKJ';
constructor TControllerSecurityDefault.Create;
begin
FListLog := TStringList.Create;
//
FFileName := Copy(Application.ExeName, 1, Length(Application.ExeName) - 4) + '.LOG';
end;
destructor TControllerSecurityDefault.Destroy;
begin
SaveLog;
//
FListLog.Free;
//
inherited;
end;
class function TControllerSecurityDefault.New: iControllerSecurityDefault;
begin
Result := Self.Create;
end;
function TControllerSecurityDefault.Login(aUsername, aPasswood: String): Integer;
begin
Result := 0;
//
if (aUsername <> '') and (aPasswood <> '') then
begin
FEntity := TModelEntityUser.New(DataModuleLocal.GetConnection);
//
FEntity.ListWhere('nameUser = ' + QuotedStr(aUsername) + ' AND passUser = ' + QuotedStr(aPasswood));
//
Result := FEntity.DataSet.RecordCount;
end;
end;
function TControllerSecurityDefault.AddLog(aLog: String): iControllerSecurityDefault;
begin
Result := Self;
//
if (aLog <> '') then
FListLog.Add(DateTimeToStr(Now) + ' - ' + aLog);
end;
procedure TControllerSecurityDefault.SaveLog;
var
MyLog: TextFile;
RowCount: Integer;
begin
AssignFile(MyLog, FFileName);
//
if FileExists(FFileName) then
Append(MyLog)
else Rewrite(MyLog);
//
for RowCount := 0 to FListLog.Count -1 do
begin
WriteLn(MyLog, FListLog[RowCount]);
end;
//
CloseFile(MyLog)
end;
function TControllerSecurityDefault.ShowLog: TStrings;
begin
Result := FListLog;
end;
function TControllerSecurityDefault.EnCrypt(InString: String): String;
var
KeyLen: Integer;
KeyPos: Integer;
OffSet: Integer;
Dest: String;
SrcPos: Integer;
SrcAsc: Integer;
TmpSrcAsc: Integer;
Range: Integer;
begin
Result := '';
//
Dest := '';
KeyLen := Length(KeyCrypt);
KeyPos := 0;
SrcPos := 0;
SrcAsc := 0;
Range := 256;
//
Randomize;
//
OffSet := Random(Range);
//
Dest := Format('%1.2x', [OffSet]);
//
for SrcPos := 1 to Length(InString) do
begin
Application.ProcessMessages;
//
SrcAsc := (Ord(InString[SrcPos]) + OffSet) Mod 255;
//
if KeyPos < KeyLen then
KeyPos := KeyPos + 1
else
KeyPos := 1;
//
SrcAsc := SrcAsc Xor Ord(KeyCrypt[KeyPos]);
//
Dest := Dest + Format('%1.2x', [SrcAsc]);
//
OffSet := SrcAsc;
end;
//
Result := Dest;
end;
function TControllerSecurityDefault.DeCrypt(InString: String): String;
var
KeyLen: Integer;
KeyPos: Integer;
OffSet: Integer;
Dest: String;
SrcPos: Integer;
SrcAsc: Integer;
TmpSrcAsc: Integer;
Range: Integer;
begin
Result := '';
//
Dest := '';
KeyLen := Length(KeyCrypt);
KeyPos := 0;
SrcPos := 0;
SrcAsc := 0;
Range := 256;
//
OffSet := StrToInt('$' + copy(InString, 1, 2));
//
SrcPos := 3;
//
repeat
SrcAsc := StrToInt('$' + copy(InString, SrcPos, 2));
//
if (KeyPos < KeyLen) Then
KeyPos := KeyPos + 1
else
KeyPos := 1;
//
TmpSrcAsc := SrcAsc Xor Ord(KeyCrypt[KeyPos]);
//
if TmpSrcAsc <= OffSet then
TmpSrcAsc := 255 + TmpSrcAsc - OffSet
else
TmpSrcAsc := TmpSrcAsc - OffSet;
//
Dest := Dest + Chr(TmpSrcAsc);
//
OffSet := SrcAsc;
//
SrcPos := SrcPos + 2;
until (SrcPos >= Length(InString));
//
Result := Dest;
end;
end.
|
//
// Generated by JavaToPas v1.5 20171018 - 171145
////////////////////////////////////////////////////////////////////////////////
unit java.nio.file.attribute.AclEntryFlag;
interface
uses
AndroidAPI.JNIBridge,
Androidapi.JNI.JavaTypes;
type
JAclEntryFlag = interface;
JAclEntryFlagClass = interface(JObjectClass)
['{58973755-E4E4-4DAC-BB43-DC649203400D}']
function _GetDIRECTORY_INHERIT : JAclEntryFlag; cdecl; // A: $4019
function _GetFILE_INHERIT : JAclEntryFlag; cdecl; // A: $4019
function _GetINHERIT_ONLY : JAclEntryFlag; cdecl; // A: $4019
function _GetNO_PROPAGATE_INHERIT : JAclEntryFlag; cdecl; // A: $4019
function valueOf(&name : JString) : JAclEntryFlag; cdecl; // (Ljava/lang/String;)Ljava/nio/file/attribute/AclEntryFlag; A: $9
function values : TJavaArray<JAclEntryFlag>; cdecl; // ()[Ljava/nio/file/attribute/AclEntryFlag; A: $9
property DIRECTORY_INHERIT : JAclEntryFlag read _GetDIRECTORY_INHERIT; // Ljava/nio/file/attribute/AclEntryFlag; A: $4019
property FILE_INHERIT : JAclEntryFlag read _GetFILE_INHERIT; // Ljava/nio/file/attribute/AclEntryFlag; A: $4019
property INHERIT_ONLY : JAclEntryFlag read _GetINHERIT_ONLY; // Ljava/nio/file/attribute/AclEntryFlag; A: $4019
property NO_PROPAGATE_INHERIT : JAclEntryFlag read _GetNO_PROPAGATE_INHERIT;// Ljava/nio/file/attribute/AclEntryFlag; A: $4019
end;
[JavaSignature('java/nio/file/attribute/AclEntryFlag')]
JAclEntryFlag = interface(JObject)
['{F364A59B-3ED1-450D-B400-CCFDB9B6F322}']
end;
TJAclEntryFlag = class(TJavaGenericImport<JAclEntryFlagClass, JAclEntryFlag>)
end;
implementation
end.
|
unit uStringGenerator;
{
Copyright (c) 2015 Ugochukwu Mmaduekwe ugo4brain@gmail.com
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
}
interface
uses
System.SysUtils, System.Math;
function IsWhiteSpace(const Ch: Char): Boolean;
function IsControl(const Ch: Char): Boolean;
function GetAlphabet(charsCount: Integer): String;
function GetRandom(size: Integer; onlyLettersAndDigits: Boolean): String;
implementation
// replicated from 'cUnicode.pas' in 'Fundamentals Library 4.0.0 v4.12' with some
// additions.
function IsWhiteSpace(const Ch: Char): Boolean;
begin
case Ch of
#$0009 .. #$000D, // ASCII CONTROL
#$0020, // SPACE
#$0085, // <control>
#$00A0, // NO-BREAK SPACE
#$1680, // OGHAM SPACE MARK
#$2000 .. #$200A, // EN QUAD..HAIR SPACE
#$202F, // NO-BREAK SPACE
#$2028, // LINE SEPARATOR
#$2029, // PARAGRAPH SEPARATOR
#$205F, // MATHEMATICAL SPACE
#$3000: // IDEOGRAPHIC SPACE
Result := True;
else
Result := False;
end;
end;
// replicated from 'cUnicode.pas' in 'Fundamentals Library 4.0.0 v4.12' with additions.
function IsControl(const Ch: Char): Boolean;
begin
case Ch of
#$0000 .. #$001F, #$007F .. #$009F:
Result := True;
else
Result := False;
end;
end;
function GetAlphabet(charsCount: Integer): String;
var
i, count: Integer;
c: Char;
tempResult: TStringBuilder;
begin
tempResult := TStringBuilder.Create;
tempResult.Clear;
try
i := 0;
count := 0;
while (count < charsCount) do
begin
c := Char(i);
if (not IsControl(c)) and (not IsWhiteSpace(c)) then
begin
tempResult.Append(c);
Inc(count);
end;
Inc(i);
end;
Result := tempResult.ToString;
finally
tempResult.Free;
end;
end;
function GetRandom(size: Integer; onlyLettersAndDigits: Boolean): String;
var
i: Integer;
lettersAndDigits: String;
tempResult: TStringBuilder;
data: TBytes;
begin
Result := '';
tempResult := TStringBuilder.Create;
try
Randomize;
if (onlyLettersAndDigits) then
begin
lettersAndDigits :=
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
for i := 0 to Pred(size) do
begin
tempResult.Append(lettersAndDigits
[Random(Length(lettersAndDigits)) + 1]);
Result := tempResult.ToString;
end
end
else
begin
SetLength(data, size);
i := 0;
while i < (size) do
begin
data[i] := Byte(RandomRange(32, 127));
Result := TEncoding.ASCII.GetString(data);
Inc(i);
end;
data := nil;
end;
finally
tempResult.Free;
end;
end;
end.
|
unit UGenericVO;
interface
uses Atributos, Rtti, SysUtils, SQLExpr, DBClient, DB, TypInfo, DBXCommon,
Classes, Generics.Collections, Contnrs;
type
TGenericVO = class
public
end;
TClassGenericVO = class of TGenericVO;
TGenericVO<T: class> = class
private
class function CreateObject: T;
class function GetColumn(pName: string): TColumn;
public
class function FromDBXReader(pReader: TDBXReader): T;
class function FieldCaption(pFieldName: string): string;
class function FieldLength(pFieldName: string): Integer;
end;
implementation
class function TGenericVO<T>.CreateObject: T;
var
Contexto: TRttiContext;
Tipo: TRttiType;
Value: TValue;
Obj: TObject;
begin
// Criando Objeto via RTTI para chamar o envento OnCreate no Objeto
Contexto := TRttiContext.Create;
try
Tipo := Contexto.GetType(TClass(T));
Value := Tipo.GetMethod('Create').Invoke(Tipo.AsInstance.MetaclassType, []);
Result := T(Value.AsObject);
finally
Contexto.Free;
end;
end;
class function TGenericVO<T>.FromDBXReader(pReader: TDBXReader): T;
var
Obj: T;
Contexto: TRttiContext;
Tipo: TRttiType;
Propriedade: TRttiProperty;
Propriedades: TArray<TRttiProperty>;
Atributo: TCustomAttribute;
Value: TValue;
I, A: Integer;
NomeCampo: string;
DBXValueType: TDBXValueType;
DBXValue: TDBXValue;
EncontrouPropriedade: Boolean;
begin
Obj := CreateObject;
Contexto := TRttiContext.Create;
try
Tipo := Contexto.GetType(TObject(Obj).ClassType);
Propriedades := Tipo.GetProperties;
for I := 0 to pReader.ColumnCount - 1 do
begin
DBXValueType := pReader.ValueType[I];
DBXValue := pReader.Value[I];
NomeCampo := DBXValueType.Name;
with TDBXDataTypes do
begin
case DBXValueType.DataType of
AnsiStringType, WideStringType, BlobType:
Value := DBXValue.AsString;
DateType:
begin
if DBXValue.AsDate > 0 then
Value := DBXValue.AsDateTime
else
Value := TValue.Empty;
end;
DateTimeType, TimeStampType:
begin
if DBXValue.AsDateTime > 0 then
Value := DBXValue.AsDateTime
else
Value := TValue.Empty;
end;
TimeType:
begin
if DBXValue.AsTime > 0 then
Value := DBXValue.AsTime
else
Value := TValue.Empty;
end;
Int32Type:
begin
if DBXValue.IsNull then
Value := TValue.Empty
else
Value := DBXValue.AsInt32;
end;
Int64Type:
begin
if DBXValue.IsNull then
Value := TValue.Empty
else
Value := DBXValue.AsInt64;
end;
DoubleType, BcdType, CurrencyType:
begin
if DBXValue.IsNull then
Value := TValue.Empty
else
Value := DBXValue.AsDouble;
end;
BinaryBlobType, BytesType, VariantType:
Value := TValue.FromVariant(DBXValue.AsVariant);
BooleanType:
Value := DBXValue.AsBoolean;
else
Value := TValue.Empty;
end;
end;
EncontrouPropriedade := False;
for A := 0 to Length(Propriedades) - 1 do
begin
Propriedade := Propriedades[A];
for Atributo in Propriedade.GetAttributes do
begin
if Atributo is TColumn then
begin
if UpperCase((Atributo as TColumn).Name) = UpperCase(NomeCampo) then
begin
if not Value.IsEmpty then
begin
Propriedade.SetValue(TObject(Obj), Value);
end;
EncontrouPropriedade := True;
Break;
end;
end
else if Atributo is TId then
begin
if UpperCase((Atributo as TId).NameField) = UpperCase(NomeCampo) then
begin
if not Value.IsEmpty then
begin
Propriedade.SetValue(TObject(Obj), Value);
end;
EncontrouPropriedade := True;
Break;
end;
end;
end;
if EncontrouPropriedade then
Break;
end;
end;
finally
Contexto.Free;
end;
Result := Obj;
end;
class function TGenericVO<T>.GetColumn(pName: string): TColumn;
var
Obj: T;
Contexto: TRttiContext;
Tipo: TRttiType;
Propriedade: TRttiProperty;
Atributo: TCustomAttribute;
Encontrou: Boolean;
begin
Result := nil;
Obj := CreateObject;
Contexto := TRttiContext.Create;
try
Tipo := Contexto.GetType(TObject(Obj).ClassType);
Encontrou := False;
for Propriedade in Tipo.GetProperties do
begin
for Atributo in Propriedade.GetAttributes do
begin
if Atributo is TColumn then
begin
if UpperCase((Atributo as TColumn).Name) = UpperCase(pName) then
begin
Result := (Atributo as TColumn).Clone;
Encontrou := True;
Break;
end;
end;
end;
if Encontrou then
Break;
end;
finally
TObject(Obj).Free;
Contexto.Free;
end;
end;
class function TGenericVO<T>.FieldCaption(pFieldName: string): string;
var
Atributo: TColumn;
begin
Atributo := GetColumn(pFieldName);
if Assigned(Atributo) then
begin
Result := Atributo.Caption;
Atributo.Free;
end
else
begin
Result := '';
end;
end;
class function TGenericVO<T>.FieldLength(pFieldName: string): Integer;
var
Atributo: TColumn;
begin
Atributo := GetColumn(pFieldName);
if Assigned(Atributo) then
begin
Result := Atributo.Length;
Atributo.Free;
end
else
begin
Result := 0;
end;
end;
end.
|
(* IndexGen: HDO, 2002-02-28 *)
(* -------- *)
(* Generation of a sorted index of all words in a text file. *)
(* Command line: *)
(* IndexGen [ textFileName ] *)
(*===============================================================*)
PROGRAM IndexGen;
USES
WinCrt, Timer;
CONST
EF = CHR(0); (*end of file character*)
maxWordLen = 30; (*max. number of characters per word*)
chars = ['a' .. 'z', 'ä', 'ö', 'ü', 'ß',
'A' .. 'Z', 'Ä', 'Ö', 'Ü'];
size = 30000;
TYPE
Word = STRING[maxWordLen];
doubleListPtr = ^listElement;
listElement = record
val : Integer;
Prev : doubleListPtr;
Next : doubleListPtr;
end; (*Record*)
dList = ^List;
List = RECORD
first: doubleListPtr;
last: doubleListPtr;
END; (*Record*)
NodePtr = ^Node;
Node = RECORD
key: STRING;
data : dList;
next: NodePtr;
END; (*Record*)
ListPtr = NodePtr;
HashTable = ARRAY[0..size-1] OF ListPtr;
VAR
txt: TEXT; (*text file*)
curLine: STRING; (*current line from file txt*)
curCh: CHAR; (*current character*)
curLineNr: INTEGER; (*current line number*)
curColNr: INTEGER; (*current column number*)
ht : HashTable;
wordArray : ARRAY of STRING;
wordCount : Integer;
(* New has table node *)
function NewHashNode(key: String; next: NodePtr; data : dList) : NodePtr;
var
n: NodePtr;
begin
New(n);
n^.key := key;
n^.next := next;
n^.data := data;
NewHashNode := n;
end; (*NewNode*)
(* New double linked list node *)
function NewDLListNode(val : Integer) : doubleListPtr;
var temp : doubleListPtr;
begin
New(temp);
temp^.val := val;
temp^.prev := Nil;
temp^.next := Nil;
NewDLListNode := temp;
end;
(* init double linked list*)
procedure InitDLList(var l : dList);
begin
l^.first := Nil;
l^.last := Nil;
end;
(* append to double linked list *)
procedure AppendDlList(var l : dList; val : Integer);
var n : doubleListPtr;
begin
if (l^.first = Nil) then
begin
n := NewDLListNode(val);
l^.first := n;
l^.last := n;
end
else
begin
if l^.last^.val <> val then begin
n := NewDLListNode(val);
n^.prev := l^.last;
l^.last^.next := n;
l^.last := n;
end;
end;
end;
(* returns the hashcode of a key *)
function HashCode4(key: String): Integer;
var
hc, i : Integer;
begin
hc := 0;
for i := 1 to Length(key) do begin
{Q-}
{R-}
hc := 31 * hc + Ord(key[i]);
{R+}
{Q+}
end; (* for *)
HashCode4 := Abs(hc) MOD size;
end; (*HashCode4*)
(* Lookup combines search and prepend *)
function Lookup(key: String; val : Integer) : NodePtr;
var
i: Integer;
n: NodePtr;
l: dList;
begin
i := HashCode4(key);
//WriteLn('Hashwert= ', i);
n := ht[i];
while (n <> Nil) do begin
if (n^.key = key) THEN BEGIN
AppendDlList(n^.data, val);
exit;
end;
n := n^.next;
end;
if n = nil then begin
New(l);
InitDLList(l);
AppendDlList(l, val);
n := NewHashNode(key, ht[i], l);
ht[i] := n;
if wordCount >= High(wordArray) then
SetLength(wordArray, (wordCount + 500));
wordArray[wordcount] := key;
wordCount := wordCount + 1;
end; (*if*)
Lookup := n;
end; (* Lookup *)
FUNCTION LowerCase(ch: CHAR): STRING;
BEGIN
CASE ch OF
'A'..'Z': LowerCase := CHR(ORD(ch) + (ORD('a') - ORD('A')));
'Ä', 'ä': LowerCase := 'ae';
'Ö', 'ö': LowerCase := 'oe';
'Ü', 'ü': LowerCase := 'ue';
'ß': LowerCase := 'ss';
ELSE (*all the others*)
LowerCase := ch;
END; (*CASE*)
END; (*LowerCase*)
PROCEDURE GetNextChar; (*updates curChar, ...*)
BEGIN
IF curColNr < Length(curLine) THEN BEGIN
curColNr := curColNr + 1;
curCh := curLine[curColNr]
END (*THEN*)
ELSE BEGIN (*curColNr >= Length(curLine)*)
IF NOT Eof(txt) THEN BEGIN
ReadLn(txt, curLine);
curLineNr:= curLineNr + 1;
curColNr := 0;
curCh := ' '; (*separate lines by ' '*)
END (*THEN*)
ELSE (*Eof(txt)*)
curCh := EF;
END; (*ELSE*)
END; (*GetNextChar*)
PROCEDURE GetNextWord(VAR w: Word; VAR lnr: INTEGER);
BEGIN
WHILE (curCh <> EF) AND NOT (curCh IN chars) DO BEGIN
GetNextChar;
END; (*WHILE*)
lnr := curLineNr;
IF curCh <> EF THEN BEGIN
w := LowerCase(curCh);
GetNextChar;
WHILE (curCh <> EF) AND (curCh IN chars) DO BEGIN
w := Concat(w , LowerCase(curCh));
GetNextChar;
END; (*WHILE*)
END (*THEN*)
ELSE (*curCh = EF*)
w := '';
END; (*GetNextWord*)
procedure WriteLineNumbers(d : dList);
var
n : doubleListPtr;
begin
if d^.first <> NIL then begin
n := d^.first;
WHILE (n <> NIL) DO BEGIN
Write(n^.val, ' ');
n := n^.next;
END;
end;
end;
procedure WriteHashTable;
var
h : Integer;
n : NodePtr;
d : dList;
begin
for h:= 0 to size-1 do begin
if ht[h] <> nil then begin
Write(h, ': ');
n := ht[h];
while n <> nil do begin
Write(n^.key, ' ');
WriteLineNumbers(n^.data);
n := n^.next;
end; (* while *)
WriteLn;
end; (* if *)
end; (* for *)
end; (* WriteHashTable *)
PROCEDURE Swap(VAR a, b : String);
VAR
temp : String;
BEGIN
temp := b;
b := a;
a := temp;
END;
FUNCTION LT(a, b : String) : BOOLEAN;
BEGIN
LT := a < b;
END;
(* quicksort rec for string arrays *)
PROCEDURE QuickSort(VAR arr : ARRAY OF String; n : INTEGER);
PROCEDURE QuickSortRec(VAR arr : ARRAY OF String; l, u : INTEGER);
VAR
p : String;
i, j : INTEGER;
BEGIN
IF l < u THEN BEGIN
(* at least 2 elements *)
p := arr[l + (u - l) DIV 2]; (* use first element as pivot *)
i := l;
j := u;
REPEAT
WHILE LT(arr[i], p) DO Inc(i);
WHILE LT(p, arr[j]) DO Dec(j);
IF i <= j THEN BEGIN
IF i <> j THEN BEGIN
Swap(arr[i], arr[j]);
END;
Inc(i);
Dec(j);
END;
UNTIL i > j;
IF j > l THEN QuickSortRec(arr, l, j);
IF i < u THEN QuickSortRec(arr, i, u);
END;
END;
BEGIN
QuickSortRec(arr, Low(arr), n);
END;
procedure PrintStringArray();
var
i : Integer;
n : NodePtr;
begin
for i := 0 to wordCount do begin
WriteLn;
Write(wordArray[i], ': ',#9);
n := ht[HashCode4(wordArray[i])];
while (n <> NIL) AND (n^.key <> wordArray[i]) do begin
n := n^.next;
end;
if n <> nil then
WriteLineNumbers(n^.data);
end;
end;
procedure Init();
var i : Integer;
begin
SetLength(wordArray,1000);
for i := 0 to size-1 do begin
ht[i] := NIL;
end;
end;
VAR
txtName: STRING;
w: Word; (*current word*)
lnr: INTEGER; (*line number of current word*)
n: LONGINT; (*number of words*)
BEGIN (*IndexGen*)
Init;
Write('IndexGen: index generation for text file ');
IF ParamCount = 0 THEN BEGIN
WriteLn;
WriteLn;
Write('name of text file > ');
ReadLn(txtName);
END (*THEN*)
ELSE BEGIN
txtName := ParamStr(1);
WriteLn(txtName);
END; (*ELSE*)
WriteLn;
(*--- read text from text file ---*)
Assign(txt, txtName);
Reset(txt);
curLine := '';
curLineNr := 0;
curColNr := 1; (*curColNr > Length(curLine) forces reading of first line*)
GetNextChar; (*curCh now holds first character*)
n := 0;
wordCount := 0;
StartTimer;
GetNextWord(w, lnr);
WHILE Length(w) > 0 DO BEGIN
//WriteLn(w, ' ', lnr);
Lookup(w,lnr);
n := n + 1;
GetNextWord(w, lnr);
END; (*WHILE*)
QuickSort(wordArray, wordCount);
PrintStringArray();
StopTimer;
WriteLn;
WriteLn('number of words: ', n, ' ', wordCount);
WriteLn('elapsed time: ', ElapsedTime);
Close(txt);
ReadLn;
END. (*IndexGen*) |
unit ideSHRestoreConnectionFrm;
interface
uses
SHDesignIntf,
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ideSHBaseDialogFrm, AppEvnts, StdCtrls, ExtCtrls;
type
TRestoreConnectionForm = class(TBaseDialogForm)
Timer1: TTimer;
Panel1: TPanel;
Image1: TImage;
Label1: TLabel;
Panel2: TPanel;
Memo1: TMemo;
procedure FormCreate(Sender: TObject);
procedure Timer1Timer(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
//var
// RestoreConnectionForm: TRestoreConnectionForm;
procedure RestoreConnection(ADatabase: TSHComponent);
implementation
uses
ideSHSystem, ideSHConsts;
{$R *.dfm}
procedure RestoreConnection(ADatabase: TSHComponent);
var
RestoreConnectionForm: TRestoreConnectionForm;
ISHDatabaseIntf: ISHDatabase;
Reconnect: Boolean;
begin
RestoreConnectionForm := TRestoreConnectionForm.Create(Application);
try
if Supports(ADatabase, ISHDatabase, ISHDatabaseIntf) then
begin
RestoreConnectionForm.Memo1.Lines.Add(ISHDatabaseIntf.Caption);
RestoreConnectionForm.Memo1.Lines.Add(ISHDatabaseIntf.ConnectPath);
RestoreConnectionForm.Memo1.Lines.Add(SLineBreak);
RestoreConnectionForm.Memo1.Lines.Add(Format('%s', ['Please, choose your preferable action:']));
RestoreConnectionForm.Memo1.Lines.Add(Format('%s', ['1. Restore connection']));
RestoreConnectionForm.Memo1.Lines.Add(Format('%s', ['2. Close connections and all linked objects']));
end;
Reconnect := IsPositiveResult(RestoreConnectionForm.ShowModal);
finally
FreeAndNil(RestoreConnectionForm);
end;
if Reconnect then
begin
if not DesignerIntf.ReconnectTo(ADatabase) then
begin
DesignerIntf.ShowMsg(Format('%s%s%s', ['It''s impossible to reconnect to database', SLineBreak, 'The connection will be closed']), mtWarning);
DesignerIntf.DisconnectFrom(ADatabase);
end;
end else
DesignerIntf.DisconnectFrom(ADatabase);
end;
procedure TRestoreConnectionForm.FormCreate(Sender: TObject);
begin
SetFormSize(340, 420);
Position := poScreenCenter;
inherited;
ButtonsMode := bmOKCancel;
Caption := Format('%s', [SCaptionDialogLostConnection]);
CaptionOK := Format('%s', [SCaptionButtonRestore]);
CaptionCancel := Format('%s', [SCaptionButtonClose]);
end;
procedure TRestoreConnectionForm.Timer1Timer(Sender: TObject);
begin
inherited;
Image1.Visible := not Image1.Visible;
end;
end.
|
unit Unit4;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes,
System.Variants, System.inifiles,
FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.StdCtrls,
FMX.Controls.Presentation, FMX.ListBox, FMX.Objects;
type
TPerfectModem = class(Tobject)
private
FBPXAddress_0: String;
FBPXAddress_1: String;
FDevtronAddress_0: String;
FDevtronAddress_1: String;
FModemHeartBeat: String;
FFirmwareVersion: String;
FRemoteDebug: String;
FSimPriorityList: String;
public
constructor create();
property BPXAddress_0: String read FBPXAddress_0 write FBPXAddress_0;
property BPXAddress_1: String read FBPXAddress_1 write FBPXAddress_1;
property DevtronAddress_0: String read FDevtronAddress_0
write FDevtronAddress_0;
property DevtronAddress_1: String read FDevtronAddress_1
write FDevtronAddress_1;
property ModemHeartbeat: String read FModemHeartBeat write FModemHeartBeat;
property FirmwareVersion: String read FFirmwareVersion
write FFirmwareVersion;
property RemoteDebug: String read FRemoteDebug write FRemoteDebug;
property SimPriorityList: String read FSimPriorityList
write FSimPriorityList;
end;
implementation
{ TPerfectModem }
constructor TPerfectModem.create;
begin
FBPXAddress_0 := '';
FBPXAddress_1 := '';
FDevtronAddress_0 := '';
FDevtronAddress_1 := '';
FModemHeartBeat := '';
FFirmwareVersion := '';
FRemoteDebug := '';
FSimPriorityList := '';
end;
end.
|
unit ModflowNPF_WriterUnit;
interface
uses
CustomModflowWriterUnit, ModflowPackageSelectionUnit, Vcl.Forms, DataSetUnit;
type
TNpfWriter = class(TCustomFlowPackageWriter)
private
procedure WriteDataSet1;
procedure WriteIcelltype;
procedure WriteHK;
procedure WriteVK;
procedure WriteWETDRY;
procedure WriteHANI;
protected
function Package: TModflowPackageSelection; override;
class function Extension: string; override;
public
procedure WriteFile(const AFileName: string);
end;
implementation
uses
frmErrorsAndWarningsUnit, ModflowUnitNumbers, frmProgressUnit, GoPhastTypes,
ModflowOptionsUnit, ModflowOutputControlUnit, PhastModelUnit,
System.SysUtils;
resourcestring
StrWritingNPFPackage = 'Writing NPF Package input.';
{ TNpfWriter }
class function TNpfWriter.Extension: string;
begin
Result := '.npf';
end;
function TNpfWriter.Package: TModflowPackageSelection;
begin
result := Model.ModflowPackages.NpfPackage;
end;
procedure TNpfWriter.WriteDataSet1;
var
HNOFlO: Real;
HDRY: Real;
NpfPackage: TNpfPackage;
Wetting: TWettingOptions;
WETFCT: Real;
IWETIT: Integer;
IHDWET: Integer;
begin
WriteBeginOptions;
WriteSaveFlowsOption;
HNOFlO := Model.ModflowOptions.HNoFlow;
WriteString(' HNOFLO ');
WriteFloat(HNOFlO);
NewLine;
HDRY := Model.ModflowOptions.HDry;
WriteString(' HDRY ');
WriteFloat(HDRY);
NewLine;
NpfPackage := Model.ModflowPackages.NpfPackage;
case NpfPackage.CellAveraging of
caHarmonic: WriteString(' CELL_AVERAGING HARMONIC');
caLogarithmic: WriteString(' CELL_AVERAGING LOGARITHMIC');
caArithLog: WriteString(' CELL_AVERAGING AMT-LMK');
else Assert(False);
end;
NewLine;
if NpfPackage.UseSaturatedThickness then
begin
WriteString(' THICKSTRT');
NewLine;
end;
if NpfPackage.TimeVaryingVerticalConductance then
begin
WriteString(' VARIABLECV');
if NpfPackage.Dewatered then
begin
WriteString(' DEWATERED');
end;
NewLine;
end;
if NpfPackage.Perched then
begin
WriteString(' PERCHED');
NewLine;
end;
Wetting := Model.ModflowWettingOptions;
if Wetting.WettingActive then
begin
WriteString(' REWET');
NewLine;
WETFCT := Wetting.WettingFactor;
WriteString(' WETFCT ');
WriteFloat(WETFCT);
NewLine;
IWETIT := Wetting.WettingIterations;
WriteString(' IWETIT ');
WriteInteger(IWETIT);
NewLine;
IHDWET := Wetting.WettingEquation;
WriteString(' IHDWET ');
WriteInteger(IHDWET);
NewLine;
end;
if NpfPackage.UseNewtonRaphson then
begin
WriteString(' NEWTON');
NewLine;
end;
if NpfPackage.ApplyHeadDampening then
begin
WriteString(' NEWTON_HEAD_DAMPENING');
NewLine;
end;
WriteEndOptions;
end;
procedure TNpfWriter.WriteFile(const AFileName: string);
var
NameOfFile: string;
begin
frmErrorsAndWarnings.BeginUpdate;
try
if not Model.ModflowPackages.NpfPackage.IsSelected then
begin
Exit
end;
if FlowPackageFileGeneratedExternally then
begin
Exit;
end;
NameOfFile := FileName(AFileName);
WriteToNameFile(StrNPF, -1, NameOfFile, foInput, Model);
OpenFile(NameOfFile);
try
frmProgressMM.AddMessage(StrWritingNPFPackage);
frmProgressMM.AddMessage(StrWritingDataSet0);
WriteDataSet0;
Application.ProcessMessages;
if not frmProgressMM.ShouldContinue then
begin
Exit;
end;
frmProgressMM.AddMessage(StrWritingOptions);
WriteDataSet1;
Application.ProcessMessages;
if not frmProgressMM.ShouldContinue then
begin
Exit;
end;
NewLine;
WriteString('BEGIN NPFDATA');
NewLine;
WriteIcelltype;
Application.ProcessMessages;
if not frmProgressMM.ShouldContinue then
begin
Exit;
end;
WriteHK;
Application.ProcessMessages;
if not frmProgressMM.ShouldContinue then
begin
Exit;
end;
WriteVK;
Application.ProcessMessages;
if not frmProgressMM.ShouldContinue then
begin
Exit;
end;
WriteWETDRY;
Application.ProcessMessages;
if not frmProgressMM.ShouldContinue then
begin
Exit;
end;
WriteHANI;
Application.ProcessMessages;
if not frmProgressMM.ShouldContinue then
begin
Exit;
end;
WriteString('END NPFDATA');
NewLine;
finally
CloseFile;
end;
finally
frmErrorsAndWarnings.EndUpdate;
end;
end;
procedure TNpfWriter.WriteHANI;
var
DataArray: TDataArray;
begin
frmProgressMM.AddMessage(' Writing HANI');
DataArray := Model.DataArrayManager.GetDataSetByName(rsHorizontalAnisotropy);
WriteMf6_DataSet(DataArray, 'HANI');
end;
procedure TNpfWriter.WriteHK;
var
DataArray: TDataArray;
begin
frmProgressMM.AddMessage(' Writing HK');
DataArray := Model.DataArrayManager.GetDataSetByName(rsKx);
WriteMf6_DataSet(DataArray, 'HK');
end;
procedure TNpfWriter.WriteIcelltype;
var
DataArray: TDataArray;
begin
frmProgressMM.AddMessage(' Writing ICELLTYPE');
DataArray := Model.DataArrayManager.GetDataSetByName(KCellType);
WriteMf6_DataSet(DataArray, 'ICELLTYPE');
end;
procedure TNpfWriter.WriteVK;
var
DataArray: TDataArray;
begin
frmProgressMM.AddMessage(' Writing VK');
DataArray := Model.DataArrayManager.GetDataSetByName(rsKz);
WriteMf6_DataSet(DataArray, 'VK');
end;
procedure TNpfWriter.WriteWETDRY;
var
DataArray: TDataArray;
begin
if Model.ModflowWettingOptions.WettingActive then
begin
frmProgressMM.AddMessage(' Writing WETDRY');
DataArray := Model.DataArrayManager.GetDataSetByName(rsWetDry);
WriteMf6_DataSet(DataArray, 'WETDRY');
end;
end;
end.
|
unit fGameHistory;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, uMinesClasses;
type
TfrmGameHistory = class(TForm)
ListBox_Actions: TListBox;
Label1: TLabel;
private
{ Private declarations }
FMines : TMines;
public
{ Public declarations }
procedure AfterUpdate(Sender: TObject);
procedure SetMines(Mines : TMines);
end;
var
frmGameHistory: TfrmGameHistory;
implementation
{$R *.dfm}
{ TfrmGameActions }
procedure TfrmGameHistory.AfterUpdate(Sender: TObject);
begin
Assert(Assigned(FMines),'Mines not set!');
ListBox_Actions.Items.Assign(FMines.MoveHistory);
FMines.MoveHistory.Assign(ListBox_Actions.Items);
end;
procedure TfrmGameHistory.SetMines(Mines: TMines);
begin
FMines := Mines;
Mines.OnAfterUpdate := AfterUpdate;
end;
end.
|
unit uSubSaleHistory;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, uParentSub, siComp, siLangRT, Grids, StdCtrls, Mask, StrUtils,
SuperComboADO, DB, ADODB, cxControls, cxContainer, cxEdit, cxTextEdit,
cxMaskEdit, cxDropDownEdit, cxLookupEdit, cxDBLookupEdit,
cxDBLookupComboBox;
type
TSubSaleHistory = class(TParentSub)
Label7: TLabel;
btnRefreshSales: TButton;
grdSaleHist: TStringGrid;
quSaleHistory: TADOQuery;
quSaleHistoryYear: TIntegerField;
quSaleHistoryMonth: TIntegerField;
quSaleHistoryTotSale: TFloatField;
quSaleHistoryTotCost: TFloatField;
cmbStoreSale: TcxLookupComboBox;
procedure btnRefreshSalesClick(Sender: TObject);
procedure grdSaleHistSelectCell(Sender: TObject; ACol,
ARow: Integer; var CanSelect: Boolean);
procedure FormCreate(Sender: TObject);
procedure cmbStoreSaleEnter(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure cxLookupComboBox1PropertiesChange(Sender: TObject);
private
{ Private declarations }
fIDModel : Integer;
fIDStore : Integer;
sRetail,
sCost,
sProfit,
sMarkup,
sTotalYear,
sTotalMonth,
sProfValor : String;
procedure RefreshSaleHistory;
procedure FillSaleHistory(Tipo, MyMonth, MyYear : integer);
protected
procedure AfterSetParam; override;
public
{ Public declarations }
end;
implementation
uses uDM, uParamFunctions, uDMGlobal, uNumericFunctions, uSystemConst,
uSqlFunctions;
{$R *.dfm}
procedure TSubSaleHistory.AfterSetParam;
begin
fIDModel := StrToIntDef(ParseParam(FParam, 'IDModel'),0);
fIDStore := StrToIntDef(ParseParam(FParam, 'IDStore'),0);
RefreshSaleHistory;
end;
procedure TSubSaleHistory.FillSaleHistory(Tipo, MyMonth, MyYear : integer);
var
TotYearSale, TotYearCost : Double;
i, Pos : integer;
begin
for i := 1 to 14 do
grdSaleHist.Cells[i, grdSaleHist.RowCount-1] := '0';
case Tipo of
HIST_RETAIL : grdSaleHist.Cells[0 , grdSaleHist.RowCount-1] := sRetail;
HIST_COST : grdSaleHist.Cells[0 , grdSaleHist.RowCount-1] := sCost;
HIST_GROSS : grdSaleHist.Cells[0 , grdSaleHist.RowCount-1] := sProfit;
HIST_MARKUP : grdSaleHist.Cells[0 , grdSaleHist.RowCount-1] := sMarkup;
HIST_PROFIT : grdSaleHist.Cells[0 , grdSaleHist.RowCount-1] := sProfValor;
end;
quSaleHistory.First;
TotYearSale := 0;
TotYearCost := 0;
while not quSaleHistory.EOF do
begin
// Preenche o MonthTo date
if (quSaleHistoryMonth.AsInteger = MyMonth) and
(quSaleHistoryYear.AsInteger = MyYear) then
begin
case Tipo of
HIST_RETAIL : grdSaleHist.Cells[1, grdSaleHist.RowCount-1] := FloatToStrF(quSaleHistoryTotSale.AsFloat, ffNumber, 20, 2);
HIST_COST : grdSaleHist.Cells[1, grdSaleHist.RowCount-1] := FloatToStrF(quSaleHistoryTotCost.AsFloat, ffNumber, 20, 2);
HIST_GROSS :
if quSaleHistoryTotSale.AsFloat <> 0 then
grdSaleHist.Cells[1, grdSaleHist.RowCount-1] := MyFloatToStr(MyRound(100-(quSaleHistoryTotCost.AsFloat/quSaleHistoryTotSale.AsFloat)*100, 2))
else
grdSaleHist.Cells[1, grdSaleHist.RowCount-1] := '0';
HIST_MARKUP :
if quSaleHistoryTotCost.AsFloat <> 0 then
grdSaleHist.Cells[1, grdSaleHist.RowCount-1] := MyFloatToStr(MyRound(((quSaleHistoryTotSale.AsFloat-quSaleHistoryTotCost.AsFloat)/quSaleHistoryTotCost.AsFloat)*100, 2))
else
grdSaleHist.Cells[1, grdSaleHist.RowCount-1] := '0';
HIST_PROFIT : grdSaleHist.Cells[1, grdSaleHist.RowCount-1] := FloatToStrF((quSaleHistoryTotSale.AsFloat - quSaleHistoryTotCost.AsFloat), ffNumber, 20, 2);
end;
end;
TotyearSale := TotYearSale + quSaleHistoryTotSale.AsFloat;
TotyearCost := TotYearCost + quSaleHistoryTotCost.AsFloat;
case Tipo of
HIST_RETAIL : grdSaleHist.Cells[14 , grdSaleHist.RowCount-1] := FloatToStrF(TotYearSale, ffNumber, 20, 2);
HIST_COST : grdSaleHist.Cells[14 , grdSaleHist.RowCount-1] := FloatToStrF(TotYearCost, ffNumber, 20, 2);
HIST_GROSS :
if TotYearSale <> 0 then
grdSaleHist.Cells[14 , grdSaleHist.RowCount-1] := MyFloatToStr(MyRound(100-(TotYearCost/TotYearSale)*100, 2))
else
grdSaleHist.Cells[14 , grdSaleHist.RowCount-1] := '0';
HIST_MARKUP :
if TotYearCost <> 0 then
grdSaleHist.Cells[14 , grdSaleHist.RowCount-1] := MyFloatToStr(MyRound(((TotYearSale-TotYearCost)/TotYearCost)*100, 2))
else
grdSaleHist.Cells[14 , grdSaleHist.RowCount-1] := '0';
HIST_PROFIT : grdSaleHist.Cells[14 , grdSaleHist.RowCount-1] := FloatToStrF(TotyearSale - TotyearCost, ffNumber, 20, 2);
end;
Pos := -1;
if (quSaleHistoryMonth.AsInteger < MyMonth) and
(quSaleHistoryYear.AsInteger = MyYear) then
Pos := (MyMonth-quSaleHistoryMonth.AsInteger)+1
else if (quSaleHistoryMonth.AsInteger >= MyMonth) and
(quSaleHistoryYear.AsInteger < MyYear ) then
Pos := (12-quSaleHistoryMonth.AsInteger)+MyMonth+1;
if Pos > 0 then
case Tipo of
HIST_RETAIL : grdSaleHist.Cells[Pos, grdSaleHist.RowCount-1] := FloatToStrF(quSaleHistoryTotSale.AsFloat, ffNumber, 20, 2);
HIST_COST : grdSaleHist.Cells[Pos, grdSaleHist.RowCount-1] := FloatToStrF(quSaleHistoryTotCost.AsFloat, ffNumber, 20, 2);
HIST_GROSS :
if quSaleHistoryTotSale.AsFloat <> 0 then
grdSaleHist.Cells[Pos, grdSaleHist.RowCount-1] := MyFloatToStr(MyRound(100-(quSaleHistoryTotCost.AsFloat/quSaleHistoryTotSale.AsFloat)*100, 2))
else
grdSaleHist.Cells[Pos, grdSaleHist.RowCount-1] := '0';
HIST_MARKUP :
if quSaleHistoryTotCost.AsFloat <> 0 then
grdSaleHist.Cells[Pos, grdSaleHist.RowCount-1] := MyFloatToStr(MyRound(((quSaleHistoryTotSale.AsFloat-quSaleHistoryTotCost.AsFloat)/quSaleHistoryTotCost.AsFloat)*100, 2))
else
grdSaleHist.Cells[Pos, grdSaleHist.RowCount-1] := '0';
HIST_PROFIT : grdSaleHist.Cells[Pos, grdSaleHist.RowCount-1] := FloatToStrF(quSaleHistoryTotSale.AsFloat - quSaleHistoryTotCost.AsFloat, ffNumber, 20, 2);
end;
quSaleHistory.Next;
end;
end;
procedure TSubSaleHistory.RefreshSaleHistory;
var
i, j , MyMonth, MyYear,
AtualMovID : Integer;
begin
Screen.Cursor := crHourGlass;
with quSaleHistory do
begin
if Active then
Close;
if not Active then
begin
MyMonth := StrToInt(FormatDateTime('m', Date));
MyYear := StrToInt(FormatDateTime('yyyy', Date));
SQL.Clear;
SQL.Add('SELECT Year, Month, SUM(TotSale) as TotSale, SUM(TotCost) as TotCost');
SQL.Add('FROM InventoryMovTotal InventoryMovTotal (NOLOCK)');
SQL.Add(' WHERE ModelID = ' + IntToStr(fIDModel));
if fIDStore <> 0 then
SQL.Add(' AND StoreID = ' + IntToStr(fIDStore))
else
SQL.Add(' AND StoreID IN (' + DM.fStore.StoreList + ')');
SQL.Add(' AND InventMovTypeID in (1, 50)');
SQL.Add(' AND ((Year >= '+IntToStr(MyYear - 1)+ ' AND Month >= '+ IntToStr(MyMonth-1)+') or ((Year-1) = '+IntToStr(MyYear-1)+')) ');
SQL.Add(' GROUP BY Year, Month ');
SQL.Add(' ORDER BY Year, Month ');
Open;
end;
grdSaleHist.RowCount := 2;
// Cabecalho TotYear e TotMonth
grdSaleHist.Cells[1, 0] := sTotalMonth;
grdSaleHist.Cells[14, 0] := sTotalYear;
// Cabeçalho dos meses
for i := 1 to 12 do
if i < MyMonth then
grdSaleHist.Cells[(MyMonth-i)+1, 0] := ShortMonthNames[i] + ' ' + RightStr(IntToStr(MyYear),2)
else
grdSaleHist.Cells[(12-i)+MyMonth+1, 0] := ShortMonthNames[i] + ' ' + RightStr(IntToStr(MyYear - 1),2);
// Totaliza o Total de Sales
FillSaleHistory(HIST_COST, MyMonth, MyYear);
grdSaleHist.RowCount := grdSaleHist.RowCount + 1;
FillSaleHistory(HIST_RETAIL, MyMonth, MyYear);
grdSaleHist.RowCount := grdSaleHist.RowCount + 1;
FillSaleHistory(HIST_GROSS, MyMonth, MyYear);
grdSaleHist.RowCount := grdSaleHist.RowCount + 1;
FillSaleHistory(HIST_MARKUP, MyMonth, MyYear);
grdSaleHist.RowCount := grdSaleHist.RowCount + 1;
FillSaleHistory(HIST_PROFIT, MyMonth, MyYear);
Close;
end;
Screen.Cursor := crDefault;
end;
procedure TSubSaleHistory.btnRefreshSalesClick(Sender: TObject);
begin
inherited;
DM.quLookUpStore.Close;
fIDStore := 0;
RefreshSaleHistory;
end;
procedure TSubSaleHistory.grdSaleHistSelectCell(Sender: TObject;
ACol, ARow: Integer; var CanSelect: Boolean);
begin
inherited;
grdSaleHist.Hint := grdSaleHist.Cells[ACol, ARow];
end;
procedure TSubSaleHistory.FormCreate(Sender: TObject);
var
sSQL, sWhere : String;
begin
inherited;
Case DMGlobal.IDLanguage of
LANG_ENGLISH :
begin
sRetail := 'Retail ';
sCost := 'Cost ';
sProfit := 'Profit % ';
sMarkup := 'MarkUp % ';
sProfValor := 'Profit Amount';
sTotalYear := 'YTD';
sTotalMonth:= 'MTD';
end;
LANG_PORTUGUESE :
begin
sRetail := 'Venda ';
sCost := 'Custo ';
sProfit := '% Lucro ';
sMarkup := '% Margem ';
sProfValor := 'Lucro';
sTotalYear := 'ANO';
sTotalMonth:= 'MES';
end;
LANG_SPANISH :
begin
sRetail := 'Venta ';
sCost := 'Costo ';
sProfit := '% Lucro ';
sMarkup := '% Margen ';
sProfValor := 'Margen';
sTotalYear := 'YTD';
sTotalMonth:= 'MTD';
end;
end;
DM.quLookUpStore.Close;
sWhere := ' Desativado = 0 AND IDStore <> 0 ';
if DM.fStore.StoreList <> '' then
sWhere := sWhere + ' AND IDStore IN (' + DM.fStore.StoreList + ')';
sSQL := ChangeWhereClause(DM.quLookUpStore.CommandText, sWhere, True);
DM.quLookUpStore.CommandText := sSQL;
end;
procedure TSubSaleHistory.cmbStoreSaleEnter(Sender: TObject);
begin
inherited;
with DM.quLookUpStore do
if not Active then
Open;
end;
procedure TSubSaleHistory.FormDestroy(Sender: TObject);
begin
DM.quLookUpStore.Close;
quSaleHistory.Close;
inherited;
end;
procedure TSubSaleHistory.cxLookupComboBox1PropertiesChange(
Sender: TObject);
begin
inherited;
with DM.quLookUpStore do
if Active then
if DM.quLookUpStore.Locate('Name', cmbStoreSale.Text, []) then
fIDStore := DM.quLookUpStoreIDStore.AsInteger;
RefreshSaleHistory;
end;
initialization
RegisterClass(TSubSaleHistory);
end.
|
(*----------------------------------------------------------------------------*
* Direct3D sample from DirectX 9.0 SDK December 2006 *
* Delphi adaptation by Alexey Barkovoy (e-mail: directx@clootie.ru) *
* *
* Supported compilers: Delphi 5,6,7,9; FreePascal 2.0 *
* *
* Latest version can be downloaded from: *
* http://www.clootie.ru *
* http://sourceforge.net/projects/delphi-dx9sdk *
*----------------------------------------------------------------------------*
* $Id: InstancingUnit.pas,v 1.17 2007/02/05 22:21:09 clootie Exp $
*----------------------------------------------------------------------------*)
//--------------------------------------------------------------------------------------
// File: Instancing.cpp
//
// Demonstrates the geometry instancing capability of VS3.0-capable hardware by replicating
// a single box model into a pile of boxes all in one DrawIndexedPrimitive call.
// Also shows alternate ways of doing instancing on non-vs_3_0 HW
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//--------------------------------------------------------------------------------------
{$I DirectX.inc}
unit InstancingUnit;
interface
uses
Windows, SysUtils, Math,
DXTypes, Direct3D9, D3DX9, dxerr9,
DXUT, DXUTcore, DXUTenum, DXUTmisc, DXUTgui, DXUTSettingsDlg;
{.$DEFINE DEBUG_VS} // Uncomment this line to debug vertex shaders
{.$DEFINE DEBUG_PS} // Uncomment this line to debug pixel shaders
//--------------------------------------------------------------------------------------
// Global variables
//--------------------------------------------------------------------------------------
const
g_nMaxBoxes = 1000; // max number of boxes to render
g_nNumBatchInstance = 120; // number of batched instances; must be the same size as g_nNumBatchInstance from .fx file
var
g_pFont: ID3DXFont; // Font for drawing text
g_pTextSprite: ID3DXSprite; // Sprite for batching draw text calls
g_pEffect: ID3DXEffect; // D3DX effect interface
g_Camera: CModelViewerCamera; // A model viewing camera
g_bShowHelp: Boolean = True; // If true, it renders the UI control text
g_DialogResourceManager: CDXUTDialogResourceManager; // manager for shared resources of dialogs
g_SettingsDlg: CD3DSettingsDlg; // Device settings dialog
g_HUD: CDXUTDialog; // dialog for standard controls
g_SampleUI: CDXUTDialog; // dialog for sample specific controls
g_SampleUI2: CDXUTDialog; // dialog for sample specific controls
g_bAppIsDebug: Boolean = False; // The application build is debug
g_bRuntimeDebug: Boolean = False; // The D3D Debug Runtime was detected
g_NumBoxes: Integer = 500; // current number of boxes
g_iUpdateCPUUsageMessage: Integer = 0; // controls when to update the CPU usage static control
g_fBurnAmount: Double = 0.0; // time in seconds to burn for during each burn period
g_HandleTechnique: TD3DXHandle; // handle to the rendering technique
g_HandleWorld, g_HandleView, g_HandleProjection: TD3DXHandle; // handle to the world/view/projection matrixes
g_HandleTexture: TD3DXHandle; // handle to the box texture
g_HandleBoxInstance_Position: TD3DXHandle; // handle to the box instance position (array or the value itself)
g_HandleBoxInstance_Color: TD3DXHandle; // handle to the box instance color (array or the value itself)
g_pBoxTexture: IDirect3DTexture9; // Texture covering the box
g_iRenderTechnique: Word = 1; // the currently selected rendering technique
g_vBoxInstance_Position: array[0..g_nMaxBoxes-1] of TD3DXVector4; // instance data used in shader instancing (position)
g_vBoxInstance_Color: array[0..g_nMaxBoxes-1] of TD3DXColor; // instance data used in shader instancing (color)
g_fLastTime: Double = 0.0;
g_nShowUI: Integer = 2; // If 2, show UI. If 1, show text only. If 0, show no UI.
//--------------------------------------------------------------------------------------
//This VB holds float-valued normal, position and texture coordinates for the model (in this case, a box)
//This will be stream 0
g_pVBBox: IDirect3DVertexBuffer9;
g_pIBBox: IDirect3DIndexBuffer9;
type
// Format of the box vertices for HW instancing
PBoxVertex = ^TBoxVertex;
TBoxVertex = packed record
pos: TD3DXVector3; // Position of the vertex
norm: TD3DXVector3; // Normal at this vertex
u, v: Single; // Texture coordinates u,v
end;
PBoxVertexArray = ^TBoxVertexArray;
TBoxVertexArray = array[0..MaxInt div SizeOf(TBoxVertex)-1] of TBoxVertex;
// Format of the box vertices for shader instancing
PBoxVertexInstance = ^TBoxVertexInstance;
TBoxVertexInstance = packed record
pos: TD3DXVector3; // Position of the vertex
norm: TD3DXVector3; // Normal at this vertex
u, v: Single; // Texture coordinates u,v
boxInstance: Single; // Box instance index
end;
PBoxVertexInstanceArray = ^TBoxVertexInstanceArray;
TBoxVertexInstanceArray = array[0..MaxInt div SizeOf(TBoxVertexInstance)-1] of TBoxVertexInstance;
//--------------------------------------------------------------------------------------
//This VB holds the positions for copies of the basic box within the pile of boxes.
//The positions are expressed as bytes in a DWORD:
// byte 0: x position
// byte 1: y position
// byte 3: height of box
// byte 4: azimuthal rotation of box
//This will be stream 1
var
g_pVBInstanceData: IDirect3DVertexBuffer9;
//Here is the format of the box positions within the pile:
type
PBoxInstanceDataPos = ^TBoxInstanceDataPos;
TBoxInstanceDataPos = packed record
color: TD3DColor;
x: Byte;
y: Byte;
z: Byte;
rotation: Byte;
end;
//--------------------------------------------------------------------------------------
var
// Vertex Declaration for Hardware Instancing
g_pVertexDeclHardware: IDirect3DVertexDeclaration9;
g_VertexElemHardware: array[0..5] of TD3DVertexElement9 =
(
(Stream: 0; Offset: 0; _Type: D3DDECLTYPE_FLOAT3; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_POSITION; UsageIndex: 0),
(Stream: 0; Offset: 3*4; _Type: D3DDECLTYPE_FLOAT3; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_NORMAL; UsageIndex: 0),
(Stream: 0; Offset: 6*4; _Type: D3DDECLTYPE_FLOAT2; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_TEXCOORD; UsageIndex: 0),
(Stream: 1; Offset: 0; _Type: D3DDECLTYPE_D3DCOLOR; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_COLOR; UsageIndex: 0),
(Stream: 1; Offset: 4; _Type: D3DDECLTYPE_D3DCOLOR; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_COLOR; UsageIndex: 1),
{D3DDECL_END()}(Stream:$FF; Offset:0; _Type:D3DDECLTYPE_UNUSED; Method:TD3DDeclMethod(0); Usage:TD3DDeclUsage(0); UsageIndex:0)
);
// Vertex Declaration for Shader Instancing
g_pVertexDeclShader: IDirect3DVertexDeclaration9;
g_VertexElemShader: array[0..4] of TD3DVertexElement9 =
(
(Stream: 0; Offset: 0; _Type: D3DDECLTYPE_FLOAT3; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_POSITION; UsageIndex: 0),
(Stream: 0; Offset: 3*4; _Type: D3DDECLTYPE_FLOAT3; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_NORMAL; UsageIndex: 0),
(Stream: 0; Offset: 6*4; _Type: D3DDECLTYPE_FLOAT2; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_TEXCOORD; UsageIndex: 0),
(Stream: 0; Offset: 8*4; _Type: D3DDECLTYPE_FLOAT1; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_TEXCOORD; UsageIndex: 1),
{D3DDECL_END()}(Stream:$FF; Offset:0; _Type:D3DDECLTYPE_UNUSED; Method:TD3DDeclMethod(0); Usage:TD3DDeclUsage(0); UsageIndex:0)
);
// Vertex Declaration for Constants Instancing
g_pVertexDeclConstants: IDirect3DVertexDeclaration9;
g_VertexElemConstants: array[0..3] of TD3DVertexElement9 =
(
(Stream: 0; Offset: 0; _Type: D3DDECLTYPE_FLOAT3; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_POSITION; UsageIndex: 0),
(Stream: 0; Offset: 3*4; _Type: D3DDECLTYPE_FLOAT3; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_NORMAL; UsageIndex: 0),
(Stream: 0; Offset: 6*4; _Type: D3DDECLTYPE_FLOAT2; Method: D3DDECLMETHOD_DEFAULT; Usage: D3DDECLUSAGE_TEXCOORD; UsageIndex: 0),
{D3DDECL_END()}(Stream:$FF; Offset:0; _Type:D3DDECLTYPE_UNUSED; Method:TD3DDeclMethod(0); Usage:TD3DDeclUsage(0); UsageIndex:0)
);
//--------------------------------------------------------------------------------------
// UI control IDs
//--------------------------------------------------------------------------------------
const
IDC_TOGGLEFULLSCREEN = 1;
IDC_TOGGLEREF = 3;
IDC_CHANGEDEVICE = 4;
IDC_NUMBERBOXES_STATIC = 5;
IDC_NUMBERBOXES_SLIDER = 6;
IDC_RENDERMETHOD_LIST = 7;
IDC_BIND_CPU_STATIC = 8;
IDC_BIND_CPU_SLIDER = 9;
IDC_STATIC = 10;
IDC_CPUUSAGE_STATIC = 11;
IDC_TOGGLEUI = 12;
//--------------------------------------------------------------------------------------
// Forward declarations
//--------------------------------------------------------------------------------------
function IsDeviceAcceptable(const pCaps: TD3DCaps9; AdapterFormat, BackBufferFormat: TD3DFormat; bWindowed: Boolean; pUserContext: Pointer): Boolean; stdcall;
function ModifyDeviceSettings(var pDeviceSettings: TDXUTDeviceSettings; const pCaps: TD3DCaps9; pUserContext: Pointer): Boolean; stdcall;
function OnCreateDevice(const pd3dDevice: IDirect3DDevice9; const pBackBufferSurfaceDesc: TD3DSurfaceDesc; pUserContext: Pointer): HRESULT; stdcall;
function OnResetDevice(const pd3dDevice: IDirect3DDevice9; const pBackBufferSurfaceDesc: TD3DSurfaceDesc; pUserContext: Pointer): HRESULT; stdcall;
procedure OnFrameMove(const pd3dDevice: IDirect3DDevice9; fTime: Double; fElapsedTime: Single; pUserContext: Pointer); stdcall;
procedure OnFrameRender(const pd3dDevice: IDirect3DDevice9; fTime: Double; fElapsedTime: Single; pUserContext: Pointer); stdcall;
function MsgProc(hWnd: HWND; uMsg: LongWord; wParam: WPARAM; lParam: LPARAM; out pbNoFurtherProcessing: Boolean; pUserContext: Pointer): LRESULT; stdcall;
procedure KeyboardProc(nChar: LongWord; bKeyDown, bAltDown: Boolean; pUserContext: Pointer); stdcall;
procedure OnGUIEvent(nEvent: LongWord; nControlID: Integer; pControl: CDXUTControl; pUserContext: Pointer); stdcall;
procedure OnLostDevice(pUserContext: Pointer); stdcall;
procedure OnDestroyDevice(pUserContext: Pointer); stdcall;
procedure InitApp;
procedure RenderText;
function OnCreateBuffers(const pd3dDevice: IDirect3DDevice9): HRESULT;
procedure OnDestroyBuffers;
procedure CreateCustomDXUTobjects;
procedure DestroyCustomDXUTobjects;
implementation
//--------------------------------------------------------------------------------------
// Initialize the app
//--------------------------------------------------------------------------------------
procedure InitApp;
var
iY: Integer;
szMessage: WideString;
begin
// Initialize dialogs
g_SettingsDlg.Init(g_DialogResourceManager);
g_HUD.Init(g_DialogResourceManager);
g_SampleUI.Init(g_DialogResourceManager);
g_SampleUI2.Init(g_DialogResourceManager);
g_HUD.SetCallback(OnGUIEvent);
iY := 10; g_HUD.AddButton(IDC_TOGGLEFULLSCREEN, 'Toggle full screen', 35, iY, 125, 22);
Inc(iY, 24); g_HUD.AddButton(IDC_TOGGLEREF, 'Toggle REF (F3)', 35, iY, 125, 22);
Inc(iY, 24); g_HUD.AddButton(IDC_CHANGEDEVICE, 'Change device (F2)', 35, iY, 125, 22, VK_F2);
Inc(iY, 24); g_HUD.AddButton(IDC_TOGGLEUI, 'Toggle UI (U)', 35, iY, 125, 22);
g_SampleUI.SetCallback(OnGUIEvent);
g_SampleUI2.SetCallback(OnGUIEvent);
iY := 24;
szMessage := WideFormat('# Boxes: %d', [g_NumBoxes]);
Inc(iY, 24); g_SampleUI.AddStatic(IDC_NUMBERBOXES_STATIC, PWideChar(szMessage), 0, iY, 200, 22);
Inc(iY, 24); g_SampleUI.AddSlider(IDC_NUMBERBOXES_SLIDER, 50, iY, 100, 22, 1, g_nMaxBoxes, g_NumBoxes);
Inc(iY, 24);
szMessage := 'Goal: 0ms/frame';
Inc(iY, 12); g_SampleUI.AddStatic(IDC_BIND_CPU_STATIC, PWideChar(szMessage), 0, iY, 200, 22 );
szMessage := 'Remaining for logic: 0';
Inc(iY, 18); g_SampleUI.AddStatic(IDC_CPUUSAGE_STATIC, PWideChar(szMessage), 0, iY, 200, 22 );
Inc(iY, 24); g_SampleUI.AddSlider(IDC_BIND_CPU_SLIDER, 50, iY, 100, 22, 0, 166, 0 );
szMessage := 'If rendering takes less'#10 +
'time than goal, then remaining'#10 +
'time is spent to represent'#10 +
'game logic. More time'#10 +
'remaining means technique'#10 +
'takes less CPU time';
Inc(iY, 12*3); g_SampleUI.AddStatic(IDC_STATIC, PWideChar(szMessage), 10, iY, 170, 100);
g_SampleUI2.AddComboBox(IDC_RENDERMETHOD_LIST, 0, 0, 166, 22);
g_SampleUI2.GetComboBox(IDC_RENDERMETHOD_LIST).SetDropHeight( 12*4);
g_SampleUI2.GetComboBox(IDC_RENDERMETHOD_LIST).AddItem('Hardware Instancing', nil);
g_SampleUI2.GetComboBox(IDC_RENDERMETHOD_LIST).AddItem('Shader Instancing', nil);
g_SampleUI2.GetComboBox(IDC_RENDERMETHOD_LIST).AddItem('Constants Instancing', nil);
g_SampleUI2.GetComboBox(IDC_RENDERMETHOD_LIST).AddItem('Stream Instancing', nil);
g_SampleUI2.GetComboBox(IDC_RENDERMETHOD_LIST).SetSelectedByIndex( g_iRenderTechnique);
g_SampleUI.EnableKeyboardInput(True);
g_SampleUI.FocusDefaultControl;
end;
//--------------------------------------------------------------------------------------
// Called during device initialization, this code checks the device for some
// minimum set of capabilities, and rejects those that don't pass by returning false.
//--------------------------------------------------------------------------------------
function IsDeviceAcceptable(const pCaps: TD3DCaps9; AdapterFormat, BackBufferFormat: TD3DFormat; bWindowed: Boolean; pUserContext: Pointer): Boolean; stdcall;
var
pD3D: IDirect3D9;
begin
Result := False;
// Skip backbuffer formats that don't support alpha blending
pD3D := DXUTGetD3DObject;
if FAILED(pD3D.CheckDeviceFormat(pCaps.AdapterOrdinal, pCaps.DeviceType,
AdapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING,
D3DRTYPE_TEXTURE, BackBufferFormat))
then Exit;
// Needs PS 2.0 support
if (pCaps.PixelShaderVersion < D3DPS_VERSION(2,0)) then Exit;
// Needs to be DDI9 (support vertex buffer offset)
if ((pCaps.DevCaps2 and D3DDEVCAPS2_STREAMOFFSET) = 0) then Exit;
Result := True;
end;
//--------------------------------------------------------------------------------------
// This callback function is called immediately before a device is created to allow the
// application to modify the device settings. The supplied pDeviceSettings parameter
// contains the settings that the framework has selected for the new device, and the
// application can make any desired changes directly to this structure. Note however that
// DXUT will not correct invalid device settings so care must be taken
// to return valid device settings, otherwise IDirect3D9::CreateDevice() will fail.
//--------------------------------------------------------------------------------------
{static} var s_bFirstTime: Boolean = True;
function ModifyDeviceSettings(var pDeviceSettings: TDXUTDeviceSettings; const pCaps: TD3DCaps9; pUserContext: Pointer): Boolean; stdcall;
begin
// Turn vsync off
pDeviceSettings.pp.PresentationInterval := D3DPRESENT_INTERVAL_IMMEDIATE;
g_SettingsDlg.DialogControl.GetComboBox(DXUTSETTINGSDLG_PRESENT_INTERVAL).Enabled := False;
// If device doesn't support HW T&L or doesn't support 2.0 vertex shaders in HW
// then switch to SWVP.
if (pCaps.DevCaps and D3DDEVCAPS_HWTRANSFORMANDLIGHT = 0) or
(pCaps.VertexShaderVersion < D3DVS_VERSION(2,0))
then pDeviceSettings.BehaviorFlags := D3DCREATE_SOFTWARE_VERTEXPROCESSING;
// Debugging vertex shaders requires either REF or software vertex processing
// and debugging pixel shaders requires REF.
{$IFDEF DEBUG_VS}
if (pDeviceSettings.DeviceType <> D3DDEVTYPE_REF) then
with pDeviceSettings do
begin
BehaviorFlags := BehaviorFlags and not D3DCREATE_HARDWARE_VERTEXPROCESSING;
BehaviorFlags := BehaviorFlags and not D3DCREATE_MIXED_VERTEXPROCESSING;
BehaviorFlags := BehaviorFlags and not D3DCREATE_PUREDEVICE;
BehaviorFlags := BehaviorFlags or D3DCREATE_SOFTWARE_VERTEXPROCESSING;
end;
{$ENDIF}
{$IFDEF DEBUG_PS}
pDeviceSettings.DeviceType := D3DDEVTYPE_REF;
{$ENDIF}
if not pDeviceSettings.pp.Windowed
then pDeviceSettings.pp.SwapEffect := D3DSWAPEFFECT_FLIP;
// For the first device created if its a REF device, optionally display a warning dialog box
if s_bFirstTime then
begin
s_bFirstTime := False;
if (pDeviceSettings.DeviceType = D3DDEVTYPE_REF) then DXUTDisplaySwitchingToREFWarning;
end;
Result:= True;
end;
//--------------------------------------------------------------------------------------
// Helper routine to fill faces of a cube
//--------------------------------------------------------------------------------------
procedure FillFace(
pVertsP: PBoxVertex;
pIndicesP: PWord;
iFace: Integer;
const vCenter: TD3DXVector3;
const vNormal: TD3DXVector3;
const vUp: TD3DXVector3);
var
vRight: TD3DXVector3;
pVerts: PBoxVertexArray;
pIndices: PWordArray;
v: TD3DXVector3;
i: Integer;
begin
D3DXVec3Cross(vRight, vNormal, vUp);
pIndices:= PWordArray(pIndicesP);
pVerts:= PBoxVertexArray(pVertsP);
pIndices[ iFace * 6 + 0 ] := iFace * 4 + 0;
pIndices[ iFace * 6 + 1 ] := iFace * 4 + 1;
pIndices[ iFace * 6 + 2 ] := iFace * 4 + 2;
pIndices[ iFace * 6 + 3 ] := iFace * 4 + 3;
pIndices[ iFace * 6 + 4 ] := iFace * 4 + 2;
pIndices[ iFace * 6 + 5 ] := iFace * 4 + 1;
{ pVerts[ iFace * 4 + 0 ].pos := vCenter + vRight + vUp;
pVerts[ iFace * 4 + 1 ].pos := vCenter + vRight - vUp;
pVerts[ iFace * 4 + 2 ].pos := vCenter - vRight + vUp;
pVerts[ iFace * 4 + 3 ].pos := vCenter - vRight - vUp; }
D3DXVec3Add(v, D3DXVec3Add(v, vCenter, vRight)^, vUp);
pVerts[ iFace * 4 + 0 ].pos := v; // vCenter + vRight + vUp;
D3DXVec3Subtract(v, D3DXVec3Add(v, vCenter, vRight)^, vUp);
pVerts[ iFace * 4 + 1 ].pos := v; // vCenter + vRight - vUp;
D3DXVec3Add(v, D3DXVec3Subtract(v, vCenter, vRight)^, vUp);
pVerts[ iFace * 4 + 2 ].pos := v; // vCenter - vRight + vUp;
D3DXVec3Subtract(v, D3DXVec3Subtract(v, vCenter, vRight)^, vUp);
pVerts[ iFace * 4 + 3 ].pos := v; // vCenter - vRight - vUp;
for i := 0 to 3 do
begin
pVerts[ iFace * 4 + i ].u := ((i div 2) and 1) * 1.0;
pVerts[ iFace * 4 + i ].v := ((i) and 1) * 1.0;
pVerts[ iFace * 4 + i ].norm := vNormal;
end;
end;
//--------------------------------------------------------------------------------------
// Helper routine to fill faces of a cube + instance data
//--------------------------------------------------------------------------------------
procedure FillFaceInstance(
pVertsP: PBoxVertexInstance;
pIndicesP: PWord;
iFace: Integer;
const vCenter: TD3DXVector3;
const vNormal: TD3DXVector3;
const vUp: TD3DXVector3;
iInstanceIndex: Word);
var
vRight: TD3DXVector3;
offsetIndex: Word; // offset from the beginning of the index array
offsetVertex: Word; // offset from the beginning of the vertex array
pVerts: PBoxVertexInstanceArray;
pIndices: PWordArray;
v: TD3DXVector3;
i: Integer;
begin
D3DXVec3Cross(vRight, vNormal, vUp);
pVerts:= PBoxVertexInstanceArray(pVertsP);
pIndices:= PWordArray(pIndicesP);
offsetIndex := iInstanceIndex * 6 * 2 * 3; // offset from the beginning of the index array
offsetVertex := iInstanceIndex * 4 * 6; // offset from the beginning of the vertex array
pIndices[ offsetIndex + iFace * 6 + 0 ] := offsetVertex + iFace * 4 + 0;
pIndices[ offsetIndex + iFace * 6 + 1 ] := offsetVertex + iFace * 4 + 1;
pIndices[ offsetIndex + iFace * 6 + 2 ] := offsetVertex + iFace * 4 + 2;
pIndices[ offsetIndex + iFace * 6 + 3 ] := offsetVertex + iFace * 4 + 3;
pIndices[ offsetIndex + iFace * 6 + 4 ] := offsetVertex + iFace * 4 + 2;
pIndices[ offsetIndex + iFace * 6 + 5 ] := offsetVertex + iFace * 4 + 1;
{ pVerts[ offsetVertex + iFace * 4 + 0 ].pos := vCenter + vRight + vUp;
pVerts[ offsetVertex + iFace * 4 + 1 ].pos := vCenter + vRight - vUp;
pVerts[ offsetVertex + iFace * 4 + 2 ].pos := vCenter - vRight + vUp;
pVerts[ offsetVertex + iFace * 4 + 3 ].pos := vCenter - vRight - vUp; }
D3DXVec3Add(v, D3DXVec3Add(v, vCenter, vRight)^, vUp);
pVerts[ offsetVertex + iFace * 4 + 0 ].pos := v; // vCenter + vRight + vUp;
D3DXVec3Subtract(v, D3DXVec3Add(v, vCenter, vRight)^, vUp);
pVerts[ offsetVertex + iFace * 4 + 1 ].pos := v; // vCenter + vRight - vUp;
D3DXVec3Add(v, D3DXVec3Subtract(v, vCenter, vRight)^, vUp);
pVerts[ offsetVertex + iFace * 4 + 2 ].pos := v; // vCenter - vRight + vUp;
D3DXVec3Subtract(v, D3DXVec3Subtract(v, vCenter, vRight)^, vUp);
pVerts[ offsetVertex + iFace * 4 + 3 ].pos := v; // vCenter - vRight - vUp;
for i := 0 to 3 do
begin
pVerts[ offsetVertex + iFace * 4 + i ].boxInstance := iInstanceIndex;
pVerts[ offsetVertex + iFace * 4 + i ].u := ( ( i div 2 ) and 1 ) * 1.0;
pVerts[ offsetVertex + iFace * 4 + i ].v := ( ( i ) and 1 ) * 1.0;
pVerts[ offsetVertex + iFace * 4 + i ].norm := vNormal;
end;
end;
//--------------------------------------------------------------------------------------
// Create the vertex and index buffers, based on the selected instancing method
// called from onCreateDevice or whenever user changes parameters or rendering method
//--------------------------------------------------------------------------------------
function OnCreateBuffers(const pd3dDevice: IDirect3DDevice9): HRESULT;
var
pVertsI: PBoxVertexInstance;
pIndices: PWord;
iInstance: Word;
pVerts: PBoxVertex;
pIPos: PBoxInstanceDataPos;
nRemainingBoxes: Integer;
iY, iZ, iX: Byte;
instanceBox: TBoxInstanceDataPos;
begin
if g_iRenderTechnique in [0, 3] then
begin
g_HandleTechnique := g_pEffect.GetTechniqueByName('THW_Instancing');
// Create the vertex declaration
Result:= pd3dDevice.CreateVertexDeclaration(@g_VertexElemHardware, g_pVertexDeclHardware);
if V_Failed(Result) then Exit;
end;
if (g_iRenderTechnique = 1) then
begin
g_HandleTechnique := g_pEffect.GetTechniqueByName('TShader_Instancing');
g_HandleBoxInstance_Position := g_pEffect.GetParameterBySemantic(nil, 'BOXINSTANCEARRAY_POSITION');
g_HandleBoxInstance_Color := g_pEffect.GetParameterBySemantic(nil, 'BOXINSTANCEARRAY_COLOR');
// First create the vertex declaration we need
Result:= pd3dDevice.CreateVertexDeclaration(@g_VertexElemShader, g_pVertexDeclShader);
if V_Failed(Result) then Exit;
// Build a VB to hold the position data. Four vertices on six faces of the box
// Create g_nNumBatchInstance copies
Result:= pd3dDevice.CreateVertexBuffer(g_nNumBatchInstance * 4 * 6 * SizeOf(TBoxVertexInstance), 0, 0, D3DPOOL_MANAGED, g_pVBBox, nil);
if V_Failed(Result) then Exit;
// And an IB to go with it. We will be rendering
// a list of independent tris, and each box face has two tris, so the box will have
// 6 * 2 * 3 indices
Result:= pd3dDevice.CreateIndexBuffer(g_nNumBatchInstance * (6 * 2 * 3) * SizeOf(Word), 0, D3DFMT_INDEX16, D3DPOOL_MANAGED, g_pIBBox, nil);
if V_Failed(Result) then Exit;
// Now, lock and fill the model VB and IB
Result := g_pVBBox.Lock(0, 0, Pointer(pVertsI), 0);
if SUCCEEDED(Result) then
begin
Result := g_pIBBox.Lock(0, 0, Pointer(pIndices), 0);
if SUCCEEDED(Result) then
begin
for iInstance := 0 to g_nNumBatchInstance-1 do
begin
FillFaceInstance(pVertsI, pIndices, 0,
D3DXVector3(0.0, 0.0,-1.0),
D3DXVector3(0.0, 0.0,-1.0),
D3DXVector3(0.0, 1.0, 0.0),
iInstance);
FillFaceInstance(pVertsI, pIndices, 1,
D3DXVector3(0.0, 0.0, 1.0),
D3DXVector3(0.0, 0.0, 1.0),
D3DXVector3(0.0, 1.0, 0.0),
iInstance);
FillFaceInstance(pVertsI, pIndices,2,
D3DXVector3(1.0, 0.0, 0.0),
D3DXVector3(1.0, 0.0, 0.0),
D3DXVector3(0.0, 1.0, 0.0),
iInstance);
FillFaceInstance(pVertsI, pIndices,3,
D3DXVECTOR3(-1.0, 0.0, 0.0),
D3DXVECTOR3(-1.0, 0.0, 0.0),
D3DXVector3(0.0, 1.0, 0.0),
iInstance);
FillFaceInstance(pVertsI, pIndices,4,
D3DXVector3(0.0, 1.0, 0.0),
D3DXVector3(0.0, 1.0, 0.0),
D3DXVector3(1.0, 0.0, 0.0),
iInstance);
FillFaceInstance(pVertsI, pIndices,5,
D3DXVector3(0.0,-1.0, 0.0),
D3DXVector3(0.0,-1.0, 0.0),
D3DXVector3(1.0, 0.0, 0.0),
iInstance);
end;
g_pIBBox.Unlock;
end else
begin
DXUT_ERR('Could not lock box model IB', Result);
end;
g_pVBBox.Unlock;
end else
begin
DXUT_ERR('Could not lock box model VB', Result);
end;
end;
if (g_iRenderTechnique = 2) then
begin
g_HandleTechnique := g_pEffect.GetTechniqueByName('TConstants_Instancing');
g_HandleBoxInstance_Position := g_pEffect.GetParameterBySemantic(nil, 'BOXINSTANCE_POSITION');
g_HandleBoxInstance_Color := g_pEffect.GetParameterBySemantic(nil, 'BOXINSTANCE_COLOR');
// Create the vertex declaration
Result:= pd3dDevice.CreateVertexDeclaration(@g_VertexElemConstants, g_pVertexDeclConstants);
if V_Failed(Result) then Exit;
end;
if (g_iRenderTechnique <> 1) then
begin
// Build a VB to hold the position data. Four vertices on six faces of the box
Result:= pd3dDevice.CreateVertexBuffer(4 * 6 * SizeOf(TBoxVertex), 0, 0, D3DPOOL_MANAGED, g_pVBBox, nil);
if V_Failed(Result) then Exit;
// And an IB to go with it. We will be rendering
// a list of independent tris, and each box face has two tris, so the box will have
// 6 * 2 * 3 indices
Result:= pd3dDevice.CreateIndexBuffer((6 * 2 * 3) * SizeOf(Word), 0, D3DFMT_INDEX16, D3DPOOL_MANAGED, g_pIBBox, nil);
if V_Failed(Result) then Exit;
// Now, lock and fill the model VB and IB:
Result := g_pVBBox.Lock(0, 0, Pointer(pVerts), 0);
if SUCCEEDED(Result) then
begin
Result := g_pIBBox.Lock(0, 0, Pointer(pIndices), 0);
if SUCCEEDED(Result) then
begin
FillFace(pVerts, pIndices, 0,
D3DXVector3(0.0, 0.0,-1.0),
D3DXVector3(0.0, 0.0,-1.0),
D3DXVector3(0.0, 1.0, 0.0));
FillFace(pVerts, pIndices, 1,
D3DXVector3(0.0, 0.0, 1.0),
D3DXVector3(0.0, 0.0, 1.0),
D3DXVector3(0.0, 1.0, 0.0));
FillFace(pVerts, pIndices,2,
D3DXVector3(1.0, 0.0, 0.0),
D3DXVector3(1.0, 0.0, 0.0),
D3DXVector3(0.0, 1.0, 0.0));
FillFace(pVerts, pIndices,3,
D3DXVECTOR3(-1.0, 0.0, 0.0),
D3DXVECTOR3(-1.0, 0.0, 0.0),
D3DXVector3(0.0, 1.0, 0.0));
FillFace(pVerts, pIndices,4,
D3DXVector3(0.0, 1.0, 0.0),
D3DXVector3(0.0, 1.0, 0.0),
D3DXVector3(1.0, 0.0, 0.0));
FillFace(pVerts, pIndices,5,
D3DXVector3(0.0,-1.0, 0.0),
D3DXVector3(0.0,-1.0, 0.0),
D3DXVector3(1.0, 0.0, 0.0));
g_pIBBox.Unlock;
end else
begin
DXUT_ERR('Could not lock box model IB', Result);
end;
g_pVBBox.Unlock;
end else
begin
DXUT_ERR('Could not lock box model VB', Result);
end;
end;
if g_iRenderTechnique in [0, 3] then
begin
// Create a VB for the instancing data
Result:= pd3dDevice.CreateVertexBuffer(g_NumBoxes * SizeOf(TBoxInstanceDataPos), 0, 0, D3DPOOL_MANAGED, g_pVBInstanceData, nil);
if V_Failed(Result) then Exit;
// Lock and fill the instancing buffer
Result := g_pVBInstanceData.Lock(0, 0, Pointer(pIPos), 0);
if SUCCEEDED(Result) then
begin
nRemainingBoxes := g_NumBoxes;
for iY := 0 to 9 do
for iZ := 0 to 9 do
for iX := 0 to 9 do // && nRemainingBoxes > 0; iX++, nRemainingBoxes-- )
if nRemainingBoxes > 0 then
begin
// Scaled so 1 box is "32" wide, the intra-pos range is 8 box widths.
// The positins are scaled and biased.
// The rotations are not
instanceBox.color := D3DCOLOR_ARGB($ff,
$7f + $40 * ((g_NumBoxes - nRemainingBoxes + iX) mod 3),
$7f + $40 * ((g_NumBoxes - nRemainingBoxes+iZ+1) mod 3),
$7f + $40 * ((g_NumBoxes - nRemainingBoxes+iY+2) mod 3));
instanceBox.x := iZ * 24;
instanceBox.z := iX * 24;
instanceBox.y := iY * 24;
instanceBox.rotation := (Word(iX) + iZ + iY) * 24 div 3;
pIPos^ := instanceBox; Inc(pIPos);
Dec(nRemainingBoxes);
end;
g_pVBInstanceData.Unlock;
end else
begin
DXUT_ERR('Could not lock box intra-pile-position VB', Result);
end;
end;
if g_iRenderTechnique in [1, 2] then
begin
// Fill the instancing constants buffer
nRemainingBoxes := g_NumBoxes;
for iY := 0 to 9 do
for iZ := 0 to 9 do
for iX := 0 to 9 do // nRemainingBoxes > 0; iX++, nRemainingBoxes-- )
if nRemainingBoxes > 0 then
begin
// Scaled so 1 box is "32" wide, the intra-pos range is 8 box widths.
// The positins are scaled and biased.
// The rotations are not
g_vBoxInstance_Color[g_NumBoxes - nRemainingBoxes] := D3DXColorFromDWord(
D3DCOLOR_ARGB($ff,
$7f + $40 * ((g_NumBoxes - nRemainingBoxes + iX) mod 3),
$7f + $40 * ((g_NumBoxes - nRemainingBoxes+iZ+1) mod 3),
$7f + $40 * ((g_NumBoxes - nRemainingBoxes+iY+2) mod 3)));
g_vBoxInstance_Position[g_NumBoxes - nRemainingBoxes].x := iX * 24 / 255.0;
g_vBoxInstance_Position[g_NumBoxes - nRemainingBoxes].z := iZ * 24 / 255.0;
g_vBoxInstance_Position[g_NumBoxes - nRemainingBoxes].y := iY * 24 / 255.0;
g_vBoxInstance_Position[g_NumBoxes - nRemainingBoxes].w := (Word(iX) + iZ + iY) * 8 / 255.0;
Dec(nRemainingBoxes);
end;
end;
Result:= S_OK;
end;
//--------------------------------------------------------------------------------------
// Release the vertex and index buffers, based on the selected instancing method
// called from onDestroyDevice or whenever user changes parameters or rendering method
//--------------------------------------------------------------------------------------
procedure OnDestroyBuffers;
begin
SAFE_RELEASE(g_pVBBox);
SAFE_RELEASE(g_pIBBox);
SAFE_RELEASE(g_pVBInstanceData);
SAFE_RELEASE(g_pVertexDeclHardware);
SAFE_RELEASE(g_pVertexDeclShader);
SAFE_RELEASE(g_pVertexDeclConstants);
end;
//--------------------------------------------------------------------------------------
// This callback function will be called immediately after the Direct3D device has been
// created, which will happen during application initialization and windowed/full screen
// toggles. This is the best location to create D3DPOOL_MANAGED resources since these
// resources need to be reloaded whenever the device is destroyed. Resources created
// here should be released in the OnDestroyDevice callback.
//--------------------------------------------------------------------------------------
function OnCreateDevice(const pd3dDevice: IDirect3DDevice9; const pBackBufferSurfaceDesc: TD3DSurfaceDesc; pUserContext: Pointer): HRESULT; stdcall;
var
dwShaderFlags: DWORD;
str: array [0..MAX_PATH-1] of WideChar;
vecEye, vecAt: TD3DXVector3;
begin
Result:= g_DialogResourceManager.OnCreateDevice(pd3dDevice);
if V_Failed(Result) then Exit;
Result:= g_SettingsDlg.OnCreateDevice(pd3dDevice);
if V_Failed(Result) then Exit;
// Initialize the font
Result := D3DXCreateFont(pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH or FF_DONTCARE,
'Arial', g_pFont);
if V_Failed(Result) then Exit;
// Define DEBUG_VS and/or DEBUG_PS to debug vertex and/or pixel shaders with the
// shader debugger. Debugging vertex shaders requires either REF or software vertex
// processing, and debugging pixel shaders requires REF. The
// D3DXSHADER_FORCE_*_SOFTWARE_NOOPT flag improves the debug experience in the
// shader debugger. It enables source level debugging, prevents instruction
// reordering, prevents dead code elimination, and forces the compiler to compile
// against the next higher available software target, which ensures that the
// unoptimized shaders do not exceed the shader model limitations. Setting these
// flags will cause slower rendering since the shaders will be unoptimized and
// forced into software. See the DirectX documentation for more information about
// using the shader debugger.
dwShaderFlags := D3DXFX_NOT_CLONEABLE;
{$IFDEF DEBUG}
// Set the D3DXSHADER_DEBUG flag to embed debug information in the shaders.
// Setting this flag improves the shader debugging experience, but still allows
// the shaders to be optimized and to run exactly the way they will run in
// the release configuration of this program.
dwShaderFlags := dwShaderFlags or D3DXSHADER_DEBUG;
{$ENDIF}
{$IFDEF DEBUG_VS}
dwShaderFlags := dwShaderFlags or D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
{$ENDIF}
{$IFDEF DEBUG_PS}
dwShaderFlags := dwShaderFlags or D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
{$ENDIF}
// Read the D3DX effect file
Result:= DXUTFindDXSDKMediaFile(str, MAX_PATH, 'Instancing.fx');
if V_Failed(Result) then Exit;
// If this fails, there should be debug output as to
// why the .fx file failed to compile
Result:= D3DXCreateEffectFromFileW(pd3dDevice, str, nil, nil, dwShaderFlags,
nil, g_pEffect, nil);
if V_Failed(Result) then Exit;
g_HandleWorld := g_pEffect.GetParameterBySemantic(nil, 'WORLD');
g_HandleView := g_pEffect.GetParameterBySemantic(nil, 'VIEW');
g_HandleProjection := g_pEffect.GetParameterBySemantic(nil, 'PROJECTION');
g_HandleTexture := g_pEffect.GetParameterBySemantic(nil, 'TEXTURE');
// Setup the camera's view parameters
vecEye := D3DXVector3(-24.0, 36.0, -36.0);
vecAt := D3DXVector3(0.0, 0.0, 0.0);
g_Camera.SetViewParams(vecEye, vecAt);
// create vertex, index buffers and vertex declaration
Result:= OnCreateBuffers(pd3dDevice);
if V_Failed(Result) then Exit;
// Load the environment texture
Result := DXUTFindDXSDKMediaFile(str, MAX_PATH, 'Misc\env2.bmp');
if FAILED(Result) then
begin
Result:= DXTRACE_ERR('DXUTFindDXSDKMediaFile', Result);
Exit;
end;
Result := D3DXCreateTextureFromFileW(pd3dDevice, str, g_pBoxTexture);
if FAILED(Result) then
begin
Result:= DXTRACE_ERR('D3DXCreateTextureFromFile', Result);
Exit;
end;
Result:= S_OK;
end;
//--------------------------------------------------------------------------------------
// This callback function will be called immediately after the Direct3D device has been
// reset, which will happen after a lost device scenario. This is the best location to
// create D3DPOOL_DEFAULT resources since these resources need to be reloaded whenever
// the device is lost. Resources created here should be released in the OnLostDevice
// callback.
//--------------------------------------------------------------------------------------
function OnResetDevice(const pd3dDevice: IDirect3DDevice9; const pBackBufferSurfaceDesc: TD3DSurfaceDesc; pUserContext: Pointer): HRESULT; stdcall;
var
fAspectRatio: Single;
begin
Result:= g_DialogResourceManager.OnResetDevice;
if V_Failed(Result) then Exit;
Result:= g_SettingsDlg.OnResetDevice;
if V_Failed(Result) then Exit;
if Assigned(g_pFont) then
begin
Result:= g_pFont.OnResetDevice;
if V_Failed(Result) then Exit;
end;
if Assigned(g_pEffect) then
begin
Result:= g_pEffect.OnResetDevice;
if V_Failed(Result) then Exit;
end;
// Create a sprite to help batch calls when drawing many lines of text
Result:= D3DXCreateSprite(pd3dDevice, g_pTextSprite);
if V_Failed(Result) then Exit;
// Setup the camera's projection parameters
fAspectRatio := pBackBufferSurfaceDesc.Width / pBackBufferSurfaceDesc.Height;
g_Camera.SetProjParams(D3DX_PI / 3, fAspectRatio, 0.1, 1000.0);
g_Camera.SetWindow(pBackBufferSurfaceDesc.Width, pBackBufferSurfaceDesc.Height);
// Set the camera speed
g_Camera.SetScalers(0.01, 10.0);
// Constrain the camera to movement within the horizontal plane
g_Camera.SetEnableYAxisMovement(False);
g_Camera.SetEnablePositionMovement(True);
g_HUD.SetLocation(pBackBufferSurfaceDesc.Width-170, 0);
g_HUD.SetSize(170, 170);
g_SampleUI.SetLocation(pBackBufferSurfaceDesc.Width-170, pBackBufferSurfaceDesc.Height-400);
g_SampleUI.SetSize(170, 400);
g_SampleUI2.SetLocation(0, 100);
g_SampleUI2.SetSize(200, 100);
g_fLastTime := DXUTGetGlobalTimer.GetTime;
Result:= S_OK;
end;
//--------------------------------------------------------------------------------------
// This callback function will be called once at the beginning of every frame. This is the
// best location for your application to handle updates to the scene, but is not
// intended to contain actual rendering calls, which should instead be placed in the
// OnFrameRender callback.
//--------------------------------------------------------------------------------------
procedure OnFrameMove(const pd3dDevice: IDirect3DDevice9; fTime: Double; fElapsedTime: Single; pUserContext: Pointer); stdcall;
var
szTmp, szMessage: WideString;
fStartTime: Double;
fCurTime: Double;
fStopTime: Double;
fTmp: Double;
fCPUUsage: Double;
begin
// Burn CPU time
fStartTime := DXUTGetGlobalTimer.GetTime;
fCurTime := fStartTime;
fStopTime := g_fLastTime + g_fBurnAmount;
while (fCurTime < fStopTime) do
begin
fCurTime := DXUTGetGlobalTimer.GetTime;
fTmp := fStartTime / g_fLastTime * 100.0;
szTmp:= WideFormat('Test %d', [Trunc(fTmp + 0.5)]);
end;
if (fCurTime - g_fLastTime > 0.00001)
then fCPUUsage := (fCurTime - fStartTime) / (fCurTime - g_fLastTime) * 100.0
else fCPUUsage := 3.402823466e+38{FLT_MAX};
g_fLastTime := DXUTGetGlobalTimer.GetTime;
szMessage := WideFormat('Remaining for logic: %d%%', [Trunc(fCPUUsage + 0.5)]);
// don't update the message every single time
if (0 = g_iUpdateCPUUsageMessage)
then g_SampleUI.GetStatic(IDC_CPUUSAGE_STATIC).Text := PWideChar(szMessage);
g_iUpdateCPUUsageMessage := (g_iUpdateCPUUsageMessage + 1) mod 100;
// Update the camera's position based on user input
g_Camera.FrameMove(fElapsedTime);
end;
//--------------------------------------------------------------------------------------
// This callback function is called by OnFrameRender
// It performs HW instancing
//--------------------------------------------------------------------------------------
procedure OnRenderHWInstancing(const pd3dDevice: IDirect3DDevice9; fTime: Double; fElapsedTime: Single);
var
iPass: Integer;
cPasses: LongWord;
begin
V(pd3dDevice.SetVertexDeclaration(g_pVertexDeclHardware));
// Stream zero is our model, and its frequency is how we communicate the number of instances required,
// which in this case is the total number of boxes
V(pd3dDevice.SetStreamSource(0, g_pVBBox, 0, SizeOf(TBoxVertex)));
V(pd3dDevice.SetStreamSourceFreq(0, D3DSTREAMSOURCE_INDEXEDDATA or Cardinal(g_NumBoxes)));
// Stream one is the instancing buffer, so this advances to the next value
// after each box instance has been drawn, so the divider is 1.
V(pd3dDevice.SetStreamSource(1, g_pVBInstanceData, 0, SizeOf(TBoxInstanceDataPos)));
V(pd3dDevice.SetStreamSourceFreq(1, D3DSTREAMSOURCE_INSTANCEDATA or 1));
V(pd3dDevice.SetIndices(g_pIBBox));
// Render the scene with this technique
// as defined in the .fx file
V(g_pEffect.SetTechnique(g_HandleTechnique));
V(g_pEffect._Begin(@cPasses, 0));
for iPass := 0 to cPasses - 1 do
begin
V(g_pEffect.BeginPass(iPass));
// Render the boxes with the applied technique
V(g_pEffect.SetTexture(g_HandleTexture, g_pBoxTexture));
// The effect interface queues up the changes and performs them
// with the CommitChanges call. You do not need to call CommitChanges if
// you are not setting any parameters between the BeginPass and EndPass.
V(g_pEffect.CommitChanges);
V(pd3dDevice.DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4 * 6, 0, 6 * 2));
V(g_pEffect.EndPass);
end;
V(g_pEffect._End);
V(pd3dDevice.SetStreamSourceFreq(0, 1));
V(pd3dDevice.SetStreamSourceFreq(1, 1));
end;
//--------------------------------------------------------------------------------------
// This callback function is called by OnFrameRender
// It performs Shader instancing
//--------------------------------------------------------------------------------------
procedure OnRenderShaderInstancing(const pd3dDevice: IDirect3DDevice9; fTime: Double; fElapsedTime: Single);
var
nRenderBoxes: Integer;
iPass: Integer;
cPasses: LongWord;
nRemainingBoxes: Integer;
begin
V(pd3dDevice.SetVertexDeclaration(g_pVertexDeclShader));
// Stream zero is our model
V(pd3dDevice.SetStreamSource(0, g_pVBBox, 0, SizeOf(TBoxVertexInstance)));
V(pd3dDevice.SetIndices(g_pIBBox));
// Render the scene with this technique
// as defined in the .fx file
V(g_pEffect.SetTechnique(g_HandleTechnique));
V(g_pEffect._Begin(@cPasses, 0));
for iPass := 0 to cPasses - 1 do
begin
V(g_pEffect.BeginPass(iPass));
// Render the boxes with the applied technique
V(g_pEffect.SetTexture(g_HandleTexture, g_pBoxTexture ));
nRemainingBoxes := g_NumBoxes;
while (nRemainingBoxes > 0) do
begin
// determine how many instances are in this batch (up to g_nNumBatchInstance)
nRenderBoxes := Min(nRemainingBoxes, g_nNumBatchInstance);
// set the box instancing array
V(g_pEffect.SetVectorArray(g_HandleBoxInstance_Position, @g_vBoxInstance_Position[g_NumBoxes - nRemainingBoxes], nRenderBoxes));
V(g_pEffect.SetVectorArray(g_HandleBoxInstance_Color, PD3DXVector4(@g_vBoxInstance_Color[g_NumBoxes - nRemainingBoxes]), nRenderBoxes));
// The effect interface queues up the changes and performs them
// with the CommitChanges call. You do not need to call CommitChanges if
// you are not setting any parameters between the BeginPass and EndPass.
V(g_pEffect.CommitChanges);
V(pd3dDevice.DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, nRenderBoxes * 4 * 6, 0, nRenderBoxes * 6 * 2));
// subtract the rendered boxes from the remaining boxes
Dec(nRemainingBoxes, nRenderBoxes);
end;
V(g_pEffect.EndPass);
end;
V(g_pEffect._End);
end;
//--------------------------------------------------------------------------------------
// This callback function is called by OnFrameRender
// It performs Constants instancing
//--------------------------------------------------------------------------------------
procedure OnRenderConstantsInstancing(const pd3dDevice: IDirect3DDevice9; fTime: Double; fElapsedTime: Single);
var
iPass: Integer;
cPasses: LongWord;
nRemainingBoxes: Integer;
begin
V(pd3dDevice.SetVertexDeclaration( g_pVertexDeclConstants));
// Stream zero is our model
V(pd3dDevice.SetStreamSource(0, g_pVBBox, 0, SizeOf(TBoxVertex)));
V(pd3dDevice.SetIndices(g_pIBBox));
// Render the scene with this technique
// as defined in the .fx file
V(g_pEffect.SetTechnique(g_HandleTechnique));
V(g_pEffect._Begin(@cPasses, 0));
for iPass := 0 to cPasses - 1 do
begin
V(g_pEffect.BeginPass(iPass));
// Render the boxes with the applied technique
V(g_pEffect.SetTexture(g_HandleTexture, g_pBoxTexture));
for nRemainingBoxes := 0 to g_NumBoxes - 1 do
begin
// set the box instancing array
V(g_pEffect.SetVector(g_HandleBoxInstance_Position, g_vBoxInstance_Position[nRemainingBoxes]));
V(g_pEffect.SetVector(g_HandleBoxInstance_Color, PD3DXVector4(@g_vBoxInstance_Color[nRemainingBoxes])^));
// The effect interface queues up the changes and performs them
// with the CommitChanges call. You do not need to call CommitChanges if
// you are not setting any parameters between the BeginPass and EndPass.
V(g_pEffect.CommitChanges);
V(pd3dDevice.DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4 * 6, 0, 6 * 2));
end;
V(g_pEffect.EndPass);
end;
V(g_pEffect._End);
end;
//--------------------------------------------------------------------------------------
// This callback function is called by OnFrameRender
// It performs Stream instancing
//--------------------------------------------------------------------------------------
procedure OnRenderStreamInstancing(const pd3dDevice: IDirect3DDevice9; fTime: Double; fElapsedTime: Single);
var
iPass: Integer;
cPasses: LongWord;
nRemainingBoxes: Integer;
begin
V(pd3dDevice.SetVertexDeclaration(g_pVertexDeclHardware));
// Stream zero is our model
V(pd3dDevice.SetStreamSource(0, g_pVBBox, 0, SizeOf(TBoxVertex)));
V(pd3dDevice.SetIndices(g_pIBBox));
// Render the scene with this technique
// as defined in the .fx file
V(g_pEffect.SetTechnique(g_HandleTechnique));
V(g_pEffect._Begin(@cPasses, 0));
for iPass := 0 to cPasses - 1 do
begin
V(g_pEffect.BeginPass(iPass));
// Render the boxes with the applied technique
V(g_pEffect.SetTexture(g_HandleTexture, g_pBoxTexture));
// The effect interface queues up the changes and performs them
// with the CommitChanges call. You do not need to call CommitChanges if
// you are not setting any parameters between the BeginPass and EndPass.
V(g_pEffect.CommitChanges);
for nRemainingBoxes := 0 to g_NumBoxes - 1 do
begin
// Stream one is the instancing buffer
V(pd3dDevice.SetStreamSource(1, g_pVBInstanceData, nRemainingBoxes * SizeOf(TBoxInstanceDataPos), 0));
V(pd3dDevice.DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4 * 6, 0, 6 * 2));
end;
V(g_pEffect.EndPass);
end;
V(g_pEffect._End);
end;
//--------------------------------------------------------------------------------------
// This callback function will be called at the end of every frame to perform all the
// rendering calls for the scene, and it will also be called if the window needs to be
// repainted. After this function has returned, DXUT will call
// IDirect3DDevice9::Present to display the contents of the next buffer in the swap chain
//--------------------------------------------------------------------------------------
procedure OnFrameRender(const pd3dDevice: IDirect3DDevice9; fTime: Double; fElapsedTime: Single; pUserContext: Pointer); stdcall;
var
mWorld: TD3DXMatrixA16;
mView: TD3DXMatrixA16;
mProj: TD3DXMatrixA16;
begin
// If the settings dialog is being shown, then
// render it instead of rendering the app's scene
if g_SettingsDlg.Active then
begin
g_SettingsDlg.OnRender(fElapsedTime);
Exit;
end;
// Clear the render target and the zbuffer
V(pd3dDevice.Clear(0, nil, D3DCLEAR_TARGET or D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0, 45, 50, 170), 1.0, 0));
// Render the scene
if SUCCEEDED(pd3dDevice.BeginScene) then
begin
// Get the projection & view matrix from the camera class
mWorld := g_Camera.GetWorldMatrix^;
mProj := g_Camera.GetProjMatrix^;
mView := g_Camera.GetViewMatrix^;
// Update the effect's variables
V(g_pEffect.SetMatrix(g_HandleWorld, mWorld));
V(g_pEffect.SetMatrix(g_HandleView, mView));
V(g_pEffect.SetMatrix(g_HandleProjection, mProj));
case g_iRenderTechnique of
0: if DXUTGetDeviceCaps.VertexShaderVersion >= D3DVS_VERSION(3,0)
then OnRenderHWInstancing(pd3dDevice, fTime, fElapsedTime);
1: OnRenderShaderInstancing(pd3dDevice, fTime, fElapsedTime);
2: OnRenderConstantsInstancing(pd3dDevice, fTime, fElapsedTime);
3: OnRenderStreamInstancing(pd3dDevice, fTime, fElapsedTime);
end;
if (g_nShowUI > 0) then RenderText;
if (g_nShowUI > 1) then
begin
V(g_HUD.OnRender(fElapsedTime));
V(g_SampleUI.OnRender(fElapsedTime));
V(g_SampleUI2.OnRender(fElapsedTime));
end;
V(pd3dDevice.EndScene);
end;
end;
//--------------------------------------------------------------------------------------
// Render the help and statistics text. This function uses the ID3DXFont interface for
// efficient text rendering.
//--------------------------------------------------------------------------------------
procedure RenderText;
var
txtHelper: CDXUTTextHelper;
begin
// The helper object simply helps keep track of text position, and color
// and then it calls pFont->DrawText( m_pSprite, strMsg, -1, &rc, DT_NOCLIP, m_clr );
// If NULL is passed in as the sprite object, then it will work however the
// pFont->DrawText() will not be batched together. Batching calls will improves performance.
txtHelper := CDXUTTextHelper.Create(g_pFont, g_pTextSprite, 15);
// Output statistics
txtHelper._Begin;
txtHelper.SetInsertionPos(5, 5);
txtHelper.SetForegroundColor(D3DXColor(1.0, 1.0, 0.0, 1.0));
txtHelper.DrawTextLine(DXUTGetFrameStats(True)); // Show FPS
txtHelper.DrawTextLine(DXUTGetDeviceStats);
if (g_nShowUI < 2) then txtHelper.DrawTextLine('Press ''U'' to toggle UI');
txtHelper.SetForegroundColor(D3DXColor(1.0, 1.0, 1.0, 1.0));
if g_bRuntimeDebug then txtHelper.DrawTextLine('WARNING (perf): DEBUG D3D runtime detected!');
if g_bAppIsDebug then txtHelper.DrawTextLine('WARNING (perf): DEBUG application build detected!');
if (g_iRenderTechnique = 0) and (DXUTGetDeviceCaps.VertexShaderVersion < D3DVS_VERSION(3,0)) then
begin
txtHelper.SetForegroundColor(D3DXColor(1.0, 0.0, 0.0, 1.0));
txtHelper.DrawTextLine('ERROR: Hardware instancing is not supported on non vs_3_0 HW');
end;
txtHelper._End;
txtHelper.Free;
end;
//--------------------------------------------------------------------------------------
// Before handling window messages, DXUT passes incoming windows
// messages to the application through this callback function. If the application sets
// *pbNoFurtherProcessing to TRUE, then DXUT will not process this message.
//--------------------------------------------------------------------------------------
function MsgProc(hWnd: HWND; uMsg: LongWord; wParam: WPARAM; lParam: LPARAM; out pbNoFurtherProcessing: Boolean; pUserContext: Pointer): LRESULT; stdcall;
begin
Result:= 0;
// Always allow dialog resource manager calls to handle global messages
// so GUI state is updated correctly
pbNoFurtherProcessing := g_DialogResourceManager.MsgProc(hWnd, uMsg, wParam, lParam);
if pbNoFurtherProcessing then Exit;
if g_SettingsDlg.IsActive then
begin
g_SettingsDlg.MsgProc(hWnd, uMsg, wParam, lParam);
Exit;
end;
if (g_nShowUI > 1) then
begin
// Give the dialogs a chance to handle the message first
pbNoFurtherProcessing := g_SampleUI.MsgProc(hWnd, uMsg, wParam, lParam);
if pbNoFurtherProcessing then Exit;
pbNoFurtherProcessing := g_HUD.MsgProc(hWnd, uMsg, wParam, lParam);
if pbNoFurtherProcessing then Exit;
pbNoFurtherProcessing := g_SampleUI2.MsgProc(hWnd, uMsg, wParam, lParam);
if pbNoFurtherProcessing then Exit;
end;
// Pass all remaining windows messages to camera so it can respond to user input
g_Camera.HandleMessages(hWnd, uMsg, wParam, lParam);
end;
//--------------------------------------------------------------------------------------
// As a convenience, DXUT inspects the incoming windows messages for
// keystroke messages and decodes the message parameters to pass relevant keyboard
// messages to the application. The framework does not remove the underlying keystroke
// messages, which are still passed to the application's MsgProc callback.
//--------------------------------------------------------------------------------------
procedure KeyboardProc(nChar: LongWord; bKeyDown, bAltDown: Boolean; pUserContext: Pointer); stdcall;
begin
if bKeyDown then
begin
case nChar of
VK_F1: g_bShowHelp := not g_bShowHelp;
Ord('U'):
begin
Dec(g_nShowUI);
if (g_nShowUI < 0) then g_nShowUI := 2;
end;
end;
end;
end;
//--------------------------------------------------------------------------------------
// Handles the GUI events
//--------------------------------------------------------------------------------------
procedure OnGUIEvent(nEvent: LongWord; nControlID: Integer; pControl: CDXUTControl; pUserContext: Pointer); stdcall;
var
szMessage: WideString;
pCBItem: PDXUTComboBoxItem;
begin
case nControlID of
IDC_TOGGLEFULLSCREEN: DXUTToggleFullScreen;
IDC_TOGGLEREF: DXUTToggleREF;
IDC_CHANGEDEVICE: with g_SettingsDlg do Active := not Active;
IDC_TOGGLEUI: KeyboardProc(Ord('U'), True, False, nil);
IDC_NUMBERBOXES_SLIDER:
begin
g_NumBoxes := g_SampleUI.GetSlider(IDC_NUMBERBOXES_SLIDER).Value;
szMessage:= WideFormat('# Boxes: %d', [g_NumBoxes]);
g_SampleUI.GetStatic(IDC_NUMBERBOXES_STATIC).Text := PWideChar(szMessage);
OnDestroyBuffers;
OnCreateBuffers(DXUTGetD3DDevice);
end;
IDC_BIND_CPU_SLIDER:
begin
g_fBurnAmount := 0.0001 * g_SampleUI.GetSlider(IDC_BIND_CPU_SLIDER).Value;
// szMessage := WideFormat('Goal: %0.1fms/frame', [g_fBurnAmount * 1000.0]); // Delphi WideFormat bug
szMessage := Format('Goal: %0.1fms/frame', [g_fBurnAmount * 1000.0]);
g_SampleUI.GetStatic(IDC_BIND_CPU_STATIC).Text := PWideChar(szMessage);
end;
IDC_RENDERMETHOD_LIST:
begin
pCBItem := g_SampleUI2.GetComboBox(IDC_RENDERMETHOD_LIST).GetSelectedItem;
if pCBItem.strText = 'Hardware Instancing' then g_iRenderTechnique := 0 else
if pCBItem.strText = 'Shader Instancing' then g_iRenderTechnique := 1 else
if pCBItem.strText = 'Constants Instancing' then g_iRenderTechnique := 2 else
if pCBItem.strText = 'Stream Instancing' then g_iRenderTechnique := 3
else g_iRenderTechnique := Word(-1);
// Note hardware instancing is not supported on non vs_3_0 HW
// This sample allows it to be set, but displays an error to the user
// recreate the buffers
OnDestroyBuffers;
OnCreateBuffers(DXUTGetD3DDevice);
end;
end;
end;
//--------------------------------------------------------------------------------------
// This callback function will be called immediately after the Direct3D device has
// entered a lost state and before IDirect3DDevice9::Reset is called. Resources created
// in the OnResetDevice callback should be released here, which generally includes all
// D3DPOOL_DEFAULT resources. See the "Lost Devices" section of the documentation for
// information about lost devices.
//--------------------------------------------------------------------------------------
procedure OnLostDevice; stdcall;
begin
g_DialogResourceManager.OnLostDevice;
g_SettingsDlg.OnLostDevice;
if Assigned(g_pFont) then g_pFont.OnLostDevice;
if Assigned(g_pEffect) then g_pEffect.OnLostDevice;
SAFE_RELEASE(g_pTextSprite);
end;
//--------------------------------------------------------------------------------------
// This callback function will be called immediately after the Direct3D device has
// been destroyed, which generally happens as a result of application termination or
// windowed/full screen toggles. Resources created in the OnCreateDevice callback
// should be released here, which generally includes all D3DPOOL_MANAGED resources.
//--------------------------------------------------------------------------------------
procedure OnDestroyDevice; stdcall;
begin
g_DialogResourceManager.OnDestroyDevice;
g_SettingsDlg.OnDestroyDevice;
SAFE_RELEASE(g_pEffect);
SAFE_RELEASE(g_pFont);
SAFE_RELEASE(g_pTextSprite);
SAFE_RELEASE(g_pBoxTexture);
// destroy vertex/index buffers, vertex declaration
OnDestroyBuffers;
end;
procedure CreateCustomDXUTobjects;
begin
g_DialogResourceManager:= CDXUTDialogResourceManager.Create; // manager for shared resources of dialogs
g_SettingsDlg:= CD3DSettingsDlg.Create; // Device settings dialog
g_Camera:= CModelViewerCamera.Create; // A model viewing camera
g_HUD:= CDXUTDialog.Create; // dialog for standard controls
g_SampleUI:= CDXUTDialog.Create; // dialog for sample specific controls
g_SampleUI2:= CDXUTDialog.Create; // dialog for sample specific controls
end;
procedure DestroyCustomDXUTobjects;
begin
FreeAndNil(g_DialogResourceManager);
FreeAndNil(g_SettingsDlg);
FreeAndNil(g_Camera);
FreeAndNil(g_HUD);
FreeAndNil(g_SampleUI);
FreeAndNil(g_SampleUI2);
end;
end.
|
unit SubtitlesAnalyzer;
interface
uses Windows, SysUtils, Classes, Graphics, Subtitles, IntegerList, Dictionaries;
type
TSubtitlesAnalyzer = class
private
FSubtitles: TSrtSubtitles;
FFreqDict: TWordDictionary;
FData: TIntegerList;
FSubsWordCount: Integer;
public
constructor Create(subs: TSrtSubtitles;
freqDict: TWordDictionary);
procedure Analyze;
function GetWordCount: Integer;
function GetExpectedValue: Integer;
function GetVariance: Integer;
function GetHysto(const height, width: Integer;
skipfirst: Integer): TBitmap;
end;
implementation
uses Misc;
{ TSubtitlesAnalyzer }
procedure TSubtitlesAnalyzer.Analyze;
var
i, j, k: Integer;
s: String;
ss: TStringList;
rating: TWordDictionary;
begin
//clear previous data
FData.Clear;
FSubsWordCount := 0;
//create temporary string list
ss := TStringList.Create;
//create subs dictionary
rating := TWordDictionary.Create;
try
//update data count
//last one (+1) is for unknown words
FData.Count := FFreqDict.Count + 1;
//enum entries
for i := 0 to FSubtitles.Count - 1 do
begin
//get text and explode it to words
s := FSubtitles[i].Text;
ss.Clear;
ExplodeToWordsOnlyLetters(s, ss);
//enum words
for j := 0 to ss.Count - 1 do
begin
//if exists - increment key by 1
//otherwise create new with key 1
//key is actually a word count
rating.UpdateKeyOrCreate(ss[j], 1);
end;
end;
//clear temporary list
ss.Clear;
//get string list for collected data
rating.GetStringList(ss);
//enum entries
for i := 0 to ss.Count - 1 do
begin
//find word in frequency dictionary
k := FFreqDict.Find(ss[i]);
//if not found
//add data to last column (all uknown words)
if k < 0 then
k := FFreqDict.Count;
//collect data
//add words count to data column k
FData[k] := FData[k] + Integer(ss.Objects[i]);
//increment total words count
Inc(FSubsWordCount, Integer(ss.Objects[i]));
end;
FData.CollectInfo(FSubsWordCount);
finally
rating.Free;
ss.Free;
end;
end;
constructor TSubtitlesAnalyzer.Create(subs: TSrtSubtitles;
freqDict: TWordDictionary);
begin
FSubtitles := subs;
FFreqDict := freqDict;
FSubsWordCount := -1;
FData := TIntegerList.Create;
end;
function TSubtitlesAnalyzer.GetExpectedValue: Integer;
begin
Result := FData.ExpectedValue;
end;
function TSubtitlesAnalyzer.GetHysto(const height,
width: Integer; skipfirst: Integer): TBitmap;
function limitToByte(a: Integer): Integer;
begin
if (a < 0) then
Result := 0
else if (a > 255) then
Result := 255
else Result := a;
end;
var
bm: TBitmap;
modh: Integer;
modw: Integer;
i, j, k: Integer;
data: TIntegerList;
divisor: Integer;
begin
Result := nil;
bm := TBitmap.Create;
data := TIntegerList.Create;
try
bm.Width := width;
bm.Height := height;
bm.Canvas.Brush.Color := $222222;
bm.Canvas.FillRect(Rect(0,0,width, height));
modw := (FData.Count - skipfirst) div width;
data.Count := width + 1;
j := 0;
k := 0;
for i := skipfirst to FData.Count - 1 do
begin
data[j] := data[j] + FData[i];
Inc(k);
if k > modw then
begin
Inc(j);
k := 0;
end;
end;
//data.CollectInfo;
modh := data.TheBiggest div height;
if modh = 0 then
modh := 1;
divisor := data.Count div 10;
for i := 0 to data.Count - 1 do
begin
bm.Canvas.Pen.Color := RGB(limitToByte((i * 255) div divisor),
limitToByte(255 - (255*i) div divisor), 100);
bm.Canvas.MoveTo(i, height);
bm.Canvas.LineTo(i, height - data[i] div modh);
end;
Result := bm;
except
Result := nil;
bm.Free;
data.Free;
end;
end;
function TSubtitlesAnalyzer.GetVariance: Integer;
begin
Result := FData.Variance;
end;
function TSubtitlesAnalyzer.GetWordCount: Integer;
begin
Result := FSubsWordCount;
end;
end.
|
unit uCustomers;
interface
Type
TCustomer = class
private
Fname: string;
Fid: integer;
Fstatus: integer;
procedure Setid(const Value: integer);
procedure Setname(const Value: string);
procedure Setstatus(const Value: integer);
published
property id : integer read Fid write Setid;
property name : string read Fname write Setname;
property status : integer read Fstatus write Setstatus;
end;
implementation
{ TCustomer }
procedure TCustomer.Setid(const Value: integer);
begin
Fid := Value;
end;
procedure TCustomer.Setname(const Value: string);
begin
Fname := Value;
end;
procedure TCustomer.Setstatus(const Value: integer);
begin
Fstatus := Value;
end;
end.
|
{
@abstract(provides a component for exporting data to clipboard and text files)
@author(Aaron Hochwimer <aaron@graphic-edge.co.nz>)
@created(June 30, 2003)
@lastmod(June 30, 2003)
This unit provides the TGEExportFile component component. This is a general
purpose export module to export data to comma, tab, or space separated data
files, clipboard also xml and LaTeX
}
unit geExportFile;
// $Id: geExportFile.pas,v 1.3 2003/07/01 01:42:02 hochwimmera Exp $
interface
uses
classes,controls,db,dialogs,forms,menus,registry,stdctrls,sysutils,windows,
shellapi,clipbrd,frmExport;
const
sACCEPTDATEBOUNDS = 'acceptdatebounds';
sEXPORT = 'Export';
sFIELDNAMES = 'fnames';
sHIDDEN = 'hidden';
sHIGHTIME = 'hightime';
sLATEXLONGTABLE = 'longtable';
sLATEXHLINES = 'hlines';
sLATEXTABULAR = 'tabular';
sLATEXVERTRULE = 'vrule';
sLOWTIME = 'lowtime';
sOPEN = 'open';
sOVERRIDE = 'override';
{clipboard}
sCLIPBOARD = 'clipboard';
{comma separated value file}
sCSV = 'comma separated value ';
{space separated value file}
sSSV = 'space separated value';
{tab separated value file}
sTSV = 'tab separated value';
{xml}
sXML = 'xml';
{latex}
sLATEX = 'LaTeX';
type
{Enumeration type providing a list of export file types. Current types include:
efCSV,efTSV,efSSV,efClipboard,efXML,efLatex}
TExportFileType = (efCSV,efTSV,efClipboard,efSSV,efXML,efLatex);
TGEExportFile = class(TComponent)
private
fAcceptDateBounds:boolean;
fDateTimeFilterField:string;
fDelimitEverything:boolean;
fDefaultFileType:TExportFileType;
fDelimiter:string;
fExporter : TformExporter;
fExportFileType: TExportFileType;
fFileName: string;
fFilePath: string;
fHighTime : boolean;
fHighDateTime : TDateTime;
fIdentifier : string;
fLatexEnvironment : string;
fLatexHline:boolean;
fLatexVRule:boolean;
fLatexColType:string;
fLowDateTime : TDateTime;
fLowTime : boolean;
fOnTypeChange: TNotifyEvent;
{runs shellapi command to open}
fOpenFileAfterExport : boolean;
{outputs the fieldnames in the header}
fOutputFieldNames : boolean;
fPrecision:integer;
fReg: TRegIniFile;
fRegPath: string;
fSubRegPath:string;
fSaveDialog: TSaveDialog;
{allow access to hidden fields}
fShowHiddenFields: boolean;
fSource: TDataSet;
fTextFile:Textfile;
function AppendDelimiter(sDelimiter,sItem:string):string;
function GetHint:string;
procedure LoadExportFileType;
procedure SaveNodalSettings;
procedure SetDelimiter(sDelimiter:string);
procedure SetExportFileType(aFileType:TExportFileType);
procedure SetFilePath(aFilePath:string);
procedure SetExportFile(exporter:TformExporter);
procedure SetIdentifier(sIdentifier:string);
protected
procedure DoOnTypeChange;virtual;
procedure Loaded;override;
procedure LoadFilePath;
procedure LoadRegistrySettings(fsl:TStringList);
procedure SaveRegistrySettings(fsl:TStringList);
procedure WriteFileHeaderInfo(sl:TStringList;sSep:string);
procedure WriteLaTexHeader(sl:TStringList);
public
constructor Create(aOwner:TComponent);override;
destructor Destroy;override;
procedure Execute;
procedure SaveTableToClipboard(sl:TStringList);
procedure SaveTableToFile(sl:TStringList);
property AcceptDateBounds : boolean read fAcceptDateBounds write fAcceptDateBounds;
property DateTimeFilterField : string read fDateTimeFilterField write fDateTimeFilterField;
property DelimitEverything : boolean read fDelimitEverything write fDelimitEverything;
property Delimiter : string read fDelimiter write SetDelimiter;
property Exporter : TformExporter read fExporter write fExporter;
property ExportTextFile : TextFile read fTextFile write fTextFile;
property FileName : string read fFileName write fFileName;
property FilePath : string read fFilePath write SetFilePath;
property Hint : string read GetHint;
property HighDateTime : TDateTime read fHighDateTime write fHighDateTime;
property HighTime : boolean read fHighTime write fHighTime;
property Identifier : string read fIdentifier write SetIdentifier;
property LatexColType : string read fLatexColType write fLatexColType;
property LatexEnvironment : string read fLatexEnvironment write fLatexEnvironment;
property LatexHline : boolean read fLatexHLine write fLatexHline;
property LatexVRule : boolean read fLatexVRule write fLatexVRule;
property LowDateTime : TDateTime read fLowDateTime write fLowDateTime;
property LowTime : boolean read fLowTime write fLowTime;
property OpenFileAfterExport : boolean read fOpenFileAfterExport write fOpenFileAfterExport;
property OutputFieldNames : boolean read fOutputFieldNames write fOutputFieldNames;
property Reg: TRegIniFile read fReg write fReg;
property SaveDialog: TSaveDialog read fSaveDialog write fSaveDialog;
property ShowHiddenFields: boolean read fShowHiddenFields write fShowHiddenFields;
published
property OnTypeChange: TNotifyEvent read fOnTypeChange write fOnTypeChange;
property DefaultFileType: TExportFileType read fDefaultFileType write fDefaultFileType;
property ExportFileType: TExportFileType read fExportFileType write SetExportFileType;
property RegPath: string read fRegPath write fRegPath;
property Precision : integer read fPrecision write fPrecision;
property Source: TDataSet read fSource write fSource;
property SubRegPath:string read fSubRegPath write fSubRegpath;
end;
procedure Register;
implementation
//------ Register --------------------------------------------------------------
procedure Register;
begin
RegisterComponents('Graphic Edge IO', [TGEExportFile]);
end;
// ------ TGEExportFile.AppendDelimiter --------------------------------------
function TGEExportFile.AppendDelimiter(sDelimiter,sItem:string):string;
begin
if (sItem <> '') then
result := sItem + sDelimiter
else
result := '';
end;
//------ TGEExportFile.GetHint -------------------------------------------------
{** provides a hint string based on the Export file type}
function TGEExportFile.GetHint:string;
begin
if (ExportFileType = efCSV) then
result := sCSV
else if (ExportFileType = efTSV) then
result := sTSV
else if (ExportFileType = efClipboard) then
result := sCLIPBOARD
else if (ExportFileType = efSSV) then
result := sSSV
else if (ExportFileType = efXML) then
result := sXML
else if (ExportFileType = efLatex) then
result := sLATEX
else
result := '';
end;
//------ TGEExportFile.LoadExportFileType ------------------------------------
procedure TGEExportFile.LoadExportFileType;
var
sType:string;
begin
Reg.OpenKey(RegPath,true);
sType := LowerCase(Reg.ReadString(SubRegPath,Identifier+'.DefaultFileType',
''));
Reg.CloseKey;
if (sType = sCSV) then
ExportFileType := efCSV
else if (sType = sTSV) then
ExportFileType := efTSV
else if (sType = sCLIPBOARD) then
ExportFileType := efClipboard
else if (sType = sSSV) then
ExportFileType := efSSV
else if (sType = sXML) then
ExportFileType := efXML
else if (sType = sLATEX) then
ExportFileType := efLaTeX
else
ExportFileType := DefaultFileType;
end;
//------ TGEExportFile.SaveNodalSettings ---------------------------------------
procedure TGEExportFile.SaveNodalSettings;
begin
FilePath := FilePath;
ExportFileType := ExportFileType;
end;
// ----- TFEExportFile.SaveTableToClipboard ----------------------------------
procedure TGeExportFile.SaveTableToClipboard(sl:TStringList);
const
sDELIMIT = #9; {** clipboard is tab delimited}
var
i,iPos,j,k : integer;
sField,sFieldEntry,sTemp : string;
checkdatetime : TDateTime;
clip : TStringList;
begin
Source.DisableControls;
screen.Cursor := crHourGlass;
clip:=TStringList.Create;
{** headers}
j:=0;
sFieldEntry := '';
if OutputFieldNames then
begin
{** this is the preferred name}
for i:=0 to sl.Count-1 do
begin
{** need to get the real name - only works if there is a one-to-one with
preferred}
sField := sl.Strings[i];
if (Source.FieldDefs.IndexOf(sField) <> -1) then
begin
sFieldEntry := sFieldEntry + sField;
inc(j);
if (j<sl.count) then
sFieldEntry := sFieldEntry + sDELIMIT;
end;
end;
clip.Add(sFieldEntry);
end; {output field names}
// now loop over all records
Source.First;
for k:= 0 to Source.RecordCount-1 do
begin
j:=0;
sFieldEntry:='';
{** date filtering - reject records that fail}
if ((LowTime or HighTime) and (DateTimeFilterField <> '')) then
begin
checkdateTime := Source.FieldByName(DateTimeFilterField).AsDateTime;
if AcceptDateBounds then
begin
if ((LowTime and (checkdatetime < LowDateTime)) or
(HighTime and (checkdatetime > HighDateTime))) then
begin
Source.Next;
Continue;
end;
end else
begin
if ((LowTime and (checkdatetime <= LowDateTime)) or
(HighTime and (checkdateTime >= HighDateTime))) then
begin
Source.Next;
continue;
end;
end;
end;
for i:=0 to sl.Count-1 do
begin
sField := sl.Strings[i];
iPos :=Source.FieldDefs.IndexOf(sField);
if (iPos<>-1) then
begin
// need formating here with precision [float fields]
sTemp := Source.FieldByName(sField).AsString;
{** delimiter code - make this subroutine to share with file code}
if (DelimitEverything and (Delimiter<>'')) then
stemp := DELIMITER + sTemp + DELIMITER
else if ((Delimiter <> '') and ((Source.FieldByName(sField)
is TStringField) or
(Source.FieldByName(sField) is TWideSTringField))) then
sTemp := DELIMITER + sTemp + DELIMITER;
sFieldEntry := sFieldEntry + sTemp;
inc(j);
if (j < sl.Count) then
sFieldEntry := sFieldEntry + sDELIMIT;
end;
end;
clip.Add(sFieldEntry);
Source.Next;
end;
Source.EnableControls;
screen.Cursor :=crDefault;
// the actual copy to clipboard
ClipBoard.AsText := clip.Text;
end;
// ----- TGEExportFile.SaveTableToFile -----------------------------------------
procedure TGEExportFile.SaveTableToFile(sl:TStringList);
var
i,iPos,j,k : integer;
sField,sFieldEntry,sSep,sTemp : string;
bNoEntry: boolean;
checkdateTime : TDateTime;
begin
if (ExportFileType = efCSV) then
ssep := ','
else if (ExportFileType = efTSV) then
ssep := #9
else if (ExportFileType = efSSV) then
ssep := ' '
else if (ExportFileType = efLatex) then
ssep := ' & ';
source.DisableControls;
screen.Cursor := crHourGlass;
Rewrite(ExportTextFile);
{** writes header info (LaTeX syntax) for LaTeX modes}
if (ExportFileType = efLaTeX) then
WriteLaTeXHeader(sl)
else if (ExportFileType = efXML) then
begin
{** writes}
WriteLn(ExportTextFile,'<?xml version="1.0" encoding="UTF-8"?>');
WriteLn(ExportTextFile,'<records>');
end else
{** writes field names and units if required}
WriteFileHeaderInfo(sl,sSep);
{** prep the table}
Source.First;
{** force output of table units in a specified precision}
bNoEntry := true;
{** loop over records}
for k:= 0 to Source.RecordCount-1 do
begin
j:=0;
{** date filtering - reject records that fail}
if ((LowTime or HighTime) and (DateTimeFilterField <> '')) then
begin
checkdateTime :=
Source.FieldByName(DateTimeFilterField).AsDateTime;
if AcceptDateBounds then
begin
if ((LowTime and (checkdatetime < LowDateTime)) or
(HighTime and (checkdatetime > HighDateTime))) then
begin
Source.Next;
Continue;
end;
end else
begin
if ((LowTime and (checkdatetime <= LowDateTime)) or
(HighTime and (checkdateTime >= HighDateTime))) then
begin
Source.Next;
continue;
end;
end;
end;
{** initialise the field entry}
if (ExportFileType = efXML) then
sFieldEntry := '<record>'
else
sFieldEntry := '';
bNoEntry := false;
for i:=0 to sl.Count-1 do
begin
sField := sl.Strings[i];
iPos := Source.FieldDefs.IndexOf(sField);
if (iPos <> -1) then
begin
// need formating here with precision...
sTemp := Source.FieldByName(sField).AsString;
if (DelimitEverything and (Delimiter<>'')) then
stemp := DELIMITER + sTemp + DELIMITER
else if ((Delimiter <> '') and
(Source.Fields[iPos] is TStringField) or
(Source.Fields[iPos] is TWideSTringField)) then
sTemp := DELIMITER + sTemp + DELIMITER;
if (ExportFileType = efXML) then
begin
sFieldEntry := sFieldEntry + '<field name="'+sField+'">'+sTemp+'</field>';
inc(j);
end else
begin
sFieldEntry := sFieldEntry + sTemp;
inc(j);
if (j < sl.Count) then
sFieldEntry := sFieldEntry + ssep;
end;
end;
end;
if (ExportFileType = efLatex) then
sFieldEntry := sFieldEntry + ' \\';
WriteLn(ExportTextFile,sFieldEntry);
if (ExportFileType = efLatex) and LatexHLine then
WriteLn(ExportTextFile,'\hline');
if (ExportFileType = efXML) then
WriteLn(ExportTextFile,'</record>');
Source.Next;
end; {** for k = 0 to RecordCount-1 - loop over all records}
if (ExportFileType = efLatex) then
begin
if (LatexEnvironment = sLATEXTABULAR) then
Write(ExportTextFile,'\end{tabular}')
else if (LatexEnvironment = sLATEXLONGTABLE) then
Write(ExportTextFile,'\end{longtable}');
end else if (ExportFileType = efXML) then
Write(ExportTextFile,'</records>');
CloseFile(ExportTextFile);
Source.EnableControls;
screen.Cursor :=crDefault;
if (bNoentry) and (DateTimeFilterField <> '') then
MessageDlg('Date filtering caused all records to be rejected!',
mtInformation, [mbOK], 0);
if (OpenFileAfterExport and (not bNoEntry)) then
ShellExecute(TForm(self.owner).handle,pchar('open'),
pchar(FileName),nil,nil,SW_NORMAL);
end;
// ------ TGEExportFile.SetDelimiter -----------------------------------------
procedure TGEExportFile.SetDelimiter(sDelimiter:string);
begin
if (fDelimiter <> sDelimiter) then
begin
fDelimiter := sDelimiter;
Reg.OpenKey(RegPath,true);
Reg.WriteString(SubRegPath,Identifier+'.Delimiter',sDelimiter);
Reg.CloseKey;
end;
end;
//------ TGEExportFile.SetExportFileTYpe -------------------------------------
procedure TGEExportFile.SetExportFileType(aFileType:TExportFileType);
var
sType:string;
begin
fExportFileType := aFileType;
if (fExportFileType = efCSV) then
sType := sCSV
else if (fExportFileType = efTSV) then
sType := STSV
else if (fExportFileType = efClipboard) then
sType := sCLIPBOARD
else if (fExportFileType = efSSV) then
sType := sSSV
else if (fExportFileType = efXML) then
sType := sXML
else if (fExportFileType = efLatex) then
sType := sLATEX;
{** enable the tooltips of the applications export button to update if req.}
DoOnTypeChange;
Reg.OpenKey(RegPath,true);
Reg.WriteString(SubRegPath,Identifier+'.DefaultFileType',sType);
Reg.CloseKey;
end;
//------ TGEExportFile.SetFilePath -------------------------------------------
procedure TGEExportFile.SetFilePath(aFilePath:string);
begin
fFilePath := aFilePath;
with Reg do
begin
OpenKey(RegPath,true);
WriteString(SubRegPath,Identifier+'.FilePath',aFilePath);
CloseKey;
end;
end;
// ------ TGEExportFile.SetExportFile ------------------------------------------
procedure TGEExportFile.SetExportFile(exporter:TformExporter);
var
SaveDialog : TSaveDialog;
sFileName:string;
begin
SaveDialog := TSaveDialog.Create(nil);
with SaveDialog do
begin
Filter := 'Comma Separated Value files (*.csv)|*.csv|'+
'Text files (*.txt)|*.txt|'+
'XML files (*.xml)|*.xml|'+
'TeX files (*.tex)|*.tex|'+
'VTK files (*.vtk)|*.vtk|'+
'All files|*.*';
Options := [ofOverwritePrompt];
InitialDir := FilePath; {** needs checking}
if (ExportFileType = efCSV) then
begin
Title := 'Save Comma Separated Value file';
FilterIndex := 1;
DefaultExt := '.csv';
end else if (ExportFileType = efTSV) then
begin
Title := 'Save Tab Separated Value file';
FilterIndex := 2;
DefaultExt := '.txt';
end else if (ExportFileType = efSSV) then
begin
Title := 'Save Space Separated Value file';
FilterIndex := 2;
DefaultExt := '.txt';
end else if (ExportFileType = efXML) then
begin
Title := 'Save XML File';
FilterIndex := 3;
DefaultExt := '.xml';
end else if (ExportFileType = efLatex) then
begin
Title := 'Save LaTeX File';
FilterIndex := 4;
DefaultExt := '.tex';
end;
if Execute then
begin
sFileName := FileName;
self.FileName := sFileName;
AssignFile(ExportTextFile,sFileName);
SaveTableToFile(exporter.storedfields);
end;
Free;
end;
end;
//------ TUnitExportFile.SetIdentifier -----------------------------------------
procedure TGEExportFile.SetIdentifier(sIdentifier:string);
begin
fIdentifier := sIdentifier; // always load
LoadExportFileType;
LoadFilePath;
end;
//------ TGEExportFile.DoOnTypeChange ------------------------------------------
procedure TGEExportFile.DoOnTypeChange;
begin
if Assigned(fOnTypeChange) then
fOnTypechange(self);
end;
//------ TGEExportFile.Loaded ------------------------------------------------
procedure TGEExportFile.Loaded;
begin
inherited Loaded;
end;
//------ TGEExportFile.LoadFilePath --------------------------------------------
procedure TGEExportFile.LoadFilePath;
begin
Reg.OpenKey(RegPath,true);
FilePath := Reg.ReadString(SubRegPath,Identifier+'.FilePath',
ExtractFilePath(ParamStr(0)));
Reg.CloseKey;
end;
//------ TGEExportFile.LoadRegistrySettings ----------------------------------
{** this imports the stored fieldnames from the registry}
procedure TGEExportFile.LoadRegistrySettings(fsl:TStringList);
const
iDELIMITER = 1;
sDELIMITER = ',';
var
{** s1,s2 are temp string variables}
s1,s2,sPath,sStored : string;
bBlankLow:boolean;
begin
fsl.Clear;
Reg.OpenKey(RegPath,true);
sStored := Reg.ReadString(SubRegPath,Identifier+'.FieldSelection','');
if (sStored <> '') then
begin
s1 := sStored;
while (s1 <> '') do
begin
if (Pos(sDELIMITER,s1) > 0) then
begin
s2 := Copy(s1,1,Pos(sDELIMITER,s1)-1);
s1 := Copy(s1,Pos(sDELIMITER,s1) + iDELIMITER,Length(s1));
end else
begin
s2 := s1;
s1 := '';
end;
fsl.Add(s2);
end;
end;
{** default settings}
sStored := Reg.ReadString(SubRegPath,Identifier+'.Options','');
OpenFileAfterExport := (Pos(sOPEN,sStored) > 0);
OutputFieldNames := ((Pos(sFIELDNAMES,sStored) > 0) or (sStored = ''));
ShowHiddenFields := (Pos(sHIDDEN,sStored) > 0);
AcceptDateBounds := (Pos(sACCEPTDATEBOUNDS,sStored) > 0);
LowTime := (Pos(sLOWTIME,sStored) > 0);
HighTime := (Pos(sHIGHTIME,sStored) > 0);
DateTimeFilterField := Reg.ReadString(SubRegPath,Identifier+'.DateTimeField','');
Precision := Reg.ReadInteger(SubRegPath,Identifier+'.Precision',15);
sStored := Reg.ReadString(SubRegPath,Identifier+'.LaTeXOptions','');
Reg.CloseKey;
{** check for environment string - default to normal tabular}
LatexEnvironment := sLATEXTABULAR;
if (Pos(sLATEXLONGTABLE,sStored) > 0) then
LatexEnvironment := sLATEXLONGTABLE;
if (pos(sLATEXTABULAR,sStored) > 0) then
LatexEnvironment := sLATEXTABULAR;
Reg.OpenKey(RegPath + '\' + SubRegPath,false);
sPath := Identifier+'.LowDateTime';
if Reg.ValueExists(sPath) then
begin
LowDateTime := Reg.ReadFloat(sPath);
bBlankLow := false;
end else
begin
LowDateTime := Now;
bBlankLow := true;
end;
sPath := Identifier+'.HighDateTime';
if Reg.ValueExists(sPath) then
HighDateTime := Reg.ReadFloat(sPath)
else
HighDateTime := Now;
if bBlankLow then
HighDateTime := Now + 1.0;
Reg.CloseKey;
end;
//------ TGEExportFile.SaveRegistrySettings ----------------------------------
{** this saves the stored fieldnames into registry}
procedure TGEExportFile.SaveRegistrySettings(fsl:TStringList);
const
sDELIMITER = ',';
var
i,iCount : integer;
sPath,sRegEntry : string;
begin
Reg.OpenKey(RegPath,true);
sRegEntry := '';
iCount := fsl.Count-1;
for i:=0 to iCount do
begin
sRegEntry := sRegEntry + fsl.Strings[i];
if (i<iCount) then
sRegEntry := sRegEntry + sDELIMITER;
end;
Reg.WriteString(SubRegPath,Identifier + '.FieldSelection',sRegEntry);
{** write export options}
sRegEntry:='';
if OpenFileAfterExport then
sRegEntry := sOPEN;
if OutputFieldNames then
begin
sRegEntry := AppendDelimiter(sDELIMITER,sRegEntry);
sRegEntry := sRegEntry + sFIELDNAMES;
end;
if ShowHiddenFields then
begin
sRegEntry := AppendDelimiter(sDELIMITER,sRegEntry);
sRegEntry := sRegEntry + sHIDDEN;
end;
if AcceptDateBounds then
begin
sRegEntry := AppendDelimiter(sDELIMITER,sRegEntry);
sRegEntry := sRegEntry + sACCEPTDATEBOUNDS;
end;
if LowTime then
begin
sRegEntry := AppendDelimiter(sDELIMITER,sRegEntry);
sRegEntry := sRegEntry + sLOWTIME;
end;
if HighTime then
begin
sRegEntry := AppendDelimiter(sDELIMITER,sRegEntry);
sRegEntry := sRegEntry + sHIGHTIME;
end;
Reg.WriteString(SubRegPath,Identifier+'.Options',sRegEntry);
sRegEntry := LatexEnvironment;
{** save registry settings for this node}
sRegEntry := LatexEnvironment;
Reg.WriteString(SubRegPath,Identifier+'.LatexOptions',sRegEntry);
if LatexHLine then
sRegEntry := sRegEntry + sLATEXHLINES;
if LatexVRule then
sRegEntry := sRegEntry + sLATEXVERTRULE;
Reg.WriteSTring(SubRegPath,Identifier+'.DateTimeField',DateTimeFilterField);
Reg.WriteInteger(SubRegPath,Identifier+'.Precision',Precision);
Reg.CloseKey;
Reg.OpenKey(RegPath + '\'+SubRegPath,true);
sPath := Identifier+'.LowDateTime';
Reg.WriteFloat(sPath,LowDateTime);
sPath := Identifier+'.HighDateTime';
Reg.WriteFloat(sPath,HighDateTime);
Reg.CloseKey;
end;
// ------ TGEExportFile.WriteFileHeaderInfo ------------------------------------
procedure TGEExportFile.WriteFileHeaderInfo(sl:TstringList;sSep:string);
var
i,j:integer;
sField,sFieldEntry:string;
begin
j:=0;
sFieldEntry := '';
if OutputFieldNames then
begin
for i:=0 to sl.Count-1 do
begin
sField := sl.Strings[i];
if (Source.FieldDefs.IndexOf(sField) <> -1) then
begin
sFieldEntry := sFieldEntry + sField;
inc(j);
if (j<sl.count) then
sFieldEntry := sFieldEntry + ssep;
end;
end;
if ExportFIleType = efLatex then
sFieldEntry := sFieldEntry + ' \\';
WriteLn(ExportTextFile,sFieldEntry);
if (ExportFileType = efLatex) and LatexHLine then
WriteLn(ExportTextFile,'\hline');
end;
end;
// ------ TGEExportFile.WriteLaTexHeader -------------------------------------
procedure TGEExportFile.WriteLaTexHeader(sl:TStringList);
var
sTemp : string;
i : integer;
begin
if (LaTeXEnvironment = sLATEXTABULAR) then
begin
sTemp := '\begin{tabular}{';
if LatexVRule then
sTemp := sTemp + '|';
{** set up the column definitions}
for i := 0 to sl.Count-1 do
begin
sTemp := sTemp + LateXColType;
if LatexVRule then
sTemp := sTemp + '|';
end;
sTemp := sTemp + '}';
Write(ExportTextFile,sTemp);
Write(ExportTextFile,#13);
if LatexHLine then
begin
Write(ExportTextFile,'\hline');
Write(ExportTextFile,#13);
end;
{** LONGTABLE Mode}
end else if (LatexEnvironment = sLATEXLONGTABLE) then
begin
sTemp := '\begin{longtable}{';
if LatexVRule then
sTemp := sTemp + '|';
{** set up the column definitions}
for i := 0 to sl.Count-1 do
begin
sTemp := sTemp + 'c';
if LatexVRule then
sTemp := sTemp + '|';
end;
sTemp := sTemp + '}';
Write(ExportTextFile,sTemp + #13);
{** first caption}
Write(ExportTextFile,
'\caption[Short first caption]{Long first caption} \\'+#13);
if LatexHLine then
Write(ExportTextFile,'\hline'+#13);
Write(ExportTextFile,'\endfirsthead'+#13);
{** repeated captions/headers}
Write(ExportTextFile,'\caption[]{(continued)} \\'+#13);
if LatexHLine then
Write(ExportTextFile,'\hline'+#13);
Write(ExportTextFile,'\endhead'+#13);
{** first footer}
if LatexHLine then
Write(ExportTextFile,'\hline'+#13);
Write(ExportTextFile,'\endfoot'+#13);
{** last footer}
if LatexHLine then
Write(ExportTextFile,'\hline'+#13);
Write(ExportTextFile,'\endlastfoot'+#13);
end;
end;
//------ TGEExportFile.Create --------------------------------------------------
constructor TGEExportFile.Create(aOwner:TComponent);
begin
inherited Create(aOwner);
Reg:= TRegIniFile.Create;
fDefaultFileType := efCSV;
fDelimiter:= '';
fDelimitEverything:= false;
fLowDateTime := Now;
fHighDateTime := Now+1;
fAcceptDateBounds := false;
fSubRegPath:=sEXPORT;
LowTime := false;
HighTime := false;
fIdentifier := 'Untitled';
end;
//------ TGEExportFile.Destroy -------------------------------------------------
destructor TGEExportFile.Destroy;
begin
Reg.Free;
inherited Destroy;
end;
// ----- TGEExportFile.Execute -------------------------------------------------
procedure TGEExportFile.Execute;
var
bAcceptDateBounds,bDelimitEverything,bFields,bHidden,bHighTime,bHLine,
bKeepExporting,bLowTime,bOpen,bVRule : boolean;
i : integer;
sDateTimeField,sDelimiter,sLateXEnv : string;
aHighDateTime, aLowDateTime : TDateTime;
dsl : TStringList;
iPrecision :integer;
begin
bKeepExporting := true;
exporter := TformExporter.Create(self);
exporter.Source := Source;
dsl := TStringList.Create;
for i:=0 to Source.FieldCount-1 do
begin
if ((Source.Fields[i] is TDateField) or
(Source.Fields[i] is TTimeField) or
(Source.Fields[i] is TDateTimeField)) then
dsl.Add(Source.Fields[i].FieldName);
end;
exporter.pnlLatex.visible := (ExportFileType = efLaTeX);
exporter.PrepCaption(ord(ExportFileType),LaTeXEnvironment,LaTeXHLine,LaTeXVRule);
while bKeepExporting do
begin
{** load registry settings here - i.e. which items to check etc.}
LoadRegistrySettings(exporter.storedfields);
exporter.PrepFilters(DateTimeFilterField,dsl);
exporter.CopySettings(OpenFileAfterExport,OutputFieldNames,ShowHiddenFields,
LowTime,HighTime,DelimitEverything,AcceptDateBounds,
LowDateTime,HighDateTime,Delimiter,Precision);
if (exporter.ShowModal = mrOK) then
begin
{** this saves the settings from the exporter form to the properties here}
exporter.SaveSettings(bOpen,bFields,bHidden,
bLowTime,bHighTime,bDelimitEverything,bAcceptDateBounds,
aLowDateTime,aHighDateTime,sDateTimeField,
sDelimiter,iPrecision);
Precision := iPrecision;
OpenFileAfterExport:=bOpen;
OutputFieldNames:=bFields;
ShowHiddenFields:=bHidden;
LowTime := bLowTime;
HighTime := bHighTime;
LowDateTime := aLowDateTime;
HighDateTime := aHighDateTime;
Delimiter := sDelimiter;
DelimitEverything:= bDelimitEverything;
AcceptDateBoundS := bAcceptDateBounds;
if (sDateTimeField <> '') then
DateTimeFilterField := sDateTimeField;
{** save LaTex Settings}
if (ExportFileType = efLatex) then
exporter.SaveLaTexSettings(sLatexEnv,bHline,bVrule);
LatexEnvironment := sLatexEnv;
LatexHLine := bhline;
LatexVRule := bVrule;
{** firstly save the current selection to the registry}
SaveRegistrySettings(exporter.storedfields);
SaveNodalSettings;
if (exporter.storedfields.Count > 0) then
begin
if (ExportFileType = efClipboard) then
SaveTableToClipboard(exporter.storedfields)
else
SetExportFile(exporter);
end;
end else
bKeepExporting := false; {** cancel action stops the exporting cycle}
end;
dsl.Free;
exporter.Release;
end;
end.
|
unit Odontologia.Controlador.Producto;
interface
uses
Data.DB,
System.Generics.Collections,
Odontologia.Modelo.Entidades.Producto,
Odontologia.Modelo.Producto.Interfaces,
System.SysUtils, Odontologia.Modelo,
Odontologia.Controlador.Producto.Interfaces;
type
TControllerProducto = class(TInterfacedObject, iControllerProducto)
private
FModel: iModelProducto;
FDataSource: TDataSource;
Flista: TObjectList<TPRODUCTO>;
FEntidad: TPRODUCTO;
public
constructor Create;
destructor Destroy; override;
class function New: iControllerProducto;
function DataSource(aDataSource: TDataSource): iControllerProducto;
function Buscar: iControllerProducto; overload;
function Buscar(aId: Integer): iControllerProducto; overload;
function Buscar(aNombre: String): iControllerProducto; overload;
function Insertar: iControllerProducto;
function Modificar: iControllerProducto;
function Eliminar: iControllerProducto;
function Entidad: TPRODUCTO;
end;
implementation
{ TControllerProducto }
function TControllerProducto.Buscar: iControllerProducto;
begin
Result := Self;
Flista := TObjectList<TPRODUCTO>.Create;
FModel.DAO.Find(Flista);
end;
function TControllerProducto.Buscar(aNombre: String): iControllerProducto;
begin
Result := Self;
FModel.DAO.SQL.Where('NOMBRE = ' + QuotedStr(aNombre)).&End.Find;
end;
function TControllerProducto.Buscar(aId: Integer): iControllerProducto;
begin
Result := Self;
if Assigned(FEntidad) then
FEntidad.Free;
FEntidad := FModel.DAO.Find(aId);
end;
constructor TControllerProducto.Create;
begin
FModel := TModel.New.Producto;
end;
function TControllerProducto.DataSource(aDataSource: TDataSource)
: iControllerProducto;
begin
Result := Self;
FDataSource := aDataSource;
FModel.DataSource(FDataSource);
end;
destructor TControllerProducto.Destroy;
begin
if Assigned(Flista) then
Flista.Free;
if Assigned(FEntidad) then
FEntidad.Free;
inherited;
end;
function TControllerProducto.Eliminar: iControllerProducto;
begin
Result := Self;
FModel.DAO.Delete(FModel.Entidad);
end;
function TControllerProducto.Entidad: TPRODUCTO;
begin
Result := FModel.Entidad;
end;
function TControllerProducto.Insertar: iControllerProducto;
begin
Result := Self;
FModel.DAO.Insert(FModel.Entidad);
end;
function TControllerProducto.Modificar: iControllerProducto;
begin
Result := Self;
FModel.DAO.Update(FModel.Entidad);
end;
class function TControllerProducto.New: iControllerProducto;
begin
Result := Self.Create;
end;
end.
|
unit E_GeoHash;
//------------------------------------------------------------------------------
// реализация гео-хэширования
//------------------------------------------------------------------------------
// HashEncode - процедура
// кодирование массива точек в строку со списком гео-хэшей
//
// аргументы:
// ACoords - массив точек
// ARegion - строка, задающая регион кодирования
// 'GR' - Россия, 8 символов
// 'GQ' - северо-восточная часть ЗШ, 10 символов
// 'GW' - весь ЗШ, 12 символов
// RHash - результирующая строка с префиксом региона и списком гео-хэшей
//
// !!! ВНИМАНИЕ: координаты точек не проверяются на совпадение с заданным регионом !!!
//
// HashDecode - функция
// декодирование строки со списком гео-хэшей в массив точек
// аргументы:
// AHash - строка с префиксом региона и списком гео-хэшей
// КCoords - массив точек (точки _добавляются_ в этот массив)
// результат:
// True, если раскодирование прошло успешно
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
interface
uses
SysUtils,
T_Points;
//------------------------------------------------------------------------------
//!
//------------------------------------------------------------------------------
procedure HashEncode(
const ACoords: TGeoPointArray;
const ARegion: string;
var RHash: string
);
//------------------------------------------------------------------------------
//!
//------------------------------------------------------------------------------
function HashDecode(
const AHash: string;
var RCoords: TGeoPointArray
): Boolean;
//------------------------------------------------------------------------------
implementation
const
//------------------------------------------------------------------------------
//! массив конвертации букв в номера
//------------------------------------------------------------------------------
CHashFromLetters: array[48..122] of Integer = (
0, 1, 2, 3, 4, 5, 6, 7, // 30-37, '0'..'7'
8, 9, -1, -1, -1, -1, -1, -1, // 38-3F, '8','9'
-1, -1, 10, 11, 12, 13, 14, 15, // 40-47, 'B'..'G'
16, -1, 17, 18, -1, 19, 20, -1, // 48-4F, 'H','J','K','M','N'
21, 22, 23, 24, 25, 26, 27, 28, // 50-57, 'P'..'W'
29, 30, 31, -1, -1, -1, -1, -1, // 58-5F, 'X'..'Z'
-1, -1, 10, 11, 12, 13, 14, 15, // 60-67, 'b'..'g'
16, -1, 17, 18, -1, 19, 20, -1, // 68-6F, 'h','j','k','m','n'
21, 22, 23, 24, 25, 26, 27, 28, // 70-77, 'p'..'w'
29, 30, 31 // 78-7A, 'x'..'z'
);
//------------------------------------------------------------------------------
//! массив конвертации номеров в буквы
//------------------------------------------------------------------------------
CHashToLetters: array[0..31] of Char = (
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'b', 'c', 'd', 'e', 'f', 'g',
'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
);
//------------------------------------------------------------------------------
//! конвертируем букву в номер
//------------------------------------------------------------------------------
function Letter2Num(
const ALetter: Char
): Integer;
begin
if ( Ord( ALetter ) < Low( CHashFromLetters ) ) or ( Ord( ALetter ) > High( CHashFromLetters ) ) then
Result := -1
else
Result := CHashFromLetters[Ord( ALetter )];
end;
//------------------------------------------------------------------------------
//! внутренняя прцедура кодирования точки в гео-хэш
//------------------------------------------------------------------------------
procedure EncodePoint(
const ACoords: TGeoPoint;
const ABoundMin: TGeoPoint;
const ABoundMax: TGeoPoint;
const APerc: Integer;
var RHash: string
);
var
//! рабочие переменные
WorkBoundMin, WorkBoundMax: TGeoPoint;
//! рабочие переменные
LatiMid, LongiMid: Double;
//! бинарное представление хэша
BinHash: Integer;
//! номер бита
Bit: Integer;
//! позиция в массиве Rez
Poz: Integer;
//! массив хранящий генерируемый код
Rez: array[0..12] of Char;
//! флаг чётного бита
EvenBit: Boolean;
//------------------------------------------------------------------------------
begin
WorkBoundMin := ABoundMin;
WorkBoundMax := ABoundMax;
BinHash := 0;
Bit := 5;
EvenBit := False;
FillChar( Rez, SizeOf( Rez ), #0 );
Poz := 0;
while ( Poz < APerc ) do
begin
BinHash := BinHash shl 1;
EvenBit := not EvenBit;
if EvenBit then
begin
LongiMid := ( WorkBoundMin.Longitude + WorkBoundMax.Longitude ) * 0.5;
if ( ACoords.Longitude >= LongiMid ) then
begin
Inc( BinHash );
WorkBoundMin.Longitude := LongiMid;
end
else
WorkBoundMax.Longitude := LongiMid;
end
else
begin
LatiMid := ( WorkBoundMin.Latitude + WorkBoundMax.Latitude ) * 0.5;
if ( ACoords.Latitude >= LatiMid ) then
begin
Inc( BinHash );
WorkBoundMin.Latitude := LatiMid;
end
else
WorkBoundMax.Latitude := LatiMid;
end;
Dec( Bit );
if ( Bit = 0 ) then
begin
Bit := 5;
Rez[Poz] := CHashToLetters[BinHash];
BinHash := 0;
Inc( Poz );
end;
end;
RHash := RHash + string( Rez );
end;
//------------------------------------------------------------------------------
//! внутренняя функция декодирования гео-хэша в точку
//------------------------------------------------------------------------------
function DecodePoint(
const RHash: string;
const ABoundMin: TGeoPoint;
const ABoundMax: TGeoPoint;
const APerc: Integer;
var ACoords: TGeoPoint
): Boolean;
var
//! рабочие переменные
WorkBoundMin, WorkBoundMax: TGeoPoint;
//! рабочие переменные
LatiMid, LongiMid: Double;
//! бинарное представление хэша
BinHash: Integer;
//! позиция бита
BitPos: Integer;
//! значение бита
BitX: Integer;
//! итератор по буквам
WorkChar: Char;
//! флаг чётного бита
EvenBit: Boolean;
//------------------------------------------------------------------------------
begin
Result := False;
WorkBoundMin := ABoundMin;
WorkBoundMax := ABoundMax;
EvenBit := False;
for WorkChar in RHash do
begin
BinHash := Letter2Num( WorkChar );
if ( BinHash = -1 ) then Exit;
for BitPos := 4 downto 0 do
begin
BitX := ( BinHash shr BitPos ) and 1;
EvenBit := not EvenBit;
if EvenBit then
begin
LongiMid := ( WorkBoundMin.Longitude + WorkBoundMax.Longitude ) * 0.5;
if ( BitX <> 0 ) then
WorkBoundMin.Longitude := LongiMid
else
WorkBoundMax.Longitude := LongiMid;
end
else
begin
LatiMid := ( WorkBoundMin.Latitude + WorkBoundMax.Latitude ) * 0.5;
if ( BitX <> 0 ) then
WorkBoundMin.Latitude := LatiMid
else
WorkBoundMax.Latitude := LatiMid;
end;
end;
end;
ACoords.Latitude := ( WorkBoundMin.Latitude + WorkBoundMax.Latitude ) * 0.5;
ACoords.Longitude := ( WorkBoundMin.Longitude + WorkBoundMax.Longitude ) * 0.5;
Result := True;
end;
//------------------------------------------------------------------------------
// interface
//------------------------------------------------------------------------------
procedure HashEncode(
const ACoords: TGeoPointArray;
const ARegion: string;
var RHash: string
);
var
//! итератор по точкам массива
Iter: TGeoPoint;
//! границы региона
BoundMin, BoundMax: TGeoPoint;
//! точность, символов
Perc: Integer;
//------------------------------------------------------------------------------
begin
RHash := ARegion;
if ( ARegion = 'GR' ) then
begin
BoundMin.Latitude := 40;
BoundMin.Longitude := 20;
BoundMax.Latitude := 80;
BoundMax.Longitude := 160;
Perc := 8;
end
else if ( ARegion = 'GQ' ) then
begin
BoundMin.Latitude := 0;
BoundMin.Longitude := 0;
BoundMax.Latitude := 90;
BoundMax.Longitude := 180;
Perc := 10;
end
else if ( ARegion = 'GW' ) then
begin
BoundMin.Latitude := -90;
BoundMin.Longitude := -180;
BoundMax.Latitude := 90;
BoundMax.Longitude := 180;
Perc := 12;
end
else Exit;
for Iter in ACoords do
begin
EncodePoint( Iter, BoundMin, BoundMax, Perc, RHash );
end;
end;
function HashDecode(
const AHash: string;
var RCoords: TGeoPointArray
): Boolean;
var
//! точность, символов
Perc: Integer;
//!
TempInt: Integer;
//!
WorkStr: string;
//!
HashStr: string;
//!
Coords: TGeoPoint;
//! границы региона
BoundMin, BoundMax: TGeoPoint;
//------------------------------------------------------------------------------
begin
Result := False;
HashStr := Copy( AHash, 1, 2 );
if ( HashStr = 'GR' ) then
begin
BoundMin.Latitude := 40;
BoundMin.Longitude := 20;
BoundMax.Latitude := 80;
BoundMax.Longitude := 160;
Perc := 8;
end
else if ( HashStr = 'GQ' ) then
begin
BoundMin.Latitude := 0;
BoundMin.Longitude := 0;
BoundMax.Latitude := 90;
BoundMax.Longitude := 180;
Perc := 10;
end
else if ( HashStr = 'GW' ) then
begin
BoundMin.Latitude := -90;
BoundMin.Longitude := -180;
BoundMax.Latitude := 90;
BoundMax.Longitude := 180;
Perc := 12;
end
else Exit;
WorkStr := Copy( AHash, 3, MaxInt );
if ( ( Length( WorkStr ) mod Perc ) <> 0 ) then Exit;
repeat
HashStr := Copy( WorkStr, 1, Perc );
if not DecodePoint( HashStr, BoundMin, BoundMax, Perc, Coords ) then Exit;
TempInt := Length( RCoords );
SetLength( RCoords, TempInt + 1 );
RCoords[TempInt] := Coords;
WorkStr := Copy( WorkStr, Perc + 1, MaxInt );
if ( WorkStr = '' ) then Break;
until False;
Result := True;
end;
end.
|
unit uStrUtil;
interface
uses
Math, Windows, Dialogs, SysUtils, Classes, uHashTable, StrUtils;
const
UNIT_NAME = 'StrUtil';
RANDCHARS = '0123456789ABCDEFGHJKLMNPQRSTUVWXYZ';
TRUE_VALUE_DEFAULT = '1';
FALSE_VALUE_DEFAULT = '0';
type
CStrUtil = class(TObject)
private
Fws : integer; //=3; // weight for substitution
Fwi : integer; //=1; // weight for insertion
Fwd : integer; //=6; // weight for deleting
Fth : integer;
protected
function DamerauLevenshteinLike(const s1,s2:string;ws,wi,wd:integer):Integer;
public
function ExtractInt(str: string): integer;
procedure WriteStreamStr(Stream : TStream; Str : string);
function ReadStreamStr(Stream : TStream) : string;
procedure WriteStreamInt(Stream : TStream; Num : integer);
function ReadStreamInt(Stream : TStream) : integer;
function strEOL(str: string): string;
function IsHex(str: string): boolean;
function AlphaCharCount(str: string): integer;
function NonAlphaCharCount(str: string): integer;
function SimilarCharCount(str, str2: string): integer;
function SimilarCharPct(str, str2: string): extended;
function folderNameFriendly(str: string): string;
function PadL(StringToPad: string; Size: Integer): String;
function IsChrAlpha( Character : Char ) : boolean;
function IsChrUpperAlpha( Character : Char ) : boolean;
function IsChrLowerAlpha( Character : Char ) : boolean;
function IsChrNumeric( Character : Char ) : boolean;
function IsNumeric( StringToCheck : string ) : boolean;
function IsStrictNumeric( StringToCheck : string ) : boolean;
function extNumDbl(str: string): double;
function extNumInt(str: string): integer;
function ParseString(const vS : string; ParseChar : Char; var ParsedString : TStringList; TrimOnInsert : boolean ) : cardinal;
function StringsAreLike( const s1,s2:string ): boolean;
property DLWeightForSubstitution : integer read Fws write Fws;
property DLWeightForInsertion : integer read Fwi write Fwi;
property DLWeightForDeleting : integer read Fwd write Fwd;
property DLWeightForMisc : integer read Fth write Fth;
constructor Create();
destructor Destroy; override;
end;
TCharSet = Set of Char;
TStringObject = class(TObject)
private
fStr: String;
public
constructor Create(const AStr: String) ;
property AsString: String read FStr write FStr;
end;
TStringList2 = class(TStringList)
public
function asString() : string; overload;
function asString(delimiter : string) : string; overload;
function fromString(str : string) : boolean; overload;
function fromString(str, delimiter : string) : boolean; overload;
end;
TXMLCharXlate = record
Char : string;
XML : string;
end;
TKeyValueExtended = record
Key : string;
Val : Extended;
end;
TKeyValueExtendedList = array of TKeyValueExtended;
TPtrAccuracy = record
Ptr : Pointer;
Val : Extended;
end;
TPtrAccuracyList = array of TPtrAccuracy;
function RandomString( num : smallint = 4 ) : string; overload;
procedure RandomString( const num : smallint; var outStr : string ); overload;
function BoolToStr( val : boolean; trueValue : string = TRUE_VALUE_DEFAULT; falseValue : string = FALSE_VALUE_DEFAULT ) : string;
function StrToBool( val : string; trueValue : string = TRUE_VALUE_DEFAULT; falseValue : string = FALSE_VALUE_DEFAULT ) : boolean;
function Split(const input: string; const schar: Char; const s: Word ): string;
Function StringCount(const input, stringToCount : string ): Cardinal;
Function XMLEnc(const str : string ): string;
Function XMLDec(const str : string ): string;
function MaxValue(const Data: TKeyValueExtendedList): TKeyValueExtended;
function MaxValueP(const Data: TPtrAccuracyList): TPtrAccuracy;
function uDateTimeToStr( const val : TDateTime ) : string;
function uStrToDateTime( const val : string ) : TDateTime;
function sNow() : String;
function IsIn( const Val : string; const Data : array of string ) : boolean;
var
XMLXlateTable : array[0..3] of TXMLCharXlate =
(
(Char : '&'; XML : '&'),
(Char : '<'; XML : '<'),
(Char : '>'; XML : '>'),
(Char : '"'; XML : '"')
);
implementation
function sNow(): string;
var
today : TDateTime;
begin
today := Now;
Result := DateToStr(today) + ' ' + TimeToStr(today);
End;
function uDateTimeToStr( const val : TDateTime ): string;
Begin
if ( val = MinDouble ) then
Result := ''
else
Result := DateTimeToStr( val );
End;
function uStrToDateTime( const val : string ) : TDateTime;
Begin
try
Result := StrToDateTime( val );
except
Result := MinDouble;
end;
End;
function IsIn( const Val : string; const Data : array of string ) : boolean;
var
I: Integer;
begin
Result := false;
for I := Low(Data) to High(Data) do begin
if LowerCase(Val) = LowerCase(Data[I]) then begin
Result := true;
Exit;
end;
end;
end;
function MaxValue(const Data: TKeyValueExtendedList): TKeyValueExtended;
var
I: Integer;
res : Extended;
begin
Result := Data[Low(Data)];
res := Data[Low(Data)].Val;
for I := Low(Data) + 1 to High(Data) do
if res < Data[I].Val then begin
res := Data[I].Val;
Result := Data[I];
end;
end;
function MaxValueP(const Data: TPtrAccuracyList): TPtrAccuracy;
var
I: Integer;
res : Extended;
begin
Result := Data[Low(Data)];
res := Data[Low(Data)].Val;
for I := Low(Data) + 1 to High(Data) do
if res < Data[I].Val then begin
res := Data[I].Val;
Result := Data[I];
end;
end;
Function XMLEnc(const str : string ): string;
var
i : integer;
Begin
Result := str;
for i := 0 to Length( XMLXlateTable ) - 1 do
if ( Pos( XMLXlateTable[i].Char, Result ) > 0 ) then
Result := StringReplace( Result, XMLXlateTable[i].Char, XMLXlateTable[i].XML, [rfReplaceAll]);
End;
Function XMLDec(const str : string ): string;
var
i : integer;
Begin
Result := str;
for i := 0 to Length( XMLXlateTable ) - 1 do
if ( Pos( XMLXlateTable[i].XML, Result ) > 0 ) then
Result := StringReplace( Result, XMLXlateTable[i].XML, XMLXlateTable[i].Char, [rfReplaceAll]);
End;
Function Split(const input: string; const schar: Char; const s: Word ): string;
// Thanks to http://www.swissdelphicenter.ch/torry/showcode.php?id=2064
Var
c: array of Integer;
b, t: Integer;
Begin
if ( not ContainsText(input, schar) ) then begin
if (s = 0) then
Result := input
else
Result := '';
end else begin
t := Length( input ); // variable T needs to be initialized...
setlength(c, Length(input));
for b := 0 to pred(High(c)) do
begin
c[b + 1] := posex( schar, input, succ(c[b]) );
if ( c[b + 1] < c[b] ) then begin
c[b + 1] := succ( t );
break;
end else if ( succ(s) < b ) then
break;
end;
Result := Copy( input, succ(c[s]), pred(c[s + 1] - c[s]));
end;
End;
Function StringCount(const input, stringToCount : string ): Cardinal;
Var
cRes : Cardinal;
pos: Integer;
Begin
cRes := 0;
pos := 1;
while pos <= Length( input ) do begin
pos := posex( stringToCount, input, pos );
if ( pos = 0 ) then break;
Inc( cRes );
Inc(pos, Length( stringToCount ));
end;
Result := cRes;
End;
function BoolToStr( val : boolean; trueValue : string = TRUE_VALUE_DEFAULT; falseValue : string = FALSE_VALUE_DEFAULT ) : string;
Begin
if ( val ) then
Result := trueValue
else
Result := falseValue;
End;
function StrToBool( val : string; trueValue : string = TRUE_VALUE_DEFAULT; falseValue : string = FALSE_VALUE_DEFAULT ) : boolean;
Begin
Result := ( Trim(val) = Trim(trueValue) );
End;
function RandomString(num : smallint) : string;
var
S: string;
i, N: integer;
Begin
Randomize;
S := '';
for i := 1 to num do begin
N := Random(Length(RANDCHARS)) + 1;
S := S + RANDCHARS[N];
end;
Result := S;
End;
procedure RandomString(const num : smallint ; var outStr : string);
var
S: string;
i, N: integer;
Begin
Randomize;
S := '';
for i := 1 to num do begin
N := Random(Length(RANDCHARS)) + 1;
S := S + RANDCHARS[N];
end;
outStr := S;
End;
{ CStrUtil }
function CStrUtil.AlphaCharCount(str: string): integer;
var i, nCnt : integer;
Begin
nCnt := 0;
for i := 1 to Length(str) do begin
case str[i] of
'A'..'Z': Inc(nCnt);
'a'..'z': Inc(nCnt);
'0'..'9': Inc(nCnt);
' ': Inc(nCnt);
end; {case}
end; {for}
Result := nCnt;
End;
constructor CStrUtil.Create;
begin
Fws :=3; // weight for substitution
Fwi :=1; // weight for insertion
Fwd :=6; // weight for deleting
Fth :=4;
end;
function CStrUtil.DamerauLevenshteinLike(const s1, s2: string; ws, wi,
wd: integer): Integer;
VAR
i,j:Integer;
function Pp(x,y:Integer):Integer;
begin
if AnsiUpperCase(s1[x])=AnsiUpperCase(s2[y]) then Pp:=0 else Pp:=ws;
end;
var
Wmax:integer;
d:array of array of integer;
begin
Wmax:=Max(length(s1),length(s2))+1;
SetLength(d,Wmax,Wmax);
dec(Wmax);
d[0,0]:=0;
for j:=1 TO Wmax DO d[0,j]:=d[0,Pred(j)]+wi;
for i:=1 TO Wmax DO d[i,0]:=d[Pred(i),0]+wd;
for i:=1 TO Length(s1) DO
for j:=1 TO Length(s2) DO
d[i,j]:=MinIntValue([ d[Pred(i),Pred(j)]+Pp(i,j), //substitution
d[ i ,Pred(j)]+wi, //insertion
d[Pred(i), j ]+wd //deletion
]);
result:=d[Length(s1),Length(s2)];
SetLength(d,0);
end{DamerauLevenshteinLike};
destructor CStrUtil.Destroy;
begin
inherited;
end;
function CStrUtil.strEOL(str: string): string;
var
nPos : integer;
begin
result := str;
nPos := Pos(#10, str);
if ( nPos > 0 ) then begin
result := Copy(str, 1, nPos - 1);
end;
nPos := Pos(#13, str);
if ( nPos > 0 ) then begin
result := Copy(str, 1, nPos - 1);
end;
End;
function CStrUtil.StringsAreLike(const s1, s2: string): boolean;
begin
result:= DamerauLevenshteinLike(s1,s2,Fws,Fwi,Fwd)<=Fth;
end;
procedure CStrUtil.WriteStreamInt(Stream: TStream; Num: integer);
{writes an integer to the stream}
begin
Stream.Write(Num, SizeOf(Integer));
end;
procedure CStrUtil.WriteStreamStr(Stream: TStream; Str: string);
{writes a string to the stream}
var
StrLen : integer;
begin
{get length of string}
StrLen := Length(Str);
{write length of string}
WriteStreamInt(Stream, StrLen);
{write characters}
if StrLen > 0 then
Stream.Write(Str[1], StrLen);
Stream.Position := 0;
end;
function CStrUtil.IsChrAlpha(Character: Char): boolean;
begin
case Character of
'a'..'z': Result := True;
'A'..'Z': Result := True;
else
Result := False;
end; {case}
End;
function CStrUtil.IsChrLowerAlpha(Character: Char): boolean;
begin
case Character of
'a'..'z': Result := True;
else
Result := False;
end; {case}
End;
function CStrUtil.IsChrNumeric(Character: Char): boolean;
begin
case Character of
'0'..'9': Result := True;
else
Result := False;
end; {case}
End;
function CStrUtil.IsChrUpperAlpha(Character: Char): boolean;
begin
case Character of
'A'..'Z': Result := True;
else
Result := False;
end; {case}
End;
function CStrUtil.IsHex(str: string): boolean;
var i : integer;
begin
for i := 1 to Length(str) do begin
case str[i] of
'A'..'F': Result := True;
'a'..'f': Result := True;
'0'..'9': Result := True;
else
Result := False;
break;
end; {case}
end; {for}
Result := False;
End;
function CStrUtil.IsNumeric(StringToCheck: string): boolean;
var
i : integer;
begin
result := true;
for i := 1 to Length(StringToCheck) do begin
if ( StringToCheck[i] = ',' ) and ( StringToCheck[i] = '$' ) then StringToCheck[i] := '0';
//if ( i = Length(StringToCheck)) and ( StringToCheck[i] = '-' ) then StringToCheck[i] := '0';
if ( i = 1) and ( StringToCheck[i] = '-' ) then StringToCheck[i] := '0';
if not IsChrNumeric( StringToCheck[i] ) then begin
result := false;
break;
end;
end; {for}
End;
function CStrUtil.extNumDbl(str: string): double;
var
i : integer;
begin
for i := 1 to Length(str) do begin
if ( str[i] = ',' ) and ( str[i] = '$' ) then str[i] := ' ';
end; {for}
result := StrToFloat(StringReplace(str, ' ', '', [rfReplaceAll, rfIgnoreCase] ));
End;
function CStrUtil.extNumInt(str: string): integer;
var
i : integer;
begin
for i := 1 to Length(str) do begin
if ( str[i] = ',' ) and ( str[i] = '$' ) then str[i] := ' ';
end; {for}
result := StrToInt(StringReplace(str, ' ', '', [rfReplaceAll, rfIgnoreCase] ));
End;
function CStrUtil.ExtractInt(str: string): integer;
var
i : integer;
begin
for i := 1 to Length(str) do begin
case str[i] of
'0'..'9':
else
str[i] := ' ';
end; {case}
end; {for}
result := StrToInt(StringReplace(str, ' ', '', [rfReplaceAll, rfIgnoreCase] ));
End;
function CStrUtil.folderNameFriendly(str: string): string;
begin
result := StringReplace(str , '/', '-', [rfReplaceAll, rfIgnoreCase] );
result := StringReplace(result, '\', '-', [rfReplaceAll, rfIgnoreCase] );
result := StringReplace(result, '*', '-', [rfReplaceAll, rfIgnoreCase] );
result := StringReplace(result, '?', '-', [rfReplaceAll, rfIgnoreCase] );
result := StringReplace(result, ':', '_', [rfReplaceAll, rfIgnoreCase] );
result := StringReplace(result, '.', ' ', [rfReplaceAll, rfIgnoreCase] );
End;
function CStrUtil.IsStrictNumeric(StringToCheck: string): boolean;
var
i : integer;
bIsStrNumeric : boolean;
begin
bIsStrNumeric := true;
for i := 1 to Length(StringToCheck) do begin
bIsStrNumeric := IsChrNumeric( StringToCheck[i] );
if not bIsStrNumeric then break;
end; {for}
result := bIsStrNumeric;
End;
function CStrUtil.NonAlphaCharCount(str: string): integer;
var i, nCnt : integer;
Begin
nCnt := 0;
for i := 1 to Length(str) do begin
case str[i] of
'A'..'Z': ;
'a'..'z': ;
'0'..'9': ;
' ': ;
else
Inc( nCnt );
end; {case}
end; {for}
Result := nCnt;
End;
function CStrUtil.PadL(StringToPad: string; Size: Integer): String;
var
nStPos : integer;
sNew, sPadString : string;
begin
sPadString := '0';
nStPos := (Size - Length(StringToPad)) + 1;
if nStPos < 2 then nStPos := 1;
sNew := StringOfChar(sPadString[1], nStPos - 1);
Result := sNew + StringToPad;
End;
function CStrUtil.ParseString(const vS: string; ParseChar: Char;
var ParsedString: TStringList; TrimOnInsert: boolean) : cardinal;
Var
i, StPos : integer;
s, newStr : String;
Begin
if ( ParsedString=nil) then
ParsedString := TStringList.Create;
s := vS + ParseChar;
i := 1; StPos := 1;
While i <= Length(s) do begin
if ( s[i] = ParseChar ) and ( i > 1 ) then begin
if TrimOnInsert then
newStr := Trim(Copy(s, StPos, i - StPos))
else
newStr := Copy(s, StPos, i - StPos);
if ( Length(newStr) > 0 ) then ParsedString.Add(newStr);
StPos := i + 1;
end;{if}
Inc(i);
end; {while}
Result := ParsedString.Count;
End;
function CStrUtil.ReadStreamInt(Stream: TStream): integer;
{returns an integer from stream}
begin
if Stream.Read(Result, SizeOf(Integer)) < SizeOf(Integer) then
Result := -1;
end;
function CStrUtil.ReadStreamStr(Stream: TStream): string;
{returns a string from the stream}
var
StrLen : integer;
begin
Stream.Position := 0;
{get length of string}
StrLen := ReadStreamInt(Stream);
if StrLen > 0 then
begin
{set string to get memory}
SetLength(Result, StrLen);
{read characters}
Stream.Read(Result[1], StrLen);
end else
Result := '';
{end; if StrLen > -1 else}
end;
function CStrUtil.SimilarCharCount(str, str2: string): integer;
var i, nCnt : integer;
Begin
nCnt := 0;
for i := 1 to Length(str) do
if (( Length( str2 ) > i ) and
( str[i] = str2[i] ) ) then
Inc( nCnt );
Result := nCnt;
End;
function CStrUtil.SimilarCharPct(str, str2: string): extended;
begin
if (( str='' ) or ( str2='' )) then
Result := 0
else
Result := SimilarCharCount(str, str2) / MAX(Length(str), Length(str2));
end;
{ TStringList2 }
function TStringList2.asString(delimiter: string): string;
var
i : integer;
res : string;
begin
res := '';
for i := 0 to self.Count - 1 do begin
if ( i = 0 ) then
res := self[i]
else
res := res + delimiter + self[i]
end;
result := res;
end;
function TStringList2.asString: string;
begin
result := asString('|');
end;
function TStringList2.fromString(str, delimiter: string): boolean;
var
oStrUtil : CStrUtil;
sl : TStringList;
begin
try
try
oStrUtil := CStrUtil.Create;
sl := TStringList.Create;
oStrUtil.ParseString( str, delimiter[1], sl, true );
self.Clear;
self.AddStrings( sl );
result := true;
except
result := false;
end;
finally
FreeAndNil( sl );
FreeAndNil( oStrUtil );
end;
end;
function TStringList2.fromString(str: string): boolean;
begin
result := self.fromString(str, '|');
end;
{ TString }
constructor TStringObject.Create(const AStr: String) ;
begin
inherited Create;
FStr := AStr;
end;
initialization
finalization
END.
|
unit fmeSystemTrayOptions;
{ TODO : why is this a separate frame? only used once }
interface
uses
Classes, fmeBaseOptions, Controls, Dialogs, Forms,
fmeLcOptions, MainSettings, Graphics, Messages, SDUStdCtrls,
StdCtrls, SysUtils, Variants, Windows;
type
TfmeSystemTrayOptions = class (TfmeLcOptions)
gbSystemTrayIcon: TGroupBox;
ckUseSystemTrayIcon: TSDUCheckBox;
ckMinToIcon: TSDUCheckBox;
ckCloseToIcon: TSDUCheckBox;
gbClickActions: TGroupBox;
rbSingleClick: TRadioButton;
rbDoubleClick: TRadioButton;
Label1: TLabel;
Label2: TLabel;
cbClickAction: TComboBox;
procedure ckUseSystemTrayIconClick(Sender: TObject);
PRIVATE
procedure PopulateAndSetClickAction(cbox: TComboBox; selectedAction: TSystemTrayClickAction);
function GetClickAction(cbox: TComboBox): TSystemTrayClickAction;
PROTECTED
procedure _ReadSettings(config: TMainSettings); OVERRIDE;
procedure _WriteSettings(config: TMainSettings); OVERRIDE;
PUBLIC
procedure Initialize(); OVERRIDE;
procedure EnableDisableControls(); OVERRIDE;
end;
implementation
{$R *.dfm}
uses
Math,
SDUGeneral;
procedure TfmeSystemTrayOptions.ckUseSystemTrayIconClick(Sender: TObject);
begin
inherited;
EnableDisableControls();
end;
procedure TfmeSystemTrayOptions.Initialize();
var
maxToIconCkBoxWidth: Integer;
maxgbWidth: Integer;
begin
// ckHotkeyDismount and ckHotkeyDismountEmerg have AutoSize := TRUE
// Use the autosized controls to determine how big the groupbox needs to be
maxToIconCkBoxWidth := max(ckMinToIcon.Width, ckCloseToIcon.Width);
maxgbWidth := 0;
maxgbWidth := max(maxgbWidth, (ckUseSystemTrayIcon.left * 2) +
ckUseSystemTrayIcon.Width);
maxgbWidth := max(maxgbWidth, (ckMinToIcon.left + maxToIconCkBoxWidth +
ckUseSystemTrayIcon.left));
maxgbWidth := max(maxgbWidth, (gbClickActions.left +
gbClickActions.Width + ckUseSystemTrayIcon.left));
gbSystemTrayIcon.Width := maxgbWidth;
SDUCenterControl(gbSystemTrayIcon, ccHorizontal);
SDUCenterControl(gbSystemTrayIcon, ccVertical, 25);
end;
procedure TfmeSystemTrayOptions.EnableDisableControls();
begin
inherited;
SDUEnableControl(ckMinToIcon, ckUseSystemTrayIcon.Checked);
SDUEnableControl(ckCloseToIcon, ckUseSystemTrayIcon.Checked);
SDUEnableControl(gbClickActions, ckUseSystemTrayIcon.Checked);
end;
procedure TfmeSystemTrayOptions._ReadSettings(config: TMainSettings);
begin
// System tray icon related...
ckUseSystemTrayIcon.Checked := config.OptSystemTrayIconDisplay;
ckMinToIcon.Checked := config.OptSystemTrayIconMinTo;
ckCloseToIcon.Checked := config.OptSystemTrayIconCloseTo;
if (config.OptSystemTrayIconActionSingleClick <> stcaDoNothing) then begin
rbSingleClick.Checked := True;
PopulateAndSetClickAction(cbClickAction, config.OptSystemTrayIconActionSingleClick);
end else begin
rbDoubleClick.Checked := True;
PopulateAndSetClickAction(cbClickAction, config.OptSystemTrayIconActionDoubleClick);
end;
end;
procedure TfmeSystemTrayOptions._WriteSettings(config: TMainSettings);
begin
// System tray icon related...
config.OptSystemTrayIconDisplay := ckUseSystemTrayIcon.Checked;
config.OptSystemTrayIconMinTo := ckMinToIcon.Checked;
config.OptSystemTrayIconCloseTo := ckCloseToIcon.Checked;
if rbSingleClick.Checked then begin
config.OptSystemTrayIconActionSingleClick := GetClickAction(cbClickAction);
config.OptSystemTrayIconActionDoubleClick := stcaDoNothing;
end else begin
config.OptSystemTrayIconActionSingleClick := stcaDoNothing;
config.OptSystemTrayIconActionDoubleClick := GetClickAction(cbClickAction);
end;
end;
procedure TfmeSystemTrayOptions.PopulateAndSetClickAction(cbox: TComboBox;
selectedAction: TSystemTrayClickAction);
var
stca: TSystemTrayClickAction;
idx: Integer;
useIdx: Integer;
begin
// Populate and set default store op dropdown
cbox.Items.Clear();
idx := -1;
useIdx := -1;
for stca := low(stca) to high(stca) do begin
Inc(idx);
cbox.Items.Add(SystemTrayClickActionTitle(stca));
if (selectedAction = stca) then begin
useIdx := idx;
end;
end;
cbox.ItemIndex := useIdx;
end;
function TfmeSystemTrayOptions.GetClickAction(cbox: TComboBox): TSystemTrayClickAction;
var
stca: TSystemTrayClickAction;
begin
Result := stcaDoNothing;
// Decode click action...
for stca := low(stca) to high(stca) do begin
if (SystemTrayClickActionTitle(stca) = cbox.Items[cbox.ItemIndex]) then begin
Result := stca;
break;
end;
end;
end;
end.
|
unit uInvoiceClasses;
interface
uses SysUtils, Classes, ADODB, Variants;
type
TInvoiceItemCommission = class
private
FSQLConnection: TADOConnection;
FIDSaleItemCommission: Integer;
FIDInventoryMov: Integer;
FIDPreInventoryMov: Integer;
FCommissionPercent: Double;
FIDCommission: Integer;
public
constructor Create(ASQLConnection: TADOConnection);
function CreateInvoiceItemCommission: Boolean;
function CreateIDSaleItemCommission: Integer;
property SQLConnection: TADOConnection read FSQLConnection write FSQLConnection;
property IDSaleItemCommission: Integer read FIDSaleItemCommission write FIDSaleItemCommission;
property IDPreInventoryMov: Integer read FIDPreInventoryMov write FIDPreInventoryMov;
property IDInventoryMov: Integer read FIDInventoryMov write FIDInventoryMov;
property IDCommission: Integer read FIDCommission write FIDCommission;
property CommissionPercent: Double read FCommissionPercent write FCommissionPercent;
end;
TInvoiceItemSerial = class
private
FSQLConnection: TADOConnection;
FIDInventoryMov: Integer;
FSerialNumber: String;
FIdentificationNumber: String;
FIDModel: Integer;
FIDStore: Integer;
FGiftTotal: Currency;
FGiftIDUser: Integer;
FIDPreSale: Integer;
FGiftCupom: String;
function CreateIDAccountCard: Integer;
public
constructor Create(ASQLConnection: TADOConnection);
function CreateInvoiceItemSerial: Boolean;
property SQLConnection: TADOConnection read FSQLConnection write FSQLConnection;
property IDInventoryMov: Integer read FIDInventoryMov write FIDInventoryMov;
property SerialNumber: String read FSerialNumber write FSerialNumber;
property IdentificationNumber: String read FIdentificationNumber write FIdentificationNumber;
property IDModel : Integer read FIDModel write FIDModel;
property IDStore : Integer read FIDStore write FIDStore;
property IDPreSale : Integer read FIDPreSale write FIDPreSale;
property GiftTotal : Currency read FGiftTotal write FGiftTotal;
property GiftIDUser : Integer read FGiftIDUser write FGiftIDUser;
property GiftCupom : String read FGiftCupom write FGiftCupom;
end;
TInvoiceItemPrice = class
private
FSQLConnection: TADOConnection;
FIDMovPrice: Integer;
FIDInventoryMov: Integer;
FIDDescriptionPrice: Integer;
FIDVendorPrice: Integer;
FSuggPrice: Currency;
public
constructor Create(ASQLConnection: TADOConnection);
function CreateInvoiceItemPrice: Boolean;
function CreateIDMovPrice: Integer;
property SQLConnection: TADOConnection read FSQLConnection write FSQLConnection;
property IDMovPrice: Integer read FIDMovPrice write FIDMovPrice;
property IDInventoryMov: Integer read FIDInventoryMov write FIDInventoryMov;
property IDDescriptionPrice: Integer read FIDDescriptionPrice write FIDDescriptionPrice;
property IDVendorPrice: Integer read FIDVendorPrice write FIDVendorPrice;
property SuggPrice: Currency read FSuggPrice write FSuggPrice;
end;
TInvoiceItemDocument = class
private
FSQLConnection: TADOConnection;
FIDMovDocument: Integer;
FIDInventoryMov: Integer;
FDocumentNumber: String;
FIDDocumentType: Integer;
FDocumentDate: TDateTime;
public
constructor Create(ASQLConnection: TADOConnection);
function CreateInvoiceItemDocument: Boolean;
function CreateIDMovDocument: Integer;
property SQLConnection: TADOConnection read FSQLConnection write FSQLConnection;
property IDMovDocument: Integer read FIDMovDocument write FIDMovDocument;
property IDInventoryMov: Integer read FIDInventoryMov write FIDInventoryMov;
property DocumentNumber: String read FDocumentNumber write FDocumentNumber;
property IDDocumentType: Integer read FIDDocumentType write FIDDocumentType;
property DocumentDate: TDateTime read FDocumentDate write FDocumentDate;
end;
TInvoiceItem = class
private
FCommssionList: TList;
FSerialNumberList: TList;
FSQLConnection: TADOConnection;
FIsPromo: Boolean;
FCostPrice: Currency;
FSalePrice: Currency;
FDiscount: Currency;
FQty: Double;
FIDComission: Integer;
FIDCustomer: Integer;
FIDModel: Integer;
FIDDepartment: Integer;
FIDPreSale: Integer;
FIDPreInvMovExchange: Integer;
FIDUser: Integer;
FIDInventoryMov: Integer;
FIDStore: Integer;
FMovDate: TDateTime;
FIDInvoice: Integer;
FAvgCost: Currency;
FDesiredMarkup: Double;
FIDParentPack: Integer;
FInvoiceCode: String;
FItemDocument: TInvoiceItemDocument;
FItemPrice: TInvoiceItemPrice;
FSaleCode: String;
FTotParcial: String;
FItemIndex: Integer;
FAcrescimo: Currency;
FIDCashRegister: Integer;
procedure SetValues;
function CreateIDInventoryMov: Integer;
function CreateTaxes: Boolean;
function CreatePricePayment: Boolean;
function GetAutoGeneratePrice: Boolean;
function CreateIDLancamento: Integer;
public
constructor Create(ASQLConnection: TADOConnection);
destructor Destroy; override;
function CreateInvoiceItem: Boolean; virtual;
property SQLConnection: TADOConnection read FSQLConnection write FSQLConnection;
property CommssionList: TList read FCommssionList write FCommssionList;
property SerialNumberList: TList read FSerialNumberList write FSerialNumberList;
property IDInventoryMov: Integer read FIDInventoryMov write FIDInventoryMov;
property IDPreSale: Integer read FIDPreSale write FIDPreSale;
property IDInvoice: Integer read FIDInvoice write FIDInvoice;
property InvoiceCode: String read FInvoiceCode write FInvoiceCode;
property IDCustomer: Integer read FIDCustomer write FIDCustomer;
property IDStore: Integer read FIDStore write FIDStore;
property IDUser: Integer read FIDUser write FIDUser;
property IDModel: Integer read FIDModel write FIDModel;
property IDCashRegister: Integer read FIDCashRegister write FIDCashRegister;
property IDComission: Integer read FIDComission write FIDComission;
property Qty: Double read FQty write FQty;
property SalePrice: Currency read FSalePrice write FSalePrice;
property CostPrice: Currency read FCostPrice write FCostPrice;
property Discount: Currency read FDiscount write FDiscount;
property Acrescimo: Currency read FAcrescimo write FAcrescimo;
property MovDate: TDateTime read FMovDate write FMovDate;
property IDPreInvMovExchange: Integer read FIDPreInvMovExchange write FIDPreInvMovExchange;
property IDDepartment: Integer read FIDDepartment write FIDDepartment;
property IsPromo: Boolean read FIsPromo write FIsPromo;
property IDParentPack: Integer read FIDParentPack write FIDParentPack;
property AvgCost: Currency read FAvgCost write FAvgCost;
property DesiredMarkup: Double read FDesiredMarkup write FDesiredMarkup;
property SaleCode: String read FSaleCode write FSaleCode;
property ItemDocument: TInvoiceItemDocument read FItemDocument write FItemDocument;
property ItemPrice: TInvoiceItemPrice read FItemPrice write FItemPrice;
property TotParcial: String read FTotParcial write FTotParcial;
property ItemIndex: Integer read FItemIndex write FItemIndex;
end;
TInvoiceRemovedItem = class(TInvoiceItem)
private
function CreateIDRemovedItem: Integer;
public
function CreateInvoiceItem: Boolean; override;
end;
TInvoicePayment = class
private
FSQLConnection: TADOConnection;
FIsPredatado: Boolean;
FPaymentValue: Currency;
FIDStore: Integer;
FIDUser: Integer;
FIDCustomer: Integer;
FIDMeioPag: Integer;
FIDCashRegMov: Integer;
FIDBankCheck: Integer;
FIDPreSale: Integer;
FPaymentPlace: Integer;
FCustomerPhone: String;
FParcela: String;
FAuthorization: String;
FOBS: String;
FCustomerName: String;
FCheckNumber: String;
FCustomerDocument: String;
FPreSaleDate: TDateTime;
FExpirationDate: TDateTime;
FIDInvoice: Integer;
public
constructor Create(ASQLConnection: TADOConnection);
function CreateInvoicePayment: Boolean;
property SQLConnection: TADOConnection read FSQLConnection write FSQLConnection;
property IDPreSale: Integer read FIDPreSale write FIDPreSale;
property IDInvoice: Integer read FIDInvoice write FIDInvoice;
property IDStore: Integer read FIDStore write FIDStore;
property IDUser: Integer read FIDUser write FIDUser;
property IDCustomer: Integer read FIDCustomer write FIDCustomer;
property IDMeioPag: Integer read FIDMeioPag write FIDMeioPag;
property IDCashRegMov: Integer read FIDCashRegMov write FIDCashRegMov;
property PreSaleDate: TDateTime read FPreSaleDate write FPreSaleDate;
property ExpirationDate: TDateTime read FExpirationDate write FExpirationDate;
property Parcela: String read FParcela write FParcela;
property Authorization: String read FAuthorization write FAuthorization;
property PaymentValue: Currency read FPaymentValue write FPaymentValue;
property CheckNumber: String read FCheckNumber write FCheckNumber;
property CustomerDocument: String read FCustomerDocument write FCustomerDocument;
property CustomerName: String read FCustomerName write FCustomerName;
property CustomerPhone: String read FCustomerPhone write FCustomerPhone;
property IDBankCheck: Integer read FIDBankCheck write FIDBankCheck;
property OBS: String read FOBS write FOBS;
property PaymentPlace: Integer read FPaymentPlace write FPaymentPlace;
property IsPredatado: Boolean read FIsPredatado write FIsPredatado;
end;
TInvoice = class
private
FItemList: TList;
FRemovedItemList: TList;
FPaymentList: TList;
FSQLConnection: TADOConnection;
FIDPreSale: Integer;
FPrintNotes: Boolean;
FIsLayaway: Boolean;
FIDStore: Integer;
FIDTouristGroup: Integer;
FIDCustomer: Integer;
FIDMedia: Integer;
FIDDeliverType: Integer;
FIDOtherComission: Integer;
FFirstName: String;
FZip: String;
FLastName: String;
FNote: String;
FPreSaleDate: TDateTime;
FPuppyTracker: Boolean;
FIDPreSaleParent: Integer;
FSaleCode: String;
FCOO: String;
FECFSerial: String;
FTaxExempt: Boolean;
FIDInvoice: Integer;
FInvoiceDate: TDateTime;
FCupomFiscal: String;
FInvoiceCode: String;
FCashReceived: Currency;
FIDCashRegMov: Integer;
FSubTotal: Currency;
FItemDiscount: Currency;
FInvoiceDiscount: Currency;
FScaleAdjust: Currency;
FCPFCGC: String;
procedure SetTotalValues;
procedure SetIDParentPack(APackIndex: Integer);
function ValidadePayment: Boolean;
function GetNewID(ATabela: String): Integer;
function GetNewInvoiceCode: String;
function AjustaPreco(Qtde, PrecoBalanca, PrecoUnit: real): Real;
function TruncarDecimal(Valor: Real; Decimal: integer): Double;
public
constructor Create(ASQLConnection: TADOConnection);
destructor Destroy; override;
function CreateInvoice: Boolean;
function AddInvoiceItem(AInvoiceItem: TInvoiceItem): Boolean;
function AddInvoiceRemovedItem(AInvoiceRemovedItem: TInvoiceRemovedItem): Boolean;
property SQLConnection: TADOConnection read FSQLConnection write FSQLConnection;
property ItemList: TList read FItemList write FItemList;
property RemovedItemList: TList read FRemovedItemList write FRemovedItemList;
property PaymentList: TList read FPaymentList write FPaymentList;
property IDPreSale: Integer read FIDPreSale write FIDPreSale;
property IDPreSaleParent: Integer read FIDPreSaleParent write FIDPreSaleParent;
property PreSaleDate: TDateTime read FPreSaleDate write FPreSaleDate;
property IDInvoice: Integer read FIDInvoice write FIDInvoice;
property InvoiceDate: TDateTime read FInvoiceDate write FInvoiceDate;
property IDCustomer: Integer read FIDCustomer write FIDCustomer;
property IDTouristGroup: Integer read FIDTouristGroup write FIDTouristGroup;
property IDMedia: Integer read FIDMedia write FIDMedia;
property IDDeliverType: Integer read FIDDeliverType write FIDDeliverType;
property IDOtherComission: Integer read FIDOtherComission write FIDOtherComission;
property FirstName: String read FFirstName write FFirstName;
property LastName: String read FLastName write FLastName;
property IsLayaway: Boolean read FIsLayaway write FIsLayaway;
property IDStore: Integer read FIDStore write FIDStore;
property Zip: String read FZip write FZip;
property Note: String read FNote write FNote;
property PrintNotes: Boolean read FPrintNotes write FPrintNotes;
property SaleCode: String read FSaleCode write FSaleCode;
property InvoiceCode: String read FInvoiceCode write FInvoiceCode;
property CupomFiscal: String read FCupomFiscal write FCupomFiscal;
property COO: String read FCOO write FCOO;
property PuppyTracker: Boolean read FPuppyTracker write FPuppyTracker;
property ECFSerial: String read FECFSerial write FECFSerial;
property TaxExempt: Boolean read FTaxExempt write FTaxExempt;
property CashReceived: Currency read FCashReceived write FCashReceived;
property IDCashRegMov: Integer read FIDCashRegMov write FIDCashRegMov;
property InvoiceDiscount: Currency read FInvoiceDiscount write FInvoiceDiscount;
property ItemDiscount: Currency read FItemDiscount write FItemDiscount;
property SubTotal: Currency read FSubTotal write FSubTotal;
property CPFCGC: String read FCPFCGC write FCPFCGC;
end;
implementation
uses DB, Math, uNumericFunctions;
{ TInvoiceItemCommission }
constructor TInvoiceItemCommission.Create(ASQLConnection: TADOConnection);
begin
FSQLConnection := ASQLConnection;
end;
function TInvoiceItemCommission.CreateIDSaleItemCommission: Integer;
begin
Result := -1;
with TADOStoredProc.Create(nil) do
try
Connection := FSQLConnection;
ProcedureName := 'sp_Sis_GetNextCode';
Parameters.Refresh;
Parameters.ParamByName('@Tabela').Value := 'SaleItemCommission.IDSaleItemCommission';
Parameters.ParamByName('@NovoCodigo').Value := 0;
ExecProc;
Result := Parameters.ParamByName('@NovoCodigo').Value;
finally
Free;
end;
end;
function TInvoiceItemCommission.CreateInvoiceItemCommission: Boolean;
begin
Result := False;
FIDSaleItemCommission := CreateIDSaleItemCommission;
if FIDSaleItemCommission = -1 then
raise Exception.Create('Erro ao gerar IDSaleItemCommission.');
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'INSERT INTO SaleItemCommission (IDSaleItemCommission, IDInventoryMov, IDCommission, CommissionPercent) ' +
'VALUES (:IDSaleItemCommission, :IDInventoryMov, :IDComission, :CommissionPercent)';
Parameters.ParamByName('IDSaleItemCommission').Value := FIDSaleItemCommission;
Parameters.ParamByName('IDInventoryMov').Value := FIDInventoryMov;
Parameters.ParamByName('IDComission').Value := FIDCommission;
Parameters.ParamByName('CommissionPercent').Value := FCommissionPercent;
Execute;
Result := True;
finally
Free;
end;
end;
{ TInvoice }
constructor TInvoice.Create(ASQLConnection: TADOConnection);
begin
FSQLConnection := ASQLConnection;
FItemList := TList.Create;
FPaymentList := TList.Create;
FRemovedItemList := TList.Create;
end;
function TInvoice.GetNewID(ATabela: String): Integer;
begin
Result := -1;
with TADOStoredProc.Create(nil) do
try
Connection := FSQLConnection;
ProcedureName := 'sp_Sis_GetNextCode';
Parameters.Refresh;
Parameters.ParamByName('@Tabela').Value := ATabela;
Parameters.ParamByName('@NovoCodigo').Value := 0;
ExecProc;
Result := Parameters.ParamByName('@NovoCodigo').Value;
finally
Free;
end;
end;
function TInvoice.CreateInvoice: Boolean;
var
i: Integer;
begin
Result := False;
FIDPreSale := GetNewID('Invoice.IDPresale');
if FIDPreSale = -1 then
raise Exception.Create('Erro ao gerar IDPreSale.');
FIDInvoice := GetNewID('InvoiceGen.IDInvoice');
if FIDInvoice = -1 then
raise Exception.Create('Erro ao gerar IDInvoice.');
if FInvoiceCode = '' then
FInvoiceCode := GetNewInvoiceCode;
if FInvoiceCode = '-1' then
raise Exception.Create('Erro ao gerar InvoiceCode.');
SetTotalValues;
if not ValidadePayment then
raise Exception.Create('Valor da nota é diferente do total de pagamentos.');
if (FCOO = '') or (FCOO = 'XXXXXX') then
begin
FCupomFiscal := '';
FECFSerial := '';
end
else
begin
FSaleCode := FCOO;
FCupomFiscal := FCOO;
end;
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'INSERT INTO Invoice (IDPreSale, IDInvoice, IDCustomer, IDTouristGroup, PreSaleDate, CupomFiscal, Tax, ItemDiscount, ' +
'InvoiceDate, MediaID, DeliverTypeID, OtherComissionID, FirstName, LastName, TaxIsent, CashReceived, CashRegMovID, ' +
'Layaway, IDStore, Zip, Note, PrintNotes, PuppyTracker, SaleCode, NumeroSeriePrinter, InvoiceCode, SubTotal, InvoiceDiscount) ' +
'VALUES (:IDPreSale, :IDInvoice, :IDCustomer, :IDTouristGroup, :PreSaleDate, :CupomFiscal, :Tax, :ItemDiscount, ' +
':InvoiceDate, :MediaID, :DeliverTypeID, :IDOtherCommission, :FirstName, :LastName, :TaxIsent, :CashReceived, :CashRegMovID, ' +
':Layaway, :IDStore, :Zip, :Note, :PrintNotes, :PuppyTracker, :SaleCode, :NumeroSeriePrinter, :InvoiceCode, :SubTotal, :InvoiceDiscount)';
Parameters.ParambyName('IDPreSale').Value := FIDPreSale;
Parameters.ParambyName('PreSaleDate').Value := FPreSaleDate;
Parameters.ParambyName('IDInvoice').Value := FIDInvoice;
Parameters.ParambyName('InvoiceDate').Value := FInvoiceDate;
Parameters.ParambyName('DeliverTypeID').Value := FIDDeliverType;
Parameters.ParambyName('Layaway').Value := FIsLayaway;
Parameters.ParambyName('IDStore').Value := FIDStore;
Parameters.ParambyName('FirstName').Value := Copy(FFirstName, 1, 20);
Parameters.ParambyName('LastName').Value := Copy(FLastName, 1, 20);
Parameters.ParambyName('ZIP').Value := FZip;
Parameters.ParambyName('IDCustomer').Value := FIDCustomer;
Parameters.ParambyName('MediaID').Value := FIDMedia;
Parameters.ParambyName('SaleCode').Value := FSaleCode;
Parameters.ParambyName('InvoiceCode').Value := FInvoiceCode;
Parameters.ParambyName('PuppyTracker').Value := FPuppyTracker;
Parameters.ParambyName('Tax').Value := 0;
Parameters.ParambyName('TaxIsent').Value := FTaxExempt;
Parameters.ParambyName('CashReceived').Value := FCashReceived;
Parameters.ParambyName('CashRegMovID').Value := FIDCashRegMov;
Parameters.ParambyName('SubTotal').Value := FSubTotal;
Parameters.ParambyName('ItemDiscount').Value := FItemDiscount;
Parameters.ParambyName('InvoiceDiscount').Value := FInvoiceDiscount;
if FCupomFiscal = '' then
Parameters.ParambyName('CupomFiscal').Value := NULL
else
Parameters.ParambyName('CupomFiscal').Value := FCupomFiscal;
if FECFSerial = '' then
Parameters.ParambyName('NumeroSeriePrinter').Value := NULL
else
Parameters.ParambyName('NumeroSeriePrinter').Value := FECFSerial;
if FIDOtherComission = 0 then
Parameters.ParambyName('IDOtherCommission').Value := Null
else
Parameters.ParambyName('IDOtherCommission').Value := FIDOtherComission;
if FIDTouristGroup = 0 then
Parameters.ParambyName('IDTouristGroup').Value := Null
else
Parameters.ParambyName('IDTouristGroup').Value := FIDTouristGroup;
if FNote = '' then
begin
Parameters.ParambyName('Note').Value := Null;
Parameters.ParambyName('PrintNotes').Value := False;
end
else
begin
Parameters.ParambyName('Note').Value := FNote;
Parameters.ParambyName('PrintNotes').Value := True;
end;
Execute;
finally
Free;
end;
for i := 0 to Pred(FItemList.Count) do
begin
TInvoiceItem(FItemList[i]).IDPreSale := FIDPreSale;
TInvoiceItem(FItemList[i]).IDInvoice := FIDInvoice;
TInvoiceItem(FItemList[i]).InvoiceCode := FInvoiceCode;
TInvoiceItem(FItemList[i]).SaleCode := FSaleCode;
TInvoiceItem(FItemList[i]).IDCustomer := FIDCustomer;
if not TInvoiceItem(FItemList[i]).CreateInvoiceItem then
begin
Result := False;
Exit;
end;
SetIDParentPack(i);
end;
for i := 0 to Pred(FRemovedItemList.Count) do
begin
TInvoiceRemovedItem(FRemovedItemList[i]).IDPreSale := FIDPreSale;
TInvoiceRemovedItem(FRemovedItemList[i]).IDInvoice := FIDInvoice;
TInvoiceRemovedItem(FRemovedItemList[i]).InvoiceCode := FInvoiceCode;
TInvoiceRemovedItem(FRemovedItemList[i]).SaleCode := FSaleCode;
TInvoiceRemovedItem(FRemovedItemList[i]).IDCustomer := FIDCustomer;
if not TInvoiceRemovedItem(FRemovedItemList[i]).CreateInvoiceItem then
begin
Result := False;
Exit;
end;
end;
for i := 0 to Pred(FPaymentList.Count) do
begin
TInvoicePayment(FPaymentList[i]).IDPreSale := FIDPreSale;
TInvoicePayment(FPaymentList[i]).IDInvoice := FIDInvoice;
TInvoicePayment(FPaymentList[i]).IDCustomer := FIDCustomer;
if not TInvoicePayment(FPaymentList[i]).CreateInvoicePayment then
begin
Result := False;
Exit;
end;
end;
Result := True;
end;
destructor TInvoice.Destroy;
begin
FreeAndNil(FItemList);
FreeAndNil(FPaymentList);
FreeAndNil(FRemovedItemList);
inherited;
end;
function TInvoice.GetNewInvoiceCode: String;
begin
Result := '-1';
with TADOStoredProc.Create(nil) do
try
Connection := FSQLConnection;
ProcedureName := 'SP_PreSale_GetNewInvoiceCode';
Parameters.Refresh;
Parameters.ParamByName('@IDStore').Value := FIDStore;
Parameters.ParamByName('@InvoiceCode').Value := 0;
ExecProc;
Result := Parameters.ParamByName('@InvoiceCode').Value;
finally
Free;
end;
end;
procedure TInvoice.SetTotalValues;
var
i: Integer;
fPrice : Real;
begin
FItemDiscount := 0;
FSubTotal := 0;
FScaleAdjust := 0;
for i := 0 to Pred(FItemList.Count) do
begin
FItemDiscount := FItemDiscount + TInvoiceItem(FItemList[i]).Discount;
fPrice := AjustaPreco(TInvoiceItem(FItemList[i]).Qty, (TInvoiceItem(FItemList[i]).SalePrice * TInvoiceItem(FItemList[i]).Qty), TInvoiceItem(FItemList[i]).SalePrice);
FSubTotal := FSubTotal + fPrice;
if fPrice > 0 then
FScaleAdjust := FScaleAdjust + fPrice - (TruncMoney(TInvoiceItem(FItemList[i]).SalePrice * TInvoiceItem(FItemList[i]).Qty, 2));
end;
end;
function TInvoice.ValidadePayment: Boolean;
var
i: Integer;
dTotalPayment: Currency;
begin
dTotalPayment := 0;
for i := 0 to Pred(FPaymentList.Count) do
dTotalPayment := dTotalPayment + TInvoicePayment(FPaymentList[i]).PaymentValue;
if (FInvoiceDiscount <> 0) and (FScaleAdjust <> 0) then
FInvoiceDiscount := (FInvoiceDiscount - ABS(FScaleAdjust));
Result := (FSubTotal - FInvoiceDiscount - FItemDiscount) = dTotalPayment;
//Bacalhau para resolver proplemas de centavos das vendas granel
if not Result then
if ABS((FSubTotal - FInvoiceDiscount - FItemDiscount) - dTotalPayment) = 0.01 then
Result := True;
end;
function TInvoice.AddInvoiceItem(AInvoiceItem: TInvoiceItem): Boolean;
var
iPackIndex: Integer;
InvoiceItemPack: TInvoiceItem;
InvoiceItemPackCommission: TInvoiceItemCommission;
begin
iPackIndex := FItemList.Add(AInvoiceItem);
with TADODataSet.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'SELECT M.IDModel, P.Qty, M.FinalCost ' +
'FROM dbo.PackModel P JOIN dbo.Model M ON (P.IDModel= M.IDModel) ' +
'WHERE P.IDPackModel = :IDModel';
Parameters.ParamByName('IDModel').Value := AInvoiceItem.IDModel;
Open;
while not Eof do
begin
InvoiceItemPack := TInvoiceItem.Create(FSQLConnection);
InvoiceItemPackCommission := TInvoiceItemCommission.Create(FSQLConnection);
InvoiceItemPack.IDCustomer := AInvoiceItem.IDCustomer;
InvoiceItemPack.IDPreSale := AInvoiceItem.IDPreSale;
InvoiceItemPack.IDModel := FieldByName('IDModel').AsInteger;
InvoiceItemPack.IDStore := AInvoiceItem.IDStore;
InvoiceItemPack.Qty := AInvoiceItem.Qty * FieldByName('Qty').AsFloat;
InvoiceItemPack.Discount := 0;
InvoiceItemPack.SalePrice := 0;
InvoiceItemPack.CostPrice := FieldByName('FinalCost').AsCurrency;
InvoiceItemPack.IDUser := AInvoiceItem.IDUser;
InvoiceItemPack.IDComission := AInvoiceItem.IDComission;
InvoiceItemPack.MovDate := AInvoiceItem.MovDate;
InvoiceItemPack.IsPromo := AInvoiceItem.IsPromo;
InvoiceItemPack.IDDepartment := AInvoiceItem.IDDepartment;
InvoiceItemPack.IDParentPack := iPackIndex+1;
InvoiceItemPackCommission.IDCommission := AInvoiceItem.IDComission;
InvoiceItemPackCommission.CommissionPercent := 100;
InvoiceItemPack.CommssionList.Add(InvoiceItemPackCommission);
FItemList.Add(InvoiceItemPack);
Next;
end;
Close;
finally
Free;
end;
end;
procedure TInvoice.SetIDParentPack(APackIndex: Integer);
var
i: Integer;
begin
for i := 0 to Pred(FItemList.Count) do
if TInvoiceItem(FItemList[i]).IDParentPack = (APackIndex+1) then
TInvoiceItem(FItemList[i]).IDParentPack := TInvoiceItem(FItemList[APackIndex]).IDInventoryMov;
end;
function TInvoice.AjustaPreco(Qtde, PrecoBalanca, PrecoUnit: real): Real;
var
PrecoECF, QtdeECF: real;
sQTD: String;
begin
sQTD := FormatFloat('0000.000', Qtde);
if Qtde > 0 then
begin
QtdeECF := TruncarDecimal(StrToFloat(sQTD), 3);
Qtde := TruncarDecimal(Qtde, 3);
end
else
QtdeECF := Qtde;
if QtdeECF <> Qtde then
PrecoECF := QtdeECF * PrecoUnit
else
PrecoECF := Qtde * PrecoUnit;
if Qtde > 0 then
PrecoECF := TruncarDecimal(PrecoECF, 2)
else
begin
PrecoECF := PrecoECF * -1;
PrecoECF := TruncarDecimal(PrecoECF, 2);
PrecoECF := PrecoECF * -1;
end;
if PrecoBalanca <> PrecoECF then
Result := PrecoECF
else
Result := PrecoBalanca;
end;
function TInvoice.TruncarDecimal(Valor: Real; Decimal: integer): Double;
var
aux: string;
begin
valor := valor * 100000;
aux := FormatFloat('00000000000000000000',valor);
aux := copy( aux, 1, 15) + copy( aux, 16, Decimal);
case Decimal of
2: valor := strToFloat(aux) / 100;
3: valor := strToFloat(aux) / 1000;
4: valor := strToFloat(aux) / 10000;
5: valor := strToFloat(aux) / 100000;
end;
result := Valor;
end;
function TInvoice.AddInvoiceRemovedItem(
AInvoiceRemovedItem: TInvoiceRemovedItem): Boolean;
begin
FRemovedItemList.Add(AInvoiceRemovedItem);
end;
{ TInvoiceItem }
constructor TInvoiceItem.Create(ASQLConnection: TADOConnection);
begin
FSQLConnection := ASQLConnection;
FCommssionList := TList.Create;
FSerialNumberList := TList.Create;
end;
function TInvoiceItem.CreateIDInventoryMov: Integer;
begin
Result := -1;
with TADOStoredProc.Create(nil) do
try
Connection := FSQLConnection;
ProcedureName := 'sp_Sis_GetNextCode';
Parameters.Refresh;
Parameters.ParamByName('@Tabela').Value := 'InventoryMov.IDInventoryMov';
Parameters.ParamByName('@NovoCodigo').Value := 0;
ExecProc;
Result := Parameters.ParamByName('@NovoCodigo').Value;
finally
Free;
end;
end;
function TInvoiceItem.CreateIDLancamento: Integer;
begin
Result := -1;
with TADOStoredProc.Create(nil) do
try
Connection := FSQLConnection;
ProcedureName := 'sp_Sis_GetNextCode';
Parameters.Refresh;
Parameters.ParamByName('@Tabela').Value := 'Fin_Lancamento.IDLancamento';
Parameters.ParamByName('@NovoCodigo').Value := 0;
ExecProc;
Result := Parameters.ParamByName('@NovoCodigo').Value;
finally
Free;
end;
end;
function TInvoiceItem.CreateInvoiceItem: Boolean;
var
i: Integer;
begin
Result := False;
FIDInventoryMov := CreateIDInventoryMov;
if FIDInventoryMov = -1 then
raise Exception.Create('Erro ao gerar IDInventoryMov.');
SetValues;
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'INSERT InventoryMov (IDInventoryMov, InventMovTypeID, DocumentID, ' +
'IDPessoa, StoreID, ModelID, BarCodeID, MovDate, Qty, CostPrice, SalePrice, ' +
'Discount, IDUser, SalesTax, IDParentPack, QtyExchanged, ' +
'IDPreInvMovExchange, AvgCost, DesiredMarkup, IDDepartment, Promo, SequencyNum) ' +
'VALUES (:IDInventoryMov, :InventMovTypeID, :DocumentID, :IDPessoa, :StoreID, ' +
':ModelID, :BarCodeID, :MovDate, :Qty, :CostPrice, :SalePrice, :Discount, ' +
':IDUser, :SalesTax, :IDParentPack, :QtyExchanged, ' +
':IDPreInvMovExchange, :AvgCost, :DesiredMarkup, :IDDepartment, :Promo, :SequencyNum)';
Parameters.ParamByName('IDInventoryMov').Value := FIDInventoryMov;
Parameters.ParamByName('InventMovTypeID').Value := 1;
Parameters.ParamByName('DocumentID').Value := FIDInvoice;
Parameters.ParamByName('IDPessoa').Value := FIDCustomer;
Parameters.ParamByName('StoreID').Value := FIDStore;
Parameters.ParamByName('ModelID').Value := FIDModel;
Parameters.ParamByName('MovDate').Value := FMovDate;
Parameters.ParamByName('Qty').Value := FQty;
Parameters.ParamByName('CostPrice').Value := FCostPrice;
Parameters.ParamByName('SalePrice').Value := FSalePrice;
Parameters.ParamByName('Discount').Value := FDiscount;
Parameters.ParamByName('IDUser').Value := FIDUser;
Parameters.ParamByName('IDDepartment').Value := FIDDepartment;
Parameters.ParamByName('Promo').Value := FIsPromo;
Parameters.ParamByName('DesiredMarkup').Value := FDesiredMarkup;
Parameters.ParamByName('AvgCost').Value := FAvgCost;
Parameters.ParamByName('SequencyNum').Value := FItemIndex;
if FIDParentPack = 0 then
Parameters.ParamByName('IDParentPack').Value := NULL
else
Parameters.ParamByName('IDParentPack').Value := FIDParentPack;
Execute;
finally
Free;
end;
if FTotParcial <> '' then
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'INSERT Inv_MovComplement (IDInventoryMov, TotalizadorParcial, IDMovReason) ' +
'VALUES (:IDInventoryMov, :TotalizadorParcial, 1)';
Parameters.ParamByName('IDInventoryMov').Value := FIDInventoryMov;
Parameters.ParamByName('TotalizadorParcial').Value := FTotParcial;
Execute;
finally
Free;
end;
for i := 0 to Pred(FCommssionList.Count) do
begin
TInvoiceItemCommission(FCommssionList[i]).IDInventoryMov := FIDInventoryMov;
if not TInvoiceItemCommission(FCommssionList[i]).CreateInvoiceItemCommission then
begin
Result := False;
Exit;
end;
end;
for i := 0 to Pred(FSerialNumberList.Count) do
begin
TInvoiceItemSerial(FSerialNumberList[i]).IDInventoryMov := FIDInventoryMov;
TInvoiceItemSerial(FSerialNumberList[i]).IDPreSale := FIDPreSale;
TInvoiceItemSerial(FSerialNumberList[i]).GiftCupom := FSaleCode;
if not TInvoiceItemSerial(FSerialNumberList[i]).CreateInvoiceItemSerial then
begin
Result := False;
Exit;
end;
end;
if Assigned(FItemPrice) then
if FItemPrice.IDDescriptionPrice <> 0 then
begin
FItemPrice.IDInventoryMov := FIDInventoryMov;
if not FItemPrice.CreateInvoiceItemPrice then
begin
Result := False;
Exit;
end;
if GetAutoGeneratePrice and ((FItemPrice.SuggPrice - FSalePrice) > 0) then
if not CreatePricePayment then
raise Exception.Create('Erro ao gerar contas a receber de PRICE.');
end;
if Assigned(FItemDocument) then
if FItemDocument.DocumentNumber <> '' then
begin
FItemDocument.IDInventoryMov := FIDInventoryMov;
FItemDocument.DocumentDate := FMovDate;
if not FItemDocument.CreateInvoiceItemDocument then
begin
Result := False;
Exit;
end;
end;
if not CreateTaxes then
raise Exception.Create('Erro ao gerar encargos e impostos.');
Result := True;
end;
function TInvoiceItem.CreatePricePayment: Boolean;
var
iIDMovPrice,
iIDLancamentoTipo,
iIDDocumentoTipo,
iIDPagamentoTipo,
iDiasVencimento,
iIDVendorType,
iIDCentroCusto,
iIDContaCorrente,
iIDEmpresa,
iIDLancamento: Integer;
begin
with TADODataSet.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'SELECT CAST(PropertyValue AS INT) IDLancamentoTipo FROM Sis_PropertyDomain WHERE Property = ' + QuotedStr('PriceRecordType');
Open;
iIDLancamentoTipo := FieldByName('IDLancamentoTipo').AsInteger;
Close;
CommandText := 'SELECT CAST(PropertyValue AS INT) IDDocumentoTipo FROM Sis_PropertyDomain WHERE Property = ' + QuotedStr('PriceDocumentType');
Open;
iIDDocumentoTipo := FieldByName('IDDocumentoTipo').AsInteger;
Close;
CommandText := 'SELECT CAST(PropertyValue AS INT) IDPagamentoTipo FROM Sis_PropertyDomain WHERE Property = ' + QuotedStr('PricePaymentType');
Open;
iIDPagamentoTipo := FieldByName('IDPagamentoTipo').AsInteger;
Close;
CommandText := 'SELECT CAST(PropertyValue AS INT) DiasVencimento FROM Sis_PropertyDomain WHERE Property = ' + QuotedStr('PriceDueDateDays');
Open;
iDiasVencimento := FieldByName('DiasVencimento').AsInteger;
Close;
CommandText := 'SELECT IDTipoPessoaRoot FROM Pessoa WHERE IDPessoa = ' + IntToStr(FItemPrice.FIDVendorPrice);
Open;
iIDVendorType := FieldByName('IDTipoPessoaRoot').AsInteger;
Close;
CommandText := 'SELECT S.IDCentroCusto, MPS.IDContaCorrente, S.IDEmpresa ' +
'FROM Store S JOIN MeioPagToStore MPS ON (S.IDStore = MPS.IDStore) ' +
'WHERE S.IDStore = ' + IntToStr(FIDStore) + ' AND MPS.IDMeioPag = ' + IntToStr(iIDPagamentoTipo);
Open;
iIDCentroCusto := FieldByName('IDCentroCusto').AsInteger;
iIDContaCorrente := FieldByName('IDContaCorrente').AsInteger;
iIDEmpresa := FieldByName('IDEmpresa').AsInteger;
Close;
finally
Free;
end;
iIDLancamento := CreateIDLancamento;
if iIDLancamento = -1 then
raise Exception.Create('Erro ao gerar IDLancamento.');
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'INSERT INTO Fin_Lancamento (IDLancamento, IDPessoa, IDPessoaTipo, IDUsuarioLancamento, IDEmpresa, ' +
'DataLancamento, DataVencimento, ValorNominal, Pagando, NumDocumento, IDCentroCusto, ' +
'IDContaCorrentePrevista, IDQuitacaoMeioPrevisto, IDLancamentoTipo, IDDocumentoTipo, Situacao) ' +
'VALUES (:IDLancamento, :IDVendorPrice, :IDVendorType, :IDUser, :IDEmpresa, :MovDate, ' +
'DATEADD(DAY, :DiasVencimento, :MovDate2), :ValorNominal, 0, :InvoiceCode, ' +
':IDCentroCusto, :IDContaCorrente, :IDPagamentoTipo, :IDLancamentoTipo, :IDDocumentoTipo, 1)';
Parameters.ParamByName('IDLancamento').Value := iIDLancamento;
Parameters.ParamByName('IDVendorPrice').Value := FItemPrice.FIDVendorPrice;
Parameters.ParamByName('IDVendorType').Value := iIDVendorType;
Parameters.ParamByName('IDUser').Value := FIDUser;
Parameters.ParamByName('IDEmpresa').Value := iIDEmpresa;
Parameters.ParamByName('MovDate').Value := FMovDate;
Parameters.ParamByName('DiasVencimento').Value := iDiasVencimento;
Parameters.ParamByName('MovDate2').Value := FMovDate;
Parameters.ParamByName('ValorNominal').Value := FItemPrice.FSuggPrice - FSalePrice;
Parameters.ParamByName('InvoiceCode').Value := FInvoiceCode;
Parameters.ParamByName('IDCentroCusto').Value := iIDCentroCusto;
Parameters.ParamByName('IDContaCorrente').Value := iIDContaCorrente;
Parameters.ParamByName('IDPagamentoTipo').Value := iIDPagamentoTipo;
Parameters.ParamByName('IDLancamentoTipo').Value := iIDLancamentoTipo;
Parameters.ParamByName('IDDocumentoTipo').Value := iIDDocumentoTipo;
Execute;
finally
Free;
end;
Result := True;
end;
function TInvoiceItem.CreateTaxes: Boolean;
begin
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
//Insert Encargos de Venda na tabela de Taxas InventoryMovTax
CommandText := 'INSERT INTO InventoryMovTax ( IDInventoryMov, IDTaxCategory, Tax, TaxValue) ' +
'SELECT ' +
' IM.IDInventoryMov, ' +
' ISNULL (TCC.IDTaxCategory,0) AS IDTaxCategory, ' +
' ISNULL (TCC.Tax,0)/100 AS Tax, ' +
' ISNULL (((IM.SalePrice * IM.Qty) - IM.Discount) * TCC.Tax,0)/100 AS TaxValue ' +
'FROM InventoryMov IM ' +
' JOIN Model Mo ON (IM.ModelID = Mo.IDModel) ' +
' JOIN StoreToTabGroup SG ON (SG.IDStore = IM.StoreID AND SG.IDGroup = Mo.GroupID ) ' +
' JOIN TaxCategory TCP ON (TCP.IDTaxCategory = SG.IDTaxCategory) ' +
' JOIN TaxCategory TCC ON (SG.IDTaxCategory = TCC.IDTaxCategoryParent) ' +
'WHERE ' +
' IM.IDInventoryMov = :IDInventoryMov';
Parameters.ParamByName('IDInventoryMov').Value := FIDInventoryMov;
Execute;
//Insert Impostos de Venda na tabela de Taxas InventoryMovTax
CommandText := 'INSERT INTO InventoryMovTax (IDInventoryMov, IDTaxCategory, Tax, TaxValue) ' +
'SELECT ' +
' IM.IDInventoryMov, ' +
' ISNULL (TC.IDTaxCategory,0) AS IDTaxCategory, ' +
' ISNULL (TC.Tax,0)/100 AS Tax, ' +
' ISNULL (((IM.SalePrice * IM.Qty) - IM.Discount) * TC.Tax,0)/100 AS TaxValue ' +
'FROM InventoryMov IM ' +
' JOIN Model Mo ON (IM.ModelID = Mo.IDModel) ' +
' JOIN StoreToTabGroup SG ON (SG.IDStore = IM.StoreID AND SG.IDGroup = Mo.GroupID ) ' +
' JOIN TaxCategory TC ON (SG.IDSaleTax = TC.IDTaxCategory) ' +
'WHERE ' +
' IM.IDInventoryMov = :IDInventoryMov';
Parameters.ParamByName('IDInventoryMov').Value := FIDInventoryMov;
Execute;
Result := True;
finally
Free;
end;
end;
destructor TInvoiceItem.Destroy;
var
IIC : TInvoiceItemCommission;
IIS : TInvoiceItemSerial;
begin
while FCommssionList.Count <> 0 do
begin
if FCommssionList[0] <> nil then
begin
IIC := TInvoiceItemCommission(FCommssionList[0]);
FreeAndNil(IIC);
end;
FCommssionList.Delete(0);
end;
while FSerialNumberList.Count <> 0 do
begin
if FSerialNumberList[0] <> nil then
begin
IIS := TInvoiceItemSerial(FSerialNumberList[0]);
FreeAndNil(IIS);
end;
FSerialNumberList.Delete(0);
end;
FreeAndNil(FCommssionList);
FreeAndNil(FSerialNumberList);
if Assigned(FItemDocument) then
FreeAndNil(FItemDocument);
inherited;
end;
function TInvoiceItem.GetAutoGeneratePrice: Boolean;
begin
with TADODataSet.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'SELECT SrvValue ' +
'FROM Param ' +
'WHERE IDParam = 97';
Open;
Result := StrToBool(FieldByName('SrvValue').Value);
Close
finally
Free;
end;
end;
procedure TInvoiceItem.SetValues;
begin
with TADODataSet.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'SELECT M.AvgCost, TG.DesiredMarkup ' +
'FROM Model M JOIN TabGroup TG ON (M.GroupID = TG.IDGroup) ' +
'WHERE M.IDModel = :IDModel';
Parameters.ParamByName('IDModel').Value := FIDModel;
Open;
FDesiredMarkup := FieldByName('DesiredMarkup').AsFloat;
FAvgCost := FieldByName('AvgCost').AsCurrency;
Close
finally
Free;
end;
end;
{ TInvoicePayment }
constructor TInvoicePayment.Create(ASQLConnection: TADOConnection);
begin
FSQLConnection := ASQLConnection;
end;
function TInvoicePayment.CreateInvoicePayment: Boolean;
begin
Result := False;
with TADOStoredProc.Create(nil) do
try
Connection := FSQLConnection;
ProcedureName := 'sp_PreSale_AddParcela';
Parameters.Refresh;
Parameters.ParambyName('@PreSaleID').Value := FIDPreSale;
Parameters.ParambyName('@IDStore').Value := FIDStore;
Parameters.ParambyName('@IDUser').Value := FIDUser;
Parameters.ParambyName('@IDCliente').Value := FIDCustomer;
Parameters.ParambyName('@IDMeioPag').Value := FIDMeioPag;
Parameters.ParambyName('@IDCashRegMov').Value := FIDCashRegMov;
Parameters.ParambyName('@PreSaleDate').Value := FPreSaleDate;
Parameters.ParambyName('@ExpirationDate').Value := FExpirationDate;
Parameters.ParambyName('@Value').Value := FPaymentValue;
Parameters.ParambyName('@Parcela').Value := FParcela;
Parameters.ParambyName('@PaymentPlace').Value := FPaymentPlace;
Parameters.ParambyName('@IsPredatado').Value := FIsPredatado;
if FAuthorization <> '' then
Parameters.ParambyName('@Authorization').Value := FAuthorization
else
Parameters.ParambyName('@Authorization').Value := Null;
if FCheckNumber <> '' then
Parameters.ParambyName('@CheckNumber').Value := FCheckNumber
else
Parameters.ParambyName('@CheckNumber').Value := Null;
if FCustomerDocument <> '' then
Parameters.ParambyName('@CustomerDocument').Value := FCustomerDocument
else
Parameters.ParambyName('@CustomerDocument').Value := Null;
if FCustomerName <> '' then
Parameters.ParambyName('@CustomerName').Value := FCustomerName
else
Parameters.ParambyName('@CustomerName').Value := Null;
if FCustomerPhone <> '' then
Parameters.ParambyName('@CustomerPhone').Value := FCustomerPhone
else
Parameters.ParambyName('@CustomerPhone').Value := Null;
if FIDBankCheck <> 0 then
Parameters.ParambyName('@IDBankCheck').Value := FIDBankCheck
else
Parameters.ParambyName('@IDBankCheck').Value := Null;
if FOBS <> '' then
Parameters.ParambyName('@OBS').Value := FOBS
else
Parameters.ParambyName('@OBS').Value := Null;
ExecProc;
if Parameters.ParamByName('@RETURN_VALUE').Value <> 0 then
raise Exception.Create('SQL (POS) %S : ' + Format('Stored Procedure %S Error %S', [ProcedureName, VarToStr(Parameters.ParamByName('@RETURN_VALUE').Value)]));
finally
Free;
end;
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'UPDATE Fin_Lancamento SET NumDocumento = :NumDocumento, DataEmissao = :DataEmissao, Previsao = 0 WHERE IDPreSale = :IDPreSale';
Parameters.ParamByName('IDPreSale').Value := FIDPreSale;
Parameters.ParamByName('NumDocumento').Value := IntToStr(FIDInvoice);
Parameters.ParamByName('DataEmissao').Value := FPreSaleDate;
Execute;
finally
Free;
end;
Result := True;
end;
{ TInvoiceItemSerial }
constructor TInvoiceItemSerial.Create(ASQLConnection: TADOConnection);
begin
FSQLConnection := ASQLConnection;
end;
function TInvoiceItemSerial.CreateIDAccountCard: Integer;
begin
Result := -1;
with TADOStoredProc.Create(nil) do
try
Connection := FSQLConnection;
ProcedureName := 'sp_Sis_GetNextCode';
Parameters.Refresh;
Parameters.ParamByName('@Tabela').Value := 'Sal_AccountCard.IDAccountCard';
Parameters.ParamByName('@NovoCodigo').Value := 0;
ExecProc;
Result := Parameters.ParamByName('@NovoCodigo').Value;
finally
Free;
end;
end;
function TInvoiceItemSerial.CreateInvoiceItemSerial: Boolean;
begin
Result := False;
with TADODataSet.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'SELECT M.IDModel ' +
'FROM Model M ' +
'WHERE M.IDModel = :IDModel AND M.ModelType = :ModelType ';
Parameters.ParamByName('IDModel').Value := FIDModel;
Parameters.ParamByName('ModelType').Value := 'G';
Open;
if (not IsEmpty) then
begin
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'INSERT Sal_AccountCard (IDAccountCard, CardNumber, CardDate, IDPreInventoryMov, IDUser, Amount, ExpirationDate) ' +
' VALUES (:IDAccountCard, :CardNumber, :CardDate, :IDPreInventoryMov, :IDUser, 0, :ExpirationDate)';
Parameters.ParamByName('IDAccountCard').Value := CreateIDAccountCard;
Parameters.ParamByName('CardNumber').Value := FSerialNumber;
Parameters.ParamByName('CardDate').Value := Now;
Parameters.ParamByName('IDPreInventoryMov').Value := Null;
Parameters.ParamByName('IDUser').Value := FGiftIDUser;
Parameters.ParamByName('ExpirationDate').Value := Null;
Execute;
finally
Free;
end;
with TADOStoredProc.Create(nil) do
try
Connection := FSQLConnection;
ProcedureName := 'sp_Sal_AccountCard_AddAmount';
Parameters.Refresh;
Parameters.ParamByName('@CardNumber').Value := FSerialNumber;
Parameters.ParamByName('@Amount').Value := FGiftTotal;
Parameters.ParamByName('@IDPreSale').Value := FIDPreSale;
Parameters.ParamByName('@IDLancamento').Value := Null;
Parameters.ParamByName('@IDUser').Value := FGiftIDUser;
Parameters.ParamByName('@Credit').Value := True;
Parameters.ParamByName('@OBS').Value := 'Nº venda ' + FGiftCupom;
ExecProc;
finally
Free;
end;
end;
Close;
finally
Free;
end;
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'INSERT SerialMov (InventoryMovID, SerialNumber, IdentificationNumber) ' +
'VALUES (:InventoryMovID, :SerialNumber, :IdentificationNumber)';
Parameters.ParamByName('InventoryMovID').Value := FIDInventoryMov;
Parameters.ParamByName('SerialNumber').Value := FSerialNumber;
Parameters.ParamByName('IdentificationNumber').Value := FIdentificationNumber;
Execute;
CommandText := 'DELETE InventorySerial WHERE Serial = :SerialNumber AND StoreID = :StoreID AND ModelID = :ModelID';
Parameters.ParamByName('SerialNumber').Value := FSerialNumber;
Parameters.ParamByName('StoreID').Value := FIDStore;
Parameters.ParamByName('ModelID').Value := FIDModel;
Execute;
finally
Free;
end;
Result := True;
end;
{ TInvoiceItemDocument }
constructor TInvoiceItemDocument.Create(ASQLConnection: TADOConnection);
begin
FSQLConnection := ASQLConnection;
end;
function TInvoiceItemDocument.CreateIDMovDocument: Integer;
begin
Result := -1;
with TADOStoredProc.Create(nil) do
try
Connection := FSQLConnection;
ProcedureName := 'sp_Sis_GetNextCode';
Parameters.Refresh;
Parameters.ParamByName('@Tabela').Value := 'Inv_MovDocument.IDMovDocument';
Parameters.ParamByName('@NovoCodigo').Value := 0;
ExecProc;
Result := Parameters.ParamByName('@NovoCodigo').Value;
finally
Free;
end;
end;
function TInvoiceItemDocument.CreateInvoiceItemDocument: Boolean;
begin
Result := False;
FIDMovDocument := CreateIDMovDocument;
if FIDMovDocument = -1 then
raise Exception.Create('Erro ao gerar IDMovDocument.');
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'INSERT Inv_MovDocument (IDMovDocument, IDPreInventoryMov, IDInventoryMov, DocumentNumber, DocumentDate, DocumentStatus, IDDocumentType, OBS)' +
'VALUES (:IDMovDocument, NULL, :IDInventoryMov, :DocumentNumber, :DocumentDate, 1, :IDDocumentType, NULL)';
Parameters.ParamByName('IDMovDocument').Value := FIDMovDocument;
Parameters.ParamByName('IDInventoryMov').Value := FIDInventoryMov;
Parameters.ParamByName('DocumentNumber').Value := FDocumentNumber;
Parameters.ParamByName('DocumentDate').Value := FDocumentDate;
Parameters.ParamByName('IDDocumentType').Value := FIDDocumentType;
Execute;
finally
Free;
end;
Result := True;
end;
{ TInvoiceItemPrice }
constructor TInvoiceItemPrice.Create(ASQLConnection: TADOConnection);
begin
FSQLConnection := ASQLConnection;
end;
function TInvoiceItemPrice.CreateIDMovPrice: Integer;
begin
Result := -1;
with TADOStoredProc.Create(nil) do
try
Connection := FSQLConnection;
ProcedureName := 'sp_Sis_GetNextCode';
Parameters.Refresh;
Parameters.ParamByName('@Tabela').Value := 'Inv_MovPrice.IDMovPrice';
Parameters.ParamByName('@NovoCodigo').Value := 0;
ExecProc;
Result := Parameters.ParamByName('@NovoCodigo').Value;
finally
Free;
end;
end;
function TInvoiceItemPrice.CreateInvoiceItemPrice: Boolean;
begin
Result := False;
FIDMovPrice := CreateIDMovPrice;
if FIDMovPrice = -1 then
raise Exception.Create('Erro ao gerar IDMovPrice.');
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'INSERT INTO Inv_MovPrice (IDMovPrice, IDPreInventoryMov, IDInventoryMov, IDDescriptionPrice, IDVendor, SuggPrice) ' +
'VALUES (:IDMovPrice, NULL, :IDInventoryMov, :IDDescriptionPrice, :IDVendor, :SuggPrice)';
Parameters.ParamByName('IDMovPrice').Value := FIDMovPrice;
Parameters.ParamByName('IDInventoryMov').Value := FIDInventoryMov;
Parameters.ParamByName('IDDescriptionPrice').Value := FIDDescriptionPrice;
Parameters.ParamByName('IDVendor').Value := FIDVendorPrice;
Parameters.ParamByName('SuggPrice').Value := FSuggPrice;
Execute;
finally
Free;
end;
Result := True;
end;
{ TInvoiceRemovedItem }
function TInvoiceRemovedItem.CreateIDRemovedItem: Integer;
begin
Result := -1;
with TADOStoredProc.Create(nil) do
try
Connection := FSQLConnection;
ProcedureName := 'sp_Sis_GetNextCode';
Parameters.Refresh;
Parameters.ParamByName('@Tabela').Value := 'Sal_RemovedItem.IDRemovedItem';
Parameters.ParamByName('@NovoCodigo').Value := 0;
ExecProc;
Result := Parameters.ParamByName('@NovoCodigo').Value;
finally
Free;
end;
end;
function TInvoiceRemovedItem.CreateInvoiceItem: Boolean;
var
FIDRemovedItem : Integer;
begin
Result := False;
FIDRemovedItem := CreateIDRemovedItem;
if FIDRemovedItem = -1 then
raise Exception.Create('Erro ao gerar IDRemovedItem.');
with TADOCommand.Create(nil) do
try
Connection := FSQLConnection;
CommandText := 'INSERT Sal_RemovedItem(IDRemovedItem, IDCashRegister, IDModel, IDStore, ' +
'IDDepartment, IDUserAuto, IDPessoa, IDUser, MovDate, Qty, SalePrice, CostPrice, '+
'Discount, SaleCode, PosicaoItem, Acrescimo, TotalizadorParcial, IDNotasCanceladas, ' +
'IDPreSale) VALUES (:IDRemovedItem, :IDCashRegister, :IDModel, :IDStore, :IDDepartment, ' +
':IDUserAuto, :IDPessoa, :IDUser, :MovDate, :Qty, :SalePrice, :CostPrice, :Discount, ' +
':SaleCode, :PosicaoItem, :Acrescimo, :TotalizadorParcial, :IDNotasCanceladas, :IDPreSale)';
Parameters.ParamByName('IDRemovedItem').Value := FIDRemovedItem;
Parameters.ParamByName('IDCashRegister').Value := IDCashRegister;
Parameters.ParamByName('IDModel').Value := IDModel;
Parameters.ParamByName('IDStore').Value := IDStore;
Parameters.ParamByName('IDDepartment').Value := IDDepartment;
Parameters.ParamByName('IDUserAuto').Value := IDUser;
Parameters.ParamByName('IDPessoa').Value := IDComission;
Parameters.ParamByName('IDUser').Value := IDUser;
Parameters.ParamByName('MovDate').Value := MovDate;
Parameters.ParamByName('Qty').Value := Qty;
Parameters.ParamByName('SalePrice').Value := SalePrice;
Parameters.ParamByName('CostPrice').Value := CostPrice;
Parameters.ParamByName('Discount').Value := Discount;
Parameters.ParamByName('SaleCode').Value := SaleCode;
Parameters.ParamByName('PosicaoItem').Value := ItemIndex;
Parameters.ParamByName('Acrescimo').Value := Acrescimo;
Parameters.ParamByName('TotalizadorParcial').Value := TotParcial;
Parameters.ParamByName('IDNotasCanceladas').Value := Null;
Parameters.ParamByName('IDPreSale').Value := IDPreSale;
Execute;
finally
Free;
end;
Result := True;
end;
end.
|
unit ThAttributeList;
interface
uses
SysUtils, Classes, Graphics;
type
TThAttributeList = class(TStringList)
private
function GetThisList: TThAttributeList;
function GetAttribute(const inName: string): string;
procedure SetAttribute(const inName, Value: string);
protected
function GetHtmlAttributes: string;
public
procedure Add(const inName, inValue: string); reintroduce; overload;
procedure Add(const inName: string;
inValue: Integer); reintroduce; overload;
procedure Add(const inName: string;
inValue: Boolean); reintroduce; overload;
procedure AddColor(const inName: string;
inValue: TColor);
procedure Remove(const inName: string);
public
property Attribute[const inName: string]: string read GetAttribute
write SetAttribute; default;
property HtmlAttributes: string read GetHtmlAttributes;
property ThisList: TThAttributeList read GetThisList;
end;
implementation
uses
ThCssStyle;
{ TThAttributeList }
procedure TThAttributeList.Add(const inName, inValue: string);
begin
if inValue <> '' then
Add(inName + '="' + inValue + '"');
end;
procedure TThAttributeList.Add(const inName: string; inValue: Integer);
begin
Add(inName, IntToStr(inValue));
end;
procedure TThAttributeList.Add(const inName: string; inValue: Boolean);
begin
if inValue then
Add(inName, inName);
end;
procedure TThAttributeList.AddColor(const inName: string; inValue: TColor);
begin
if ThVisibleColor(inValue) then
Add(inName, ThColorToHtml(inValue));
end;
function TThAttributeList.GetAttribute(const inName: string): string;
begin
if IndexOfName(inName) < 0 then
Result := ''
else
Result := Values[inName];
end;
function TThAttributeList.GetHtmlAttributes: string;
var
i: Integer;
begin
Result := '';
for i := 0 to Pred(Count) do
Result := Result + ' ' + Strings[i];
end;
function TThAttributeList.GetThisList: TThAttributeList;
begin
Result := Self;
end;
procedure TThAttributeList.Remove(const inName: string);
var
i: Integer;
begin
i := IndexOfName(inName);
if i >= 0 then
Delete(i);
end;
procedure TThAttributeList.SetAttribute(const inName, Value: string);
begin
if IndexOfName(inName) < 0 then
Add(inName, '');
Values[inName] := '"' + Value + '"';
end;
end.
|
unit FuncionarioAssalariadoModel;
interface
uses
InterfaceFuncionarioModel;
type
TFuncionarioAssalariadoModel = class(TInterfacedObject, IFuncionarioModel)
private
FNome: String;
FSalarioBase: Double;
function GetAliquotaComissao: Double; stdcall;
function GetNome: string; stdcall;
function GetSalarioBase: Double; stdcall;
public
function CalcularSalario(const pFaturamentoMes: Double): Double; stdcall;
constructor Create(const pNome: String; const pSalarioBase: Double);
end;
implementation
{ TFuncionarioAssalariadoModel }
function TFuncionarioAssalariadoModel.CalcularSalario(const pFaturamentoMes: Double): Double;
begin
Result := Self.FSalarioBase;
end;
constructor TFuncionarioAssalariadoModel.Create(const pNome: String; const pSalarioBase: Double);
begin
inherited Create();
Self.FNome := pNome;
Self.FSalarioBase := pSalarioBase;
end;
function TFuncionarioAssalariadoModel.GetAliquotaComissao: Double;
begin
Result := 0;
end;
function TFuncionarioAssalariadoModel.GetNome: string;
begin
Result := Self.FNome;
end;
function TFuncionarioAssalariadoModel.GetSalarioBase: Double;
begin
Result := Self.FSalarioBase;
end;
end.
|
unit APIControl;
interface
uses
Windows,
Messages,
UtilFunc,
UTilClass;
type
TAPICreateParams = record
Caption: string;
Style: Longint;
ExStyle: Longint;
X, Y: Integer;
Width, Height: Integer;
WinClassName: array[0..63] of Char;
end;
//----------- TSelfSubClass -----------------------------------------
TSelfSubClass = class(TSubClass)
private
FHandle: HWND;
FID: HMenu;
protected
procedure APICreateParams(var Params: TAPICreateParams); virtual; abstract;
procedure Initialize; virtual; abstract;
public
constructor Create(hParent: HWND); override;
destructor Destroy; override;
procedure DestroyObject;
property Handle: HWND read FHandle;
property ID: HMenu read FID;
end;
//----------- TAPIContol -------------------------------------------
TAPIControl = class(TSelfSubClass)
private
function GetCaption: string;
procedure SetCaption(value: string);
function GetDimension: TRect;
procedure SetDimension(value: TRect);
function GetXPos: integer;
procedure SetXPos(value: integer);
function GetYPos: integer;
procedure SetYPos(value: integer);
function GetWidth: integer;
procedure SetWidth(value: integer);
function GetHeight: integer;
procedure SetHeight(value: integer);
function GetEnable: Boolean;
procedure SetEnable(value:Boolean);
function GetVisible: Boolean;
procedure SetVisible(value: Boolean);
protected
procedure Initialize; override;
public
destructor Destroy; override;
property Caption: string read GetCaption write SetCaption;
property Dimension : TRect read GetDimension write SetDimension;
property XPos: integer read GetXPos write SetXPos;
property YPos: integer read GetYPos write SetYPos;
property Width: integer read GetWidth write SetWidth;
property Height: integer read GetHeight write SetHeight;
property Enable: Boolean read GetEnable write SetEnable;
property Visible: Boolean read GetVisible write SetVisible;
end;
//---------- TAPIButton ----------------------------------------------
TAPIButton = class(TAPIControl)
private
FOnClick: TNotifyMessage;
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
public
procedure DefaultHandler(var Message); override;
property OnClick: TNotifyMessage read FOnClick write FOnClick;
end;
//---------- TAPICheckBox ----------------------------------------------
TCBTextStyle = (cbtRight,cbtLeft);
TAPICheckBox = class(TAPIControl)
private
FChecked: Boolean;
FTextStyle: TCBTextStyle;
FReadOnly: Boolean;
FIndeterminate: Boolean;
FOnClick: TNotifyMessage;
procedure SetChecked(value:Boolean);
procedure SetTextStyle(value:TCBTextStyle);
procedure SetIndeterminate(value: Boolean);
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
procedure Initialize; override;
public
procedure DefaultHandler(var Message); override;
property Checked: Boolean read FChecked write SetChecked;
property TextStyle: TCBTextStyle read FTextStyle write SetTextStyle;
property DoIndeterminate: Boolean read FIndeterminate write SetIndeterminate;
property ReadOnly: Boolean read FReadOnly write FReadOnly;
property OnClick: TNotifyMessage read FOnClick write FOnClick;
end;
//---------- TAPIRadioButton --------------------------------------------
TAPIRadioButton = class(TAPIControl)
private
FTextStyle: TCBTextStyle;
FGroupIndex: Integer;
FOnClick: TNotifyMessage;
function GetChecked:Boolean;
procedure SetChecked(value:Boolean);
procedure SetTextStyle(value:TCBTextStyle);
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
procedure Initialize; override;
public
procedure DefaultHandler(var Message); override;
property Checked: Boolean read GetChecked write SetChecked;
property TextStyle: TCBTextStyle read FTextStyle write SetTextStyle;
property GroupIndex: integer read FGroupIndex write FGroupIndex;
property OnClick: TNotifyMessage read FOnClick write FOnClick;
end;
//---------- APIPushRadio --------------------------------------------
TAPIPushRadio = class(TAPIRadioButton)
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
end;
//---------- APIGroupBox ---------------------------------------------
TGBTextAlign = (gbtLeft, gbtCenter, gbtRight);// TextAlign of APIGroupBox
TAPIGroupBox = class(TAPIControl)
private
FTextAlign: TGBTextAlign;
procedure SetTextAlign(value:TGBTextAlign);
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
procedure Initialize; override;
public
property TextAlign: TGBTextAlign read FTextAlign write SetTextAlign;
end;
//---------- APIListBoxBase ----------------------------------------------
TAPIListBoxBase = class(TAPIControl)
private
FColor: COLORREF;
FTxtColor: COLORREF;
FRedraw: Boolean;
FOnDoubleClick: TNotifyMessage;
FOnSelChange: TNotifyMessage;
function GetString(index:integer): string;
procedure SetString(index: integer; value: string);
function GetCount: integer;
function GetTopIndex: integer;
procedure SetTopIndex(value: integer);
function GetItemData(index: integer):integer;
procedure SetItemData(index,value: integer);
procedure SetColor(value: COLORREF);
procedure SetTxtColor(value: COLORREF);
procedure SetRedraw(value: Boolean);
protected
procedure Initialize; override;
public
procedure DefaultHandler(var Message); override;
function AddString(value: string):integer;
function DeleteString(index: integer):integer;
function InsertString(index: integer; value:string):integer;
procedure Clear;
function FindString(StartIndex:integer; s: string):integer;
procedure DoSort;
property ItemString[index:integer]: string read GetString write SetString;default;
property Count: integer read GetCount;
property TopIndex: integer read GetTopIndex write SetTopIndex;
property ItemData[index:integer]: integer read GetItemData write SetItemData;
property Color: COLORREF read FColor write SetColor;
property TextColor: COLORREF read FTxtColor write SetTxtColor;
property Redraw: Boolean read FRedraw write SetRedraw;
property OnDoubleClick: TNotifyMessage read FOnDoubleClick write FOnDoubleClick;
property OnSelChange: TNotifyMessage read FOnSelChange write FOnSelChange;
end;
//---------- APIListBox ----------------------------------------------
TAPIListBox = class(TAPIListBoxBase)
private
procedure SetSelIndex(value: Integer);
function GetSelIndex: integer;
function GetSelString: string;
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
public
property SelIndex: integer read GetSelIndex write SetSelIndex;
property SelText: string read GetSelString;
end;
//---------- APIMSListBox ----------------------------------------------
TAPIMSListBox = class(TAPIListBoxBase)
private
function GetSelected(index: integer):Boolean;
procedure SetSelected(index: integer; value: Boolean);
function GetSelCount: integer;
function GetCaretIndex: integer;
procedure SetCaretIndex(index:integer);
function GetCaretText: string;
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
public
property Selected[index:integer]: Boolean read GetSelected write SetSelected;
property SelCount: integer read GetSelCount;
property CaretIndex: integer read GetCaretIndex write SetCaretIndex;
property CaretText: string read GetCaretText;
end;
//---------- TEnumFontListBox --------------------------------------------
TEnumFontListBox = class(TAPIListBox)
private
FFontType: integer;
function GetSelLogFont: TLogFont;
procedure SetFontType(value: integer);
protected
procedure Initialize; override;
public
property SelLogFont: TLogFont read GetSelLogFont;
property FontType: integer read FFontType write SetFontType;
end;
//---------- TAPIEditBase -------------------------------------
TAPIEditBase = class(TAPIControl)
private
FColor: COLORREF;
FTxtColor: COLORREF;
FOnSetFocus: TNotifyMessage;
FOnKillFocus: TNotifyMessage;
FOnChange: TNotifyMessage;
FOnUpdate: TNotifyMessage;
FOnNotice: TNotifyMessage;
function GetTextLength: integer;
function GetText: string;
procedure SetText(value: string);
function GetCaretPos:integer;
procedure SetCaretPos(value: integer);
function GetSelTextLength: integer;
function GetSelText:string;
function GetReadOnly: Boolean;
procedure SetReadOnly(value: Boolean);
function GetLeftMargin: integer;
procedure SetLeftMargin(value: integer);
procedure SetColor(value: COLORREF);
procedure SetTxtColor(value: COLORREF);
protected
procedure Initialize; override;
public
procedure DefaultHandler(var Message); override;
procedure Cut;
procedure Copy;
procedure Paste;
procedure Clear;
procedure SelectAll;
procedure ClearAll;
property TextLength: integer read GetTextLength;
property Text: string read GetText write SetText;
property CaretPos: integer read GetCaretPos write SetCaretPos;
property SelTextLength: integer read GetSelTextLength;
property SelText: string read GetSelText;
property ReadOnly: Boolean read GetReadOnly write SetReadOnly;
property LeftMargin: integer read GetLeftMargin write SetLeftMargin;
property Color: COLORREF read FColor write SetColor;
property TextColor: COLORREF read FTxtColor write SetTxtColor;
property OnSetFocus: TNotifyMessage read FOnSetFocus write FOnSetFocus;
property OnKillFocus: TNotifyMessage read FOnKillFocus write FOnKillFocus;
property OnChange: TNotifyMessage read FOnChange write FOnChange;
property OnUpdate: TNotifyMessage read FOnUpdate write FOnUpdate;
property OnNotice: TNotifyMessage read FOnNotice write FOnNotice;
end;
//---------- TAPIEdit ----------------------------------------------
TAPIEdit = class(TAPIEditBase)
private
function GetNumEdit:Boolean;
procedure SetNumEdit(value:Boolean);
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
public
property NumEdit: Boolean read GetNumEdit write SetNumEdit;
end;
//---------- TAPIPasswordEdit ----------------------------------------------
TAPIPasswordEdit = class(TAPIEdit)
private
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
public
end;
//---------- TAPIMemo -----------------------------------------------
TAPIMemo = class(TAPIEditBase)
private
function GetLineCount: integer;
function GetCanUndo: Boolean;
procedure SetModified(value: Boolean);
function GetModified: Boolean;
function GetLineNo: integer;
function GetColNo: integer;
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
procedure Initialize; override;
public
procedure Undo;
procedure Add(s: string);
procedure LoadText(filename:string);
procedure SaveText(filename:string);
procedure SetSelRange(StartPos,EndPos:integer);
procedure GetSelRange(var StartPos,EndPos: integer);
procedure ReplaceSel(s:string);
procedure ScrollCaret;
procedure Scroll(line:integer);
procedure SetTabStop(value: integer);
function FindString(s: string; StartPos:integer):integer;
function GetLineLength(line: integer):integer;
function GetLineFromChar(CharPos: integer):integer;
function GetLine(line: integer): string;
property LineCount: integer read GetLineCount;
property CanUndo: Boolean read GetCanUndo;
property LineNo: Integer read GetLineNo;
property ColNo: integer read GetColNo;
property Modified: Boolean read GetModified write SetModified;
end;
//--------- TAPIComboBoxBase --------------------------------------------
TAPIComboBoxBase = class(TAPIControl)
private
FResultText: string;
FOnSelChange: TNotifyMessage;
function GetSelText:string;
function GetSelIndex:integer;
procedure SetSelIndex(index:integer);
function GetCount: integer;
function GetItemData(index:integer):integer;
procedure SetItemData(index,value: integer);
protected
public
function AddString(value: string):integer;
procedure DeleteString(index:integer);
function InsertString(value:string;index:integer):integer;
function GetText(index: integer):string;
procedure Clear;
property SelText: string read GetSelText;
property ResultText: string read FResultText;
property SelIndex: integer read GetSelIndex write SetSelIndex;
property Count: integer read GetCount;
property ItemData[index:integer]:integer read GetItemData write SetItemData;
property OnSelChange: TNotifyMessage read FOnSelChange write FOnSelChange;
end;
//--------- TAPIDDLCombo --------------------------------------------
TAPIDDLCombo = class(TAPIComboBoxBase)
private
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
public
procedure DefaultHandler(var Message); override;
procedure ShowDropDown(value:Boolean);
end;
//--------- TAPISMPCombo --------------------------------------------
TAPISMPCombo = class(TAPIComboBoxBase)
private
FOnEditChange: TNotifyMessage;
function GetEditText:string;
procedure SetEditText(value:string);
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
public
procedure DefaultHandler(var Message); override;
property EditText: string read GetEditText write SetEditText;
property OnEditChange: TNotifyMessage read FOnEditChange write FOnEditChange;
end;
//---------- TAPIDDCombo --------------------------------------------
TAPIDDCombo = class(TAPISMPCombo)
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
public
procedure ShowDropDown(value:Boolean);
end;
//---------- TAPIDriveCombo -----------------------------------------
TAPIDriveCombo = class(TAPIDDLCombo)
private
FRootDir: string;
FVolumeName: string;
FFileSystem: string;
FSerialNumber: integer;
FDiskSpace: integer;
FUsedSpace: integer;
FFreeSpace: integer;
protected
procedure Initialize; override;
function GetVolumeName(Root: string):string;
public
procedure DefaultHandler(var Message); override;
procedure GetVolumeInfo(Root: string);
property RootDir: string read FRootDir;
property VolumeName: string read FVolumeName;
property FileSystem: string read FFileSystem;
property SerialNumber: integer read FSerialNumber;
property DiskSpace: integer read FDiskSpace;
property UsedSpace: integer read FUsedSpace;
property FreeSpace: integer read FFreeSpace;
end;
//---------- TEnumFontComboBox --------------------------------------------
TEnumFontComboBox = class(TAPIDDLCombo)
private
FFontType: integer;
function GetSelLogFont: TLogFont;
procedure SetFontType(value: integer);
protected
procedure Initialize; override;
public
property SelLogFont: TLogFont read GetSelLogFont;
property FontType: integer read FFontType write SetFontType;
end;
//--------- APIHScroll --------------------------------------------
TAPIHScroll = class(TAPIControl)
private
FLargeChange: integer;
FSmallChange: integer;
FColor: COLORREF;
FOnChange: TNotifyMessage;
FOnTrack: TNotifyMessage;
function GetMin:integer;
procedure SetMin(value:integer);
function GetMax:integer;
procedure SetMax(value:integer);
function GetPosition: integer;
procedure SetPosition(value: integer);
function GetThumbSize: integer;
procedure SetThumbSize(ASize: integer);
procedure SetColor(value: COLORREF);
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
procedure Initialize; override;
public
procedure DefaultHandler(var Message); override;
property Min: integer read GetMin write SetMin;
property Max: integer read GetMax write SetMax;
property Position: integer read GetPosition write SetPosition;
property LargeChange: integer read FLargeChange write FLargeChange;
property SmallChange: integer read FSmallChange write FSmallChange;
property ThumbSize: integer read GetThumbSize write SetThumbSize;
property Color: COLORREF read FColor write SetColor;
property OnChange: TNotifyMessage read FOnChange write FOnChange;
property OnTrack: TNotifyMessage read FOnTrack write FOnTrack;
end;
//--------- APIVScroll --------------------------------------------
TAPIVScroll = class(TAPIHScroll)
protected
procedure APICreateParams(var Params: TAPICreateParams); override;
end;
//
//---------- Create Functions ---------------------------------------
//
function CreateButton(hParent: HWND; x,y,cx,cy: integer;sCaption: string;
sOnClick:TNotifyMessage): TAPIButton;
function CreateCheckBox(hParent: HWND; x,y,cx,cy: integer;sCaption: string;
sOnClick:TNotifyMessage): TAPICheckBox;
function CreateRadioButton(hParent: HWND; x,y,cx,cy: integer;sCaption: string;
Group: integer; sOnClick:TNotifyMessage): TAPIRadioButton;
function CreatePushRadio(hParent: HWND; x,y,cx,cy: integer;sCaption: string;
Group: integer; sOnClick:TNotifyMessage): TAPIPushRadio;
function CreateGroupBox(hParent: HWND; x,y,cx,cy: integer;
sCaption: string): TAPIGroupBox;
function CreateListBox(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPIListBox;
function CreateMSListBox(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPIMSListBox;
function CreateEdit(hParent: HWND; x,y,cx,cy: integer; txt: string;
sOnChange:TNotifyMessage): TAPIEdit;
function CreatePasswordEdit(hParent: HWND; x,y,cx,cy: integer; txt: string;
sOnChange:TNotifyMessage): TAPIPasswordEdit;
function CreateMemo(hParent: HWND; x,y,cx,cy: integer): TAPIMemo;
function CreateDDLCombo(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPIDDLCombo;
function CreateSMPCombo(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPISMPCombo;
function CreateDDCombo(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPIDDCombo;
function CreateDriveCombo(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPIDriveCombo;
function CreateHScroll(hParent: HWND; x,y,cx,cy: integer;
sOnTrackChange:TNotifyMessage): TAPIHScroll;
function CreateVScroll(hParent: HWND; x,y,cx,cy: integer;
sOnTrackChange:TNotifyMessage): TAPIVScroll;
implementation
var
ID_CONT: integer = 400;
//----------- TSelfSubClass -----------------------------------------
function SelfSubClassProc(hWnd: HWND; Msg: UINT;
wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;
var
PascalObject: TSelfSubClass;
OriginalProc: TFNWndProc;
SBMsg: TMessage;
begin
OriginalProc := TFNWndProc(GetProp(hWnd,'WNDPROC'));
result := CallWindowProc(OriginalProc,hWnd,Msg,wParam,lParam);
PascalObject := TSelfSubClass(GetProp(hWnd,'OBJECT'));
case Msg of
WM_DESTROY: if Assigned(PascalObject) then PascalObject.Free;
else
if Assigned(PascalObject) then begin
SBMsg.Msg := Msg;
SBMsg.WParam := wParam;
SBMsg.LParam := lParam;
SBMsg.Result := 0;
PascalObject.Dispatch(SBMsg);
if SBMsg.Result <> 0 then result := SBMsg.Result;
end;
end; // case
end;
constructor TSelfSubClass.Create(hParent: HWnd);
var
Params: TAPICreateParams;
DefWndProc: TFNWndProc;
begin
inherited Create(hParent);
APICreateParams(Params);
with Params do begin
FHandle := CreateWindowEx(ExStyle,WinClassName,PChar(Caption),
Style,X, Y, Width, Height,
hParent,
ID_CONT,
hInstance,
nil);
end;
if IsWindow(FHandle) then begin
SetProp(FHandle,'OBJECT',Integer(self));
DefWndProc := TFNWndProc(SetWindowLong(FHandle,
GWL_WNDPROC,Integer(@SelfSubClassProc)));
SetProp(FHandle,'WNDPROC',integer(DefWndProc));
end;
FID := ID_CONT; Inc(ID_CONT);
Initialize;
end;
destructor TSelfSubClass.Destroy;
begin
SetWindowLong(FHandle,GWL_WNDPROC,GetProp(FHandle,'WNDPROC'));
RemoveProp(FHandle,'OBJECT');
RemoveProp(FHandle,'WNDPROC');
inherited Destroy;
end;
procedure TSelfSubClass.DestroyObject;
begin
DestroyWindow(FHandle);
end;
//----------- TAPIControl -----------------------------------------
destructor TAPIControl.Destroy;
begin
inherited Destroy;
end;
procedure TAPIControl.Initialize;
begin
Dispatcher.TrapMessage(WM_COMMAND,self);
end;
function TAPIControl.GetCaption: string;
var
s: string;
begin
SetLength(s,50);
SetString(result,PChar(s),GetWindowText(FHandle,PChar(s),50));
end;
procedure TAPIControl.SetCaption(value: string);
begin
SetWindowText(FHandle, PChar(Value));
end;
function TAPIControl.GetDimension: TRect;
begin
result := SetDim(XPos,YPos,Width,Height);
end;
procedure TAPIControl.SetDimension(value: TRect);
begin
MoveWindow(FHandle,value.left, value.top,
value.right, value.bottom, true);
end;
function TAPIControl.GetXPos: integer;
var
r: TRect;
p: TPoint;
begin
GetWindowRect(FHandle,r);
p.x := r.Left; p.y := r.Top;
ScreenToClient(Parent,p);
result := p.x;
end;
procedure TAPIControl.SetXPos(value: integer);
begin
ChangeWindowPos(FHandle,value,YPos);
end;
function TAPIControl.GetYPos: integer;
var
r: TRect;
p: TPoint;
begin
GetWindowRect(FHandle,r);
p.x := r.Left; p.y := r.Top;
ScreenToClient(Parent,p);
result := p.y;
end;
procedure TAPIControl.SetYPos(value: integer);
begin
ChangeWindowPos(FHandle,XPos,value);
end;
function TAPIControl.GetWidth: integer;
var
r: TRect;
begin
GetWindowRect(FHandle,r);
result := r.Right-r.Left;
end;
procedure TAPIControl.SetWidth(value: integer);
begin
ChangeWindowSize(FHandle,value,Height);
end;
function TAPIControl.GetHeight: integer;
var
r: TRect;
begin
GetWindowRect(FHandle,r);
result := r.Bottom-r.Top;
end;
procedure TAPIControl.SetHeight(value: integer);
begin
ChangeWindowSize(FHandle,Width,value);
end;
function TAPIControl.GetEnable: Boolean;
begin
result := Boolean(IsWindowEnabled(FHandle));
end;
procedure TAPIControl.SetEnable(value: Boolean);
begin
EnableWindow(FHandle,value);
end;
function TAPIControl.GetVisible: Boolean;
begin
result := Boolean(IsWindowVisible(FHandle));
end;
procedure TAPIControl.SetVisible(value:Boolean);
begin
if value then
ShowWindow(FHandle,SW_SHOWNORMAL)
else
ShowWindow(FHandle,SW_HIDE);
end;
//--------------- TAPIButton ----------------------------------------------
procedure TAPIButton.APICreateParams(var Params: TAPICreateParams);
begin
with Params do begin
Caption := 'APIButton';
Style := WS_CHILD or WS_VISIBLE or WS_TABSTOP or
WS_CLIPSIBLINGS or BS_PUSHBUTTON;
ExStyle := 0;
X := 0;
Y := 0;
Width := 0;
Height := 0;
WinClassName := 'BUTTON';
end;
end;
procedure TAPIButton.DefaultHandler(var Message);
var
AMsg:TMessage;
begin
AMsg := TMessage(message);
case AMsg.Msg of
WM_COMMAND:
if (AMsg.LParam = LongInt(FHandle)) and (AMsg.WParamHi = BN_CLICKED) then
if Assigned(FOnClick) then begin
AMsg.Msg := UINT(self); // Sender
OnClick(AMsg);
end;
end; // case
end;
//
//---------- Create Functions ---------------------------------------
//
function CreateButton(hParent: HWND; x,y,cx,cy: integer;sCaption: string;
sOnClick:TNotifyMessage): TAPIButton;
begin
result := TAPIButton.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
Caption := sCaption;
OnClick := sOnClick;
end;
end;
//---------- TAPICheckBox ----------------------------------------------
procedure TAPICheckBox.Initialize;
begin
inherited Initialize;
FChecked := false;
FTextStyle := cbtRight;
FReadOnly := false;
FIndeterminate := false;
end;
procedure TAPICheckBox.APICreateParams(var Params: TAPICreateParams);
begin
with Params do begin
Caption := 'APICheckBox';
Style := WS_CHILD or WS_VISIBLE or WS_TABSTOP or
WS_CLIPSIBLINGS or BS_3STATE;
ExStyle := 0;
X := 50;
Y := 50;
Width := 150;
Height := 32;
WinClassName := 'BUTTON';
end;
end;
procedure TAPICheckBox.DefaultHandler(var Message);
var
AMsg: TMessage;
begin
if FReadOnly then Exit;
AMsg := TMessage(message);
case AMsg.Msg of
WM_COMMAND:
if (AMsg.LParam = LPARAM(FHandle)) and (AMsg.WParamHi = BN_CLICKED) then begin
Checked := not Checked;
AMsg.Msg := UINT(self); // Sender
if Assigned(FOnClick)then OnClick(AMsg);
end;
end; // case
end;
procedure TAPICheckBox.SetChecked(value:Boolean);
begin
FChecked := value;
if value then
SendMessage(FHandle,BM_SETCHECK,BST_CHECKED,0)
else
SendMessage(FHandle,BM_SETCHECK,BST_UNCHECKED,0);
end;
procedure TAPICheckBox.SetTextStyle(value:TCBTextStyle);
var
Style: LongInt;
begin
if FTextStyle = value then exit;
FTextStyle := value;
Style := GetWindowLong(FHandle,GWL_STYLE);
if value = cbtLeft then
SetWindowLong(FHandle,GWL_STYLE,(Style or BS_LEFTTEXT))
else
SetWindowLong(FHandle,GWL_STYLE,(Style and (not BS_LEFTTEXT)));
InvalidateRect(FHandle,nil,true);
end;
procedure TAPICheckBox.SetIndeterminate(value: Boolean);
begin
if value then
SendMessage(FHandle,BM_SETCHECK,BST_INDETERMINATE,0)
else
if FChecked then Checked := true else Checked := false;
FIndeterminate := value;
end;
function CreateCheckBox(hParent: HWND; x,y,cx,cy: integer;sCaption: string;
sOnClick:TNotifyMessage): TAPICheckBox;
begin
result := TAPICheckBox.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
Caption := sCaption;
OnClick := sOnClick;
end;
end;
//---------- TAPIRadioButton --------------------------------------------
procedure TAPIRadioButton.Initialize;
begin
inherited Initialize;
FTextStyle := cbtRight;
FGroupIndex := 0;
end;
procedure TAPIRadioButton.APICreateParams(var Params: TAPICreateParams);
begin
with Params do begin
Caption := 'APIRadioButton';
Style := WS_CHILD or WS_VISIBLE or WS_TABSTOP or
WS_CLIPSIBLINGS or BS_RADIOBUTTON;
ExStyle := 0;
X := 50;
Y := 50;
Width := 150;
Height := 32;
WinClassName := 'BUTTON';
end;
end;
function UnCheckSameRadioGroup(hWindow: HWND; Data:LParam): Boolean; stdcall;
var
sobject: TObject;
begin
result := true;
if GetProp(hWindow,'OBJECT') <> 0 then begin
sobject := TObject(GetProp(hWindow,'OBJECT'));
if (sobject is TAPIRadioButton) and
(TAPIRadioButton(sobject).GroupIndex = Data) then
TAPIRadioButton(sobject).Checked := false;
end;
end;
procedure UnCheckSameGroup(hParent: HWND; GroupIndex:Integer);
begin
EnumChildWindows(hParent,@UnCheckSameRadioGroup,GroupIndex);
end;
procedure TAPIRadioButton.DefaultHandler(var Message);
var
AMsg: TMessage;
begin
AMsg := TMessage(message);
case AMsg.Msg of
WM_COMMAND:
if (AMsg.LParam = LPARAM(FHandle)) and (AMsg.WParamHi = BN_CLICKED) then begin
if FGroupIndex = 0 then begin
Checked := not Checked;
end else begin // グループ化されている
UnCheckSameGroup(Parent,FGroupIndex);
Checked := true;
end;
AMsg.Msg := UINT(self);
if Assigned(FOnClick)then OnClick(AMsg);
end;
end; // case
end;
function TAPIRadioButton.GetChecked:Boolean;
begin
result := Boolean(SendMessage(FHandle,BM_GETCHECK,0,0));
end;
procedure TAPIRadioButton.SetChecked(value:Boolean);
begin
if value then
SendMessage(FHandle,BM_SETCHECK,1,0)
else
SendMessage(FHandle,BM_SETCHECK,0,0);
end;
procedure TAPIRadioButton.SetTextStyle(value:TCBTextStyle);
var
Style: LongInt;
begin
if FTextStyle = value then exit;
FTextStyle := value;
Style := GetWindowLong(FHandle,GWL_STYLE);
if value = cbtLeft then
SetWindowLong(FHandle,GWL_STYLE,(Style or BS_LEFTTEXT))
else
SetWindowLong(FHandle,GWL_STYLE,(Style and (not BS_LEFTTEXT)));
InvalidateRect(FHandle,nil,true);
end;
//---------- TAPIPushRadio --------------------------------------------
procedure TAPIPushRadio.APICreateParams(var Params: TAPICreateParams);
begin
inherited APICreateParams(Params);
with Params do begin
Caption := 'APIPushRadio';
Style := Style or BS_PUSHLIKE;
end;
end;
function CreateRadioButton(hParent: HWND; x,y,cx,cy: integer;sCaption: string;
Group: integer; sOnClick:TNotifyMessage): TAPIRadioButton;
begin
result := TAPIRadioButton.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
Caption := sCaption;
GroupIndex := Group;
OnClick := sOnClick;
end;
end;
function CreatePushRadio(hParent: HWND; x,y,cx,cy: integer;sCaption: string;
Group: integer; sOnClick:TNotifyMessage): TAPIPushRadio;
begin
result := TAPIPushRadio.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
Caption := sCaption;
GroupIndex := Group;
OnClick := sOnClick;
end;
end;
//---------- APIGroupBox ---------------------------------------------
procedure TAPIGroupBox.Initialize;
begin
inherited Initialize;
FTextAlign := gbtLeft;
end;
procedure TAPIGroupBox.APICreateParams(var Params: TAPICreateParams);
begin
with Params do begin
Caption := 'APIGroupBox';
Style := WS_CHILD or WS_VISIBLE or WS_CLIPSIBLINGS or
BS_GROUPBOX or BS_LEFT;
ExStyle := 0;
X := 50;
Y := 50;
Width := 150;
Height := 32;
WinClassName := 'BUTTON';
end;
end;
procedure TAPIGroupBox.SetTextAlign(value:TGBTextAlign);
var
Style,SetStyle: LongInt;
r: TRect;
begin
if FTextAlign = value then Exit;
FTextAlign := value;
Style := GetWindowLong(FHandle,GWL_STYLE);
SetStyle := Style and (not BS_CENTER);
case value of
gbtLeft: SetStyle := SetStyle or BS_LEFT;
gbtCenter: SetStyle := SetStyle or BS_CENTER;
gbtRight: SetStyle := SetStyle or BS_RIGHT;
end;
SetWindowLong(FHandle,GWL_STYLE,SetStyle);
r := SetDim(XPos,YPos,XPos+Width,YPos+Height);
InvalidateRect(Parent,@r,true);
end;
function CreateGroupBox(hParent: HWND; x,y,cx,cy: integer;
sCaption: string): TAPIGroupBox;
begin
result := TAPIGroupBox.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
Caption := sCaption;
end;
end;
//---------- APIListBoxBase ----------------------------------------------
procedure TAPIListBoxBase.Initialize;
begin
inherited Initialize;
FColor := clrWhite;
FTxtColor := clrBlack;
FRedraw := true;
Dispatcher.TrapMessage(WM_CTLCOLORLISTBOX,self);
end;
procedure TAPIListBoxBase.DefaultHandler(var Message);
var
AMsg: TMessage;
begin
AMsg := TMessage(Message);
case AMsg.Msg of
WM_COMMAND: begin
if (AMsg.LParam <> LPARAM(FHandle)) then exit;
if AMsg.WParamHi = WORD(LBN_ERRSPACE) then
MessageBox(Parent,'ListBox Error Space','Warning',MB_OK);
AMsg.Msg := UINT(self); // Sender
case AMsg.WParamHi of
LBN_SELCHANGE: if Assigned(FOnSelChange) then OnSelChange(AMsg);
LBN_DBLCLK: if Assigned(FOnDoubleClick) then OnDoubleClick(AMsg);
end; // case
end;
WM_CTLCOLORLISTBOX: if AMsg.LParam = LPARAM(FHandle) then begin
SetBkColor(AMsg.WParam,FColor);
SetTextColor(AMsg.WParam,FTxtColor);
TMessage(Message).Result := CreateSolidBrush(FColor);
end;
end; // case
end;
function TAPIListBoxBase.AddString(value: string):integer;
begin
Result := SendMessage(FHandle,LB_ADDSTRING, 0, Integer(PChar(value)));
end;
function TAPIListBoxBase.DeleteString(index: integer):integer;
begin
Result := SendMessage(FHandle,LB_DELETESTRING,WParam(index),0);
end;
function TAPIListBoxBase.InsertString(index: integer; value:string):integer;
begin
Result := SendMessage(FHandle,LB_INSERTSTRING,WParam(index),
lParam(PChar(value)));
end;
procedure TAPIListBoxBase.Clear;
begin
SendMessage(FHandle,LB_RESETCONTENT, 0, 0);
end;
function TAPIListBoxBase.GetString(index:integer): string;
var
len: integer;
PC:PChar;
begin
if (index > Count-1) or (index < 0) then Exit;
len := SendMessage(FHandle,LB_GETTEXTLEN,WPARAM(index),0);
GetMem(PC,len+1); // +1 for null-terminator
SendMessage(FHandle,LB_GETTEXT,WParam(index),LParam(PC));
System.SetString(result,PC,len);
FreeMem(PC);
end;
procedure TAPIListBoxBase.SetString(index: integer; value: string);
begin
if (index > Count-1) or (index < 0) then Exit;
DeleteString(index);
InsertString(index,value);
end;
function TAPIListBoxBase.FindString(StartIndex:integer; s: string):integer;
begin
Result := SendMessage(FHandle,LB_FINDSTRING,StartIndex,LPARAM(PChar(s)))
end;
procedure TAPIListBoxBase.DoSort;
var
SA: TStringArray;
i,IC: integer;
begin
SA := TStringArray.Create;
IC := Count;
for i := 0 to IC-1 do SA.Add(ItemString[i]);
Clear;
SA.Sort;
Redraw := false;
for i := 0 to IC-1 do AddString(SA[i]);
SA.Free;
Redraw := true;
end;
function TAPIListBoxBase.GetCount: integer;
begin
result := SendMessage(FHandle,LB_GETCOUNT,0,0);
end;
function TAPIListBoxBase.GetTopIndex: integer;
begin
result := SendMessage(FHandle,LB_GETTOPINDEX,0,0);
end;
procedure TAPIListBoxBase.SetTopIndex(value: integer);
begin
SendMessage(FHandle,LB_SETTOPINDEX,WParam(value),0);
end;
function TAPIListBoxBase.GetItemData(index: integer):integer;
begin
Result := SendMessage(FHandle,LB_GETITEMDATA,index,0);
end;
procedure TAPIListBoxBase.SetItemData(index,value: integer);
begin
SendMessage(FHandle,LB_SETITEMDATA,index,value);
end;
procedure TAPIListBoxBase.SetColor(value: COLORREF);
begin
FColor := value;
InvalidateRect(FHandle,nil,true);
end;
procedure TAPIListBoxBase.SetTxtColor(value: COLORREF);
begin
FTxtColor := value;
InvalidateRect(FHandle,nil,true);
end;
procedure TAPIListBoxBase.SetRedraw(value: Boolean);
begin
if value then begin
SendMessage(FHandle,WM_SETREDRAW,1,0);
InvalidateRect(FHandle,nil,true);
end else
SendMessage(FHandle,WM_SETREDRAW,0,0);
FRedraw := value;
end;
//---------- APIListBox ----------------------------------------------
procedure TAPIListBox.APICreateParams(var Params: TAPICreateParams);
begin
with Params do begin
Caption := 'APIListBox';
Style := WS_CHILD or WS_VISIBLE or WS_TABSTOP or
WS_CLIPSIBLINGS or WS_VSCROLL or LBS_NOINTEGRALHEIGHT or
LBS_USETABSTOPS or LBS_HASSTRINGS or LBS_NOTIFY;
ExStyle := WS_EX_CLIENTEDGE;
X := 50;
Y := 50;
Width := 150;
Height := 32;
WinClassName := 'LISTBOX';
end;
end;
procedure TAPIListBox.SetSelIndex(value: Integer);
begin
SendMessage(FHandle,LB_SETCURSEL,WParam(value),0);
end;
function TAPIListBox.GetSelIndex: integer;
begin
Result := Integer(SendMessage(FHandle,LB_GETCURSEL,0,0));
end;
function TAPIListBox.GetSelString: string;
begin
Result := ItemString[SelIndex];
end;
function CreateListBox(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPIListBox;
begin
result := TAPIListBox.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
OnSelChange := sOnSelChange;
end;
end;
//---------- APIMSListBox ----------------------------------------------
procedure TAPIMSListBox.APICreateParams(var Params: TAPICreateParams);
begin
with Params do begin
Caption := 'APIMSListBox';
Style := WS_CHILD or WS_VISIBLE or WS_TABSTOP or
WS_CLIPSIBLINGS or WS_VSCROLL or LBS_NOINTEGRALHEIGHT or
LBS_USETABSTOPS or LBS_HASSTRINGS or LBS_NOTIFY or
LBS_EXTENDEDSEL;
ExStyle := WS_EX_CLIENTEDGE;
X := 50;
Y := 50;
Width := 150;
Height := 32;
WinClassName := 'LISTBOX';
end;
end;
function TAPIMSListBox.GetSelCount: integer;
begin
result := SendMessage(FHandle,LB_GETSELCOUNT,0,0);
end;
function TAPIMSListBox.GetSelected(index: integer):Boolean;
begin
if SendMessage(FHandle,LB_GETSEL,wParam(index),0) > 0 then
result := true
else
result := false;
end;
procedure TAPIMSListBox.SetSelected(index: integer; value: Boolean);
begin
SendMessage(FHandle,LB_SETSEL,WPARAM(value),LPARAM(index));
end;
function TAPIMSListBox.GetCaretIndex: integer;
begin
result := SendMessage(FHandle,LB_GETCARETINDEX,0,0);
end;
procedure TAPIMSListBox.SetCaretIndex(index:integer);
begin
SendMessage(FHandle,LB_GETCARETINDEX,WPARAM(index),1);
end;
function TAPIMSListBox.GetCaretText: string;
begin
Result := ItemString[CaretIndex];
end;
function CreateMSListBox(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPIMSListBox;
begin
result := TAPIMSListBox.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
OnSelChange := sOnSelChange;
end;
end;
//---------- TAPIEditBase -------------------------------------
procedure TAPIEditBase.Initialize;
begin
inherited Initialize;
FColor := clrWhite;
FTxtColor := clrBlack;
Dispatcher.TrapMessage(WM_CTLCOLOREDIT,self);
end;
procedure TAPIEditBase.DefaultHandler(var Message);
var
AMsg: TMessage;
begin
AMsg := TMessage(Message);
case AMsg.Msg of
WM_COMMAND: begin
if (AMsg.LParam <> LPARAM(FHandle)) then exit;
case AMsg.WParamHi of
EN_SETFOCUS: if Assigned(FOnSetFocus) then begin
AMsg.Msg := UINT(self); // sender
OnSetFocus(AMsg);
end;
EN_KILLFOCUS: if Assigned(FOnKillFocus) then begin
AMsg.Msg := UINT(self); // sender
OnKillFocus(AMsg);
end;
EN_CHANGE: if Assigned(FOnChange) then begin
AMsg.Msg := UINT(self); // sender
OnChange(AMsg);
end;
EN_UPDATE: if Assigned(FOnUpdate) then begin
AMsg.Msg := UINT(self); // sender
OnUpdate(AMsg);
end;
EN_ERRSPACE,EN_MAXTEXT:MessageBox(Parent,'Edit Control Buffer Full!',
'Warning',MB_OK);
end;// case
end;
WM_CTLCOLOREDIT:if AMsg.LParam = LPARAM(FHandle) then begin
SetBkColor(AMsg.WParam,FColor);
SetTextColor(AMsg.WParam,FTxtColor);
TMessage(Message).Result := CreateSolidBrush(FColor);
end;
WM_KEYUP, WM_LBUTTONUP:if Assigned(FOnNotice) then OnNotice(AMsg);
end;//case
end;
function TAPIEditBase.GetTextLength: integer;
begin
result := SendMessage(FHandle,WM_GETTEXTLENGTH,0,0);
end;
function TAPIEditBase.GetText: string;
var
Len: integer;
PC: PChar;
begin
Len := GetTextLength + 1;
GetMem(PC,Len);
FillChar(PC^,Len,0);
Len := SendMessage(FHandle,WM_GETTEXT,Len,integer(PC));
SetString(result,PC,Len);
FreeMem(PC);
end;
procedure TAPIEditBase.SetText(value: string);
begin
SendMessage(FHandle,WM_SETTEXT,0,integer(PChar(value)));
end;
function TAPIEditBase.GetCaretPos:integer;
var
st, ed: integer;
begin
SendMessage(FHandle,EM_GETSEL,integer(@st),integer(@ed));
if ed < st then result := st else result := ed;
end;
procedure TAPIEditBase.SetCaretPos(value:integer);
begin
SendMessage(FHandle,EM_SETSEL,value,value);
end;
function TAPIEditBase.GetSelTextLength: integer;
var
st,ed: integer;
begin
SendMessage(FHandle,EM_GETSEL,integer(@st),integer(@ed));
result := ed-st;
end;
function TAPIEditBase.GetSelText:string;
var
st,ed: integer;
s: string;
PCS: PChar;
begin
SendMessage(FHandle,EM_GETSEL,integer(@st),integer(@ed));
if (ed-st) <> 0 then begin
s := GetText;
PCS := PChar(integer(PChar(s))+st);
SetString(result,PCS,ed-st);
end else
result := '';
end;
procedure TAPIEditBase.Cut;
begin
SendMessage(FHandle,WM_CUT,0,0);
end;
procedure TAPIEditBase.Copy;
begin
SendMessage(FHandle,WM_COPY,0,0);
end;
procedure TAPIEditBase.Paste;
begin
SendMessage(FHandle,WM_PASTE,0,0);
end;
procedure TAPIEditBase.Clear;
begin
SendMessage(FHandle,WM_CLEAR,0,0);
end;
procedure TAPIEditBase.SelectAll;
begin
SendMessage(FHandle,EM_SETSEL,0,-1);
end;
procedure TAPIEditBase.ClearAll;
begin
SelectAll;
Clear;
end;
function TAPIEditBase.GetReadOnly: Boolean;
var
i: integer;
begin
i := GetWindowLong(FHandle,GWL_STYLE);
i := ( i and ES_READONLY);
result := ( i <> 0 );
end;
procedure TAPIEditBase.SetReadOnly(value: Boolean);
begin
SendMessage(FHandle,EM_SETREADONLY,integer(value),0);
end;
function TAPIEditBase.GetLeftMargin: integer;
begin
result := LOWORD(SendMessage(FHandle,EM_SETMARGINS,0,0));
end;
procedure TAPIEditBase.SetLeftMargin(value: integer);
begin
SendMessage(FHandle,EM_SETMARGINS,EC_LEFTMARGIN,MakeLong(value,0));
end;
procedure TAPIEditBase.SetColor(value: COLORREF);
begin
FColor := value;
InvalidateRect(FHandle,nil,true);
end;
procedure TAPIEditBase.SetTxtColor(value: COLORREF);
begin
FTxtColor := value;
InvalidateRect(FHandle,nil,true);
end;
//---------- TAPIEdit ----------------------------------------------
procedure TAPIEdit.APICreateParams(var Params: TAPICreateParams);
begin
with Params do begin
Caption := '';
Style := WS_CHILD or WS_VISIBLE or WS_TABSTOP or
WS_CLIPSIBLINGS or ES_AUTOHSCROLL or ES_LEFT;
ExStyle := WS_EX_CLIENTEDGE;
X := 50;
Y := 50;
Width := 150;
Height := 32;
WinClassName := 'EDIT';
end;
end;
function TAPIEdit.GetNumEdit:Boolean;
var
i: integer;
begin
i := GetWindowLong(FHandle,GWL_STYLE);
i := ( i and ES_NUMBER);
result := ( i <> 0 );
end;
procedure TAPIEdit.SetNumEdit(value:Boolean);
var
i: integer;
begin
i := GetWindowLong(FHandle,GWL_STYLE);
if value then
i := i or ES_NUMBER
else
i := i and ( not ES_NUMBER);
SetWindowLong(FHandle,GWL_STYLE,i);
end;
//---------- TAPIPasswordEdit ----------------------------------------------
procedure TAPIPasswordEdit.APICreateParams(var Params: TAPICreateParams);
begin
inherited APICreateParams(Params);
Params.Style := Params.Style or ES_PASSWORD;
end;
function CreateEdit(hParent: HWND; x,y,cx,cy: integer; txt: string;
sOnChange:TNotifyMessage): TAPIEdit;
begin
result := TAPIEdit.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
Text := txt;
OnChange := sOnChange;
end;
end;
function CreatePasswordEdit(hParent: HWND; x,y,cx,cy: integer; txt: string;
sOnChange:TNotifyMessage): TAPIPasswordEdit;
begin
result := TAPIPasswordEdit.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
Text := txt;
OnChange := sOnChange;
end;
end;
//---------- TAPIMemo ----------------------------------------------
procedure TAPIMemo.Initialize;
begin
inherited Initialize;
SendMessage(FHandle,EM_SETLIMITTEXT,0,0)
end;
procedure TAPIMemo.APICreateParams(var Params: TAPICreateParams);
begin
with Params do begin
Caption := '';
Style := WS_CHILD or WS_VISIBLE or WS_TABSTOP or
WS_CLIPSIBLINGS or WS_VSCROLL or ES_NOHIDESEL or
ES_AUTOVSCROLL or ES_MULTILINE or ES_LEFT or ES_WANTRETURN;
ExStyle := WS_EX_CLIENTEDGE;
X := 50;
Y := 50;
Width := 150;
Height := 32;
WinClassName := 'EDIT';
end;
end;
procedure TAPIMemo.Undo;
begin
SendMessage(FHandle,EM_UNDO,0,0);
end;
procedure TAPIMemo.Add(s: string);
begin
Text := Text+#13#10+s;
Scroll(LineCount);
end;
function TAPIMemo.FindString(s: string; StartPos:integer):integer;
var
st,ed: integer;
Txt: string;
PCS: PChar;
begin
Txt := Text;
PCS := PChar(integer(PChar(Txt))+StartPos);
st := Pos(s,string(PCS));
if st <> 0 then begin
st := st-1+StartPos;
ed := st+Length(s);
SetSelRange(st,ed);
ScrollCaret;
end;
result := st;
end;
procedure TAPIMemo.ScrollCaret;
begin
SendMessage(FHandle,EM_SCROLLCARET,0,0);
end;
procedure TAPIMemo.Scroll(line:integer);
begin
SendMessage(FHandle,EM_LINESCROLL,0,line);
end;
procedure TAPIMemo.SetTabStop(value: integer);
begin
SendMessage(FHandle,EM_SETTABSTOPS,1,integer(@value));;
end;
function TAPIMemo.GetLine(line: integer): string;
var
PC: PChar;
PCLen: Word;
Len: integer;
begin
PCLen := GetLineLength(line);
PCLen := PCLen+1;
GetMem(PC,PCLen);
Move(PCLen,PC^,SizeOf(Word));
Len := SendMessage(FHandle,EM_GETLINE,line,integer(PC));
SetString(result,PC,Len);
FreeMem(PC);
end;
function TAPIMemo.GetLineCount: integer;
begin
result := SendMessage(FHandle,EM_GETLINECOUNT,0,0);
end;
procedure TAPIMemo.LoadText(filename:string);
var
F: file;
Size,NumRead: Integer;
P: PChar;
s:string;
begin
AssignFile(F,filename);
Reset(F,1);
try
Size := FileSize(F);
GetMem(P, Size);
try
BlockRead(F, P^, Size,NumRead);
finally
s := string(p);
SetLength(s,NumRead);
Text := s;
FreeMem(P);
end;
finally
CloseFile(F);
end;
end;
procedure TAPIMemo.SaveText(filename:string);
var
f: TextFile;
Buf: array[0..$1FFF] of Char;
begin
AssignFile(f,filename);
SetTextBuf(f,Buf);
ReWrite(f);
write(f,Text);
Flush(f);
CloseFile(f);
end;
procedure TAPIMemo.SetSelRange(StartPos,EndPos:integer);
begin
SendMessage(FHandle,EM_SETSEL,StartPos,EndPos);
end;
procedure TAPIMemo.GetSelRange(var StartPos,EndPos: integer);
begin
SendMessage(FHandle,EM_GETSEL,integer(@StartPos),integer(@EndPos));
end;
procedure TAPIMemo.ReplaceSel(s:string);
begin
SendMessage(FHandle,EM_REPLACESEL,1,integer(PChar(s)));
end;
function TAPIMemo.GetCanUndo: Boolean;
begin
result := Boolean(SendMessage(FHandle,EM_CANUNDO,0,0));
end;
function TAPIMemo.GetLineLength(line:integer): integer;
var
CharPos: integer;
begin
CharPos := SendMessage(FHandle,EM_LINEINDEX,line,0);
result := SendMessage(FHandle,EM_LINELENGTH,CharPos,0);
end;
function TAPIMemo.GetLineFromChar(CharPos: integer):integer;
begin
result := SendMessage(FHandle,EM_LINEFROMCHAR,CharPos,0);
end;
procedure TAPIMemo.SetModified(value: Boolean);
begin
SendMessage(FHandle,EM_SETMODIFY,UINT(value),0);
end;
function TAPIMemo.GetModified: Boolean;
begin
result := Boolean(SendMessage(FHandle,EM_GETMODIFY,0,0));
end;
function TAPIMemo.GetLineNo: integer;
begin
result := SendMessage(FHandle,EM_LINEFROMCHAR,-1,0);
end;
function TAPIMemo.GetColNo: integer;
begin
result := CaretPos-SendMessage(FHandle,EM_LINEINDEX,LineNo,0);
end;
function CreateMemo(hParent: HWND; x,y,cx,cy: integer): TAPIMemo;
begin
result := TAPIMemo.Create(hParent);
result.Dimension := SetDim(x,y,cx,cy);
end;
//--------- TAPIComboBoxBase --------------------------------------------
function TAPIComboBoxBase.AddString(value: string):integer;
begin
result := SendMessage(FHandle,CB_ADDSTRING,0,integer(PChar(value)));
end;
procedure TAPIComboBoxBase.DeleteString(index:integer);
begin
SendMessage(FHandle,CB_DELETESTRING,index,0);
end;
function TAPIComboBoxBase.InsertString(value:string;index:integer):integer;
begin
result := SendMessage(FHandle,CB_INSERTSTRING,index,integer(PChar(value)));
end;
function TAPIComboBoxBase.GetSelText:string;
begin
Result := GetText(SelIndex);
end;
function TAPIComboBoxBase.GetSelIndex:integer;
begin
result := SendMessage(FHandle,CB_GETCURSEL,0,0);
end;
procedure TAPIComboBoxBase.SetSelIndex(index:integer);
var
AMsg: TMessage;
begin
if index = SelIndex then exit;
SendMessage(FHandle,CB_SETCURSEL,index,0);
AMsg.Msg := WM_COMMAND;
AMsg.WParamHi := CBN_SELCHANGE;
AMsg.WParamLo := FID;
AMsg.LParam := FHandle;
Dispatch(AMsg);
end;
function TAPIComboBoxBase.GetText(index: integer):string;
var
s:string;
Len: integer;
begin
Len := SendMessage(FHandle,CB_GETLBTEXTLEN,index,0);
SetLength(s,Len);
SendMessage(FHandle,CB_GETLBTEXT,index,integer(PChar(s)));
result := s;
end;
procedure TAPIComboBoxBase.Clear;
begin
SendMessage(FHandle,CB_RESETCONTENT,0,0);
end;
function TAPIComboBoxBase.GetCount:integer;
begin
result := SendMessage(FHandle,CB_GETCOUNT,0,0);
end;
function TAPIComboBoxBase.GetItemData(index:integer):integer;
begin
result := SendMessage(FHandle,CB_GETITEMDATA,index,0);
end;
procedure TAPIComboBoxBase.SetItemData(index,value: integer);
begin
SendMessage(FHandle,CB_SETITEMDATA,index,value);
end;
//--------- TAPIDDLCombo --------------------------------------------
procedure TAPIDDLCombo.APICreateParams(var Params: TAPICreateParams);
begin
with Params do begin
Caption := '';
Style := $54010240 or WS_VSCROLL or CBS_DROPDOWNLIST;
ExStyle := WS_EX_CLIENTEDGE;
X := 50;
Y := 50;
Width := 150;
Height := 32;
WinClassName := 'COMBOBOX';
end;
end;
procedure TAPIDDLCombo.DefaultHandler(var Message);
var
AMsg: TMessage;
begin
AMsg := TMessage(message);
case AMsg.Msg of
WM_COMMAND:begin
if (AMsg.LParam <> LPARAM(FHandle)) then exit;
case AMsg.WParamHi of
CBN_SELCHANGE: begin
AMsg.Msg := UINT(self);
FResultText := SelText;
if Assigned(FOnSelChange) then OnSelChange(AMsg);
end;
end;
if AMsg.WParamHi = WORD(CBN_ERRSPACE) then
MessageBox(Parent,'ComboBox Control Buffer Full!','Warning',MB_OK);
end;
end; // case
end;
procedure TAPIDDLCombo.ShowDropDown(value:Boolean);
begin
if value then
SendMessage(FHandle,CB_SHOWDROPDOWN,1,0)
else
SendMessage(FHandle,CB_SHOWDROPDOWN,0,0);
end;
//--------- TAPISMPCombo --------------------------------------------
procedure TAPISMPCombo.APICreateParams(var Params: TAPICreateParams);
begin
with Params do begin
Caption := '';
Style := $54010240 or WS_VSCROLL or CBS_SIMPLE;
ExStyle := WS_EX_CLIENTEDGE;
X := 50;
Y := 50;
Width := 150;
Height := 32;
WinClassName := 'COMBOBOX';
end;
end;
procedure TAPISMPCombo.DefaultHandler(var Message);
var
AMsg: TMessage;
begin
AMsg := TMessage(message);
case AMsg.Msg of
WM_COMMAND:begin
if (AMsg.LParam <> LPARAM(FHandle)) then exit;
case AMsg.WParamHi of
CBN_EDITCHANGE: begin
AMsg.Msg := UINT(self);
FResultText := EditText;
if Assigned(FOnEditChange) then OnEditChange(AMsg);
end;
CBN_SELCHANGE: begin
AMsg.Msg := UINT(self);
FResultText := SelText;
if Assigned(FOnSelChange) then OnSelChange(AMsg);
end;
end;
if AMsg.WParamHi = WORD(CBN_ERRSPACE) then
MessageBox(Parent,'ComboBox Control Buffer Full!','Warning',MB_OK);
end;
end; // case
end;
function TAPISMPCombo.GetEditText:string;
var
s:string;
Len: integer;
begin
SetLength(s,256);
Len := SendMessage(FHandle,WM_GETTEXT,256,integer(PChar(s)));
SetLength(s,Len);
result := s;
end;
procedure TAPISMPCombo.SetEditText(value:string);
var
AMsg: TMessage;
begin
SetWindowText(FHandle,PChar(value));
AMsg.Msg := WM_COMMAND;
AMsg.WParamHi := CBN_EDITCHANGE;
AMsg.WParamLo := FID;
AMsg.LParam := FHandle;
Dispatch(AMsg);
end;
//---------- TAPIDDCombo --------------------------------------------
procedure TAPIDDCombo.APICreateParams(var Params: TAPICreateParams);
begin
inherited APICreateParams(Params);
Params.Style := $54010240 or WS_VSCROLL or CBS_DROPDOWN;
end;
procedure TAPIDDCombo.ShowDropDown(value:Boolean);
begin
if value then
SendMessage(FHandle,CB_SHOWDROPDOWN,1,0)
else
SendMessage(FHandle,CB_SHOWDROPDOWN,0,0);
end;
function CreateDDLCombo(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPIDDLCombo;
begin
result := TAPIDDLCombo.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
OnSelChange := sOnSelChange;
end;
end;
function CreateSMPCombo(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPISMPCombo;
begin
result := TAPISMPCombo.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
OnSelChange := sOnSelChange;
end;
end;
function CreateDDCombo(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPIDDCombo;
begin
result := TAPIDDCombo.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
OnSelChange := sOnSelChange;
end;
end;
//---------- TAPIDriveCombo -----------------------------------------
procedure TAPIDriveCombo.Initialize;
var
i,r: integer;
s,t: string;
begin
inherited Initialize;
for i := byte('A') to byte('Z') do begin
s := Char(i)+':\';
r := GetDriveType(PChar(s));
case r of
DRIVE_UNKNOWN: t := 'Unknown';
DRIVE_NO_ROOT_DIR: t := 'No Root';
DRIVE_REMOVABLE: t := 'Removable';
DRIVE_FIXED: t := GetVolumeName(s);
DRIVE_REMOTE: t := 'Network';
DRIVE_CDROM: t := 'CD_ROM';
DRIVE_RAMDISK: t := 'RamDisk';
end;
if r >1 then begin
t := s+' '+t;
AddString(t);
end;
end;
end;
procedure TAPIDriveCombo.DefaultHandler(var Message);
var
AMsg: TMessage;
begin
AMsg := TMessage(message);
case AMsg.Msg of
WM_COMMAND:begin
if (AMsg.LParam <> LPARAM(FHandle)) then exit;
case AMsg.WParamHi of
CBN_SELCHANGE: begin
FRootDir := Copy(SelText,1,3);
GetVolumeInfo(FRootDir);
AMsg.Msg := UINT(self);
FResultText := SelText;
if Assigned(FOnSelChange) then OnSelChange(AMsg);
end;
end;
if AMsg.WParamHi = WORD(CBN_ERRSPACE) then
MessageBox(Parent,'ComboBox Control Buffer Full!','Warning',MB_OK);
end;
end; // case
end;
function TAPIDriveCombo.GetVolumeName(Root: string):string;
var
Vol,FileSys: array[0..100] of Char;
SN,MaxN,FSF: DWORD;
begin
GetVolumeInformation(PChar(Root),Vol,100,@SN,MaxN,FSF,FileSys,100);
result := '['+Vol+']';
end;
procedure TAPIDriveCombo.GetVolumeInfo(Root: string);
var
Vol,FileSys: array[0..100] of Char;
SN,MaxN,FSF: DWORD;
SectPerClstr,BytePerSect,FreeClstr,Clstr: DWORD;
begin
GetVolumeInformation(PChar(Root),Vol,100,@SN,MaxN,FSF,FileSys,100);
GetDiskFreeSpace(PChar(Root),SectPerClstr,BytePerSect,FreeClstr,Clstr);
FRootDir := Root;
FVolumeName := '['+Vol+']';
FFileSystem := FileSys;
FSerialNumber := SN;
FDiskSpace := Clstr*BytePerSect*SectPerClstr;
FFreeSpace := FreeClstr*BytePerSect*SectPerClstr;
FUsedSpace := DiskSpace-FreeSpace;
end;
function CreateDriveCombo(hParent: HWND; x,y,cx,cy: integer;
sOnSelChange:TNotifyMessage): TAPIDriveCombo;
begin
result := TAPIDriveCombo.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
OnSelChange := sOnSelChange;
end;
end;
//--------- APIHScroll --------------------------------------------
procedure TAPIHScroll.Initialize;
begin
inherited Initialize;
SetScrollrange(FHandle,SB_CTL,0,100,true);;// default range 0-100
FLargeChange := 10;
FSmallChange := 1;
Dispatcher.TrapMessage(WM_HSCROLL,self);
Dispatcher.TrapMessage(WM_VSCROLL,self);
Dispatcher.TrapMessage(WM_CTLCOLORSCROLLBAR,self);
end;
procedure TAPIHScroll.APICreateParams(var Params: TAPICreateParams);
begin
with Params do begin
Caption := '';
Style := $54010000;
ExStyle := 0;
X := 50;
Y := 50;
Width := 150;
Height := 32;
WinClassName := 'SCROLLBAR';
end;
end;
procedure TAPIHScroll.DefaultHandler(var Message);
var
AMsg: TMessage;
ScrPos: integer;
begin
AMsg := TMessage(Message);
case AMsg.Msg of
WM_HSCROLL,WM_VSCROLL: begin
if (AMsg.LParam <> LPARAM(FHandle)) then exit;
ScrPos := GetScrollPos(FHandle,SB_CTL);
case AMsg.WParamLo of
SB_THUMBPOSITION: begin
SetScrollPos(FHandle,SB_CTL,AMsg.WParamHi,true);
if Assigned(FOnChange) then OnChange(AMsg);
end;
SB_LINERIGHT: begin
SetScrollPos(FHandle,SB_CTL,ScrPos+FSmallChange,true);
if Assigned(FOnChange) then OnChange(AMsg);
end;
SB_LINELEFT: begin
SetScrollPos(FHandle,SB_CTL,ScrPos-FSmallChange,true);
if Assigned(FOnChange) then OnChange(AMsg);
end;
SB_PAGERIGHT: begin
SetScrollPos(FHandle,SB_CTL,ScrPos+FLargeChange,true);
if Assigned(FOnChange) then OnChange(AMsg);
end;
SB_PAGELEFT: begin
SetScrollPos(FHandle,SB_CTL,ScrPos-FLargeChange,true);
if Assigned(FOnChange) then OnChange(AMsg);
end;
SB_THUMBTRACK: begin
SetScrollPos(FHandle,SB_CTL,AMsg.WParamHi,true);
if Assigned(FOnTrack) then OnTrack(AMsg);
end;
SB_LEFT: begin
SetScrollPos(FHandle,SB_CTL,Min,true);
if Assigned(FOnChange) then OnChange(AMsg);
end;
SB_RIGHT: begin
SetScrollPos(FHandle,SB_CTL,Max,true);
if Assigned(FOnChange) then OnChange(AMsg);
end;
SB_ENDSCROLL: if Assigned(FOnChange) then OnChange(AMsg);
end; // case
end;
WM_CTLCOLORSCROLLBAR: if AMsg.LParam = LPARAM(FHandle) then
if FColor <> 0 then TMessage(Message).Result := CreateSolidBrush(FColor);
end;
end;
function TAPIHScroll.GetMin:integer;
var
AMax:integer;
begin
GetScrollRange(FHandle,SB_CTL,result,AMax);
end;
procedure TAPIHScroll.SetMin(value:integer);
begin
SetScrollrange(FHandle,SB_CTL,value,Max,true);
end;
function TAPIHScroll.GetMax:integer;
var
AMin:integer;
begin
GetScrollRange(FHandle,SB_CTL,AMin,result);
end;
procedure TAPIHScroll.SetMax(value:integer);
begin
SetScrollrange(FHandle,SB_CTL,Min,value,true);
end;
function TAPIHScroll.GetPosition: integer;
begin
result := GetScrollPos(FHandle,SB_CTL);
end;
procedure TAPIHScroll.SetPosition(value: integer);
var
AMsg: TMessage;
begin
with AMsg do begin
Msg := WM_HSCROLL;
WParamHi := value;
Result := 0;
LParam := FHandle;
WParamLo := SB_THUMBPOSITION;
end;
Dispatch(AMsg);
end;
function TAPIHScroll.GetThumbSize: integer;
var
si: TScrollInfo;
begin
si.cbSize := SizeOf(si);
si.fMask:= SIF_PAGE;
GetScrollInfo(FHandle,SB_CTL,si);
result := si.nPage;
end;
procedure TAPIHScroll.SetThumbSize(ASize: integer);
var
si: TScrollInfo;
begin
si.cbSize := SizeOf(si);
si.fMask:= SIF_PAGE;
si.nPage := ASize;
SetScrollInfo(FHandle,SB_CTL,si,true);
end;
procedure TAPIHScroll.SetColor(value: COLORREF);
begin
if FColor <> value then begin
FColor := value;
InvalidateRect(FHandle,nil,true);
end;
end;
//--------- APIVScroll --------------------------------------------
procedure TAPIVScroll.APICreateParams(var Params: TAPICreateParams);
begin
inherited APICreateParams(Params);
with Params do begin
Style := $54010001;
end;
end;
function CreateHScroll(hParent: HWND; x,y,cx,cy: integer;
sOnTrackChange:TNotifyMessage): TAPIHScroll;
begin
result := TAPIHScroll.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
OnChange := sOnTrackChange;
OnTrack := sOnTrackChange;
end;
end;
function CreateVScroll(hParent: HWND; x,y,cx,cy: integer;
sOnTrackChange:TNotifyMessage): TAPIVScroll;
begin
result := TAPIVScroll.Create(hParent);
with result do begin
Dimension := SetDim(x,y,cx,cy);
OnChange := sOnTrackChange;
OnTrack := sOnTrackChange;
end;
end;
//---------- TEnumFontComboBox --------------------------------------------
function EnumFontProcB(lpelf: PEnumLogFont;
lpntm: PNewTextMetric;
nFontType: integer;
lParam: LParam):integer; stdcall;
begin
result := 1;
if TEnumFontComboBox(lParam).FontType <> 0 then
if (nFontType and TEnumFontComboBox(lParam).FontType) = 0 then exit;
TEnumFontComboBox(lParam).AddString(string(lpelf^.elfLogFont.lfFaceName));
end;
function FindFontProcB(lpelf: PEnumLogFont;
lpntm: PNewTextMetric;
nFontType: integer;
lParam: LParam):integer; stdcall;
begin
PLogFont(lParam)^ := lpelf^.elfLogFont;
Result := 1;
end;
procedure TEnumFontComboBox.Initialize;
var
DC: HDC;
begin
inherited Initialize;
Clear;
DC := GetDC(Parent);
EnumFontFamilies(DC, nil, @EnumFontProcB,integer(self));
ReleaseDC(Parent,DC);
end;
function TEnumFontComboBox.GetSelLogFont: TLogFont;
var
DC: HDC;
begin
DC := GetDC(Parent);
EnumFontFamilies(DC,PChar(SelText),@FindFontProcB,integer(@result));
ReleaseDC(Parent,DC);
end;
procedure TEnumFontComboBox.SetFontType(value: integer);
var
DC: HDC;
begin
if FFontType = value then Exit;
FFontType := value;
Clear;
DC := GetDC(Parent);
EnumFontFamilies(DC, nil, @EnumFontProcB,integer(self));
ReleaseDC(Parent,DC);
end;
//---------- TEnumFontListBox --------------------------------------------
function EnumFontProc(lpelf: PEnumLogFont;
lpntm: PNewTextMetric;
nFontType: integer;
lParam: LParam):integer; stdcall;
begin
result := 1;
if TEnumFontListBox(lParam).FontType <> 0 then
if (nFontType and TEnumFontListBox(lParam).FontType) = 0 then exit;
TEnumFontListBox(lParam).AddString(string(lpelf^.elfLogFont.lfFaceName));
end;
function FindFontProc(lpelf: PEnumLogFont;
lpntm: PNewTextMetric;
nFontType: integer;
lParam: LParam):integer; stdcall;
begin
PLogFont(lParam)^ := lpelf^.elfLogFont;
Result := 1;
end;
procedure TEnumFontListBox.Initialize;
var
DC: HDC;
begin
inherited Initialize;
Clear;
DC := GetDC(Parent);
EnumFontFamilies(DC, nil, @EnumFontProc,integer(self));
ReleaseDC(Parent,DC);
end;
function TEnumFontListBox.GetSelLogFont: TLogFont;
var
DC: HDC;
begin
DC := GetDC(Parent);
EnumFontFamilies(DC,PChar(SelText),@FindFontProc,integer(@result));
ReleaseDC(Parent,DC);
end;
procedure TEnumFontListBox.SetFontType(value: integer);
var
DC: HDC;
begin
if FFontType = value then Exit;
FFontType := value;
Clear;
DC := GetDC(Parent);
EnumFontFamilies(DC, nil, @EnumFontProc,integer(self));
ReleaseDC(Parent,DC);
end;
end.
|
//
// VXScene Component Library, based on GLScene http://glscene.sourceforge.net
//
{
Design time registration code for the Sounds
History:
01/12/15 - PW - Creation.
}
unit VXS.SoundRegister;
interface
uses
System.Classes,
VXS.SMBASS,
VXS.SMFMOD,
VXS.SMOpenAL,
VXS.WaveOut;
procedure Register;
// ------------------------------------------------------------------
// ------------------------------------------------------------------
// ------------------------------------------------------------------
implementation
// ------------------------------------------------------------------
// ------------------------------------------------------------------
// ------------------------------------------------------------------
// Register
//
procedure Register;
begin
RegisterComponents('VXScene',[TVXSMBASS,TVXSMFMOD,TVXSMOpenAL,TVXSMWaveOut]);
end;
end.
|
unit uModBarcodeRequest;
interface
uses
SysUtils, Windows, Messages, Classes, Graphics, Controls, Forms, Dialogs, uModApp,
System.Generics.Collections, uModOrganization, uModUnit, uModBarang,
uModSatuan, uModSuplier, System.StrUtils;
type
TModBarcodeRequestItem = class;
TModBarcodeRequest = class(TModApp)
private
FBarcodeRequestItems: TOBjectList<TModBarcodeRequestItem>;
FBR_COLIE: Integer;
FBR_DESCRIPTION: string;
FBR_NO: string;
FBR_SUPMG: TModSuplierMerchanGroup;
FBR_DATE: tdatetime;
FBR_IS_INVOICED: Integer;
FBR_TOTAL: Double;
FBR_HARGA: Double;
FBR_UNIT: TModUnit;
function GetBarcodeRequestItems: TOBjectList<TModBarcodeRequestItem>;
function GetBR_DESCRIPTION: string;
public
property BarcodeRequestItems: TOBjectList<TModBarcodeRequestItem> read
GetBarcodeRequestItems write FBarcodeRequestItems;
published
property BR_COLIE: Integer read FBR_COLIE write FBR_COLIE;
[AttributeOfSize('120')]
property BR_DESCRIPTION: string read GetBR_DESCRIPTION write FBR_DESCRIPTION;
[AttributeOfCode]
property BR_NO: string read FBR_NO write FBR_NO;
property BR_SUPMG: TModSuplierMerchanGroup read FBR_SUPMG write FBR_SUPMG;
property BR_DATE: tdatetime read FBR_DATE write FBR_DATE;
property BR_IS_INVOICED: Integer read FBR_IS_INVOICED write FBR_IS_INVOICED;
property BR_TOTAL: Double read FBR_TOTAL write FBR_TOTAL;
property BR_HARGA: Double read FBR_HARGA write FBR_HARGA;
property BR_UNIT: TModUnit read FBR_UNIT write FBR_UNIT;
end;
TModBarcodeRequestItem = class(TModApp)
private
FBarcodeRequest: TModBarcodeRequest;
FBRI_BARANG: TModBarang;
FBRI_HARGA: Double;
FBRI_QTY: Double;
FBRI_SATUAN: TModSatuan;
FBRI_TOTAL: Double;
published
[AttributeOfHeader]
property BarcodeRequest: TModBarcodeRequest read FBarcodeRequest write
FBarcodeRequest;
property BRI_BARANG: TModBarang read FBRI_BARANG write FBRI_BARANG;
property BRI_HARGA: Double read FBRI_HARGA write FBRI_HARGA;
property BRI_QTY: Double read FBRI_QTY write FBRI_QTY;
property BRI_SATUAN: TModSatuan read FBRI_SATUAN write FBRI_SATUAN;
property BRI_TOTAL: Double read FBRI_TOTAL write FBRI_TOTAL;
end;
implementation
{
****************************** TModBarcodeRequest ******************************
}
function TModBarcodeRequest.GetBarcodeRequestItems:
TOBjectList<TModBarcodeRequestItem>;
begin
if FBarcodeRequestItems = nil then
FBarcodeRequestItems := TObjectList<TModBarcodeRequestItem>.Create();
Result := FBarcodeRequestItems;
end;
function TModBarcodeRequest.GetBR_DESCRIPTION: string;
begin
Result := LeftStr(FBR_DESCRIPTION,120);
end;
Initialization
TModBarcodeRequest.RegisterRTTI;
end.
|
unit AddOpTest;
interface
uses
DUnitX.TestFramework,
uIntXLibTypes,
// Classes,
uIntX,
uConstants;
type
[TestFixture]
TAddOpTest = class(TObject)
public
[Test]
procedure Add2IntX();
[Test]
procedure Add2IntXNeg();
[Test]
procedure AddIntIntX();
[Test]
procedure AddIntXInt();
procedure AddNullIntX();
[Test]
procedure CallAddNullIntX();
[Test]
procedure Add0IntX();
[Test]
procedure Add0IntXNeg();
[Test]
procedure Add2BigIntX();
[Test]
procedure Add2BigIntXC();
[Test]
procedure Add2BigIntXC2();
[Test]
procedure Add2BigIntXC3();
[Test]
procedure Add2BigIntXC4();
[Test]
procedure Fibon();
[Test]
procedure AddSub();
{
// Simple output (hex Fibonacci numbers). uncomment to see
[Test]
procedure FibonOut();
}
end;
implementation
[Test]
procedure TAddOpTest.Add2IntX();
var
int1, int2: TIntX;
begin
int1 := TIntX.Create(3);
int2 := TIntX.Create(5);
Assert.IsTrue(int1 + int2 = 8);
end;
[Test]
procedure TAddOpTest.Add2IntXNeg();
var
int1, int2: TIntX;
begin
int1 := TIntX.Create(-3);
int2 := TIntX.Create(-5);
Assert.IsTrue(int1 + int2 = -8);
end;
[Test]
procedure TAddOpTest.AddIntIntX();
var
IntX: TIntX;
begin
IntX := TIntX.Create(3);
Assert.IsTrue(IntX + 5 = 8);
end;
[Test]
procedure TAddOpTest.AddIntXInt();
var
IntX: TIntX;
begin
IntX := TIntX.Create(3);
Assert.IsTrue(5 + IntX = 8);
end;
procedure TAddOpTest.AddNullIntX();
var
int1: TIntX;
begin
int1 := TIntX.Create(3);
int1 := int1 + Default (TIntX);
end;
[Test]
procedure TAddOpTest.CallAddNullIntX();
var
TempMethod: TTestLocalMethod;
begin
TempMethod := AddNullIntX;
Assert.WillRaise(TempMethod, EArgumentNilException);
end;
[Test]
procedure TAddOpTest.Add0IntX();
var
int1: TIntX;
begin
int1 := TIntX.Create(3);
Assert.IsTrue(int1 + 0 = 3);
Assert.IsTrue(int1 + TIntX.Create(0) = 3);
end;
[Test]
procedure TAddOpTest.Add0IntXNeg();
var
int1: TIntX;
begin
int1 := TIntX.Create(-3);
Assert.IsTrue(int1 + 0 = -3);
Assert.IsTrue(int1 + TIntX.Create(0) = -3);
Assert.IsTrue(TIntX.Create(0) + TIntX.Create(-1) = -1);
Assert.IsTrue(TIntX.Create(0) + 0 = 0);
end;
[Test]
procedure TAddOpTest.Add2BigIntX();
var
temp1, temp2, temp3: TIntXLibUInt32Array;
int1, int2, int3: TIntX;
begin
SetLength(temp1, 3);
temp1[0] := 1;
temp1[1] := 2;
temp1[2] := 3;
SetLength(temp2, 3);
temp2[0] := 3;
temp2[1] := 4;
temp2[2] := 5;
SetLength(temp3, 3);
temp3[0] := 4;
temp3[1] := 6;
temp3[2] := 8;
int1 := TIntX.Create(temp1, False);
int2 := TIntX.Create(temp2, False);
int3 := TIntX.Create(temp3, False);
Assert.IsTrue(int1 + int2 = int3);
end;
[Test]
procedure TAddOpTest.Add2BigIntXC();
var
temp1, temp2, temp3: TIntXLibUInt32Array;
int1, int2, int3: TIntX;
begin
SetLength(temp1, 2);
temp1[0] := TConstants.MaxUInt32Value;
temp1[1] := TConstants.MaxUInt32Value - 1;
SetLength(temp2, 2);
temp2[0] := 1;
temp2[1] := 1;
SetLength(temp3, 3);
temp3[0] := 0;
temp3[1] := 0;
temp3[2] := 1;
int1 := TIntX.Create(temp1, False);
int2 := TIntX.Create(temp2, False);
int3 := TIntX.Create(temp3, False);
Assert.IsTrue(int1 + int2 = int3);
end;
[Test]
procedure TAddOpTest.Add2BigIntXC2();
var
temp1, temp2, temp3: TIntXLibUInt32Array;
int1, int2, int3: TIntX;
begin
SetLength(temp1, 2);
temp1[0] := TConstants.MaxUInt32Value - 1;
temp1[1] := TConstants.MaxUInt32Value - 1;
SetLength(temp2, 2);
temp2[0] := 1;
temp2[1] := 1;
SetLength(temp3, 2);
temp3[0] := TConstants.MaxUInt32Value;
temp3[1] := TConstants.MaxUInt32Value;
int1 := TIntX.Create(temp1, False);
int2 := TIntX.Create(temp2, False);
int3 := TIntX.Create(temp3, False);
Assert.IsTrue(int1 + int2 = int3);
end;
[Test]
procedure TAddOpTest.Add2BigIntXC3();
var
temp1, temp2, temp3: TIntXLibUInt32Array;
int1, int2, int3: TIntX;
begin
SetLength(temp1, 2);
temp1[0] := TConstants.MaxUInt32Value;
temp1[1] := TConstants.MaxUInt32Value;
SetLength(temp2, 2);
temp2[0] := 1;
temp2[1] := 1;
SetLength(temp3, 3);
temp3[0] := 0;
temp3[1] := 1;
temp3[2] := 1;
int1 := TIntX.Create(temp1, False);
int2 := TIntX.Create(temp2, False);
int3 := TIntX.Create(temp3, False);
Assert.IsTrue(int1 + int2 = int3);
end;
[Test]
procedure TAddOpTest.Add2BigIntXC4();
var
temp1, temp2, temp3: TIntXLibUInt32Array;
int1, int2, int3: TIntX;
begin
SetLength(temp1, 4);
temp1[0] := TConstants.MaxUInt32Value;
temp1[1] := TConstants.MaxUInt32Value;
temp1[2] := 1;
temp1[3] := 1;
SetLength(temp2, 2);
temp2[0] := 1;
temp2[1] := 1;
SetLength(temp3, 4);
temp3[0] := 0;
temp3[1] := 1;
temp3[2] := 2;
temp3[3] := 1;
int1 := TIntX.Create(temp1, False);
int2 := TIntX.Create(temp2, False);
int3 := TIntX.Create(temp3, False);
Assert.IsTrue(int1 + int2 = int3);
end;
[Test]
procedure TAddOpTest.Fibon();
var
int1, int2, int3: TIntX;
i: Integer;
begin
int1 := TIntX.Create(1);
int2 := int1;
int3 := Default (TIntX);
i := 0;
while i <= Pred(10000) do
begin
int3 := int1 + int2;
int1 := int2;
int2 := int3;
Inc(i);
end;
end;
[Test]
procedure TAddOpTest.AddSub();
var
int1, int2: TIntX;
begin
int1 := TIntX.Create(2);
int2 := TIntX.Create(-2);
Assert.IsTrue(int1 + int2 = 0);
end;
// Simple output (hex Fibonacci numbers). Uncomment to see
(*
[Test]
procedure TAddOpTest.FibonOut();
var
numberBase: UInt32;
Writer: TStreamWriter;
int1, int2, int3: TIntX;
i: Integer;
begin
numberBase := 16;
Writer := TStreamWriter.Create('fibon.txt');
try
int1 := TIntX.Create(1);
Writer.WriteLine(int1.ToString(numberBase));
int2 := int1;
Writer.WriteLine(int2.ToString(numberBase));
int3 := Default (TIntX);
for i := 0 to Pred(1000) do
begin
int3 := int1 + int2;
Writer.WriteLine(int3.ToString(numberBase));
int1 := int2;
int2 := int3;
end;
finally
Writer.Free;
end;
end;
*)
initialization
TDUnitX.RegisterTestFixture(TAddOpTest);
end.
|
unit NotesResourceU;
// EMS Resource Module
interface
uses
System.SysUtils, System.Classes, System.JSON,
EMS.Services, EMS.ResourceAPI, EMS.ResourceTypes, NotesManagerU,
NoteTypesU, NotesSwaggerU;
type
// Swagger for request and response body
[EndPointObjectsYAMLDefinitions(sYMALBody)]
[EndPointObjectsJSONDefinitions(sJSONBody)]
[ResourceName('Notes')]
TNotesResource1 = class(TDataModule)
private
FNotesManager: TNotesManager;
procedure CheckNotesManager(const AContext: TEndpointContext);
procedure HandleException;
procedure RespondWithNote(const AResponse: TEndpointResponse;
const ATitle: string);
public
destructor Destroy; override;
public
// Swagger for GetAll
// Add session token parameter because EMS does not automatically add
[EndPointRequestParameter(TAPIDocParameter.TParameterIn.Header, 'X-Embarcadero-Session-Token', 'Session Token', false, TAPIDoc.TPrimitiveType.spString,
TAPIDoc.TPrimitiveFormat.None, TAPIDoc.TPrimitiveType.spString, '', '')]
[EndPointRequestSummary('Notes', 'Get all', 'Get all notes', 'application/json', '')]
[EndPointResponseDetails(200, 'OK', TAPIDoc.TPrimitiveType.spArray, TAPIDoc.TPrimitiveFormat.None, '', '#/definitions/entityObject')]
[EndPointResponseDetails(401, 'Login required', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
procedure GetAll(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
// Swagger for GetNote
[EndPointRequestParameter(TAPIDocParameter.TParameterIn.Header, 'X-Embarcadero-Session-Token', 'Session Token', false, TAPIDoc.TPrimitiveType.spString,
TAPIDoc.TPrimitiveFormat.None, TAPIDoc.TPrimitiveType.spString, '', '')]
[EndPointRequestSummary('Notes', 'Get one', 'Get a note', 'application/json', '')]
[EndPointRequestParameter(TAPIDocParameter.TParameterIn.Path, 'title', 'Note title', true, TAPIDoc.TPrimitiveType.spString,
TAPIDoc.TPrimitiveFormat.None, TAPIDoc.TPrimitiveType.spString, '', '')]
[EndPointResponseDetails(200, 'OK', TAPIDoc.TPrimitiveType.spObject, TAPIDoc.TPrimitiveFormat.None, '', '#/definitions/entityObject')]
[EndPointResponseDetails(404, 'Note not found', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
[EndPointResponseDetails(401, 'Login required', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
[ResourceSuffix('{title}')]
procedure GetNote(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
// Swagger for PostNote
[EndPointRequestParameter(TAPIDocParameter.TParameterIn.Header, 'X-Embarcadero-Session-Token', 'Session Token', false, TAPIDoc.TPrimitiveType.spString,
TAPIDoc.TPrimitiveFormat.None, TAPIDoc.TPrimitiveType.spString, '', '')]
[EndPointRequestSummary('Notes', 'Create', 'Create a new note', 'application/json', 'application/json')]
[EndPointRequestParameter(TAPIDocParameter.TParameterIn.Body, 'body', 'Note title and text', true, TAPIDoc.TPrimitiveType.spObject,
TAPIDoc.TPrimitiveFormat.None, TAPIDoc.TPrimitiveType.spObject, '', '#/definitions/entityObject')]
[EndPointResponseDetails(201, 'Note created', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
[EndPointResponseDetails(409, 'Note already exists', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
[EndPointResponseDetails(401, 'Login required', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
[EndPointResponseDetails(400, 'Incorrect JSON', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
procedure PostNote(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
// Swagger for PutNote
[EndPointRequestParameter(TAPIDocParameter.TParameterIn.Header, 'X-Embarcadero-Session-Token', 'Session Token', false, TAPIDoc.TPrimitiveType.spString,
TAPIDoc.TPrimitiveFormat.None, TAPIDoc.TPrimitiveType.spString, '', '')]
[EndPointRequestSummary('Notes', 'Update', 'Update a note', 'application/json', 'application/json')]
[EndPointRequestParameter(TAPIDocParameter.TParameterIn.Path, 'title', 'Note title', true, TAPIDoc.TPrimitiveType.spString,
TAPIDoc.TPrimitiveFormat.None, TAPIDoc.TPrimitiveType.spString, '', '')]
[EndPointRequestParameter(TAPIDocParameter.TParameterIn.Body, 'body', 'Note text', true, TAPIDoc.TPrimitiveType.spObject,
TAPIDoc.TPrimitiveFormat.None, TAPIDoc.TPrimitiveType.spObject, '', '#/definitions/updateEntityObject')]
[EndPointResponseDetails(200, 'OK', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '#/definitions/entityObject')]
[EndPointResponseDetails(404, 'Note not found', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
[EndPointResponseDetails(401, 'Login required', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
[ResourceSuffix('{title}')]
procedure PutNote(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
// Swagger for DeleteNote
[EndPointRequestParameter(TAPIDocParameter.TParameterIn.Header, 'X-Embarcadero-Session-Token', 'Session Token', false, TAPIDoc.TPrimitiveType.spString,
TAPIDoc.TPrimitiveFormat.None, TAPIDoc.TPrimitiveType.spString, '', '')]
[EndPointRequestSummary('Notes', 'Delete', 'Delete a note', '', '')]
[EndPointRequestParameter(TAPIDocParameter.TParameterIn.Path, 'title', 'Note title', true, TAPIDoc.TPrimitiveType.spString,
TAPIDoc.TPrimitiveFormat.None, TAPIDoc.TPrimitiveType.spString, 'application/json', '')]
[EndPointResponseDetails(200, 'OK', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
[EndPointResponseDetails(404, 'Note not found', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
[EndPointResponseDetails(401, 'Login required', TAPIDoc.TPrimitiveType.spNull, TAPIDoc.TPrimitiveFormat.None, '', '')]
[ResourceSuffix('{title}')]
procedure DeleteNote(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
end;
procedure Register;
implementation
{%CLASSGROUP 'System.Classes.TPersistent'}
{$R *.dfm}
function GetModuleDirectory: string;
begin
Result := ExtractFilePath(StringReplace(GetModuleName(HInstance),'\\?\','',[rfReplaceAll]));
end;
destructor TNotesResource1.Destroy;
begin
FNotesManager.Free;
inherited;
end;
// Call this from within an exception block
procedure TNotesResource1.HandleException;
var
LException: TObject;
LMessage: string;
begin
LException := ExceptObject;
Assert(LException <> nil); // should be within an except block
if LException is Exception then
begin
LMessage := Exception(LException).Message;
if LException is ENoteDuplicate then
EEMSHTTPError.RaiseDuplicate('', LMessage) // 409
else if LException is ENoteNotFound then
EEMSHTTPError.RaiseNotFound('', LMessage) // 404
else if LException is ENoteMissingTitle then
EEMSHTTPError.RaiseBadRequest('', LMessage) // 400
else
begin
LException := TObject(AcquireExceptionObject);
Assert(LException <> nil); // should be within an except block
raise LException;
end;
end;
end;
procedure TNotesResource1.CheckNotesManager(const AContext: TEndpointContext);
begin
if AContext.User = nil then
EEMSHTTPError.RaiseUnauthorized('', 'The operation is only permitted for logged in users'); // 401
if FNotesManager = nil then
FNotesManager := TNotesManager.Create(GetModuleDirectory, AContext.User.UserID);
end;
procedure TNotesResource1.GetAll(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
var
LNotes: TArray<TNote>;
LJSON: TJSONArray;
begin
LJSON := nil;
try
CheckNotesManager(AContext);
LNotes := FNotesManager.GetNotes;
LJSON := TJSONArray.Create;
TNoteJSON.NotesToJSON(LNotes, LJSON);
AResponse.Body.SetValue(LJSON, True) // AResponse owns LJSONArray and will free it
except
LJSON.Free;
HandleException;
end;
end;
procedure TNotesResource1.GetNote(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
var
LTitle: string;
begin
try
CheckNotesManager(AContext);
LTitle := ARequest.Params.Values['title'];
RespondWithNote(AResponse, LTitle);
except
HandleException;
end;
end;
procedure TNotesResource1.PostNote(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
var
LJSON: TJSONObject;
LNote: TNote;
begin
try
if ARequest.Body.TryGetObject(LJSON) then
begin
CheckNotesManager(AContext);
LNote := TNoteJSON.JSONToNote(LJSON);
FNotesManager.AddNote(LNote);
RespondWithNote(AResponse, LNote.Title);
AResponse.SetCreated(LNote.Title); // 201 response
end
else
AResponse.RaiseBadRequest('JSON expected'); // 400
except
HandleException;
end;
end;
procedure TNotesResource1.PutNote(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
var
LTitle: string;
LJSON: TJSONObject;
LNote: TNote;
begin
try
CheckNotesManager(AContext);
LTitle := ARequest.Params.Values['title'];
if ARequest.Body.TryGetObject(LJSON) then
begin
LNote := TNoteJSON.JSONToNote(LJSON);
FNotesManager.UpdateNote(LTitle, LNote);
RespondWithNote(AResponse, LTitle);
end
else
AResponse.RaiseBadRequest('JSON expected'); // 400
except
HandleException;
end;
end;
procedure TNotesResource1.DeleteNote(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
var
LTitle: string;
begin
try
CheckNotesManager(AContext);
LTitle := ARequest.Params.Values['title'];
FNotesManager.DeleteNote(LTitle);
except
HandleException;
end;
end;
procedure TNotesResource1.RespondWithNote(const AResponse: TEndpointResponse; const ATitle: string);
var
LNote: TNote;
LJSON: TJSONObject;
begin
Assert(FNotesManager <> nil);
LNote := FNotesManager.GetNote(ATitle);
LJSON := TJSONObject.Create;
TNoteJSON.NoteToJSON(LNote, LJSON);
AResponse.Body.SetValue(LJSON, True); // AResponse owns LJSONObject and will free it
end;
procedure Register;
begin
RegisterResource(TypeInfo(TNotesResource1));
end;
end.
|
unit Common.Entities.Card;
interface
uses
Spring, Neon.Core.Attributes, System.Generics.Defaults,
System.Generics.Collections,Graphics, System.JSON, Neon.Core.Types,
Neon.Core.Persistence;
type
TCardType=(ctTarock,ctHeart,ctSpade,ctCross,ctDiamond);
[NeonInclude(IncludeIf.Always)]
TCardKey=(None,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,
H1,H2,H3,H4,HB,HR,HD,HK,D1,D2,D3,D4,DB,DR,DD,DK,
S7,S8,S9,S10,SB,SR,SD,SK,C7,C8,C9,C10,CB,CR,CD,CK);
TCard=class(TObject)
private
FFold: Boolean;
FID: TCardKey;
FValue: Byte;
FImageIndex: Integer;
FCType: TCardType;
FPoints: Byte;
public
property ID:TCardKey read FID write FID;
property CType:TCardType read FCType write FCType;
property Value:Byte read FValue write FValue;
property Points:Byte read FPoints write FPoints;
property ImageIndex:Integer read FImageIndex write FImageIndex;
property Fold:Boolean read FFold write FFold;
procedure Assign(const ASource:TCard);
function Clone:TCard;
function IsStronger(const ACard:TCard; const AColorGame:Boolean):Boolean;
end;
TCardsComparer=class(TComparer<TCard>)
function Compare(const Left, Right: TCard): Integer; override;
end;
TCards=class(TObjectList<TCard>)
private
function GetUnFoldCount: Integer;
public
function AddItem(AID:TCardKey;ACType:TCardType;AValue:Byte;APoints:Byte;AImageIdx:Integer):TCard;
function Clone:TCards;
procedure Assign(const ASource:TCards);
function Find(const AID:TCardKey):TCard;
function Exists(const AID:TCardKey):Boolean;
function ExistsUnfold(const AID: TCardKey): Boolean;
function ExistsCardType(const ACType:TCardType):Boolean;
function ExistsStronger(const ACard:TCard; const AColorGame:Boolean):Boolean;
procedure Sort;
property UnFoldCount:Integer read GetUnFoldCount;
end;
TCardKeySerializer=class(TCustomSerializer)
protected
class function GetTargetInfo: PTypeInfo; override;
// class function CanHandle(AType: PTypeInfo): Boolean; override;
public
function Serialize(const AValue: TValue; ANeonObject: TNeonRttiObject; AContext: ISerializerContext): TJSONValue; override;
function Deserialize(AValue:TJsonValue;const AData:TValue;ANeonObject: TNeonRttiObject; AContext:IDeserializerContext):TValue;override;
end;
var ALLCARDS:TCards;
procedure Initialize;
procedure TearDown;
implementation
uses SysUtils;
procedure Initialize;
begin
ALLCARDS:=TCards.Create;
ALLCARDS.AddItem(T1,ctTarock,1,5,0);
ALLCARDS.AddItem(T2,ctTarock,2,1,1);
ALLCARDS.AddItem(T3,ctTarock,3,1,2);
ALLCARDS.AddItem(T4,ctTarock,4,1,3);
ALLCARDS.AddItem(T5,ctTarock,5,1,4);
ALLCARDS.AddItem(T6,ctTarock,6,1,5);
ALLCARDS.AddItem(T7,ctTarock,7,1,6);
ALLCARDS.AddItem(T8,ctTarock,8,1,7);
ALLCARDS.AddItem(T9,ctTarock,9,1,8);
ALLCARDS.AddItem(T10,ctTarock,10,1,9);
ALLCARDS.AddItem(T11,ctTarock,11,1,10);
ALLCARDS.AddItem(T12,ctTarock,12,1,11);
ALLCARDS.AddItem(T13,ctTarock,13,1,12);
ALLCARDS.AddItem(T14,ctTarock,14,1,13);
ALLCARDS.AddItem(T15,ctTarock,15,1,14);
ALLCARDS.AddItem(T16,ctTarock,16,1,15);
ALLCARDS.AddItem(T17,ctTarock,17,1,16);
ALLCARDS.AddItem(T18,ctTarock,18,1,17);
ALLCARDS.AddItem(T19,ctTarock,19,1,18);
ALLCARDS.AddItem(T20,ctTarock,20,1,19);
ALLCARDS.AddItem(T21,ctTarock,21,5,20);
ALLCARDS.AddItem(T22,ctTarock,22,5,21);
ALLCARDS.AddItem(H4,ctHeart,1,1,22);
ALLCARDS.AddItem(H3,ctHeart,2,1,23);
ALLCARDS.AddItem(H2,ctHeart,3,1,24);
ALLCARDS.AddItem(H1,ctHeart,4,1,25);
ALLCARDS.AddItem(HB,ctHeart,5,2,26);
ALLCARDS.AddItem(HR,ctHeart,6,3,27);
ALLCARDS.AddItem(HD,ctHeart,7,4,28);
ALLCARDS.AddItem(HK,ctHeart,8,5,29);
ALLCARDS.AddItem(D4,ctDiamond,1,1,30);
ALLCARDS.AddItem(D3,ctDiamond,2,1,31);
ALLCARDS.AddItem(D2,ctDiamond,3,1,32);
ALLCARDS.AddItem(D1,ctDiamond,4,1,33);
ALLCARDS.AddItem(DB,ctDiamond,5,2,34);
ALLCARDS.AddItem(DR,ctDiamond,6,3,35);
ALLCARDS.AddItem(DD,ctDiamond,7,4,36);
ALLCARDS.AddItem(DK,ctDiamond,8,5,37);
ALLCARDS.AddItem(C7,ctCross,1,1,38);
ALLCARDS.AddItem(C8,ctCross,2,1,39);
ALLCARDS.AddItem(C9,ctCross,3,1,40);
ALLCARDS.AddItem(C10,ctCross,4,1,41);
ALLCARDS.AddItem(CB,ctCross,5,2,42);
ALLCARDS.AddItem(CR,ctCross,6,3,43);
ALLCARDS.AddItem(CD,ctCross,7,4,44);
ALLCARDS.AddItem(CK,ctCross,8,5,45);
ALLCARDS.AddItem(S7,ctSpade,1,1,46);
ALLCARDS.AddItem(S8,ctSpade,2,1,47);
ALLCARDS.AddItem(S9,ctSpade,3,1,48);
ALLCARDS.AddItem(S10,ctSpade,4,1,49);
ALLCARDS.AddItem(SB,ctSpade,5,2,50);
ALLCARDS.AddItem(SR,ctSpade,6,3,51);
ALLCARDS.AddItem(SD,ctSpade,7,4,52);
ALLCARDS.AddItem(SK,ctSpade,8,5,53);
end;
procedure TearDown;
begin
ALLCARDS.Free;
ALLCARDS:=nil;
end;
{ TCards }
function TCards.AddItem(AID:TCardKey;ACType:TCardType;AValue:Byte;APoints:Byte; AImageIdx:Integer): TCard;
begin
Result:=TCard.Create;
Result.ID:=AID;
Result.CType:=ACType;
Result.Value:=AValue;
Result.Points:=APoints;
Result.ImageIndex:=AImageIdx;
Result.Fold:=False;
Add(Result);
end;
function TCards.Clone:TCards;
begin
Result:=TCards.Create(True);
Result.Assign(Self);
end;
function TCards.Exists(const AID: TCardKey): Boolean;
begin
Result:=Assigned(Find(AID));
end;
function TCards.ExistsUnfold(const AID: TCardKey): Boolean;
var itm:TCard;
begin
itm:=Find(AID);
Result:=Assigned(itm) and not itm.Fold;
end;
function TCards.ExistsCardType(const ACType: TCardType): Boolean;
var itm:TCard;
begin
Result:=False;
for itm in Self do begin
if not itm.Fold and (itm.CType=ACType) then begin
Result:=True;
Exit;
end;
end;
end;
function TCards.ExistsStronger(const ACard: TCard; const AColorGame:Boolean): Boolean;
var itm:TCard;
begin
Result:=False;
for itm in Self do begin
if not itm.Fold and itm.IsStronger(ACard,AColorGame) then begin
Result:=True;
Break;
end;
end;
end;
function TCards.Find(const AID:TCardKey): TCard;
var itm:TCard;
begin
Result:=nil;
for itm in Self do begin
if itm.ID=AID then begin
Result:=itm;
Break;
end;
end;
end;
function TCards.GetUnFoldCount: Integer;
var
itm: TCard;
begin
Result:=0;
for itm in Self do
if not itm.Fold then
Inc(Result);
end;
procedure TCards.Sort;
var comp:TCardsComparer;
begin
comp:=TCardsComparer.Create;
try
inherited Sort(comp)
finally
comp.Free;
end;
end;
procedure TCards.Assign(const ASource:TCards);
var itm:TCard;
begin
for itm in ASource do begin
AddItem(itm.ID,itm.CType,itm.Value,itm.Points,itm.ImageIndex).Fold:=itm.Fold;
end;
end;
{ TCardsComparer }
function TCardsComparer.Compare(const Left, Right: TCard): Integer;
begin
if Ord(Left.CType)=Ord(Right.CType) then begin
Result:=Left.Value-Right.Value
end
else
Result:=Ord(Left.CType)-Ord(Right.CType);
end;
{ TCard }
procedure TCard.Assign(const ASource: TCard);
begin
FID:=ASource.FID;
FCType:=ASource.FCType;
FValue:=ASource.FValue;
FImageIndex:=ASource.FImageIndex;
FFold:=ASource.FFold;
end;
function TCard.Clone: TCard;
begin
Result:=TCard.Create;
Result.Assign(Self);
end;
function TCard.IsStronger(const ACard: TCard; const AColorGame:Boolean): Boolean;
begin
if CType=ACard.CType then
Result:=Value>ACard.Value
else if not AColorGame then
Result:=CType=ctTarock
else
Result:=false;
end;
{ TCardKeySerializer }
function TCardKeySerializer.Deserialize(AValue:TJsonValue;const AData:TValue;
ANeonObject: TNeonRttiObject; AContext:IDeserializerContext): TValue;
var cd:TCardKey;
begin
inherited;
cd:=TCardKey(StrToInt(AValue.ToString));
Result:= TValue.From<TCardKey>(cd)
end;
class function TCardKeySerializer.GetTargetInfo: PTypeInfo;
begin
Result := TypeInfo(TCardKey);
end;
function TCardKeySerializer.Serialize(const AValue: TValue; ANeonObject: TNeonRttiObject; AContext: ISerializerContext): TJSONValue;
begin
Result:=TJSONNumber.Create(AValue.AsOrdinal);
end;
end.
|
unit Uatualizador;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ExtCtrls, TFlatButtonUnit, StdCtrls, IdBaseComponent,
IdComponent, IdTCPConnection, IdTCPClient, IdFTP,funcoes, AppEvnts,
TFlatGaugeUnit, IdDayTime, IdExplicitTLSClientServerBase;
type
TForm1 = class(TForm)
Panel1: TPanel;
FlatButton1: TFlatButton;
FTP: TIdFTP;
ApplicationEvents1: TApplicationEvents;
Gauge1: TFlatGauge;
Label1: TLabel;
Label2: TLabel;
dt: TIdDayTime;
Label3: TLabel;
procedure FlatButton1Click(Sender: TObject);
procedure ApplicationEvents1Exception(Sender: TObject; E: Exception);
function BaixarArquivo(DadosDoArquivo:string):boolean;
procedure FTPWork(Sender: TObject; AWorkMode: TWorkMode;const AWorkCount: Integer);
function DataArqFTP(dadosArq:string):Tdatetime;
function DefineDataHoraArq(NomeArq: string; DataHora: TDateTime): boolean;
procedure FTPWorkEnd(Sender: TObject; AWorkMode: TWorkMode);
procedure FormActivate(Sender: TObject);
procedure MostraMensagem(sender:Tobject;Mensagem:string);
function AcertarDataeHora(l:string):boolean;
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
PATH_DEST,PATH,ARQ_INI:STRING;
TAMANHOARQUIVO:INTEGER;
implementation
{$R *.dfm}
procedure TForm1.FormActivate(Sender: TObject);
begin
PATH := ExtractFilePath(ParamStr(0));
ARQ_INI := ParamStr(1);
PATH_DEST := funcoes.lerParam(arq_ini,01);
Label1.caption:= Label1.caption + funcoes.lerParam(arq_ini,02);
if ParamStr(2) <> '' then
flatButton1.Visible := true
else
FlatButton1Click(Sender);
end;
function tform1.AcertarDataeHora(l:string):boolean;
var
SystemTime : TSystemTime;
dia,mes,ano,hora,min:string;
horaEmInteiro,i:integer;
begin
for i:=1 to pos(':',l)-1 do
hora := hora + l[i];
if length(hora) < 2 then insert('0',hora,01);
delete(l,01,pos(':',l));
for i:=1 to pos(':',l)-1 do
min := min + l[i];
delete(l,i,pos(':',l));
if length(min) < 2 then insert('0',min,01);
for i:=0 to pos(' ',l)do
delete(l,1,pos(' ',l));
for i:=1 to pos('/',l)-1 do
dia := dia + l[i];
if length(dia) < 2 then insert('0',dia,01);
delete(l,1,pos('/',l));
for i:=1 to pos('/',l)-1 do
mes := mes + l[i];
if length(mes) < 2 then insert('0',mes,01);
delete(l,1,pos('/',l));
ano:=copy(l,01,04);
With SystemTime do
begin
//Definindo o dia do sistema
wYear:= StrToint(ano);
wMonth:= StrToint(mes);
wDay:= StrToint(dia);
wHour:= StrToint(hora);
wMinute:= StrToint(min);
wSecond:= 00;
end;
SetLocalTime(SystemTime);
funcoes.GravaLinhaEmUmArquivo(funcoes.tempdir()+'AcertosAcertaHora.txt','Acerto da hora '+ hora +' '+ min );
end;
procedure TForm1.ApplicationEvents1Exception(Sender: TObject; E: Exception);
begin
showmessage(' - Ocorreu o seguinte erro no programa ' +#13+#13+ e.Message);
Application.Terminate;
end;
procedure TForm1.FTPWork(Sender: TObject; AWorkMode: TWorkMode; const AWorkCount: Integer);
begin
if TAMANHOARQUIVO <> 0 then;
begin
gauge1.Progress := AWorkCount;
label3.Caption := InttoStr(AWorkCount) + ' de ' + InttoStr(TAMANHOARQUIVO);
end;
end;
procedure TForm1.FlatButton1Click(Sender: TObject);
var
i:integer;
items:tstringList;
begin
items := tstringList.Create;
try
if ftp.Connected = true then
ftp.Disconnect;
ftp.ReadTimeout := 300;
ftp.Connect();
ftp.ChangeDir('\');
ftp.ChangeDir(funcoes.tiraEspaco(funcoes.lerParam(ARQ_INI,00)));
ftp.List(Items);
for i:=0 to Items.Count-1 do
begin
MostraMensagem(sender, ExtractFilename(copy(items[i], 40,100)) );
BaixarArquivo(Items[i]);
end;
if uppercase(funcoes.lerParam(ARQ_INI,04)) = 'S' then
begin
MostraMensagem(sender, 'Verificando data e hora');
AcertarDataeHora( dt.DayTimeStr);
end;
except
on e: exception do
begin
ApplicationEvents1Exception(Sender,e);
end
end;
MostraMensagem(sender,' Executar ' + funcoes.lerParam(arq_ini,02) ) ;
winexec(pchar(funcoes.lerParam(ARQ_INI,03)),sw_normal );
application.terminate;
end;
function TForm1.BaixarArquivo(DadosDoArquivo: string): boolean;
var
arq:string;
begin
TAMANHOARQUIVO := StrToint( funcoes.tiraEspaco(copy(DadosDoArquivo,23,15) ) );
arq := ExtractFilename(copy(DadosDoArquivo, 40,100));
if (FileExists( FUNCOES.lerParam(ARQ_INI,01) + arq) = false) or ( funcoes.DataDoArquivo( FUNCOES.lerParam(ARQ_INI,01) + arq) < DataArqFTP(DadosDoArquivo) ) then
begin
gauge1.visible := true;
gauge1.MaxValue := TAMANHOARQUIVO;
ftp.Get(arq, ExtractFilePath(funcoes.lerParam(ARQ_INI,01)) + arq, true,false );
DefineDataHoraArq( ExtractFilePath(funcoes.lerParam(ARQ_INI,01))+arq , DataArqFTP(DadosDoArquivo) ) ;
result := true;
end;
end;
function tform1.DefineDataHoraArq(NomeArq: string; DataHora: TDateTime): boolean;
var
F: integer;
begin
Result := false;
F := FileOpen(NomeArq, fmOpenWrite or fmShareDenyNone);
try
if F > 0 then
begin
Result := FileSetDate(F, DateTimeToFileDate(DataHora)) = 0;
Result := true;
end;
finally
FileClose(F);
end;
end;
function TForm1.DataArqFTP(dadosArq: string): Tdatetime;
var
data:string;
hora:integer;
begin
hora := strtoint( copy(dadosArq,11,02) );
if copy(dadosArq,16,02) = 'PM' then
hora := hora+12;
result := StrToDateTime (copy(dadosArq,04,02) +'/'+ copy(dadosArq,01,02) +'/20'+ copy(dadosArq,07,02) +' '+intToStr(hora) +':'+ copy(dadosArq,14,02) + ':00' ) ;
end;
procedure TForm1.FTPWorkEnd(Sender: TObject; AWorkMode: TWorkMode);
begin
form1.Refresh;
sleep(300);
gauge1.Visible := false;
end;
procedure TForm1.MostraMensagem(sender: Tobject; Mensagem: string);
begin
label2.caption := ' Verificando - ' + Mensagem;
form1.Refresh;
sleep(300);
end;
end.
|
unit uFrmStoreType;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Buttons, ExtCtrls, uSystemConst, ComCtrls, Mask;
type
TFrmStoreType = class(TForm)
Panel1: TPanel;
BitBtn1: TBitBtn;
BitBtn2: TBitBtn;
edtCustomer: TEdit;
Label1: TLabel;
btnAddStore: TSpeedButton;
Bevel1: TBevel;
Bevel2: TBevel;
Label2: TLabel;
edtStore: TEdit;
Label3: TLabel;
edtPW: TEdit;
treeCustomer: TTreeView;
btnDel: TSpeedButton;
Label4: TLabel;
edtConnection: TEdit;
Label5: TLabel;
edtSchedule: TEdit;
btnOpenConnection: TSpeedButton;
btnOpenSchedule: TSpeedButton;
btnTestConnection: TSpeedButton;
Label6: TLabel;
edtVersion: TEdit;
chkDisableSchedule: TCheckBox;
Label7: TLabel;
edtRepSince: TEdit;
btnSaveSchedule: TSpeedButton;
Label8: TLabel;
edtMainStore: TEdit;
pnlProcessor: TPanel;
Label9: TLabel;
edtHost: TEdit;
Label10: TLabel;
edtPort: TEdit;
Label11: TLabel;
edtStoreAuth: TEdit;
Label12: TLabel;
edtPassword: TMaskEdit;
Label13: TLabel;
edtPacketSize: TEdit;
Label14: TLabel;
cmbServerType: TComboBox;
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure btnAddStoreClick(Sender: TObject);
procedure edtCustomerKeyPress(Sender: TObject; var Key: Char);
procedure btnDelClick(Sender: TObject);
procedure treeCustomerClick(Sender: TObject);
procedure btnOpenConnectionClick(Sender: TObject);
procedure btnOpenScheduleClick(Sender: TObject);
procedure btnTestConnectionClick(Sender: TObject);
procedure edtRepSinceChange(Sender: TObject);
procedure chkDisableScheduleClick(Sender: TObject);
procedure btnSaveScheduleClick(Sender: TObject);
procedure cmbServerTypeChange(Sender: TObject);
private
{ Private declarations }
procedure GetStores;
procedure ClearFields;
function DeleteStore:Boolean;
function ValitadeFields:Boolean;
function SetStores(sCustomer, sStore, sPW : String):Boolean;
procedure SetEnabladpnlProcessor(AEnabled: Boolean);
public
{ Public declarations }
function Start:Boolean;
end;
implementation
uses uDMServer, uMainConf, ADODB, uFileFunctions, uEncryptFunctions, uFrmSchedule,
IniFiles, uParamFunctions;
{$R *.dfm}
function TFrmStoreType.Start:Boolean;
begin
GetStores;
ShowModal;
Result := (ModalResult=mrOK);
end;
procedure TFrmStoreType.FormClose(Sender: TObject;
var Action: TCloseAction);
begin
Action := caFree;
end;
procedure TFrmStoreType.btnAddStoreClick(Sender: TObject);
begin
if not ValitadeFields then
Exit;
if SetStores(edtCustomer.Text, edtStore.Text, edtPW.Text) then
begin
GetStores;
edtStore.Clear;
edtPW.Clear;
edtStore.SetFocus;
end;
end;
procedure TFrmStoreType.edtCustomerKeyPress(Sender: TObject; var Key: Char);
begin
if (Key IN [' ','/', '\']) then
begin
Key:=#0;
MessageBeep($FFFFFFFF);
end
else
Key:=Key;
end;
function TFrmStoreType.ValitadeFields: Boolean;
begin
Result := False;
if (Trim(edtCustomer.Text) = '') or (Trim(edtStore.Text) = '')
or (Trim(edtPW.Text) = '') then
Exit;
Result := True;
end;
procedure TFrmStoreType.GetStores;
var
sCustomerList,
sCustomerStores : TStringList;
fNode: TTreeNode;
i, j : integer;
begin
sCustomerList := TStringList.Create;
sCustomerStores := TStringList.Create;
treeCustomer.Items.Clear;
try
FrmMain.fIniCustomersConfig.ReadSections(sCustomerList);
For i:=0 to sCustomerList.Count-1 do
begin
fNode := treeCustomer.Items.Add(treeCustomer.Items.GetFirstNode,sCustomerList.Strings[i]);
FrmMain.fIniCustomersConfig.ReadSection(sCustomerList.Strings[i], sCustomerStores);
for j:=0 to sCustomerStores.Count-1 do
if not DMServer.IsSessionToExclude(sCustomerStores.Strings[j]) then
treeCustomer.Items.AddChild(fNode, sCustomerStores.Strings[j]);
end;
finally
FreeAndNil(sCustomerList);
FreeAndNil(sCustomerStores);
treeCustomer.FullExpand;
end;
end;
function TFrmStoreType.SetStores(sCustomer, sStore,
sPW: String): Boolean;
var
sDir : String;
begin
sDir := DMServer.LocalPath+sCustomer+'\'+sStore;
//Create directories
if not DirectoryExists(sDir) then
ForceDirectories(sDir);
FrmMain.fIniCustomersConfig.WriteString(LowerCase(sCustomer), LowerCase(sStore), LowerCase(sPW));
Result := True;
end;
procedure TFrmStoreType.btnDelClick(Sender: TObject);
begin
if not ValitadeFields then
Exit;
if DeleteStore then
begin
ClearFields;
GetStores;
end;
end;
function TFrmStoreType.DeleteStore: Boolean;
begin
//Result := False;
if FrmMain.fIniCustomersConfig.ValueExists(edtCustomer.Text, edtStore.Text) then
begin
FrmMain.fIniCustomersConfig.DeleteKey(edtCustomer.Text, edtStore.Text);
end;
Result := True;
end;
procedure TFrmStoreType.treeCustomerClick(Sender: TObject);
var
fNode : TTreeNode;
sUncripted : String;
begin
fNode := treeCustomer.Selected;
ClearFields;
if (fNode <> nil) then
begin
if (not fNode.HasChildren) and (fNode.Parent <> nil) then
begin
edtCustomer.Text := fNode.Parent.Text;
edtStore.Text := fNode.Text;
edtPW.Text := FrmMain.fIniCustomersConfig.ReadString(fNode.Parent.Text, fNode.Text, '');
end
else
begin
edtCustomer.Text := fNode.Text;
end;
if FrmMain.fIniCustomersConfig.ValueExists(edtCustomer.Text, CONNECTION_STR) then
edtConnection.Text := FrmMain.fIniCustomersConfig.ReadString(edtCustomer.Text, CONNECTION_STR, '');
if FrmMain.fIniCustomersConfig.ValueExists(edtCustomer.Text, SCHEDULE_STR) then
edtSchedule.Text := FrmMain.fIniCustomersConfig.ReadString(edtCustomer.Text, SCHEDULE_STR, '');
if FrmMain.fIniCustomersConfig.ValueExists(edtCustomer.Text, VERSION_STR) then
edtVersion.Text := FrmMain.fIniCustomersConfig.ReadString(edtCustomer.Text, VERSION_STR, '');
btnSaveSchedule.Tag := 1;
try
if FrmMain.fIniCustomersConfig.ValueExists(edtCustomer.Text, REPSINCE_STR) then
edtRepSince.Text := FrmMain.fIniCustomersConfig.ReadString(edtCustomer.Text, REPSINCE_STR, '1');
if FrmMain.fIniCustomersConfig.ValueExists(edtCustomer.Text, DISABLESCHEDULE_STR) then
chkDisableSchedule.Checked := FrmMain.fIniCustomersConfig.ReadBool(edtCustomer.Text, DISABLESCHEDULE_STR, False);
if FrmMain.fIniCustomersConfig.ValueExists(edtCustomer.Text, MAINSTORE_STR) then
edtMainStore.Text := FrmMain.fIniCustomersConfig.ReadString(edtCustomer.Text, MAINSTORE_STR, '1');
if FrmMain.fIniCustomersConfig.ValueExists(edtCustomer.Text, SERVER_TYPE_STR) then
cmbServerType.ItemIndex := FrmMain.fIniCustomersConfig.ReadInteger(edtCustomer.Text, SERVER_TYPE_STR, 0);
SetEnabladpnlProcessor(True);
Application.ProcessMessages;
if FrmMain.fIniCustomersConfig.ValueExists(edtCustomer.Text, AUTH_CRIPTO_STR) then
begin
sUncripted := FrmMain.fIniCustomersConfig.ReadString(edtCustomer.Text, AUTH_CRIPTO_STR, '');
sUncripted := DecodeServerInfo(sUncripted, 'NetCon', CIPHER_TEXT_STEALING, FMT_XX);
edtHost.Text := ParseParam(sUncripted, FILE_SERVER_HOST_STR);
edtPort.Text := ParseParam(sUncripted, FILE_SERVER_PORT_STR);
edtStoreAuth.Text := ParseParam(sUncripted, AUTH_STORE_NAME_STR);
edtPassword.Text := ParseParam(sUncripted, AUTH_PASSWORD_STR);
edtPacketSize.Text := ParseParam(sUncripted, AUTH_PACKET_SIZE_STR);
end;
Application.ProcessMessages;
SetEnabladpnlProcessor(cmbServerType.ItemIndex = 1);
finally
btnSaveSchedule.Tag := 0;
end;
end;
end;
procedure TFrmStoreType.ClearFields;
begin
edtCustomer.Clear;
edtStore.Clear;
edtPW.Clear;
end;
procedure TFrmStoreType.btnOpenConnectionClick(Sender: TObject);
var
sConnection : String;
begin
if Trim(edtCustomer.Text) = '' then
Exit;
if not FrmMain.fIniCustomersConfig.ValueExists(edtCustomer.Text, CONNECTION_STR) then
FrmMain.fIniCustomersConfig.WriteString(edtCustomer.Text, CONNECTION_STR, '');
sConnection := FrmMain.fIniCustomersConfig.ReadString(edtCustomer.Text, CONNECTION_STR, '');
sConnection := DMServer.GetServerConnection(sConnection, True);
edtConnection.Text := sConnection;
FrmMain.fIniCustomersConfig.WriteString(edtCustomer.Text, CONNECTION_STR, sConnection);
GetStores;
end;
procedure TFrmStoreType.btnOpenScheduleClick(Sender: TObject);
var
Schedule : String;
begin
if (edtCustomer.Text = '') then
Exit;
if not FrmMain.fIniCustomersConfig.ValueExists(edtCustomer.Text, SCHEDULE_STR) then
FrmMain.fIniCustomersConfig.WriteString(edtCustomer.Text, SCHEDULE_STR, '');
Schedule := FrmMain.fIniCustomersConfig.ReadString(edtCustomer.Text, SCHEDULE_STR, '');
with TFrmSchedule.Create(Self) do
Schedule := BuildSchedule(Schedule);
FrmMain.fIniCustomersConfig.WriteString(edtCustomer.Text, SCHEDULE_STR, Schedule);
GetStores;
end;
procedure TFrmStoreType.btnTestConnectionClick(Sender: TObject);
var
sConnection : String;
begin
if (edtConnection.Text = '') then
Exit;
try
sConnection := DecodeServerInfo(edtConnection.Text, 'Server', CIPHER_TEXT_STEALING, FMT_UU);
except
sConnection := '';
end;
if sConnection <> '' then
if DMServer.TestConnection(sConnection) then
ShowMessage('Connection OK')
else
ShowMessage('Connection ERROR');
end;
procedure TFrmStoreType.edtRepSinceChange(Sender: TObject);
begin
if btnSaveSchedule.Tag = 0 then
btnSaveSchedule.Enabled := True;
end;
procedure TFrmStoreType.chkDisableScheduleClick(Sender: TObject);
begin
if btnSaveSchedule.Tag = 0 then
btnSaveSchedule.Enabled := True;
end;
procedure TFrmStoreType.btnSaveScheduleClick(Sender: TObject);
var
sEncodedInfo: String;
begin
FrmMain.fIniCustomersConfig.WriteInteger(edtCustomer.Text, REPSINCE_STR, StrToInt(edtRepSince.Text));
FrmMain.fIniCustomersConfig.WriteBool(edtCustomer.Text, DISABLESCHEDULE_STR, chkDisableSchedule.Checked);
FrmMain.fIniCustomersConfig.WriteInteger(edtCustomer.Text, MAINSTORE_STR, StrToInt(edtMainStore.Text));
FrmMain.fIniCustomersConfig.WriteInteger(edtCustomer.Text, SERVER_TYPE_STR, cmbServerType.ItemIndex);
sEncodedInfo := Format(FMT_CLIENT_CONNECTION, [edtHost.Text,
edtPort.Text,
edtStoreAuth.Text,
edtPacketSize.Text,
edtPassword.Text]);
sEncodedInfo := EncodeServerInfo(sEncodedInfo, 'NetCon', CIPHER_TEXT_STEALING, FMT_XX);
FrmMain.fIniCustomersConfig.WriteString(edtCustomer.Text, AUTH_CRIPTO_STR, sEncodedInfo);
btnSaveSchedule.Enabled := False;
end;
procedure TFrmStoreType.cmbServerTypeChange(Sender: TObject);
begin
SetEnabladpnlProcessor(cmbServerType.ItemIndex = 1);
edtRepSinceChange(self);
end;
procedure TFrmStoreType.SetEnabladpnlProcessor(AEnabled : Boolean);
var
AColor: TColor;
I: Integer;
begin
if AEnabled then
AColor := clWhite
else
AColor := clSilver;
for I := 0 to pnlProcessor.ControlCount - 1 do
begin
if pnlProcessor.Controls[I] is TEdit then
begin
TEdit(pnlProcessor.Controls[I]).Color := AColor;
TEdit(pnlProcessor.Controls[I]).Enabled := AEnabled;
end;
if pnlProcessor.Controls[I] is TMaskEdit then
begin
TMaskEdit(pnlProcessor.Controls[I]).Color := AColor;
TMaskEdit(pnlProcessor.Controls[I]).Enabled := AEnabled;
end;
end;
end;
end.
|
unit AcceptedReport_FilterForm;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ExtCtrls, cxLabel, cxControls, cxContainer, cxEdit, cxTextEdit,
cxMaskEdit, cxButtonEdit, cxLookAndFeelPainters, StdCtrls, cxButtons,
cxDropDownEdit, cxCalendar, ActnList, IBase, uCommonSp,
Asup_LoaderPrintDocs_Types, Asup_LoaderPrintDocs_Proc,
Asup_LoaderPrintDocs_WaitForm, ASUP_LoaderPrintDocs_Consts,
ASUP_LoaderPrintDocs_Messages, cxMRUEdit, cxCheckBox,qftools,DateUtils;
type
TFormOptions = class(TForm)
Bevel1: TBevel;
LabelDateEnd: TcxLabel;
DateEditEnd: TcxDateEdit;
DateEditBeg: TcxDateEdit;
LabelDateBeg: TcxLabel;
ActionList: TActionList;
YesAction: TAction;
CancelAction: TAction;
YesBtn: TcxButton;
CancelBtn: TcxButton;
CatComboBox: TcxComboBox;
cxLabel1: TcxLabel;
LabelDepartment: TcxLabel;
EditDepartment: TcxButtonEdit;
CheckBoxWithChild: TcxCheckBox;
procedure CancelActionExecute(Sender: TObject);
procedure YesActionExecute(Sender: TObject);
procedure cxMRUEdit1PropertiesButtonClick(Sender: TObject);
procedure EditDepartmentPropertiesButtonClick(Sender: TObject;
AButtonIndex: Integer);
private
PDb_Handle:TISC_DB_HANDLE;
PId_Depratment:integer;
public
constructor Create(AParameter:TSimpleParam);reintroduce;
property Id_Department:integer read PId_Depratment;
end;
implementation
{$R *.dfm}
constructor TFormOptions.Create(AParameter:TSimpleParam);
var Year, Month, Day, Days: Word; str:string;
begin
inherited Create(AParameter.Owner);
PDb_Handle:=AParameter.DB_Handle;
//******************************************************************************
Caption := 'Список працівників, прийнятих за період (форма №21)';
YesBtn.Caption := 'Гаразд';
CancelBtn.Caption := 'Відміна';
YesBtn.Hint := 'Гаразд';
CancelBtn.Hint := 'Відміна';
LabelDepartment.Caption := Label_Department_Caption;
CheckBoxWithChild.Properties.Caption := CheckBoxWithChild_Caption;
PId_Depratment:=-255;
LabelDateBeg.Caption := 'Введіть період з';
LabelDateEnd.Caption := 'по';
//******************************************************************************
DecodeDate(Date,Year, Month, Day);
if month>9 then
str:='01.'+inttostr(month)+'.'+inttostr(year)
else
str:='01.'+'0'+inttostr(month)+'.'+inttostr(year);
DateEditBeg.Date:=strtodate(str);
DecodeDate(Date,Year, Month, Day);
Days:=DaysInAMonth(Year, Month);
if month>9 then
str:=inttostr(Days)+'.'+inttostr(Month)+'.'+inttostr(year)
else
str:=inttostr(Days)+'.'+'0'+inttostr(Month)+'.'+inttostr(year);
DateEditEnd.Date:=strtodate(str);
CatComboBox.Properties.Items.Add('Усі');
CatComboBox.Properties.Items.Add('Науково-педагогічний персонал');
//******************************************************************************
end;
procedure TFormOptions.CancelActionExecute(Sender: TObject);
begin
ModalResult:=mrCancel;
end;
procedure TFormOptions.YesActionExecute(Sender: TObject);
begin
if EditDepartment.Text='' then
begin
AsupShowMessage(Error_Caption,E_NotSelectDepartment_Text,mtWarning,[mbOK]);
Exit;
end;
if DateEditBeg.Date>DateEditEnd.Date then
begin
AsupShowMessage(Error_Caption,E_Terms_Text,mtWarning,[mbOK]);
Exit;
end;
ModalResult := mrYes;
end;
procedure TFormOptions.cxMRUEdit1PropertiesButtonClick(Sender: TObject);
var sp: TSprav;
begin
sp := GetSprav('SpDepartment');
if sp <> nil then
begin
// заполнить входные параметры
with sp.Input do
begin
Append;
FieldValues['DBHandle'] := Integer(PDb_Handle);
FieldValues['ShowStyle'] := 0;
FieldValues['Select'] := 1;
FieldValues['Actual_Date'] := Date;
Post;
end;
end;
sp.Show;
if sp.Output = nil then
ShowMessage('BUG: Output is NIL!!!')
else
if not sp.Output.IsEmpty then
begin
EditDepartment.Text := varToStr(sp.Output['NAME_FULL']);
PId_Depratment:=sp.Output['ID_DEPARTMENT'];
end;
sp.Free;
end;
procedure TFormOptions.EditDepartmentPropertiesButtonClick(Sender: TObject;
AButtonIndex: Integer);
var sp: TSprav;
begin
sp := GetSprav('SpDepartment');
if sp <> nil then
begin
// заполнить входные параметры
with sp.Input do
begin
Append;
FieldValues['DBHandle'] := Integer(PDb_Handle);
FieldValues['ShowStyle'] := 0;
FieldValues['Select'] := 1;
FieldValues['Actual_Date'] := Date;
Post;
end;
end;
sp.Show;
if sp.Output = nil then
ShowMessage('BUG: Output is NIL!!!')
else
if not sp.Output.IsEmpty then
begin
EditDepartment.Text := varToStr(sp.Output['NAME_FULL']);
PId_Depratment:=sp.Output['ID_DEPARTMENT'];
end;
sp.Free;
end;
end.
|
<<<<<<< HEAD
{Реализуйте программу, которая выводит приветствие 'Hello dear, <name>!'.
Имя должно передаваться в параметре name QUERY_STRING, в случае когда параметра name нет, должно выводиться 'Hello Anonymous!'.
В данном задании можно считать что параметр name стоит на первом месте, либо его нет. Можно использовать функции POS COPY для работы со строками}
PROGRAM GreetUser(INPUT, OUTPUT);
uses GPC;
BEGIN
WRITELN('Content-type: text/plain');
WRITELN;
IF POS('name', GetEnv('QUERY_STRING')) > 0
THEN
WRITELN('Hello dear, ', COPY(GetEnv('QUERY_STRING'), POS('=', GetEnv('QUERY_STRING')) + 1, 20))
ELSE
WRITELN('Hello Anonymous!')
END.
=======
{Реализуйте программу, которая выводит приветствие 'Hello dear, <name>!'.
Имя должно передаваться в параметре name QUERY_STRING, в случае когда параметра name нет, должно выводиться 'Hello Anonymous!'.
В данном задании можно считать что параметр name стоит на первом месте, либо его нет. Можно использовать функции POS COPY для работы со строками}
PROGRAM GreetUser(INPUT, OUTPUT);
uses GPC;
BEGIN
WRITELN('Content-type: text/plain');
WRITELN;
IF POS('name', GetEnv('QUERY_STRING')) > 0
THEN
WRITELN('Hello dear, ', COPY(GetEnv('QUERY_STRING'), POS('=', GetEnv('QUERY_STRING')) + 1, 20))
ELSE
WRITELN('Hello Anonymous!')
END.
>>>>>>> 76163f8c603274cb8cd183299e47581ba7d33420
|
unit DPM.Core.Options.Info;
interface
uses
DPM.Core.Options.Base;
type
TInfoOptions = class(TOptionsBase)
private
class var
FDefault : TInfoOptions;
public
class constructor CreateDefault;
class property Default : TInfoOptions read FDefault;
end;
implementation
{ TInfoOptions }
class constructor TInfoOptions.CreateDefault;
begin
FDefault := TInfoOptions.Create;
end;
end.
|
unit rtti_idebinder_Lib;
interface
uses
Classes, SysUtils, rtti_broker_iBroker, Controls, rtti_idebinder_iBindings,
rtti_idebinder_uDataBinder, rtti_idebinder_uTallyBinders, forms,
rtti_idebinder_uBehavioralBinder,
rtti_idebinder_uDesigner;
type
{ TLib }
TLib = class
public
class function NewDataBinder: IRBDataBinder;
class function NewListBinder(const AListControl: TWinControl; const AContext: IRBBinderContext;
const AClass: TClass): IRBTallyBinder;
class function NewBehavioralBinder: IRBBehavioralBinder;
class function NewDesigner: IRBDesigner;
end;
{ TIDE }
TIDE = class
public
class function Edit(AFormClass: TFormClass; const AData: IRBdata; const ADataQuery: IRBDataQuery): Boolean;
end;
implementation
{ TIDE }
class function TIDE.Edit(AFormClass: TFormClass; const AData: IRBdata;
const ADataQuery: IRBDataQuery): Boolean;
var
mForm: TForm;
mBinder: IRBDataBinder;
begin
mForm := AFormClass.Create(nil);
try
mBinder := TLib.NewDataBinder;
mBinder.Bind(mForm, AData, ADataQuery);
Result := mForm.ShowModal = mrOK;
finally
mForm.Free;
end;
end;
{ TLib }
class function TLib.NewDataBinder: IRBDataBinder;
begin
Result := TRBDataBinder.Create;
end;
class function TLib.NewListBinder(const AListControl: TWinControl; const AContext: IRBBinderContext;
const AClass: TClass): IRBTallyBinder;
begin
Result := TTallyBinder.New(AListControl, AContext, AClass);
end;
class function TLib.NewBehavioralBinder: IRBBehavioralBinder;
begin
Result := TRBBehavioralBinder.Create;
end;
class function TLib.NewDesigner: IRBDesigner;
begin
Result := TRBDesigner.Create;
end;
end.
|
unit UDataModuleNFe;
{$MODE Delphi}
interface
uses
SysUtils, Classes, DB, BufDataset, FMTBcd, sqldb, Biblioteca;
type
TFDataModuleNFe = class(TDataModule)
CDSVolumes: TBufDataSet;
DSVolumes: TDataSource;
CDSNfReferenciada: TBufDataSet;
DSNfReferenciada: TDataSource;
CDSCteReferenciado: TBufDataSet;
DSCteReferenciado: TDataSource;
CDSNfRuralReferenciada: TBufDataSet;
DSNfRuralReferenciada: TDataSource;
CDSCupomReferenciado: TBufDataSet;
DSCupomReferenciado: TDataSource;
CDSDuplicata: TBufDataSet;
DSDuplicata: TDataSource;
CDSNfeReferenciada: TBufDataSet;
DSNfeReferenciada: TDataSource;
CDSNfeDetalhe: TBufDataSet;
DSNfeDetalhe: TDataSource;
CDSReboque: TBufDataSet;
DSReboque: TDataSource;
CDSNfeImpostoCofins: TBufDataSet;
DSNfeImpostoCofins: TDataSource;
CDSNfeImpostoIcms: TBufDataSet;
DSNfeImpostoIcms: TDataSource;
CDSNfeImpostoImportacao: TBufDataSet;
DSNfeImpostoImportacao: TDataSource;
CDSNfeImpostoIpi: TBufDataSet;
DSNfeImpostoIpi: TDataSource;
CDSNfeImpostoIssqn: TBufDataSet;
DSNfeImpostoIssqn: TDataSource;
CDSNfeImpostoPis: TBufDataSet;
DSNfeImpostoPis: TDataSource;
CDSNfeDeclaracaoImportacao: TBufDataSet;
DSNfeDeclaracaoImportacao: TDataSource;
CDSNfeImportacaoDetalhe: TBufDataSet;
DSNfeImportacaoDetalhe: TDataSource;
CDSNfeDetalheVeiculo: TBufDataSet;
DSNfeDetalheVeiculo: TDataSource;
CDSNfeDetalheArmamento: TBufDataSet;
DSNfeDetalheArmamento: TDataSource;
CDSNfeDetalheCombustivel: TBufDataSet;
DSNfeDetalheCombustivel: TDataSource;
CDSNfeDetalheMedicamento: TBufDataSet;
DSNfeDetalheMedicamento: TDataSource;
CDSVolumesLacres: TBufDataSet;
DSVolumesLacres: TDataSource;
CDSNfeNumero: TBufDataSet;
DSNfeNumero: TDataSource;
procedure DataModuleCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
FDataModuleNFe: TFDataModuleNFe;
implementation
uses
NfeDetalheImpostoCofinsVO, NfeDetalheImpostoIcmsVO, NfeNumeroVO,
NfeDetalheImpostoPisVO, NfeDetalheImpostoIiVO, NfeDetalheImpostoIssqnVO,
NfeDetalheImpostoIpiVO;
{$R *.lfm}
{ TFDataModuleNFe }
procedure TFDataModuleNFe.DataModuleCreate(Sender: TObject);
begin
ConfiguraCDSFromVO(CDSNfeImpostoIcms, TNfeDetalheImpostoIcmsVO);
ConfiguraCDSFromVO(CDSNfeImpostoPis, TNfeDetalheImpostoPisVO);
ConfiguraCDSFromVO(CDSNfeImpostoCofins, TNfeDetalheImpostoCofinsVO);
ConfiguraCDSFromVO(CDSNfeImpostoIpi, TNfeDetalheImpostoIpiVO);
ConfiguraCDSFromVO(CDSNfeImpostoImportacao, TNfeDetalheImpostoIiVO);
ConfiguraCDSFromVO(CDSNfeImpostoIssqn, TNfeDetalheImpostoIssqnVO);
ConfiguraCDSFromVO(CDSNfeNumero, TNfeNumeroVO);
end;
end.
|
unit SportFrm;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs,
Vcl.Buttons, Vcl.StdCtrls, Sport;
type
TSportForm = class(TForm)
NameLabel: TLabel;
DescriptionLabel: TLabel;
OriginLabel: TLabel;
PlayersLabel: TLabel;
GoalieLabel: TLabel;
FirstButton: TSpeedButton;
PreviousButton: TSpeedButton;
NextButton: TSpeedButton;
LastButton: TSpeedButton;
LanguageButton: TButton;
procedure FormCreate(Sender: TObject);
procedure FirstButtonClick(Sender: TObject);
procedure PreviousButtonClick(Sender: TObject);
procedure NextButtonClick(Sender: TObject);
procedure LastButtonClick(Sender: TObject);
procedure LanguageButtonClick(Sender: TObject);
private
FItemIndex: Integer;
procedure SetItemIndex(value: Integer);
protected
FSports: TSports;
procedure LoadSports; virtual; abstract;
public
property ItemIndex: Integer read FItemIndex write SetItemIndex;
end;
implementation
{$R *.dfm}
uses
NtLanguageDlg;
procedure TSportForm.SetItemIndex(value: Integer);
resourcestring
SOrigin = 'Origin: %s';
SPlayers = '%d players';
SHasGoalie = 'Has a goalie';
SNoGoalie = 'No goalie';
var
selected: TSport;
begin
// Get the selected sport
FItemIndex := value;
selected := FSports[FItemIndex];
// Update labels
NameLabel.Caption := selected.Name;
DescriptionLabel.Caption := selected.Description;
OriginLabel.Caption := Format(SOrigin, [selected.Origin]);
PlayersLabel.Caption := Format(SPlayers, [selected.Players]);
if selected.Goalie then
GoalieLabel.Caption := SHasGoalie
else
GoalieLabel.Caption := SNoGoalie;
// Show only those buttons that can be clicked
FirstButton.Visible := FItemIndex > 0;
PreviousButton.Visible := FirstButton.Visible;
NextButton.Visible := FItemIndex < FSports.Count - 1;
LastButton.Visible := NextButton.Visible;
end;
procedure TSportForm.FormCreate(Sender: TObject);
begin
// Load spoart data from the resources
FSports := TSports.Create;
LoadSports;
// Show first sport
FirstButtonClick(Self);
end;
procedure TSportForm.FirstButtonClick(Sender: TObject);
begin
// Show first sport
ItemIndex := 0;
end;
procedure TSportForm.PreviousButtonClick(Sender: TObject);
begin
// Show previous sport
ItemIndex := ItemIndex - 1;
end;
procedure TSportForm.NextButtonClick(Sender: TObject);
begin
// Show next sport
ItemIndex := ItemIndex + 1;
end;
procedure TSportForm.LastButtonClick(Sender: TObject);
begin
// Show last sport
ItemIndex := FSports.Count - 1;
end;
procedure TSportForm.LanguageButtonClick(Sender: TObject);
begin
// Show a language select dialog and turn on the selected language
if TNtLanguageDialog.Select('en') then
begin
// Language has been changed.
// Sport data must be reloaded.
LoadSports;
SetItemIndex(ItemIndex);
end;
end;
end.
|
namespace com.example.android.bluetoothchat;
{*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*}
interface
uses
java.util,
android.app,
android.bluetooth,
android.content,
android.os,
android.util,
android.view,
android.widget;
type
(**
* This Activity appears as a dialog. It lists any paired devices and
* devices detected in the area after discovery. When a device is chosen
* by the user, the MAC address of the device is sent back to the parent
* Activity in the result Intent.
*)
DeviceListActivity = public class(Activity)
private
// Debugging
const TAG = 'DeviceListActivity';
const D = true;
// Member fields
var mReceiver: BluetoothBroadcastReceiver;
var mBtAdapter: BluetoothAdapter;
var mPairedDevicesArrayAdapter: ArrayAdapter<String>;
// The on-click listener for all devices in the ListViews
var mDeviceClickListener: ListView.OnItemClickListener;
method doDiscovery;
protected
method onCreate(savedInstanceState: Bundle); override;
method onDestroy; override;
public
// Return Intent extra
const EXTRA_DEVICE_ADDRESS = 'device_address';
var mNewDevicesArrayAdapter: ArrayAdapter<String>;
end;
// The BroadcastReceiver that listens for discovered devices and
// changes the title when discovery is finished
BluetoothBroadcastReceiver nested in DeviceListActivity = public class(BroadcastReceiver)
private
var mActivity: DeviceListActivity;
public
constructor(aActivity: DeviceListActivity);
method onReceive(aContext: Context; aIntent: Intent); override;
end;
implementation
method DeviceListActivity.onCreate(savedInstanceState: Bundle);
begin
inherited onCreate(savedInstanceState);
// Setup the window
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
ContentView := R.layout.device_list;
// Set result CANCELED in case the user backs out
setResult(Activity.RESULT_CANCELED);
// Initialize the button to perform device discovery
var scanButton: Button := Button(findViewById(R.id.button_scan));
scanButton.OnClickListener :=
method(v: View)
begin
doDiscovery();
v.Visibility := View.GONE
end;
// Initialize array adapters. One for already paired devices and
// one for newly discovered devices
mPairedDevicesArrayAdapter := new ArrayAdapter<String>(self, R.layout.device_name);
mNewDevicesArrayAdapter := new ArrayAdapter<String>(self, R.layout.device_name);
mDeviceClickListener :=
method(av: AdapterView<Adapter>; v: View; arg2: Integer; arg3: Int64)
begin
// Cancel discovery because it's costly and we're about to connect
mBtAdapter.cancelDiscovery;
// Get the device MAC address, which is the last 17 chars in the View
var info: String := TextView(v).Text.toString;
var address: String := info.substring(info.length - 17);
// Create the result Intent and include the MAC address
var i: Intent := new Intent;
i.putExtra(EXTRA_DEVICE_ADDRESS, address);
// Set result and finish this Activity
setResult(Activity.RESULT_OK, i);
finish;
end;
// Find and set up the ListView for paired devices
var pairedListView: ListView := ListView(findViewById(R.id.paired_devices));
pairedListView.Adapter := mPairedDevicesArrayAdapter;
pairedListView.OnItemClickListener := mDeviceClickListener;
// Find and set up the ListView for newly discovered devices
var newDevicesListView: ListView := ListView(findViewById(R.id.new_devices));
newDevicesListView.Adapter := mNewDevicesArrayAdapter;
newDevicesListView.OnItemClickListener := mDeviceClickListener;
// Register for broadcasts when a device is discovered
mReceiver := new BluetoothBroadcastReceiver(self);
var filter: IntentFilter := new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, filter);
// Register for broadcasts when discovery has finished
filter := new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
registerReceiver(mReceiver, filter);
// Get the local Bluetooth adapter
mBtAdapter := BluetoothAdapter.DefaultAdapter;
// Get a set of currently paired devices
var pairedDevices: &Set<BluetoothDevice> := mBtAdapter.BondedDevices;
// If there are paired devices, add each one to the ArrayAdapter
if pairedDevices.size > 0 then
begin
findViewById(R.id.title_paired_devices).Visibility := View.VISIBLE;
for each device: BluetoothDevice in pairedDevices do
mPairedDevicesArrayAdapter.&add(device.Name + ''#10 + device.Address)
end
else
begin
var noDevices: String := Resources.String[R.string.none_paired];
mPairedDevicesArrayAdapter.&add(noDevices)
end
end;
method DeviceListActivity.onDestroy;
begin
inherited onDestroy();
// Make sure we're not doing discovery anymore
if mBtAdapter <> nil then
mBtAdapter.cancelDiscovery;
// Unregister broadcast listeners
unregisterReceiver(mReceiver)
end;
/// <summary>
/// Start device discover with the BluetoothAdapter
/// </summary>
method DeviceListActivity.doDiscovery;
begin
if D then
Log.d(TAG, 'doDiscovery()');
// Indicate scanning in the title
ProgressBarIndeterminateVisibility := true;
Title := R.string.scanning;
// Turn on sub-title for new devices
findViewById(R.id.title_new_devices).Visibility := View.VISIBLE;
// If we're already discovering, stop it
if mBtAdapter.isDiscovering then
mBtAdapter.cancelDiscovery;
// Request discover from BluetoothAdapter
mBtAdapter.startDiscovery
end;
constructor DeviceListActivity.BluetoothBroadcastReceiver(aActivity: DeviceListActivity);
begin
inherited constructor;
mActivity := aActivity;
end;
method DeviceListActivity.BluetoothBroadcastReceiver.onReceive(aContext: Context; aIntent: Intent);
begin
var action: String := aIntent.Action;
// When discovery finds a device
case action of
BluetoothDevice.ACTION_FOUND:
begin
// Get the BluetoothDevice object from the Intent
var device: BluetoothDevice := aIntent.getParcelableExtra<BluetoothDevice>(BluetoothDevice.EXTRA_DEVICE);
// If it's already paired, skip it, because it's been listed already
if device.BondState <> BluetoothDevice.BOND_BONDED then
mActivity.mNewDevicesArrayAdapter.&add(device.Name + ''#10 + device.Address)
end;
BluetoothAdapter.ACTION_DISCOVERY_FINISHED:
begin
mActivity.ProgressBarIndeterminateVisibility := false;
mActivity.Title := R.string.select_device;
if mActivity.mNewDevicesArrayAdapter.Count = 0 then
begin
var noDevices: String := aContext.Resources.Text[R.string.none_found].toString;
mActivity.mNewDevicesArrayAdapter.&add(noDevices)
end
end;
end;
end;
end. |
unit SVGBase64;
interface
uses
classes;
//stripped out from TNetEncoding - just the bits we need for svg.
function Base64DecodeStream(const InputStream : TStream; const OutputStream: TStream) : integer;
implementation
{$IF CompilerVersion > 23.0}
{$LEGACYIFEND ON}
{$IFEND}
uses
{$IF CompilerVersion > 27}
System.NetEncoding,
{$IFEND}
System.SysUtils,
System.Types;
const
DecodeTable: array[0..79] of Int8 = (
62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1,
-1, -1, -2, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
-1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51);
Base64Values : array [0..255] of byte =
(
$FE, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FE, $FE, $FF, $FF, $FE, $FF, $FF,
$FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
$FE, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $3E, $FF, $FF, $FF, $3F,
$34, $35, $36, $37, $38, $39, $3A, $3B, $3C, $3D, $FF, $FF, $FF, $FD, $FF, $FF,
$FF, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $A, $B, $C, $D, $E,
$F, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $FF, $FF, $FF, $FF, $FF,
$FF, $1A, $1B, $1C, $1D, $1E, $1F, $20, $21, $22, $23, $24, $25, $26, $27, $28,
$29, $2A, $2B, $2C, $2D, $2E, $2F, $30, $31, $32, $33, $FF, $FF, $FF, $FF, $FF,
$FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
$FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
$FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
$FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
$FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
$FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
$FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
$FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF
) ;
type
TDecodeGroup = (groupA, groupB, groupC, groupD);
function DecodeValue(const Code: Byte): Integer;
var
LCode: Integer;
begin
LCode := Code - 43;
if (LCode < Low(DecodeTable)) or (LCode > High(DecodeTable)) then
Result := -1
else
Result := DecodeTable[LCode];
end;
function DecodeBytes(Input, Output: PByte; InputLen: Integer; var group : TDecodeGroup ) : integer;
var
POutput : PByte;
PInput : PByte;
PEnd : PByte;
fragment: Integer;
begin
POutput := Output;
PInput := Input;
PEnd := PInput + InputLen;
POutput^ := 0;
while True do
begin
case group of
TDecodeGroup.groupA:
begin
repeat
if PInput = PEnd then
Exit(POutput - Output);
fragment := DecodeValue(Ord(PInput^));
Inc(PInput);
until (Fragment >= 0) ;
POutput^ := (fragment and $03F) shl 2;
group := TDecodeGroup.groupB;
end;
TDecodeGroup.groupB:
begin
repeat
if PInput = PEnd then
Exit(POutput - Output);
fragment := DecodeValue(Ord(PInput^));
Inc(PInput);
until (Fragment >= 0) ;
POutput^ := (POutput^ or ((fragment and $030) shr 4));
Inc(POutput);
POutput^ := ((fragment and $00F) shl 4);
group := TDecodeGroup.groupC;
end;
TDecodeGroup.groupC:
begin
repeat
if PInput = PEnd then
Exit(POutput - Output);
fragment := DecodeValue(Ord(PInput^));
Inc(PInput);
until (Fragment >= 0) ;
POutput^ := (POutput^ or ((fragment and $03C) shr 2));
Inc(POutput);
POutput^ := ((fragment and $003) shl 6);
group := TDecodeGroup.groupD;
end;
TDecodeGroup.groupD:
begin
repeat
if PInput = PEnd then
Exit(POutput - Output);
fragment := DecodeValue(Ord(PInput^));
Inc(PInput);
until (fragment >= 0) ;
POutput^ := (POutput^ or (fragment and $03F));
Inc(POutput);
group := TDecodeGroup.groupA;
end;
end;
end;
end;
{$IF CompilerVersion > 27}
function Base64DecodeStream(const InputStream : TStream; const OutputStream: TStream) : integer;
begin
result := TNetEncoding.Base64.Decode(InputStream, OutputStream);
end;
{$ELSE}
function Base64DecodeStream(const InputStream : TStream; const OutputStream: TStream) : integer;
var
inputBuffer: array[0..1023] of byte;
outputBuffer: array[0..767] of byte;
bytesRead, bytesToWrite: Integer;
group : TDecodeGroup;
begin
Result := 0;
group := TDecodeGroup.groupA;
repeat
bytesRead := InputStream.Read(inputBuffer[0], Length(inputBuffer));
bytesToWrite := DecodeBytes(@inputBuffer[0], @outputBuffer[0], bytesRead, group);
OutputStream.Write(Outputbuffer, bytesToWrite);
Result := Result + bytesToWrite;
until bytesRead = 0;
end;
{$IFEND}
end.
|
unit janFX;
{ original release 2-july-2000
janFX is written by Jan Verhoeven
most routines are written by myself,
some are extracted from freeware sources on the internet
to use this library add it to your library path
with Tools - Environment Options - Library path
in your application you just call the routines
for clarity and convenience you might preceed them with janFX like:
janFX.Buttonize(src,depth,weight);
this library is the updated succesor of my TjanPaintFX component
}
interface
{$DEFINE USE_SCANLINE}
uses
Windows, SysUtils, Classes, Graphics, math;
type
// Type of a filter for use with Stretch()
TFilterProc = function(Value: Single): Single;
TLightBrush=(lbBrightness,lbContrast,lbSaturation,
lbfisheye,lbrotate,lbtwist,lbrimple,
mbHor,mbTop,mbBottom,mbDiamond,mbWaste,mbRound,
mbround2,mbsplitround,mbsplitwaste);
// For scanline simplification
TRGBArray = ARRAY[0..32767] OF TRGBTriple;
pRGBArray = ^TRGBArray;
function ConvertColor(Value: Integer): TColor;
function Set255(Clr: integer): integer;
procedure CopyMe(tobmp: TBitmap; frbmp: TGraphic);
procedure MaskOval(src: TBitmap;acolor:TColor);
procedure Buttonize(src: TBitmap;depth:byte;weight:integer);
procedure ButtonizeOval(src: TBitmap;depth:byte;weight:integer;rim:string);
procedure Seamless(src: TBitmap;depth:byte);
procedure ConvolveM(ray : array of integer; z : word; aBmp : TBitmap);
procedure ConvolveE(ray : array of integer; z : word; aBmp : TBitmap);
procedure ConvolveI(ray : array of integer; z : word; aBmp : TBitmap);
procedure ConvolveFilter(filternr,edgenr: integer; src: TBitmap);
// filternr=0..8 edgenr=0..2 (0 for seamless)
procedure Solorize(src,dst:tbitmap;amount:integer);
procedure Posterize(src,dst:tbitmap;amount:integer);
procedure Blend(src1,src2,dst:tbitmap;amount:extended);
procedure ExtractColor(src:TBitmap;Acolor:tcolor);
procedure ExcludeColor(src:TBitmap;Acolor:tcolor);
procedure turn(src,dst:tbitmap);
procedure turnRight(src,dst:Tbitmap);
procedure HeightMap(src:Tbitmap;amount:integer);
procedure TexturizeTile(src:TBitmap;amount:integer);
procedure TexturizeOverlap(src:TBitmap;amount:integer);
procedure RippleRandom(src:TBitmap;amount:integer);
procedure RippleTooth(src:TBitmap;amount:integer);
procedure RippleTriangle(src:TBitmap;amount:integer);
procedure Triangles(src:TBitmap;amount:integer);
procedure DrawMandelJulia(src: Tbitmap; x0, y0, x1, y1: extended;
Niter: integer; Mandel: Boolean);
procedure filterxblue(src: tbitmap; min, max: integer);
procedure filterxgreen(src: tbitmap; min, max: integer);
procedure filterxred(src: tbitmap; min, max: integer);
procedure filterblue(src: tbitmap; min, max: integer);
procedure filtergreen(src: tbitmap; min, max: integer);
procedure filterred(src: tbitmap; min, max: integer);
procedure Emboss(var Bmp: TBitmap);
procedure Plasma(src1,src2,dst:Tbitmap;scale,turbulence:extended);
procedure Shake(src,dst:Tbitmap;factor:extended);
procedure ShakeDown(src,dst:Tbitmap;factor:extended);
procedure KeepBlue(src:Tbitmap;factor:extended);
procedure KeepGreen(src:Tbitmap;factor:extended);
procedure KeepRed(src:Tbitmap;factor:extended);
procedure MandelBrot(src:Tbitmap;factor:integer);
procedure MaskMandelBrot(src:Tbitmap;factor:integer);
procedure FoldRight(src1,src2,dst:Tbitmap;amount:extended);
procedure QuartoOpaque(src, dst: tbitmap);
procedure semiOpaque(src, dst: Tbitmap);
procedure ShadowDownLeft(src: tbitmap);
procedure ShadowDownRight(src: tbitmap);
procedure shadowupleft(src: Tbitmap);
procedure shadowupright(src: tbitmap);
procedure Darkness(var src: tbitmap; Amount: integer);
procedure Trace(src:Tbitmap;intensity:integer);
procedure FlipRight(src:Tbitmap);
procedure FlipDown(src:Tbitmap);
procedure SpotLight(var src:Tbitmap; Amount:integer;Spot:TRect);
procedure splitlight(var clip: tbitmap; amount: integer);
procedure MakeSeamlessClip(var clip: tbitmap; seam: integer);
procedure Wave(var clip: tbitmap; amount, inference, style: integer);
procedure Mosaic(var Bm: TBitmap; size: Integer);
function TrimInt(i, Min, Max: Integer): Integer;
procedure SmoothRotate(var Src, Dst: TBitmap; cx, cy: Integer;
Angle: Extended);
procedure SmoothResize(var Src, Dst: TBitmap);
procedure Twist(Bmp, Dst: TBitmap; Amount: integer);
procedure SplitBlur(var clip:tbitmap;Amount:integer);
procedure GaussianBlur(var clip:tbitmap;Amount: integer);
procedure Smooth(var clip:tbitmap;Weight: Integer);
procedure GrayScale(var clip:tbitmap);
procedure AddColorNoise(var clip:tbitmap;Amount: Integer);
procedure AddMonoNoise(var clip:tbitmap;Amount: Integer);
procedure Contrast(var clip:tbitmap;Amount: Integer);
procedure Lightness(var clip:tbitmap;Amount: Integer);
procedure Saturation(var clip:tbitmap;Amount: Integer);
procedure Spray(var clip:tbitmap;Amount: Integer);
procedure AntiAlias(clip:tbitmap);
procedure AntiAliasRect(clip:tbitmap;XOrigin, YOrigin, XFinal, YFinal: Integer);
procedure SmoothPoint(var clip:tbitmap;xk, yk: integer);
procedure FishEye(Bmp, Dst: TBitmap; Amount: Extended);
procedure marble(var src, dst: tbitmap; scale: extended;turbulence:integer);
procedure marble2(var src, dst: tbitmap; scale: extended;
turbulence: integer);
procedure marble3(var src, dst: tbitmap; scale: extended;
turbulence: integer);
procedure marble4(var src, dst: tbitmap; scale: extended;
turbulence: integer);
procedure marble5(var src, dst: tbitmap; scale: extended;
turbulence: integer);
procedure marble6(var src, dst: tbitmap; scale: extended;
turbulence: integer);
procedure marble7(var src, dst: tbitmap; scale: extended;
turbulence: integer);
procedure marble8(var src, dst: tbitmap; scale: extended;
turbulence: integer);
procedure squeezehor(src,dst:tbitmap;amount:integer;style:TLightBrush);
procedure splitround(src,dst:tbitmap;amount:integer;style:TLightBrush);
procedure tile(src,dst:TBitmap;amount:integer);
// Interpolator
// Src: Source bitmap
// Dst: Destination bitmap
// filter: Weight calculation filter
// fwidth: Relative sample radius
procedure Strecth(Src, Dst: TBitmap; filter: TFilterProc; fwidth: single);
procedure Grow(Src1,Src2,Dst: TBitmap; amount:extended;x,y:integer);
procedure Invert(src:tbitmap);
procedure MirrorRight(src:Tbitmap);
procedure MirrorDown(src:Tbitmap);
// Sample filters for use with Stretch()
function SplineFilter(Value: Single): Single;
function BellFilter(Value: Single): Single;
function TriangleFilter(Value: Single): Single;
function BoxFilter(Value: Single): Single;
function HermiteFilter(Value: Single): Single;
function Lanczos3Filter(Value: Single): Single;
function MitchellFilter(Value: Single): Single;
const
MaxPixelCount = 32768;
// -----------------------------------------------------------------------------
//
// List of Filters
//
// -----------------------------------------------------------------------------
ResampleFilters: array[0..6] of record
Name: string; // Filter name
Filter: TFilterProc;// Filter implementation
Width: Single; // Suggested sampling width/radius
end = (
(Name: 'Box'; Filter: BoxFilter; Width: 0.5),
(Name: 'Triangle'; Filter: TriangleFilter; Width: 1.0),
(Name: 'Hermite'; Filter: HermiteFilter; Width: 1.0),
(Name: 'Bell'; Filter: BellFilter; Width: 1.5),
(Name: 'B-Spline'; Filter: SplineFilter; Width: 2.0),
(Name: 'Lanczos3'; Filter: Lanczos3Filter; Width: 3.0),
(Name: 'Mitchell'; Filter: MitchellFilter; Width: 2.0)
);
implementation
type
TRGBTripleArray = ARRAY[0..MaxPixelCount-1] OF
TRGBTriple;
pRGBTripleArray = ^TRGBTripleArray;
TFColor=record
b,g,r: Byte;
end;
// Bell filter
function BellFilter(Value: Single): Single;
begin
if (Value < 0.0) then
Value := -Value;
if (Value < 0.5) then
Result := 0.75 - Sqr(Value)
else if (Value < 1.5) then
begin
Value := Value - 1.5;
Result := 0.5 * Sqr(Value);
end else
Result := 0.0;
end;
// Box filter
// a.k.a. "Nearest Neighbour" filter
// anme: I have not been able to get acceptable
// results with this filter for subsampling.
function BoxFilter(Value: Single): Single;
begin
if (Value > -0.5) and (Value <= 0.5) then
Result := 1.0
else
Result := 0.0;
end;
// Hermite filter
function HermiteFilter(Value: Single): Single;
begin
// f(t) = 2|t|^3 - 3|t|^2 + 1, -1 <= t <= 1
if (Value < 0.0) then
Value := -Value;
if (Value < 1.0) then
Result := (2.0 * Value - 3.0) * Sqr(Value) + 1.0
else
Result := 0.0;
end;
// Lanczos3 filter
function Lanczos3Filter(Value: Single): Single;
function SinC(Value: Single): Single;
begin
if (Value <> 0.0) then
begin
Value := Value * Pi;
Result := sin(Value) / Value
end else
Result := 1.0;
end;
begin
if (Value < 0.0) then
Value := -Value;
if (Value < 3.0) then
Result := SinC(Value) * SinC(Value / 3.0)
else
Result := 0.0;
end;
function MitchellFilter(Value: Single): Single;
const
B = (1.0 / 3.0);
C = (1.0 / 3.0);
var
tt : single;
begin
if (Value < 0.0) then
Value := -Value;
tt := Sqr(Value);
if (Value < 1.0) then
begin
Value := (((12.0 - 9.0 * B - 6.0 * C) * (Value * tt))
+ ((-18.0 + 12.0 * B + 6.0 * C) * tt)
+ (6.0 - 2 * B));
Result := Value / 6.0;
end else
if (Value < 2.0) then
begin
Value := (((-1.0 * B - 6.0 * C) * (Value * tt))
+ ((6.0 * B + 30.0 * C) * tt)
+ ((-12.0 * B - 48.0 * C) * Value)
+ (8.0 * B + 24 * C));
Result := Value / 6.0;
end else
Result := 0.0;
end;
// B-spline filter
function SplineFilter(Value: Single): Single;
var
tt : single;
begin
if (Value < 0.0) then
Value := -Value;
if (Value < 1.0) then
begin
tt := Sqr(Value);
Result := 0.5*tt*Value - tt + 2.0 / 3.0;
end else if (Value < 2.0) then
begin
Value := 2.0 - Value;
Result := 1.0/6.0 * Sqr(Value) * Value;
end else
Result := 0.0;
end;
// Triangle filter
// a.k.a. "Linear" or "Bilinear" filter
function TriangleFilter(Value: Single): Single;
begin
if (Value < 0.0) then
Value := -Value;
if (Value < 1.0) then
Result := 1.0 - Value
else
Result := 0.0;
end;
function IntToByte(i:Integer):Byte;
begin
if i>255 then Result:=255
else if i<0 then Result:=0
else Result:=i;
end;
procedure AddColorNoise(var clip: tbitmap; Amount: Integer);
var
p0:pbytearray;
x,y,r,g,b: Integer;
begin
for y:=0 to clip.Height-1 do
begin
p0:=clip.ScanLine [y];
for x:=0 to clip.Width-1 do
begin
r:=p0[x*3]+(Random(Amount)-(Amount shr 1));
g:=p0[x*3+1]+(Random(Amount)-(Amount shr 1));
b:=p0[x*3+2]+(Random(Amount)-(Amount shr 1));
p0[x*3]:=IntToByte(r);
p0[x*3+1]:=IntToByte(g);
p0[x*3+2]:=IntToByte(b);
end;
end;
end;
procedure AddMonoNoise(var clip: tbitmap; Amount: Integer);
var
p0:pbytearray;
x,y,a,r,g,b: Integer;
begin
for y:=0 to clip.Height-1 do
begin
p0:=clip.scanline[y];
for x:=0 to clip.Width-1 do
begin
a:=Random(Amount)-(Amount shr 1);
r:=p0[x*3]+a;
g:=p0[x*3+1]+a;
b:=p0[x*3+2]+a;
p0[x*3]:=IntToByte(r);
p0[x*3+1]:=IntToByte(g);
p0[x*3+2]:=IntToByte(b);
end;
end;
end;
procedure AntiAlias(clip: tbitmap);
begin
AntiAliasRect(clip,0,0,clip.width,clip.height);
end;
procedure AntiAliasRect(clip: tbitmap; XOrigin, YOrigin,
XFinal, YFinal: Integer);
var Memo,x,y: Integer; (* Composantes primaires des points environnants *)
p0,p1,p2:pbytearray;
begin
if XFinal<XOrigin then begin Memo:=XOrigin; XOrigin:=XFinal; XFinal:=Memo; end; (* Inversion des valeurs *)
if YFinal<YOrigin then begin Memo:=YOrigin; YOrigin:=YFinal; YFinal:=Memo; end; (* si diff‚rence n‚gative*)
XOrigin:=max(1,XOrigin);
YOrigin:=max(1,YOrigin);
XFinal:=min(clip.width-2,XFinal);
YFinal:=min(clip.height-2,YFinal);
clip.PixelFormat :=pf24bit;
for y:=YOrigin to YFinal do begin
p0:=clip.ScanLine [y-1];
p1:=clip.scanline [y];
p2:=clip.ScanLine [y+1];
for x:=XOrigin to XFinal do begin
p1[x*3]:=(p0[x*3]+p2[x*3]+p1[(x-1)*3]+p1[(x+1)*3])div 4;
p1[x*3+1]:=(p0[x*3+1]+p2[x*3+1]+p1[(x-1)*3+1]+p1[(x+1)*3+1])div 4;
p1[x*3+2]:=(p0[x*3+2]+p2[x*3+2]+p1[(x-1)*3+2]+p1[(x+1)*3+2])div 4;
end;
end;
end;
procedure Contrast(var clip: tbitmap; Amount: Integer);
var
p0:pbytearray;
rg,gg,bg,r,g,b,x,y: Integer;
begin
for y:=0 to clip.Height-1 do
begin
p0:=clip.scanline[y];
for x:=0 to clip.Width-1 do
begin
r:=p0[x*3];
g:=p0[x*3+1];
b:=p0[x*3+2];
rg:=(Abs(127-r)*Amount)div 255;
gg:=(Abs(127-g)*Amount)div 255;
bg:=(Abs(127-b)*Amount)div 255;
if r>127 then r:=r+rg else r:=r-rg;
if g>127 then g:=g+gg else g:=g-gg;
if b>127 then b:=b+bg else b:=b-bg;
p0[x*3]:=IntToByte(r);
p0[x*3+1]:=IntToByte(g);
p0[x*3+2]:=IntToByte(b);
end;
end;
end;
procedure FishEye( Bmp, Dst: TBitmap; Amount: Extended);
var
xmid,ymid : Single;
fx,fy : Single;
r1, r2 : Single;
ifx, ify : integer;
dx, dy : Single;
rmax : Single;
ty, tx : Integer;
weight_x, weight_y : array[0..1] of Single;
weight : Single;
new_red, new_green : Integer;
new_blue : Integer;
total_red, total_green : Single;
total_blue : Single;
ix, iy : Integer;
sli, slo : PByteArray;
begin
xmid := Bmp.Width/2;
ymid := Bmp.Height/2;
rmax := Dst.Width * Amount;
for ty := 0 to Dst.Height - 1 do begin
for tx := 0 to Dst.Width - 1 do begin
dx := tx - xmid;
dy := ty - ymid;
r1 := Sqrt(dx * dx + dy * dy);
if r1 = 0 then begin
fx := xmid;
fy := ymid;
end
else begin
r2 := rmax / 2 * (1 / (1 - r1/rmax) - 1);
fx := dx * r2 / r1 + xmid;
fy := dy * r2 / r1 + ymid;
end;
ify := Trunc(fy);
ifx := Trunc(fx);
// Calculate the weights.
if fy >= 0 then begin
weight_y[1] := fy - ify;
weight_y[0] := 1 - weight_y[1];
end else begin
weight_y[0] := -(fy - ify);
weight_y[1] := 1 - weight_y[0];
end;
if fx >= 0 then begin
weight_x[1] := fx - ifx;
weight_x[0] := 1 - weight_x[1];
end else begin
weight_x[0] := -(fx - ifx);
Weight_x[1] := 1 - weight_x[0];
end;
if ifx < 0 then
ifx := Bmp.Width-1-(-ifx mod Bmp.Width)
else if ifx > Bmp.Width-1 then
ifx := ifx mod Bmp.Width;
if ify < 0 then
ify := Bmp.Height-1-(-ify mod Bmp.Height)
else if ify > Bmp.Height-1 then
ify := ify mod Bmp.Height;
total_red := 0.0;
total_green := 0.0;
total_blue := 0.0;
for ix := 0 to 1 do begin
for iy := 0 to 1 do begin
if ify + iy < Bmp.Height then
sli := Bmp.scanline[ify + iy]
else
sli := Bmp.scanline[Bmp.Height - ify - iy];
if ifx + ix < Bmp.Width then begin
new_red := sli[(ifx + ix)*3];
new_green := sli[(ifx + ix)*3+1];
new_blue := sli[(ifx + ix)*3+2];
end
else begin
new_red := sli[(Bmp.Width - ifx - ix)*3];
new_green := sli[(Bmp.Width - ifx - ix)*3+1];
new_blue := sli[(Bmp.Width - ifx - ix)*3+2];
end;
weight := weight_x[ix] * weight_y[iy];
total_red := total_red + new_red * weight;
total_green := total_green + new_green * weight;
total_blue := total_blue + new_blue * weight;
end;
end;
slo := Dst.scanline[ty];
slo[tx*3] := Round(total_red);
slo[tx*3+1] := Round(total_green);
slo[tx*3+2] := Round(total_blue);
end;
end;
end;
procedure GaussianBlur(var clip: tbitmap; Amount: integer);
var
i: Integer;
begin
for i:=Amount downto 0 do
SplitBlur(clip,3);
end;
procedure GrayScale(var clip: tbitmap);
var
p0:pbytearray;
Gray,x,y: Integer;
begin
for y:=0 to clip.Height-1 do
begin
p0:=clip.scanline[y];
for x:=0 to clip.Width-1 do
begin
Gray:=Round(p0[x*3]*0.3+p0[x*3+1]*0.59+p0[x*3+2]*0.11);
p0[x*3]:=Gray;
p0[x*3+1]:=Gray;
p0[x*3+2]:=Gray;
end;
end;
end;
procedure Lightness(var clip: tbitmap; Amount: Integer);
var
p0:pbytearray;
r,g,b,p,x,y: Integer;
begin
for y:=0 to clip.Height-1 do begin
p0:=clip.scanline[y];
for x:=0 to clip.Width-1 do
begin
r:=p0[x*3];
g:=p0[x*3+1];
b:=p0[x*3+2];
p0[x*3]:=IntToByte(r+((255-r)*Amount)div 255);
p0[x*3+1]:=IntToByte(g+((255-g)*Amount)div 255);
p0[x*3+2]:=IntToByte(b+((255-b)*Amount)div 255);
end;
end;
end;
procedure Darkness(var src: tbitmap; Amount: integer);
var
p0:pbytearray;
r,g,b,x,y: Integer;
begin
src.pixelformat:=pf24bit;
for y:=0 to src.Height-1 do begin
p0:=src.scanline[y];
for x:=0 to src.Width-1 do
begin
r:=p0[x*3];
g:=p0[x*3+1];
b:=p0[x*3+2];
p0[x*3]:=IntToByte(r-((r)*Amount)div 255);
p0[x*3+1]:=IntToByte(g-((g)*Amount)div 255);
p0[x*3+2]:=IntToByte(b-((b)*Amount)div 255);
end;
end;
end;
procedure marble(var src, dst: tbitmap; scale: extended;
turbulence: integer);
var x,xm,y,ym:integer;
xx,yy:extended;
p1,p2:pbytearray;
w,h:integer;
begin
h:=src.height;
w:=src.width;
dst.width:=w;
dst.height:=h;
dst.canvas.Draw (0,0,src);
for y:=0 to h-1 do begin
yy:=scale*cos((y mod turbulence)/scale);
p1:=src.scanline[y];
for x:=0 to w-1 do begin
xx:=-scale*sin((x mod turbulence)/ scale);
xm:=round(abs(x+xx+yy));
ym:=round(abs(y+yy+xx));
if ym<h then begin
p2:=dst.scanline[ym];
if xm<w then begin
p2[xm*3]:=p1[x*3];
p2[xm*3+1]:=p1[x*3+1];
p2[xm*3+2]:=p1[x*3+2];
end;
end;
end;
end;
end;
procedure marble2(var src, dst: tbitmap; scale: extended;
turbulence: integer);
var x,xm,y,ym:integer;
xx,yy:extended;
p1,p2:pbytearray;
w,h:integer;
begin
h:=src.height;
w:=src.width;
dst.assign(src);
for y:=0 to h-1 do begin
yy:=scale*cos((y mod turbulence)/scale);
p1:=src.scanline[y];
for x:=0 to w-1 do begin
xx:=-scale*sin((x mod turbulence)/ scale);
xm:=round(abs(x+xx-yy));
ym:=round(abs(y+yy-xx));
if ym<h then begin
p2:=dst.scanline[ym];
if xm<w then begin
p2[xm*3]:=p1[x*3];
p2[xm*3+1]:=p1[x*3+1];
p2[xm*3+2]:=p1[x*3+2];
end;
end;
end;
end;
end;
procedure marble3(var src, dst: tbitmap; scale: extended;
turbulence: integer);
var x,xm,y,ym:integer;
xx,yy:extended;
p1,p2:pbytearray;
w,h:integer;
begin
h:=src.height;
w:=src.width;
dst.assign(src);
for y:=0 to h-1 do begin
yy:=scale*cos((y mod turbulence)/scale);
p1:=src.scanline[y];
for x:=0 to w-1 do begin
xx:=-scale*sin((x mod turbulence)/ scale);
xm:=round(abs(x-xx+yy));
ym:=round(abs(y-yy+xx));
if ym<h then begin
p2:=dst.scanline[ym];
if xm<w then begin
p2[xm*3]:=p1[x*3];
p2[xm*3+1]:=p1[x*3+1];
p2[xm*3+2]:=p1[x*3+2];
end;
end;
end;
end;
end;
procedure marble4(var src, dst: tbitmap; scale: extended;
turbulence: integer);
var x,xm,y,ym:integer;
xx,yy:extended;
p1,p2:pbytearray;
w,h:integer;
begin
h:=src.height;
w:=src.width;
dst.assign(src);
for y:=0 to h-1 do begin
yy:=scale*sin((y mod turbulence)/scale);
p1:=src.scanline[y];
for x:=0 to w-1 do begin
xx:=-scale*cos((x mod turbulence)/ scale);
xm:=round(abs(x+xx+yy));
ym:=round(abs(y+yy+xx));
if ym<h then begin
p2:=dst.scanline[ym];
if xm<w then begin
p2[xm*3]:=p1[x*3];
p2[xm*3+1]:=p1[x*3+1];
p2[xm*3+2]:=p1[x*3+2];
end;
end;
end;
end;
end;
procedure marble5(var src, dst: tbitmap; scale: extended;
turbulence: integer);
var x,xm,y,ym:integer;
xx,yy:extended;
p1,p2:pbytearray;
w,h:integer;
begin
h:=src.height;
w:=src.width;
dst.assign(src);
for y:=h-1 downto 0 do begin
yy:=scale*cos((y mod turbulence)/scale);
p1:=src.scanline[y];
for x:=w-1 downto 0 do begin
xx:=-scale*sin((x mod turbulence)/ scale);
xm:=round(abs(x+xx+yy));
ym:=round(abs(y+yy+xx));
if ym<h then begin
p2:=dst.scanline[ym];
if xm<w then begin
p2[xm*3]:=p1[x*3];
p2[xm*3+1]:=p1[x*3+1];
p2[xm*3+2]:=p1[x*3+2];
end;
end;
end;
end;
end;
procedure marble6(var src, dst: tbitmap; scale: extended;
turbulence: integer);
var x,xm,y,ym:integer;
xx,yy:extended;
p1,p2:pbytearray;
w,h:integer;
begin
h:=src.height;
w:=src.width;
dst.assign(src);
for y:=0 to h-1 do begin
yy:=scale*cos((y mod turbulence)/scale);
p1:=src.scanline[y];
for x:=0 to w-1 do begin
xx:=-tan((x mod turbulence)/ scale)/scale;
xm:=round(abs(x+xx+yy));
ym:=round(abs(y+yy+xx));
if ym<h then begin
p2:=dst.scanline[ym];
if xm<w then begin
p2[xm*3]:=p1[x*3];
p2[xm*3+1]:=p1[x*3+1];
p2[xm*3+2]:=p1[x*3+2];
end;
end;
end;
end;
end;
procedure marble7(var src, dst: tbitmap; scale: extended;
turbulence: integer);
var x,xm,y,ym:integer;
xx,yy:extended;
p1,p2:pbytearray;
w,h:integer;
begin
h:=src.height;
w:=src.width;
dst.assign(src);
for y:=0 to h-1 do begin
yy:=scale*sin((y mod turbulence)/scale);
p1:=src.scanline[y];
for x:=0 to w-1 do begin
xx:=-tan((x mod turbulence)/ scale)/(scale*scale);
xm:=round(abs(x+xx+yy));
ym:=round(abs(y+yy+xx));
if ym<h then begin
p2:=dst.scanline[ym];
if xm<w then begin
p2[xm*3]:=p1[x*3];
p2[xm*3+1]:=p1[x*3+1];
p2[xm*3+2]:=p1[x*3+2];
end;
end;
end;
end;
end;
procedure marble8(var src, dst: tbitmap; scale: extended;
turbulence: integer);
var x,xm,y,ym:integer;
xx,yy:extended;
p1,p2:pbytearray;
w,h:integer;
xs,xc,ax:extended;
begin
h:=src.height;
w:=src.width;
dst.assign(src);
for y:=0 to h-1 do begin
ax:=(y mod turbulence)/ scale;
yy:=scale*sin(ax)*cos(1.5*ax);
p1:=src.scanline[y];
for x:=0 to w-1 do begin
ax:=(x mod turbulence)/ scale;
xx:=-scale*sin(2*ax)*cos(ax);
xm:=round(abs(x+xx+yy));
ym:=round(abs(y+yy+xx));
if ym<h then begin
p2:=dst.scanline[ym];
if xm<w then begin
p2[xm*3]:=p1[x*3];
p2[xm*3+1]:=p1[x*3+1];
p2[xm*3+2]:=p1[x*3+2];
end;
end;
end;
end;
end;
procedure Saturation(var clip: tbitmap; Amount: Integer);
var
p0:pbytearray;
Gray,r,g,b,x,y: Integer;
begin
for y:=0 to clip.Height-1 do begin
p0:=clip.scanline[y];
for x:=0 to clip.Width-1 do
begin
r:=p0[x*3];
g:=p0[x*3+1];
b:=p0[x*3+2];
Gray:=(r+g+b)div 3;
p0[x*3]:=IntToByte(Gray+(((r-Gray)*Amount)div 255));
p0[x*3+1]:=IntToByte(Gray+(((g-Gray)*Amount)div 255));
p0[x*3+2]:=IntToByte(Gray+(((b-Gray)*Amount)div 255));
end;
end;
end;
procedure Smooth(var clip: tbitmap; Weight: Integer);
begin
//
end;
procedure SmoothPoint(var clip: tbitmap; xk, yk: integer);
var Bleu, Vert, Rouge,w,h: Integer;
color:TFColor;
Acolor:tcolor;
BB,GG,RR: array[1..5] of Integer;
begin
w:=clip.width;
h:=clip.height;
if (xk>0) and (yk>0) and (xk<w-1) and (yk<h-1) then
with clip.canvas do begin
Acolor:=colortorgb(pixels[xk,yk-1]);
color.r:=getrvalue(Acolor);
color.g:=getgvalue(Acolor);
color.b:=getbvalue(Acolor);
RR[1]:=color.r;
GG[1]:=color.g;
BB[1]:=color.b;
Acolor:=colortorgb(pixels[xk+1,yk]);
color.r:=getrvalue(Acolor);
color.g:=getgvalue(Acolor);
color.b:=getbvalue(Acolor);
RR[2]:=color.r;
GG[2]:=color.g;
BB[2]:=color.b;
acolor:=colortorgb(pixels[xk,yk+1]);
color.r:=getrvalue(Acolor);
color.g:=getgvalue(Acolor);
color.b:=getbvalue(Acolor);
RR[3]:=color.r;
GG[3]:=color.g;
BB[3]:=color.b;
acolor:=colortorgb(pixels[xk-1,yk]);
color.r:=getrvalue(Acolor);
color.g:=getgvalue(Acolor);
color.b:=getbvalue(Acolor);
RR[4]:=color.r;
GG[4]:=color.g;
BB[4]:=color.b;
Bleu :=(BB[1]+(BB[2]+BB[3]+BB[4]))div 4; (* Valeur moyenne *)
Vert:=(GG[1]+(GG[2]+GG[3]+GG[4]))div 4; (* en cours d'‚valuation *)
Rouge :=(RR[1]+(RR[2]+RR[3]+RR[4]))div 4;
color.r:=rouge;
color.g:=vert;
color.b:=bleu;
pixels[xk,yk]:=rgb(color.r,color.g,color.b);
end;
end;
procedure SmoothResize(var Src, Dst: TBitmap);
var
x,y,xP,yP,
yP2,xP2: Integer;
Read,Read2: PByteArray;
t,t3,t13,z,z2,iz2: Integer;
pc:PBytearray;
w1,w2,w3,w4: Integer;
Col1r,col1g,col1b,Col2r,col2g,col2b: byte;
begin
xP2:=((src.Width-1)shl 15)div Dst.Width;
yP2:=((src.Height-1)shl 15)div Dst.Height;
yP:=0;
for y:=0 to Dst.Height-1 do
begin
xP:=0;
Read:=src.ScanLine[yP shr 15];
if yP shr 16<src.Height-1 then
Read2:=src.ScanLine [yP shr 15+1]
else
Read2:=src.ScanLine [yP shr 15];
pc:=Dst.scanline[y];
z2:=yP and $7FFF;
iz2:=$8000-z2;
for x:=0 to Dst.Width-1 do
begin
t:=xP shr 15;
t3:=t*3;
t13:=t3+3;
Col1r:=Read[t3];
Col1g:=Read[t3+1];
Col1b:=Read[t3+2];
Col2r:=Read2[t3];
Col2g:=Read2[t3+1];
Col2b:=Read2[t3+2];
z:=xP and $7FFF;
w2:=(z*iz2)shr 15;
w1:=iz2-w2;
w4:=(z*z2)shr 15;
w3:=z2-w4;
pc[x*3+2]:=
(Col1b*w1+Read[t13+2]*w2+
Col2b*w3+Read2[t13+2]*w4)shr 15;
pc[x*3+1]:=
(Col1g*w1+Read[t13+1]*w2+
Col2g*w3+Read2[t13+1]*w4)shr 15;
// (t+1)*3 is now t13
pc[x*3]:=
(Col1r*w1+Read2[t13]*w2+
Col2r*w3+Read2[t13]*w4)shr 15;
Inc(xP,xP2);
end;
Inc(yP,yP2);
end;
end;
procedure SmoothRotate(var Src, Dst: TBitmap; cx, cy: Integer;
Angle: Extended);
type
TFColor = record b,g,r:Byte end;
var
Top,
Bottom,
Left,
Right,
eww,nsw,
fx,fy,
wx,wy: Extended;
cAngle,
sAngle: Double;
xDiff,
yDiff,
ifx,ify,
px,py,
ix,iy,
x,y: Integer;
nw,ne,
sw,se: TFColor;
P1,P2,P3:Pbytearray;
begin
Angle:=angle;
Angle:=-Angle*Pi/180;
sAngle:=Sin(Angle);
cAngle:=Cos(Angle);
xDiff:=(Dst.Width-Src.Width)div 2;
yDiff:=(Dst.Height-Src.Height)div 2;
for y:=0 to Dst.Height-1 do
begin
P3:=Dst.scanline[y];
py:=2*(y-cy)+1;
for x:=0 to Dst.Width-1 do
begin
px:=2*(x-cx)+1;
fx:=(((px*cAngle-py*sAngle)-1)/ 2+cx)-xDiff;
fy:=(((px*sAngle+py*cAngle)-1)/ 2+cy)-yDiff;
ifx:=Round(fx);
ify:=Round(fy);
if(ifx>-1)and(ifx<Src.Width)and(ify>-1)and(ify<Src.Height)then
begin
eww:=fx-ifx;
nsw:=fy-ify;
iy:=TrimInt(ify+1,0,Src.Height-1);
ix:=TrimInt(ifx+1,0,Src.Width-1);
P1:=Src.scanline[ify];
P2:=Src.scanline[iy];
nw.r:=P1[ifx*3];
nw.g:=P1[ifx*3+1];
nw.b:=P1[ifx*3+2];
ne.r:=P1[ix*3];
ne.g:=P1[ix*3+1];
ne.b:=P1[ix*3+2];
sw.r:=P2[ifx*3];
sw.g:=P2[ifx*3+1];
sw.b:=P2[ifx*3+2];
se.r:=P2[ix*3];
se.g:=P2[ix*3+1];
se.b:=P2[ix*3+2];
Top:=nw.b+eww*(ne.b-nw.b);
Bottom:=sw.b+eww*(se.b-sw.b);
P3[x*3+2]:=IntToByte(Round(Top+nsw*(Bottom-Top)));
Top:=nw.g+eww*(ne.g-nw.g);
Bottom:=sw.g+eww*(se.g-sw.g);
P3[x*3+1]:=IntToByte(Round(Top+nsw*(Bottom-Top)));
Top:=nw.r+eww*(ne.r-nw.r);
Bottom:=sw.r+eww*(se.r-sw.r);
P3[x*3]:=IntToByte(Round(Top+nsw*(Bottom-Top)));
end;
end;
end;
end;
procedure SplitBlur(var clip: tbitmap; Amount: integer);
var
p0,p1,p2:pbytearray;
cx,i,x,y: Integer;
Buf: array[0..3,0..2]of byte;
begin
if Amount=0 then Exit;
for y:=0 to clip.Height-1 do
begin
p0:=clip.scanline[y];
if y-Amount<0 then p1:=clip.scanline[y]
else {y-Amount>0} p1:=clip.ScanLine[y-Amount];
if y+Amount<clip.Height then p2:=clip.ScanLine[y+Amount]
else {y+Amount>=Height} p2:=clip.ScanLine[clip.Height-y];
for x:=0 to clip.Width-1 do
begin
if x-Amount<0 then cx:=x
else {x-Amount>0} cx:=x-Amount;
Buf[0,0]:=p1[cx*3];
Buf[0,1]:=p1[cx*3+1];
Buf[0,2]:=p1[cx*3+2];
Buf[1,0]:=p2[cx*3];
Buf[1,1]:=p2[cx*3+1];
Buf[1,2]:=p2[cx*3+2];
if x+Amount<clip.Width then cx:=x+Amount
else {x+Amount>=Width} cx:=clip.Width-x;
Buf[2,0]:=p1[cx*3];
Buf[2,1]:=p1[cx*3+1];
Buf[2,2]:=p1[cx*3+2];
Buf[3,0]:=p2[cx*3];
Buf[3,1]:=p2[cx*3+1];
Buf[3,2]:=p2[cx*3+2];
p0[x*3]:=(Buf[0,0]+Buf[1,0]+Buf[2,0]+Buf[3,0])shr 2;
p0[x*3+1]:=(Buf[0,1]+Buf[1,1]+Buf[2,1]+Buf[3,1])shr 2;
p0[x*3+2]:=(Buf[0,2]+Buf[1,2]+Buf[2,2]+Buf[3,2])shr 2;
end;
end;
end;
procedure Spray(var clip: tbitmap; Amount: Integer);
var
i,j,x,y,w,h,Val: Integer;
begin
h:=clip.height;
w:=clip.Width;
for i:=0 to w-1 do
for j:=0 to h-1 do
begin
Val:=Random(Amount);
x:=i+Val-Random(Val*2);
y:=j+Val-Random(Val*2);
if(x>-1)and(x<w)and(y>-1)and(y<h)then
clip.canvas.Pixels[i,j]:=clip.canvas.Pixels[x,y];
end;
end;
procedure Mosaic(var Bm:TBitmap;size:Integer);
var
x,y,i,j:integer;
p1,p2:pbytearray;
r,g,b:byte;
begin
y:=0;
repeat
p1:=bm.scanline[y];
x:=0;
repeat
j:=1;
repeat
p2:=bm.scanline[y];
x:=0;
repeat
r:=p1[x*3];
g:=p1[x*3+1];
b:=p1[x*3+2];
i:=1;
repeat
p2[x*3]:=r;
p2[x*3+1]:=g;
p2[x*3+2]:=b;
inc(x);
inc(i);
until (x>=bm.width) or (i>size);
until x>=bm.width;
inc(j);
inc(y);
until (y>=bm.height) or (j>size);
until (y>=bm.height) or (x>=bm.width);
until y>=bm.height;
end;
function TrimInt(i, Min, Max: Integer): Integer;
begin
if i>Max then Result:=Max
else if i<Min then Result:=Min
else Result:=i;
end;
procedure Twist(Bmp, Dst: TBitmap; Amount: integer);
var
fxmid, fymid : Single;
txmid, tymid : Single;
fx,fy : Single;
tx2, ty2 : Single;
r : Single;
theta : Single;
ifx, ify : integer;
dx, dy : Single;
OFFSET : Single;
ty, tx : Integer;
weight_x, weight_y : array[0..1] of Single;
weight : Single;
new_red, new_green : Integer;
new_blue : Integer;
total_red, total_green : Single;
total_blue : Single;
ix, iy : Integer;
sli, slo : PBytearray;
function ArcTan2(xt,yt : Single): Single;
begin
if xt = 0 then
if yt > 0 then
Result := Pi/2
else
Result := -(Pi/2)
else begin
Result := ArcTan(yt/xt);
if xt < 0 then
Result := Pi + ArcTan(yt/xt);
end;
end;
begin
OFFSET := -(Pi/2);
dx := Bmp.Width - 1;
dy := Bmp.Height - 1;
r := Sqrt(dx * dx + dy * dy);
tx2 := r;
ty2 := r;
txmid := (Bmp.Width-1)/2; //Adjust these to move center of rotation
tymid := (Bmp.Height-1)/2; //Adjust these to move ......
fxmid := (Bmp.Width-1)/2;
fymid := (Bmp.Height-1)/2;
if tx2 >= Bmp.Width then tx2 := Bmp.Width-1;
if ty2 >= Bmp.Height then ty2 := Bmp.Height-1;
for ty := 0 to Round(ty2) do begin
for tx := 0 to Round(tx2) do begin
dx := tx - txmid;
dy := ty - tymid;
r := Sqrt(dx * dx + dy * dy);
if r = 0 then begin
fx := 0;
fy := 0;
end
else begin
theta := ArcTan2(dx,dy) - r/Amount - OFFSET;
fx := r * Cos(theta);
fy := r * Sin(theta);
end;
fx := fx + fxmid;
fy := fy + fymid;
ify := Trunc(fy);
ifx := Trunc(fx);
// Calculate the weights.
if fy >= 0 then begin
weight_y[1] := fy - ify;
weight_y[0] := 1 - weight_y[1];
end else begin
weight_y[0] := -(fy - ify);
weight_y[1] := 1 - weight_y[0];
end;
if fx >= 0 then begin
weight_x[1] := fx - ifx;
weight_x[0] := 1 - weight_x[1];
end else begin
weight_x[0] := -(fx - ifx);
Weight_x[1] := 1 - weight_x[0];
end;
if ifx < 0 then
ifx := Bmp.Width-1-(-ifx mod Bmp.Width)
else if ifx > Bmp.Width-1 then
ifx := ifx mod Bmp.Width;
if ify < 0 then
ify := Bmp.Height-1-(-ify mod Bmp.Height)
else if ify > Bmp.Height-1 then
ify := ify mod Bmp.Height;
total_red := 0.0;
total_green := 0.0;
total_blue := 0.0;
for ix := 0 to 1 do begin
for iy := 0 to 1 do begin
if ify + iy < Bmp.Height then
sli := Bmp.scanline[ify + iy]
else
sli := Bmp.scanline[Bmp.Height - ify - iy];
if ifx + ix < Bmp.Width then begin
new_red := sli[(ifx + ix)*3];
new_green := sli[(ifx + ix)*3+1];
new_blue := sli[(ifx + ix)*3+2];
end
else begin
new_red := sli[(Bmp.Width - ifx - ix)*3];
new_green := sli[(Bmp.Width - ifx - ix)*3+1];
new_blue := sli[(Bmp.Width - ifx - ix)*3+2];
end;
weight := weight_x[ix] * weight_y[iy];
total_red := total_red + new_red * weight;
total_green := total_green + new_green * weight;
total_blue := total_blue + new_blue * weight;
end;
end;
slo := Dst.scanline[ty];
slo[tx*3] := Round(total_red);
slo[tx*3+1] := Round(total_green);
slo[tx*3+2] := Round(total_blue);
end;
end;
end;
procedure Wave(var clip:tbitmap;amount,inference,style:integer);
var
c,c2,x,y : integer;
BitMap : TBitMap;
P1,P2 : PByteArray;
b:integer;
fangle:real;
wavex:integer;
begin
BitMap := TBitMap.create;
Bitmap.assign(clip);
wavex:=style;
fangle:=pi / 2 / amount;
for y := BitMap.height -1-(2*amount) downto amount do begin
P1 := BitMap.ScanLine[y];
b:=0;
for x:=0 to Bitmap.width-1 do begin
P2 := clip.scanline[y+amount+b];
P2[x*3]:=P1[x*3];
P2[x*3+1]:=P1[x*3+1];
P2[x*3+2]:=P1[x*3+2];
case wavex of
0: b:=amount*variant(sin(fangle*x));
1: b:=amount*variant(sin(fangle*x)*cos(fangle*x));
2: b:=amount*variant(sin(fangle*x)*sin(inference*fangle*x));
end;
end;
end;
BitMap.free;
end;
procedure MakeSeamlessClip(var clip:tbitmap;seam:integer);
var
p0,p1,p2:pbytearray;
h,w,i,j,sv,sh:integer;
f0,f1,f2:real;
begin
h:=clip.height;
w:=clip.width;
sv:=h div seam;
sh:=w div seam;
p1:=clip.scanline[0];
p2:=clip.ScanLine [h-1];
for i:=0 to w-1 do begin
p1[i*3]:=p2[i*3];
p1[i*3+1]:=p2[i*3+1];
p1[i*3+2]:=p2[i*3+2];
end;
p0:=clip.scanline[0];
p2:=clip.scanline[sv];
for j:=1 to sv-1 do begin
p1:=clip.scanline[j];
for i:=0 to w-1 do begin
f0:=(p2[i*3]-p0[i*3])/sv*j+p0[i*3];
p1[i*3]:= round (f0);
f1:=(p2[i*3+1]-p0[i*3+1])/sv*j+p0[i*3+1];
p1[i*3+1]:=round (f1);
f2:=(p2[i*3+2]-p0[i*3+2])/sv*j+p0[i*3+2];
p1[i*3+2]:=round (f2);
end;
end;
for j:=0 to h-1 do begin
p1:=clip.scanline[j];
p1[(w-1)*3]:=p1[0];
p1[(w-1)*3+1]:=p1[1];
p1[(w-1)*3+2]:=p1[2];
for i:=1 to sh-1 do begin
f0:=(p1[(w-sh)*3]-p1[(w-1)*3])/sh*i+p1[(w-1)*3];
p1[(w-1-i)*3]:=round(f0);
f1:=(p1[(w-sh)*3+1]-p1[(w-1)*3+1])/sh*i+p1[(w-1)*3+1];
p1[(w-1-i)*3+1]:=round(f1);
f2:=(p1[(w-sh)*3+2]-p1[(w-1)*3+2])/sh*i+p1[(w-1)*3+2];
p1[(w-1-i)*3+2]:=round(f2);
end;
end;
end;
procedure splitlight(var clip:tbitmap;amount:integer);
var x,y,i:integer;
p1:pbytearray;
function sinpixs(a:integer):integer;
begin
result:=variant(sin(a/255*pi/2)*255);
end;
begin
for i:=1 to amount do
for y:=0 to clip.height-1 do begin
p1:=clip.scanline[y];
for x:=0 to clip.width-1 do begin
p1[x*3]:=sinpixs(p1[x*3]);
p1[x*3+1]:=sinpixs(p1[x*3+1]);
p1[x*3+2]:=sinpixs(p1[x*3+2]);
end;
end;
end;
procedure squeezehor(src,dst:tbitmap;amount:integer;style:TLightBrush);
var dx,x,y,h,w,c,cx:integer;
R:trect;
bm:tbitmap;
p0,p1:pbytearray;
begin
if amount>(src.width div 2) then
amount:=src.width div 2;
bm:=tbitmap.create;
bm.PixelFormat :=pf24bit;
bm.height:=1;
bm.width:=src.width;
cx:=src.width div 2;
p0:=bm.scanline[0];
for y:=0 to src.height-1 do begin
p1:=src.scanline[y];
for x:=0 to src.width-1 do begin
c:=x*3;
p0[c]:=p1[c];
p0[c+1]:=p1[c+1];
p0[c+2]:=p1[c+2];
end;
case style of
mbhor:
begin
dx:=amount;
R:=rect(dx,y,src.width-dx,y+1);
end;
mbtop:
begin
dx:= round((src.height-1-y)/src.height*amount);
R:=rect(dx,y,src.width-dx,y+1);
end;
mbBottom:
begin
dx:= round(y/src.height*amount);
R:=rect(dx,y,src.width-dx,y+1);
end;
mbDiamond:
begin
dx:=round(amount*abs(cos(y/(src.height-1)*pi)));
R:=rect(dx,y,src.width-dx,y+1);
end;
mbWaste:
begin
dx:=round(amount*abs(sin(y/(src.height-1)*pi)));
R:=rect(dx,y,src.width-dx,y+1);
end;
mbRound:
begin
dx:=round(amount*abs(sin(y/(src.height-1)*pi)));
R:=rect(cx-dx,y,cx+dx,y+1);
end;
mbRound2:
begin
dx:=round(amount*abs(sin(y/(src.height-1)*pi*2)));
R:=rect(cx-dx,y,cx+dx,y+1);
end;
end;
dst.Canvas.StretchDraw (R,bm);
end;
bm.free;
end;
procedure tile(src, dst: TBitmap; amount: integer);
var w,h,w2,h2,i,j:integer;
bm:tbitmap;
begin
w:=src.width;
h:=src.height;
dst.width:=w;
dst.height:=h;
dst.Canvas.draw(0,0,src);
if (amount<=0) or ((w div amount)<5)or ((h div amount)<5) then exit;
h2:=h div amount;
w2:=w div amount;
bm:=tbitmap.create;
bm.width:=w2;
bm.height:=h2;
bm.PixelFormat :=pf24bit;
smoothresize(src,bm);
for j:=0 to amount-1 do
for i:=0 to amount-1 do
dst.canvas.Draw (i*w2,j*h2,bm);
bm.free;
end;
// -----------------------------------------------------------------------------
//
// Interpolator
//
// -----------------------------------------------------------------------------
type
// Contributor for a pixel
TContributor = record
pixel: integer; // Source pixel
weight: single; // Pixel weight
end;
TContributorList = array[0..0] of TContributor;
PContributorList = ^TContributorList;
// List of source pixels contributing to a destination pixel
TCList = record
n : integer;
p : PContributorList;
end;
TCListList = array[0..0] of TCList;
PCListList = ^TCListList;
TRGB = packed record
r, g, b : single;
end;
// Physical bitmap pixel
TColorRGB = packed record
r, g, b : BYTE;
end;
PColorRGB = ^TColorRGB;
// Physical bitmap scanline (row)
TRGBList = packed array[0..0] of TColorRGB;
PRGBList = ^TRGBList;
procedure Strecth(Src, Dst: TBitmap; filter: TFilterProc;
fwidth: single);
var
xscale, yscale : single; // Zoom scale factors
i, j, k : integer; // Loop variables
center : single; // Filter calculation variables
width, fscale, weight : single; // Filter calculation variables
left, right : integer; // Filter calculation variables
n : integer; // Pixel number
Work : TBitmap;
contrib : PCListList;
rgb : TRGB;
color : TColorRGB;
{$IFDEF USE_SCANLINE}
SourceLine ,
DestLine : PRGBList;
SourcePixel ,
DestPixel : PColorRGB;
Delta ,
DestDelta : integer;
{$ENDIF}
SrcWidth ,
SrcHeight ,
DstWidth ,
DstHeight : integer;
function Color2RGB(Color: TColor): TColorRGB;
begin
Result.r := Color AND $000000FF;
Result.g := (Color AND $0000FF00) SHR 8;
Result.b := (Color AND $00FF0000) SHR 16;
end;
function RGB2Color(Color: TColorRGB): TColor;
begin
Result := Color.r OR (Color.g SHL 8) OR (Color.b SHL 16);
end;
begin
DstWidth := Dst.Width;
DstHeight := Dst.Height;
SrcWidth := Src.Width;
SrcHeight := Src.Height;
if (SrcWidth < 1) or (SrcHeight < 1) then
raise Exception.Create('Source bitmap too small');
// Create intermediate image to hold horizontal zoom
Work := TBitmap.Create;
try
Work.Height := SrcHeight;
Work.Width := DstWidth;
// xscale := DstWidth / SrcWidth;
// yscale := DstHeight / SrcHeight;
// Improvement suggested by David Ullrich:
if (SrcWidth = 1) then
xscale:= DstWidth / SrcWidth
else
xscale:= (DstWidth - 1) / (SrcWidth - 1);
if (SrcHeight = 1) then
yscale:= DstHeight / SrcHeight
else
yscale:= (DstHeight - 1) / (SrcHeight - 1);
// This implementation only works on 24-bit images because it uses
// TBitmap.Scanline
{$IFDEF USE_SCANLINE}
Src.PixelFormat := pf24bit;
Dst.PixelFormat := Src.PixelFormat;
Work.PixelFormat := Src.PixelFormat;
{$ENDIF}
// --------------------------------------------
// Pre-calculate filter contributions for a row
// -----------------------------------------------
GetMem(contrib, DstWidth* sizeof(TCList));
// Horizontal sub-sampling
// Scales from bigger to smaller width
if (xscale < 1.0) then
begin
width := fwidth / xscale;
fscale := 1.0 / xscale;
for i := 0 to DstWidth-1 do
begin
contrib^[i].n := 0;
GetMem(contrib^[i].p, trunc(width * 2.0 + 1) * sizeof(TContributor));
center := i / xscale;
// Original code:
// left := ceil(center - width);
// right := floor(center + width);
left := floor(center - width);
right := ceil(center + width);
for j := left to right do
begin
weight := filter((center - j) / fscale) / fscale;
if (weight = 0.0) then
continue;
if (j < 0) then
n := -j
else if (j >= SrcWidth) then
n := SrcWidth - j + SrcWidth - 1
else
n := j;
k := contrib^[i].n;
contrib^[i].n := contrib^[i].n + 1;
contrib^[i].p^[k].pixel := n;
contrib^[i].p^[k].weight := weight;
end;
end;
end else
// Horizontal super-sampling
// Scales from smaller to bigger width
begin
for i := 0 to DstWidth-1 do
begin
contrib^[i].n := 0;
GetMem(contrib^[i].p, trunc(fwidth * 2.0 + 1) * sizeof(TContributor));
center := i / xscale;
// Original code:
// left := ceil(center - fwidth);
// right := floor(center + fwidth);
left := floor(center - fwidth);
right := ceil(center + fwidth);
for j := left to right do
begin
weight := filter(center - j);
if (weight = 0.0) then
continue;
if (j < 0) then
n := -j
else if (j >= SrcWidth) then
n := SrcWidth - j + SrcWidth - 1
else
n := j;
k := contrib^[i].n;
contrib^[i].n := contrib^[i].n + 1;
contrib^[i].p^[k].pixel := n;
contrib^[i].p^[k].weight := weight;
end;
end;
end;
// ----------------------------------------------------
// Apply filter to sample horizontally from Src to Work
// ----------------------------------------------------
for k := 0 to SrcHeight-1 do
begin
{$IFDEF USE_SCANLINE}
SourceLine := Src.ScanLine[k];
DestPixel := Work.ScanLine[k];
{$ENDIF}
for i := 0 to DstWidth-1 do
begin
rgb.r := 0.0;
rgb.g := 0.0;
rgb.b := 0.0;
for j := 0 to contrib^[i].n-1 do
begin
{$IFDEF USE_SCANLINE}
color := SourceLine^[contrib^[i].p^[j].pixel];
{$ELSE}
color := Color2RGB(Src.Canvas.Pixels[contrib^[i].p^[j].pixel, k]);
{$ENDIF}
weight := contrib^[i].p^[j].weight;
if (weight = 0.0) then
continue;
rgb.r := rgb.r + color.r * weight;
rgb.g := rgb.g + color.g * weight;
rgb.b := rgb.b + color.b * weight;
end;
if (rgb.r > 255.0) then
color.r := 255
else if (rgb.r < 0.0) then
color.r := 0
else
color.r := round(rgb.r);
if (rgb.g > 255.0) then
color.g := 255
else if (rgb.g < 0.0) then
color.g := 0
else
color.g := round(rgb.g);
if (rgb.b > 255.0) then
color.b := 255
else if (rgb.b < 0.0) then
color.b := 0
else
color.b := round(rgb.b);
{$IFDEF USE_SCANLINE}
// Set new pixel value
DestPixel^ := color;
// Move on to next column
inc(DestPixel);
{$ELSE}
Work.Canvas.Pixels[i, k] := RGB2Color(color);
{$ENDIF}
end;
end;
// Free the memory allocated for horizontal filter weights
for i := 0 to DstWidth-1 do
FreeMem(contrib^[i].p);
FreeMem(contrib);
// -----------------------------------------------
// Pre-calculate filter contributions for a column
// -----------------------------------------------
GetMem(contrib, DstHeight* sizeof(TCList));
// Vertical sub-sampling
// Scales from bigger to smaller height
if (yscale < 1.0) then
begin
width := fwidth / yscale;
fscale := 1.0 / yscale;
for i := 0 to DstHeight-1 do
begin
contrib^[i].n := 0;
GetMem(contrib^[i].p, trunc(width * 2.0 + 1) * sizeof(TContributor));
center := i / yscale;
// Original code:
// left := ceil(center - width);
// right := floor(center + width);
left := floor(center - width);
right := ceil(center + width);
for j := left to right do
begin
weight := filter((center - j) / fscale) / fscale;
if (weight = 0.0) then
continue;
if (j < 0) then
n := -j
else if (j >= SrcHeight) then
n := SrcHeight - j + SrcHeight - 1
else
n := j;
k := contrib^[i].n;
contrib^[i].n := contrib^[i].n + 1;
contrib^[i].p^[k].pixel := n;
contrib^[i].p^[k].weight := weight;
end;
end
end else
// Vertical super-sampling
// Scales from smaller to bigger height
begin
for i := 0 to DstHeight-1 do
begin
contrib^[i].n := 0;
GetMem(contrib^[i].p, trunc(fwidth * 2.0 + 1) * sizeof(TContributor));
center := i / yscale;
// Original code:
// left := ceil(center - fwidth);
// right := floor(center + fwidth);
left := floor(center - fwidth);
right := ceil(center + fwidth);
for j := left to right do
begin
weight := filter(center - j);
if (weight = 0.0) then
continue;
if (j < 0) then
n := -j
else if (j >= SrcHeight) then
n := SrcHeight - j + SrcHeight - 1
else
n := j;
k := contrib^[i].n;
contrib^[i].n := contrib^[i].n + 1;
contrib^[i].p^[k].pixel := n;
contrib^[i].p^[k].weight := weight;
end;
end;
end;
// --------------------------------------------------
// Apply filter to sample vertically from Work to Dst
// --------------------------------------------------
{$IFDEF USE_SCANLINE}
SourceLine := Work.ScanLine[0];
Delta := integer(Work.ScanLine[1]) - integer(SourceLine);
DestLine := Dst.ScanLine[0];
DestDelta := integer(Dst.ScanLine[1]) - integer(DestLine);
{$ENDIF}
for k := 0 to DstWidth-1 do
begin
{$IFDEF USE_SCANLINE}
DestPixel := pointer(DestLine);
{$ENDIF}
for i := 0 to DstHeight-1 do
begin
rgb.r := 0;
rgb.g := 0;
rgb.b := 0;
// weight := 0.0;
for j := 0 to contrib^[i].n-1 do
begin
{$IFDEF USE_SCANLINE}
color := PColorRGB(integer(SourceLine)+contrib^[i].p^[j].pixel*Delta)^;
{$ELSE}
color := Color2RGB(Work.Canvas.Pixels[k, contrib^[i].p^[j].pixel]);
{$ENDIF}
weight := contrib^[i].p^[j].weight;
if (weight = 0.0) then
continue;
rgb.r := rgb.r + color.r * weight;
rgb.g := rgb.g + color.g * weight;
rgb.b := rgb.b + color.b * weight;
end;
if (rgb.r > 255.0) then
color.r := 255
else if (rgb.r < 0.0) then
color.r := 0
else
color.r := round(rgb.r);
if (rgb.g > 255.0) then
color.g := 255
else if (rgb.g < 0.0) then
color.g := 0
else
color.g := round(rgb.g);
if (rgb.b > 255.0) then
color.b := 255
else if (rgb.b < 0.0) then
color.b := 0
else
color.b := round(rgb.b);
{$IFDEF USE_SCANLINE}
DestPixel^ := color;
inc(integer(DestPixel), DestDelta);
{$ELSE}
Dst.Canvas.Pixels[k, i] := RGB2Color(color);
{$ENDIF}
end;
{$IFDEF USE_SCANLINE}
Inc(SourceLine, 1);
Inc(DestLine, 1);
{$ENDIF}
end;
// Free the memory allocated for vertical filter weights
for i := 0 to DstHeight-1 do
FreeMem(contrib^[i].p);
FreeMem(contrib);
finally
Work.Free;
end;
end;
procedure Grow(Src1, Src2, Dst: TBitmap; amount: extended;x,y:integer);
var
bm:tbitmap;
h,w,hr,wr:integer;
begin
w:=src1.Width ;
h:=src1.Height;
Dst.Width :=w;
Dst.Height:=h;
Dst.Canvas.Draw (0,0,Src1);
wr:= round(amount*w);
hr:= round(amount*h);
bm:=tbitmap.create;
bm.width:=wr;
bm.height:=hr;
Strecth(Src2,bm,resamplefilters[4].filter,resamplefilters[4].width);
Dst.Canvas.Draw (x,y,bm);
bm.free;
end;
procedure SpotLight(var src: Tbitmap; Amount: integer;
Spot: TRect);
var bm:tbitmap;
w,h:integer;
begin
Darkness(src,amount);
w:=src.Width;
h:=src.Height ;
bm:=tbitmap.create;
bm.width:=w;
bm.height:=h;
bm.canvas.Brush.color:=clblack;
bm.canvas.FillRect (rect(0,0,w,h));
bm.canvas.brush.Color :=clwhite;
bm.canvas.Ellipse (Spot.left,spot.top,spot.right,spot.bottom);
bm.transparent:=true;
bm.TransparentColor :=clwhite;
src.Canvas.Draw (0,0,bm);
bm.free;
end;
procedure FlipDown(src: Tbitmap);
var
dest:tbitmap;
w,h,x,y:integer;
pd,ps:pbytearray;
begin
w:=src.width;
h:=src.height;
dest:=tbitmap.create;
dest.width:=w;
dest.height:=h;
dest.pixelformat:=pf24bit;
src.pixelformat:=pf24bit;
for y:=0 to h-1 do begin
pd:=dest.scanline[y];
ps:=src.scanline[h-1-y];
for x:=0 to w-1 do begin
pd[x*3]:=ps[x*3];
pd[x*3+1]:=ps[x*3+1];
pd[x*3+2]:=ps[x*3+2];
end;
end;
src.assign(dest);
dest.free;
end;
procedure FlipRight(src: Tbitmap);
var
dest:tbitmap;
w,h,x,y:integer;
pd,ps:pbytearray;
begin
w:=src.width;
h:=src.height;
dest:=tbitmap.create;
dest.width:=w;
dest.height:=h;
dest.pixelformat:=pf24bit;
src.pixelformat:=pf24bit;
for y:=0 to h-1 do begin
pd:=dest.scanline[y];
ps:=src.scanline[y];
for x:=0 to w-1 do begin
pd[x*3]:=ps[(w-1-x)*3];
pd[x*3+1]:=ps[(w-1-x)*3+1];
pd[x*3+2]:=ps[(w-1-x)*3+2];
end;
end;
src.assign(dest);
dest.free;
end;
procedure Trace(src:Tbitmap;intensity:integer);
var
x,y,i : integer;
P1,P2,P3,P4 : PByteArray;
tb,TraceB:byte;
hasb:boolean;
bitmap:tbitmap;
begin
bitmap:=tbitmap.create;
bitmap.width:=src.width;
bitmap.height:=src.height;
bitmap.canvas.draw(0,0,src);
bitmap.PixelFormat :=pf8bit;
src.PixelFormat :=pf24bit;
hasb:=false;
TraceB:=$00;
for i:=1 to Intensity do begin
for y := 0 to BitMap.height -2 do begin
P1 := BitMap.ScanLine[y];
P2 := BitMap.scanline[y+1];
P3 := src.scanline[y];
P4 := src.scanline[y+1];
x:=0;
repeat
if p1[x]<>p1[x+1] then begin
if not hasb then begin
tb:=p1[x+1];
hasb:=true;
p3[x*3]:=TraceB;
p3[x*3+1]:=TraceB;
p3[x*3+2]:=TraceB;
end
else begin
if p1[x]<>tb then
begin
p3[x*3]:=TraceB;
p3[x*3+1]:=TraceB;
p3[x*3+2]:=TraceB;
end
else
begin
p3[(x+1)*3]:=TraceB;
p3[(x+1)*3+1]:=TraceB;
p3[(x+1)*3+1]:=TraceB;
end;
end;
end;
if p1[x]<>p2[x] then begin
if not hasb then begin
tb:=p2[x];
hasb:=true;
p3[x*3]:=TraceB;
p3[x*3+1]:=TraceB;
p3[x*3+2]:=TraceB;
end
else begin
if p1[x]<>tb then
begin
p3[x*3]:=TraceB;
p3[x*3+1]:=TraceB;
p3[x*3+2]:=TraceB;
end
else
begin
p4[x*3]:=TraceB;
p4[x*3+1]:=TraceB;
p4[x*3+2]:=TraceB;
end;
end;
end;
inc(x);
until x>=(BitMap.width -2);
end;
// do the same in the opposite direction
// only when intensity>1
if i>1 then
for y := BitMap.height -1 downto 1 do begin
P1 := BitMap.ScanLine[y];
P2 := BitMap.scanline[y-1];
P3 := src.scanline[y];
P4 := src.scanline [y-1];
x:=Bitmap.width-1;
repeat
if p1[x]<>p1[x-1] then begin
if not hasb then begin
tb:=p1[x-1];
hasb:=true;
p3[x*3]:=TraceB;
p3[x*3+1]:=TraceB;
p3[x*3+2]:=TraceB;
end
else begin
if p1[x]<>tb then
begin
p3[x*3]:=TraceB;
p3[x*3+1]:=TraceB;
p3[x*3+2]:=TraceB;
end
else
begin
p3[(x-1)*3]:=TraceB;
p3[(x-1)*3+1]:=TraceB;
p3[(x-1)*3+2]:=TraceB;
end;
end;
end;
if p1[x]<>p2[x] then begin
if not hasb then begin
tb:=p2[x];
hasb:=true;
p3[x*3]:=TraceB;
p3[x*3+1]:=TraceB;
p3[x*3+2]:=TraceB;
end
else begin
if p1[x]<>tb then
begin
p3[x*3]:=TraceB;
p3[x*3+1]:=TraceB;
p3[x*3+2]:=TraceB;
end
else
begin
p4[x*3]:=TraceB;
p4[x*3+1]:=TraceB;
p4[x*3+2]:=TraceB;
end;
end;
end;
dec(x);
until x<=1;
end;
end;
bitmap.free;
end;
procedure shadowupleft(src:Tbitmap);
var
c,c2,x,y : integer;
BitMap : TBitMap;
P1,P2 : PByteArray;
begin
BitMap := TBitMap.create;
bitmap.width:=src.width;
bitmap.height:=src.height;
Bitmap.pixelformat:=pf24bit;
Bitmap.canvas.draw(0,0,src);
for y := 0 to BitMap.height -5 do begin
P1 := BitMap.ScanLine[y];
P2 := BitMap.scanline[y+4];
for x:=0 to Bitmap.width-5 do
if P1[x*3]>P2[(x+4)*3] then begin
P1[x*3]:=P2[(x+4)*3]+1;
P1[x*3+1]:=P2[(x+4)*3+1]+1;
P1[x*3+2]:=P2[(x+4)*3+2]+1;
end;
end;
src.Assign (bitmap);
BitMap.free;
end;
procedure shadowupright(src:tbitmap);
var
x,y : integer;
BitMap : TBitMap;
P1,P2 : PByteArray;
begin
BitMap := TBitMap.create;
bitmap.width:=src.width;
bitmap.height:=src.height;
Bitmap.pixelformat:=pf24bit;
Bitmap.canvas.draw(0,0,src);
for y := 0 to bitmap.height -5 do begin
P1 := BitMap.ScanLine[y];
P2 := BitMap.scanline[y+4];
for x:=Bitmap.width-1 downto 4 do
if P1[x*3]>P2[(x-4)*3] then begin
P1[x*3]:=P2[(x-4)*3]+1;
P1[x*3+1]:=P2[(x-4)*3+1]+1;
P1[x*3+2]:=P2[(x-4)*3+2]+1;
end;
end;
src.Assign (bitmap);
BitMap.free;
end;
procedure ShadowDownLeft(src:tbitmap);
var
x,y : integer;
BitMap : TBitMap;
P1,P2 : PByteArray;
begin
BitMap := TBitMap.create;
bitmap.width:=src.width;
bitmap.height:=src.height;
Bitmap.pixelformat:=pf24bit;
Bitmap.canvas.draw(0,0,src);
for y := bitmap.height -1 downto 4 do begin
P1 := BitMap.ScanLine[y];
P2 := BitMap.scanline[y-4];
for x:=0 to Bitmap.width-5 do
if P1[x*3]>P2[(x+4)*3] then begin
P1[x*3]:=P2[(x+4)*3]+1;
P1[x*3+1]:=P2[(x+4)*3+1]+1;
P1[x*3+2]:=P2[(x+4)*3+2]+1;
end;
end;
src.Assign (bitmap);
BitMap.free;
end;
procedure ShadowDownRight(src:tbitmap);
var
x,y : integer;
BitMap : TBitMap;
P1,P2 : PByteArray;
begin
BitMap := TBitMap.create;
bitmap.width:=src.width;
bitmap.height:=src.height;
Bitmap.pixelformat:=pf24bit;
Bitmap.canvas.draw(0,0,src);
for y := bitmap.height -1 downto 4 do begin
P1 := BitMap.ScanLine[y];
P2 := BitMap.scanline[y-4];
for x:=Bitmap.width-1 downto 4 do
if P1[x*3]>P2[(x-4)*3] then begin
P1[x*3]:=P2[(x-4)*3]+1;
P1[x*3+1]:=P2[(x-4)*3+1]+1;
P1[x*3+2]:=P2[(x-4)*3+2]+1;
end;
end;
src.Assign (bitmap);
BitMap.free;
end;
procedure semiOpaque(src,dst:Tbitmap);
var b:tbitmap;
P:Pbytearray;
x,y:integer;
begin
b:=tbitmap.create;
b.width:=src.width;
b.height:=src.height;
b.PixelFormat :=pf24bit;
b.canvas.draw(0,0,src);
for y:=0 to b.height-1 do begin
p:=b.scanline[y];
if (y mod 2)=0 then begin
for x:=0 to b.width-1 do
if (x mod 2)=0 then begin
p[x*3]:=$FF;
p[x*3+1]:=$FF;
p[x*3+2]:=$FF;
end;
end
else begin
for x:=0 to b.width-1 do
if ((x+1) mod 2)=0 then begin
p[x*3]:=$FF;
p[x*3+1]:=$FF;
p[x*3+2]:=$FF;
end;
end;
end;
b.transparent:=true;
b.transparentcolor:=clwhite;
dst.canvas.draw(0,0,b);
b.free;
end;
procedure QuartoOpaque(src,dst:tbitmap);
var b:tbitmap;
P:Pbytearray;
x,y:integer;
begin
b:=tbitmap.create;
b.width:=src.width;
b.height:=src.height;
b.PixelFormat :=pf24bit;
b.canvas.draw(0,0,src);
for y:=0 to b.height-1 do begin
p:=b.scanline[y];
if (y mod 2)=0 then begin
for x:=0 to b.width-1 do
if (x mod 2)=0 then begin
p[x*3]:=$FF;
p[x*3+1]:=$FF;
p[x*3+2]:=$FF;
end;
end
else begin
for x:=0 to b.width-1 do begin
p[x*3]:=$FF;
p[x*3+1]:=$FF;
p[x*3+2]:=$FF;
end;
end;
end;
b.transparent:=true;
b.transparentcolor:=clwhite;
dst.canvas.draw(0,0,b);
b.free;
end;
procedure FoldRight(src1,src2,dst: Tbitmap; amount: extended);
var
w,h,x,y,xf,xf0:integer;
ps1,ps2,pd:pbytearray;
begin
src1.PixelFormat :=pf24bit;
src2.PixelFormat :=pf24bit;
w:=src1.width;
h:=src2.height;
dst.width:=w;
dst.height:=h;
dst.PixelFormat :=pf24bit;
xf:=round(amount*w);
for y:=0 to h-1 do begin
ps1:=src1.ScanLine [y];
ps2:=src2.scanline[y];
pd:=dst.scanline[y];
for x:=0 to xf do begin
xf0:=xf+(xf-x);
if xf0<w then begin
pd[xf0*3]:=ps1[x*3];
pd[xf0*3+1]:=ps1[x*3+1];
pd[xf0*3+2]:=ps1[x*3+2];
pd[x*3]:=ps2[x*3];
pd[x*3+1]:=ps2[x*3+1];
pd[x*3+2]:=ps2[x*3+2];
end;
end;
if (2*xf)<w-1 then
for x:=2*xf+1 to w-1 do begin
pd[x*3]:=ps1[x*3];
pd[x*3+1]:=ps1[x*3+1];
pd[x*3+2]:=ps1[x*3+2];
end;
end;
end;
procedure MandelBrot(src: Tbitmap; factor: integer);
const maxX=1.25;
minX=-2;
maxY=1.25;
minY=-1.25;
var
w,h,x,y,facx,facy:integer;
Sa,Sbi,dx,dy:extended;
p0:pbytearray;
color:integer;
xlo,xhi,ylo,yhi:extended;
FUNCTION IsMandel(CA,CBi:extended):integer;
const MAX_ITERATION=64;
VAR
OLD_A :extended; {just a variable to keep 'a' from being destroyed}
A,B :extended; {function Z divided in real and imaginary parts}
LENGTH_Z :extended; {length of Z, sqrt(length_z)>2 => Z->infinity}
iteration :integer;
BEGIN
A:=0; {initialize Z(0) = 0}
B:=0;
ITERATION:=0; {initialize iteration}
REPEAT
OLD_A:=A; {saves the 'a' (Will be destroyed in next line}
A:= A*A - B*B + CA;
B:= 2*OLD_A*B + CBi;
ITERATION := ITERATION + 1;
LENGTH_Z:= A*A + B*B;
UNTIL (LENGTH_Z >= 4) OR (ITERATION > MAX_ITERATION);
result:=iteration;
END;
begin
w:=src.width;
h:=src.height;
src.pixelformat:=pf24bit;
dx := (MaxX-MinX)/w;
dy := (Maxy-MinY)/h;
for y:=0 to h-1 do begin
p0:=src.ScanLine [y];
for x:=0 to w-1 do begin
color:= IsMandel(MinX+x*dx, MinY+y*dy);
if color>factor then color:=$FF
else color:=$00;
p0[x*3]:=color;
p0[x*3+1]:=color;
p0[x*3+2]:=color;
end;
end;
end;
procedure MaskMandelBrot(src: Tbitmap; factor: integer);
var
bm:Tbitmap;
begin
bm:=tbitmap.create;
bm.width:=src.width;
bm.height:=src.height;
MandelBrot(bm,factor);
bm.transparent:=true;
bm.transparentcolor:=clwhite;
src.canvas.draw(0,0,bm);
bm.free;
end;
procedure KeepBlue(src: Tbitmap; factor: extended);
var x,y,w,h:integer;
p0:pbytearray;
begin
src.PixelFormat :=pf24bit;
w:=src.width;
h:=src.height;
for y:=0 to h-1 do begin
p0:=src.scanline[y];
for x:=0 to w-1 do begin
p0[x*3]:=round(factor*p0[x*3]);
p0[x*3+1]:=0;
p0[x*3+2]:=0;
end;
end;
end;
procedure KeepGreen(src: Tbitmap; factor: extended);
var x,y,w,h:integer;
p0:pbytearray;
begin
src.PixelFormat :=pf24bit;
w:=src.width;
h:=src.height;
for y:=0 to h-1 do begin
p0:=src.scanline[y];
for x:=0 to w-1 do begin
p0[x*3+1]:=round(factor*p0[x*3+1]);
p0[x*3]:=0;
p0[x*3+2]:=0;
end;
end;
end;
procedure KeepRed(src: Tbitmap; factor: extended);
var x,y,w,h:integer;
p0:pbytearray;
begin
src.PixelFormat :=pf24bit;
w:=src.width;
h:=src.height;
for y:=0 to h-1 do begin
p0:=src.scanline[y];
for x:=0 to w-1 do begin
p0[x*3+2]:=round(factor*p0[x*3+2]);
p0[x*3+1]:=0;
p0[x*3]:=0;
end;
end;
end;
procedure Shake(src,dst: Tbitmap;factor:extended);
var x,y,h,w,dx:integer;
p:pbytearray;
begin
dst.canvas.draw(0,0,src);
dst.pixelformat:=pf24bit;
w:=dst.Width ;
h:=dst.height;
dx:=round(factor*w);
if dx=0 then exit;
if dx>(w div 2) then exit;
for y:=0 to h-1 do begin
p:=dst.scanline[y];
if (y mod 2)=0 then
for x:=dx to w-1 do begin
p[(x-dx)*3]:=p[x*3];
p[(x-dx)*3+1]:=p[x*3+1];
p[(x-dx)*3+2]:=p[x*3+2];
end
else
for x:=w-1 downto dx do begin
p[x*3]:=p[(x-dx)*3];
p[x*3+1]:=p[(x-dx)*3+1];
p[x*3+2]:=p[(x-dx)*3+2];
end;
end;
end;
procedure ShakeDown(src, dst: Tbitmap; factor: extended);
var x,y,h,w,dy:integer;
p,p2,p3:pbytearray;
begin
dst.canvas.draw(0,0,src);
dst.pixelformat:=pf24bit;
w:=dst.Width ;
h:=dst.height;
dy:=round(factor*h);
if dy=0 then exit;
if dy>(h div 2) then exit;
for y:=dy to h-1 do begin
p:=dst.scanline[y];
p2:=dst.scanline[y-dy];
for x:=0 to w-1 do
if (x mod 2)=0 then
begin
p2[x*3]:=p[x*3];
p2[x*3+1]:=p[x*3+1];
p2[x*3+2]:=p[x*3+2];
end;
end;
for y:=h-1-dy downto 0 do begin
p:=dst.scanline[y];
p3:=dst.scanline[y+dy];
for x:=0 to w-1 do
if (x mod 2)<>0 then
begin
p3[x*3]:=p[x*3];
p3[x*3+1]:=p[x*3+1];
p3[x*3+2]:=p[x*3+2];
end;
end;
end;
procedure Plasma(src1, src2, dst: Tbitmap; scale,turbulence: extended);
var
cval,sval:array[0..255] of integer;
i,x,y,w,h,xx,yy:integer;
Asin,Acos:extended;
ps1,ps2,pd:pbytearray;
begin
w:=src1.width;
h:=src1.height;
if turbulence<10 then turbulence:=10;
if scale<5 then scale:=5;
for i:=0 to 255 do begin
sincos(i/turbulence,Asin,Acos);
sval[i]:=round(-scale*Asin);
cval[i]:=round(scale*Acos);
end;
for y:=0 to h-1 do begin
pd:=dst.scanline[y];
ps2:=src2.scanline[y];
for x:=0 to w-1 do begin
xx:=x+sval[ps2[x*3]];
yy:=y+cval[ps2[x*3]];
if (xx>=0)and(xx<w)and (yy>=0)and(yy<h) then begin
ps1:=src1.scanline[yy];
pd[x*3]:=ps1[xx*3];
pd[x*3+1]:=ps1[xx*3+1];
pd[x*3+2]:=ps1[xx*3+2];
end;
end;
end;;
end;
procedure splitround(src,dst:tbitmap;amount:integer;style:TLightBrush);
var x,y,h,w,c,c00,dx,cx:integer;
R,R00:trect;
bm,bm2:tbitmap;
p0,p00,p1:pbytearray;
begin
if amount=0 then begin
dst.canvas.Draw (0,0,src);
exit;
end;
cx:=src.width div 2;
if amount>cx then
amount:=cx;
w:=src.width;
bm:=tbitmap.create;
bm.PixelFormat :=pf24bit;
bm.height:=1;
bm.width:=cx;
bm2:=tbitmap.create;
bm2.PixelFormat :=pf24bit;
bm2.height:=1;
bm2.width:=cx;
p0:=bm.scanline[0];
p00:=bm2.scanline[0];
for y:=0 to src.height-1 do begin
p1:=src.scanline[y];
for x:=0 to cx-1 do begin
c:=x*3;
c00:=(cx+x)*3;
p0[c]:=p1[c];
p0[c+1]:=p1[c+1];
p0[c+2]:=p1[c+2];
p00[c]:=p1[c00];
p00[c+1]:=p1[c00+1];
p00[c+2]:=p1[c00+2];
end;
case style of
mbsplitround: dx:=round(amount*abs(sin(y/(src.height-1)*pi)));
mbsplitwaste: dx:=round(amount*abs(cos(y/(src.height-1)*pi)));
end;
R:=rect(0,y,dx,y+1);
dst.Canvas.StretchDraw (R,bm);
R00:=rect(w-1-dx,y,w-1,y+1);
dst.Canvas.StretchDraw (R00,bm2);
end;
bm.free;
bm2.free;
end;
procedure Emboss(var Bmp:TBitmap);
var
x,y: Integer;
p1,p2: Pbytearray;
begin
for y:=0 to Bmp.Height-2 do
begin
p1:=bmp.scanline[y];
p2:=bmp.scanline[y+1];
for x:=0 to Bmp.Width-4 do
begin
p1[x*3]:=(p1[x*3]+(p2[(x+3)*3] xor $FF))shr 1;
p1[x*3+1]:=(p1[x*3+1]+(p2[(x+3)*3+1] xor $FF))shr 1;
p1[x*3+2]:=(p1[x*3+2]+(p2[(x+3)*3+2] xor $FF))shr 1;
end;
end;
end;
procedure filterred(src:tbitmap;min,max:integer);
var c,x,y:integer;
p1:pbytearray;
begin
for y:=0 to src.height-1 do begin
p1:=src.scanline[y];
for x:=0 to src.width-1 do begin
c:=x*3;
if (p1[c+2]>min) and (p1[c+2]<max) then p1[c+2]:=$FF
else p1[c+2]:=0;
p1[c]:=0;
p1[c+1]:=0;
end;
end;
end;
procedure filtergreen(src:tbitmap;min,max:integer);
var c,x,y:integer;
p1:pbytearray;
begin
for y:=0 to src.height-1 do begin
p1:=src.scanline[y];
for x:=0 to src.width-1 do begin
c:=x*3;
if (p1[c+1]>min) and (p1[c+1]<max) then p1[c+1]:=$FF
else p1[c+1]:=0;
p1[c]:=0;
p1[c+2]:=0;
end;
end;
end;
procedure filterblue(src:tbitmap;min,max:integer);
var c,x,y:integer;
p1:pbytearray;
begin
for y:=0 to src.height-1 do begin
p1:=src.scanline[y];
for x:=0 to src.width-1 do begin
c:=x*3;
if (p1[c]>min) and (p1[c]<max) then p1[c]:=$FF
else p1[c]:=0;
p1[c+1]:=0;
p1[c+2]:=0;
end;
end;
end;
procedure filterxred(src:tbitmap;min,max:integer);
var c,x,y:integer;
p1:pbytearray;
begin
for y:=0 to src.height-1 do begin
p1:=src.scanline[y];
for x:=0 to src.width-1 do begin
c:=x*3;
if (p1[c+2]>min) and (p1[c+2]<max) then p1[c+2]:=$FF
else p1[c+2]:=0;
end;
end;
end;
procedure filterxgreen(src:tbitmap;min,max:integer);
var c,x,y:integer;
p1:pbytearray;
begin
for y:=0 to src.height-1 do begin
p1:=src.scanline[y];
for x:=0 to src.width-1 do begin
c:=x*3;
if (p1[c+1]>min) and (p1[c+1]<max) then p1[c+1]:=$FF
else p1[c+1]:=0;
end;
end;
end;
procedure filterxblue(src:tbitmap;min,max:integer);
var c,x,y:integer;
p1:pbytearray;
begin
for y:=0 to src.height-1 do begin
p1:=src.scanline[y];
for x:=0 to src.width-1 do begin
c:=x*3;
if (p1[c]>min) and (p1[c]<max) then p1[c]:=$FF
else p1[c]:=0;
end;
end;
end;
//Just a small function to map the numbers to colors
function ConvertColor(Value:Integer):TColor;
begin
case Value of
0:Result := clBlack;
1:Result := clNavy;
2:Result := clGreen;
3:Result := clAqua;
4:Result := clRed;
5:Result := clPurple;
6:Result := clMaroon;
7:Result := clSilver;
8:Result := clGray;
9:Result := clBlue;
10:Result := clLime;
11:Result := clOlive;
12:Result := clFuchsia;
13:Result := clTeal;
14:Result := clYellow;
15:Result := clWhite;
else Result := clWhite;
end;
end;
procedure DrawMandelJulia(src:Tbitmap;x0,y0,x1,y1:extended;Niter:integer;Mandel:Boolean);
const
//Number if colors. If this is changed, the number of mapped colors must also be changed
nc=16;
type
TjvRGBTriplet= record
r,g,b:byte
end;
var
X,XX,Y,YY,Cx,Cy,Dx,Dy,XSquared,YSquared:Double;
Nx,Ny,Py,Px,I:Integer;
p0:pbytearray;
cc: array[0..15] of TjvRGBTriplet;
Acolor:Tcolor;
begin
src.PixelFormat :=pf24bit;
for i:=0 to 15 do begin
Acolor:=convertcolor(i);
cc[i].b:=GetBValue(colortoRGB(Acolor));
cc[i].g:=GetGValue(colortoRGB(Acolor));
cc[i].r:=GetRValue(colortoRGB(Acolor));
end;
if Niter<nc then Niter:=nc;
try
Nx := src.Width;
Ny := src.Height;
Cx := 0;
Cy := 1;
Dx := (x1 - x0) / nx;
Dy := (y1 - y0) / ny;
Py := 0;
while (PY < Ny) do begin
p0:=src.scanline[py];
PX := 0;
while (Px < Nx)do begin
x := x0 + px * dx;
y := y0 + py * dy;
if (mandel) then begin
cx := x;cy := y;
x := 0; y := 0;
end;
xsquared := 0;ysquared := 0;
I := 0;
while (I <= niter) and (xsquared + ysquared < (4)) do begin
xsquared := x*x;
ysquared := y*y;
xx := xsquared - ysquared + cx;
yy := (2*x*y) + cy;
x := xx ; y := yy;
I := I + 1;
end;
I := I - 1;
if (i = niter) then i := 0
else i := round(i / (niter / nc));
// Canvas.Pixels[PX,PY] := ConvertColor(I);
p0[px*3]:=cc[i].b;
p0[px*3+1]:=cc[i].g;
p0[px*3+2]:=cc[i].r;
Px := Px + 1;
end;
Py := Py + 1;
end;
finally
end;
end;
procedure Invert(src: tbitmap);
var w,h,x,y:integer;
p:pbytearray;
begin
w:=src.width;
h:=src.height;
src.PixelFormat :=pf24bit;
for y:=0 to h-1 do begin
p:=src.scanline[y];
for x:=0 to w-1 do begin
p[x*3]:= not p[x*3];
p[x*3+1]:= not p[x*3+1];
p[x*3+2]:= not p[x*3+2];
end;
end;
end;
procedure MirrorRight(src: Tbitmap);
var w,h,x,y:integer;
p:pbytearray;
begin
w:=src.width;
h:=src.height;
src.PixelFormat :=pf24bit;
for y:=0 to h-1 do begin
p:=src.scanline[y];
for x:=0 to w div 2 do begin
p[(w-1-x)*3]:= p[x*3];
p[(w-1-x)*3+1]:= p[x*3+1];
p[(w-1-x)*3+2]:= p[x*3+2];
end;
end;
end;
procedure MirrorDown(src: Tbitmap);
var w,h,x,y:integer;
p1,p2:pbytearray;
begin
w:=src.width;
h:=src.height;
src.PixelFormat :=pf24bit;
for y:=0 to h div 2 do begin
p1:=src.scanline[y];
p2:=src.scanline[h-1-y];
for x:=0 to w-1 do begin
p2[x*3]:= p1[x*3];
p2[x*3+1]:= p1[x*3+1];
p2[x*3+2]:= p1[x*3+2];
end;
end;
end;
// resample image as triangles
procedure Triangles(src: TBitmap; amount: integer);
type
Ttriplet=record
r,g,b:byte;
end;
var w,h,x,y,tb,tm,te:integer;
ps:pbytearray;
T:ttriplet;
begin
w:=src.width;
h:=src.height;
src.PixelFormat :=pf24bit;
if amount<5 then amount:=5;
amount:= (amount div 2)*2+1;
tm:=amount div 2;
for y:=0 to h-1 do begin
ps:=src.scanline[y];
t.r:=ps[0];
t.g:=ps[1];
t.b:=ps[2];
tb:=y mod (amount-1);
if tb>tm then tb:=2*tm-tb;
if tb=0 then tb:=amount;
te:=tm+abs(tm-(y mod amount));
for x:=0 to w-1 do begin
if (x mod tb)=0 then begin
t.r :=ps[x*3];
t.g:=ps[x*3+1];
t.b:=ps[x*3+2];
end;
if ((x mod te)=1)and(tb<>0) then begin
t.r :=ps[x*3];
t.g:=ps[x*3+1];
t.b:=ps[x*3+2];
end;
ps[x*3]:=t.r;
ps[x*3+1]:=t.g;
ps[x*3+2]:=t.b;
end;
end;
end;
procedure RippleTooth(src: TBitmap; amount: integer);
var
c,c2,x,y : integer;
P1,P2 : PByteArray;
b:byte;
begin
src.PixelFormat :=pf24bit;
amount:=min(src.height div 2, amount);
for y := src.height -1-amount downto 0 do begin
P1 := src.ScanLine[y];
b:=0;
for x:=0 to src.width-1 do begin
P2 := src.scanline[y+b];
P2[x*3]:=P1[x*3];
P2[x*3+1]:=P1[x*3+1];
P2[x*3+2]:=P1[x*3+2];
inc(b);
if b>amount then b:=0;
end;
end;
end;
procedure RippleTriangle(src: TBitmap; amount: integer);
var
c,c2,x,y : integer;
P1,P2 : PByteArray;
b:byte;
doinc:boolean;
begin
amount:=min(src.height div 2,amount);
for y := src.height -1-amount downto 0 do begin
P1 := src.ScanLine[y];
b:=0;
doinc:=true;
for x:=0 to src.width-1 do begin
P2 := src.scanline[y+b];
P2[x*3]:=P1[x*3];
P2[x*3+1]:=P1[x*3+1];
P2[x*3+2]:=P1[x*3+2];
if doinc then begin
inc(b);
if b>amount then begin
doinc:=false;
b:=amount-1;
end;
end
else begin
if b=0 then begin
doinc:=true;
b:=2;
end;
dec(b);
end;
end;
end;
end;
procedure RippleRandom(src: TBitmap; amount: integer);
var
c,c2,x,y : integer;
P1,P2 : PByteArray;
b:byte;
begin
amount:=min(src.height div 2,amount);
src.PixelFormat :=pf24bit;
randomize;
for y := src.height -1-amount downto 0 do begin
P1 := src.ScanLine[y];
b:=0;
for x:=0 to src.width-1 do begin
P2 := src.scanline[y+b];
P2[x*3]:=P1[x*3];
P2[x*3+1]:=P1[x*3+1];
P2[x*3+2]:=P1[x*3+2];
b:=random(amount);
end;
end;
end;
procedure TexturizeOverlap(src: TBitmap; amount: integer);
var w,h,x,y,xo:integer;
bm:tbitmap;
arect:trect;
begin
bm:=tbitmap.create;
amount:=min(src.width div 2,amount);
amount:=min(src.height div 2,amount);
xo:=round(amount * 2 / 3);
bm.width:=amount;
bm.height:=amount;
w:=src.width;
h:=src.height;
arect:=rect(0,0,amount,amount);
bm.Canvas.StretchDraw (arect,src);
y:=0;
repeat
x:=0;
repeat
src.canvas.Draw (x,y,bm);
x:=x+xo;
until x>=w;
y:=y+xo;
until y>=h;
bm.free;
end;
procedure TexturizeTile(src: TBitmap; amount: integer);
var w,h,x,y:integer;
bm:tbitmap;
arect:trect;
begin
bm:=tbitmap.create;
amount:=min(src.width div 2,amount);
amount:=min(src.height div 2,amount);
bm.width:=amount;
bm.height:=amount;
w:=src.width;
h:=src.height;
arect:=rect(0,0,amount,amount);
bm.Canvas.StretchDraw (arect,src);
y:=0;
repeat
x:=0;
repeat
src.canvas.Draw (x,y,bm);
x:=x+bm.width;
until x>=w;
y:=y+bm.height;
until y>=h;
bm.free;
end;
procedure HeightMap(src: Tbitmap; amount: integer);
var bm:tbitmap;
w,h,x,y:integer;
pb,ps:pbytearray;
c:integer;
begin
h:=src.height;
w:=src.width;
bm:=tbitmap.create;
bm.width:=w;
bm.height:=h;
bm.PixelFormat:=pf24bit;
src.PixelFormat :=pf24bit;
bm.Canvas.Draw (0,0,src);
for y:=0 to h-1 do begin
pb:=bm.ScanLine [y];
for x:=0 to w-1 do begin
c:=round((pb[x*3]+pb[x*3+1]+pb[x*3+2])/3/255*amount);
if (y-c)>=0 then begin
ps:=src.ScanLine [y-c];
ps[x*3]:=pb[x*3];
ps[x*3+1]:=pb[x*3+1];
ps[x*3+2]:=pb[x*3+2];
end;
end;
end;
bm.free;
end;
procedure turn(src, dst: tbitmap);
var w,h,x,y:integer;
ps,pd:pbytearray;
begin
h:=src.Height;
w:=src.width;
src.PixelFormat :=pf24bit;
dst.PixelFormat :=pf24bit;
dst.Height :=w;
dst.Width :=h;
for y:=0 to h-1 do begin
ps:=src.ScanLine [y];
for x:=0 to w-1 do begin
pd:=dst.ScanLine [w-1-x];
pd[y*3]:=ps[x*3];
pd[y*3+1]:=ps[x*3+1];
pd[y*3+2]:=ps[x*3+2];
end;
end;
end;
procedure turnRight(src, dst: Tbitmap);
var w,h,x,y:integer;
ps,pd:pbytearray;
begin
h:=src.Height;
w:=src.width;
src.PixelFormat :=pf24bit;
dst.PixelFormat :=pf24bit;
dst.Height :=w;
dst.Width :=h;
for y:=0 to h-1 do begin
ps:=src.ScanLine [y];
for x:=0 to w-1 do begin
pd:=dst.ScanLine [x];
pd[(h-1-y)*3]:=ps[x*3];
pd[(h-1-y)*3+1]:=ps[x*3+1];
pd[(h-1-y)*3+2]:=ps[x*3+2];
end;
end;
end;
procedure ExtractColor(src: TBitmap; Acolor: tcolor);
var w,h,x,y:integer;
p:pbytearray;
Ecolor:TColor;
r,g,b:byte;
begin
w:=src.width;
h:=src.height;
Ecolor:=colortorgb(Acolor);
r:=getRValue(Ecolor);
g:=getGValue(Ecolor);
b:=getBValue(Ecolor);
src.PixelFormat :=pf24bit;
for y:=0 to h-1 do begin
p:=src.ScanLine [y];
for x:=0 to w-1 do begin
if ((p[x*3]<>b) or (p[x*3+1]<>g) or (p[x*3+2]<>r)) then begin
p[x*3]:=$00;
p[x*3+1]:=$00;
p[x*3+2]:=$00;
end;
end
end;
src.transparent:=true;
src.TransparentColor :=clblack;
end;
procedure ExcludeColor(src: TBitmap; Acolor: tcolor);
var w,h,x,y:integer;
p:pbytearray;
Ecolor:TColor;
r,g,b:byte;
begin
w:=src.width;
h:=src.height;
Ecolor:=colortorgb(Acolor);
r:=getRValue(Ecolor);
g:=getGValue(Ecolor);
b:=getBValue(Ecolor);
src.PixelFormat :=pf24bit;
for y:=0 to h-1 do begin
p:=src.ScanLine [y];
for x:=0 to w-1 do begin
if ((p[x*3]=b) and (p[x*3+1]=g) and (p[x*3+2]=r)) then begin
p[x*3]:=$00;
p[x*3+1]:=$00;
p[x*3+2]:=$00;
end;
end
end;
src.transparent:=true;
src.TransparentColor :=clblack;
end;
procedure Blend(src1, src2, dst: tbitmap; amount: extended);
var w,h,x,y:integer;
ps1,ps2,pd:pbytearray;
begin
w:=src1.Width ;
h:=src1.Height;
dst.Width :=w;
dst.Height :=h;
src1.PixelFormat :=pf24bit;
src2.PixelFormat:=pf24bit;
dst.PixelFormat :=pf24bit;
for y:=0 to h-1 do begin
ps1:=src1.ScanLine [y];
ps2:=src2.ScanLine [y];
pd:=dst.ScanLine [y];
for x:=0 to w-1 do begin
pd[x*3]:=round((1-amount)*ps1[x*3]+amount*ps2[x*3]);
pd[x*3+1]:=round((1-amount)*ps1[x*3+1]+amount*ps2[x*3+1]);
pd[x*3+2]:=round((1-amount)*ps1[x*3+2]+amount*ps2[x*3+2]);
end;
end;
end;
procedure Solorize(src, dst: tbitmap; amount: integer);
var w,h,x,y:integer;
ps,pd:pbytearray;
c:integer;
begin
w:=src.width;
h:=src.height;
src.PixelFormat :=pf24bit;
dst.PixelFormat :=pf24bit;
for y:=0 to h-1 do begin
ps:=src.scanline[y];
pd:=dst.scanline[y];
for x:=0 to w-1 do begin
c:=(ps[x*3]+ps[x*3+1]+ps[x*3+2]) div 3;
if c>amount then begin
pd[x*3]:= 255-ps[x*3];
pd[x*3+1]:=255-ps[x*3+1];
pd[x*3+2]:=255-ps[x*3+2];
end
else begin
pd[x*3]:=ps[x*3];
pd[x*3+1]:=ps[x*3+1];
pd[x*3+2]:=ps[x*3+2];
end;
end;
end;
end;
procedure Posterize(src, dst: tbitmap; amount: integer);
var w,h,x,y:integer;
ps,pd:pbytearray;
c:integer;
begin
w:=src.width;
h:=src.height;
src.PixelFormat :=pf24bit;
dst.PixelFormat :=pf24bit;
for y:=0 to h-1 do begin
ps:=src.scanline[y];
pd:=dst.scanline[y];
for x:=0 to w-1 do begin
pd[x*3]:= round(ps[x*3]/amount)*amount;
pd[x*3+1]:=round(ps[x*3+1]/amount)*amount;
pd[x*3+2]:=round(ps[x*3+2]/amount)*amount;
end;
end;
end;
{This just forces a value to be 0 - 255 for rgb purposes. I used asm in an
attempt at speed, but I don't think it helps much.}
function Set255(Clr : integer) : integer;
asm
MOV EAX,Clr // store value in EAX register (32-bit register)
CMP EAX,254 // compare it to 254
JG @SETHI // if greater than 254 then go set to 255 (max value)
CMP EAX,1 // if less than 255, compare to 1
JL @SETLO // if less than 1 go set to 0 (min value)
RET // otherwise it doesn't change, just exit
@SETHI: // Set value to 255
MOV EAX,255 // Move 255 into the EAX register
RET // Exit (result value is the EAX register value)
@SETLO: // Set value to 0
MOV EAX,0 // Move 0 into EAX register
end; // Result is in EAX
{The Expand version of a 3 x 3 convolution.
This approach is similar to the mirror version, except that it copies
or duplicates the pixels from the edges to the same edge. This is
probably the best version if you're interested in quality, but don't need
a tiled (seamless) image. }
procedure ConvolveE(ray: array of integer; z: word;
aBmp: TBitmap);
var
O, T, C, B : pRGBArray; // Scanlines
x, y : integer;
tBufr : TBitmap; // temp bitmap for 'enlarged' image
begin
tBufr := TBitmap.Create;
tBufr.Width:=aBmp.Width+2; // Add a box around the outside...
tBufr.Height:=aBmp.Height+2;
tBufr.PixelFormat := pf24bit;
O := tBufr.ScanLine[0]; // Copy top corner pixels
T := aBmp.ScanLine[0];
O[0] := T[0]; // Left
O[tBufr.Width - 1] := T[aBmp.Width - 1]; // Right
// Copy top lines
tBufr.Canvas.CopyRect(RECT(1,0,tBufr.Width - 1,1),aBmp.Canvas,
RECT(0,0,aBmp.Width,1));
O := tBufr.ScanLine[tBufr.Height - 1]; // Copy bottom corner pixels
T := aBmp.ScanLine[aBmp.Height - 1];
O[0] := T[0];
O[tBufr.Width - 1] := T[aBmp.Width - 1];
// Copy bottoms
tBufr.Canvas.CopyRect(RECT(1,tBufr.Height-1,tBufr.Width - 1,tBufr.Height),
aBmp.Canvas,RECT(0,aBmp.Height-1,aBmp.Width,aBmp.Height));
// Copy rights
tBufr.Canvas.CopyRect(RECT(tBufr.Width-1,1,tBufr.Width,tBufr.Height-1),
aBmp.Canvas,RECT(aBmp.Width-1,0,aBmp.Width,aBmp.Height));
// Copy lefts
tBufr.Canvas.CopyRect(RECT(0,1,1,tBufr.Height-1),
aBmp.Canvas,RECT(0,0,1,aBmp.Height));
// Now copy main rectangle
tBufr.Canvas.CopyRect(RECT(1,1,tBufr.Width - 1,tBufr.Height - 1),
aBmp.Canvas,RECT(0,0,aBmp.Width,aBmp.Height));
// bmp now enlarged and copied, apply convolve
for x := 0 to aBmp.Height - 1 do begin // Walk scanlines
O := aBmp.ScanLine[x]; // New Target (Original)
T := tBufr.ScanLine[x]; //old x-1 (Top)
C := tBufr.ScanLine[x+1]; //old x (Center)
B := tBufr.ScanLine[x+2]; //old x+1 (Bottom)
// Now do the main piece
for y := 1 to (tBufr.Width - 2) do begin // Walk pixels
O[y-1].rgbtRed := Set255(
((T[y-1].rgbtRed*ray[0]) +
(T[y].rgbtRed*ray[1]) + (T[y+1].rgbtRed*ray[2]) +
(C[y-1].rgbtRed*ray[3]) +
(C[y].rgbtRed*ray[4]) + (C[y+1].rgbtRed*ray[5])+
(B[y-1].rgbtRed*ray[6]) +
(B[y].rgbtRed*ray[7]) + (B[y+1].rgbtRed*ray[8])) div z
);
O[y-1].rgbtBlue := Set255(
((T[y-1].rgbtBlue*ray[0]) +
(T[y].rgbtBlue*ray[1]) + (T[y+1].rgbtBlue*ray[2]) +
(C[y-1].rgbtBlue*ray[3]) +
(C[y].rgbtBlue*ray[4]) + (C[y+1].rgbtBlue*ray[5])+
(B[y-1].rgbtBlue*ray[6]) +
(B[y].rgbtBlue*ray[7]) + (B[y+1].rgbtBlue*ray[8])) div z
);
O[y-1].rgbtGreen := Set255(
((T[y-1].rgbtGreen*ray[0]) +
(T[y].rgbtGreen*ray[1]) + (T[y+1].rgbtGreen*ray[2]) +
(C[y-1].rgbtGreen*ray[3]) +
(C[y].rgbtGreen*ray[4]) + (C[y+1].rgbtGreen*ray[5])+
(B[y-1].rgbtGreen*ray[6]) +
(B[y].rgbtGreen*ray[7]) + (B[y+1].rgbtGreen*ray[8])) div z
);
end;
end;
tBufr.Free;
end;
{The Ignore (basic) version of a 3 x 3 convolution.
The 3 x 3 convolve uses the eight surrounding pixels as part of the
calculation. But, for the pixels on the edges, there is nothing to use
for the top row values. In other words, the leftmost pixel in the 3rd
row, or scanline, has no pixels on its left to use in the calculations.
This version just ignores the outermost edge of the image, and doesn't
alter those pixels at all. Repeated applications of filters will
eventually cause a pronounced 'border' effect, as those pixels never
change but all others do. However, this version is simpler, and the
logic is easier to follow. It's the fastest of the three in this
application, and works great if the 'borders' are not an issue. }
procedure ConvolveI(ray: array of integer; z: word;
aBmp: TBitmap);
var
O, T, C, B : pRGBArray; // Scanlines
x, y : integer;
tBufr : TBitmap; // temp bitmap
begin
tBufr := TBitmap.Create;
CopyMe(tBufr,aBmp);
for x := 1 to aBmp.Height - 2 do begin // Walk scanlines
O := aBmp.ScanLine[x]; // New Target (Original)
T := tBufr.ScanLine[x-1]; //old x-1 (Top)
C := tBufr.ScanLine[x]; //old x (Center)
B := tBufr.ScanLine[x+1]; //old x+1 (Bottom)
// Now do the main piece
for y := 1 to (tBufr.Width - 2) do begin // Walk pixels
O[y].rgbtRed := Set255(
((T[y-1].rgbtRed*ray[0]) +
(T[y].rgbtRed*ray[1]) + (T[y+1].rgbtRed*ray[2]) +
(C[y-1].rgbtRed*ray[3]) +
(C[y].rgbtRed*ray[4]) + (C[y+1].rgbtRed*ray[5])+
(B[y-1].rgbtRed*ray[6]) +
(B[y].rgbtRed*ray[7]) + (B[y+1].rgbtRed*ray[8])) div z
);
O[y].rgbtBlue := Set255(
((T[y-1].rgbtBlue*ray[0]) +
(T[y].rgbtBlue*ray[1]) + (T[y+1].rgbtBlue*ray[2]) +
(C[y-1].rgbtBlue*ray[3]) +
(C[y].rgbtBlue*ray[4]) + (C[y+1].rgbtBlue*ray[5])+
(B[y-1].rgbtBlue*ray[6]) +
(B[y].rgbtBlue*ray[7]) + (B[y+1].rgbtBlue*ray[8])) div z
);
O[y].rgbtGreen := Set255(
((T[y-1].rgbtGreen*ray[0]) +
(T[y].rgbtGreen*ray[1]) + (T[y+1].rgbtGreen*ray[2]) +
(C[y-1].rgbtGreen*ray[3]) +
(C[y].rgbtGreen*ray[4]) + (C[y+1].rgbtGreen*ray[5])+
(B[y-1].rgbtGreen*ray[6]) +
(B[y].rgbtGreen*ray[7]) + (B[y+1].rgbtGreen*ray[8])) div z
);
end;
end;
tBufr.Free;
end;
{The mirror version of a 3 x 3 convolution.
The 3 x 3 convolve uses the eight surrounding pixels as part of the
calculation. But, for the pixels on the edges, there is nothing to use
for the top row values. In other words, the leftmost pixel in the 3rd
row, or scanline, has no pixels on its left to use in the calculations.
I compensate for this by increasing the size of the bitmap by one pixel
on top, left, bottom, and right. The mirror version is used in an
application that creates seamless tiles, so I copy the opposite sides to
maintain the seamless integrity. }
procedure ConvolveM(ray: array of integer; z: word;
aBmp: TBitmap);
var
O, T, C, B : pRGBArray; // Scanlines
x, y : integer;
tBufr : TBitmap; // temp bitmap for 'enlarged' image
begin
tBufr := TBitmap.Create;
tBufr.Width:=aBmp.Width+2; // Add a box around the outside...
tBufr.Height:=aBmp.Height+2;
tBufr.PixelFormat := pf24bit;
O := tBufr.ScanLine[0]; // Copy top corner pixels
T := aBmp.ScanLine[0];
O[0] := T[0]; // Left
O[tBufr.Width - 1] := T[aBmp.Width - 1]; // Right
// Copy bottom line to our top - trying to remain seamless...
tBufr.Canvas.CopyRect(RECT(1,0,tBufr.Width - 1,1),aBmp.Canvas,
RECT(0,aBmp.Height - 1,aBmp.Width,aBmp.Height-2));
O := tBufr.ScanLine[tBufr.Height - 1]; // Copy bottom corner pixels
T := aBmp.ScanLine[aBmp.Height - 1];
O[0] := T[0];
O[tBufr.Width - 1] := T[aBmp.Width - 1];
// Copy top line to our bottom
tBufr.Canvas.CopyRect(RECT(1,tBufr.Height-1,tBufr.Width - 1,tBufr.Height),
aBmp.Canvas,RECT(0,0,aBmp.Width,1));
// Copy left to our right
tBufr.Canvas.CopyRect(RECT(tBufr.Width-1,1,tBufr.Width,tBufr.Height-1),
aBmp.Canvas,RECT(0,0,1,aBmp.Height));
// Copy right to our left
tBufr.Canvas.CopyRect(RECT(0,1,1,tBufr.Height-1),
aBmp.Canvas,RECT(aBmp.Width - 1,0,aBmp.Width,aBmp.Height));
// Now copy main rectangle
tBufr.Canvas.CopyRect(RECT(1,1,tBufr.Width - 1,tBufr.Height - 1),
aBmp.Canvas,RECT(0,0,aBmp.Width,aBmp.Height));
// bmp now enlarged and copied, apply convolve
for x := 0 to aBmp.Height - 1 do begin // Walk scanlines
O := aBmp.ScanLine[x]; // New Target (Original)
T := tBufr.ScanLine[x]; //old x-1 (Top)
C := tBufr.ScanLine[x+1]; //old x (Center)
B := tBufr.ScanLine[x+2]; //old x+1 (Bottom)
// Now do the main piece
for y := 1 to (tBufr.Width - 2) do begin // Walk pixels
O[y-1].rgbtRed := Set255(
((T[y-1].rgbtRed*ray[0]) +
(T[y].rgbtRed*ray[1]) + (T[y+1].rgbtRed*ray[2]) +
(C[y-1].rgbtRed*ray[3]) +
(C[y].rgbtRed*ray[4]) + (C[y+1].rgbtRed*ray[5])+
(B[y-1].rgbtRed*ray[6]) +
(B[y].rgbtRed*ray[7]) + (B[y+1].rgbtRed*ray[8])) div z
);
O[y-1].rgbtBlue := Set255(
((T[y-1].rgbtBlue*ray[0]) +
(T[y].rgbtBlue*ray[1]) + (T[y+1].rgbtBlue*ray[2]) +
(C[y-1].rgbtBlue*ray[3]) +
(C[y].rgbtBlue*ray[4]) + (C[y+1].rgbtBlue*ray[5])+
(B[y-1].rgbtBlue*ray[6]) +
(B[y].rgbtBlue*ray[7]) + (B[y+1].rgbtBlue*ray[8])) div z
);
O[y-1].rgbtGreen := Set255(
((T[y-1].rgbtGreen*ray[0]) +
(T[y].rgbtGreen*ray[1]) + (T[y+1].rgbtGreen*ray[2]) +
(C[y-1].rgbtGreen*ray[3]) +
(C[y].rgbtGreen*ray[4]) + (C[y+1].rgbtGreen*ray[5])+
(B[y-1].rgbtGreen*ray[6]) +
(B[y].rgbtGreen*ray[7]) + (B[y+1].rgbtGreen*ray[8])) div z
);
end;
end;
tBufr.Free;
end;
procedure Seamless(src: TBitmap;depth:byte);
var
p1,p2:pbytearray;
w,w3,h,i,x,x3,y:integer;
am,amount:extended;
begin
w:=src.width;
h:=src.height;
src.PixelFormat:=pf24bit;
if depth=0 then exit;
am:=1/depth;
for y:=0 to depth do
begin
p1:=src.ScanLine[y];
p2:=src.ScanLine[h-y-1];
amount:=1-y*am;
for x:=y to w-1-y do
begin
x3:=x*3;
p2[x3]:=round((1-amount)*p2[x3]+amount*p1[x3]);
p2[x3+1]:=round((1-amount)*p2[x3+1]+amount*p1[x3+1]);
p2[x3+2]:=round((1-amount)*p2[x3+2]+amount*p1[x3+2]);
end;
for x:=0 to y do
begin
amount:=1-x*am;
x3:=x*3;
w3:=(w-1-x)*3;
p1[w3]:=round((1-amount)*p1[w3]+amount*p1[x3]);
p1[w3+1]:=round((1-amount)*p1[w3+1]+amount*p1[x3+1]);
p1[w3+2]:=round((1-amount)*p1[w3+2]+amount*p1[x3+2]);
p2[w3]:=round((1-amount)*p2[w3]+amount*p2[x3]);
p2[w3+1]:=round((1-amount)*p2[w3+1]+amount*p2[x3+1]);
p2[w3+2]:=round((1-amount)*p2[w3+2]+amount*p2[x3+2]);
end;
end;
for y:=depth to h-1-depth do
begin
p1:=src.ScanLine[y];
for x:=0 to depth do
begin
x3:=x*3;
w3:=(w-1-x)*3;
amount:=1-x*am;
p1[w3]:=round((1-amount)*p1[w3]+amount*p1[x3]);
p1[w3+1]:=round((1-amount)*p1[w3+1]+amount*p1[x3+1]);
p1[w3+2]:=round((1-amount)*p1[w3+2]+amount*p1[x3+2]);
end;
end;
end;
procedure Buttonize(src: TBitmap;depth:byte;weight:integer);
var
p1,p2:pbytearray;
w,w3,h,i,x,x3,y:integer;
am,amount:extended;
a,r,g,b: Integer;
begin
a:=weight;
//
w:=src.width;
h:=src.height;
src.PixelFormat:=pf24bit;
if depth=0 then exit;
for y:=0 to depth do
begin
p1:=src.ScanLine[y];
p2:=src.ScanLine[h-y-1];
// amount:=1-y*am;
for x:=y to w-1-y do
begin
x3:=x*3;
// lighter
r:=p1[x3];
g:=p1[x3+1];
b:=p1[x3+2];
p1[x3]:=IntToByte(r+((255-r)*a)div 255);
p1[x3+1]:=IntToByte(g+((255-g)*a)div 255);
p1[x3+2]:=IntToByte(b+((255-b)*a)div 255);
// darker
r:=p2[x3];
g:=p2[x3+1];
b:=p2[x3+2];
p2[x3]:=IntToByte(r-((r)*a)div 255);
p2[x3+1]:=IntToByte(g-((g)*a)div 255);
p2[x3+2]:=IntToByte(b-((b)*a)div 255);
end;
for x:=0 to y do
begin
x3:=x*3;
w3:=(w-1-x)*3;
// lighter left
r:=p1[x3];
g:=p1[x3+1];
b:=p1[x3+2];
p1[x3]:=IntToByte(r+((255-r)*a)div 255);
p1[x3+1]:=IntToByte(g+((255-g)*a)div 255);
p1[x3+2]:=IntToByte(b+((255-b)*a)div 255);
// darker right
r:=p1[w3];
g:=p1[w3+1];
b:=p1[w3+2];
p1[w3]:=IntToByte(r-((r)*a)div 255);
p1[w3+1]:=IntToByte(g-((g)*a)div 255);
p1[w3+2]:=IntToByte(b-((b)*a)div 255);
// lighter bottom left
r:=p2[x3];
g:=p2[x3+1];
b:=p2[x3+2];
p2[x3]:=IntToByte(r+((255-r)*a)div 255);
p2[x3+1]:=IntToByte(g+((255-g)*a)div 255);
p2[x3+2]:=IntToByte(b+((255-b)*a)div 255);
// darker bottom right
r:=p2[w3];
g:=p2[w3+1];
b:=p2[w3+2];
p2[w3]:=IntToByte(r-((r)*a)div 255);
p2[w3+1]:=IntToByte(g-((g)*a)div 255);
p2[w3+2]:=IntToByte(b-((b)*a)div 255);
end;
end;
for y:=depth+1 to h-2-depth do
begin
p1:=src.ScanLine[y];
for x:=0 to depth do
begin
x3:=x*3;
w3:=(w-1-x)*3;
// lighter left
r:=p1[x3];
g:=p1[x3+1];
b:=p1[x3+2];
p1[x3]:=IntToByte(r+((255-r)*a)div 255);
p1[x3+1]:=IntToByte(g+((255-g)*a)div 255);
p1[x3+2]:=IntToByte(b+((255-b)*a)div 255);
// darker right
r:=p1[w3];
g:=p1[w3+1];
b:=p1[w3+2];
p1[w3]:=IntToByte(r-((r)*a)div 255);
p1[w3+1]:=IntToByte(g-((g)*a)div 255);
p1[w3+2]:=IntToByte(b-((b)*a)div 255);
end;
end;
end;
procedure ConvolveFilter(filternr,edgenr:integer;src:TBitmap);
var
z : integer;
ray : array [0..8] of integer;
OrigBMP : TBitmap; // Bitmap for temporary use
begin
z := 1; // just to avoid compiler warnings!
case filternr of
0 : begin // Laplace
ray[0] := -1; ray[1] := -1; ray[2] := -1;
ray[3] := -1; ray[4] := 8; ray[5] := -1;
ray[6] := -1; ray[7] := -1; ray[8] := -1;
z := 1;
end;
1 : begin // Hipass
ray[0] := -1; ray[1] := -1; ray[2] := -1;
ray[3] := -1; ray[4] := 9; ray[5] := -1;
ray[6] := -1; ray[7] := -1; ray[8] := -1;
z := 1;
end;
2 : begin // Find Edges (top down)
ray[0] := 1; ray[1] := 1; ray[2] := 1;
ray[3] := 1; ray[4] := -2; ray[5] := 1;
ray[6] := -1; ray[7] := -1; ray[8] := -1;
z := 1;
end;
3 : begin // Sharpen
ray[0] := -1; ray[1] := -1; ray[2] := -1;
ray[3] := -1; ray[4] := 16; ray[5] := -1;
ray[6] := -1; ray[7] := -1; ray[8] := -1;
z := 8;
end;
4 : begin // Edge Enhance
ray[0] := 0; ray[1] := -1; ray[2] := 0;
ray[3] := -1; ray[4] := 5; ray[5] := -1;
ray[6] := 0; ray[7] := -1; ray[8] := 0;
z := 1;
end;
5 : begin // Color Emboss (Sorta)
ray[0] := 1; ray[1] := 0; ray[2] := 1;
ray[3] := 0; ray[4] := 0; ray[5] := 0;
ray[6] := 1; ray[7] := 0; ray[8] := -2;
z := 1;
end;
6 : begin // Soften
ray[0] := 2; ray[1] := 2; ray[2] := 2;
ray[3] := 2; ray[4] := 0; ray[5] := 2;
ray[6] := 2; ray[7] := 2; ray[8] := 2;
z := 16;
end;
7 : begin // Blur
ray[0] := 3; ray[1] := 3; ray[2] := 3;
ray[3] := 3; ray[4] := 8; ray[5] := 3;
ray[6] := 3; ray[7] := 3; ray[8] := 3;
z := 32;
end;
8 : begin // Soften less
ray[0] := 0; ray[1] := 1; ray[2] := 0;
ray[3] := 1; ray[4] := 2; ray[5] := 1;
ray[6] := 0; ray[7] := 1; ray[8] := 0;
z := 6;
end;
else exit;
end;
OrigBMP := TBitmap.Create; // Copy image to 24-bit bitmap
CopyMe(OrigBMP,src);
case Edgenr of
0 : ConvolveM(ray,z,OrigBMP);
1 : ConvolveE(ray,z,OrigBMP);
2 : ConvolveI(ray,z,OrigBMP);
end;
src.Assign(OrigBMP); // Assign filtered image to Image1
OrigBMP.Free;
end;
procedure CopyMe(tobmp: TBitmap; frbmp : TGraphic);
begin
tobmp.Width := frbmp.Width;
tobmp.Height := frbmp.Height;
tobmp.PixelFormat := pf24bit;
tobmp.Canvas.Draw(0,0,frbmp);
end;
procedure ButtonizeOval(src: TBitmap; depth: byte;
weight: integer;rim:string);
var
p0,p1,p2,p3:pbytearray;
w,w3,h,i,x,x3,y,w2,h2:integer;
am,amount:extended;
fac,a,r,g,b,r2,g2,b2: Integer;
contour:Tbitmap;
biclight,bicdark,bicnone:byte;
act:boolean;
begin
a:=weight;
w:=src.width;
h:=src.height;
contour:=Tbitmap.create;
contour.width:=w;
contour.height:=h;
contour.PixelFormat:=pf24bit;
contour.Canvas.brush.color:=clwhite;
contour.canvas.FillRect(Rect(0,0,w,h));
with contour.canvas do begin
pen.Width:=1;
pen.style:=pssolid;
for i:=0 to depth-1 do begin
if rim='rimmed' then begin
// (bottom-right)
pen.color:=rgb($00,$02,i);
Arc (i, i, w-i, h-i, // ellipse
0, h, // start
w, 0); // end
// (top-left)
Pen.Color := rgb($00,$01,i);
Arc (i, i, w-i, h-i, // ellipse
w, 0, // start
0, h); // end
end
else if (rim='round') or (rim='doubleround') then begin
// (bottom-right)
pen.color:=rgb($00,$01,depth-1-i);
Arc (i, i, w-i, h-i, // ellipse
0, h, // start
w, 0); // end
// (top-left)
Pen.Color := rgb($00,$02,depth-1-i);
Arc (i, i, w-i, h-i, // ellipse
w, 0, // start
0, h); // end
end;
end;
if rim='doubleround' then
for i:=depth to depth-1+depth do begin
// (bottom-right)
pen.color:=rgb($00,$02,i);
Arc (i, i, w-i, h-i, // ellipse
0, h, // start
w, 0); // end
// (top-left)
Pen.Color := rgb($00,$01,i);
Arc (i, i, w-i, h-i, // ellipse
w, 0, // start
0, h); // end
end;
end;
src.PixelFormat:=pf24bit;
for y:=0 to h-1 do
begin
p1:=src.ScanLine[y];
p2:=contour.scanline[y];
for x:=0 to w-1 do begin
x3:=x*3;
r:=p1[x3];
g:=p1[x3+1];
b:=p1[x3+2];
r2:=p2[x3];
g2:=p2[x3+1];
b2:=p2[x3+2];
fac:=trunc(r2/depth*a);
if g2=$02 then begin // lighter
p1[x3]:=IntToByte(r+((255-r)*fac)div 255);
p1[x3+1]:=IntToByte(g+((255-g)*fac)div 255);
p1[x3+2]:=IntToByte(b+((255-b)*fac)div 255);
end
else if g2=$01 then begin // darker
p1[x3]:=IntToByte(r-((r)*fac)div 255);
p1[x3+1]:=IntToByte(g-((g)*fac)div 255);
p1[x3+2]:=IntToByte(b-((b)*fac)div 255);
end;
end;
end;
// anti alias
for y:=1 to h-2 do begin
p0:=src.ScanLine [y-1];
p1:=src.scanline [y];
p2:=src.ScanLine [y+1];
p3:=contour.scanline[y];
for x:=1 to w-2 do begin
g2:=p3[x*3+1];
if g2<>$00 then begin
p1[x*3]:=(p0[x*3]+p2[x*3]+p1[(x-1)*3]+p1[(x+1)*3])div 4;
p1[x3+1]:=(p0[x*3+1]+p2[x*3+1]+p1[(x-1)*3+1]+p1[(x+1)*3+1])div 4;
p1[x*3+2]:=(p0[x*3+2]+p2[x*3+2]+p1[(x-1)*3+2]+p1[(x+1)*3+2])div 4;
end;
end;
end;
contour.free;
end;
procedure MaskOval(src: TBitmap;acolor:TColor);
var
p0,p1,p2,p3:pbytearray;
w,w3,h,i,x,x3,y,w2,h2:integer;
fac,a,r,g,b,r2,g2,b2: Integer;
mr,mg,mb:byte;
contour:Tbitmap;
begin
acolor:= colortorgb(acolor);
mr:=getRvalue(acolor);
mg:=getGvalue(acolor);
mb:=getBvalue(acolor);
w:=src.width;
h:=src.height;
contour:=Tbitmap.create;
contour.width:=w;
contour.height:=h;
contour.PixelFormat:=pf24bit;
contour.Canvas.brush.color:=clblack;
contour.canvas.FillRect(Rect(0,0,w,h));
contour.canvas.pen.color:=clred;
contour.canvas.brush.color:=clred;
contour.canvas.Ellipse(0,0,w,h);
src.PixelFormat:=pf24bit;
for y:=0 to h-1 do
begin
p1:=src.ScanLine[y];
p2:=contour.scanline[y];
for x:=0 to w-1 do begin
x3:=x*3;
r:=p1[x3];
g:=p1[x3+1];
b:=p1[x3+2];
r2:=p2[x3];
g2:=p2[x3+1];
b2:=p2[x3+2];
if b2=$00 then begin // mask
p1[x3]:=mb;
p1[x3+1]:=mg;
p1[x3+2]:=mr;
end;
end;
end;
contour.free;
end;
end.
|
unit unFileMapping;
{
Copyright (c) 2005-2006 by Davy Landman
See the file COPYING.FPC, included in this distribution,
for details about the copyright. Alternately, you may use this source under the provisions of MPL v1.x or later
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
}
interface
uses
Windows, SysUtils;
type
TMappedFile = class
private
FMapping: THandle;
FContent: Pointer;
FSize: Integer;
procedure MapFile(const AFileName: WideString);
public
constructor Create(const AFileName: WideString);
destructor Destroy; override;
property Content: Pointer read FContent;
property Size: Integer read FSize;
end;
implementation
function FileExistsLongFileNames(const FileName: WideString): Boolean;
begin
if Length(FileName) < 2 then
begin
Result := False;
Exit;
end;
if CompareMem(@FileName[1], @WideString('\\')[1], 2) then
Result := (GetFileAttributesW(PWideChar(FileName)) and FILE_ATTRIBUTE_DIRECTORY = 0)
else
Result := (GetFileAttributesW(PWideChar(WideString('\\?\' + FileName))) and FILE_ATTRIBUTE_DIRECTORY = 0)
end;
{ TMappedFile }
constructor TMappedFile.Create(const AFileName: WideString);
begin
inherited Create;
if FileExistsLongFileNames(AFileName) then
MapFile(AFileName)
else
raise Exception.Create('File "' + AFileName + '" does not exists.');
end;
destructor TMappedFile.Destroy;
begin
if Assigned(FContent) then
begin
UnmapViewOfFile(FContent);
CloseHandle(FMapping);
end;
inherited;
end;
procedure TMappedFile.MapFile(const AFileName: WideString);
var
FileHandle: THandle;
begin
if CompareMem(@(AFileName[1]), @('\\'[1]), 2) then
{ Allready an UNC path }
FileHandle := CreateFileW(PWideChar(AFileName), GENERIC_READ, FILE_SHARE_READ or
FILE_SHARE_WRITE, nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)
else
FileHandle := CreateFileW(PWideChar(WideString('\\?\' + AFileName)), GENERIC_READ, FILE_SHARE_READ or
FILE_SHARE_WRITE, nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if FileHandle <> 0 then
try
FSize := GetFileSize(FileHandle, nil);
if FSize <> 0 then
begin
FMapping := CreateFileMappingW(FileHandle, nil, PAGE_READONLY, 0, 0, nil);
//Win32Check(FMapping <> 0);
end;
finally
CloseHandle(FileHandle);
end;
if FSize = 0 then
FContent := nil
else
FContent := MapViewOfFile(FMapping, FILE_MAP_READ, 0, 0, 0);
//Win32Check(FContent <> nil);
end;
end.
|
unit pSHIntf;
interface
uses Classes;
type
TtkTokenKind = (tkComment, tkDatatype, tkDefaultPackage, tkException,
tkFunction, tkIdentifier, tkKey, tkNull, tkNumber, tkSpace, tkPLSQL,
tkSQLPlus, tkString, tkSymbol, tkTableName, tkUnknown, tkVariable,
tkCustomStrings); //pavel
TRangeState = (rsUnknown, rsComment, rsString);
TProcTableProc = procedure of object;
TEnumerateKeywordsProc = procedure(AKind: integer; KeywordList: string) of object;
TSQLDialect = (sqlStandard, sqlInterbase, sqlMSSQL, sqlMySQL, sqlOracle,
sqlSybase, sqlIngres, sqlMSSQL2K);
TSQLSubDialect = integer;
TpSHHyperLinkRule = (hlrSingleClick, hlrCtrlClick, hlrDblClick);
TpSHCaseCode = (ccLower, ccUpper, ccNameCase, ccFirstUpper, ccNone,
ccInvert, ccToggle);
TpSHNeedObjectType = (ntAll, ntDomain, ntTable, ntView, ntProcedure, ntTrigger,
ntGenerator, ntException, ntFunction, ntFilter, ntRole, ntKeyWords,
ntDataTypes, ntBuildInFunctions, ntField, ntVariable, ntCustomStrings,
ntTableOrViewOrProcedure,ntTableOrView,ntFieldOrFunction,
ntFieldOrVariableOrFunction, ntExecutable, ntReturningValues,ntDeclareVariables
);
TpSHNeedObjectTypes = Set of TpSHNeedObjectType;
(*const
//InterBase subdialects {1..20}
ibdInterBase4 = 1;
ibdInterBase5 = 2;
ibdInterBase6 = 3;
ibdInterBase65 = 4;
ibdInterBase7 = 5;
ibdInterBase75 = 6;
ibdFirebird1 = 7;
ibdFirebird15 = 8;
ibdFirebird20 = 9;
*)
const
ibdInterBase6 = 3; // Ключевой диалект для хайлайтера
//MySQL subdialects {21..40}
//Sybase dialects {41..60}
//Oracle dialects {61..80}
type
IpSHSynEditManager = interface
['{A07C3B09-3992-449A-8B8E-C7ACA6CECD2A}']
end;
//Предоставляет список объектов для подсветки
IpSHObjectNamesManager = interface
['{89E0C14D-3871-4CBC-BAEA-8CFC0CCAD047}']
{Highlighter methods group}
//MayBe - начало слова
//Position - положение слова от начала строки
function GetObjectNamesRetriever: IInterface;
procedure SetObjectNamesRetriever(const Value: IInterface);
function GetHighlighter: TComponent;
function GetCompletionProposal: TComponent;
function GetParametersHint: TComponent;
function GetCaseCode: TpSHCaseCode;
procedure SetCaseCode(const Value: TpSHCaseCode);
function GetCaseSQLCode: TpSHCaseCode;
procedure SetCaseSQLCode(const Value: TpSHCaseCode);
procedure LinkSearchNotify(Sender: TObject; MayBe: PChar;
Position, Len: Integer; var TokenKind: TtkTokenKind);
{Completion proposal methods group}
procedure ExecuteNotify(Kind: Integer; Sender: TObject;
var CurrentInput: string; var x, y: Integer; var CanExecute: Boolean);
{Editor methods group}
procedure FindDeclaration(const AObjectName: string);
//Для обслуживания ситуаций с квотированием и регистрозависимостью
function IsIdentifiresEqual(Sender: TObject;
AIdentifire1, AIdentifire2: string): Boolean;
property ObjectNamesRetriever: IInterface read GetObjectNamesRetriever
write SetObjectNamesRetriever;
property Highlighter: TComponent read GetHighlighter;
property CompletionProposal: TComponent read GetCompletionProposal;
property ParametersHint: TComponent read GetParametersHint;
property CaseCode: TpSHCaseCode read GetCaseCode write SetCaseCode;
property CaseSQLCode: TpSHCaseCode read GetCaseSQLCode write SetCaseSQLCode;
end;
//Предоставляет список ключевых слов в соответствии с выбранным
//SQL диалектом и версией сервера
IpSHKeywordsManager = interface
['{2A052CA8-BBFD-4BFE-9715-B132EF9E04EF}']
procedure InitializeKeywordLists(Sender: TObject; SubDialect: TSQLSubDialect;
EnumerateKeywordsProc: TEnumerateKeywordsProc);
procedure ChangeSubSQLDialectTo(ASubSQLDialect: TSQLSubDialect);
procedure AddHighlighter(AHighlighter: TComponent);
procedure RemoveHighlighter(AHighlighter: TComponent);
function IsKeyword(AWord: string): Boolean;
end;
// IpSHExecutableCommandManager = interface
// ['{E17B4562-BC64-4201-862E-5FB950F97167}']
// procedure RunQuery(const AText: string);
// procedure PrepareQuery(const AText: string);
// end;
IpSHUserInputHistory = interface
['{A49E5F9A-1FB4-4D58-8C76-385512DB7974}']
function GetFindHistory: TStrings;
function GetReplaceHistory: TStrings;
function GetGotoLineNumberHistory: TStrings;
function GetPromtOnReplace: Boolean;
procedure SetPromtOnReplace(const Value: Boolean);
procedure AddToFindHistory(const AString: string);
procedure AddToReplaceHistory(const AString: string);
procedure AddToGotoLineNumberHistory(const AString: string);
property FindHistory: TStrings read GetFindHistory;
property ReplaceHistory: TStrings read GetReplaceHistory;
property GotoLineNumberHistory: TStrings
read GetGotoLineNumberHistory;
property PromtOnReplace: Boolean read GetPromtOnReplace
write SetPromtOnReplace;
end;
IpSHAutoComplete = interface
['{3919CBDD-C590-4D04-B5E2-C64DBEC5B5DB}']
function GetAutoComplete: TComponent;
end;
IpSHFieldListRetriever = interface
['{5F9F29D9-5F55-496B-97B3-D616DE6C81A1}']
function GetDatabase: IInterface;
procedure SetDatabase(const Value: IInterface);
function GetFieldList(const AObjectName: string; AList: TStrings): Boolean;
property Database: IInterface read GetDatabase write SetDatabase;
end;
IpSHCompletionProposalOptions = interface
['{223F197A-4E6C-40C0-8988-F78F8FE78F81}']
function GetEnabled: Boolean;
procedure SetEnabled(const Value: Boolean);
function GetExtended: Boolean;
procedure SetExtended(const Value: Boolean);
// function GetCodeParametersEnabled: Boolean;
// procedure SetCodeParametersEnabled(const Value: Boolean);
function GetLinesCount: Integer;
procedure SetLinesCount(const Value: Integer);
function GetWidth: Integer;
procedure SetWidth(const Value: Integer);
property Enabled: Boolean read GetEnabled
write SetEnabled;
property Extended: Boolean read GetExtended
write SetExtended;
// property CodeParametersEnabled: Boolean read GetCodeParametersEnabled
// write SetCodeParametersEnabled;
property LinesCount: Integer read GetLinesCount
write SetLinesCount;
property Width: Integer read GetWidth
write SetWidth;
end;
IpSHProposalHintRetriever = interface
['{D8F5951E-FA0B-41D1-B370-6A9645AE4C12}']
procedure AfterCompile(Sender: TObject);
function GetHint(const AObjectName: string; var AHint: string;
IsReturningValuesSection: Boolean): Boolean;
end;
implementation
end.
|
unit TpImageList;
interface
uses
SysUtils, Classes, Graphics,
dcfdes, dcsystem, dcdsgnstuff,
Dialogs, ImgList, ThImageList;
type
TTpImageList = class(TThImageList)
protected
procedure SetImageHeight(const Value: Integer);
procedure SetImageWidth(const Value: Integer);
function GetImageHeight: Integer;
function GetImageWidth: Integer;
public
constructor Create(inOwner: TComponent); override;
procedure DumpImages(const inFolder: string);
function GetImageName(inIndex: Integer): string;
function GetImageUrl(inIndex: Integer): string; override;
published
property ImageHeight: Integer read GetImageHeight write SetImageHeight;
property ImageWidth: Integer read GetImageWidth write SetImageWidth;
end;
//
TTpImageListPropertyEditor = class(TStringProperty)
public
function GetAttributes: TPropertyAttributes; override;
procedure Edit; override;
end;
procedure RegisterImageListPropertyEditor;
const
cTpAutoImageFolder = 'auto_images/';
implementation
uses
DcimgEd;
procedure RegisterImageListPropertyEditor;
begin
RegisterPropertyEditor(TypeInfo(TCustomImageList), TTpImageList,
'ImageList', TTpImageListPropertyEditor);
end;
{ TTpImageList }
constructor TTpImageList.Create(inOwner: TComponent);
begin
inherited;
end;
function TTpImageList.GetImageHeight: Integer;
begin
Result := ImageList.Height;
end;
function TTpImageList.GetImageWidth: Integer;
begin
Result := ImageList.Width;
end;
procedure TTpImageList.SetImageHeight(const Value: Integer);
begin
ImageList.Height := Value;
end;
procedure TTpImageList.SetImageWidth(const Value: Integer);
begin
ImageList.Width := Value;
end;
function TTpImageList.GetImageName(inIndex: Integer): string;
begin
Result := Format('%s_%.3d.bmp', [ Name, inIndex ]);
end;
function TTpImageList.GetImageUrl(inIndex: Integer): string;
begin
Result := cTpAutoImageFolder + GetImageName(inIndex);
end;
procedure TTpImageList.DumpImages(const inFolder: string);
var
i: Integer;
begin
for i := 0 to Pred(ImageList.Count) do
begin
with GetJpegStream(i) do
try
SaveToFile(inFolder + GetImageName(i));
finally
Free;
end;
end;
end;
{
function TThImageList.GetJpegStream(inIndex: Integer): TStream;
var
b: TBitmap;
begin
Result := TMemoryStream.Create;
b := TBitmap.Create;
try
ImageList.GetBitmap(inIndex, b);
ThBitmapToJpgStream(b, Result);
finally
b.Free;
end;
end;
}
{ TTpImageListPropertyEditor }
function TTpImageListPropertyEditor.GetAttributes: TPropertyAttributes;
begin
Result := [ paDialog ];
end;
procedure TTpImageListPropertyEditor.Edit;
var
s: Integer;
begin
s := 0;
EditCustomImageList(TCustomImageList(GetOrdValue), s);
end;
end.
|
unit ExpressionBase;
interface
uses
System.SysUtils,
System.Classes,
Vcl.StdCtrls,
Parse.Easy.Lexer.CustomLexer,
Parse.Easy.Parser.LR1;
type
TExpressionBase = class(TLR1)
private
FVars: TList;
FConsole: TMemo;
FStringReference: TList;
protected
function HexToFloat(const S: string): Double;
function FindVar(const Name: string): Pointer;
function GetVarValue(const Name: string): Double;
function RegisterVar(const Name: string): Pointer;
function SQString(const Str: string): PChar;
function DQString(const Str: string): PChar;
procedure DoClear();
function DoMin(List: TList): Double;
function DoMax(List: TList): Double;
procedure DoEcho(Text: PChar);
procedure InternalClean();
procedure DoAssignment(IsNew: Boolean; Name: string; Expression: Double);
public
constructor Create(ALexer: TCustomLexer); override;
destructor Destroy(); override;
property Console: TMemo read FConsole write FConsole;
end;
implementation
{ TExpressionBase }
type
TVariable = record
Name: string;
Value: Double;
end;
PVariable = ^TVariable;
constructor TExpressionBase.Create(ALexer: TCustomLexer);
begin
inherited;
FVars := TList.Create();
FStringReference := TList.Create();
end;
destructor TExpressionBase.Destroy();
begin
InternalClean();
FVars.Free();
FStringReference.Free();
inherited;
end;
procedure TExpressionBase.DoAssignment(IsNew: Boolean; Name: string; Expression: Double);
var
Variable: PVariable;
begin
if (IsNew) then
Variable := RegisterVar(Name)
else
Variable := FindVar(Name);
if not Assigned(Variable) then
raise Exception.Create('Error Message');
Variable^.Value := Expression;
end;
procedure TExpressionBase.DoClear;
begin
Console.Clear();
end;
procedure TExpressionBase.DoEcho(Text: PChar);
var
S: string;
begin
S := string(Text);
Console.Lines.Add(S);
end;
function TExpressionBase.DoMax(List: TList): Double;
var
I: Integer;
Value: Double;
begin
for I := 0 to List.Count - 1 do
begin
Value := PDouble(List[I])^;
if I = 0 then
begin
Result := Value;
Continue;
end;
if Value > Result then
Result := Value;
end;
end;
function TExpressionBase.DoMin(List: TList): Double;
var
I: Integer;
Value: Double;
begin
for I := 0 to List.Count - 1 do
begin
Value := PDouble(List[I])^;
if I = 0 then
begin
Result := Value;
Continue;
end;
if Value < Result then
Result := Value;
end;
end;
function TExpressionBase.FindVar(const Name: string): Pointer;
var
I: Integer;
Variable: PVariable;
begin
for I := 0 to FVars.Count - 1 do
begin
Variable := FVars[I];
if (Assigned(Variable)) then
begin
if (SameText(Variable^.Name, Name)) then
exit(Variable);
end;
end;
Result := nil;
end;
function TExpressionBase.GetVarValue(const Name: string): Double;
var
Variable: PVariable;
begin
Variable := FindVar(Name);
if not Assigned(Variable) then
raise Exception.Create('Error Message');
Result := Variable^.Value;
end;
function TExpressionBase.HexToFloat(const S: string): Double;
var
Value: Integer;
begin
S.Replace('0x', '$');
Value := StrToInt(S);
Result := Value;
end;
procedure TExpressionBase.InternalClean();
var
I: Integer;
P: Pointer;
begin
for I := 0 to FVars.Count - 1 do
begin
P := FVars[I];
if Assigned(P) then
begin
FinalizeRecord(P, TypeInfo(TVariable));
FreeMem(P);
end;
end;
FVars.Clear();
for I := 0 to FStringReference.Count - 1 do
begin
P := FStringReference[I];
if Assigned(P) then
FreeMem(P);
end;
FStringReference.Clear();
end;
function TExpressionBase.RegisterVar(const Name: string): Pointer;
var
Variable: PVariable;
begin
Variable := FindVar(Name);
if Assigned(Variable) then
raise Exception.Create('Error Message');
GetMem(Variable, SizeOf(TVariable));
FillChar(Variable^, SizeOf(TVariable), 0);
Variable^.Name := Name;
FVars.Add(Variable);
Result := Variable;
end;
function TExpressionBase.SQString(const Str: string): PChar;
var
I: Integer;
n: Integer;
C: Char;
S: string;
P: PChar;
begin
S := '';
I := 1;
n := Length(Str);
while (True) do
begin
Inc(I);
C := Str[I];
if (C = '''') then
begin
if I < n then
begin
C := Str[I + 1];
if (C = '''') then
begin
S := S + C;
Inc(I);
Continue;
end;
end;
Break;
end;
S := S + C;
end;
GetMem(Result, (Length(S) + 1) * 2);
P := Result;
FStringReference.Add(Result);
for I := 1 to S.Length do
begin
P^ := S[I];
Inc(P);
end;
P^ := #0000;
end;
function TExpressionBase.DQString(const Str: string): PChar;
function IsSeparator(C: Char): Boolean;
var
CP: Integer;
begin
Result := False;
CP := Ord(C);
case CP of
0 .. 64, 91 .. 96, 123 .. 169, 171 .. 180, 182 .. 185, 187 .. 191, 215, 247,
706 .. 709, 722 .. 735, 741 .. 747, 749, 751 .. 879, 885, 888 .. 889, 894,
896 .. 901, 903, 907, 909, 930, 1014, 1154 .. 1161, 1328, 1367 .. 1368,
1370 .. 1376, 1416 .. 1487, 1515 .. 1519, 1523 .. 1567, 1611 .. 1645, 1648,
1748, 1750 .. 1764, 1767 .. 1773, 1776 .. 1785, 1789 .. 1790, 1792 .. 1807,
1809, 1840 .. 1868, 1958 .. 1968, 1970 .. 1993, 2027 .. 2035, 2038 .. 2041,
2043 .. 2047, 2070 .. 2073, 2075 .. 2083, 2085 .. 2087, 2089 .. 2111, 2137 .. 2207,
2229, 2238 .. 2307, 2362 .. 2364, 2366 .. 2383, 2385 .. 2391, 2402 .. 2416,
2433 .. 2436, 2445 .. 2446, 2449 .. 2450, 2473, 2481, 2483 .. 2485, 2490 .. 2492, 2494 .. 2509,
2511 .. 2523, 2526, 2530 .. 2543, 2546 .. 2564, 2571 .. 2574, 2577 .. 2578, 2601, 2609, 2612, 2615, 2618 .. 2648, 2653, 2655 .. 2673, 2677 .. 2692, 2702,
2706, 2729, 2737, 2740, 2746 .. 2748, 2750 .. 2767, 2769 .. 2783, 2786 .. 2808, 2810 .. 2820, 2829 .. 2830, 2833 .. 2834, 2857, 2865, 2868, 2874 .. 2876,
2878 .. 2907, 2910, 2914 .. 2928, 2930 .. 2946, 2948, 2955 .. 2957, 2961, 2966 .. 2968, 2971, 2973, 2976 .. 2978, 2981 .. 2983, 2987 .. 2989,
3002 .. 3023, 3025 .. 3076, 3085, 3089, 3113, 3130 .. 3132, 3134 .. 3159, 3163 .. 3167, 3170 .. 3199, 3201 .. 3204, 3213, 3217, 3241, 3252, 3258 .. 3260,
3262 .. 3293, 3295, 3298 .. 3312, 3315 .. 3332, 3341, 3345, 3387 .. 3388, 3390 .. 3405, 3407 .. 3411, 3415 .. 3422, 3426 .. 3449, 3456 .. 3460,
3479 .. 3481, 3506, 3516, 3518 .. 3519, 3527 .. 3584, 3633, 3636 .. 3647, 3655 .. 3712, 3715, 3717 .. 3718, 3721, 3723 .. 3724, 3726 .. 3731, 3736, 3744,
3748, 3750, 3752 .. 3753, 3756, 3761, 3764 .. 3772, 3774 .. 3775, 3781, 3783 .. 3803, 3808 .. 3839, 3841 .. 3903, 3912, 3949 .. 3975, 3981 .. 4095,
4139 .. 4158, 4160 .. 4175, 4182 .. 4185, 4190 .. 4192, 4194 .. 4196, 4199 .. 4205, 4209 .. 4212, 4226 .. 4237, 4239 .. 4255, 4294, 4296 .. 4300,
4302 .. 4303, 4347, 4681, 4686 .. 4687, 4695, 4697, 4702 .. 4703, 4745, 4750 .. 4751, 4785, 4790 .. 4791, 4799, 4801, 4806 .. 4807, 4823, 4881,
4886 .. 4887, 4955 .. 4991, 5008 .. 5023, 5110 .. 5111, 5118 .. 5120, 5741 .. 5742, 5760, 5787 .. 5791, 5867 .. 5872, 5881 .. 5887, 5901, 5906 .. 5919,
5938 .. 5951, 5970 .. 5983, 5997, 6001 .. 6015, 6068 .. 6102, 6104 .. 6107, 6109 .. 6175, 6264 .. 6271, 6277 .. 6278, 6313, 6315 .. 6319, 6390 .. 6399,
6431 .. 6479, 6510 .. 6511, 6517 .. 6527, 6572 .. 6575, 6602 .. 6655, 6679 .. 6687, 6741 .. 6822, 6824 .. 6916, 6964 .. 6980, 6988 .. 7042, 7073 .. 7085,
7088 .. 7097, 7142 .. 7167, 7204 .. 7244, 7248 .. 7257, 7294 .. 7295, 7305 .. 7400, 7405, 7410 .. 7412, 7415 .. 7423, 7616 .. 7679, 7958 .. 7959,
7966 .. 7967, 8006 .. 8007, 8014 .. 8015, 8024, 8026, 8028, 8030, 8062 .. 8063, 8117, 8125, 8127 .. 8129, 8133, 8141 .. 8143, 8148 .. 8149, 8156 .. 8159,
8173 .. 8177, 8181, 8189 .. 8304, 8306 .. 8318, 8320 .. 8335, 8349 .. 8449, 8451 .. 8454, 8456 .. 8457, 8468, 8470 .. 8472, 8478 .. 8483, 8485, 8487,
8489, 8494, 8506 .. 8507, 8512 .. 8516, 8522 .. 8525, 8527 .. 8578, 8581 .. 11263, 11311, 11359, 11493 .. 11498, 11503 .. 11505, 11508 .. 11519, 11558,
11560 .. 11564, 11566 .. 11567, 11624 .. 11630, 11632 .. 11647, 11671 .. 11679, 11687, 11695, 11703, 11711, 11719, 11727, 11735, 11743 .. 11822,
11824 .. 12292, 12295 .. 12336, 12342 .. 12346, 12349 .. 12352, 12439 .. 12444, 12448, 12539, 12544 .. 12548, 12590 .. 12592, 12687 .. 12703,
12731 .. 12783, 12800 .. 13311, 19894 .. 19967, 40918 .. 40959, 42125 .. 42191, 42238 .. 42239, 42509 .. 42511, 42528 .. 42537, 42540 .. 42559,
42607 .. 42622, 42654 .. 42655, 42726 .. 42774, 42784 .. 42785, 42889 .. 42890, 42927, 42936 .. 42998, 43010, 43014, 43019, 43043 .. 43071,
43124 .. 43137, 43188 .. 43249, 43256 .. 43258, 43260, 43262 .. 43273, 43302 .. 43311, 43335 .. 43359, 43389 .. 43395, 43443 .. 43470, 43472 .. 43487,
43493, 43504 .. 43513, 43519, 43561 .. 43583, 43587, 43596 .. 43615, 43639 .. 43641, 43643 .. 43645, 43696, 43698 .. 43700, 43703 .. 43704,
43710 .. 43711, 43713, 43715 .. 43738, 43742 .. 43743, 43755 .. 43761, 43765 .. 43776, 43783 .. 43784, 43791 .. 43792, 43799 .. 43807, 43815, 43823,
43867, 43878 .. 43887, 44003 .. 44031, 55204 .. 55215, 55239 .. 55242, 55292 .. 63743, 64110 .. 64111, 64218 .. 64255, 64263 .. 64274, 64280 .. 64284,
64286, 64297, 64311, 64317, 64319, 64322, 64325, 64434 .. 64466, 64830 .. 64847, 64912 .. 64913, 64968 .. 65007, 65020 .. 65135, 65141, 65277 .. 65312,
65339 .. 65344, 65371 .. 65381, 65471 .. 65473,
65480 .. 65481, 65488 .. 65489, 65496 .. 65497, 65501 .. 65535: Result := True;
end;
end;
var
I: Integer;
n: Integer;
C: Char;
S: string;
ID: string;
J: Integer;
Value: Double;
P: PChar;
begin
S := '';
I := 1;
n := Length(Str);
while (True) do
begin
Inc(I);
C := Str[I];
if (C = '\') then
begin
Inc(I);
C := Str[I];
S := S + C;
Continue;
end;
if (C = '$') then
begin
ID := '';
Inc(I);
for J := I to n - 1 do
begin
C := Str[J];
if IsSeparator(C) then
Break;
ID := ID + C;
Inc(I);
end;
Dec(I);
Value := GetVarValue(ID);
S := S + FloatToStr(Value);
Continue;
end;
if (C = '"') then
Break;
S := S + C;
end;
GetMem(Result, (Length(S) + 1) * 2);
FStringReference.Add(Result);
P := Result;
for I := 1 to S.Length do
begin
P^ := S[I];
Inc(P);
end;
P^ := #0000;
end;
end.
|
unit ThAttributes;
interface
uses
ThDrawItem, ThDrawStyle;
type
TDrawObjInfo = record
Id: Integer;
Alias: string;
StyleCls: TThDrawStyleClass;
ItemCls: TThDrawItemClass;
end;
DrawObjAttribute = class(TCustomAttribute)
public
FInfo: TDrawObjInfo;
public
constructor Create(const AId: Integer; AAlias: string; AStyleCls: TThDrawStyleClass = nil; AItemCls: TThDrawItemClass = nil);
destructor Destroy; override;
property Info: TDrawObjInfo read FInfo;
end;
DrawObjAttr = DrawObjAttribute;
function TryDrawObjAttr(ACls: TClass; var AInfo: TDrawObjInfo): Boolean;
implementation
uses
System.Rtti, ThDrawObject;
function TryDrawObjAttr(ACls: TClass; var AInfo: TDrawObjInfo): Boolean;
var
LContext: TRttiContext;
LType: TRttiType;
LAttr: TCustomAttribute;
begin
Result := False;
LContext := TRttiContext.Create;
try
LType := LContext.GetType(ACls.ClassInfo);
for LAttr in LType.GetAttributes do
begin
if LAttr is DrawObjAttribute then
begin
AInfo := DrawObjAttribute(LAttr).Info;
Exit(True);
end;
end;
finally
LContext.Free;
end;
end;
{ DrawObjAttribute }
constructor DrawObjAttribute.Create(const AId: Integer; AAlias: string; AStyleCls: TThDrawStyleClass; AItemCls: TThDrawItemClass);
begin
FInfo.Id := AId;
FInfo.Alias := AAlias;
FInfo.StyleCls := AStyleCls;
FInfo.ItemCls := AItemCls;
end;
destructor DrawObjAttribute.Destroy;
begin
inherited;
end;
end.
|
unit uNewBarangTransaksi;
interface
uses
SysUtils, Classes, uNewUnit, uTSBaseClass;
type
TBarangTransaksi = class(TSBaseClass)
private
FAssgrosAlloc: Double;
FAssgrosStock: Double;
FCOGS: Double;
FCommonAlloc: Double;
FCommonStock: Double;
FDATE_CREATE: TDateTime;
FDATE_MODIFY: TDateTime;
FKode: string;
FLastCost: Double;
//FNewUnit: TUnit;
FNewUnitID: Integer;
//FOPC_UNIT: TUnit;
FOPC_UNITID: Integer;
//FOPM_UNIT: TUnit;
FOPM_UNITID: Integer;
FOP_CREATE: Integer;
FOP_MODIFY: Integer;
FSalesPerDay: Double;
FStock: Double;
FStockDisplay: Double;
FStockInOrder: Double;
FStockMax: Double;
FStockMaxDisplay: Double;
FStockMin: Double;
FStockMinDisplay: Double;
FTraderAlloc: Double;
FTraderStock: Double;
function FLoadFromDB( aSQL : String ): Boolean;
function GetOPC_UNIT: TUnit;
function GetOPM_UNIT: TUnit;
procedure SetOPC_UNIT(Value: TUnit);
procedure SetOPM_UNIT(Value: TUnit);
public
constructor Create(AOwner : TComponent); override;
constructor CreateWithUser(AOwner : TComponent; AUserID: Integer; AUnitID:
Integer);
destructor Destroy; override;
procedure ClearProperties;
function CustomSQLTask: Tstrings;
function CustomSQLTaskPrior: Tstrings;
function CustomTableName: string;
function GenerateInterbaseMetaData: TStrings;
function GenerateSQL(ARepeatCount: Integer = 1): TStrings;
function GetFieldNameFor_AssgrosAlloc: string; dynamic;
function GetFieldNameFor_AssgrosStock: string; dynamic;
function GetFieldNameFor_COGS: string; dynamic;
function GetFieldNameFor_CommonAlloc: string; dynamic;
function GetFieldNameFor_CommonStock: string; dynamic;
function GetFieldNameFor_DATE_CREATE: string; dynamic;
function GetFieldNameFor_DATE_MODIFY: string; dynamic;
function GetFieldNameFor_Kode: string; dynamic;
function GetFieldNameFor_LastCost: string; dynamic;
function GetFieldNameFor_NewUnit: string; dynamic;
function GetFieldNameFor_OPC_UNIT: string; dynamic;
function GetFieldNameFor_OPM_UNIT: string; dynamic;
function GetFieldNameFor_OP_CREATE: string; dynamic;
function GetFieldNameFor_OP_MODIFY: string; dynamic;
function GetFieldNameFor_SalesPerDay: string; dynamic;
function GetFieldNameFor_Stock: string; dynamic;
function GetFieldNameFor_StockDisplay: string; dynamic;
function GetFieldNameFor_StockInOrder: string; dynamic;
function GetFieldNameFor_StockMax: string; dynamic;
function GetFieldNameFor_StockMaxDisplay: string; dynamic;
function GetFieldNameFor_StockMin: string; dynamic;
function GetFieldNameFor_StockMinDisplay: string; dynamic;
function GetFieldNameFor_TraderAlloc: string; dynamic;
function GetFieldNameFor_TraderStock: string; dynamic;
function GetFieldPrefix: string;
function GetGeneratorName: string; dynamic;
function GetHeaderFlag: Integer;
function GetPlannedID: Integer;
function LoadByID(AID: Integer): Boolean;
function LoadByKode(AKode: string): Boolean;
function RemoveFromDB: Boolean;
function SaveToDB: Boolean;
procedure UpdateData(AAssgrosAlloc: Double; AAssgrosStock: Double; ACOGS:
Double; ACommonAlloc: Double; ACommonStock: Double; AKode: string;
ALastCost: Double; ANewUnit_ID: Integer; ASalesPerDay: Double;
AStock: Double; AStockDisplay: Double; AStockInOrder: Double;
AStockMax: Double; AStockMaxDisplay: Double; AStockMin: Double;
AStockMinDisplay: Double; ATraderAlloc: Double; ATraderStock:
Double);
property AssgrosAlloc: Double read FAssgrosAlloc write FAssgrosAlloc;
property AssgrosStock: Double read FAssgrosStock write FAssgrosStock;
property COGS: Double read FCOGS write FCOGS;
property CommonAlloc: Double read FCommonAlloc write FCommonAlloc;
property CommonStock: Double read FCommonStock write FCommonStock;
property DATE_CREATE: TDateTime read FDATE_CREATE write FDATE_CREATE;
property DATE_MODIFY: TDateTime read FDATE_MODIFY write FDATE_MODIFY;
property Kode: string read FKode write FKode;
property LastCost: Double read FLastCost write FLastCost;
property OPC_UNIT: TUnit read GetOPC_UNIT write SetOPC_UNIT;
property OPM_UNIT: TUnit read GetOPM_UNIT write SetOPM_UNIT;
property OP_CREATE: Integer read FOP_CREATE write FOP_CREATE;
property OP_MODIFY: Integer read FOP_MODIFY write FOP_MODIFY;
property SalesPerDay: Double read FSalesPerDay write FSalesPerDay;
property Stock: Double read FStock write FStock;
property StockDisplay: Double read FStockDisplay write FStockDisplay;
property StockInOrder: Double read FStockInOrder write FStockInOrder;
property StockMax: Double read FStockMax write FStockMax;
property StockMaxDisplay: Double read FStockMaxDisplay write
FStockMaxDisplay;
property StockMin: Double read FStockMin write FStockMin;
property StockMinDisplay: Double read FStockMinDisplay write
FStockMinDisplay;
property TraderAlloc: Double read FTraderAlloc write FTraderAlloc;
property TraderStock: Double read FTraderStock write FTraderStock;
end;
implementation
uses FireDAC.Comp.Client, FireDAC.Stan.Error, udmMain, uAppUtils;
{
******************************* TBarangTransaksi *******************************
}
constructor TBarangTransaksi.Create(AOwner : TComponent);
begin
inherited Create(AOwner);
end;
constructor TBarangTransaksi.CreateWithUser(AOwner : TComponent; AUserID:
Integer; AUnitID: Integer);
begin
Create(AOwner);
OP_MODIFY := AUserID;
FOPM_UNITID := AUnitID;
end;
destructor TBarangTransaksi.Destroy;
begin
ClearProperties;
inherited Destroy;
end;
procedure TBarangTransaksi.ClearProperties;
begin
TraderStock := 0;
TraderAlloc := 0;
StockMinDisplay := 0;
StockMin := 0;
StockMaxDisplay := 0;
StockMax := 0;
StockInOrder := 0;
StockDisplay := 0;
Stock := 0;
SalesPerDay := 0;
LastCost := 0;
Kode := '';
CommonStock := 0;
CommonAlloc := 0;
COGS := 0;
AssgrosStock := 0;
AssgrosAlloc := 0;
end;
function TBarangTransaksi.CustomSQLTask: Tstrings;
begin
result := nil;
end;
function TBarangTransaksi.CustomSQLTaskPrior: Tstrings;
begin
result := nil;
end;
function TBarangTransaksi.CustomTableName: string;
begin
Result := 'barang_transaksi';
end;
function TBarangTransaksi.FLoadFromDB( aSQL : String ): Boolean;
begin
Result := False;
State := csNone;
ClearProperties;
with cOpenQuery(aSQL) do
begin
try
if not EOF then
begin
FAssgrosAlloc := FieldByName(GetFieldNameFor_AssgrosAlloc).AsFloat;
FAssgrosStock := FieldByName(GetFieldNameFor_AssgrosStock).AsFloat;
FCOGS := FieldByName(GetFieldNameFor_COGS).AsFloat;
FCommonAlloc := FieldByName(GetFieldNameFor_CommonAlloc).AsFloat;
FCommonStock := FieldByName(GetFieldNameFor_CommonStock).AsFloat;
FDATE_CREATE := FieldByName(GetFieldNameFor_DATE_CREATE).AsDateTime;
FDATE_MODIFY := FieldByName(GetFieldNameFor_DATE_MODIFY).AsDateTime;
FKode := FieldByName(GetFieldNameFor_Kode).AsString;
FLastCost := FieldByName(GetFieldNameFor_LastCost).AsFloat;
FNewUnitID := FieldByName(GetFieldNameFor_NewUnit).AsInteger;
FOPC_UNITID := FieldByName(GetFieldNameFor_OPC_UNIT).AsInteger;
FOPM_UNITID := FieldByName(GetFieldNameFor_OPM_UNIT).AsInteger;
FOP_CREATE := FieldByName(GetFieldNameFor_OP_CREATE).AsInteger;
FOP_MODIFY := FieldByName(GetFieldNameFor_OP_MODIFY).AsInteger;
FSalesPerDay := FieldByName(GetFieldNameFor_SalesPerDay).AsFloat;
FStock := FieldByName(GetFieldNameFor_Stock).AsFloat;
FStockDisplay := FieldByName(GetFieldNameFor_StockDisplay).AsFloat;
FStockInOrder := FieldByName(GetFieldNameFor_StockInOrder).AsFloat;
FStockMax := FieldByName(GetFieldNameFor_StockMax).AsFloat;
FStockMaxDisplay := FieldByName(GetFieldNameFor_StockMaxDisplay).AsFloat;
FStockMin := FieldByName(GetFieldNameFor_StockMin).AsFloat;
FStockMinDisplay := FieldByName(GetFieldNameFor_StockMinDisplay).AsFloat;
FTraderAlloc := FieldByName(GetFieldNameFor_TraderAlloc).AsFloat;
FTraderStock := FieldByName(GetFieldNameFor_TraderStock).AsFloat;
Self.State := csLoaded;
Result := True;
end;
finally
Free;
end;
End;
end;
function TBarangTransaksi.GenerateInterbaseMetaData: TStrings;
begin
Result := TStringList.Create;
Result.Append( '' );
Result.Append( 'Create Table ''+ CustomTableName +'' ( ' );
Result.Append( 'TRMSBaseClass_ID Integer not null, ' );
Result.Append( 'AssgrosAlloc double precision Not Null , ' );
Result.Append( 'AssgrosStock double precision Not Null , ' );
Result.Append( 'COGS double precision Not Null , ' );
Result.Append( 'CommonAlloc double precision Not Null , ' );
Result.Append( 'CommonStock double precision Not Null , ' );
Result.Append( 'DATE_CREATE Date Not Null , ' );
Result.Append( 'DATE_MODIFY Date Not Null , ' );
Result.Append( 'Kode Varchar(30) Not Null Unique, ' );
Result.Append( 'LastCost double precision Not Null , ' );
Result.Append( 'NewUnit_ID Integer Not Null, ' );
Result.Append( 'OPC_UNIT_ID Integer Not Null, ' );
Result.Append( 'OPM_UNIT_ID Integer Not Null, ' );
Result.Append( 'OP_CREATE Integer Not Null , ' );
Result.Append( 'OP_MODIFY Integer Not Null , ' );
Result.Append( 'SalesPerDay double precision Not Null , ' );
Result.Append( 'Stock double precision Not Null , ' );
Result.Append( 'StockDisplay double precision Not Null , ' );
Result.Append( 'StockInOrder double precision Not Null , ' );
Result.Append( 'StockMax double precision Not Null , ' );
Result.Append( 'StockMaxDisplay double precision Not Null , ' );
Result.Append( 'StockMin double precision Not Null , ' );
Result.Append( 'StockMinDisplay double precision Not Null , ' );
Result.Append( 'TraderAlloc double precision Not Null , ' );
Result.Append( 'TraderStock double precision Not Null , ' );
Result.Append( 'Stamp TimeStamp ' );
Result.Append( ' ); ' );
end;
function TBarangTransaksi.GenerateSQL(ARepeatCount: Integer = 1): TStrings;
var
// lDecimalSeparator: Char;
sSQL: string;
//i: Integer;
ssSQL: TStrings;
begin
Result := TStringList.Create;
if State = csNone then
begin
raise Exception.create('Tidak bisa generate dalam Mode csNone')
end;
// lDecimalSeparator := DecimalSeparator;
// DecimalSeparator := '.';
ssSQL := CustomSQLTaskPrior;
if ssSQL <> nil then
begin
Result.AddStrings(ssSQL);
end;
ssSQL := nil;
DATE_MODIFY := cGetServerDateTime;
FOPM_UNITID := FNewUnitID;
If Kode = '' then
begin
//Generate Insert SQL
OP_CREATE := OP_MODIFY;
DATE_CREATE := DATE_MODIFY;
FOPC_UNITID := FOPM_UNITID;
//FID := cGetNextID(GetGeneratorName);
sSQL := 'insert into ' + CustomTableName + ' ('
+ GetFieldNameFor_AssgrosAlloc + ', '
+ GetFieldNameFor_AssgrosStock + ', '
+ GetFieldNameFor_COGS + ', '
+ GetFieldNameFor_CommonAlloc + ', '
+ GetFieldNameFor_CommonStock + ', '
+ GetFieldNameFor_DATE_CREATE + ', '
+ GetFieldNameFor_DATE_MODIFY + ', '
+ GetFieldNameFor_Kode + ', '
+ GetFieldNameFor_LastCost + ', '
+ GetFieldNameFor_NewUnit + ', '
+ GetFieldNameFor_OPC_UNIT + ', '
+ GetFieldNameFor_OPM_UNIT + ', '
+ GetFieldNameFor_OP_CREATE + ', '
+ GetFieldNameFor_OP_MODIFY + ', '
+ GetFieldNameFor_SalesPerDay + ', '
+ GetFieldNameFor_Stock + ', '
+ GetFieldNameFor_StockDisplay + ', '
+ GetFieldNameFor_StockInOrder + ', '
+ GetFieldNameFor_StockMax + ', '
+ GetFieldNameFor_StockMaxDisplay + ', '
+ GetFieldNameFor_StockMin + ', '
+ GetFieldNameFor_StockMinDisplay + ', '
+ GetFieldNameFor_TraderAlloc + ', '
+ GetFieldNameFor_TraderStock +') values ('
+ FormatFloat('0.00', FAssgrosAlloc) + ', '
+ FormatFloat('0.00', FAssgrosStock) + ', '
+ FormatFloat('0.00', FCOGS) + ', '
+ FormatFloat('0.00', FCommonAlloc) + ', '
+ FormatFloat('0.00', FCommonStock) + ', '
+ TAppUtils.QuotDT(FDATE_CREATE) + ', '
+ TAppUtils.QuotDT(FDATE_MODIFY) + ', '
+ QuotedStr(FKode) + ', '
+ FormatFloat('0.00', FLastCost) + ', '
+ InttoStr(FNewUnitID) + ', '
+ InttoStr(FOPC_UNITID) + ', '
+ InttoStr(FOPM_UNITID) + ', '
+ IntToStr(FOP_CREATE) + ', '
+ IntToStr(FOP_MODIFY) + ', '
+ FormatFloat('0.00', FSalesPerDay) + ', '
+ FormatFloat('0.00', FStock) + ', '
+ FormatFloat('0.00', FStockDisplay) + ', '
+ FormatFloat('0.00', FStockInOrder) + ', '
+ FormatFloat('0.00', FStockMax) + ', '
+ FormatFloat('0.00', FStockMaxDisplay) + ', '
+ FormatFloat('0.00', FStockMin) + ', '
+ FormatFloat('0.00', FStockMinDisplay) + ', '
+ FormatFloat('0.00', FTraderAlloc) + ', '
+ FormatFloat('0.00', FTraderStock) + ');';
end
else
begin
//generate Update SQL
sSQL := 'update ' + CustomTableName + ' set '
+ GetFieldNameFor_AssgrosAlloc + ' = ' + FormatFloat('0.00', FAssgrosAlloc)
+ ', ' + GetFieldNameFor_AssgrosStock + ' = ' + FormatFloat('0.00', FAssgrosStock)
+ ', ' + GetFieldNameFor_COGS + ' = ' + FormatFloat('0.00', FCOGS)
+ ', ' + GetFieldNameFor_CommonAlloc + ' = ' + FormatFloat('0.00', FCommonAlloc)
+ ', ' + GetFieldNameFor_CommonStock + ' = ' + FormatFloat('0.00', FCommonStock)
+ ', ' + GetFieldNameFor_DATE_MODIFY + ' = ' + TAppUtils.QuotDT(FDATE_MODIFY)
+ ', ' + GetFieldNameFor_Kode + ' = ' + QuotedStr(FKode)
+ ', ' + GetFieldNameFor_LastCost + ' = ' + FormatFloat('0.00', FLastCost)
+ ', ' + GetFieldNameFor_NewUnit + ' = ' + IntToStr(FNewUnitID)
+ ', ' + GetFieldNameFor_OPM_UNIT + ' = ' + IntToStr(FOPM_UNITID)
+ ', ' + GetFieldNameFor_OP_MODIFY + ' = ' + IntToStr(FOP_MODIFY)
+ ', ' + GetFieldNameFor_SalesPerDay + ' = ' + FormatFloat('0.00', FSalesPerDay)
+ ', ' + GetFieldNameFor_Stock + ' = ' + FormatFloat('0.00', FStock)
+ ', ' + GetFieldNameFor_StockDisplay + ' = ' + FormatFloat('0.00', FStockDisplay)
+ ', ' + GetFieldNameFor_StockInOrder + ' = ' + FormatFloat('0.00', FStockInOrder)
+ ', ' + GetFieldNameFor_StockMax + ' = ' + FormatFloat('0.00', FStockMax)
+ ', ' + GetFieldNameFor_StockMaxDisplay + ' = ' + FormatFloat('0.00', FStockMaxDisplay)
+ ', ' + GetFieldNameFor_StockMin + ' = ' + FormatFloat('0.00', FStockMin)
+ ', ' + GetFieldNameFor_StockMinDisplay + ' = ' + FormatFloat('0.00', FStockMinDisplay)
+ ', ' + GetFieldNameFor_TraderAlloc + ' = ' + FormatFloat('0.00', FTraderAlloc)
+ ', ' + GetFieldNameFor_TraderStock + ' = ' + FormatFloat('0.00', FTraderStock)
+ ' where ' + GetFieldNameFor_Kode + ' = ' + QuotedStr(Kode)
+ ' and ' + GetFieldNameFor_NewUnit + ' = ' + IntToStr(FNewUnitID) + ';';
end;
Result.Append(sSQL);
//generating Collections SQL
ssSQL := CustomSQLTask;
if ssSQL <> nil then
begin
Result.AddStrings(ssSQL);
end;
// DecimalSeparator := lDecimalSeparator;
FreeAndNil(ssSQL)
end;
function TBarangTransaksi.GetFieldNameFor_AssgrosAlloc: string;
begin
Result := GetFieldPrefix + 'Assgros_Alloc';
end;
function TBarangTransaksi.GetFieldNameFor_AssgrosStock: string;
begin
Result := GetFieldPrefix + 'Assgros_Stock';
end;
function TBarangTransaksi.GetFieldNameFor_COGS: string;
begin
Result := GetFieldPrefix + 'COGS';
end;
function TBarangTransaksi.GetFieldNameFor_CommonAlloc: string;
begin
Result := GetFieldPrefix + 'Common_Alloc';
end;
function TBarangTransaksi.GetFieldNameFor_CommonStock: string;
begin
Result := GetFieldPrefix + 'Common_Stock';
end;
function TBarangTransaksi.GetFieldNameFor_DATE_CREATE: string;
begin
Result := 'DATE_CREATE';
end;
function TBarangTransaksi.GetFieldNameFor_DATE_MODIFY: string;
begin
Result := 'DATE_MODIFY';
end;
function TBarangTransaksi.GetFieldNameFor_Kode: string;
begin
Result := GetFieldPrefix + 'brg_code';
end;
function TBarangTransaksi.GetFieldNameFor_LastCost: string;
begin
Result := GetFieldPrefix + 'Last_Cost';
end;
function TBarangTransaksi.GetFieldNameFor_NewUnit: string;
begin
Result := GetFieldPrefix + 'BRG_UNT_ID';
end;
function TBarangTransaksi.GetFieldNameFor_OPC_UNIT: string;
begin
Result := 'OPC_UNIT';
end;
function TBarangTransaksi.GetFieldNameFor_OPM_UNIT: string;
begin
Result := 'OPM_UNIT';
end;
function TBarangTransaksi.GetFieldNameFor_OP_CREATE: string;
begin
Result := 'OP_CREATE';
end;
function TBarangTransaksi.GetFieldNameFor_OP_MODIFY: string;
begin
Result := 'OP_MODIFY';
end;
function TBarangTransaksi.GetFieldNameFor_SalesPerDay: string;
begin
Result := GetFieldPrefix + 'Sales_Per_Day';
end;
function TBarangTransaksi.GetFieldNameFor_Stock: string;
begin
Result := GetFieldPrefix + 'Stock';
end;
function TBarangTransaksi.GetFieldNameFor_StockDisplay: string;
begin
Result := GetFieldPrefix + 'Stock_Disp';
end;
function TBarangTransaksi.GetFieldNameFor_StockInOrder: string;
begin
Result := GetFieldPrefix + 'Stock_In_Order';
end;
function TBarangTransaksi.GetFieldNameFor_StockMax: string;
begin
Result := GetFieldPrefix + 'Stock_Max';
end;
function TBarangTransaksi.GetFieldNameFor_StockMaxDisplay: string;
begin
Result := GetFieldPrefix + 'Stock_Max_Disp';
end;
function TBarangTransaksi.GetFieldNameFor_StockMin: string;
begin
Result := GetFieldPrefix + 'Stock_Min';
end;
function TBarangTransaksi.GetFieldNameFor_StockMinDisplay: string;
begin
Result := GetFieldPrefix + 'Stock_Min_Disp';
end;
function TBarangTransaksi.GetFieldNameFor_TraderAlloc: string;
begin
Result := GetFieldPrefix + 'Trader_Alloc';
end;
function TBarangTransaksi.GetFieldNameFor_TraderStock: string;
begin
Result := GetFieldPrefix + 'Trader_Stock';
end;
function TBarangTransaksi.GetFieldPrefix: string;
begin
Result := 'brgt_';
end;
function TBarangTransaksi.GetGeneratorName: string;
begin
Result := 'GEN_' + CustomTableName + '_ID';
end;
function TBarangTransaksi.GetHeaderFlag: Integer;
begin
result := 5416;
end;
function TBarangTransaksi.GetOPC_UNIT: TUnit;
begin
Result := OPC_UNIT;
end;
function TBarangTransaksi.GetOPM_UNIT: TUnit;
begin
Result := OPM_UNIT;
end;
function TBarangTransaksi.GetPlannedID: Integer;
begin
result := -1;
if State = csNone then
begin
Raise exception.create('Tidak bisa GetPlannedID di Mode csNone');
exit;
end
else if state = csCreated then
begin
//result := cGetNextID(GetGeneratorName);
end
else if State = csLoaded then
begin
result := -1;
end;
end;
function TBarangTransaksi.LoadByID(AID: Integer): Boolean;
//var
// sSQL: string;
begin
Result := False;
end;
function TBarangTransaksi.LoadByKode(AKode: string): Boolean;
var
sSQL: string;
begin
sSQL := 'select * from ' + CustomTableName
+ ' where ' + GetFieldNameFor_Kode + ' = ' + QuotedStr(AKode);
Result := FloadFromDB(sSQL);
end;
function TBarangTransaksi.RemoveFromDB: Boolean;
var
sSQL: string;
begin
Result := False;
sSQL := 'delete from ' + CustomTableName
+ ' where ' + GetFieldNameFor_Kode + ' = ' + QuotedStr(Kode)
+ ' and ' + GetFieldNameFor_NewUnit + ' = ' + IntToStr(FNewUnitID);
if cExecSQL(sSQL, dbtPOS, False) then
Result := True; //SimpanBlob(sSQL,GetHeaderFlag);
end;
function TBarangTransaksi.SaveToDB: Boolean;
var
ssSQL: TStrings;
begin
Result := False;
try
ssSQL := GenerateSQL();
try
if cExecSQL(ssSQL) then
// if SimpanBlob(ssSQL,GetHeaderFlag) then
Result := True;
except
end;
finally
FreeAndNil(ssSQL);
end;
end;
procedure TBarangTransaksi.SetOPC_UNIT(Value: TUnit);
begin
end;
procedure TBarangTransaksi.SetOPM_UNIT(Value: TUnit);
begin
end;
procedure TBarangTransaksi.UpdateData(AAssgrosAlloc: Double; AAssgrosStock:
Double; ACOGS: Double; ACommonAlloc: Double; ACommonStock: Double;
AKode: string; ALastCost: Double; ANewUnit_ID: Integer; ASalesPerDay:
Double; AStock: Double; AStockDisplay: Double; AStockInOrder: Double;
AStockMax: Double; AStockMaxDisplay: Double; AStockMin: Double;
AStockMinDisplay: Double; ATraderAlloc: Double; ATraderStock: Double);
begin
FAssgrosAlloc := AAssgrosAlloc;
FAssgrosStock := AAssgrosStock;
FCOGS := ACOGS;
FCommonAlloc := ACommonAlloc;
FCommonStock := ACommonStock;
FKode := Trim(AKode);
FLastCost := ALastCost;
FNewUnitID := ANewUnit_ID;
FSalesPerDay := ASalesPerDay;
FStock := AStock;
FStockDisplay := AStockDisplay;
FStockInOrder := AStockInOrder;
FStockMax := AStockMax;
FStockMaxDisplay := AStockMaxDisplay;
FStockMin := AStockMin;
FStockMinDisplay := AStockMinDisplay;
FTraderAlloc := ATraderAlloc;
FTraderStock := ATraderStock;
State := csCreated;
end;
end.
|
unit rtti_idebinder_uBehaveBinders;
{$mode objfpc}{$H+}
interface
uses
Controls, ComCtrls, LMessages, Forms, SysUtils, StdCtrls, Menus, types,
classes, ExtCtrls;
const
LM_BEHAVEBINDER = LM_USER + $99000;
LM_DISCONECTWINDOWPROC = LM_BEHAVEBINDER + 01;
type
{ TBehaveBinder }
TBehaveBinder = class
private type
PMethod = ^TMethod;
TLMBBWINDOWPROC = record
Msg: Cardinal;
{$ifdef cpu64}
UnusedMsg: Cardinal;
{$endif}
DisposedProc: PMethod;
StoredProc: PMethod;
Result: PtrInt;
end;
{ TNotificator }
TNotificator = class(TComponent)
private
fBinder: TBehaveBinder;
protected
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
public
constructor Create(ABinder: TBehaveBinder); reintroduce;
end;
private
fControl: TControl;
fControlNotificator: TNotificator;
fOldWndProc: TWndMethod;
procedure HookWndPproc;
procedure UnhookWndProc;
protected
procedure ControlWndProc(var TheMessage: TLMessage);
procedure DoControlWndProc(var TheMessage: TLMessage); virtual;
property Control: TControl read fControl;
procedure BindControl; virtual;
procedure UnbindControl; virtual;
public
destructor Destroy; override;
procedure Bind(AControl: TControl);
procedure Unbind;
end;
{ TPageControlBehaveBinder }
TPageControlBehaveBinder = class(TBehaveBinder)
private
fPageIndex: Integer;
fFirstVisiblePassed: Boolean;
function GetControl: TPageControl;
function IsActiveControlOnActivePage: Boolean;
procedure FocusActualPageControl;
procedure SetFirstVisiblePage;
function FindForm: TCustomForm;
protected
procedure DoControlWndProc(var TheMessage: TLMessage); override;
public
procedure BindControl; override;
property Control: TPageControl read GetControl;
end;
{ TPopupMenuBinder }
TPopupMenuBinder = class(TBehaveBinder)
public type
TBuildMenuEvent = procedure(AMenu: TMenu; AControl: TControl) of object;
private
fMenu: TPopupMenu;
fOnBuildMenu: TBuildMenuEvent;
private
procedure ShowPopupMenu(const AX, AY: integer);
function GetMenu: TPopupMenu;
property Menu: TPopupMenu read GetMenu;
protected
procedure DoControlWndProc(var TheMessage: TLMessage); override;
public
constructor Create(AOnBuildMenu: TBuildMenuEvent);
destructor Destroy; override;
procedure BindControl; override;
end;
{ TMoveControlBinder }
TMoveControlBinder = class(TBehaveBinder)
private
fOriginalParentFormWndProc: TWndMethod;
fHold: Boolean;
fPrevPos: TPoint;
fControlDelta: TPoint;
fOriginalCapture: TControl;
fOriginalCaptureButtons: TCaptureMouseButtons;
function GetParentControl: TWinControl;
function GetParentForm: TCustomForm;
procedure MoveBegin;
procedure MoveEnd;
procedure MoveControl;
procedure CorrectMousePos;
procedure CorrectParent(const AMousePos: TPoint);
function FindBranchParent(const AParent: TWinControl; APos: TPoint): TWinControl;
function FindUpperParent(const AParent: TWinControl; ASkip: TControl; APos: TPoint): TWinControl;
protected
procedure DoControlWndProc(var TheMessage: TLMessage); override;
procedure MouseMoveUserInputHandler(Sender: TObject; Msg: Cardinal);
procedure BindControl; override;
public
property ParentControl: TWinControl read GetParentControl;
property ParentForm: TCustomForm read GetParentForm;
end;
{ TMoveFormBinder }
TMoveFormBinder = class(TBehaveBinder)
end;
implementation
type
{ TControlHelper }
TControlHelper = class helper for TControl
private
function GetH_MouseCapture: Boolean;
procedure SetH_MouseCapture(AValue: Boolean);
public
property H_MouseCapture: Boolean read GetH_MouseCapture write SetH_MouseCapture;
function H_GetClientScrollOffset: TPoint;
end;
{ TWinControlHelper }
TWinControlHelper = class helper for TWinControl
public
function H_IsControlMouseMsg(var TheMessage): Boolean;
end;
{ TWinControlHelper }
function TWinControlHelper.H_IsControlMouseMsg(var TheMessage): Boolean;
begin
Result := IsControlMouseMsg(TheMessage);
end;
{ TControlHelper }
function TControlHelper.GetH_MouseCapture: Boolean;
begin
Result := MouseCapture;
end;
procedure TControlHelper.SetH_MouseCapture(AValue: Boolean);
begin
MouseCapture := AValue;
end;
function TControlHelper.H_GetClientScrollOffset: TPoint;
begin
Result := GetClientScrollOffset;
end;
{ TBehaveBinder.TNotificator }
procedure TBehaveBinder.TNotificator.Notification(AComponent: TComponent;
Operation: TOperation);
begin
inherited Notification(AComponent, Operation);
if (Operation = opRemove) and (AComponent = fBinder.Control) then
begin
fBinder.Unbind;
end;
end;
constructor TBehaveBinder.TNotificator.Create(ABinder: TBehaveBinder);
begin
inherited Create(nil);
fBinder := ABinder;
fBinder.Control.FreeNotification(Self);
end;
{ TMoveControlBinder }
function TMoveControlBinder.GetParentControl: TWinControl;
begin
Result := Control.Parent;
end;
function TMoveControlBinder.GetParentForm: TCustomForm;
var
mParent: TWinControl;
begin
Result := nil;
mParent := ParentControl;
while (mParent <> nil) and not (mParent is TCustomForm) do
mParent := mParent.Parent;
if (mParent <> nil) and (mParent is TCustomForm) then
Result := mParent as TCustomForm;
end;
procedure TMoveControlBinder.MoveControl;
var
mPos: TPoint;
mNew: integer;
mc: TControl;
begin
mc := Control;
mPos := ParentControl.ScreenToClient(Mouse.CursorPos);
mNew := mPos.X - fControlDelta.X;
if Control.Left <> mNew then
Control.Left := mNew;
mNew := mPos.Y - fControlDelta.Y;
if Control.Top <> mNew then
Control.Top := mNew;
end;
procedure TMoveControlBinder.CorrectMousePos;
var
mPos: TPoint;
mConPos: TPoint;
mRect: TRect;
begin
mRect.Left := 0;
mRect.Right := Control.Width;
mRect.Top := 0;
mRect.Bottom := Control.Height;
mRect.TopLeft := Control.ClientToScreen(mRect.TopLeft);
mRect.BottomRight := Control.ClientToScreen(mRect.BottomRight);
mPos := Mouse.CursorPos;
if mPos.X < mRect.Left then
mPos.X := mRect.Left + 1
else if mPos.X > mRect.Right then
mPos.X := mRect.Right - 1;
if mPos.Y < mRect.Top then
mPos.Y := mRect.Top + 1
else if mPos.Y > mRect.Bottom then
mPos.Y := mRect.Bottom - 1;
Mouse.CursorPos := mPos;
end;
procedure TMoveControlBinder.CorrectParent(const AMousePos: TPoint);
var
mPoint, mControlPoint: TPoint;
mNewParent: TWinControl;
begin
mNewParent := FindUpperParent(ParentControl, Control, AMousePos);
if (mNewParent <> nil) and (mNewParent <> ParentControl) then
begin
mControlPoint := Control.ScreenToClient(AMousePos);
Control.Parent := mNewParent;
mPoint := mNewParent.ScreenToClient(AMousePos);
Control.Left := mPoint.X - mControlPoint.X;
Control.Top := mPoint.y - mControlPoint.Y;
if Control is TWinControl then
(Control as TWinControl).SetFocus;
end;
end;
function TMoveControlBinder.FindBranchParent(const AParent: TWinControl;
APos: TPoint): TWinControl;
var
i: integer;
mControl: TWinControl;
begin
Result := nil;
if AParent = nil then
Exit;
// serach in subcontrols
for i := 0 to AParent.ControlCount - 1 do
begin
if not (AParent.Controls[i] is TWinControl) then
Continue;
mControl := AParent.Controls[i] as TWinControl;
Result := FindBranchParent(mControl, APos);
if Result <> nil then
Exit;
end;
if AParent is TCustomPanel then
begin
if PtInRect(AParent.ClientRect, AParent.ScreenToClient(APos)) then
Result := AParent;
end;
end;
function TMoveControlBinder.FindUpperParent(const AParent: TWinControl;
ASkip: TControl; APos: TPoint): TWinControl;
var
i: integer;
mControl: TWinControl;
begin
Result := nil;
if AParent = nil then
Exit;
// serach in subcontrols
for i := 0 to AParent.ControlCount - 1 do
begin
if not (AParent.Controls[i] is TWinControl) then
Continue;
if AParent.Controls[i] = ASkip then
Continue;
mControl := AParent.Controls[i] as TWinControl;
Result := FindBranchParent(mControl, APos);
if Result <> nil then
Exit;
end;
// test self
if (
(AParent is TCustomPanel)
or (AParent is TCustomForm)
or (AParent is TCustomGroupBox)
)
and PtInRect(AParent.ClientRect, AParent.ScreenToClient(APos)) then
begin
Result := AParent;
Exit;
end;
// extend search on upper level
Result := FindUpperParent(AParent.Parent, AParent, APos);
end;
procedure TMoveControlBinder.MoveBegin;
begin
if fHold then
raise Exception.Create('already moving');
fHold := True;
fPrevPos := Mouse.CursorPos;
fControlDelta := Control.ScreenToClient(Mouse.CursorPos);
// capture only control not work, ParentForm with MouseMoveUserInputHandler yes
SetCaptureControl(ParentForm);
Application.AddOnUserInputHandler(@MouseMoveUserInputHandler, True);
Control.BringToFront;
end;
procedure TMoveControlBinder.MoveEnd;
begin
if not fHold then
raise Exception.Create('not moving');
fHold := False;
CorrectParent(Mouse.CursorPos);
Application.RemoveOnUserInputHandler(@MouseMoveUserInputHandler);
SetCaptureControl(nil);
end;
procedure TMoveControlBinder.DoControlWndProc(var TheMessage: TLMessage
);
begin
case TheMessage.Msg of
LM_LBUTTONDOWN:
begin
MoveBegin;
end;
LM_LBUTTONUP:
begin
if fHold then
MoveEnd
else
inherited;
end;
LM_MOUSEMOVE:
begin
if fHold then
MoveControl
else
inherited;
end;
LM_MOUSELEAVE:
begin
if fHold then
MoveControl
else
inherited;
end;
else
begin
inherited;
end;
end;
end;
procedure TMoveControlBinder.MouseMoveUserInputHandler(Sender: TObject; Msg: Cardinal);
begin
case Msg of
LM_LBUTTONUP:
begin
if fHold then
MoveEnd;
end;
LM_MOUSEMOVE:
begin
if fHold then
MoveControl;
end;
end;
end;
procedure TMoveControlBinder.BindControl;
begin
end;
{ TPopupMenuBinder }
function TPopupMenuBinder.GetMenu: TPopupMenu;
begin
if fMenu = nil then
begin
fMenu := TPopupMenu.Create(nil);
end;
Result := fMenu;
end;
procedure TPopupMenuBinder.ShowPopupMenu(const AX, AY: integer);
begin
if Assigned(fOnBuildMenu) then
fOnBuildMenu(Menu, Control);
Menu.PopUp(AX, AY);
end;
procedure TPopupMenuBinder.DoControlWndProc(var TheMessage: TLMessage
);
begin
case TheMessage.Msg of
LM_RBUTTONDOWN:
begin
fOldWndProc(TheMessage);
ShowPopupMenu(Mouse.CursorPos.X, Mouse.CursorPos.Y);
end;
else
inherited;
end;
end;
constructor TPopupMenuBinder.Create(AOnBuildMenu: TBuildMenuEvent);
begin
inherited Create;
fOnBuildMenu := AOnBuildMenu;
end;
destructor TPopupMenuBinder.Destroy;
begin
FreeAndNil(fMenu);
inherited Destroy;
end;
procedure TPopupMenuBinder.BindControl;
begin
end;
{ TBehaveBinder }
procedure TBehaveBinder.HookWndPproc;
begin
//if (Control is TWinControl) or (Control.Parent = nil) then
begin
fOldWndProc := Control.WindowProc;
Control.WindowProc := @ControlWndProc;
end
//else
//begin
// fOldWndProc := Control.Parent.WindowProc;
// Control.Parent.WindowProc := @DoControlWndProc;
//end;
end;
procedure TBehaveBinder.UnhookWndProc;
var
mMsgWP: TLMBBWINDOWPROC;
mMsg: TLMessage absolute mMsgWP;
mdWndProc: TWndMethod;
begin
mdWndProc := @ControlWndProc;
if (TMethod(Control.WindowProc).Code = TMethod(mdWndProc).Code)
and (TMethod(Control.WindowProc).Data = TMethod(mdWndProc).Data) then
// this object hook belongs to this binder
Control.WindowProc := fOldWndProc
else
begin
// something hooked after me, so need to notify it to adjust its fOldWndProc
// (WndProc is method - so we need to compare code and data aswell)
mMsgWP.Msg := LM_DISCONECTWINDOWPROC;
mMsgWP.DisposedProc := @TMethod(mdWndProc);
mMsgWP.StoredProc := @TMethod(fOldWndProc);
mMsgWP.Result := 0;
Control.WindowProc(mMsg);
if mMsgWP.Result <> 1 then
raise Exception.Create('Problem with unhook windowproc from chain - superior hook not responsed');
end;
end;
procedure TBehaveBinder.ControlWndProc(var TheMessage: TLMessage);
begin
if not (Control is TWinControl)
or not (Control as TWinControl).H_IsControlMouseMsg(TheMessage) then
DoControlWndProc(TheMessage);
end;
procedure TBehaveBinder.DoControlWndProc(var TheMessage: TLMessage);
var
mMsg: TLMBBWINDOWPROC absolute TheMessage;
begin
case TheMessage.Msg of
LM_DISCONECTWINDOWPROC:
begin
if (mMsg.DisposedProc^.Code = TMethod(fOldWndProc).Code)
and (mMsg.DisposedProc^.Data = TMethod(fOldWndProc).Data) then
begin
fOldWndProc := TWndMethod(mMsg.StoredProc^);
mMsg.Result := 1;
end
else
fOldWndProc(TheMessage);
end;
else
fOldWndProc(TheMessage);
end;
end;
procedure TBehaveBinder.BindControl;
begin
end;
procedure TBehaveBinder.UnbindControl;
begin
end;
destructor TBehaveBinder.Destroy;
begin
Unbind;
FreeAndNil(fControlNotificator);
inherited Destroy;
end;
procedure TBehaveBinder.Bind(AControl: TControl);
begin
fControl := AControl;
HookWndPproc;
FreeAndNil(fControlNotificator);
fControlNotificator := TNotificator.Create(Self);
BindControl;
end;
procedure TBehaveBinder.Unbind;
begin
if fControl <> nil then
begin
UnbindControl;
UnhookWndProc;
fControl := nil;
end;
end;
{ TPageControlBehaveBinder }
function TPageControlBehaveBinder.GetControl: TPageControl;
begin
Result := inherited Control as TPageControl;
end;
procedure TPageControlBehaveBinder.DoControlWndProc(var TheMessage: TLMessage
);
begin
case TheMessage.Msg of
48206:
begin
if TLMNotify(TheMessage).NMHdr^.code = TCN_SELCHANGE then
begin
fPageIndex := Control.PageIndex;
inherited;
if fPageIndex <> Control.PageIndex then
FocusActualPageControl;
end else
inherited;
end;
LM_SHOWWINDOW:
begin
inherited;
if Control.Visible and not fFirstVisiblePassed then
begin
fFirstVisiblePassed := True;
SetFirstVisiblePage;
end;
end
else
inherited;
end;
end;
procedure TPageControlBehaveBinder.BindControl;
begin
end;
function TPageControlBehaveBinder.IsActiveControlOnActivePage: Boolean;
var
mControl: TWinControl;
begin
Result := False;
mControl := FindForm.ActiveControl.Parent;
while mControl <> nil do begin
if mControl = Control.ActivePage then
begin
Result := True;
Break;
end;
mControl := mControl.Parent;
end;
end;
procedure TPageControlBehaveBinder.FocusActualPageControl;
var
mControl, mFocControl: TWinControl;
mTabOrder: integer;
i: integer;
begin
if not IsActiveControlOnActivePage then
begin
mTabOrder := MaxInt;
mFocControl := nil;
for i := 0 to Control.ActivePage.ControlCount - 1 do
begin
if not (Control.ActivePage.Controls[i] is TWinControl) then
Continue;
mControl := Control.ActivePage.Controls[i] as TWinControl;
if not mControl.CanFocus or not mControl.TabStop then
Continue;
if mControl.TabOrder < mTabOrder then
begin
mFocControl := mControl;
mTabOrder := mControl.TabOrder;
end;
end;
if mFocControl <> nil then
begin
mFocControl.SetFocus;
end;
end;
end;
procedure TPageControlBehaveBinder.SetFirstVisiblePage;
var
i: integer;
begin
for i := 0 to Control.PageCount - 1 do
begin
if Control.Pages[i].TabVisible then
begin
Control.PageIndex := Control.Pages[i].PageIndex;
Break;
end;
end;
end;
function TPageControlBehaveBinder.FindForm: TCustomForm;
var
mControl: TWinControl;
begin
Result := nil;
mControl := Control.Parent;
while mControl <> nil do
begin
if mControl is TCustomForm then
begin
Result := mControl as TCustomForm;
Break;
end;
mControl := mControl.Parent;
end;
end;
end.
|
unit UnitGetWAMip;
interface
function GetWanIP: String;
function GetLocalIP : string;
implementation
uses
Windows,
winsock;
function fileexists(filename: string): boolean;
var
hfile: thandle;
lpfindfiledata: twin32finddata;
begin
result := false;
hfile := findfirstfile(pchar(filename), lpfindfiledata);
if hfile <> invalid_handle_value then
begin
findclose(hfile);
result := true;
end;
end;
function LerArquivo(FileName: String; var tamanho: DWORD): String;
var
hFile: Cardinal;
lpNumberOfBytesRead: DWORD;
imagem: pointer;
begin
result := '';
if fileexists(filename) = false then exit;
imagem := nil;
hFile := CreateFile(PChar(FileName), GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, 0, 0);
tamanho := GetFileSize(hFile, nil);
GetMem(imagem, tamanho);
ReadFile(hFile, imagem^, tamanho, lpNumberOfBytesRead, nil);
setstring(result, Pchar(imagem), tamanho);
freemem(imagem, tamanho);
CloseHandle(hFile);
end;
function URLDownloadToFile(Caller: IUnknown; URL: PChar; FileName: PChar;
Reserved: DWORD;LPBINDSTATUSCALLBACK: pointer): HResult;
var
xURLDownloadToFile: function(Caller: IUnknown; URL: PChar; FileName: PChar;
Reserved: DWORD;LPBINDSTATUSCALLBACK: pointer): HResult; stdcall;
begin
xURLDownloadToFile := GetProcAddress(LoadLibrary(pchar('urlmon.dll')), pchar('URLDownloadToFileA'));
Result := xURLDownloadToFile(Caller, URL, FileName, Reserved, LPBINDSTATUSCALLBACK);
end;
// obtains your outside world IP.
function GetWanIP: String;
var
TempList: string;
len: cardinal;
DestFile:String;
const
SourceFile = 'http://www.ip-adress.com/';
begin
result := '127.0.0.1';
DestFile := 'IP.txt';
if UrlDownloadToFile(nil, PChar(SourceFile), PChar(DestFile), 0, nil) = S_OK then
try
TempList := lerarquivo(DestFile, len);
DeleteFile(PChar(DestFile));
if TempList = '' then exit;
Result := TempList;
except
exit;
end;
delete(result, 1, pos('My IP address:', result) + 13);
result := copy(result, 1, pos('<', result) - 1);
if result = '' then result := '127.0.0.1';
end;
function StrPas(const Str: PChar): string;
begin
Result := Str;
end;
function GetLocalIP : string;
type
TaPInAddr = array [0..10] of PInAddr;
PaPInAddr = ^TaPInAddr;
var
phe : PHostEnt;
pptr : PaPInAddr;
Buffer : array [0..63] of char;
I : Integer;
GInitData : TWSADATA;
begin
WSAStartup($101, GInitData);
Result := '';
GetHostName(Buffer, SizeOf(Buffer));
phe :=GetHostByName(buffer);
if phe = nil then Exit;
pptr := PaPInAddr(Phe^.h_addr_list);
I := 0;
while pptr^[I] <> nil do begin
result := StrPas(inet_ntoa(pptr^[I]^));
result := StrPas(inet_ntoa(pptr^[I]^));
Inc(I);
end;
WSACleanup;
end;
{
var
Host, IP, Err: string;
begin
if GetIPFromHost(Host, IP, Err) then
messagebox(0, PChar('Your Hostname: ' + host + #13+
'Your Dialup or LAN IP: ' + IP + #13 +
'Your WAN IP: ' + GetWanIp), 'Network Info', MB_OK or MB_ICONINFORMATION);
end.
}
end.
|
unit Unit2;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs,
FMX.Controls.Presentation, FMX.StdCtrls, FMX.Memo.Types,
FMX.ScrollBox, FMX.Memo, FMX.Objects,
Spring, Spring.Collections,
MVVM.Messages.Engine,
MVVM.Messages.Engine.Interfaces,
MVVM.Types;
type
TThreadPublisher = class(TThread)
protected
procedure Execute; override;
end;
TTestMessageInteger = class(TMessage)
public
Valor: Integer;
constructor Create(const AValue: Integer); overload;
end;
TTestMessageString = class(TMessage)
public
Valor: String;
constructor Create(const AValue: String); overload;
end;
TTestMessageGeneric_Integer = class(TMessage_Generic<Integer>);
TTestMessageInteger_Filter = class(TMessage)
public
Valor : Integer;
Filter: String;
constructor Create(const AValue: Integer; const AFilter: String); overload;
end;
TTestMessageInteger_Filter_Listener = class(TMessageListener<TTestMessageInteger_Filter>)
private
FFilter: String;
protected
function GetConditionsMatch(AMessage: IMessage): Boolean; override;
public
constructor Create(const AFilter: string; const AChannel: String = ''; const AFilterCondition: TListenerFilter = nil; const ACodeExecutesInMainUIThread: Boolean = False;
const ATypeRestriction: EMessageTypeRestriction = EMessageTypeRestriction.mtrAllowDescendants); overload;
property Filter: string read FFilter write FFilter;
end;
ITest = interface
['{621B7280-C06D-4123-B8DC-7BF02EA898E4}']
end;
TTest = class(TInterfacedObject, ITest)
public
constructor Create;
destructor Destroy; override;
end;
TForm2 = class(TForm)
Button1: TButton;
Memo1: TMemo;
Button2: TButton;
Button3: TButton;
Button4: TButton;
Button5: TButton;
Button6: TButton;
Memo2: TMemo;
ToolBar1: TToolBar;
CheckBox1: TCheckBox;
CheckBox2: TCheckBox;
CheckBox3: TCheckBox;
CheckBox4: TCheckBox;
ToolBar2: TToolBar;
Rectangle1: TRectangle;
cbPooled: TCheckBox;
Label1: TLabel;
Label2: TLabel;
Memo3: TMemo;
Button7: TButton;
Button8: TButton;
Button9: TButton;
Button10: TButton;
procedure FormCreate(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure Button4Click(Sender: TObject);
procedure Button6Click(Sender: TObject);
procedure Button5Click(Sender: TObject);
procedure CheckBox1Change(Sender: TObject);
procedure CheckBox2Change(Sender: TObject);
procedure CheckBox3Change(Sender: TObject);
procedure CheckBox4Change(Sender: TObject);
procedure cbPooledChange(Sender: TObject);
procedure Button7Click(Sender: TObject);
procedure Button8Click(Sender: TObject);
procedure Button9Click(Sender: TObject);
procedure Button10Click(Sender: TObject);
private
{ Private declarations }
FValor : Integer;
FListenerInteger : IMessageListener<TTestMessageInteger>;
FListenerInteger2 : IMessageListener<TTestMessageInteger>;
FListenerString1 : IMessageListener<TTestMessageString>;
FListenerString2 : IMessageListener<TTestMessageString>;
FListenerGeneric : IMessageListener<TTestMessageGeneric_Integer>;
FListenerTest : IMessageListener<TTestMessageInteger>;
FListenerFilter1: IMessageListener<TTestMessageInteger_Filter>;
FListenerFilter2: IMessageListener<TTestMessageInteger_Filter>;
function LogTime: string;
protected
procedure DisableChecks;
procedure OnTestMessageInteger(AMsg: IMessage);
procedure OnTestMessageInteger2(AMsg: IMessage);
procedure OnTestMessageString1(AMsg: IMessage);
procedure OnTestMessageString2(AMsg: IMessage);
procedure OnTestMessageGeneric_Integer(AMsg: IMessage);
procedure OnTestMessageIntegerMemo2(AMsg: IMessage);
procedure OnFilteredMessage1(AMsg: IMessage);
procedure OnFilteredMessage2(AMsg: IMessage);
public
{ Public declarations }
end;
var
Form2: TForm2;
implementation
uses
System.DateUtils,
MVVM.Core,
MVVM.Services.Platform.FMX;
{$R *.fmx}
{ TForm2 }
procedure TForm2.Button10Click(Sender: TObject);
var
LHour, LMinute, LSecond, LMilliSecond: Word;
LMsg : IMessage;
LNewDateTime : TDateTime;
begin
DecodeTime(Now, LHour, LMinute, LSecond, LMilliSecond);
LNewDateTime := RecodeTime(Now, LHour, LMinute, LSecond + 3, LMilliSecond);
Memo1.Lines.Add(LogTime + 'Scheduled');
LMsg := TTestMessageInteger.Create(8888);
LMsg.Schedule(LNewDateTime);
end;
procedure TForm2.Button1Click(Sender: TObject);
var
LMsg: IMessage;
begin
LMsg := TTestMessageInteger.Create(FValor);
LMsg.Post;
Inc(FValor);
end;
procedure TForm2.Button2Click(Sender: TObject);
var
LMsg: IMessage;
begin
LMsg := TTestMessageString.Create('Este es un mensaje de prueba de tipo <string>');
LMsg.Post;
end;
procedure TForm2.Button3Click(Sender: TObject);
var
LMsg: IMessage;
begin
LMsg := TTestMessageGeneric_Integer.Create;
TTestMessageGeneric_Integer(LMsg).Data := FValor;
LMsg.Post;
Inc(FValor);
end;
procedure TForm2.Button4Click(Sender: TObject);
begin
DisableChecks;
if Assigned(FListenerTest) then
begin
FListenerTest.Unregister;
FListenerTest := nil;
end;
FListenerTest := TMessageListener<TTestMessageInteger>.Create(DEFAULT_CHANNEL_SINGLED_THREADED);
FListenerTest.IsCodeToExecuteInUIMainThread := True;
FListenerTest.OnMessage.Add(OnTestMessageIntegerMemo2);
end;
procedure TForm2.Button5Click(Sender: TObject);
begin
DisableChecks;
if Assigned(FListenerTest) then
begin
FListenerTest.Unregister;
FListenerTest := nil;
end;
FListenerTest := TMessageListener<TTestMessageInteger>.Create(DEFAULT_CHANNEL_MULTI_THREADED);
FListenerTest.IsCodeToExecuteInUIMainThread := True;
FListenerTest.OnMessage.Add(OnTestMessageIntegerMemo2);
end;
procedure TForm2.Button6Click(Sender: TObject);
var
LThread: TThreadPublisher;
begin
Memo2.Lines.Clear;
LThread := TThreadPublisher.Create(True);
LThread.FreeOnTerminate := True;
LThread.Start;
end;
procedure TForm2.Button7Click(Sender: TObject);
begin
FListenerFilter1 := TTestMessageInteger_Filter_Listener.Create('Filter1');
FListenerFilter1.IsCodeToExecuteInUIMainThread := True;
FListenerFilter1.OnMessage.Add(OnFilteredMessage1);
FListenerFilter2 := TTestMessageInteger_Filter_Listener.Create('Filter2');
FListenerFilter2.IsCodeToExecuteInUIMainThread := True;
FListenerFilter2.OnMessage.Add(OnFilteredMessage2);
end;
procedure TForm2.Button8Click(Sender: TObject);
var
LMsg: IMessage;
I : Integer;
begin
for I := 1 to 10 do
begin
case I Mod 2 of
0:
begin
LMsg := TTestMessageInteger_Filter.Create(I, 'Filter2');
LMsg.Post;
end
else begin
LMsg := TTestMessageInteger_Filter.Create(I, 'Filter1');
LMsg.Post;
end;
end;
end;
end;
procedure TForm2.Button9Click(Sender: TObject);
var
LMsg: IMessage;
begin
Memo1.Lines.Add(LogTime + 'Scheduled');
LMsg := TTestMessageInteger.Create(9999);
LMsg.Schedule(2000);
end;
procedure TForm2.cbPooledChange(Sender: TObject);
begin
case cbPooled.IsChecked of
True:
begin
MessageBus.MessageDeploymentKind := EMessageDeploymentKind.mdkPooled
end;
False:
begin
MessageBus.MessageDeploymentKind := EMessageDeploymentKind.mdkFifo
end;
end;
end;
procedure TForm2.CheckBox1Change(Sender: TObject);
begin
FListenerInteger.Enabled := CheckBox1.IsChecked
end;
procedure TForm2.CheckBox2Change(Sender: TObject);
begin
FListenerString1.Enabled := CheckBox2.IsChecked;
end;
procedure TForm2.CheckBox3Change(Sender: TObject);
begin
FListenerGeneric.Enabled := CheckBox3.IsChecked
end;
procedure TForm2.CheckBox4Change(Sender: TObject);
begin
FListenerString2.Enabled := CheckBox4.IsChecked
end;
procedure TForm2.DisableChecks;
begin
CheckBox1.IsChecked := False;
CheckBox2.IsChecked := False;
CheckBox3.IsChecked := False;
CheckBox4.IsChecked := False;
end;
procedure TForm2.FormCreate(Sender: TObject);
begin
MVVMCore.InitializationDone;
InitializePlatform;
FListenerInteger := TMessageListener<TTestMessageInteger>.Create;
FListenerInteger.IsCodeToExecuteInUIMainThread := True;
FListenerInteger.OnMessage.Add(OnTestMessageInteger);
FListenerInteger2 := TMessageListener<TTestMessageInteger>.Create;
FListenerInteger2.IsCodeToExecuteInUIMainThread := False;
FListenerInteger2.OnMessage.Add(OnTestMessageInteger2);
FListenerString1 := TMessageListener<TTestMessageString>.Create;
FListenerString1.IsCodeToExecuteInUIMainThread := True;
FListenerString1.OnMessage.Add(OnTestMessageString1);
FListenerString2 := TMessageListener<TTestMessageString>.Create;
FListenerString2.IsCodeToExecuteInUIMainThread := True;
FListenerString2.OnMessage.Add(OnTestMessageString2);
FListenerGeneric := TMessageListener<TTestMessageGeneric_Integer>.Create;
FListenerGeneric.IsCodeToExecuteInUIMainThread := True;
FListenerGeneric.OnMessage.Add(OnTestMessageGeneric_Integer);
FValor := 1;
cbPooled.isChecked := (MessageBus.MessageDeploymentKind = EMessageDeploymentKind.mdkPooled);
end;
function TForm2.LogTime: string;
begin
Result := FormatDateTime('hhnnss.zzz ', Now);
end;
procedure TForm2.OnFilteredMessage1(AMsg: IMessage);
begin
Memo3.Lines.Add(LogTime + 'Filtered (Listener1): ' + TTestMessageInteger_Filter(AMsg).Valor.ToString)
end;
procedure TForm2.OnFilteredMessage2(AMsg: IMessage);
begin
Memo3.Lines.Add(LogTime + 'Filtered (Listener2): ' + TTestMessageInteger_Filter(AMsg).Valor.ToString)
end;
procedure TForm2.OnTestMessageGeneric_Integer(AMsg: IMessage);
begin
Memo1.Lines.Add(LogTime + 'Generic-Integer: ' + TMessage_Generic<Integer>(AMsg).Data.ToString)
end;
procedure TForm2.OnTestMessageInteger(AMsg: IMessage);
begin
Memo1.Lines.Add(LogTime + 'Integer: ' + TTestMessageInteger(AMsg).Valor.ToString)
end;
procedure TForm2.OnTestMessageInteger2(AMsg: IMessage);
begin
Sleep(10000);
TThread.Queue(nil,
procedure
begin
Memo1.Lines.Add(LogTime + ' Fin!');
end);
end;
procedure TForm2.OnTestMessageIntegerMemo2(AMsg: IMessage);
begin
Memo2.Lines.Add(TTestMessageInteger(AMsg).Valor.ToString)
end;
procedure TForm2.OnTestMessageString1(AMsg: IMessage);
begin
Memo1.Lines.Add(LogTime + 'String (Subscriber1): ' + TTestMessageString(AMsg).Valor)
end;
procedure TForm2.OnTestMessageString2(AMsg: IMessage);
begin
Memo1.Lines.Add(LogTime + 'String (Subscriber2): ' + TTestMessageString(AMsg).Valor)
end;
{ TTestMessage }
constructor TTestMessageInteger.Create(const AValue: Integer);
begin
inherited Create;
Valor := AValue;
end;
{ TTestMessageString }
constructor TTestMessageString.Create(const AValue: String);
begin
inherited Create;
Valor := AValue;
end;
{ TThreadPublisher }
procedure TThreadPublisher.Execute;
var
I : Integer;
LMsg: IMessage;
begin
for I := 1 to 1000 do
begin
LMsg := TTestMessageInteger.Create(I);
LMsg.Post;
end;
end;
{ TTestMessageInteger_Filter }
constructor TTestMessageInteger_Filter.Create(const AValue: Integer; const AFilter: String);
begin
inherited Create;
Valor := AValue;
Filter:= AFilter;
end;
{ TTestMessageInteger_Filter_Listener }
constructor TTestMessageInteger_Filter_Listener.Create(const AFilter: string; const AChannel: String; const AFilterCondition: TListenerFilter; const ACodeExecutesInMainUIThread: Boolean; const ATypeRestriction: EMessageTypeRestriction);
begin
FFilter := AFilter;
Create(AChannel, AFilterCondition, ACodeExecutesInMainUIThread, ATypeRestriction);
end;
function TTestMessageInteger_Filter_Listener.GetConditionsMatch(AMessage: IMessage): Boolean;
begin
Result := FFilter.Equals(TTestMessageInteger_Filter(AMessage).Filter)
end;
{ TTest }
constructor TTest.Create;
begin
inherited;
end;
destructor TTest.Destroy;
begin
inherited;
end;
end.
|
{*******************************************************************************
* uPrintSpPostMain *
* *
* Печать справочника должностных окладов *
* Copyright © 2006, Олег Г. Волков, Донецкий Национальный Университет *
*******************************************************************************}
unit uPrintSpPostMain;
interface
uses uCommonSp, DB, Forms, Dialogs, Controls, uPrintSpPostData, IBase;
type
TPrintSpPost = class(TSprav)
private
DataModule: TdmPrintSpPost;
IsConnected: Boolean;
procedure PrepareConnect;
public
constructor Create;
destructor Destroy;override;
procedure Show;override;
procedure GetInfo;override;
function Exists: boolean;override;
end;
function CreateSprav: TSprav;stdcall;
exports CreateSprav;
implementation
uses Variants, SysUtils, uPrintSpPostForm;
function CreateSprav: TSprav;
begin
Result := TPrintSpPost.Create;
end;
constructor TPrintSpPost.Create;
begin
inherited Create;
// создание входных/выходных полей
Input.FieldDefs.Add('Actual_Date', ftDate);
// подготовить параметры
PrepareMemoryDatasets;
end;
destructor TPrintSpPost.Destroy;
begin
inherited Destroy;
if IsConnected then
begin
DataModule.ReadTransaction.Active := False;
end;
DataModule.Free;
end;
// подготовить соединение с базой
procedure TPrintSpPost.PrepareConnect;
var
hnd: Integer;
begin
DataModule := TdmPrintSpPost.Create(nil);
with DataModule do
begin
if Database.Connected then
Database.Connected := False;
hnd := Input['DBHandle'];
Database.Handle := TISC_DB_HANDLE(hnd);
Database.Connected := True;
end;
IsConnected := True;
end;
procedure TPrintSpPost.Show;
var
form: TfmPrintSpPost;
begin
if not IsConnected then PrepareConnect;
form := TfmPrintSpPost.Create(Application.MainForm, DataModule);
if ( Input['ShowStyle'] = 0 ) or ( Input['Select'] > 0 ) then
begin
form.ShowModal;
form.Free;
end
else
begin
form.FormStyle := fsMDIChild;
form.WindowState := wsMaximized;
end;
end;
function TPrintSpPost.Exists: boolean;
begin
if not IsConnected then PrepareConnect;
Result := True;
end;
procedure TPrintSpPost.GetInfo;
begin
if not IsConnected then PrepareConnect;
end;
end.
|
program MustacheTestsGenerator;
{$mode objfpc}{$H+}
uses
Classes, fpjson, sysutils, LuiJSONUtils, strutils;
function GetTestName(TestData: TJSONObject): String;
begin
Result := TestData.Strings['name'];
Result := DelChars(Result, ' ');
Result := DelChars(Result, '-');
Result := DelChars(Result, '(');
Result := DelChars(Result, ')');
end;
function NormalizeJSONString(const Str: String): String;
begin
Result := StringReplace(Str, '''', '''''', [rfReplaceAll]);
Result := StringReplace(Result, LineEnding, '''+ LineEnding +''', [rfReplaceAll]);
Result := StringReplace(Result, #10, '''+ LineEnding +''', [rfReplaceAll]);
end;
function CreateClassDeclaration(const TestCaseName: String; SpecData: TJSONObject): String;
var
TestsData: TJSONArray;
TestName: String;
i: Integer;
begin
Result := ' ' + TestCaseName + ' = class(THandlebarsTestCase)' + LineEnding;
Result := Result + ' published' + LineEnding;
if FindJSONProp(SpecData, 'tests', TestsData) then
begin
for i := 0 to TestsData.Count - 1 do
begin
TestName := GetTestName(TestsData.Objects[i]);
Result := Result + ' procedure Test' + TestName + ';' + LineEnding;
end;
end;
Result := Result + ' end;' + LineEnding;
end;
function CreateClassImplementation(const TestCaseName: String; SpecData: TJSONObject): String;
var
TestsData: TJSONArray;
TestData, TemplateData: TJSONObject;
TestName: String;
i: Integer;
begin
Result := '';
if FindJSONProp(SpecData, 'tests', TestsData) then
begin
for i := 0 to TestsData.Count - 1 do
begin
TestData := TestsData.Objects[i];
TemplateData := TestData.Objects['data'];
TestName := GetTestName(TestData);
Result := Result + Format(LineEnding + 'procedure %s.Test%s;' + LineEnding, [TestCaseName, TestName]);
Result := Result + 'begin' +LineEnding;
Result := Result + Format(' CheckRender(''%s'',''%s'',''%s'')',
[NormalizeJSONString(TestData.Strings['template']),
TemplateData.AsJSON,
NormalizeJSONString(TestData.Strings['expected'])]);
Result := Result + LineEnding + 'end;' + LineEnding;
end;
end;
end;
const
SpecFolder = 'mustache-specs';
var
SpecData: TJSONObject;
SearchRec: TSearchRec;
DeclarationSrc, ImplementationSrc, InitializationSrc, UnitSrc: TStringList;
TestCaseName: String;
begin
if not DirectoryExists(SpecFolder) then
begin
WriteLn(Format('SpecFolder "%s" not found', [SpecFolder]));
Exit;
end;
DeclarationSrc := TStringList.Create;
ImplementationSrc := TStringList.Create;
UnitSrc := TStringList.Create;
InitializationSrc := TStringList.Create;
try
if FindFirst(SpecFolder + PathDelim + '*.json', faAnyFile, SearchRec) = 0 then
repeat
if TryReadJSONFile(SpecFolder + PathDelim + SearchRec.Name, SpecData) then
begin
TestCaseName := AnsiProperCase(DelChars(ChangeFileExt(SearchRec.Name, ''), '~'), [' ']);
TestCaseName := Format('T%sTests', [TestCaseName]);
DeclarationSrc.Add(CreateClassDeclaration(TestCaseName, SpecData));
ImplementationSrc.Add(CreateClassImplementation(TestCaseName, SpecData));
InitializationSrc.Add(Format(' RegisterTest(''Mustache'', %s.Suite);', [TestCaseName]));
SpecData.Destroy;
end;
until FindNext(SearchRec) <> 0;
//interface
UnitSrc.Add('unit MustacheTests;' + LineEnding);
UnitSrc.Add('{$mode objfpc}{$H+}' + LineEnding);
UnitSrc.Add('interface' + LineEnding);
UnitSrc.Add('uses' + LineEnding + ' TestFramework, HandlebarsTestCase;' + LineEnding);
UnitSrc.Add('type');
UnitSrc.AddStrings(DeclarationSrc);
//implementation
UnitSrc.Add('implementation');
UnitSrc.AddStrings(ImplementationSrc);
UnitSrc.Add('initialization');
UnitSrc.AddStrings(InitializationSrc);
UnitSrc.Add(LineEnding + 'end.');
UnitSrc.SaveToFile('mustachetests.pas');
finally
InitializationSrc.Destroy;
UnitSrc.Destroy;
ImplementationSrc.Destroy;
DeclarationSrc.Destroy;
end;
end.
|
unit TestULoteVO;
{
Delphi DUnit Test Case
----------------------
This unit contains a skeleton test case class generated by the Test Case Wizard.
Modify the generated code to correctly setup and call the methods from the unit
being tested.
}
interface
uses
TestFramework, SysUtils, ULoteVO, UCondominioVO, Generics.Collections, UGenericVO,
Classes, Constantes, Atributos;
type
// Test methods for class TLoteVO
TestTLoteVO = class(TTestCase)
strict private
FLoteVO: TLoteVO;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestValidarCamposObrigatorios;
procedure TestValidarCamposObrigatoriosNaoEncontrado;
end;
implementation
procedure TestTLoteVO.SetUp;
begin
FLoteVO := TLoteVO.Create;
end;
procedure TestTLoteVO.TearDown;
begin
FLoteVO.Free;
FLoteVO := nil;
end;
procedure TestTLoteVO.TestValidarCamposObrigatorios;
var
Lote : TLoteVO;
begin
Lote := TLoteVO.Create;
Lote.idLote := 1;
Lote.nrLote := '1';
Lote.dtLote := StrToDate('01/01/2016');
Lote.dsLote := 'Lote Folha de Pgto';
try
Lote.ValidarCamposObrigatorios;
Check(True,'Sucesso!')
except on E: Exception do
Check(false,'Erro!');
end;
end;
procedure TestTLoteVO.TestValidarCamposObrigatoriosNaoEncontrado;
var
Lote : TLoteVO;
begin
Lote := TLoteVO.Create;
Lote.idLote := 0;
Lote.dtLote := StrToDate('01/01/2016');
Lote.dsLote := '';
try
Lote.ValidarCamposObrigatorios;
Check(false,'Erro!')
except on E: Exception do
Check(True,'Sucesso!');
end;
end;
initialization
// Register any test cases with the test runner
RegisterTest(TestTLoteVO.Suite);
end.
|
unit uView;
interface
uses
FMX.Forms,
System.Generics.Collections,
uInterfaces;
type
TFormView<I: IViewModel; K: TViewModel> = class abstract(TForm, IView, IVM_User<I, K>)
protected
var
FViewModel : IViewModel;
function GetVM_AsInterface: I; virtual; abstract;
function GetVM_AsObject: K; virtual; abstract;
procedure Loaded; override;
procedure CreateVM;
public
property VM_AsInterface: I read GetVM_AsInterface;
property VM_AsObject: K read GetVM_AsObject;
end;
TFrameView<I: IViewModel; K: TViewModel> = class abstract(TFrame, IView, IVM_User<I, K>)
protected
var
FViewModel : IViewModel;
function GetVM_AsInterface: I; virtual; abstract;
function GetVM_AsObject: K; virtual; abstract;
procedure Loaded; override;
procedure CreateVM;
public
property VM_AsInterface: I read GetVM_AsInterface;
property VM_AsObject: K read GetVM_AsObject;
end;
var
FSingletonViewModels: TDictionary<TGUID, IViewModel>;
implementation
uses
System.RTTI,
uTypes,
uAtributos;
{ TFormView<I, K> }
procedure TFormView<I, K>.CreateVM;
var
Ctx : TRttiContext;
Typ : TRttiType;
LAttr: TCustomAttribute;
LVMA : ViewForVM;
begin
if Assigned(FViewModel) then Exit;
Ctx := TRttiContext.Create;
try
Typ := Ctx.GetType(Self.ClassInfo);
// Loop for attributes
for LAttr in Typ.GetAttributes do
begin
//ViewForVM
if LAttr is ViewForVM then
begin
LVMA := LAttr as ViewForVM;
case LVMA.InstanceType of
EInstanceType.itSingleton:
begin
if not FSingletonViewModels.TryGetValue(LVMA.VMInterface, FViewModel) then
begin
FViewModel := LVMA.VMClass.Create;
FSingletonViewModels.AddOrSetValue(LVMA.VMInterface, FViewModel);
end;
end;
EInstanceType.itDefault:
begin
FViewModel := LVMA.VMClass.Create;
end;
end;
Exit;
end;
end;
finally
Ctx.Free;
end;
end;
procedure TFormView<I, K>.Loaded;
begin
inherited;
CreateVM;
end;
{ TFrameView<I, K> }
procedure TFrameView<I, K>.CreateVM;
var
Ctx : TRttiContext;
Typ : TRttiType;
LAttr: TCustomAttribute;
LVMA : ViewForVM;
begin
if Assigned(FViewModel) then Exit;
Ctx := TRttiContext.Create;
try
Typ := Ctx.GetType(Self.ClassInfo);
// Loop for attributes
for LAttr in Typ.GetAttributes do
begin
//ViewForVM
if LAttr is ViewForVM then
begin
LVMA := LAttr as ViewForVM;
case LVMA.InstanceType of
EInstanceType.itSingleton:
begin
if not FSingletonViewModels.TryGetValue(LVMA.VMInterface, FViewModel) then
begin
FViewModel := LVMA.VMClass.Create;
FSingletonViewModels.AddOrSetValue(LVMA.VMInterface, FViewModel);
end;
end;
EInstanceType.itDefault:
begin
FViewModel := LVMA.VMClass.Create;
end;
end;
Exit;
end;
end;
finally
Ctx.Free;
end;
end;
procedure TFrameView<I, K>.Loaded;
begin
inherited;
CreateVM;
end;
initialization
FSingletonViewModels := TDictionary<TGUID, IViewModel>.Create;
finalization
FSingletonViewModels.Free;
end.
|
unit AP;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, Drawer, StdCtrls, XPButton, ComCtrls, ExtCtrls, XPLabel, ShellApi,
Registry;
type
TWmMoving = record
Msg: Cardinal;
fwSide: Cardinal;
lpRect: PRect;
Result: Integer;
end;
const
AlignCenter = Wm_User + 1024;
type
TAboutForm = class(TForm)
fr1: TPanel;
Logo: TImage;
tx1: TXPLabel;
tx2: TXPLabel;
tx5: TXPLabel;
tx4: TXPLabel;
tx3: TXPLabel;
spr1: TBevel;
spr2: TBevel;
tx9: TXPLabel;
License: TRichEdit;
fr2: TPanel;
Closed: TXPButton;
SendMail: TEdit;
Drawer: TDrawer;
tx8: TXPLabel;
procedure FormActivate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure FormCreate(Sender: TObject);
procedure FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure LogoClick(Sender: TObject);
procedure tx8Click(Sender: TObject);
procedure tx9Click(Sender: TObject);
procedure SendMailClick(Sender: TObject);
procedure ClosedClick(Sender: TObject);
procedure tx9MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer);
procedure tx9MouseLeave(Sender: TObject);
procedure tx9MouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure tx8MouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure tx8MouseLeave(Sender: TObject);
procedure tx8MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer);
procedure FormShow(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
private
SM: HWND;
r: TRegistry;
MS: TMemoryStatus;
procedure WMMoving(var msg: TWMMoving);
message WM_MOVING;
procedure wmNCLButtonDown(var Msg: TWMNCLButtonDown);
message WM_NCLBUTTONDOWN;
procedure wmNCLButtonUp(var Msg: TWMNCLButtonUp);
message WM_NCLBUTTONUP;
procedure CMMouseLeave(var msg: TMessage);
message CM_MOUSELEAVE;
procedure ChangeMessageBoxPosition(var Msg: TMessage);
message AlignCenter;
public
end;
var
AboutForm: TAboutForm;
msgCaption: PChar;
implementation
uses SP;
{$R *.dfm}
procedure TAboutForm.FormActivate(Sender: TObject);
begin
SM := GetSystemMenu(Handle, False);
DeleteMenu(SM, Sc_Restore, Mf_String);
DeleteMenu(SM, Sc_Size, Mf_String);
DeleteMenu(SM, Sc_Minimize, Mf_String);
DeleteMenu(SM, Sc_Maximize, Mf_String);
end;
procedure TAboutForm.FormDestroy(Sender: TObject);
begin
AboutForm.OnActivate := nil;
SendMail.Free;
License.Free;
Drawer.Free;
Closed.Free;
Logo.Free;
spr1.Free;
spr2.Free;
fr1.Free;
fr2.Free;
tx1.Free;
tx2.Free;
tx3.Free;
tx4.Free;
tx5.Free;
tx8.Free;
tx9.Free;
end;
procedure TAboutForm.FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
if Key = vk_Escape then
AboutForm.Close;
end;
procedure TAboutForm.FormCreate(Sender: TObject);
begin
r:=TRegistry.Create;
r.RootKey:=HKEY_LOCAL_MACHINE;
r.OpenKey('\Software\Microsoft\Windows NT\CurrentVersion', True);
tx4.Caption := r.ReadString('ProductName');
GlobalMemoryStatus(MS);
tx5.Caption := 'Memory Available to Windows: ' + FormatFloat('#,###" KB"', MS.dwTotalPhys / 1024);
end;
procedure TAboutForm.FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if SetForm.ch13.Checked then
begin
ReleaseCapture;
Perform(Wm_SysCommand, $f012, 0);
end;
end;
procedure TAboutForm.LogoClick(Sender: TObject);
begin
PostMessage(Handle, WM_USER + 1024, 0, 0);
if Application.MessageBox(PChar(
'Copyright @2008 Домани Олег (aka ?КТО_Я?)' + #13 +
'============================================' + #13 + #13 + '' +
'Вы имеете право распространять и использовать программу' +
#13 + 'в любых целях при условии целостности оригинального' + #13 + 'дистрибутива.'
+ #13 + ''
+ #13 + 'Если Вы хотите получить исходный код проекта (архив'
+ #13 + 'с компонентами по желанию пользователя), а также все'
+ #13 + 'последующие новые версии программы, то отправьте'
+ #13 + 'электронное письмо автору.'
+ #13 + ''
+ #13 + 'После отправки электронного письма автору, лицензия на'
+ #13 + 'этот программный продукт будет иметь характер GPL'
+ #13 + '(General Public License - общая открытая лицензия).'
+ #13 + ''
+ #13 + 'Данная лицензия практически не имеет никаких ограничений.'
+ #13 + 'Это означает, что Вы можете использовать программное'
+ #13 + 'обеспечение для любых целей.'
+ #13 + #13 + 'Вы даже можете изменять его по своему усмотрению. Однако'
+ #13 + 'Вы не имеете право свободно распространять его в качестве'
+ #13 + 'патентованной программы.'
+ #13 + #13 + 'Это право остается только за автором открытого исходного'
+ #13 + 'кода.'
+ #13 + #13 + 'Любой человек, получивший это программное обеспечение'
+ #13 + 'от Вас имеет все права на исходный код и может изменять его'
+ #13 + 'или свободно распространять.' +
'' + #13 + #13 + '============================================' + #13 +
'' + #13 +
'Отправить письмо сейчас?'),
'Адресная книга',
mb_IconAsterisk + mb_YesNo) = idYes then
begin
ShellExecute(Handle, 'open',
'mailto:GoodWinNix@mail.ru?Subject=Address Book Project' +
'&Body=Hello, please send me the source code program. Thanks!',
'', '', SW_SHOW);
end;
end;
procedure TAboutForm.CMMouseLeave(var msg: TMessage);
begin
tx8.ForegroundColor := $00FF8000;
tx9.ForegroundColor := $00FF8000;
end;
procedure TAboutForm.wmNCLButtonDown(var Msg: TWMNCLButtonDown);
begin
if Msg.HitTest = HTHELP then
begin
Msg.Result := 0;
end else
inherited;
end;
procedure TAboutForm.wmNCLButtonUp(var Msg: TWMNCLButtonUp);
begin
try
if Msg.HitTest = HTHELP then
begin
Logo.OnClick(Self);
end
else
inherited;
except
end;
end;
procedure TAboutForm.tx8Click(Sender: TObject);
begin
ShellExecute(Handle,'open',
'mailto:GoodWinNix@mail.ru?Subject=Address Book Project'+
'',
'','',SW_SHOW);
end;
procedure TAboutForm.tx9Click(Sender: TObject);
begin
ShellExecute(Handle, nil, 'http://www.viacoding.mylivepage.ru/', nil,nil, Sw_ShowNormal);
end;
procedure TAboutForm.SendMailClick(Sender: TObject);
begin
Drawer.Open;
end;
procedure TAboutForm.ClosedClick(Sender: TObject);
begin
AboutForm.Close;
end;
procedure TAboutForm.tx9MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer);
begin
tx9.ForegroundColor := clRed;
end;
procedure TAboutForm.tx9MouseLeave(Sender: TObject);
begin
tx9.ForegroundColor := $00FF8000;
end;
procedure TAboutForm.tx9MouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
tx9.ForegroundColor := $00FF8000;
end;
procedure TAboutForm.tx8MouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
tx8.ForegroundColor := $00FF8000;
end;
procedure TAboutForm.tx8MouseLeave(Sender: TObject);
begin
tx8.ForegroundColor := $00FF8000;
end;
procedure TAboutForm.tx8MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer);
begin
tx8.ForegroundColor := clRed;
end;
procedure TAboutForm.ChangeMessageBoxPosition(var Msg: TMessage);
var
MbHwnd: longword;
MbRect: TRect;
x, y, w, h: integer;
begin
MbHwnd := FindWindow(MAKEINTRESOURCE(WC_DIALOG), msgCaption);
if (MbHwnd <> 0) then
begin
GetWindowRect(MBHWnd, MBRect);
with MbRect do
begin
w := Right - Left;
h := Bottom - Top;
end;
x := AboutForm.Left + ((AboutForm.Width - w) div 2);
if x < 0 then
x := 0
else if x + w > Screen.Width then x := Screen.Width - w;
y := AboutForm.Top + ((AboutForm.Height - h) div 2);
if y < 0 then y := 0
else if y + h > Screen.Height then y := Screen.Height - h;
SetWindowPos(MBHWnd, 0, x, y, 0, 0, SWP_NOACTIVATE or SWP_NOSIZE or SWP_NOZORDER);
end;
end;
procedure TAboutForm.FormShow(Sender: TObject);
begin
if SetForm.ch12.Checked then
begin
SetWindowLong(AboutForm.Handle, GWL_EXSTYLE,
GetWindowLOng(AboutForm.Handle, GWL_EXSTYLE) or WS_EX_APPWINDOW);
end;
end;
procedure TAboutForm.FormClose(Sender: TObject; var Action: TCloseAction);
begin
Closed.SetFocus;
end;
procedure TAboutForm.WMMoving(var msg: TWMMoving);
var
r: TRect;
begin
if SetForm.Ch15.Checked then
begin
r := Screen.WorkareaRect;
if msg.lprect^.left < r.left then
OffsetRect(msg.lprect^, r.left - msg.lprect^.left, 0);
if msg.lprect^.top < r.top then
OffsetRect(msg.lprect^, 0, r.top - msg.lprect^.top);
if msg.lprect^.right > r.right then
OffsetRect(msg.lprect^, r.right - msg.lprect^.right, 0);
if msg.lprect^.bottom > r.bottom then
OffsetRect(msg.lprect^, 0, r.bottom - msg.lprect^.bottom);
end;
inherited;
end;
end.
|
unit Guia.DmGeral;
interface
uses
System.SysUtils, System.Classes, FireDAC.Stan.Intf, FireDAC.Stan.Option,
FireDAC.Stan.Error, FireDAC.UI.Intf, FireDAC.Phys.Intf, FireDAC.Stan.Def,
FireDAC.Stan.Pool, FireDAC.Stan.Async, FireDAC.Phys, FireDAC.Phys.FB,
FireDAC.Phys.FBDef, FireDAC.FMXUI.Wait, FireDAC.Stan.Param, FireDAC.DatS,
FireDAC.DApt.Intf, FireDAC.DApt, Data.DB, FireDAC.Comp.DataSet,
FireDAC.Comp.Client, FireDAC.Phys.IB, FireDAC.Phys.IBDef,
FireDAC.Stan.ExprFuncs, FireDAC.Phys.SQLiteDef, FireDAC.Stan.StorageBin,
FireDAC.Phys.SQLite,Data.FireDACJSONReflect, FMX.Types, FMX.VirtualKeyboard,
FMX.Platform, System.IOUtils, REST.Types, REST.Client, Data.Bind.Components,
Data.Bind.ObjectScope, REST.Response.Adapter, Guia.untClientmodule;
type
TdmGeral = class(TDataModule)
memCategorias: TFDMemTable;
memContrato: TFDMemTable;
memComCategorias: TFDMemTable;
memSubCategorias: TFDMemTable;
memComercio: TFDMemTable;
memFotosComercio: TFDMemTable;
memCheckList: TFDMemTable;
memTelefones: TFDMemTable;
memAvaliacoes: TFDMemTable;
memUsuarios: TFDMemTable;
memFotosPorSecao: TFDMemTable;
memCelularUsuario: TFDMemTable;
memDestaques: TFDMemTable;
memControle: TFDMemTable;
RESTResponseDataSetAdapter1: TRESTResponseDataSetAdapter;
RESTResponse1: TRESTResponse;
restCEP: TRESTRequest;
RESTClient1: TRESTClient;
memCep: TFDMemTable;
memCepcep: TWideStringField;
memCeplogradouro: TWideStringField;
memCepbairro: TWideStringField;
memCeplocalidade: TWideStringField;
memCepuf: TWideStringField;
memAuxiliar: TFDMemTable;
memNotificacao: TFDMemTable;
memAnuncios: TFDMemTable;
private
{ Private declarations }
public
procedure LoadDestaquePrincipal(AIdPush : String);
procedure LoadComercioCategoria(AIdPush : String; IdCategoria, IdSubCategoria : Integer);
procedure LoadCategorias(AIdPush : String);
procedure LoadSubCategoria(AIdPush : String; IdCategoria: Integer);
procedure LoadFotosPorSecao(vIdCat: Integer; APesquisa, AIdPush : String);
procedure LoadComercioPesquisa(AIdPush, FPesquisa : String);
procedure LoadDestaqueFavorito(AIdPush : String; vIdUsu : Integer);
function getNotificacoes(AIdUsu: Integer): TFDJSONDataSets;
procedure LoadComercio(idComercio: Integer);
procedure LoadAvaliacoes(idComercio, nStart: Integer);
function CelularDuplicado(vCelular: String) : Boolean;
procedure DownloadIdUsuario(vCelular : String);
procedure DownloadUsuario(vCelular : String);
procedure DownloadUsuarioId(fIdUsu: Integer);
function KeyboradShowing:boolean;
procedure KeyboradHide;
procedure KeyboradShow(const AControl: TFmxObject);
procedure RegistrarDispositivo(ADeviceToken : String; AIdUsu: Integer);
procedure ConsultaCep(ACep : String);
procedure getControle;
procedure getAvaliacaoCompleta(AIdAvaliacao : Integer);
procedure getAnuncios(AIdCom : Integer);
{ Public declarations }
end;
var
dmGeral: TdmGeral;
implementation
{%CLASSGROUP 'FMX.Controls.TControl'}
uses untGlobal;
{$R *.dfm}
procedure TdmGeral.ConsultaCep(ACep : String);
begin
memCep.Close;
restCEP.Params.ParameterByName('pCEP').Value := ACep;
restCEP.Execute;
end;
function TdmGeral.KeyboradShowing:boolean; // teclado visivel ou não
{ uses FMX.VirtualKeyboard }
var
Keyboard: IFMXVirtualKeyboardService;
begin
TPlatformServices.Current.SupportsPlatformService(IFMXVirtualKeyboardService,
IInterface(Keyboard));
if (Keyboard <> nil) then
result:= TVirtualKeyBoardState.Visible in Keyboard.GetVirtualKeyBoardState;
end;
procedure TdmGeral.DownloadIdUsuario(vCelular: String);
var
DownloadIdUsuario : TFDJSONDataSets;
begin
//memUsuarios := TFDMemTable.Create(nil);
DownloadIdUsuario := cm.ServerMethodsClient.DownloadIdUsuario(vCelular);
Assert(TFDJSONDataSetsReader.GetListCount(DownloadIdUsuario) = 1);
memUsuarios.Active := False;
memUsuarios.AppendData(TFDJSONDataSetsReader.GetListValue(DownloadIdUsuario, 0));
memUsuarios.Active := True;
end;
procedure TdmGeral.DownloadUsuario(vCelular: String);
var
DownloadUsuario : TFDJSONDataSets;
begin
//memUsuarios := TFDMemTable.Create(nil);
DownloadUsuario := cm.ServerMethodsClient.DownloadUsuario(vCelular);
Assert(TFDJSONDataSetsReader.GetListCount(DownloadUsuario) = 1);
memUsuarios.Active := False;
memUsuarios.AppendData(TFDJSONDataSetsReader.GetListValue(DownloadUsuario, 0));
memUsuarios.Active := True;
end;
procedure TdmGeral.DownloadUsuarioId(fIdUsu: Integer);
var
DownloadUsuarioId : TFDJSONDataSets;
begin
memUsuarios := TFDMemTable.Create(nil);
DownloadUsuarioId := cm.ServerMethodsClient.DownloadUsuarioId(fIdUsu);
Assert(TFDJSONDataSetsReader.GetListCount(DownloadUsuarioId) = 1);
memUsuarios.Active := False;
memUsuarios.AppendData(TFDJSONDataSetsReader.GetListValue(DownloadUsuarioId, 0));
memUsuarios.Active := True;
end;
procedure TdmGeral.getAnuncios(AIdCom: Integer);
var
dsAnuncios : TFDJSONDataSets;
begin
//memAnuncios := TFDMemTable.Create(nil);
dsAnuncios := cm.ServerMethodsClient.getAnuncios(AIdCom);
Assert(TFDJSONDataSetsReader.GetListCount(dsAnuncios) = 1);
memAnuncios.Active := False;
memAnuncios.AppendData(TFDJSONDataSetsReader.GetListValue(dsAnuncios, 0));
memAnuncios.Active := True;
end;
procedure TdmGeral.getAvaliacaoCompleta(AIdAvaliacao: Integer);
var
dsAvaliacoes : TFDJSONDataSets;
begin
//memAuxiliar := TFDMemTable.Create(nil);
dsAvaliacoes := cm.ServerMethodsClient.getAvaliacaoCompleta(AIdAvaliacao);
Assert(TFDJSONDataSetsReader.GetListCount(dsAvaliacoes) = 1);
memAuxiliar.Active := False;
memAuxiliar.AppendData(TFDJSONDataSetsReader.GetListValue(dsAvaliacoes, 0));
memAuxiliar.Active := True;
end;
procedure TdmGeral.getControle;
var
dsControle : TFDJSONDataSets;
begin
//memControle := TFDMemTable.Create(nil);
dsControle := cm.ServerMethodsClient.getControle;
Assert(TFDJSONDataSetsReader.GetListCount(dsControle) = 1);
memControle.Active := False;
memControle.AppendData(TFDJSONDataSetsReader.GetListValue(dsControle, 0));
memControle.Active := True;
end;
procedure TdmGeral.KeyboradHide; // esconde teclado
{ uses FMX.VirtualKeyboard }
var
Keyboard: IFMXVirtualKeyboardService;
begin
TPlatformServices.Current.SupportsPlatformService(IFMXVirtualKeyboardService,
IInterface(Keyboard));
if (Keyboard <> nil) then
Keyboard.HideVirtualKeyboard;
end;
procedure TdmGeral.KeyboradShow(const AControl: TFmxObject); // mostra teclado
{ uses FMX.VirtualKeyboard }
var
Keyboard: IFMXVirtualKeyboardService;
begin
TPlatformServices.Current.SupportsPlatformService(IFMXVirtualKeyboardService,
IInterface(Keyboard));
if (Keyboard <> nil) then
Keyboard.ShowVirtualKeyboard(AControl);
end;
procedure TdmGeral.LoadAvaliacoes(idComercio, nStart: Integer);
var
dsAvaliacoes : TFDJSONDataSets;
begin
//memAvaliacoes := TFDMemTable.Create(nil);
dsAvaliacoes := cm.ServerMethodsClient.LoadAvaliacoes(idComercio, nStart);
Assert(TFDJSONDataSetsReader.GetListCount(dsAvaliacoes) = 1);
memAvaliacoes.Active := False;
memAvaliacoes.AppendData(TFDJSONDataSetsReader.GetListValue(dsAvaliacoes, 0));
memAvaliacoes.Active := True;
end;
procedure TdmGeral.LoadCategorias(AIdPush : String);
var
dsCategorias : TFDJSONDataSets;
begin
//memCategorias := TFDMemTable.Create(nil);
dsCategorias := cm.ServerMethodsClient.LoadCategorias(AIdPush, gRaio);
Assert(TFDJSONDataSetsReader.GetListCount(dsCategorias) = 1);
memCategorias.Active := False;
memCategorias.AppendData(TFDJSONDataSetsReader.GetListValue(dsCategorias, 0));
memCategorias.Active := True;
end;
procedure TdmGeral.LoadComercio(idComercio: Integer);
var
dsComercio,
dsFotosComercio,
dsCheckList,
dsFone : TFDJSONDataSets;
begin
//memComercio := TFDMemTable.Create(nil);
dsComercio := cm.ServerMethodsClient.LoadComercio(idComercio);
memComercio.Active := False;
memComercio.AppendData(TFDJSONDataSetsReader.GetListValue(dsComercio, 0));
memComercio.Active := True;
//memFotosComercio := TFDMemTable.Create(nil);
dsFotosComercio := cm.ServerMethodsClient.LoadComercio(idComercio);
memFotosComercio.Active := False;
memFotosComercio.AppendData(TFDJSONDataSetsReader.GetListValue(dsFotosComercio, 1));
memFotosComercio.Active := True;
//memCheckList := TFDMemTable.Create(nil);
dsCheckList := cm.ServerMethodsClient.LoadComercio(idComercio);
memCheckList.Active := False;
memCheckList.AppendData(TFDJSONDataSetsReader.GetListValue(dsCheckList, 2));
memCheckList.Active := True;
//memTelefones := TFDMemTable.Create(nil);
dsFone := cm.ServerMethodsClient.LoadComercio(idComercio);
memTelefones.Active := False;
memTelefones.AppendData(TFDJSONDataSetsReader.GetListValue(dsFone, 3));
memTelefones.Active := True;
end;
procedure TdmGeral.LoadComercioCategoria(AIdPush : String; IdCategoria, IdSubCategoria : Integer);
var
dsComCategoria : TFDJSONDataSets;
begin
//memComCategorias := TFDMemTable.Create(nil);
dsComCategoria := cm.ServerMethodsClient.LoadComercioCategoria(AIdPush, gRaio, IdCategoria, IdSubCategoria);
Assert(TFDJSONDataSetsReader.GetListCount(dsComCategoria) = 1);
memComCategorias.Active := False;
memComCategorias.AppendData(TFDJSONDataSetsReader.GetListValue(dsComCategoria, 0));
memComCategorias.Active := True;
end;
procedure TdmGeral.LoadComercioPesquisa(AIdPush, FPesquisa : String);
var
dsComercio : TFDJSONDataSets;
begin
//memComCategorias := TFDMemTable.Create(nil);
dsComercio := cm.ServerMethodsClient.LoadComercioPesquisa(gRaio, FPesquisa, AIdPush);
Assert(TFDJSONDataSetsReader.GetListCount(dsComercio) = 1);
memComCategorias.Active := False;
memComCategorias.AppendData(TFDJSONDataSetsReader.GetListValue(dsComercio, 0));
memComCategorias.Active := True;
end;
procedure TdmGeral.LoadDestaquePrincipal(AIdPush : String);
var
dsContrato : TFDJSONDataSets;
begin
//memContrato := TFDMemTable.Create(nil);
dsContrato := cm.ServerMethodsClient.LoadDestaquePrincipal(AIdPush, gRaio);
Assert(TFDJSONDataSetsReader.GetListCount(dsContrato) = 1);
memContrato.Active := False;
memContrato.AppendData(TFDJSONDataSetsReader.GetListValue(dsContrato, 0));
memContrato.Active := True;
end;
procedure TdmGeral.LoadDestaqueFavorito(AIdPush : String; vIdUsu : Integer);
var
dsDestaque : TFDJSONDataSets;
begin
//memDestaques := TFDMemTable.Create(nil);
dsDestaque := cm.ServerMethodsClient.LoadDestaqueFavorito(AIdPush, gRaio, vIdUsu);
Assert(TFDJSONDataSetsReader.GetListCount(dsDestaque)=1);
memDestaques.Active := False;
memDestaques.AppendData(TFDJSONDataSetsReader.GetListValue(dsDestaque, 0));
memDestaques.Active := True;
end;
function TdmGeral.getNotificacoes(AIdUsu : Integer) : TFDJSONDataSets;
var
dsNotificacao : TFDJSONDataSets;
begin
dsNotificacao := cm.ServerMethodsClient.getNotificacoes(AIdUsu);
Assert(TFDJSONDataSetsReader.GetListCount(dsNotificacao)=1);
memNotificacao.Active := False;
memNotificacao.AppendData(TFDJSONDataSetsReader.GetListValue(dsNotificacao, 0));
memNotificacao.Active := True;
end;
procedure TdmGeral.LoadFotosPorSecao(vIdCat: Integer; APesquisa, AIdPush : String);
var
dsFotosPorSecao : TFDJSONDataSets;
begin
//memFotosPorSecao := TFDMemTable.Create(nil);
dsFotosPorSecao := cm.ServerMethodsClient.LoadFotosPorSecao(gRaio,vIdCat, APesquisa, AIdPush);
Assert(TFDJSONDataSetsReader.GetListCount(dsFotosPorSecao) = 1);
memFotosPorSecao.Active := False;
memFotosPorSecao.AppendData(TFDJSONDataSetsReader.GetListValue(dsFotosPorSecao, 0));
memFotosPorSecao.Active := True;
end;
procedure TdmGeral.LoadSubCategoria(AIdPush : String; IdCategoria: Integer);
var
dsSubCategoria : TFDJSONDataSets;
begin
//memSubCategorias := TFDMemTable.Create(nil);
dsSubCategoria := cm.ServerMethodsClient.LoadSubCategoria(AIdPush, gRaio,idCategoria);
Assert(TFDJSONDataSetsReader.GetListCount(dsSubCategoria) = 1);
memSubCategorias.Active := False;
memSubCategorias.AppendData(TFDJSONDataSetsReader.GetListValue(dsSubCategoria, 0));
memSubCategorias.Active := True;
end;
procedure TdmGeral.RegistrarDispositivo(ADeviceToken: String; AIdUsu: Integer);
begin
cm.ServerMethodsClient.RegistrarDispositivo(ADeviceToken, AIdUsu);
end;
function TdmGeral.CelularDuplicado(vCelular: String) : Boolean;
var
dsCelularUsuario : TFDJSONDataSets;
begin
//memCelularUsuario := TFDMemTable.Create(nil);
dsCelularUsuario := cm.ServerMethodsClient.VerificaCelularDuplicado(vCelular);
Assert(TFDJSONDataSetsReader.GetListCount(dsCelularUsuario) = 1);
memCelularUsuario.Active := False;
memCelularUsuario.AppendData(TFDJSONDataSetsReader.GetListValue(dsCelularUsuario, 0));
memCelularUsuario.Active := True;
memCelularUsuario.First;
if memCelularUsuario.RecordCount > 0 then
Result := True else Result := False;
end;
end.
|
{ ****************************************************************************** }
{ * geometry 3D Advance library writen by QQ 600585@qq.com * }
{ * https://zpascal.net * }
{ * https://github.com/PassByYou888/zAI * }
{ * https://github.com/PassByYou888/ZServer4D * }
{ * https://github.com/PassByYou888/PascalString * }
{ * https://github.com/PassByYou888/zRasterization * }
{ * https://github.com/PassByYou888/CoreCipher * }
{ * https://github.com/PassByYou888/zSound * }
{ * https://github.com/PassByYou888/zChinese * }
{ * https://github.com/PassByYou888/zExpression * }
{ * https://github.com/PassByYou888/zGameWare * }
{ * https://github.com/PassByYou888/zAnalysis * }
{ * https://github.com/PassByYou888/FFMPEG-Header * }
{ * https://github.com/PassByYou888/zTranslate * }
{ * https://github.com/PassByYou888/InfiniteIoT * }
{ * https://github.com/PassByYou888/FastMD5 * }
{ ****************************************************************************** }
unit Geometry3DUnit;
{$DEFINE FPC_DELPHI_MODE}
{$INCLUDE zDefine.inc}
interface
uses Types, CoreClasses,
GeometryLib, Geometry2DUnit, PascalStrings, UnicodeMixedLib;
type
TMat4 = TMatrix;
TVec4 = TVector;
TVec3 = TAffineVector;
TMatrix4 = record
Buff: TMat4;
public
class operator Equal(const Lhs, Rhs: TMatrix4): Boolean;
class operator NotEqual(const Lhs, Rhs: TMatrix4): Boolean;
class operator Multiply(const Lhs, Rhs: TMatrix4): TMatrix4;
class operator Implicit(Value: TGeoFloat): TMatrix4;
class operator Implicit(Value: TMat4): TMatrix4;
function Swap: TMatrix4;
function Lerp(M: TMatrix4; Delta: TGeoFloat): TMatrix4;
function AffineMatrix: TAffineMatrix;
function Invert: TMatrix4;
function Translate(v: TVec3): TMatrix4;
function Normalize: TMatrix4;
function Transpose: TMatrix4;
function AnglePreservingInvert: TMatrix4;
function Determinant: TGeoFloat;
function Adjoint: TMatrix4;
function Pitch(angle: TGeoFloat): TMatrix4;
function Roll(angle: TGeoFloat): TMatrix4;
function Turn(angle: TGeoFloat): TMatrix4;
end;
TVector4 = record
Buff: TVec4;
private
function GetVec3: TVec3;
procedure SetVec3(const Value: TVec3);
function GetVec2: TVec2;
procedure SetVec2(const Value: TVec2);
function GetLinkValue(index: Integer): TGeoFloat;
procedure SetLinkValue(index: Integer; const Value: TGeoFloat);
public
property Vec2: TVec2 read GetVec2 write SetVec2;
property Vec3: TVec3 read GetVec3 write SetVec3;
property XYZ: TVec3 read GetVec3 write SetVec3;
property RGB: TVec3 read GetVec3 write SetVec3;
property Vec4: TVec4 read Buff write Buff;
property RGBA: TVec4 read Buff write Buff;
property COLOR: TVec4 read Buff write Buff;
property LinkValue[index: Integer]: TGeoFloat read GetLinkValue write SetLinkValue; default;
class operator Equal(const Lhs, Rhs: TVector4): Boolean;
class operator NotEqual(const Lhs, Rhs: TVector4): Boolean;
class operator GreaterThan(const Lhs, Rhs: TVector4): Boolean;
class operator GreaterThanOrEqual(const Lhs, Rhs: TVector4): Boolean;
class operator LessThan(const Lhs, Rhs: TVector4): Boolean;
class operator LessThanOrEqual(const Lhs, Rhs: TVector4): Boolean;
class operator Add(const Lhs, Rhs: TVector4): TVector4;
class operator Add(const Lhs: TVector4; const Rhs: TGeoFloat): TVector4;
class operator Add(const Lhs: TGeoFloat; const Rhs: TVector4): TVector4;
class operator Subtract(const Lhs, Rhs: TVector4): TVector4;
class operator Subtract(const Lhs: TVector4; const Rhs: TGeoFloat): TVector4;
class operator Subtract(const Lhs: TGeoFloat; const Rhs: TVector4): TVector4;
class operator Multiply(const Lhs, Rhs: TVector4): TVector4;
class operator Multiply(const Lhs: TVector4; const Rhs: TGeoFloat): TVector4;
class operator Multiply(const Lhs: TGeoFloat; const Rhs: TVector4): TVector4;
class operator Multiply(const Lhs: TVector4; const Rhs: TMatrix4): TVector4;
class operator Multiply(const Lhs: TMatrix4; const Rhs: TVector4): TVector4;
class operator Multiply(const Lhs: TVector4; const Rhs: TMat4): TVector4;
class operator Multiply(const Lhs: TMat4; const Rhs: TVector4): TVector4;
class operator Multiply(const Lhs: TVector4; const Rhs: TAffineMatrix): TVector4;
class operator Multiply(const Lhs: TAffineMatrix; const Rhs: TVector4): TVector4;
class operator Divide(const Lhs, Rhs: TVector4): TVector4;
class operator Divide(const Lhs: TVector4; const Rhs: TGeoFloat): TVector4;
class operator Divide(const Lhs: TGeoFloat; const Rhs: TVector4): TVector4;
class operator Implicit(Value: TGeoFloat): TVector4;
class operator Implicit(Value: TVec4): TVector4;
class operator Implicit(Value: TVec3): TVector4;
class operator Implicit(Value: TVec2): TVector4;
class operator Explicit(Value: TVector4): TVec4;
class operator Explicit(Value: TVector4): TVec3;
class operator Explicit(Value: TVector4): TVec2;
procedure SetRGBA(const r, g, b, a: TGeoFloat); overload;
procedure SetLocation(const fx, fy, fz, fw: TGeoFloat); overload;
procedure SetLocation(const fx, fy, fz: TGeoFloat); overload;
function Distance4D(const v2: TVector4): TGeoFloat;
function Distance3D(const v2: TVector4): TGeoFloat;
function Distance2D(const v2: TVector4): TGeoFloat;
function Lerp(const v2: TVector4; const t: TGeoFloat): TVector4;
function LerpDistance(const v2: TVector4; const d: TGeoFloat): TVector4;
function Norm: TGeoFloat;
function length: TGeoFloat;
function Normalize: TVector4;
function Cross(const v2: TVector4): TVector4; overload;
function Cross(const v2: TVec3): TVector4; overload;
function Cross(const v2: TVec4): TVector4; overload;
end;
TVector3 = record
Buff: TVec3;
private
function GetVec2: TVec2;
procedure SetVec2(const Value: TVec2);
function GetLinkValue(index: Integer): TGeoFloat;
procedure SetLinkValue(index: Integer; const Value: TGeoFloat);
public
property Vec2: TVec2 read GetVec2 write SetVec2;
property Vec3: TVec3 read Buff write Buff;
property XYZ: TVec3 read Buff write Buff;
property COLOR: TVec3 read Buff write Buff;
property RGB: TVec3 read Buff write Buff;
property LinkValue[index: Integer]: TGeoFloat read GetLinkValue write SetLinkValue; default;
class operator Equal(const Lhs, Rhs: TVector3): Boolean;
class operator NotEqual(const Lhs, Rhs: TVector3): Boolean;
class operator GreaterThan(const Lhs, Rhs: TVector3): Boolean;
class operator GreaterThanOrEqual(const Lhs, Rhs: TVector3): Boolean;
class operator LessThan(const Lhs, Rhs: TVector3): Boolean;
class operator LessThanOrEqual(const Lhs, Rhs: TVector3): Boolean;
class operator Add(const Lhs, Rhs: TVector3): TVector3;
class operator Add(const Lhs: TVector3; const Rhs: TGeoFloat): TVector3;
class operator Add(const Lhs: TGeoFloat; const Rhs: TVector3): TVector3;
class operator Subtract(const Lhs, Rhs: TVector3): TVector3;
class operator Subtract(const Lhs: TVector3; const Rhs: TGeoFloat): TVector3;
class operator Subtract(const Lhs: TGeoFloat; const Rhs: TVector3): TVector3;
class operator Multiply(const Lhs, Rhs: TVector3): TVector3;
class operator Multiply(const Lhs: TVector3; const Rhs: TGeoFloat): TVector3;
class operator Multiply(const Lhs: TGeoFloat; const Rhs: TVector3): TVector3;
class operator Multiply(const Lhs: TVector3; const Rhs: TMatrix4): TVector3;
class operator Multiply(const Lhs: TMatrix4; const Rhs: TVector3): TVector3;
class operator Multiply(const Lhs: TVector3; const Rhs: TMat4): TVector3;
class operator Multiply(const Lhs: TMat4; const Rhs: TVector3): TVector3;
class operator Multiply(const Lhs: TVector3; const Rhs: TAffineMatrix): TVector3;
class operator Multiply(const Lhs: TAffineMatrix; const Rhs: TVector3): TVector3;
class operator Divide(const Lhs, Rhs: TVector3): TVector3;
class operator Divide(const Lhs: TVector3; const Rhs: TGeoFloat): TVector3;
class operator Divide(const Lhs: TGeoFloat; const Rhs: TVector3): TVector3;
class operator Implicit(Value: TGeoFloat): TVector3;
class operator Implicit(Value: TVec4): TVector3;
class operator Implicit(Value: TVec3): TVector3;
class operator Implicit(Value: TVec2): TVector3;
class operator Explicit(Value: TVector3): TVec4;
class operator Explicit(Value: TVector3): TVec3;
class operator Explicit(Value: TVector3): TVec2;
procedure SetLocation(const fx, fy, fz: TGeoFloat); overload;
function Distance3D(const v2: TVector3): TGeoFloat;
function Distance2D(const v2: TVector3): TGeoFloat;
function Lerp(const v2: TVector3; const t: TGeoFloat): TVector3;
function LerpDistance(const v2: TVector3; const d: TGeoFloat): TVector3;
function Norm: TGeoFloat;
function length: TGeoFloat;
function Normalize: TVector3;
function Cross(const v2: TVector3): TVector3;
function Vec4(fw: TGeoFloat): TVector4; overload;
function Vec4: TVector4; overload;
end;
TAABB = record
Min, Max: TAffineVector;
public
{ : Resize the AABB if necessary to include p. }
procedure Include(const p: TVector3);
{ : Make an AABB that is formed by sweeping a sphere (or AABB) from Start to Dest }
procedure FromSweep(const Start, dest: TVector3; const radius: TGeoFloat);
{ : Returns the intersection AABB of two AABBs.<p>
If the AABBs don't intersect, will return a degenerated AABB (plane, line or point). }
function Intersection(const aabb2: TAABB): TAABB;
{ : Adds delta to min and max of the AABB. }
procedure Offset(const Delta: TVector3);
{ : Checks if a point "p" is inside an AABB }
function PointIn(const p: TVector3): Boolean;
end;
TVector2 = record
Buff: TVec2;
private
function GetLinkValue(index: Integer): TGeoFloat;
procedure SetLinkValue(index: Integer; const Value: TGeoFloat);
public
property LinkValue[index: Integer]: TGeoFloat read GetLinkValue write SetLinkValue; default;
class operator Equal(const Lhs, Rhs: TVector2): Boolean;
class operator NotEqual(const Lhs, Rhs: TVector2): Boolean;
class operator GreaterThan(const Lhs, Rhs: TVector2): Boolean;
class operator GreaterThanOrEqual(const Lhs, Rhs: TVector2): Boolean;
class operator LessThan(const Lhs, Rhs: TVector2): Boolean;
class operator LessThanOrEqual(const Lhs, Rhs: TVector2): Boolean;
class operator Add(const Lhs, Rhs: TVector2): TVector2;
class operator Add(const Lhs: TVector2; const Rhs: TGeoFloat): TVector2;
class operator Add(const Lhs: TGeoFloat; const Rhs: TVector2): TVector2;
class operator Subtract(const Lhs, Rhs: TVector2): TVector2;
class operator Subtract(const Lhs: TVector2; const Rhs: TGeoFloat): TVector2;
class operator Subtract(const Lhs: TGeoFloat; const Rhs: TVector2): TVector2;
class operator Multiply(const Lhs, Rhs: TVector2): TVector2;
class operator Multiply(const Lhs: TVector2; const Rhs: TGeoFloat): TVector2;
class operator Multiply(const Lhs: TGeoFloat; const Rhs: TVector2): TVector2;
class operator Divide(const Lhs, Rhs: TVector2): TVector2;
class operator Divide(const Lhs: TVector2; const Rhs: TGeoFloat): TVector2;
class operator Divide(const Lhs: TGeoFloat; const Rhs: TVector2): TVector2;
class operator Implicit(Value: TGeoFloat): TVector2;
class operator Implicit(Value: TPoint): TVector2;
class operator Implicit(Value: TPointf): TVector2;
class operator Implicit(Value: TVec2): TVector2;
class operator Explicit(Value: TVector2): TPointf;
class operator Explicit(Value: TVector2): TPoint;
class operator Explicit(Value: TVector2): TVec2;
procedure SetLocation(const fx, fy: TGeoFloat); overload;
function Distance(const v2: TVector2): TGeoFloat;
function Lerp(const v2: TVector2; const t: TGeoFloat): TVector2;
function LerpDistance(const v2: TVector2; const d: TGeoFloat): TVector2;
function Norm: TGeoFloat;
function length: TGeoFloat;
function Normalize: TVector2;
end;
function Vector4(x, y, z, w: TGeoFloat): TVector4; overload;
function Vector4(x, y, z: TGeoFloat): TVector4; overload;
function Vector4(v: TVec3): TVector4; overload;
function Vector4(v: TVec4): TVector4; overload;
function Vector3(x, y, z: TGeoFloat): TVector3; overload;
function Vector3(v: TVec3): TVector3; overload;
function Vector3(v: TVec4): TVector3; overload;
function Vec3(const x, y, z: TGeoFloat): TVec3; overload;
function Vec3(const v: TVec4): TVec3; overload;
function Vec3(const v: TVector3): TVec3; overload;
function Vec3(const v: TVector2): TVec3; overload;
function Vec3(const v: TVector2; z: TGeoFloat): TVec3; overload;
function Vec4(const x, y, z: TGeoFloat): TVec4; overload;
function Vec4(const x, y, z, w: TGeoFloat): TVec4; overload;
function Vec4(const v: TVec3): TVec4; overload;
function Vec4(const v: TVec3; const z: TGeoFloat): TVec4; overload;
function Vec4(const v: TVector3): TVec4; overload;
function Vec2(const v: TVec3): TVector2; overload;
function Vec2(const v: TVec4): TVector2; overload;
function Vec2(const v: TVector3): TVector2; overload;
function Vec2(const v: TVector4): TVector2; overload;
function VecToStr(const v: TVec2): SystemString; overload;
function VecToStr(const v: TVector2): SystemString; overload;
function VecToStr(const v: TArrayVec2): SystemString; overload;
function VecToStr(const v: TVec3): SystemString; overload;
function VecToStr(const v: TVec4): SystemString; overload;
function VecToStr(const v: TVector3): SystemString; overload;
function VecToStr(const v: TVector4): SystemString; overload;
function RectToStr(const v: TRectV2): SystemString; overload;
function RectToStr(const v: TRect): SystemString; overload;
function StrToVec2(const s: SystemString): TVec2;
function StrToVector2(const s: SystemString): TVector2;
function StrToArrayVec2(const s: SystemString): TArrayVec2;
function StrToVec3(const s: SystemString): TVec3;
function StrToVec4(const s: SystemString): TVec4;
function StrToVector3(const s: SystemString): TVector3;
function StrToVector4(const s: SystemString): TVector4;
function StrToRect(const s: SystemString): TRect;
function StrToRectV2(const s: SystemString): TRectV2;
function GetMin(const arry: array of TGeoFloat): TGeoFloat; overload;
function GetMin(const arry: array of Integer): Integer; overload;
function GetMax(const arry: array of TGeoFloat): TGeoFloat; overload;
function GetMax(const arry: array of Integer): Integer; overload;
function FinalAngle4FMX(const a: TGeoFloat): TGeoFloat;
function CalcAngle(const v1, v2: TVec2): TGeoFloat;
function AngleDistance(const sour, dest: TGeoFloat): TGeoFloat;
function SmoothAngle(const sour, dest, Delta: TGeoFloat): TGeoFloat;
function AngleEqual(const a1, a2: TGeoFloat): Boolean;
function Distance(const v1, v2: TVec2): TGeoFloat; overload;
function Distance(const v1, v2: TRectV2): TGeoFloat; overload;
function MovementLerp(const s, d, Lerp: TGeoFloat): TGeoFloat; overload;
function MovementLerp(const s, d: TVec2; Lerp: TGeoFloat): TVec2; overload;
function MovementLerp(const s, d: TRectV2; Lerp: TGeoFloat): TRectV2; overload;
function MovementDistance(const s, d: TVec2; dt: TGeoFloat): TVec2; overload;
function MovementDistance(const s, d: TRectV2; dt: TGeoFloat): TRectV2; overload;
function MovementDistance(const sour, dest: TVector4; Distance: TGeoFloat): TVector4; overload;
function MovementDistance(const sour, dest: TVector3; Distance: TGeoFloat): TVector3; overload;
function MovementDistanceDeltaTime(const s, d: TVec2; Speed_: TGeoFloat): Double; overload;
function MovementDistanceDeltaTime(const s, d: TRectV2; Speed_: TGeoFloat): Double; overload;
function AngleRollDistanceDeltaTime(const s, d: TGeoFloat; ARollSpeed: TGeoFloat): Double; overload;
function BounceVector(const Current: TVector4; DeltaDistance: TGeoFloat; const BeginVector, EndVector: TVector4; var EndFlag: Boolean): TVector4; overload;
function BounceVector(const Current: TVector3; DeltaDistance: TGeoFloat; const BeginVector, EndVector: TVector3; var EndFlag: Boolean): TVector3; overload;
function BounceVector(const Current: TVector2; DeltaDistance: TGeoFloat; const BeginVector, EndVector: TVector2; var EndFlag: Boolean): TVector2; overload;
function BounceFloat(const CurrentVal, DeltaVal, StartVal, OverVal: TGeoFloat; var EndFlag: Boolean): TGeoFloat; overload;
implementation
function Vector4(x, y, z, w: TGeoFloat): TVector4;
begin
Result.Buff[0] := x;
Result.Buff[1] := y;
Result.Buff[2] := z;
Result.Buff[3] := w;
end;
function Vector4(x, y, z: TGeoFloat): TVector4;
begin
Result.Buff[0] := x;
Result.Buff[1] := y;
Result.Buff[2] := z;
Result.Buff[3] := 0;
end;
function Vector4(v: TVec3): TVector4;
begin
Result.Buff[0] := v[0];
Result.Buff[1] := v[1];
Result.Buff[2] := v[2];
Result.Buff[3] := 0;
end;
function Vector4(v: TVec4): TVector4;
begin
Result.Buff := v;
end;
function Vector3(x, y, z: TGeoFloat): TVector3;
begin
Result.Buff[0] := x;
Result.Buff[1] := y;
Result.Buff[2] := z;
end;
function Vector3(v: TVec3): TVector3;
begin
Result.Buff := v;
end;
function Vector3(v: TVec4): TVector3;
begin
Result.Buff[0] := v[0];
Result.Buff[1] := v[1];
Result.Buff[2] := v[2];
end;
function Vec3(const x, y, z: TGeoFloat): TVec3;
begin
Result := AffineVectorMake(x, y, z);
end;
function Vec3(const v: TVec4): TVec3;
begin
Result[0] := v[0];
Result[1] := v[1];
Result[2] := v[2];
end;
function Vec3(const v: TVector3): TVec3;
begin
Result := v.Buff;
end;
function Vec3(const v: TVector2): TVec3;
begin
Result[0] := v[0];
Result[1] := v[1];
Result[2] := 0;
end;
function Vec3(const v: TVector2; z: TGeoFloat): TVec3;
begin
Result[0] := v[0];
Result[1] := v[1];
Result[2] := z;
end;
function Vec4(const x, y, z: TGeoFloat): TVec4;
begin
Result := VectorMake(x, y, z, 0);
end;
function Vec4(const x, y, z, w: TGeoFloat): TVec4;
begin
Result := VectorMake(x, y, z, w);
end;
function Vec4(const v: TVec3): TVec4;
begin
Result := VectorMake(v);
end;
function Vec4(const v: TVec3; const z: TGeoFloat): TVec4;
begin
Result := VectorMake(v, z);
end;
function Vec4(const v: TVector3): TVec4;
begin
Result := VectorMake(v.Buff);
end;
function Vec2(const v: TVec3): TVector2;
begin
Result := Vec2(v[0], v[1]);
end;
function Vec2(const v: TVec4): TVector2;
begin
Result := Vec2(v[0], v[1]);
end;
function Vec2(const v: TVector3): TVector2;
begin
Result[0] := v.Buff[0];
Result[1] := v.Buff[1];
end;
function Vec2(const v: TVector4): TVector2;
begin
Result[0] := v.Buff[0];
Result[1] := v.Buff[1];
end;
function VecToStr(const v: TVec2): SystemString;
begin
Result := PFormat('%g,%g', [v[0], v[1]]);
end;
function VecToStr(const v: TVector2): SystemString;
begin
Result := PFormat('%g,%g', [v[0], v[1]]);
end;
function VecToStr(const v: TArrayVec2): SystemString;
var
i: Integer;
begin
Result := '';
for i := low(v) to high(v) do
Result := Result + if_(i <> low(v), ',', '') + PFormat('%g,%g', [v[i, 0], v[i, 1]]);
end;
function VecToStr(const v: TVec3): SystemString;
begin
Result := PFormat('%g,%g,%g', [v[0], v[1], v[2]]);
end;
function VecToStr(const v: TVec4): SystemString;
begin
Result := PFormat('%g,%g,%g,%g', [v[0], v[1], v[2], v[3]]);
end;
function VecToStr(const v: TVector3): SystemString;
begin
Result := VecToStr(v.Buff);
end;
function VecToStr(const v: TVector4): SystemString;
begin
Result := VecToStr(v.Buff);
end;
function RectToStr(const v: TRectV2): SystemString;
begin
Result := PFormat('%g,%g,%g,%g', [v[0][0], v[0][1], v[1][0], v[1][1]]);
end;
function RectToStr(const v: TRect): SystemString;
begin
Result := PFormat('%d,%d,%d,%d', [v.Left, v.Top, v.Right, v.Bottom]);
end;
function StrToVec2(const s: SystemString): TVec2;
var
v, v1, v2: U_String;
begin
v := umlTrimSpace(s);
v1 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v2 := umlGetFirstStr(v, ',: ');
Result[0] := umlStrToFloat(v1, 0);
Result[1] := umlStrToFloat(v2, 0);
end;
function StrToVector2(const s: SystemString): TVector2;
var
v, v1, v2: U_String;
begin
v := umlTrimSpace(s);
v1 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v2 := umlGetFirstStr(v, ',: ');
Result[0] := umlStrToFloat(v1, 0);
Result[1] := umlStrToFloat(v2, 0);
end;
function StrToArrayVec2(const s: SystemString): TArrayVec2;
var
n, v1, v2: U_String;
L: TVec2List;
begin
L := TVec2List.Create;
n := umlTrimSpace(s);
while n.L > 0 do
begin
v1 := umlGetFirstStr(n, ',: ');
n := umlDeleteFirstStr(n, ',: ');
v2 := umlGetFirstStr(n, ',: ');
n := umlDeleteFirstStr(n, ',: ');
L.Add(umlStrToFloat(v1, 0), umlStrToFloat(v2, 0));
end;
Result := L.BuildArray();
DisposeObject(L);
end;
function StrToVec3(const s: SystemString): TVec3;
var
v, v1, v2, v3: U_String;
begin
v := umlTrimSpace(s);
v1 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v2 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v3 := umlGetFirstStr(v, ',: ');
Result[0] := umlStrToFloat(v1, 0);
Result[1] := umlStrToFloat(v2, 0);
Result[2] := umlStrToFloat(v3, 0);
end;
function StrToVec4(const s: SystemString): TVec4;
var
v, v1, v2, v3, v4: U_String;
begin
v := umlTrimSpace(s);
v1 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v2 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v3 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v4 := umlGetFirstStr(v, ',: ');
Result[0] := umlStrToFloat(v1, 0);
Result[1] := umlStrToFloat(v2, 0);
Result[2] := umlStrToFloat(v3, 0);
Result[3] := umlStrToFloat(v4, 0);
end;
function StrToVector3(const s: SystemString): TVector3;
var
v, v1, v2, v3: U_String;
begin
v := umlTrimSpace(s);
v1 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v2 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v3 := umlGetFirstStr(v, ',: ');
Result.Buff[0] := umlStrToFloat(v1, 0);
Result.Buff[1] := umlStrToFloat(v2, 0);
Result.Buff[2] := umlStrToFloat(v3, 0);
end;
function StrToVector4(const s: SystemString): TVector4;
var
v, v1, v2, v3, v4: U_String;
begin
v := umlTrimSpace(s);
v1 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v2 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v3 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v4 := umlGetFirstStr(v, ',: ');
Result.Buff[0] := umlStrToFloat(v1, 0);
Result.Buff[1] := umlStrToFloat(v2, 0);
Result.Buff[2] := umlStrToFloat(v3, 0);
Result.Buff[3] := umlStrToFloat(v4, 0);
end;
function StrToRect(const s: SystemString): TRect;
begin
Result := Rect2Rect(StrToRectV2(s));
end;
function StrToRectV2(const s: SystemString): TRectV2;
var
v, v1, v2, v3, v4: U_String;
begin
v := umlTrimSpace(s);
v1 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v2 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v3 := umlGetFirstStr(v, ',: ');
v := umlDeleteFirstStr(v, ',: ');
v4 := umlGetFirstStr(v, ',: ');
Result[0][0] := umlStrToFloat(v1, 0);
Result[0][1] := umlStrToFloat(v2, 0);
Result[1][0] := umlStrToFloat(v3, 0);
Result[1][1] := umlStrToFloat(v4, 0);
end;
function GetMin(const arry: array of TGeoFloat): TGeoFloat;
var
i: Integer;
begin
Result := arry[low(arry)];
for i := low(arry) + 1 to high(arry) do
if Result > arry[i] then
Result := arry[i];
end;
function GetMin(const arry: array of Integer): Integer;
var
i: Integer;
begin
Result := arry[low(arry)];
for i := low(arry) + 1 to high(arry) do
if Result > arry[i] then
Result := arry[i];
end;
function GetMax(const arry: array of TGeoFloat): TGeoFloat;
var
i: Integer;
begin
Result := arry[low(arry)];
for i := low(arry) + 1 to high(arry) do
if Result < arry[i] then
Result := arry[i];
end;
function GetMax(const arry: array of Integer): Integer;
var
i: Integer;
begin
Result := arry[low(arry)];
for i := low(arry) + 1 to high(arry) do
if Result < arry[i] then
Result := arry[i];
end;
function FinalAngle4FMX(const a: TGeoFloat): TGeoFloat;
begin
Result := NormalizeDegAngle((-a - 90) + 180);
end;
function CalcAngle(const v1, v2: TVec2): TGeoFloat;
begin
if IsEqual(v1, v2) then
Result := 0
else
Result := RadToDeg(ArcTan2(v1[0] - v2[0], v1[1] - v2[1]));
end;
function AngleDistance(const sour, dest: TGeoFloat): TGeoFloat;
begin
Result := Abs(sour - dest);
if Result > 180.0 then
Result := 360.0 - Result;
end;
function SmoothAngle(const sour, dest, Delta: TGeoFloat): TGeoFloat;
var
a1, a2: TGeoFloat;
begin
if sour <> dest then
begin
if sour >= 0 then
begin
a1 := sour + Delta;
a2 := sour - Delta;
end
else
begin
a1 := sour + -Delta;
a2 := sour + Delta;
end;
if AngleDistance(dest, a1) >= AngleDistance(dest, a2) then
begin
if AngleDistance(dest, a2) > Delta then
Result := a2
else
Result := dest;
end
else if AngleDistance(dest, a1) > Delta then
Result := a1
else
Result := dest;
end
else
Result := dest;
end;
function AngleEqual(const a1, a2: TGeoFloat): Boolean;
begin
Result := AngleDistance(a1, a2) < 0.01;
end;
function Distance(const v1, v2: TVec2): TGeoFloat;
begin
Result := PointDistance(v1, v2);
end;
function Distance(const v1, v2: TRectV2): TGeoFloat;
var
d1, d2: TGeoFloat;
begin
d1 := PointDistance(v1[0], v2[0]);
d2 := PointDistance(v1[1], v2[1]);
if d1 >= d2 then
Result := d1
else
Result := d2;
end;
function MovementLerp(const s, d, Lerp: TGeoFloat): TGeoFloat;
begin
if Lerp < 1.0 then
Result := s + Lerp * (d - s)
else
Result := d;
end;
function MovementLerp(const s, d: TVec2; Lerp: TGeoFloat): TVec2;
begin
if Lerp < 1.0 then
begin
Result[0] := s[0] + Lerp * (d[0] - s[0]);
Result[1] := s[1] + Lerp * (d[1] - s[1]);
end
else
Result := d;
end;
function MovementLerp(const s, d: TRectV2; Lerp: TGeoFloat): TRectV2;
begin
if Lerp < 1.0 then
begin
Result[0] := MovementLerp(s[0], d[0], Lerp);
Result[1] := MovementLerp(s[1], d[1], Lerp);
end
else
Result := d;
end;
function MovementDistance(const s, d: TVec2; dt: TGeoFloat): TVec2;
var
k: Double;
begin
k := dt / Sqrt((d[0] - s[0]) * (d[0] - s[0]) + (d[1] - s[1]) * (d[1] - s[1]));
Result[0] := s[0] + k * (d[0] - s[0]);
Result[1] := s[1] + k * (d[1] - s[1]);
end;
function MovementDistance(const s, d: TRectV2; dt: TGeoFloat): TRectV2;
begin
if Distance(s[0], d[0]) > dt then
Result[0] := MovementDistance(s[0], d[0], dt)
else
Result[0] := d[0];
if Distance(s[1], d[1]) > dt then
Result[1] := MovementDistance(s[1], d[1], dt)
else
Result[1] := d[1];
end;
function MovementDistance(const sour, dest: TVector4; Distance: TGeoFloat): TVector4;
var
k: TGeoFloat;
begin
// calc distance
k := Distance / Sqrt((dest[0] - sour[0]) * (dest[0] - sour[0]) + (dest[1] - sour[1]) * (dest[1] - sour[1]) + (dest[2] - sour[2]) * (dest[2] - sour[2]) + (dest[3] - sour[3]) *
(dest[3] - sour[3]));
// done
Result[0] := sour[0] + k * (dest[0] - sour[0]);
Result[1] := sour[1] + k * (dest[1] - sour[1]);
Result[2] := sour[2] + k * (dest[2] - sour[2]);
Result[3] := sour[3] + k * (dest[3] - sour[3]);
end;
function MovementDistance(const sour, dest: TVector3; Distance: TGeoFloat): TVector3;
var
k: TGeoFloat;
begin
// calc distance
k := Distance / Sqrt((dest[0] - sour[0]) * (dest[0] - sour[0]) + (dest[1] - sour[1]) * (dest[1] - sour[1]) + (dest[2] - sour[2]) * (dest[2] - sour[2]));
// done
Result[0] := sour[0] + k * (dest[0] - sour[0]);
Result[1] := sour[1] + k * (dest[1] - sour[1]);
Result[2] := sour[2] + k * (dest[2] - sour[2]);
end;
function MovementDistanceDeltaTime(const s, d: TVec2; Speed_: TGeoFloat): Double;
begin
Result := Distance(s, d) / Speed_;
end;
function MovementDistanceDeltaTime(const s, d: TRectV2; Speed_: TGeoFloat): Double;
var
d1, d2: Double;
begin
d1 := MovementDistanceDeltaTime(s[0], d[0], Speed_);
d2 := MovementDistanceDeltaTime(s[1], d[1], Speed_);
if d1 > d2 then
Result := d1
else
Result := d2;
end;
function AngleRollDistanceDeltaTime(const s, d: TGeoFloat; ARollSpeed: TGeoFloat): Double;
begin
Result := AngleDistance(s, d) / ARollSpeed;
end;
function BounceVector(const Current: TVector4; DeltaDistance: TGeoFloat; const BeginVector, EndVector: TVector4; var EndFlag: Boolean): TVector4;
function ToVector: TVector4;
begin
if EndFlag then
Result := EndVector
else
Result := BeginVector;
end;
var
k: TGeoFloat;
begin
k := Current.Distance4D(ToVector);
if k >= DeltaDistance then
Result := MovementDistance(Current, ToVector, DeltaDistance)
else
begin
Result := ToVector;
EndFlag := not EndFlag;
Result := MovementDistance(Result, ToVector, DeltaDistance - k);
end;
end;
function BounceVector(const Current: TVector3; DeltaDistance: TGeoFloat; const BeginVector, EndVector: TVector3; var EndFlag: Boolean): TVector3;
function ToVector: TVector3;
begin
if EndFlag then
Result := EndVector
else
Result := BeginVector;
end;
var
k: TGeoFloat;
begin
k := Current.Distance3D(ToVector);
if k >= DeltaDistance then
Result := MovementDistance(Current, ToVector, DeltaDistance)
else
begin
Result := ToVector;
EndFlag := not EndFlag;
Result := MovementDistance(Result, ToVector, DeltaDistance - k);
end;
end;
function BounceVector(const Current: TVector2; DeltaDistance: TGeoFloat; const BeginVector, EndVector: TVector2; var EndFlag: Boolean): TVector2;
function ToVector: TVector2;
begin
if EndFlag then
Result := EndVector
else
Result := BeginVector;
end;
var
k: TGeoFloat;
begin
k := Vec2Distance(Current.Buff, ToVector.Buff);
if k >= DeltaDistance then
Result := Vec2LerpTo(Current.Buff, ToVector.Buff, DeltaDistance)
else
begin
Result := ToVector;
EndFlag := not EndFlag;
Result := Vec2LerpTo(Result.Buff, ToVector.Buff, DeltaDistance - k);
end;
end;
function BounceFloat(const CurrentVal, DeltaVal, StartVal, OverVal: TGeoFloat; var EndFlag: Boolean): TGeoFloat;
function IfOut(Cur, Delta, dest: TGeoFloat): Boolean;
begin
if Cur > dest then
Result := Cur - Delta < dest
else
Result := Cur + Delta > dest;
end;
function GetOutValue(Cur, Delta, dest: TGeoFloat): TGeoFloat;
begin
if IfOut(Cur, Delta, dest) then
begin
if Cur > dest then
Result := dest - (Cur - Delta)
else
Result := Cur + Delta - dest;
end
else
Result := 0;
end;
function GetDeltaValue(Cur, Delta, dest: TGeoFloat): TGeoFloat;
begin
if Cur > dest then
Result := Cur - Delta
else
Result := Cur + Delta;
end;
begin
if (DeltaVal > 0) and (StartVal <> OverVal) then
begin
if EndFlag then
begin
if IfOut(CurrentVal, DeltaVal, OverVal) then
begin
EndFlag := False;
Result := umlProcessCycleValue(OverVal, GetOutValue(CurrentVal, DeltaVal, OverVal), StartVal, OverVal, EndFlag);
end
else
Result := GetDeltaValue(CurrentVal, DeltaVal, OverVal);
end
else
begin
if IfOut(CurrentVal, DeltaVal, StartVal) then
begin
EndFlag := True;
Result := umlProcessCycleValue(StartVal, GetOutValue(CurrentVal, DeltaVal, StartVal), StartVal, OverVal, EndFlag);
end
else
Result := GetDeltaValue(CurrentVal, DeltaVal, StartVal);
end
end
else
Result := CurrentVal;
end;
class operator TMatrix4.Equal(const Lhs, Rhs: TMatrix4): Boolean;
begin
Result := VectorEquals(Lhs.Buff[0], Rhs.Buff[0]) and VectorEquals(Lhs.Buff[1], Rhs.Buff[1]) and VectorEquals(Lhs.Buff[2], Rhs.Buff[2]) and VectorEquals(Lhs.Buff[3], Rhs.Buff[3]);
end;
class operator TMatrix4.NotEqual(const Lhs, Rhs: TMatrix4): Boolean;
begin
Result := not(Lhs = Rhs);
end;
class operator TMatrix4.Multiply(const Lhs, Rhs: TMatrix4): TMatrix4;
begin
Result.Buff := GeometryLib.MatrixMultiply(Lhs.Buff, Rhs.Buff);
end;
class operator TMatrix4.Implicit(Value: TGeoFloat): TMatrix4;
var
i, j: Integer;
begin
for i := 0 to 3 do
for j := 0 to 3 do
Result.Buff[i, j] := Value;
end;
class operator TMatrix4.Implicit(Value: TMat4): TMatrix4;
begin
Result.Buff := Value;
end;
function TMatrix4.Swap: TMatrix4;
var
i, j: Integer;
begin
for i := 0 to 3 do
for j := 0 to 3 do
Result.Buff[j, i] := Buff[i, j];
end;
function TMatrix4.Lerp(M: TMatrix4; Delta: TGeoFloat): TMatrix4;
var
i, j: Integer;
begin
for j := 0 to 3 do
for i := 0 to 3 do
Result.Buff[i][j] := Buff[i][j] + (M.Buff[i][j] - Buff[i][j]) * Delta;
end;
function TMatrix4.AffineMatrix: TAffineMatrix;
begin
Result[0, 0] := Buff[0, 0];
Result[0, 1] := Buff[0, 1];
Result[0, 2] := Buff[0, 2];
Result[1, 0] := Buff[1, 0];
Result[1, 1] := Buff[1, 1];
Result[1, 2] := Buff[1, 2];
Result[2, 0] := Buff[2, 0];
Result[2, 1] := Buff[2, 1];
Result[2, 2] := Buff[2, 2];
end;
function TMatrix4.Invert: TMatrix4;
var
det: TGeoFloat;
begin
Result.Buff := Buff;
det := GeometryLib.MatrixDeterminant(Result.Buff);
if Abs(det) < Epsilon then
Result.Buff := GeometryLib.IdentityHmgMatrix
else
begin
GeometryLib.AdjointMatrix(Result.Buff);
GeometryLib.ScaleMatrix(Result.Buff, 1 / det);
end;
end;
function TMatrix4.Translate(v: TVec3): TMatrix4;
begin
Result.Buff := Buff;
GeometryLib.TranslateMatrix(Result.Buff, v);
end;
function TMatrix4.Normalize: TMatrix4;
begin
Result.Buff := Buff;
GeometryLib.NormalizeMatrix(Result.Buff);
end;
function TMatrix4.Transpose: TMatrix4;
begin
Result.Buff := Buff;
GeometryLib.TransposeMatrix(Result.Buff);
end;
function TMatrix4.AnglePreservingInvert: TMatrix4;
begin
Result.Buff := GeometryLib.AnglePreservingMatrixInvert(Buff);
end;
function TMatrix4.Determinant: TGeoFloat;
begin
Result := GeometryLib.MatrixDeterminant(Buff);
end;
function TMatrix4.Adjoint: TMatrix4;
begin
Result.Buff := Buff;
GeometryLib.AdjointMatrix(Result.Buff);
end;
function TMatrix4.Pitch(angle: TGeoFloat): TMatrix4;
begin
Result.Buff := GeometryLib.Pitch(Buff, angle);
end;
function TMatrix4.Roll(angle: TGeoFloat): TMatrix4;
begin
Result.Buff := GeometryLib.Roll(Buff, angle);
end;
function TMatrix4.Turn(angle: TGeoFloat): TMatrix4;
begin
Result.Buff := GeometryLib.Turn(Buff, angle);
end;
function TVector4.GetVec3: TVec3;
begin
Result := AffineVectorMake(Buff);
end;
procedure TVector4.SetVec3(const Value: TVec3);
begin
Buff := VectorMake(Value);
end;
function TVector4.GetVec2: TVec2;
begin
Result[0] := Buff[0];
Result[1] := Buff[1];
end;
procedure TVector4.SetVec2(const Value: TVec2);
begin
Buff[0] := Value[0];
Buff[1] := Value[1];
end;
function TVector4.GetLinkValue(index: Integer): TGeoFloat;
begin
Result := Buff[index];
end;
procedure TVector4.SetLinkValue(index: Integer; const Value: TGeoFloat);
begin
Buff[index] := Value;
end;
class operator TVector4.Equal(const Lhs, Rhs: TVector4): Boolean;
begin
Result := (Lhs.Buff[0] = Rhs.Buff[0]) and (Lhs.Buff[1] = Rhs.Buff[1]) and (Lhs.Buff[2] = Rhs.Buff[2]) and (Lhs.Buff[3] = Rhs.Buff[3]);
end;
class operator TVector4.NotEqual(const Lhs, Rhs: TVector4): Boolean;
begin
Result := (Lhs.Buff[0] <> Rhs.Buff[0]) or (Lhs.Buff[1] <> Rhs.Buff[1]) or (Lhs.Buff[2] <> Rhs.Buff[2]) or (Lhs.Buff[3] <> Rhs.Buff[3]);
end;
class operator TVector4.GreaterThan(const Lhs, Rhs: TVector4): Boolean;
begin
Result := (Lhs.Buff[0] > Rhs.Buff[0]) and (Lhs.Buff[1] > Rhs.Buff[1]) and (Lhs.Buff[2] > Rhs.Buff[2]) and (Lhs.Buff[3] > Rhs.Buff[3]);
end;
class operator TVector4.GreaterThanOrEqual(const Lhs, Rhs: TVector4): Boolean;
begin
Result := (Lhs.Buff[0] >= Rhs.Buff[0]) and (Lhs.Buff[1] >= Rhs.Buff[1]) and (Lhs.Buff[2] >= Rhs.Buff[2]) and (Lhs.Buff[3] >= Rhs.Buff[3]);
end;
class operator TVector4.LessThan(const Lhs, Rhs: TVector4): Boolean;
begin
Result := (Lhs.Buff[0] < Rhs.Buff[0]) and (Lhs.Buff[1] < Rhs.Buff[1]) and (Lhs.Buff[2] < Rhs.Buff[2]) and (Lhs.Buff[3] < Rhs.Buff[3]);
end;
class operator TVector4.LessThanOrEqual(const Lhs, Rhs: TVector4): Boolean;
begin
Result := (Lhs.Buff[0] <= Rhs.Buff[0]) and (Lhs.Buff[1] <= Rhs.Buff[1]) and (Lhs.Buff[2] <= Rhs.Buff[2]) and (Lhs.Buff[3] <= Rhs.Buff[3]);
end;
class operator TVector4.Add(const Lhs, Rhs: TVector4): TVector4;
begin
Result.Buff[0] := Lhs.Buff[0] + Rhs.Buff[0];
Result.Buff[1] := Lhs.Buff[1] + Rhs.Buff[1];
Result.Buff[2] := Lhs.Buff[2] + Rhs.Buff[2];
Result.Buff[3] := Lhs.Buff[3] + Rhs.Buff[3];
end;
class operator TVector4.Add(const Lhs: TVector4; const Rhs: TGeoFloat): TVector4;
begin
Result.Buff[0] := Lhs.Buff[0] + Rhs;
Result.Buff[1] := Lhs.Buff[1] + Rhs;
Result.Buff[2] := Lhs.Buff[2] + Rhs;
Result.Buff[3] := Lhs.Buff[3] + Rhs;
end;
class operator TVector4.Add(const Lhs: TGeoFloat; const Rhs: TVector4): TVector4;
begin
Result.Buff[0] := Lhs + Rhs.Buff[0];
Result.Buff[1] := Lhs + Rhs.Buff[1];
Result.Buff[2] := Lhs + Rhs.Buff[2];
Result.Buff[3] := Lhs + Rhs.Buff[3];
end;
class operator TVector4.Subtract(const Lhs, Rhs: TVector4): TVector4;
begin
Result.Buff[0] := Lhs.Buff[0] - Rhs.Buff[0];
Result.Buff[1] := Lhs.Buff[1] - Rhs.Buff[1];
Result.Buff[2] := Lhs.Buff[2] - Rhs.Buff[2];
Result.Buff[3] := Lhs.Buff[3] - Rhs.Buff[3];
end;
class operator TVector4.Subtract(const Lhs: TVector4; const Rhs: TGeoFloat): TVector4;
begin
Result.Buff[0] := Lhs.Buff[0] - Rhs;
Result.Buff[1] := Lhs.Buff[1] - Rhs;
Result.Buff[2] := Lhs.Buff[2] - Rhs;
Result.Buff[3] := Lhs.Buff[3] - Rhs;
end;
class operator TVector4.Subtract(const Lhs: TGeoFloat; const Rhs: TVector4): TVector4;
begin
Result.Buff[0] := Lhs - Rhs.Buff[0];
Result.Buff[1] := Lhs - Rhs.Buff[1];
Result.Buff[2] := Lhs - Rhs.Buff[2];
Result.Buff[3] := Lhs - Rhs.Buff[3];
end;
class operator TVector4.Multiply(const Lhs, Rhs: TVector4): TVector4;
begin
Result.Buff[0] := Lhs.Buff[0] * Rhs.Buff[0];
Result.Buff[1] := Lhs.Buff[1] * Rhs.Buff[1];
Result.Buff[2] := Lhs.Buff[2] * Rhs.Buff[2];
Result.Buff[3] := Lhs.Buff[2] * Rhs.Buff[3];
end;
class operator TVector4.Multiply(const Lhs: TVector4; const Rhs: TGeoFloat): TVector4;
begin
Result.Buff[0] := Lhs.Buff[0] * Rhs;
Result.Buff[1] := Lhs.Buff[1] * Rhs;
Result.Buff[2] := Lhs.Buff[2] * Rhs;
Result.Buff[3] := Lhs.Buff[3] * Rhs;
end;
class operator TVector4.Multiply(const Lhs: TGeoFloat; const Rhs: TVector4): TVector4;
begin
Result.Buff[0] := Lhs * Rhs.Buff[0];
Result.Buff[1] := Lhs * Rhs.Buff[1];
Result.Buff[2] := Lhs * Rhs.Buff[2];
Result.Buff[3] := Lhs * Rhs.Buff[3];
end;
class operator TVector4.Multiply(const Lhs: TVector4; const Rhs: TMatrix4): TVector4;
begin
Result.Buff := GeometryLib.VectorTransform(Lhs.Buff, Rhs.Buff);
end;
class operator TVector4.Multiply(const Lhs: TMatrix4; const Rhs: TVector4): TVector4;
begin
Result.Buff := VectorTransform(Rhs.Buff, Lhs.Buff);
end;
class operator TVector4.Multiply(const Lhs: TVector4; const Rhs: TMat4): TVector4;
begin
Result.Buff := GeometryLib.VectorTransform(Lhs.Buff, Rhs);
end;
class operator TVector4.Multiply(const Lhs: TMat4; const Rhs: TVector4): TVector4;
begin
Result.Buff := GeometryLib.VectorTransform(Rhs.Buff, Lhs);
end;
class operator TVector4.Multiply(const Lhs: TVector4; const Rhs: TAffineMatrix): TVector4;
begin
Result.Buff := GeometryLib.VectorTransform(Lhs.Buff, Rhs);
end;
class operator TVector4.Multiply(const Lhs: TAffineMatrix; const Rhs: TVector4): TVector4;
begin
Result.Buff := GeometryLib.VectorTransform(Rhs.Buff, Lhs);
end;
class operator TVector4.Divide(const Lhs, Rhs: TVector4): TVector4;
begin
Result.Buff[0] := Lhs.Buff[0] / Rhs.Buff[0];
Result.Buff[1] := Lhs.Buff[1] / Rhs.Buff[1];
Result.Buff[2] := Lhs.Buff[2] / Rhs.Buff[2];
Result.Buff[3] := Lhs.Buff[3] / Rhs.Buff[3];
end;
class operator TVector4.Divide(const Lhs: TVector4; const Rhs: TGeoFloat): TVector4;
begin
Result.Buff[0] := Lhs.Buff[0] / Rhs;
Result.Buff[1] := Lhs.Buff[1] / Rhs;
Result.Buff[2] := Lhs.Buff[2] / Rhs;
Result.Buff[3] := Lhs.Buff[3] / Rhs;
end;
class operator TVector4.Divide(const Lhs: TGeoFloat; const Rhs: TVector4): TVector4;
begin
Result.Buff[0] := Lhs / Rhs.Buff[0];
Result.Buff[1] := Lhs / Rhs.Buff[1];
Result.Buff[2] := Lhs / Rhs.Buff[2];
Result.Buff[3] := Lhs / Rhs.Buff[3];
end;
class operator TVector4.Implicit(Value: TGeoFloat): TVector4;
begin
Result.Buff[0] := Value;
Result.Buff[1] := Value;
Result.Buff[2] := Value;
Result.Buff[3] := Value;
end;
class operator TVector4.Implicit(Value: TVec4): TVector4;
begin
Result.Buff := Value;
end;
class operator TVector4.Implicit(Value: TVec3): TVector4;
begin
Result.Buff := VectorMake(Value);
end;
class operator TVector4.Implicit(Value: TVec2): TVector4;
begin
Result.Buff := VectorMake(Value[0], Value[1], 0, 0);
end;
class operator TVector4.Explicit(Value: TVector4): TVec4;
begin
Result := Value.Buff;
end;
class operator TVector4.Explicit(Value: TVector4): TVec3;
begin
Result := AffineVectorMake(Value.Buff);
end;
class operator TVector4.Explicit(Value: TVector4): TVec2;
begin
Result[0] := Value.Buff[0];
Result[1] := Value.Buff[1];
end;
procedure TVector4.SetRGBA(const r, g, b, a: TGeoFloat);
begin
Buff[0] := r;
Buff[1] := g;
Buff[2] := b;
Buff[3] := a;
end;
procedure TVector4.SetLocation(const fx, fy, fz, fw: TGeoFloat);
begin
Buff[0] := fx;
Buff[1] := fy;
Buff[2] := fz;
Buff[3] := fw;
end;
procedure TVector4.SetLocation(const fx, fy, fz: TGeoFloat);
begin
Buff[0] := fx;
Buff[1] := fy;
Buff[2] := fz;
end;
function TVector4.Distance4D(const v2: TVector4): TGeoFloat;
begin
Result := Sqrt(Sqr(v2.Buff[0] - Buff[0]) + Sqr(v2.Buff[1] - Buff[1]) + Sqr(v2.Buff[2] - Buff[2]) + Sqr(v2.Buff[3] - Buff[3]));
end;
function TVector4.Distance3D(const v2: TVector4): TGeoFloat;
begin
Result := Sqrt(Sqr(v2.Buff[0] - Buff[0]) + Sqr(v2.Buff[1] - Buff[1]) + Sqr(v2.Buff[2] - Buff[2]));
end;
function TVector4.Distance2D(const v2: TVector4): TGeoFloat;
begin
Result := Sqrt(Sqr(v2.Buff[0] - Buff[0]) + Sqr(v2.Buff[1] - Buff[1]));
end;
function TVector4.Lerp(const v2: TVector4; const t: TGeoFloat): TVector4;
begin
Result.Buff[0] := Buff[0] + (v2.Buff[0] - Buff[0]) * t;
Result.Buff[1] := Buff[1] + (v2.Buff[1] - Buff[1]) * t;
Result.Buff[2] := Buff[2] + (v2.Buff[2] - Buff[2]) * t;
Result.Buff[3] := Buff[3] + (v2.Buff[3] - Buff[3]) * t;
end;
function TVector4.LerpDistance(const v2: TVector4; const d: TGeoFloat): TVector4;
var
k: Double;
begin
k := d / Sqrt((v2.Buff[0] - Buff[0]) * (v2.Buff[0] - Buff[0]) + (v2.Buff[1] - Buff[1]) * (v2.Buff[1] - Buff[1]) + (v2.Buff[2] - Buff[2]) * (v2.Buff[2] - Buff[2]) +
(v2.Buff[3] - Buff[3]) * (v2.Buff[3] - Buff[3]));
Result.Buff[0] := Buff[0] + k * (v2.Buff[0] - Buff[0]);
Result.Buff[1] := Buff[1] + k * (v2.Buff[1] - Buff[1]);
Result.Buff[2] := Buff[2] + k * (v2.Buff[2] - Buff[2]);
Result.Buff[3] := Buff[3] + k * (v2.Buff[3] - Buff[3]);
end;
function TVector4.Norm: TGeoFloat;
begin
Result := Buff[0] * Buff[0] + Buff[1] * Buff[1] + Buff[2] * Buff[2] + Buff[3] * Buff[3];
end;
function TVector4.length: TGeoFloat;
begin
Result := Sqrt(Norm);
end;
function TVector4.Normalize: TVector4;
var
InvLen: TGeoFloat;
vn: TGeoFloat;
begin
vn := Norm;
if vn = 0 then
Result := Self
else
begin
InvLen := RSqrt(vn);
Result.Buff[0] := Buff[0] * InvLen;
Result.Buff[1] := Buff[1] * InvLen;
Result.Buff[2] := Buff[2] * InvLen;
Result.Buff[3] := Buff[3] * InvLen;
end;
end;
function TVector4.Cross(const v2: TVector4): TVector4;
begin
Result.Buff[0] := Buff[1] * v2.Buff[2] - Buff[2] * v2.Buff[1];
Result.Buff[1] := Buff[2] * v2.Buff[0] - Buff[0] * v2.Buff[2];
Result.Buff[2] := Buff[0] * v2.Buff[1] - Buff[1] * v2.Buff[0];
Result.Buff[3] := 0;
end;
function TVector4.Cross(const v2: TVec3): TVector4;
begin
Result.Buff[0] := Buff[1] * v2[2] - Buff[2] * v2[1];
Result.Buff[1] := Buff[2] * v2[0] - Buff[0] * v2[2];
Result.Buff[2] := Buff[0] * v2[1] - Buff[1] * v2[0];
Result.Buff[3] := 0;
end;
function TVector4.Cross(const v2: TVec4): TVector4;
begin
Result.Buff[0] := Buff[1] * v2[2] - Buff[2] * v2[1];
Result.Buff[1] := Buff[2] * v2[0] - Buff[0] * v2[2];
Result.Buff[2] := Buff[0] * v2[1] - Buff[1] * v2[0];
Result.Buff[3] := 0;
end;
function TVector3.GetVec2: TVec2;
begin
Result[0] := Buff[0];
Result[1] := Buff[1];
end;
procedure TVector3.SetVec2(const Value: TVec2);
begin
Buff[0] := Value[0];
Buff[1] := Value[1];
end;
function TVector3.GetLinkValue(index: Integer): TGeoFloat;
begin
Result := Buff[index];
end;
procedure TVector3.SetLinkValue(index: Integer; const Value: TGeoFloat);
begin
Buff[index] := Value;
end;
class operator TVector3.Equal(const Lhs, Rhs: TVector3): Boolean;
begin
Result := (Lhs.Buff[0] = Rhs.Buff[0]) and (Lhs.Buff[1] = Rhs.Buff[1]) and (Lhs.Buff[2] = Rhs.Buff[2]);
end;
class operator TVector3.NotEqual(const Lhs, Rhs: TVector3): Boolean;
begin
Result := (Lhs.Buff[0] <> Rhs.Buff[0]) or (Lhs.Buff[1] <> Rhs.Buff[1]) or (Lhs.Buff[2] <> Rhs.Buff[2]);
end;
class operator TVector3.GreaterThan(const Lhs, Rhs: TVector3): Boolean;
begin
Result := (Lhs.Buff[0] > Rhs.Buff[0]) and (Lhs.Buff[1] > Rhs.Buff[1]) and (Lhs.Buff[2] > Rhs.Buff[2]);
end;
class operator TVector3.GreaterThanOrEqual(const Lhs, Rhs: TVector3): Boolean;
begin
Result := (Lhs.Buff[0] >= Rhs.Buff[0]) and (Lhs.Buff[1] >= Rhs.Buff[1]) and (Lhs.Buff[2] >= Rhs.Buff[2]);
end;
class operator TVector3.LessThan(const Lhs, Rhs: TVector3): Boolean;
begin
Result := (Lhs.Buff[0] < Rhs.Buff[0]) and (Lhs.Buff[1] < Rhs.Buff[1]) and (Lhs.Buff[2] < Rhs.Buff[2]);
end;
class operator TVector3.LessThanOrEqual(const Lhs, Rhs: TVector3): Boolean;
begin
Result := (Lhs.Buff[0] <= Rhs.Buff[0]) and (Lhs.Buff[1] <= Rhs.Buff[1]) and (Lhs.Buff[2] <= Rhs.Buff[2]);
end;
class operator TVector3.Add(const Lhs, Rhs: TVector3): TVector3;
begin
Result.Buff[0] := Lhs.Buff[0] + Rhs.Buff[0];
Result.Buff[1] := Lhs.Buff[1] + Rhs.Buff[1];
Result.Buff[2] := Lhs.Buff[2] + Rhs.Buff[2];
end;
class operator TVector3.Add(const Lhs: TVector3; const Rhs: TGeoFloat): TVector3;
begin
Result.Buff[0] := Lhs.Buff[0] + Rhs;
Result.Buff[1] := Lhs.Buff[1] + Rhs;
Result.Buff[2] := Lhs.Buff[2] + Rhs;
end;
class operator TVector3.Add(const Lhs: TGeoFloat; const Rhs: TVector3): TVector3;
begin
Result.Buff[0] := Lhs + Rhs.Buff[0];
Result.Buff[1] := Lhs + Rhs.Buff[1];
Result.Buff[2] := Lhs + Rhs.Buff[2];
end;
class operator TVector3.Subtract(const Lhs, Rhs: TVector3): TVector3;
begin
Result.Buff[0] := Lhs.Buff[0] - Rhs.Buff[0];
Result.Buff[1] := Lhs.Buff[1] - Rhs.Buff[1];
Result.Buff[2] := Lhs.Buff[2] - Rhs.Buff[2];
end;
class operator TVector3.Subtract(const Lhs: TVector3; const Rhs: TGeoFloat): TVector3;
begin
Result.Buff[0] := Lhs.Buff[0] - Rhs;
Result.Buff[1] := Lhs.Buff[1] - Rhs;
Result.Buff[2] := Lhs.Buff[2] - Rhs;
end;
class operator TVector3.Subtract(const Lhs: TGeoFloat; const Rhs: TVector3): TVector3;
begin
Result.Buff[0] := Lhs - Rhs.Buff[0];
Result.Buff[1] := Lhs - Rhs.Buff[1];
Result.Buff[2] := Lhs - Rhs.Buff[2];
end;
class operator TVector3.Multiply(const Lhs, Rhs: TVector3): TVector3;
begin
Result.Buff[0] := Lhs.Buff[0] * Rhs.Buff[0];
Result.Buff[1] := Lhs.Buff[1] * Rhs.Buff[1];
Result.Buff[2] := Lhs.Buff[2] * Rhs.Buff[2];
end;
class operator TVector3.Multiply(const Lhs: TVector3; const Rhs: TGeoFloat): TVector3;
begin
Result.Buff[0] := Lhs.Buff[0] * Rhs;
Result.Buff[1] := Lhs.Buff[1] * Rhs;
Result.Buff[2] := Lhs.Buff[2] * Rhs;
end;
class operator TVector3.Multiply(const Lhs: TGeoFloat; const Rhs: TVector3): TVector3;
begin
Result.Buff[0] := Lhs * Rhs.Buff[0];
Result.Buff[1] := Lhs * Rhs.Buff[1];
Result.Buff[2] := Lhs * Rhs.Buff[2];
end;
class operator TVector3.Multiply(const Lhs: TVector3; const Rhs: TMatrix4): TVector3;
begin
Result.Buff := GeometryLib.VectorTransform(Lhs.Buff, Rhs.Buff);
end;
class operator TVector3.Multiply(const Lhs: TMatrix4; const Rhs: TVector3): TVector3;
begin
Result.Buff := GeometryLib.VectorTransform(Rhs.Buff, Lhs.Buff);
end;
class operator TVector3.Multiply(const Lhs: TVector3; const Rhs: TMat4): TVector3;
begin
Result.Buff := GeometryLib.VectorTransform(Lhs.Buff, Rhs);
end;
class operator TVector3.Multiply(const Lhs: TMat4; const Rhs: TVector3): TVector3;
begin
Result.Buff := GeometryLib.VectorTransform(Rhs.Buff, Lhs);
end;
class operator TVector3.Multiply(const Lhs: TVector3; const Rhs: TAffineMatrix): TVector3;
begin
Result.Buff := GeometryLib.VectorTransform(Lhs.Buff, Rhs);
end;
class operator TVector3.Multiply(const Lhs: TAffineMatrix; const Rhs: TVector3): TVector3;
begin
Result.Buff := GeometryLib.VectorTransform(Rhs.Buff, Lhs);
end;
class operator TVector3.Divide(const Lhs, Rhs: TVector3): TVector3;
begin
Result.Buff[0] := Lhs.Buff[0] / Rhs.Buff[0];
Result.Buff[1] := Lhs.Buff[1] / Rhs.Buff[1];
Result.Buff[2] := Lhs.Buff[2] / Rhs.Buff[2];
end;
class operator TVector3.Divide(const Lhs: TVector3; const Rhs: TGeoFloat): TVector3;
begin
Result.Buff[0] := Lhs.Buff[0] / Rhs;
Result.Buff[1] := Lhs.Buff[1] / Rhs;
Result.Buff[2] := Lhs.Buff[2] / Rhs;
end;
class operator TVector3.Divide(const Lhs: TGeoFloat; const Rhs: TVector3): TVector3;
begin
Result.Buff[0] := Lhs / Rhs.Buff[0];
Result.Buff[1] := Lhs / Rhs.Buff[1];
Result.Buff[2] := Lhs / Rhs.Buff[2];
end;
class operator TVector3.Implicit(Value: TGeoFloat): TVector3;
begin
Result.Buff[0] := Value;
Result.Buff[1] := Value;
Result.Buff[2] := Value;
end;
class operator TVector3.Implicit(Value: TVec4): TVector3;
begin
Result.Buff := AffineVectorMake(Value);
end;
class operator TVector3.Implicit(Value: TVec3): TVector3;
begin
Result.Buff := Value;
end;
class operator TVector3.Implicit(Value: TVec2): TVector3;
begin
Result.Buff := AffineVectorMake(Value[0], Value[1], 0);
end;
class operator TVector3.Explicit(Value: TVector3): TVec4;
begin
Result := VectorMake(Value.Buff);
end;
class operator TVector3.Explicit(Value: TVector3): TVec3;
begin
Result := Value.Buff;
end;
class operator TVector3.Explicit(Value: TVector3): TVec2;
begin
Result[0] := Value.Buff[0];
Result[1] := Value.Buff[1];
end;
procedure TVector3.SetLocation(const fx, fy, fz: TGeoFloat);
begin
Buff[0] := fx;
Buff[1] := fy;
Buff[2] := fz;
end;
function TVector3.Distance3D(const v2: TVector3): TGeoFloat;
begin
Result := Sqrt(Sqr(v2.Buff[0] - Buff[0]) + Sqr(v2.Buff[1] - Buff[1]) + Sqr(v2.Buff[2] - Buff[2]));
end;
function TVector3.Distance2D(const v2: TVector3): TGeoFloat;
begin
Result := Sqrt(Sqr(v2.Buff[0] - Buff[0]) + Sqr(v2.Buff[1] - Buff[1]));
end;
function TVector3.Lerp(const v2: TVector3; const t: TGeoFloat): TVector3;
begin
Result.Buff[0] := Buff[0] + (v2.Buff[0] - Buff[0]) * t;
Result.Buff[1] := Buff[1] + (v2.Buff[1] - Buff[1]) * t;
Result.Buff[2] := Buff[2] + (v2.Buff[2] - Buff[2]) * t;
end;
function TVector3.LerpDistance(const v2: TVector3; const d: TGeoFloat): TVector3;
var
k: Double;
begin
k := d / Sqrt((v2.Buff[0] - Buff[0]) * (v2.Buff[0] - Buff[0]) + (v2.Buff[1] - Buff[1]) * (v2.Buff[1] - Buff[1]) + (v2.Buff[2] - Buff[2]) * (v2.Buff[2] - Buff[2]));
Result.Buff[0] := Buff[0] + k * (v2.Buff[0] - Buff[0]);
Result.Buff[1] := Buff[1] + k * (v2.Buff[1] - Buff[1]);
Result.Buff[2] := Buff[2] + k * (v2.Buff[2] - Buff[2]);
end;
function TVector3.Norm: TGeoFloat;
begin
Result := Buff[0] * Buff[0] + Buff[1] * Buff[1] + Buff[2] * Buff[2];
end;
function TVector3.length: TGeoFloat;
begin
Result := Sqrt(Norm);
end;
function TVector3.Normalize: TVector3;
var
InvLen: TGeoFloat;
vn: TGeoFloat;
begin
vn := Norm;
if vn = 0 then
Result := Self
else
begin
InvLen := RSqrt(vn);
Result.Buff[0] := Buff[0] * InvLen;
Result.Buff[1] := Buff[1] * InvLen;
Result.Buff[2] := Buff[2] * InvLen;
end;
end;
function TVector3.Cross(const v2: TVector3): TVector3;
begin
Result.Buff[0] := Buff[1] * v2.Buff[2] - Buff[2] * v2.Buff[1];
Result.Buff[1] := Buff[2] * v2.Buff[0] - Buff[0] * v2.Buff[2];
Result.Buff[2] := Buff[0] * v2.Buff[1] - Buff[1] * v2.Buff[0];
end;
function TVector3.Vec4(fw: TGeoFloat): TVector4;
begin
Result.SetLocation(Buff[0], Buff[1], Buff[2], fw);
end;
function TVector3.Vec4: TVector4;
begin
Result.SetLocation(Buff[0], Buff[1], Buff[2], 0);
end;
{ TAABB }
procedure TAABB.Include(const p: TVector3);
begin
if p.Buff[0] < Min[0] then
Min[0] := p.Buff[0];
if p.Buff[0] > Max[0] then
Max[0] := p.Buff[0];
if p.Buff[1] < Min[1] then
Min[1] := p.Buff[1];
if p.Buff[1] > Max[1] then
Max[1] := p.Buff[1];
if p.Buff[2] < Min[2] then
Min[2] := p.Buff[2];
if p.Buff[2] > Max[2] then
Max[2] := p.Buff[2];
end;
procedure TAABB.FromSweep(const Start, dest: TVector3; const radius: TGeoFloat);
begin
if Start.Buff[0] < dest.Buff[0] then
begin
Min[0] := Start.Buff[0] - radius;
Max[0] := dest.Buff[0] + radius;
end
else
begin
Min[0] := dest.Buff[0] - radius;
Max[0] := Start.Buff[0] + radius;
end;
if Start.Buff[1] < dest.Buff[1] then
begin
Min[1] := Start.Buff[1] - radius;
Max[1] := dest.Buff[1] + radius;
end
else
begin
Min[1] := dest.Buff[1] - radius;
Max[1] := Start.Buff[1] + radius;
end;
if Start.Buff[2] < dest.Buff[2] then
begin
Min[2] := Start.Buff[2] - radius;
Max[2] := dest.Buff[2] + radius;
end
else
begin
Min[2] := dest.Buff[2] - radius;
Max[2] := Start.Buff[2] + radius;
end;
end;
function TAABB.Intersection(const aabb2: TAABB): TAABB;
var
i: Integer;
begin
for i := 0 to 2 do
begin
Result.Min[i] := MaxFloat(Min[i], aabb2.Min[i]);
Result.Max[i] := MinFloat(Max[i], aabb2.Max[i]);
end;
end;
procedure TAABB.Offset(const Delta: TVector3);
begin
AddVector(Min, Delta.Buff);
AddVector(Max, Delta.Buff);
end;
function TAABB.PointIn(const p: TVector3): Boolean;
begin
Result := (p.Buff[0] <= Max[0]) and (p.Buff[0] >= Min[0])
and (p.Buff[1] <= Max[1]) and (p.Buff[1] >= Min[1])
and (p.Buff[2] <= Max[2]) and (p.Buff[2] >= Min[2]);
end;
function TVector2.GetLinkValue(index: Integer): TGeoFloat;
begin
Result := Buff[index];
end;
procedure TVector2.SetLinkValue(index: Integer; const Value: TGeoFloat);
begin
Buff[index] := Value;
end;
class operator TVector2.Equal(const Lhs, Rhs: TVector2): Boolean;
begin
Result := IsEqual(Lhs.Buff, Rhs.Buff);
end;
class operator TVector2.NotEqual(const Lhs, Rhs: TVector2): Boolean;
begin
Result := NotEqual(Lhs.Buff, Rhs.Buff);
end;
class operator TVector2.GreaterThan(const Lhs, Rhs: TVector2): Boolean;
begin
Result := (Lhs.Buff[0] > Rhs.Buff[0]) and (Lhs.Buff[1] > Rhs.Buff[1]);
end;
class operator TVector2.GreaterThanOrEqual(const Lhs, Rhs: TVector2): Boolean;
begin
Result := (Lhs.Buff[0] >= Rhs.Buff[0]) and (Lhs.Buff[1] >= Rhs.Buff[1]);
end;
class operator TVector2.LessThan(const Lhs, Rhs: TVector2): Boolean;
begin
Result := (Lhs.Buff[0] < Rhs.Buff[0]) and (Lhs.Buff[1] < Rhs.Buff[1]);
end;
class operator TVector2.LessThanOrEqual(const Lhs, Rhs: TVector2): Boolean;
begin
Result := (Lhs.Buff[0] <= Rhs.Buff[0]) and (Lhs.Buff[1] <= Rhs.Buff[1]);
end;
class operator TVector2.Add(const Lhs, Rhs: TVector2): TVector2;
begin
Result.Buff := Vec2Add(Lhs.Buff, Rhs.Buff);
end;
class operator TVector2.Add(const Lhs: TVector2; const Rhs: TGeoFloat): TVector2;
begin
Result.Buff := Vec2Add(Lhs.Buff, Rhs);
end;
class operator TVector2.Add(const Lhs: TGeoFloat; const Rhs: TVector2): TVector2;
begin
Result.Buff := Vec2Add(Lhs, Rhs.Buff);
end;
class operator TVector2.Subtract(const Lhs, Rhs: TVector2): TVector2;
begin
Result.Buff := Vec2Sub(Lhs.Buff, Rhs.Buff);
end;
class operator TVector2.Subtract(const Lhs: TVector2; const Rhs: TGeoFloat): TVector2;
begin
Result.Buff := Vec2Sub(Lhs.Buff, Rhs);
end;
class operator TVector2.Subtract(const Lhs: TGeoFloat; const Rhs: TVector2): TVector2;
begin
Result.Buff := Vec2Sub(Lhs, Rhs.Buff);
end;
class operator TVector2.Multiply(const Lhs, Rhs: TVector2): TVector2;
begin
Result.Buff := Vec2Mul(Lhs.Buff, Rhs.Buff);
end;
class operator TVector2.Multiply(const Lhs: TVector2; const Rhs: TGeoFloat): TVector2;
begin
Result.Buff := Vec2Mul(Lhs.Buff, Rhs);
end;
class operator TVector2.Multiply(const Lhs: TGeoFloat; const Rhs: TVector2): TVector2;
begin
Result.Buff := Vec2Mul(Lhs, Rhs.Buff);
end;
class operator TVector2.Divide(const Lhs, Rhs: TVector2): TVector2;
begin
Result.Buff := Vec2Div(Lhs.Buff, Rhs.Buff);
end;
class operator TVector2.Divide(const Lhs: TVector2; const Rhs: TGeoFloat): TVector2;
begin
Result.Buff := Vec2Div(Lhs.Buff, Rhs);
end;
class operator TVector2.Divide(const Lhs: TGeoFloat; const Rhs: TVector2): TVector2;
begin
Result.Buff := Vec2Div(Lhs, Rhs.Buff);
end;
class operator TVector2.Implicit(Value: TGeoFloat): TVector2;
begin
Result.Buff := Vec2(Value);
end;
class operator TVector2.Implicit(Value: TPoint): TVector2;
begin
Result.Buff := Vec2(Value);
end;
class operator TVector2.Implicit(Value: TPointf): TVector2;
begin
Result.Buff := Vec2(Value);
end;
class operator TVector2.Implicit(Value: TVec2): TVector2;
begin
Result.Buff := Value;
end;
class operator TVector2.Explicit(Value: TVector2): TPointf;
begin
Result := MakePointf(Value.Buff);
end;
class operator TVector2.Explicit(Value: TVector2): TPoint;
begin
Result := MakePoint(Value.Buff);
end;
class operator TVector2.Explicit(Value: TVector2): TVec2;
begin
Result := Value.Buff;
end;
procedure TVector2.SetLocation(const fx, fy: TGeoFloat);
begin
Buff := Vec2(fx, fy);
end;
function TVector2.Distance(const v2: TVector2): TGeoFloat;
begin
Result := Vec2Distance(Buff, v2.Buff);
end;
function TVector2.Lerp(const v2: TVector2; const t: TGeoFloat): TVector2;
begin
Result.Buff := Vec2Lerp(Buff, v2.Buff, t);
end;
function TVector2.LerpDistance(const v2: TVector2; const d: TGeoFloat): TVector2;
begin
Result.Buff := Vec2LerpTo(Buff, v2.Buff, d);
end;
function TVector2.Norm: TGeoFloat;
begin
Result := Vec2Norm(Buff);
end;
function TVector2.length: TGeoFloat;
begin
Result := Vec2Length(Buff);
end;
function TVector2.Normalize: TVector2;
begin
Result.Buff := Vec2Normalize(Buff);
end;
end.
|
unit uController;
interface
uses
SysUtils, System.Math, uCommonDevice, uModbus, syncobjs;
type
TAr = array[0..59] of byte;
TController = class(TCommonModbusDevice)
private
function ReadData(Addr: byte; RegAddr: word; var Ans: word): TModbusError; overload;
function ReadData(Addr: byte; RegAddr: word; var Ans: ansistring; Count: byte = 1): TModbusError; overload;
function WriteState(Addr: byte; RegAddr: word; Value: array of word): TModbusError;
public
//Данные сканера входа
function GetEnterCard(Addr: byte; var IsNew: boolean; var CardNum: TAr; var Count: word): TModbusError;
//Данные сканера выхода
function GetExitCard(Addr: byte; var IsNew: boolean; var CardNum: TAr; var Count: word): TModbusError;
//Состояние входа
//0 – проход закрыт;
//(1-$FFFЕ) – количество разрешенных проходов
//$FFFF – разрешен свободный проход
function GetEnter(Addr: byte; var Value: word): TModbusError;
//Состояние выхода
//0 – проход закрыт;
//(1-$FFFЕ) – количество разрешенных проходов
//$FFFF – разрешен свободный проход
function GetExit(Addr: byte; var Value: word): TModbusError;
//0 - нормальный режим
//1 - режим Блокировки
//2 - режим Антипаники
function GetPassState(Addr: byte; var Value: word): TModbusError;
//Ошибки:
//0 – Ошибок нет
//не 0 – Наличие ошибок в системе
function GetErrorState(Addr: byte; var Value: word): TModbusError;
//Количество проходов в направлении вход
function GetEnterCount(Addr: byte; var Value: longword): TModbusError;
//Количество проходов в направлении выход
function GetExitCount(Addr: byte; var Value: longword): TModbusError;
//Состояние входа
//0 - Проход в направлении вход свободен
//Не 0 – позиция(наличие) объекта с направления вход
function GetEnterState(Addr: byte; var Value: word): TModbusError;
//Состояние выхода
//0 - Проход в направлении выход свободен
//Не 0 – позиция(наличие) объекта с направления выход
function GetExitState(Addr: byte; var Value: word): TModbusError;
//Время необходимое для прохода после разрешения, секунд
function GetAfterPermissionPassTime(Addr: byte; var Value: word): TModbusError;
//Время необходимое после начала прохода, секунд
function GetAfterStartPassTime(Addr: byte; var Value: word): TModbusError;
//Таймаут работы двигателя, секунд
function GetEngineTime(Addr: byte; var Value: word): TModbusError;
//Разрешение накопления проходов
//0 – Накопление проходов запрещено
//1 - Накопление проходов разрешено
function SetAccumulPas(Addr: byte; State: byte): TModbusError;
//0 - Установить нормальный режим
//1 - Установить режим Блокировки
//2 - Установить режим Антипаники
function SetPassState(Addr: byte; State: byte): TModbusError;
//скорость обмена между контроллером турникета и контроллером верхнего уровня деленная на 100
function SetControllerSpeed(Addr: byte; Value: longword): TModbusError;
//скорость обмена между контроллером турникета и сканером деленная на 100
function SetScannerSpeed(Addr: byte; Value: word): TModbusError;
//0 – проход закрыт;
//(1-$FFFЕ) – количество разрешенных проходов
//$FFFF – разрешен свободный проход
function SetEnter(Addr: byte; State: word): TModbusError;
//0 – проход закрыт;
//(1-$FFFЕ) – количество разрешенных проходов
//$FFFF – разрешен свободный проход
function SetExit(Addr: byte; State: word): TModbusError;
//Время необходимое для прохода после разрешения, секунд
function SetAfterPermissionPassTime(Addr: byte; State: byte): TModbusError;
//Время необходимое после начала прохода, секунд
function SetAfterStartPassTime(Addr: byte; State: byte): TModbusError;
//Таймаут работы двигателя, секунд
function SetEngineTime(Addr: byte; State: byte): TModbusError;
//Зеленый Вход: длительность включения сигнала, в 100 мс интервалах (t)
//длительность выключения сигнала, в 100 мс интервалах (T)
//Общая длительность цикла индикации, в 100 мс интервалах (time)
//Значение 0xFFFF – Соответствуют бесконечному времени.
function SetEnterGreen(Addr: byte; OnTime, OffTime, LengthTime: word): TModbusError;
//Красный Вход: длительность включения сигнала, в 100 мс интервалах (t)
//длительность выключения сигнала, в 100 мс интервалах (T)
//Общая длительность цикла индикации, в 100 мс интервалах (time)
//Значение 0xFFFF – Соответствуют бесконечному времени.
function SetEnterRed(Addr: byte; OnTime, OffTime, LengthTime: word): TModbusError;
//Зеленый Выход: длительность включения сигнала, в 100 мс интервалах (t)
//длительность выключения сигнала, в 100 мс интервалах (T)
//Общая длительность цикла индикации, в 100 мс интервалах (time)
//Значение 0xFFFF – Соответствуют бесконечному времени.
function SetExitGreen(Addr: byte; OnTime, OffTime, LengthTime: word): TModbusError;
//Красный Выход: длительность включения сигнала, в 100 мс интервалах (t)
//длительность выключения сигнала, в 100 мс интервалах (T)
//Общая длительность цикла индикации, в 100 мс интервалах (time)
//Значение 0xFFFF – Соответствуют бесконечному времени.
function SetExitRed(Addr: byte; OnTime, OffTime, LengthTime: word): TModbusError;
function GetDemo(Addr: byte; var State: word): TModbusError;
function SetDemo(Addr: byte; State: byte): TModbusError;
//ЖКИ индикатор-----------------------------------------------------
//Вывод 32 символа сообщения
function SetMessage(Addr: byte; AMessage: ansistring): TModbusError;
//Мигание символами сообщения
function SetBlink(Addr: byte; value: longword): TModbusError;
function SetAddress(Addr: byte; NewAddr: byte): TModbusError;
end;
implementation
function TController.GetErrorState(Addr: byte; var Value: word): TModbusError;
begin
result := ReadData(addr, $48, value);
end;
function TController.GetAfterPermissionPassTime(Addr: byte;
var Value: word): TModbusError;
begin
result := ReadData(addr, $3011, value);
end;
function TController.GetAfterStartPassTime(Addr: byte; var Value: word): TModbusError;
begin
result := ReadData(addr, $3012, value);
end;
function TController.GetDemo(Addr:byte; var State: word): TModbusError;
begin
result := ReadData(addr, $666, state);
end;
function TController.GetEngineTime(Addr: byte; var Value: word): TModbusError;
begin
result := ReadData(addr, $48, value);
end;
function TController.GetEnter(Addr: byte; var Value: word): TModbusError;
begin
result := ReadData(addr, $40, value);
end;
function TController.GetEnterCard(Addr: byte; var IsNew: boolean;
var CardNum: TAr; var Count: word): TModbusError;
var
s: ansistring;
OldRM: TRoundingMode;
begin
OldRM := GetRoundMode;
try
FillChar(CardNum, SizeOf(CardNum), #0);
result := ReadData(addr, $100, count);
IsNew := Boolean(hi(count));
count := lo(count);
if (count <> 0) and IsNew then
begin
SetRoundMode(rmUp);
result := ReadData(addr, $101, s, round(count / 2));
if result = merNone then
begin
if (count = 15) and (Byte(s[14]) = $0D) and (Byte(s[15]) = $0A) then
count := count - 2; // -$0D$0A
move(s[1], CardNum[0], count);
end;
end
finally
SetRoundMode(OldRM);
end;
end;
function TController.GetEnterCount(Addr: byte; var Value: longword): TModbusError;
var
n: word;
begin
ReadData(addr, $45, n);
value := n;
result := ReadData(addr, $44, n);
value := value shl 16 + n;
end;
function TController.GetEnterState(Addr: byte; var Value: word): TModbusError;
begin
result := ReadData(addr, $42, value);
end;
function TController.GetExit(Addr: byte; var Value: word): TModbusError;
begin
result := ReadData(addr, $41, value);
end;
function TController.GetExitCard(Addr: byte; var IsNew: boolean;
var CardNum: TAr; var Count: word): TModbusError;
var
s: ansistring;
OldRM: TRoundingMode;
begin
OldRM := GetRoundMode;
try
FillChar(CardNum, SizeOf(CardNum), #0);
result := ReadData(addr, $200, count);
IsNew := Boolean(hi(count));
count := lo(count);
if (count <> 0) and IsNew then
begin
SetRoundMode(rmUp);
result := ReadData(addr, $201, s, round(count / 2));
if result = merNone then
begin
if (count = 15) and (Byte(s[14]) = $0D) and (Byte(s[15]) = $0A) then
count := count - 2; // -$0D$0A
move(s[1], CardNum[0], count);
end;
end
finally
SetRoundMode(OldRM);
end;
end;
function TController.GetExitCount(Addr: byte; var Value: longword): TModbusError;
var
n: word;
begin
ReadData(addr, $47, n);
value := n;
result := ReadData(addr, $46, n);
value := value shl 16 + n;
end;
function TController.GetExitState(Addr: byte; var Value: word): TModbusError;
begin
result := ReadData(addr, $43, value);
end;
function TController.GetPassState(Addr: byte; var Value: word): TModbusError;
begin
result := ReadData(addr, $3000, value);
end;
function TController.ReadData(Addr: byte; RegAddr: word; var Ans: ansistring; Count: byte = 1): TModbusError;
var
param: TAddrQtyRec;
output: TResultRec;
begin
ans := '';
param.Addr := RegAddr;
param.Qty := Count;
Result := FModbus.ReadHoldingRegisters(Addr, param, output);
if Result = merNone then
begin
if output.Qty <> 0 then
begin
SetLength(ans, output.Qty);
move(output.data[1], ans[1], output.Qty);
end;
end;
end;
function TController.ReadData(Addr: byte; RegAddr: word; var Ans: word): TModbusError;
var
param: TAddrQtyRec;
output: TResultRec;
begin
ans := 0;
param.Addr := RegAddr;
param.Qty := 1;
FillChar(output.data, SizeOf(output.data), #0);
Result := FModbus.ReadHoldingRegisters(Addr, param, output);
if Result = merNone then
begin
if output.Qty <> 0 then
ans := output.data[1] shl 8 + output.data[2];
end;
end;
function TController.SetControllerSpeed(Addr: byte; Value: longword): TModbusError;
var
speed, speed2: longint;
begin
speed := trunc(value / 100);
speed2 := not speed;
// result := WriteState(addr, $4310 , [speed, speed2]); //Турникет
result := WriteState(addr, $4310 , [speed]); //Индикатор
result := WriteState(addr, $4312 , [speed2]);
end;
function TController.SetDemo(Addr, State: byte): TModbusError;
begin
result := WriteState(addr, $666, [state]);
end;
function TController.SetEngineTime(Addr, State: byte): TModbusError;
begin
result := WriteState(addr, $48, [state]);
end;
function TController.SetEnter(Addr: byte; State: word): TModbusError;
begin
result := WriteState(addr, $40, [state]);
end;
function TController.SetEnterGreen(Addr: byte; OnTime, OffTime,
LengthTime: word): TModbusError;
begin
result := WriteState(addr, $1000, [OnTime, OffTime, LengthTime]);
end;
function TController.SetEnterRed(Addr: byte; OnTime, OffTime,
LengthTime: word): TModbusError;
begin
result := WriteState(addr, $1003, [OnTime, OffTime, LengthTime]);
end;
function TController.SetExit(Addr:byte; State: word): TModbusError;
begin
result := WriteState(addr, $41, [state]);
end;
function TController.SetExitGreen(Addr: byte; OnTime, OffTime,
LengthTime: word): TModbusError;
begin
result := WriteState(addr, $1008, [OnTime, OffTime, LengthTime]);
end;
function TController.SetExitRed(Addr: byte; OnTime, OffTime,
LengthTime: word): TModbusError;
begin
result := WriteState(addr, $1009, [OnTime, OffTime, LengthTime]);
end;
function TController.SetMessage(Addr: byte; AMessage: ansistring): TModbusError;
var
t: array[0..15] of word;
i, j: byte;
begin
FillChar(t, SizeOf(t), #0);
i := 1;
j := 0;
while i <= length(AMessage) do
begin
t[j]:= ord(AMessage[i]);
t[j] := t[j] shl 8 + ord(AMessage[i + 1]);
i := i + 2;
inc(j);
end;
// move(AMessage[1], t[0], length(AMessage));
result := WriteState(addr, $40, t);
end;
function TController.SetAccumulPas(Addr, State: byte): TModbusError;
begin
result := WriteState(addr, $3010, [state]);
end;
function TController.SetAddress(Addr, NewAddr: byte): TModbusError;
var
t: word;
begin
t := NewAddr;
result := WriteState(addr, $4320, [t]);
t := not t;
result := WriteState(addr, $4322, [t]);
end;
function TController.SetAfterPermissionPassTime(Addr,
State: byte): TModbusError;
begin
result := WriteState(addr, $3011, [state]);
end;
function TController.SetAfterStartPassTime(Addr, State: byte): TModbusError;
begin
result := WriteState(addr, $3012, [state]);
end;
function TController.SetBlink(Addr: byte; value: longword): TModbusError;
begin
result := WriteState(addr, $50, [LongRec(value).Words[0], LongRec(value).Words[1]]);
end;
function TController.SetPassState(Addr, State: byte): TModbusError;
begin
result := WriteState(addr, $3000, [state]);
end;
function TController.SetScannerSpeed(Addr: byte; Value: word): TModbusError;
var
speed: word;
begin
speed := trunc(value / 100);
result := WriteState(addr, $4350, [speed]);
end;
function TController.WriteState(Addr: byte; RegAddr: word;
Value: array of word): TModbusError;
var
arec: TRegDataRec;
i, j: byte;
begin
arec.Addr := RegAddr;
arec.Qty := length(value);
j := 1;
for i := 0 to length(value) - 1 do
begin
arec.data[j] := hi(value[i]);
arec.data[j + 1] := lo(value[i]);
j := j + 2;
end;
Result := FModbus.WriteMultipleRegisters(Addr, arec);
end;
end.
|
unit System_InOut;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ TMyClass }
{ TSystemInOut }
TSystemInOut = class
private // Attribute
read1Data: byte;
newRead1Data: boolean;
protected // Attribute
public // Attribute
public // Konstruktor/Destruktor
constructor Create; overload;
destructor Destroy; override;
private // Methoden
protected // Methoden
public // Methoden
function cpuIoRead(port: word): byte;
procedure cpuIoWrite(port: word; Data: byte);
procedure cpuTXA0(Data: byte);
function cpuCanReadRXA0: boolean;
function cpuRXA0: byte;
procedure cpuTXA1(Data: byte);
function cpuCanReadRXA1: boolean;
function cpuRXA1: byte;
end;
var
SystemInOut: TSystemInOut;
implementation
uses System_Terminal, System_Memory, System_Fdc, System_Hdc, System_Rtc, System_Prt;
// --------------------------------------------------------------------------------
constructor TSystemInOut.Create;
begin
inherited Create;
read1Data := $00;
newRead1Data := False;
end;
// --------------------------------------------------------------------------------
destructor TSystemInOut.Destroy;
begin
inherited Destroy;
end;
// --------------------------------------------------------------------------------
function TSystemInOut.cpuIoRead(port: word): byte;
begin
case (port and $FF) of
$70: begin
Result := SystemFdc.getStatus;
end;
$71: begin
Result := SystemFdc.getTrack;
end;
$72: begin
Result := SystemFdc.getSector;
end;
$73: begin
Result := SystemFdc.getData;
end;
$74: begin
Result := SystemFdc.getExtStatus;
end;
$7D: begin
Result := SystemRtc.Read;
end;
$A0: begin
Result := SystemHdc.getDataLow;
end;
$A1: begin
Result := SystemHdc.getError;
end;
$A2: begin
Result := SystemHdc.getSectorCount;
end;
$A3: begin
Result := SystemHdc.getSector;
end;
$A4: begin
Result := SystemHdc.getTrackLow;
end;
$A5: begin
Result := SystemHdc.getTrackHigh;
end;
$A6: begin
Result := SystemHdc.getDriveHead;
end;
$A7: begin
Result := SystemHdc.getStatus;
end;
$A8: begin
Result := SystemHdc.getDataHigh;
end;
$DB: begin
Result := SystemPrt.getStatus;
end;
else begin
Result := $FF;
end;
end;
end;
// --------------------------------------------------------------------------------
procedure TSystemInOut.cpuIoWrite(port: word; Data: byte);
begin
case (port and $FF) of
$70: begin
SystemFdc.setCommand(Data);
end;
$71: begin
SystemFdc.setTrack(Data);
end;
$72: begin
SystemFdc.setSector(Data);
end;
$73: begin
SystemFdc.setData(Data);
end;
$78: begin
SystemFdc.setExtControl(Data);
end;
$7C: begin
SystemRtc.setAddress(Data);
end;
$7D: begin
SystemRtc.Write(Data);
end;
$A0: begin
SystemHdc.setDataLow(Data);
end;
$A1: begin
SystemHdc.setFeatures(Data);
end;
$A2: begin
SystemHdc.setSectorCount(Data);
end;
$A3: begin
SystemHdc.setSector(Data);
end;
$A4: begin
SystemHdc.setTrackLow(Data);
end;
$A5: begin
SystemHdc.setTrackHigh(Data);
end;
$A6: begin
SystemHdc.setDriveHead(Data);
end;
$A7: begin
SystemHdc.setCommand(Data);
end;
$A8: begin
SystemHdc.setDataHigh(Data);
end;
$DB: begin
SystemPrt.setData(Data);
end;
$FF: begin
SystemMemory.EnableBootRom(False);
end;
end;
end;
// --------------------------------------------------------------------------------
procedure TSystemInOut.cpuTXA0(Data: byte);
begin
SystemTerminal.writeCharacter(Data);
end;
// --------------------------------------------------------------------------------
function TSystemInOut.cpuCanReadRXA0: boolean;
begin
Result := SystemTerminal.terminalReadable;
end;
// --------------------------------------------------------------------------------
function TSystemInOut.cpuRXA0: byte;
begin
Result := SystemTerminal.readCharacter;
end;
// --------------------------------------------------------------------------------
procedure TSystemInOut.cpuTXA1(Data: byte);
begin
end;
// --------------------------------------------------------------------------------
function TSystemInOut.cpuCanReadRXA1: boolean;
begin
Result := newRead1Data;
end;
// --------------------------------------------------------------------------------
function TSystemInOut.cpuRXA1: byte;
begin
newRead1Data := False;
Result := read1Data;
end;
// --------------------------------------------------------------------------------
end.
|
// PaxCompiler
// Site: http://www.paxcompiler.com
// Author: Alexander Baranovsky (paxscript@gmail.com)
// ========================================================================
// Copyright (c) Alexander Baranovsky, 2006-2014. All rights reserved.
// Code Version: 4.2
// ========================================================================
// Unit: PAXCOMP_EMIT.pas
// ========================================================================
////////////////////////////////////////////////////////////////////////////
{$I PaxCompiler.def}
{$R-}
unit PAXCOMP_EMIT;
interface
uses {$I uses.def}
SysUtils,
Classes,
PAXCOMP_CONSTANTS,
PAXCOMP_TYPES,
PAXCOMP_SYS,
PAXCOMP_BYTECODE,
PAXCOMP_MODULE,
PAXCOMP_SYMBOL_REC,
PAXCOMP_VAROBJECT,
PAXCOMP_BASESYMBOL_TABLE,
PAXCOMP_SYMBOL_TABLE,
PAXCOMP_SYMBOL_PROGRAM;
type
TRegisters = class
private
PAX64: Boolean;
A: array[_NOREG.._R15] of Boolean;
public
constructor Create(aPAX64: Boolean);
function GetReg64: Integer;
function GetReg: Integer; overload;
procedure GetReg(Reg: Integer); overload;
procedure FreeReg(Reg: Integer);
end;
TEmitProc = procedure of object;
TEmitter = class
private
kernel: Pointer;
R: TCodeRec;
Prg: TSymbolProg;
Registers: TRegisters;
ContextStack: TIntegerStack;
List1: TList;
List2: TList;
List3: TList;
EmitOff: Boolean;
HandlesEvents: Boolean;
OverflowCheck: Boolean;
EmitList: array of TEmitProc;
procedure EmitSaveRBX;
procedure EmitRestoreRBX;
procedure EmitSaveRDI;
procedure EmitRestoreRDI;
function GetTargetPlatform: TTargetPlatform;
function GetSizeOfPointer: Integer;
procedure CheckSetElement(S: TSymbolRec);
procedure EmitPushParam(Reg: Integer);
procedure EmitPushParam_64(Reg: Integer);
function GetSaveRegAreaOffset: Integer;
procedure SaveRegisters(const A: array of Integer;
ExtraOffset: Integer = 0);
procedure RestoreRegisters(const A: array of Integer;
ExtraOffset: Integer = 0);
procedure EmitStdCall(SubId: Integer; InitSize: Integer = - 1);
procedure EmitCallPro(SubId: Integer; InitSize: Integer = -1);
procedure EmitCallEpi(SubId: Integer; InitSize: Integer = -1);
procedure EmitStdCall_Adr1(SubId: Integer);
procedure EmitStdCall_Adr1_AdrR(SubId: Integer);
procedure EmitStdCall_Adr1_Adr2_AdrR(SubId: Integer);
procedure EmitStdCall_Lang_Adr1_Adr2_AdrR(SubId: Integer);
procedure EmitStdCall_Adr1_from_Int2(SubId: Integer);
procedure EmitStdCall_Adr1_from_Adr2(SubId: Integer);
procedure EmitStdCall_AdrR_from_Adr2(SubId: Integer);
procedure CreateEmitProcList;
procedure EmitNotImpl;
procedure EmitNothing;
procedure EmitComment;
procedure EmitStartSub(SubId: Integer);
procedure EmitFinSub(SubId: Integer);
function GetSymbolRec(Id: Integer): TSymbolRec;
function SymbolTable: TSymbolTable;
function ByteCode: TCode;
function GetOperName: String;
procedure EmitPCodeOperator;
function Lookup(const S: String): Integer;
function GetLanguage: Integer;
function IsLocalPos: Boolean;
procedure EmitCheckOperResult(Reg: Integer);
procedure Emit_PUSH_REGS(SubId: Integer = 0);
procedure Emit_POP_REGS(SubId: Integer = 0);
procedure Emit_PUSH_REGS_EX;
procedure Emit_POP_REGS_EX;
procedure EmitOP_SEPARATOR(I: Integer);
procedure EmitOP_EMIT_ON;
procedure EmitOP_EMIT_OFF;
procedure EmitOP_PUSH_PROG; // stdcall expected on win32
procedure EmitOP_EXPORTS;
procedure EmitOP_EXPORTS_64;
procedure EmitOP_PUSH_ADDRESS;
procedure EmitOP_PUSH_ADDRESS_64;
procedure EmitOP_PUSH_STRUCTURE;
procedure EmitOP_PUSH_STRUCTURE_64;
procedure EmitOP_PUSH_SET;
procedure EmitOP_PUSH_SET_64;
procedure EmitOP_PUSH_INT_IMM;
procedure EmitOP_PUSH_INT_IMM_64;
procedure EmitOP_PUSH_INT;
procedure EmitOP_PUSH_INT_64;
procedure EmitOP_PUSH_INT64;
procedure EmitOP_PUSH_DOUBLE;
procedure EmitOP_PUSH_DOUBLE_64;
procedure EmitOP_PUSH_CURRENCY;
procedure EmitOP_PUSH_SINGLE;
procedure EmitOP_PUSH_SINGLE_64;
procedure EmitOP_PUSH_EXTENDED;
procedure EmitOP_PUSH_ANSISTRING;
procedure EmitOP_PUSH_ANSISTRING_64;
procedure EmitOP_PUSH_WIDESTRING;
procedure EmitOP_PUSH_WIDESTRING_64;
procedure EmitOP_PUSH_UNICSTRING;
procedure EmitOP_PUSH_UNICSTRING_64;
procedure EmitOP_PUSH_SHORTSTRING;
procedure EmitOP_PUSH_SHORTSTRING_64;
{$IFNDEF PAXARM}
procedure EmitOP_PUSH_PANSICHAR_IMM;
procedure EmitOP_PUSH_PANSICHAR_IMM_64;
{$ENDIF}
procedure EmitOP_PUSH_PWIDECHAR_IMM;
procedure EmitOP_PUSH_PWIDECHAR_IMM_64;
procedure EmitOP_PUSH_INST;
procedure EmitOP_PUSH_INST_64;
procedure EmitOP_PUSH_CLSREF;
procedure EmitOP_PUSH_CLSREF_64;
procedure EmitOP_UPDATE_INSTANCE;
procedure EmitOP_UPDATE_INSTANCE_64;
procedure EmitOP_CLEAR_EDX;
procedure EmitOP_CLEAR_EDX_64;
procedure EmitOP_PUSH_DYNARRAY;
procedure EmitOP_PUSH_DYNARRAY_64;
procedure EmitOP_PUSH_OPENARRAY;
procedure EmitOP_PUSH_OPENARRAY_64;
procedure EmitOP_PUSH_DATA;
procedure EmitOP_PUSH_DATA_64;
procedure EmitOP_PUSH_EVENT;
procedure EmitOP_PUSH_EVENT_64;
procedure EmitOP_CALL;
procedure EmitOP_CALL_64;
procedure EmitOP_BEGIN_CALL;
procedure EmitOP_BEGIN_CALL_64;
procedure EmitOP_CURRENCY_FROM_INT;
procedure EmitOP_CURRENCY_FROM_INT_64;
procedure EmitOP_CURRENCY_FROM_INT64;
procedure EmitOP_CURRENCY_FROM_INT64_64;
procedure EmitOP_CURRENCY_FROM_REAL;
procedure EmitOP_CURRENCY_FROM_REAL_64;
procedure EmitOP_ASSIGN_INT_I;
procedure EmitOP_ASSIGN_INT_I_64;
procedure EmitOP_ASSIGN_INT_M;
procedure EmitOP_ASSIGN_INT_M_64;
procedure EmitOP_ASSIGN_PANSICHAR;
procedure EmitOP_ASSIGN_PANSICHAR_64;
procedure EmitOP_ASSIGN_PWIDECHAR;
procedure EmitOP_ASSIGN_PWIDECHAR_64;
procedure EmitOP_ASSIGN_DOUBLE;
procedure EmitOP_ASSIGN_DOUBLE_64;
procedure EmitOP_ASSIGN_CURRENCY;
procedure EmitOP_ASSIGN_CURRENCY_64;
procedure EmitOP_ASSIGN_EVENT;
procedure EmitOP_ASSIGN_EVENT_64;
procedure EmitOP_ASSIGN_SINGLE;
procedure EmitOP_ASSIGN_SINGLE_64;
procedure EmitOP_ASSIGN_EXTENDED;
procedure EmitOP_ASSIGN_EXTENDED_64;
procedure EmitOP_ASSIGN_INT64;
procedure EmitOP_ASSIGN_INT64_64;
procedure EmitOP_ASSIGN_RECORD;
procedure EmitOP_ASSIGN_RECORD_64;
procedure EmitOP_ASSIGN_RECORD_EX;
procedure EmitOP_ASSIGN_INTERFACE;
procedure EmitOP_ASSIGN_INTERFACE_64;
procedure EmitOP_CREATE_EVENT;
procedure EmitOP_CREATE_EVENT_64;
procedure EmitOP_INT_FROM_INT64;
procedure EmitOP_INT_FROM_INT64_64;
procedure EmitOP_BYTE_FROM_INT64;
procedure EmitOP_BYTE_FROM_INT64_64;
procedure EmitOP_WORD_FROM_INT64;
procedure EmitOP_WORD_FROM_INT64_64;
procedure EmitOP_CARDINAL_FROM_INT64;
procedure EmitOP_CARDINAL_FROM_INT64_64;
procedure EmitOP_SMALLINT_FROM_INT64;
procedure EmitOP_SMALLINT_FROM_INT64_64;
procedure EmitOP_SHORTINT_FROM_INT64;
procedure EmitOP_SHORTINT_FROM_INT64_64;
procedure EmitOP_ADD_INT64;
procedure EmitOP_ADD_INT64_64;
procedure EmitOP_SUB_INT64;
procedure EmitOP_SUB_INT64_64;
procedure EmitOP_AND_INT64;
procedure EmitOP_AND_INT64_64;
procedure EmitOP_OR_INT64;
procedure EmitOP_OR_INT64_64;
procedure EmitOP_XOR_INT64;
procedure EmitOP_ABS_INT64;
procedure EmitOP_ABS_INT64_64;
procedure EmitOP_ADD_UINT64;
procedure EmitOP_ADD_UINT64_64;
procedure EmitOP_SUB_UINT64;
procedure EmitOP_SUB_UINT64_64;
procedure EmitOP_AND_UINT64;
procedure EmitOP_AND_UINT64_64;
procedure EmitOP_OR_UINT64;
procedure EmitOP_OR_UINT64_64;
procedure EmitOP_XOR_UINT64;
procedure EmitOP_LT_INT64;
procedure EmitOP_LT_INT64_64;
procedure EmitOP_LE_INT64;
procedure EmitOP_LE_INT64_64;
procedure EmitOP_GT_INT64;
procedure EmitOP_GT_INT64_64;
procedure EmitOP_GE_INT64;
procedure EmitOP_GE_INT64_64;
procedure EmitOP_EQ_INT64;
procedure EmitOP_EQ_INT64_64;
procedure EmitOP_NE_INT64;
procedure EmitOP_NE_INT64_64;
procedure EmitOP_LT_UINT64;
procedure EmitOP_LT_UINT64_64;
procedure EmitOP_LE_UINT64;
procedure EmitOP_LE_UINT64_64;
procedure EmitOP_GT_UINT64;
procedure EmitOP_GT_UINT64_64;
procedure EmitOP_GE_UINT64;
procedure EmitOP_GE_UINT64_64;
procedure EmitOP_EQ_STRUCT;
procedure EmitOP_EQ_STRUCT_64;
procedure EmitOP_NE_STRUCT;
procedure EmitOP_NE_STRUCT_64;
procedure EmitOP_ADD_CURRENCY;
procedure EmitOP_ADD_CURRENCY_64;
procedure EmitOP_SUB_CURRENCY;
procedure EmitOP_SUB_CURRENCY_64;
procedure EmitOP_MUL_CURRENCY;
procedure EmitOP_MUL_CURRENCY_64;
procedure EmitOP_DIV_CURRENCY;
procedure EmitOP_DIV_CURRENCY_64;
procedure EmitOP_ADD_INT_MI;
procedure EmitOP_ADD_INT_MI_64;
procedure EmitOP_ADD_INT_MM;
procedure EmitOP_ADD_INT_MM_64;
procedure EmitOP_ADD_DOUBLE;
procedure EmitOP_ADD_DOUBLE_64;
procedure EmitOP_ADD_SINGLE;
procedure EmitOP_ADD_SINGLE_64;
procedure EmitOP_ADD_EXTENDED;
procedure EmitOP_ADD_EXTENDED_64;
procedure EmitOP_SUB_INT_MI;
procedure EmitOP_SUB_INT_MI_64;
procedure EmitOP_SUB_INT_MM;
procedure EmitOP_SUB_INT_MM_64;
procedure EmitOP_SUB_DOUBLE;
procedure EmitOP_SUB_DOUBLE_64;
procedure EmitOP_SUB_SINGLE;
procedure EmitOP_SUB_SINGLE_64;
procedure EmitOP_SUB_EXTENDED;
procedure EmitOP_SUB_EXTENDED_64;
procedure EmitOP_NEG_INT;
procedure EmitOP_NEG_INT_64;
procedure EmitOP_NEG_INT64;
procedure EmitOP_NEG_INT64_64;
procedure EmitOP_NOT;
procedure EmitOP_NOT_64;
procedure EmitOP_NOT_BOOL;
procedure EmitOP_NOT_BOOL64;
procedure EmitOP_NOT_BYTEBOOL;
procedure EmitOP_NOT_BYTEBOOL64;
procedure EmitOP_NOT_WORDBOOL;
procedure EmitOP_NOT_WORDBOOL64;
procedure EmitOP_NOT_LONGBOOL;
procedure EmitOP_NOT_LONGBOOL64;
procedure EmitOP_NEG_DOUBLE;
procedure EmitOP_NEG_DOUBLE_64;
procedure EmitOP_NEG_CURRENCY;
procedure EmitOP_NEG_CURRENCY_64;
procedure EmitOP_NEG_SINGLE;
procedure EmitOP_NEG_SINGLE_64;
procedure EmitOP_NEG_EXTENDED;
procedure EmitOP_NEG_EXTENDED_64;
procedure EmitOP_ABS_INT;
procedure EmitOP_ABS_INT_64;
procedure EmitOP_ABS_DOUBLE;
procedure EmitOP_ABS_DOUBLE_64;
procedure EmitOP_ABS_SINGLE;
procedure EmitOP_ABS_SINGLE_64;
procedure EmitOP_ABS_EXTENDED;
procedure EmitOP_ABS_EXTENDED_64;
procedure EmitOP_ABS_CURRENCY;
procedure EmitOP_ABS_CURRENCY_64;
procedure EmitOP_IMUL_INT_MI;
procedure EmitOP_IMUL_INT_MI_64;
procedure EmitOP_IMUL_INT_MM;
procedure EmitOP_IMUL_INT_MM_64;
procedure EmitOP_MUL_DOUBLE;
procedure EmitOP_MUL_DOUBLE_64;
procedure EmitOP_MUL_SINGLE;
procedure EmitOP_MUL_SINGLE_64;
procedure EmitOP_MUL_EXTENDED;
procedure EmitOP_MUL_EXTENDED_64;
procedure EmitOP_IDIV_INT_MI;
procedure EmitOP_IDIV_INT_MI_64;
procedure EmitOP_IDIV_INT_MM;
procedure EmitOP_IDIV_INT_MM_64;
procedure EmitOP_IDIV_INT_IM;
procedure EmitOP_IDIV_INT_IM_64;
procedure EmitOP_DIV_DOUBLE;
procedure EmitOP_DIV_DOUBLE_64;
procedure EmitOP_DIV_SINGLE;
procedure EmitOP_DIV_SINGLE_64;
procedure EmitOP_DIV_EXTENDED;
procedure EmitOP_DIV_EXTENDED_64;
procedure EmitOP_MOD_INT_MI;
procedure EmitOP_MOD_INT_MI_64;
procedure EmitOP_MOD_INT_MM;
procedure EmitOP_MOD_INT_MM_64;
procedure EmitOP_MOD_INT_IM;
procedure EmitOP_MOD_INT_IM_64;
procedure EmitOP_SHL_INT_MI;
procedure EmitOP_SHL_INT_MI_64;
procedure EmitOP_SHL_INT_MM;
procedure EmitOP_SHL_INT_MM_64;
procedure EmitOP_SHL_INT_IM;
procedure EmitOP_SHL_INT_IM_64;
procedure EmitOP_SHR_INT_MI;
procedure EmitOP_SHR_INT_MI_64;
procedure EmitOP_SHR_INT_MM;
procedure EmitOP_SHR_INT_MM_64;
procedure EmitOP_SHR_INT_IM;
procedure EmitOP_SHR_INT_IM_64;
procedure EmitOP_AND_INT_MI;
procedure EmitOP_AND_INT_MI_64;
procedure EmitOP_AND_INT_MM;
procedure EmitOP_AND_INT_MM_64;
procedure EmitOP_OR_INT_MI;
procedure EmitOP_OR_INT_MI_64;
procedure EmitOP_OR_INT_MM;
procedure EmitOP_OR_INT_MM_64;
procedure EmitOP_XOR_INT_MI;
procedure EmitOP_XOR_INT_MI_64;
procedure EmitOP_XOR_INT_MM;
procedure EmitOP_XOR_INT_MM_64;
procedure EmitOP_LT_INT_MI;
procedure EmitOP_LT_INT_MI_64;
procedure EmitOP_LT_INT_MM;
procedure EmitOP_LT_INT_MM_64;
procedure EmitOP_LE_INT_MI;
procedure EmitOP_LE_INT_MI_64;
procedure EmitOP_LE_INT_MM;
procedure EmitOP_LE_INT_MM_64;
procedure EmitOP_GT_INT_MI;
procedure EmitOP_GT_INT_MI_64;
procedure EmitOP_GT_INT_MM;
procedure EmitOP_GT_INT_MM_64;
procedure EmitOP_GE_INT_MI;
procedure EmitOP_GE_INT_MI_64;
procedure EmitOP_GE_INT_MM;
procedure EmitOP_GE_INT_MM_64;
procedure EmitOP_EQ_INT_MI;
procedure EmitOP_EQ_INT_MI_64;
procedure EmitOP_EQ_INT_MM;
procedure EmitOP_EQ_INT_MM_64;
procedure EmitOP_NE_INT_MI;
procedure EmitOP_NE_INT_MI_64;
procedure EmitOP_NE_INT_MM;
procedure EmitOP_NE_INT_MM_64;
procedure EmitOP_LT_DOUBLE;
procedure EmitOP_LT_DOUBLE_64;
procedure EmitOP_LE_DOUBLE;
procedure EmitOP_LE_DOUBLE_64;
procedure EmitOP_GT_DOUBLE;
procedure EmitOP_GT_DOUBLE_64;
procedure EmitOP_GE_DOUBLE;
procedure EmitOP_GE_DOUBLE_64;
procedure EmitOP_EQ_DOUBLE;
procedure EmitOP_EQ_DOUBLE_64;
procedure EmitOP_NE_DOUBLE;
procedure EmitOP_NE_DOUBLE_64;
procedure EmitOP_LT_CURRENCY;
procedure EmitOP_LT_CURRENCY_64;
procedure EmitOP_LE_CURRENCY;
procedure EmitOP_LE_CURRENCY_64;
procedure EmitOP_GT_CURRENCY;
procedure EmitOP_GT_CURRENCY_64;
procedure EmitOP_GE_CURRENCY;
procedure EmitOP_GE_CURRENCY_64;
procedure EmitOP_EQ_CURRENCY;
procedure EmitOP_EQ_CURRENCY_64;
procedure EmitOP_NE_CURRENCY;
procedure EmitOP_NE_CURRENCY_64;
procedure EmitOP_LT_SINGLE;
procedure EmitOP_LT_SINGLE_64;
procedure EmitOP_LE_SINGLE;
procedure EmitOP_LE_SINGLE_64;
procedure EmitOP_GT_SINGLE;
procedure EmitOP_GT_SINGLE_64;
procedure EmitOP_GE_SINGLE;
procedure EmitOP_GE_SINGLE_64;
procedure EmitOP_EQ_SINGLE;
procedure EmitOP_EQ_SINGLE_64;
procedure EmitOP_NE_SINGLE;
procedure EmitOP_NE_SINGLE_64;
procedure EmitOP_LT_EXTENDED;
procedure EmitOP_LT_EXTENDED_64;
procedure EmitOP_LE_EXTENDED;
procedure EmitOP_LE_EXTENDED_64;
procedure EmitOP_GT_EXTENDED;
procedure EmitOP_GT_EXTENDED_64;
procedure EmitOP_GE_EXTENDED;
procedure EmitOP_GE_EXTENDED_64;
procedure EmitOP_EQ_EXTENDED;
procedure EmitOP_EQ_EXTENDED_64;
procedure EmitOP_NE_EXTENDED;
procedure EmitOP_NE_EXTENDED_64;
procedure EmitOP_INIT_SUB;
procedure EmitOP_INIT_SUB_64;
procedure EmitOP_END_SUB;
procedure EmitOP_END_SUB_64;
procedure EmitOP_FIN_SUB;
procedure EmitOP_FIN_SUB_64;
procedure EmitOP_RET;
procedure EmitOP_RET_64;
procedure EmitOP_PUSH_EBP;
procedure EmitOP_PUSH_EBP_64;
procedure EmitOP_POP;
procedure EmitOP_POP_64;
procedure EmitOP_SAVE_REGS;
procedure EmitOP_SAVE_REGS_64;
procedure EmitOP_RESTORE_REGS;
procedure EmitOP_RESTORE_REGS_64;
procedure EmitOP_FIELD;
procedure EmitOP_FIELD_64;
procedure EmitOP_ELEM;
procedure EmitOP_ELEM_64;
procedure EmitOP_GET_COMPONENT;
procedure EmitOP_GET_COMPONENT_64;
procedure EmitOP_PRINT_EX;
procedure EmitOP_PRINT_EX_64;
procedure EmitOP_TO_FW_OBJECT;
procedure EmitOP_TO_FW_OBJECT_64;
procedure EmitOP_INT_TO_INT64;
procedure EmitOP_INT_TO_INT64_64;
procedure EmitOP_BYTE_TO_INT64;
procedure EmitOP_BYTE_TO_INT64_64;
procedure EmitOP_WORD_TO_INT64;
procedure EmitOP_WORD_TO_INT64_64;
procedure EmitOP_CARDINAL_TO_INT64;
procedure EmitOP_CARDINAL_TO_INT64_64;
procedure EmitOP_SMALLINT_TO_INT64;
procedure EmitOP_SMALLINT_TO_INT64_64;
procedure EmitOP_SHORTINT_TO_INT64;
procedure EmitOP_SHORTINT_TO_INT64_64;
procedure EmitOP_INT_TO_DOUBLE;
procedure EmitOP_INT_TO_DOUBLE_64;
procedure EmitOP_INT64_TO_DOUBLE;
procedure EmitOP_INT64_TO_DOUBLE_64;
procedure EmitOP_INT_TO_SINGLE;
procedure EmitOP_INT_TO_SINGLE_64;
procedure EmitOP_INT64_TO_SINGLE;
procedure EmitOP_INT64_TO_SINGLE_64;
procedure EmitOP_INT_TO_EXTENDED;
procedure EmitOP_INT_TO_EXTENDED_64;
procedure EmitOP_INT64_TO_EXTENDED;
procedure EmitOP_INT64_TO_EXTENDED_64;
procedure EmitOP_MULT_INT64;
procedure EmitOP_MULT_INT64_64;
procedure EmitOP_IDIV_INT64;
procedure EmitOP_IDIV_INT64_64;
procedure EmitOP_MOD_INT64;
procedure EmitOP_MOD_INT64_64;
procedure EmitOP_SHL_INT64_64;
procedure EmitOP_SHL_INT64;
procedure EmitOP_SHR_INT64_64;
procedure EmitOP_SHR_INT64;
procedure EmitOP_CURRENCY_TO_EXTENDED;
procedure EmitOP_CURRENCY_TO_EXTENDED_64;
procedure EmitOP_CURRENCY_TO_SINGLE;
procedure EmitOP_CURRENCY_TO_SINGLE_64;
procedure EmitOP_DOUBLE_TO_SINGLE;
procedure EmitOP_DOUBLE_TO_SINGLE_64;
procedure EmitOP_DOUBLE_TO_EXTENDED;
procedure EmitOP_DOUBLE_TO_EXTENDED_64;
procedure EmitOP_SINGLE_TO_DOUBLE;
procedure EmitOP_SINGLE_TO_DOUBLE_64;
procedure EmitOP_CURRENCY_TO_DOUBLE;
procedure EmitOP_CURRENCY_TO_DOUBLE_64;
procedure EmitOP_SINGLE_TO_EXTENDED;
procedure EmitOP_SINGLE_TO_EXTENDED_64;
procedure EmitOP_EXTENDED_TO_DOUBLE;
procedure EmitOP_EXTENDED_TO_DOUBLE_64;
procedure EmitOP_EXTENDED_TO_SINGLE;
procedure EmitOP_EXTENDED_TO_SINGLE_64;
procedure EmitOP_GO;
procedure EmitOP_GO_1;
procedure EmitOP_GO_2;
procedure EmitOP_GO_3;
procedure EmitOP_GO_TRUE;
procedure EmitOP_GO_TRUE_64;
procedure EmitOP_GO_FALSE;
procedure EmitOP_GO_FALSE_64;
procedure EmitOP_GO_DL;
procedure EmitOP_GO_DL_64;
procedure EmitOP_SAVE_EDX;
procedure EmitOP_SAVE_EDX_64;
procedure EmitOP_RESTORE_EDX;
procedure EmitOP_RESTORE_EDX_64;
procedure EmitOP_ADDRESS;
procedure EmitOP_ADDRESS_64;
procedure EmitOP_TERMINAL;
procedure EmitOP_TERMINAL_64;
procedure EmitOP_ADDRESS_PROG;
procedure EmitOP_ADDRESS_PROG_64;
procedure EmitOP_ASSIGN_PROG;
procedure EmitOP_ASSIGN_PROG_64;
procedure EmitOP_SET_INCLUDE;
procedure EmitOP_SET_INCLUDE_64;
procedure EmitOP_SET_INCLUDE_INTERVAL;
procedure EmitOP_SET_INCLUDE_INTERVAL_64;
procedure EmitOP_SET_EXCLUDE;
procedure EmitOP_SET_EXCLUDE_64;
procedure EmitOP_SET_UNION;
procedure EmitOP_SET_UNION_64;
procedure EmitOP_SET_DIFFERENCE;
procedure EmitOP_SET_DIFFERENCE_64;
procedure EmitOP_SET_INTERSECTION;
procedure EmitOP_SET_INTERSECTION_64;
procedure EmitOP_SET_SUBSET;
procedure EmitOP_SET_SUBSET_64;
procedure EmitOP_SET_SUPERSET;
procedure EmitOP_SET_SUPERSET_64;
procedure EmitOP_SET_EQUALITY;
procedure EmitOP_SET_EQUALITY_64;
procedure EmitOP_SET_INEQUALITY;
procedure EmitOP_SET_INEQUALITY_64;
procedure EmitOP_SET_MEMBERSHIP;
procedure EmitOP_SET_MEMBERSHIP_64;
procedure EmitOP_SET_ASSIGN;
procedure EmitOP_SET_ASSIGN_64;
procedure EmitOP_SET_COUNTER_ASSIGN;
procedure EmitOP_SET_COUNTER_ASSIGN_64;
procedure EmitOP_ERR_ABSTRACT;
procedure EmitOP_ERR_ABSTRACT_64;
procedure EmitOP_LOAD_PROC;
procedure EmitOP_LOAD_PROC_64;
procedure EmitOP_ADD_MESSAGE;
procedure EmitOP_ADD_MESSAGE_64;
procedure EmitOP_BEGIN_CRT_JS_FUNC_OBJECT;
procedure EmitOP_BEGIN_CRT_JS_FUNC_OBJECT_64;
procedure EmitOP_END_CRT_JS_FUNC_OBJECT;
procedure EmitOP_END_CRT_JS_FUNC_OBJECT_64;
procedure EmitOP_TO_JS_OBJECT;
procedure EmitOP_TO_JS_OBJECT_64;
procedure EmitOP_JS_TYPEOF;
procedure EmitOP_JS_TYPEOF_64;
procedure EmitOP_JS_VOID;
procedure EmitOP_JS_VOID_64;
procedure EmitOP_GET_NEXTJSPROP;
procedure EmitOP_GET_NEXTJSPROP_64;
procedure EmitOP_CLEAR_REFERENCES;
procedure EmitOP_CLEAR_REFERENCES_64;
procedure EmitOP_CREATE_METHOD;
procedure EmitOP_CREATE_METHOD_64;
procedure EmitOP_VAR_FROM_TVALUE;
procedure EmitOP_VAR_FROM_TVALUE_64;
procedure EmitOP_INIT_PCHAR_LITERAL;
procedure EmitOP_INIT_PWIDECHAR_LITERAL;
procedure EmitOP_ANSISTRING_FROM_PANSICHAR;
procedure EmitOP_ANSISTRING_FROM_PANSICHAR_64;
procedure EmitOP_ANSISTRING_FROM_PWIDECHAR;
procedure EmitOP_ANSISTRING_FROM_PWIDECHAR_64;
procedure EmitOP_ANSISTRING_FROM_ANSICHAR;
procedure EmitOP_ANSISTRING_FROM_ANSICHAR_64;
procedure EmitOP_ASSIGN_ANSISTRING;
procedure EmitOP_ASSIGN_ANSISTRING_64;
{$IFNDEF PAXARM}
procedure EmitOP_ASSIGN_SHORTSTRING;
procedure EmitOP_ASSIGN_SHORTSTRING_64;
{$ENDIF}
procedure EmitOP_ASSIGN_WIDESTRING;
procedure EmitOP_ASSIGN_WIDESTRING_64;
procedure EmitOP_ASSIGN_UNICSTRING;
procedure EmitOP_ASSIGN_UNICSTRING_64;
procedure EmitOP_ADD_ANSISTRING;
procedure EmitOP_ADD_ANSISTRING_64;
procedure EmitOP_ADD_SHORTSTRING;
procedure EmitOP_ADD_SHORTSTRING_64;
procedure EmitOP_ADD_WIDESTRING;
procedure EmitOP_ADD_WIDESTRING_64;
procedure EmitOP_ADD_UNICSTRING;
procedure EmitOP_ADD_UNICSTRING_64;
procedure EmitOP_SET_LENGTH;
procedure EmitOP_SET_LENGTH_64;
procedure EmitOP_SET_LENGTH_EX;
procedure EmitOP_SET_LENGTH_EX_64;
procedure EmitOP_ANSISTRING_CLR;
procedure EmitOP_ANSISTRING_CLR_64;
procedure EmitOP_WIDESTRING_CLR;
procedure EmitOP_WIDESTRING_CLR_64;
procedure EmitOP_UNICSTRING_CLR;
procedure EmitOP_UNICSTRING_CLR_64;
procedure EmitOP_INTERFACE_CLR;
procedure EmitOP_INTERFACE_CLR_64;
procedure EmitOP_STRUCTURE_CLR;
procedure EmitOP_STRUCTURE_CLR_64;
procedure EmitOP_CLASS_CLR;
procedure EmitOP_CLASS_CLR_64;
procedure EmitOP_STRUCTURE_ADDREF;
procedure EmitOP_STRUCTURE_ADDREF_64;
procedure EmitOP_ADDREF_64;
procedure EmitOP_ADDREF;
procedure EmitOP_DYNARRAY_CLR;
procedure EmitOP_DYNARRAY_CLR_64;
procedure EmitOP_DYNARRAY_HIGH;
procedure EmitOP_DYNARRAY_HIGH_64;
procedure EmitOP_DYNARRAY_ASSIGN;
procedure EmitOP_DYNARRAY_ASSIGN_64;
procedure EmitOP_CREATE_EMPTY_DYNARRAY;
procedure EmitOP_CREATE_EMPTY_DYNARRAY_64;
procedure EmitOP_ASSIGN_TVarRec;
procedure EmitOP_ASSIGN_TVarRec_64;
{$IFNDEF PAXARM}
procedure EmitOP_SHORTSTRING_FROM_PANSICHAR_LITERAL;
procedure EmitOP_SHORTSTRING_FROM_PANSICHAR_LITERAL_64;
procedure EmitOP_SHORTSTRING_FROM_PWIDECHAR_LITERAL;
procedure EmitOP_SHORTSTRING_FROM_PWIDECHAR_LITERAL_64;
procedure EmitOP_SHORTSTRING_FROM_ANSISTRING;
procedure EmitOP_SHORTSTRING_FROM_ANSISTRING_64;
procedure EmitOP_SHORTSTRING_FROM_WIDESTRING;
procedure EmitOP_SHORTSTRING_FROM_WIDESTRING_64;
procedure EmitOP_SHORTSTRING_FROM_UNICSTRING;
procedure EmitOP_SHORTSTRING_FROM_UNICSTRING_64;
{$ENDIF}
procedure EmitOP_SHORTSTRING_FROM_ANSICHAR;
procedure EmitOP_SHORTSTRING_FROM_ANSICHAR_64;
procedure EmitOP_SHORTSTRING_FROM_WIDECHAR;
procedure EmitOP_SHORTSTRING_FROM_WIDECHAR_64;
procedure EmitOP_UNICSTRING_FROM_WIDESTRING;
procedure EmitOP_UNICSTRING_FROM_WIDESTRING_64;
procedure EmitOP_ANSISTRING_FROM_SHORTSTRING;
procedure EmitOP_ANSISTRING_FROM_SHORTSTRING_64;
procedure EmitOP_WIDESTRING_FROM_PANSICHAR_LITERAL;
procedure EmitOP_WIDESTRING_FROM_PANSICHAR_LITERAL_64;
procedure EmitOP_WIDESTRING_FROM_PWIDECHAR_LITERAL;
procedure EmitOP_WIDESTRING_FROM_PWIDECHAR_LITERAL_64;
procedure EmitOP_WIDESTRING_FROM_ANSICHAR;
procedure EmitOP_WIDESTRING_FROM_ANSICHAR_64;
procedure EmitOP_WIDESTRING_FROM_WIDECHAR;
procedure EmitOP_WIDESTRING_FROM_WIDECHAR_64;
procedure EmitOP_ANSISTRING_FROM_WIDECHAR;
procedure EmitOP_ANSISTRING_FROM_WIDECHAR_64;
procedure EmitOP_WIDESTRING_FROM_WIDECHAR_LITERAL;
procedure EmitOP_WIDESTRING_FROM_WIDECHAR_LITERAL_64;
procedure EmitOP_WIDESTRING_FROM_ANSISTRING;
procedure EmitOP_WIDESTRING_FROM_ANSISTRING_64;
procedure EmitOP_UNICSTRING_FROM_ANSISTRING;
procedure EmitOP_UNICSTRING_FROM_ANSISTRING_64;
procedure EmitOP_WIDESTRING_FROM_SHORTSTRING;
procedure EmitOP_WIDESTRING_FROM_SHORTSTRING_64;
procedure EmitOP_WIDESTRING_FROM_UNICSTRING;
procedure EmitOP_WIDESTRING_FROM_UNICSTRING_64;
procedure EmitOP_UNICSTRING_FROM_SHORTSTRING;
procedure EmitOP_UNICSTRING_FROM_SHORTSTRING_64;
procedure EmitOP_ANSISTRING_FROM_WIDESTRING;
procedure EmitOP_ANSISTRING_FROM_WIDESTRING_64;
procedure EmitOP_ANSISTRING_FROM_UNICSTRING;
procedure EmitOP_ANSISTRING_FROM_UNICSTRING_64;
procedure EmitOP_UNICSTRING_FROM_PANSICHAR_LITERAL;
procedure EmitOP_UNICSTRING_FROM_PANSICHAR_LITERAL_64;
procedure EmitOP_UNICSTRING_FROM_PWIDECHAR_LITERAL;
procedure EmitOP_UNICSTRING_FROM_PWIDECHAR_LITERAL_64;
procedure EmitOP_UNICSTRING_FROM_ANSICHAR;
procedure EmitOP_UNICSTRING_FROM_ANSICHAR_64;
procedure EmitOP_UNICSTRING_FROM_WIDECHAR;
procedure EmitOP_UNICSTRING_FROM_WIDECHAR_64;
procedure EmitOP_UNICSTRING_FROM_WIDECHAR_LITERAL;
procedure EmitOP_UNICSTRING_FROM_WIDECHAR_LITERAL_64;
procedure EmitOP_SHORTSTRING_HIGH;
procedure EmitOP_SHORTSTRING_HIGH_64;
procedure EmitOP_EQ_ANSISTRING;
procedure EmitOP_EQ_ANSISTRING_64;
procedure EmitOP_NE_ANSISTRING;
procedure EmitOP_NE_ANSISTRING_64;
procedure EmitOP_EQ_SHORTSTRING;
procedure EmitOP_EQ_SHORTSTRING_64;
procedure EmitOP_NE_SHORTSTRING;
procedure EmitOP_NE_SHORTSTRING_64;
procedure EmitOP_EQ_WIDESTRING;
procedure EmitOP_EQ_WIDESTRING_64;
procedure EmitOP_EQ_UNICSTRING;
procedure EmitOP_EQ_UNICSTRING_64;
procedure EmitOP_NE_WIDESTRING;
procedure EmitOP_NE_WIDESTRING_64;
procedure EmitOP_NE_UNICSTRING;
procedure EmitOP_NE_UNICSTRING_64;
procedure EmitOP_GT_ANSISTRING;
procedure EmitOP_GT_ANSISTRING_64;
procedure EmitOP_GE_ANSISTRING;
procedure EmitOP_GE_ANSISTRING_64;
procedure EmitOP_LT_ANSISTRING;
procedure EmitOP_LT_ANSISTRING_64;
procedure EmitOP_LE_ANSISTRING;
procedure EmitOP_LE_ANSISTRING_64;
procedure EmitOP_GT_SHORTSTRING;
procedure EmitOP_GT_SHORTSTRING_64;
procedure EmitOP_GE_SHORTSTRING;
procedure EmitOP_GE_SHORTSTRING_64;
procedure EmitOP_LT_SHORTSTRING;
procedure EmitOP_LT_SHORTSTRING_64;
procedure EmitOP_LE_SHORTSTRING;
procedure EmitOP_LE_SHORTSTRING_64;
procedure EmitOP_GT_WIDESTRING;
procedure EmitOP_GT_WIDESTRING_64;
procedure EmitOP_GE_WIDESTRING;
procedure EmitOP_GE_WIDESTRING_64;
procedure EmitOP_LT_WIDESTRING;
procedure EmitOP_LT_WIDESTRING_64;
procedure EmitOP_LE_WIDESTRING;
procedure EmitOP_LE_WIDESTRING_64;
procedure EmitOP_GT_UNICSTRING;
procedure EmitOP_GT_UNICSTRING_64;
procedure EmitOP_GE_UNICSTRING;
procedure EmitOP_GE_UNICSTRING_64;
procedure EmitOP_LT_UNICSTRING;
procedure EmitOP_LT_UNICSTRING_64;
procedure EmitOP_LE_UNICSTRING;
procedure EmitOP_LE_UNICSTRING_64;
procedure EmitOP_VARIANT_FROM_CLASS; // JS only
procedure EmitOP_VARIANT_FROM_CLASS_64; // JS only
procedure EmitOP_VARIANT_FROM_POINTER; //JS only
procedure EmitOP_VARIANT_FROM_POINTER_64; //JS only
procedure EmitOP_CLASS_FROM_VARIANT; // JS only
procedure EmitOP_CLASS_FROM_VARIANT_64; // JS only
procedure EmitOP_INTERFACE_FROM_CLASS;
procedure EmitOP_INTERFACE_FROM_CLASS_64;
procedure EmitOP_INTERFACE_CAST;
procedure EmitOP_INTERFACE_CAST_64;
procedure EmitOP_LOCK_VARRAY;
procedure EmitOP_LOCK_VARRAY_64;
procedure EmitOP_UNLOCK_VARRAY;
procedure EmitOP_UNLOCK_VARRAY_64;
procedure EmitOP_VARIANT_CLR;
procedure EmitOP_VARIANT_CLR_64;
procedure EmitOP_ASSIGN_VARIANT;
procedure EmitOP_ASSIGN_VARIANT_64;
procedure EmitOP_ASSIGN_OLEVARIANT;
procedure EmitOP_ASSIGN_OLEVARIANT_64;
procedure EmitOP_ASSIGN_CLASS;
procedure EmitOP_ASSIGN_CLASS_64;
procedure EmitOP_VARIANT_FROM_PANSICHAR_LITERAL;
procedure EmitOP_VARIANT_FROM_PANSICHAR_LITERAL_64;
procedure EmitOP_VARIANT_FROM_PWIDECHAR_LITERAL;
procedure EmitOP_VARIANT_FROM_PWIDECHAR_LITERAL_64;
procedure EmitOP_VARIANT_FROM_ANSISTRING;
procedure EmitOP_VARIANT_FROM_ANSISTRING_64;
procedure EmitOP_VARIANT_FROM_WIDESTRING;
procedure EmitOP_VARIANT_FROM_WIDESTRING_64;
procedure EmitOP_VARIANT_FROM_UNICSTRING;
procedure EmitOP_VARIANT_FROM_UNICSTRING_64;
procedure EmitOP_VARIANT_FROM_SHORTSTRING;
procedure EmitOP_VARIANT_FROM_SHORTSTRING_64;
procedure EmitOP_VARIANT_FROM_ANSICHAR;
procedure EmitOP_VARIANT_FROM_ANSICHAR_64;
procedure EmitOP_VARIANT_FROM_WIDECHAR;
procedure EmitOP_VARIANT_FROM_WIDECHAR_64;
procedure EmitOP_VARIANT_FROM_WIDECHAR_LITERAL;
procedure EmitOP_VARIANT_FROM_WIDECHAR_LITERAL_64;
procedure EmitOP_VARIANT_FROM_INT;
procedure EmitOP_VARIANT_FROM_INT_64;
procedure EmitOP_VARIANT_FROM_INT64;
procedure EmitOP_VARIANT_FROM_INT64_64;
procedure EmitOP_VARIANT_FROM_BYTE;
procedure EmitOP_VARIANT_FROM_BYTE_64;
procedure EmitOP_VARIANT_FROM_BOOL;
procedure EmitOP_VARIANT_FROM_BOOL_64;
procedure EmitOP_VARIANT_FROM_WORD;
procedure EmitOP_VARIANT_FROM_WORD_64;
procedure EmitOP_VARIANT_FROM_CARDINAL;
procedure EmitOP_VARIANT_FROM_CARDINAL_64;
procedure EmitOP_VARIANT_FROM_SMALLINT;
procedure EmitOP_VARIANT_FROM_SMALLINT_64;
procedure EmitOP_VARIANT_FROM_SHORTINT;
procedure EmitOP_VARIANT_FROM_SHORTINT_64;
procedure EmitOP_VARIANT_FROM_DOUBLE;
procedure EmitOP_VARIANT_FROM_DOUBLE_64;
procedure EmitOP_VARIANT_FROM_CURRENCY;
procedure EmitOP_VARIANT_FROM_CURRENCY_64;
procedure EmitOP_VARIANT_FROM_SINGLE;
procedure EmitOP_VARIANT_FROM_SINGLE_64;
procedure EmitOP_VARIANT_FROM_EXTENDED;
procedure EmitOP_VARIANT_FROM_EXTENDED_64;
procedure EmitOP_VARIANT_FROM_INTERFACE;
procedure EmitOP_VARIANT_FROM_INTERFACE_64;
procedure EmitOP_OLEVARIANT_FROM_VARIANT;
procedure EmitOP_OLEVARIANT_FROM_VARIANT_64;
procedure EmitOP_OLEVARIANT_FROM_PANSICHAR_LITERAL;
procedure EmitOP_OLEVARIANT_FROM_PANSICHAR_LITERAL_64;
procedure EmitOP_OLEVARIANT_FROM_PWIDECHAR_LITERAL;
procedure EmitOP_OLEVARIANT_FROM_PWIDECHAR_LITERAL_64;
procedure EmitOP_OLEVARIANT_FROM_ANSISTRING;
procedure EmitOP_OLEVARIANT_FROM_ANSISTRING_64;
procedure EmitOP_OLEVARIANT_FROM_WIDESTRING;
procedure EmitOP_OLEVARIANT_FROM_WIDESTRING_64;
procedure EmitOP_OLEVARIANT_FROM_UNICSTRING;
procedure EmitOP_OLEVARIANT_FROM_UNICSTRING_64;
procedure EmitOP_OLEVARIANT_FROM_SHORTSTRING;
procedure EmitOP_OLEVARIANT_FROM_SHORTSTRING_64;
procedure EmitOP_OLEVARIANT_FROM_ANSICHAR;
procedure EmitOP_OLEVARIANT_FROM_ANSICHAR_64;
procedure EmitOP_OLEVARIANT_FROM_WIDECHAR;
procedure EmitOP_OLEVARIANT_FROM_WIDECHAR_64;
procedure EmitOP_OLEVARIANT_FROM_WIDECHAR_LITERAL;
procedure EmitOP_OLEVARIANT_FROM_WIDECHAR_LITERAL_64;
procedure EmitOP_OLEVARIANT_FROM_INT;
procedure EmitOP_OLEVARIANT_FROM_INT_64;
procedure EmitOP_OLEVARIANT_FROM_INT64;
procedure EmitOP_OLEVARIANT_FROM_INT64_64;
procedure EmitOP_OLEVARIANT_FROM_BYTE;
procedure EmitOP_OLEVARIANT_FROM_BYTE_64;
procedure EmitOP_OLEVARIANT_FROM_BOOL;
procedure EmitOP_OLEVARIANT_FROM_BOOL_64;
procedure EmitOP_OLEVARIANT_FROM_WORD;
procedure EmitOP_OLEVARIANT_FROM_WORD_64;
procedure EmitOP_OLEVARIANT_FROM_CARDINAL;
procedure EmitOP_OLEVARIANT_FROM_CARDINAL_64;
procedure EmitOP_OLEVARIANT_FROM_SMALLINT;
procedure EmitOP_OLEVARIANT_FROM_SMALLINT_64;
procedure EmitOP_OLEVARIANT_FROM_SHORTINT;
procedure EmitOP_OLEVARIANT_FROM_SHORTINT_64;
procedure EmitOP_OLEVARIANT_FROM_DOUBLE;
procedure EmitOP_OLEVARIANT_FROM_DOUBLE_64;
procedure EmitOP_OLEVARIANT_FROM_CURRENCY;
procedure EmitOP_OLEVARIANT_FROM_CURRENCY_64;
procedure EmitOP_OLEVARIANT_FROM_SINGLE;
procedure EmitOP_OLEVARIANT_FROM_SINGLE_64;
procedure EmitOP_OLEVARIANT_FROM_EXTENDED;
procedure EmitOP_OLEVARIANT_FROM_EXTENDED_64;
procedure EmitOP_OLEVARIANT_FROM_INTERFACE;
procedure EmitOP_OLEVARIANT_FROM_INTERFACE_64;
procedure EmitOP_ANSISTRING_FROM_INT; // JS only
procedure EmitOP_ANSISTRING_FROM_INT_64; // JS only
procedure EmitOP_ANSISTRING_FROM_DOUBLE; // JS only
procedure EmitOP_ANSISTRING_FROM_DOUBLE_64; // JS only
procedure EmitOP_ANSISTRING_FROM_SINGLE; // JS only
procedure EmitOP_ANSISTRING_FROM_SINGLE_64; // JS only
procedure EmitOP_ANSISTRING_FROM_EXTENDED; // JS only
procedure EmitOP_ANSISTRING_FROM_EXTENDED_64; // JS only
procedure EmitOP_ANSISTRING_FROM_BOOLEAN; // JS only
procedure EmitOP_ANSISTRING_FROM_BOOLEAN_64; // JS only
procedure EmitOP_UNICSTRING_FROM_INT; // JS only
procedure EmitOP_UNICSTRING_FROM_INT_64; // JS only
procedure EmitOP_UNICSTRING_FROM_DOUBLE; // JS only
procedure EmitOP_UNICSTRING_FROM_DOUBLE_64; // JS only
procedure EmitOP_UNICSTRING_FROM_SINGLE; // JS only
procedure EmitOP_UNICSTRING_FROM_SINGLE_64; // JS only
procedure EmitOP_UNICSTRING_FROM_EXTENDED; // JS only
procedure EmitOP_UNICSTRING_FROM_EXTENDED_64; // JS only
procedure EmitOP_UNICSTRING_FROM_BOOLEAN; // JS only
procedure EmitOP_UNICSTRING_FROM_BOOLEAN_64; // JS only
procedure EmitOP_JS_FUNC_OBJ_FROM_VARIANT; // JS only
procedure EmitOP_JS_FUNC_OBJ_FROM_VARIANT_64; // JS only
procedure EmitOP_ANSICHAR_FROM_VARIANT;
procedure EmitOP_ANSICHAR_FROM_VARIANT_64;
procedure EmitOP_WIDECHAR_FROM_VARIANT;
procedure EmitOP_WIDECHAR_FROM_VARIANT_64;
procedure EmitOP_ANSISTRING_FROM_VARIANT;
procedure EmitOP_ANSISTRING_FROM_VARIANT_64;
procedure EmitOP_WIDESTRING_FROM_VARIANT;
procedure EmitOP_WIDESTRING_FROM_VARIANT_64;
procedure EmitOP_UNICSTRING_FROM_VARIANT;
procedure EmitOP_UNICSTRING_FROM_VARIANT_64;
{$IFNDEF PAXARM}
procedure EmitOP_SHORTSTRING_FROM_VARIANT;
procedure EmitOP_SHORTSTRING_FROM_VARIANT_64;
{$ENDIF}
procedure EmitOP_DOUBLE_FROM_VARIANT;
procedure EmitOP_DOUBLE_FROM_VARIANT_64;
procedure EmitOP_CURRENCY_FROM_VARIANT;
procedure EmitOP_CURRENCY_FROM_VARIANT_64;
procedure EmitOP_SINGLE_FROM_VARIANT;
procedure EmitOP_SINGLE_FROM_VARIANT_64;
procedure EmitOP_EXTENDED_FROM_VARIANT;
procedure EmitOP_EXTENDED_FROM_VARIANT_64;
procedure EmitOP_INT_FROM_VARIANT;
procedure EmitOP_INT_FROM_VARIANT_64;
procedure EmitOP_INT64_FROM_VARIANT;
procedure EmitOP_INT64_FROM_VARIANT_64;
procedure EmitOP_BYTE_FROM_VARIANT;
procedure EmitOP_BYTE_FROM_VARIANT_64;
procedure EmitOP_WORD_FROM_VARIANT;
procedure EmitOP_WORD_FROM_VARIANT_64;
procedure EmitOP_CARDINAL_FROM_VARIANT;
procedure EmitOP_CARDINAL_FROM_VARIANT_64;
procedure EmitOP_BOOL_FROM_VARIANT;
procedure EmitOP_BOOL_FROM_VARIANT_64;
procedure EmitOP_BYTEBOOL_FROM_VARIANT;
procedure EmitOP_BYTEBOOL_FROM_VARIANT_64;
procedure EmitOP_WORDBOOL_FROM_VARIANT;
procedure EmitOP_WORDBOOL_FROM_VARIANT_64;
procedure EmitOP_LONGBOOL_FROM_VARIANT;
procedure EmitOP_LONGBOOL_FROM_VARIANT_64;
procedure EmitOP_SMALLINT_FROM_VARIANT;
procedure EmitOP_SMALLINT_FROM_VARIANT_64;
procedure EmitOP_SHORTINT_FROM_VARIANT;
procedure EmitOP_SHORTINT_FROM_VARIANT_64;
procedure EmitOP_BOOL_FROM_BYTEBOOL;
procedure EmitOP_BOOL_FROM_BYTEBOOL_64;
procedure EmitOP_BOOL_FROM_WORDBOOL;
procedure EmitOP_BOOL_FROM_WORDBOOL_64;
procedure EmitOP_BOOL_FROM_LONGBOOL;
procedure EmitOP_BOOL_FROM_LONGBOOL_64;
procedure EmitOP_NEG_VARIANT;
procedure EmitOP_NEG_VARIANT_64;
procedure EmitOP_ABS_VARIANT;
procedure EmitOP_ABS_VARIANT_64;
procedure EmitOP_NOT_VARIANT;
procedure EmitOP_NOT_VARIANT_64;
procedure EmitOP_ADD_VARIANT;
procedure EmitOP_ADD_VARIANT_64;
procedure EmitOP_SUB_VARIANT;
procedure EmitOP_SUB_VARIANT_64;
procedure EmitOP_MULT_VARIANT;
procedure EmitOP_MULT_VARIANT_64;
procedure EmitOP_DIV_VARIANT;
procedure EmitOP_DIV_VARIANT_64;
procedure EmitOP_IDIV_VARIANT;
procedure EmitOP_IDIV_VARIANT_64;
procedure EmitOP_MOD_VARIANT;
procedure EmitOP_MOD_VARIANT_64;
procedure EmitOP_SHL_VARIANT;
procedure EmitOP_SHL_VARIANT_64;
procedure EmitOP_SHR_VARIANT;
procedure EmitOP_SHR_VARIANT_64;
procedure EmitOP_AND_VARIANT;
procedure EmitOP_AND_VARIANT_64;
procedure EmitOP_OR_VARIANT;
procedure EmitOP_OR_VARIANT_64;
procedure EmitOP_XOR_VARIANT;
procedure EmitOP_XOR_VARIANT_64;
procedure EmitOP_LT_VARIANT;
procedure EmitOP_LT_VARIANT_64;
procedure EmitOP_LE_VARIANT;
procedure EmitOP_LE_VARIANT_64;
procedure EmitOP_GT_VARIANT;
procedure EmitOP_GT_VARIANT_64;
procedure EmitOP_GE_VARIANT;
procedure EmitOP_GE_VARIANT_64;
procedure EmitOP_EQ_VARIANT;
procedure EmitOP_EQ_VARIANT_64;
procedure EmitOP_NE_VARIANT;
procedure EmitOP_NE_VARIANT_64;
procedure EmitOP_VARARRAY_GET;
procedure EmitOP_VARARRAY_GET_64;
procedure EmitOP_VARARRAY_PUT;
procedure EmitOP_VARARRAY_PUT_64;
procedure EmitOP_OLE_GET;
procedure EmitOP_OLE_GET_64;
procedure EmitOP_OLE_SET;
procedure EmitOP_OLE_SET_64;
procedure EmitOP_OLE_PARAM;
procedure EmitOP_OLE_PARAM_64;
procedure EmitOP_GENERAL_GET;
procedure EmitOP_GENERAL_GET_64;
procedure EmitOP_GENERAL_PUT;
procedure EmitOP_GENERAL_PUT_64;
procedure EmitOP_ONCREATE_HOST_OBJECT;
procedure EmitOP_ONCREATE_HOST_OBJECT_64;
procedure EmitOP_ONDESTROY_HOST_OBJECT;
procedure EmitOP_ONDESTROY_HOST_OBJECT_64;
procedure EmitOP_BEFORE_CALL_HOST;
procedure EmitOP_AFTER_CALL_HOST;
procedure EmitOP_BEFORE_CALL_HOST_64;
procedure EmitOP_AFTER_CALL_HOST_64;
procedure EmitOP_INIT_FWARRAY;
procedure EmitOP_INIT_FWARRAY_64;
procedure EmitOP_ONCREATE_OBJECT;
procedure EmitOP_ONCREATE_OBJECT_64;
procedure EmitOP_ON_AFTER_OBJECT_CREATION;
procedure EmitOP_ON_AFTER_OBJECT_CREATION_64;
procedure EmitOP_IS;
procedure EmitOP_IS_64;
procedure EmitOP_CLASSNAME;
procedure EmitOP_CLASSNAME_64;
procedure EmitOP_TYPEINFO;
procedure EmitOP_TYPEINFO_64;
procedure EmitOP_PUSH_CONTEXT;
procedure EmitOP_PUSH_CONTEXT_64;
procedure EmitOP_POP_CONTEXT;
procedure EmitOP_POP_CONTEXT_64;
procedure EmitOP_FIND_CONTEXT;
procedure EmitOP_FIND_CONTEXT_64;
procedure EmitOP_FIND_JS_FUNC;
procedure EmitOP_FIND_JS_FUNC_64;
procedure EmitOP_GET_PROG;
procedure EmitOP_GET_PROG_64;
procedure EmitOP_GET_DRTTI_PROP;
procedure EmitOP_GET_DRTTI_PROP_64;
procedure EmitOP_SET_DRTTI_PROP;
procedure EmitOP_SET_DRTTI_PROP_64;
procedure EmitOP_GET_ANSISTR_PROP;
procedure EmitOP_GET_ANSISTR_PROP_64;
procedure EmitOP_SET_ANSISTR_PROP;
procedure EmitOP_SET_ANSISTR_PROP_64;
procedure EmitOP_GET_WIDESTR_PROP;
procedure EmitOP_GET_WIDESTR_PROP_64;
procedure EmitOP_SET_WIDESTR_PROP;
procedure EmitOP_SET_WIDESTR_PROP_64;
procedure EmitOP_GET_UNICSTR_PROP;
procedure EmitOP_GET_UNICSTR_PROP_64;
procedure EmitOP_SET_UNICSTR_PROP;
procedure EmitOP_SET_UNICSTR_PROP_64;
procedure EmitOP_GET_ORD_PROP;
procedure EmitOP_GET_ORD_PROP_64;
procedure EmitOP_SET_ORD_PROP;
procedure EmitOP_SET_ORD_PROP_64;
procedure EmitOP_GET_INTERFACE_PROP;
procedure EmitOP_GET_INTERFACE_PROP_64;
procedure EmitOP_SET_INTERFACE_PROP;
procedure EmitOP_SET_INTERFACE_PROP_64;
procedure EmitOP_GET_SET_PROP;
procedure EmitOP_GET_SET_PROP_64;
procedure EmitOP_SET_SET_PROP;
procedure EmitOP_SET_SET_PROP_64;
procedure EmitOP_GET_FLOAT_PROP;
procedure EmitOP_GET_FLOAT_PROP_64;
procedure EmitOP_SET_FLOAT_PROP;
procedure EmitOP_SET_FLOAT_PROP_64;
procedure EmitOP_GET_VARIANT_PROP;
procedure EmitOP_GET_VARIANT_PROP_64;
procedure EmitOP_SET_VARIANT_PROP;
procedure EmitOP_SET_VARIANT_PROP_64;
procedure EmitOP_GET_INT64_PROP;
procedure EmitOP_GET_INT64_PROP_64;
procedure EmitOP_SET_INT64_PROP;
procedure EmitOP_SET_INT64_PROP_64;
procedure EmitOP_GET_EVENT_PROP;
procedure EmitOP_GET_EVENT_PROP_64;
procedure EmitOP_SET_EVENT_PROP;
procedure EmitOP_SET_EVENT_PROP_64;
procedure EmitOP_SET_EVENT_PROP2;
procedure EmitOP_SET_EVENT_PROP2_64;
procedure EmitOP_TRY_ON;
procedure EmitOP_TRY_ON_64;
procedure EmitOP_TRY_OFF;
procedure EmitOP_TRY_OFF_64;
procedure EmitOP_EXCEPT_SEH;
procedure EmitOP_EXCEPT_SEH_64;
procedure EmitOP_FINALLY;
procedure EmitOP_FINALLY_64;
procedure EmitOP_EXCEPT;
procedure EmitOP_EXCEPT_64;
procedure EmitOP_EXCEPT_ON;
procedure EmitOP_EXCEPT_ON_64;
procedure EmitOP_RAISE;
procedure EmitOP_RAISE_64;
procedure EmitOP_EXIT;
procedure EmitOP_EXIT_64;
procedure EmitOP_COND_RAISE;
procedure EmitOP_COND_RAISE_64;
procedure EmitOP_BEGIN_EXCEPT_BLOCK;
procedure EmitOP_BEGIN_EXCEPT_BLOCK_64;
procedure EmitOP_END_EXCEPT_BLOCK;
procedure EmitOP_END_EXCEPT_BLOCK_64;
procedure EmitOP_OVERFLOW_CHECK;
procedure EmitOP_OVERFLOW_CHECK_64;
procedure EmitOP_PAUSE;
procedure EmitOP_PAUSE_64;
procedure EmitOP_CHECK_PAUSE;
procedure EmitOP_CHECK_PAUSE_64;
procedure EmitOP_CHECK_PAUSE_LIGHT;
procedure EmitOP_CHECK_PAUSE_LIGHT_64;
procedure EmitOP_HALT;
procedure EmitOP_HALT_64;
procedure EmitOP_CHECK_INIT_ONLY;
procedure EmitOP_CHECK_BODY_ONLY;
procedure EmitOP_CREATE_OBJECT;
procedure EmitOP_CREATE_OBJECT_64;
procedure EmitOP_DESTROY_OBJECT;
procedure EmitOP_DESTROY_OBJECT_64;
procedure EmitOP_GET_VMT_ADDRESS;
procedure EmitOP_GET_VMT_ADDRESS_64;
procedure EmitJmp;
procedure EmitOP_EQ_EVENT_64;
procedure EmitOP_NE_EVENT_64;
procedure EmitFLD(S: TSymbolRec);
procedure EmitFSTP(S: TSymbolRec);
procedure EmitFild(S: TSymbolRec);
procedure EmitFistp(S: TSymbolRec);
procedure EmitFDiv_10000;
procedure EmitFMul_10000;
procedure EmitLoadAddress(Reg: Integer; S: TSymbolRec);
function HasTheSameAddressRegister(S1, S2: TSymbolRec): Boolean; // see next method
function EmitGetAddressRegister(S: TSymbolRec): Integer; // this method
// returns a register.
// If it returns ESI or EBP, true address = result + S.Shift !!
// otherwise, address = result
// Caller must free the register !!
procedure EmitLoadIntVal(Reg: Integer; S: TSymbolRec);
procedure EmitSaveIntVal(Reg: Integer; S: TSymbolRec);
procedure EmitRestoreEBP(Reg: Integer; S: TSymbolRec);
procedure EmitRestoreEBP_64(Reg: Integer; S: TSymbolRec);
procedure EmitPut_REG(Reg: Integer; S: TSymbolRec; ExtraShift: Integer = 0);
// Reg contains a 32-bit value
// S - destination
procedure EmitPut_REG_64(Reg: Integer; S: TSymbolRec; ExtraShift: Integer = 0);
// Reg contains a 32-bit value
// S - destination
procedure EmitGet_REG(Reg: Integer; S: TSymbolRec; ExtraShift: Integer = 0);
// S - source
// Reg - destination
procedure EmitGet_REG_64(Reg: Integer; S: TSymbolRec; ExtraShift: Integer = 0);
// S - source
// Reg - destination
procedure EmitLabel(LabelId: Integer; const LabelName: String);
procedure RaiseError(const Message: string; params: array of Const);
procedure CreateError(const Message: string; params: array of Const);
function Host1: Boolean;
function Host2: Boolean;
function ByRef1: Boolean;
function GetReg: Integer; overload;
function GetReg(Reg: Integer): integer; overload;
function GetRegEx: Integer;
function GetReg64: Integer;
procedure FreeReg(Reg: Integer);
function ImmValue1: Cardinal;
function ImmValue2: Cardinal;
function GetOffset(S: TSymbolRec): Integer;
function SymbolRec1: TSymbolRec;
function SymbolRec2: TSymbolRec;
function SymbolRecR: TSymbolRec;
procedure Emit(I: Integer);
property OperName: String read GetOperName;
property Language: Integer read GetLanguage;
public
constructor Create(akernel: Pointer);
destructor Destroy; override;
function CreateSymbolProgram(i_kernel: Pointer): TSymbolProg;
procedure CopyContextStack(AStack: TIntegerStack);
property SizeOfPointer: Integer read GetSizeOfPointer;
property TargetPlatform: TTargetPlatform read GetTargetPlatform;
end;
procedure EmitProgProc(akernel, aprog: Pointer; context: Pointer = nil);
implementation
uses
PAXCOMP_BASERUNNER,
PAXCOMP_PROG,
PAXCOMP_KERNEL,
PAXCOMP_STDLIB;
{$IFDEF TRIAL}
var
_Counter: Integer = 3;
{$ENDIF}
constructor TRegisters.Create(aPAX64: Boolean);
var
I, K: Integer;
begin
PAX64 := aPAX64;
if PAX64 then
K := _R15
else
K := _EDI;
for I:=_NOREG to K do
FreeReg(I);
A[_ESI] := true;
A[_EDI] := true;
A[_ESP] := true;
A[_EBP] := true;
A[_R12] := true;
A[_R13] := true;
end;
function TRegisters.GetReg: Integer;
var
I, K: Integer;
begin
if PAX64 then
K := _R9
else
K := _EDI;
for I:=_EAX to K do
if A[I] then
begin
A[I] := false;
result := I;
Exit;
end;
raise Exception.Create(errInternalError);
end;
function TRegisters.GetReg64: Integer;
var
I: Integer;
begin
for I := _R10 to _R15 do
if A[I] then
begin
A[I] := false;
result := I;
Exit;
end;
raise Exception.Create(errInternalError);
end;
procedure TRegisters.GetReg(Reg: Integer);
begin
if A[Reg] then
A[Reg] := false
else
begin
raise Exception.Create(errInternalError);
end;
end;
procedure TRegisters.FreeReg(Reg: Integer);
begin
A[Reg] := true;
end;
constructor TEmitter.Create(akernel: Pointer);
begin
inherited Create;
kernel := akernel;
Registers := TRegisters.Create(TargetPlatform = tpWIN64);
ContextStack := TIntegerStack.Create;
List1 := TList.Create;
List2 := TList.Create;
List3 := TList.Create;
OverflowCheck := true;
CreateEmitProcList;
end;
destructor TEmitter.Destroy;
begin
FreeAndNil(Registers);
FreeAndNil(ContextStack);
FreeAndNil(List1);
FreeAndNil(List2);
FreeAndNil(List3);
inherited;
end;
procedure TEmitter.EmitNotImpl;
begin
RaiseError(errInternalError, []);
end;
procedure TEmitter.EmitNothing;
begin
end;
procedure TEmitter.CreateEmitProcList;
var
I: Integer;
begin
SetLength(EmitList, - OP_DUMMY);
for I:=0 to System.Length(EmitList) - 1 do
EmitList[I] := EmitNotImpl;
EmitList[ - OP_EMIT_ON ] := EmitOP_EMIT_ON;
EmitList[ - OP_EMIT_OFF] := EmitOP_EMIT_OFF;
EmitList[ - OP_NOP ] := EmitNothing;
EmitList[ - OP_ADD_COMMENT ] := EmitComment;
EmitList[ - OP_BEGIN_NAMESPACE ] := EmitNothing;
EmitList[ - OP_END_NAMESPACE ] := EmitNothing;
EmitList[ - OP_GO ] := EmitOP_GO;
EmitList[ - OP_GO_1 ] := EmitOP_GO_1;
EmitList[ - OP_GO_2 ] := EmitOP_GO_2;
EmitList[ - OP_GO_3 ] := EmitOP_GO_3;
EmitList[ - OP_GO_TRUE ] := EmitOP_GO_TRUE;
EmitList[ - OP_GO_FALSE ] := EmitOP_GO_FALSE;
EmitList[ - OP_GO_DL ] := EmitOP_GO_DL;
EmitList[ - OP_SAVE_EDX ] := EmitOP_SAVE_EDX;
EmitList[ - OP_RESTORE_EDX ] := EmitOP_RESTORE_EDX;
EmitList[ - OP_ASSIGN_BYTE_I ] := EmitOP_ASSIGN_INT_I;
EmitList[ - OP_ASSIGN_BYTE_M ] := EmitOP_ASSIGN_INT_M;
EmitList[ - OP_ASSIGN_WORD_I ] := EmitOP_ASSIGN_INT_I;
EmitList[ - OP_ASSIGN_WORD_M ] := EmitOP_ASSIGN_INT_M;
EmitList[ - OP_ASSIGN_CARDINAL_I ] := EmitOP_ASSIGN_INT_I;
EmitList[ - OP_ASSIGN_CARDINAL_M ] := EmitOP_ASSIGN_INT_M;
EmitList[ - OP_ASSIGN_SMALLINT_I ] := EmitOP_ASSIGN_INT_I;
EmitList[ - OP_ASSIGN_SMALLINT_M ] := EmitOP_ASSIGN_INT_M;
EmitList[ - OP_ASSIGN_SHORTINT_I ] := EmitOP_ASSIGN_INT_I;
EmitList[ - OP_ASSIGN_SHORTINT_M ] := EmitOP_ASSIGN_INT_M;
EmitList[ - OP_ASSIGN_INT_I ] := EmitOP_ASSIGN_INT_I;
EmitList[ - OP_ASSIGN_INT_M ] := EmitOP_ASSIGN_INT_M;
{$IFNDEF PAXARM}
EmitList[ - OP_ASSIGN_PANSICHAR ] := EmitOP_ASSIGN_PANSICHAR;
{$ENDIF}
EmitList[ - OP_ASSIGN_PWIDECHAR ] := EmitOP_ASSIGN_PWIDECHAR;
EmitList[ - OP_ASSIGN_EVENT ] := EmitOP_ASSIGN_EVENT;
EmitList[ - OP_CREATE_EVENT ] := EmitOP_CREATE_EVENT;
EmitList[ - OP_ASSIGN_DOUBLE ] := EmitOP_ASSIGN_DOUBLE;
EmitList[ - OP_ASSIGN_CURRENCY ] := EmitOP_ASSIGN_CURRENCY;
EmitList[ - OP_ASSIGN_SINGLE ] := EmitOP_ASSIGN_SINGLE;
EmitList[ - OP_ASSIGN_EXTENDED ] := EmitOP_ASSIGN_EXTENDED;
EmitList[ - OP_ASSIGN_INT64 ] := EmitOP_ASSIGN_INT64;
EmitList[ - OP_ASSIGN_UINT64 ] := EmitOP_ASSIGN_INT64;
EmitList[ - OP_ASSIGN_RECORD ] := EmitOP_ASSIGN_RECORD;
EmitList[ - OP_ASSIGN_ARRAY ] := EmitOP_ASSIGN_RECORD;
EmitList[ - OP_ASSIGN_INTERFACE ] := EmitOP_ASSIGN_INTERFACE;
EmitList[ - OP_ADD_INT64 ] := EmitOP_ADD_INT64;
EmitList[ - OP_SUB_INT64 ] := EmitOP_SUB_INT64;
EmitList[ - OP_AND_INT64 ] := EmitOP_AND_INT64;
EmitList[ - OP_OR_INT64 ] := EmitOP_OR_INT64;
EmitList[ - OP_XOR_INT64 ] := EmitOP_XOR_INT64;
EmitList[ - OP_ADD_UINT64 ] := EmitOP_ADD_UINT64;
EmitList[ - OP_SUB_UINT64 ] := EmitOP_SUB_UINT64;
EmitList[ - OP_AND_UINT64 ] := EmitOP_AND_UINT64;
EmitList[ - OP_OR_UINT64 ] := EmitOP_OR_UINT64;
EmitList[ - OP_XOR_UINT64 ] := EmitOP_XOR_UINT64;
EmitList[ - OP_LT_INT64 ] := EmitOP_LT_INT64;
EmitList[ - OP_LE_INT64 ] := EmitOP_LE_INT64;
EmitList[ - OP_GT_INT64 ] := EmitOP_GT_INT64;
EmitList[ - OP_GE_INT64 ] := EmitOP_GE_INT64;
EmitList[ - OP_EQ_INT64 ] := EmitOP_EQ_INT64;
EmitList[ - OP_NE_INT64 ] := EmitOP_NE_INT64;
EmitList[ - OP_LT_UINT64 ] := EmitOP_LT_UINT64;
EmitList[ - OP_LE_UINT64 ] := EmitOP_LE_UINT64;
EmitList[ - OP_GT_UINT64 ] := EmitOP_GT_UINT64;
EmitList[ - OP_GE_UINT64 ] := EmitOP_GE_UINT64;
EmitList[ - OP_EQ_STRUCT ] := EmitOP_EQ_STRUCT;
EmitList[ - OP_NE_STRUCT ] := EmitOP_NE_STRUCT;
EmitList[ - OP_EQ_EVENT ] := EmitOP_EQ_INT64;
EmitList[ - OP_NE_EVENT ] := EmitOP_NE_INT64;
EmitList[ - OP_ADD_CURRENCY ] := EmitOP_ADD_CURRENCY;
EmitList[ - OP_SUB_CURRENCY ] := EmitOP_SUB_CURRENCY;
EmitList[ - OP_MUL_CURRENCY ] := EmitOP_MUL_CURRENCY;
EmitList[ - OP_DIV_CURRENCY ] := EmitOP_DIV_CURRENCY;
EmitList[ - OP_ADD_INT_MI ] := EmitOP_ADD_INT_MI;
EmitList[ - OP_ADD_INT_MM ] := EmitOP_ADD_INT_MM;
EmitList[ - OP_ADD_DOUBLE ] := EmitOP_ADD_DOUBLE;
EmitList[ - OP_ADD_SINGLE ] := EmitOP_ADD_SINGLE;
EmitList[ - OP_ADD_EXTENDED ] := EmitOP_ADD_EXTENDED;
EmitList[ - OP_NEG_INT ] := EmitOP_NEG_INT;
EmitList[ - OP_NEG_INT64 ] := EmitOP_NEG_INT64;
EmitList[ - OP_NEG_UINT64 ] := EmitOP_NEG_INT64;
EmitList[ - OP_NOT ] := EmitOP_NOT;
EmitList[ - OP_NOT_BOOL ] := EmitOP_NOT_BOOL;
EmitList[ - OP_NOT_BYTEBOOL ] := EmitOP_NOT_BYTEBOOL;
EmitList[ - OP_NOT_WORDBOOL ] := EmitOP_NOT_WORDBOOL;
EmitList[ - OP_NOT_LONGBOOL ] := EmitOP_NOT_LONGBOOL;
EmitList[ - OP_NEG_DOUBLE ] := EmitOP_NEG_DOUBLE;
EmitList[ - OP_NEG_CURRENCY ] := EmitOP_NEG_CURRENCY;
EmitList[ - OP_NEG_SINGLE ] := EmitOP_NEG_SINGLE;
EmitList[ - OP_NEG_EXTENDED ] := EmitOP_NEG_EXTENDED;
EmitList[ - OP_ABS_INT ] := EmitOP_ABS_INT;
EmitList[ - OP_ABS_DOUBLE ] := EmitOP_ABS_DOUBLE;
EmitList[ - OP_ABS_SINGLE ] := EmitOP_ABS_SINGLE;
EmitList[ - OP_ABS_EXTENDED ] := EmitOP_ABS_EXTENDED;
EmitList[ - OP_ABS_CURRENCY ] := EmitOP_ABS_CURRENCY;
EmitList[ - OP_SUB_INT_MI ] := EmitOP_SUB_INT_MI;
EmitList[ - OP_SUB_INT_MM ] := EmitOP_SUB_INT_MM;
EmitList[ - OP_SUB_DOUBLE ] := EmitOP_SUB_DOUBLE;
EmitList[ - OP_SUB_SINGLE ] := EmitOP_SUB_SINGLE;
EmitList[ - OP_SUB_EXTENDED ] := EmitOP_SUB_EXTENDED;
EmitList[ - OP_IMUL_INT_MI ] := EmitOP_IMUL_INT_MI;
EmitList[ - OP_IMUL_INT_MM ] := EmitOP_IMUL_INT_MM;
EmitList[ - OP_MUL_DOUBLE ] := EmitOP_MUL_DOUBLE;
EmitList[ - OP_MUL_SINGLE ] := EmitOP_MUL_SINGLE;
EmitList[ - OP_MUL_EXTENDED ] := EmitOP_MUL_EXTENDED;
EmitList[ - OP_IDIV_INT_MI ] := EmitOP_IDIV_INT_MI;
EmitList[ - OP_IDIV_INT_MM ] := EmitOP_IDIV_INT_MM;
EmitList[ - OP_IDIV_INT_IM ] := EmitOP_IDIV_INT_IM;
EmitList[ - OP_DIV_DOUBLE ] := EmitOP_DIV_DOUBLE;
EmitList[ - OP_DIV_SINGLE ] := EmitOP_DIV_SINGLE;
EmitList[ - OP_DIV_EXTENDED ] := EmitOP_DIV_EXTENDED;
EmitList[ - OP_MOD_INT_MI ] := EmitOP_MOD_INT_MI;
EmitList[ - OP_MOD_INT_MM ] := EmitOP_MOD_INT_MM;
EmitList[ - OP_MOD_INT_IM ] := EmitOP_MOD_INT_IM;
EmitList[ - OP_SHL_INT_MI ] := EmitOP_SHL_INT_MI;
EmitList[ - OP_SHL_INT_MM ] := EmitOP_SHL_INT_MM;
EmitList[ - OP_SHL_INT_IM ] := EmitOP_SHL_INT_IM;
EmitList[ - OP_SHR_INT_MI ] := EmitOP_SHR_INT_MI;
EmitList[ - OP_SHR_INT_MM ] := EmitOP_SHR_INT_MM;
EmitList[ - OP_SHR_INT_IM ] := EmitOP_SHR_INT_IM;
EmitList[ - OP_AND_INT_MI ] := EmitOP_AND_INT_MI;
EmitList[ - OP_AND_INT_MM ] := EmitOP_AND_INT_MM;
EmitList[ - OP_OR_INT_MI ] := EmitOP_OR_INT_MI;
EmitList[ - OP_OR_INT_MM ] := EmitOP_OR_INT_MM;
EmitList[ - OP_XOR_INT_MI ] := EmitOP_XOR_INT_MI;
EmitList[ - OP_XOR_INT_MM ] := EmitOP_XOR_INT_MM;
EmitList[ - OP_LT_INT_MI ] := EmitOP_LT_INT_MI;
EmitList[ - OP_LT_INT_MM ] := EmitOP_LT_INT_MM;
EmitList[ - OP_LE_INT_MI ] := EmitOP_LE_INT_MI;
EmitList[ - OP_LE_INT_MM ] := EmitOP_LE_INT_MM;
EmitList[ - OP_GT_INT_MI ] := EmitOP_GT_INT_MI;
EmitList[ - OP_GT_INT_MM ] := EmitOP_GT_INT_MM;
EmitList[ - OP_GE_INT_MI ] := EmitOP_GE_INT_MI;
EmitList[ - OP_GE_INT_MM ] := EmitOP_GE_INT_MM;
EmitList[ - OP_EQ_INT_MI ] := EmitOP_EQ_INT_MI;
EmitList[ - OP_EQ_INT_MM ] := EmitOP_EQ_INT_MM;
EmitList[ - OP_NE_INT_MI ] := EmitOP_NE_INT_MI;
EmitList[ - OP_NE_INT_MM ] := EmitOP_NE_INT_MM;
EmitList[ - OP_LT_DOUBLE ] := EmitOP_LT_DOUBLE;
EmitList[ - OP_LE_DOUBLE ] := EmitOP_LE_DOUBLE;
EmitList[ - OP_GT_DOUBLE ] := EmitOP_GT_DOUBLE;
EmitList[ - OP_GE_DOUBLE ] := EmitOP_GE_DOUBLE;
EmitList[ - OP_EQ_DOUBLE ] := EmitOP_EQ_DOUBLE;
EmitList[ - OP_NE_DOUBLE ] := EmitOP_NE_DOUBLE;
EmitList[ - OP_LT_CURRENCY ] := EmitOP_LT_CURRENCY;
EmitList[ - OP_LE_CURRENCY ] := EmitOP_LE_CURRENCY;
EmitList[ - OP_GT_CURRENCY ] := EmitOP_GT_CURRENCY;
EmitList[ - OP_GE_CURRENCY ] := EmitOP_GE_CURRENCY;
EmitList[ - OP_EQ_CURRENCY ] := EmitOP_EQ_CURRENCY;
EmitList[ - OP_NE_CURRENCY ] := EmitOP_NE_CURRENCY;
EmitList[ - OP_LT_SINGLE ] := EmitOP_LT_SINGLE;
EmitList[ - OP_LE_SINGLE ] := EmitOP_LE_SINGLE;
EmitList[ - OP_GT_SINGLE ] := EmitOP_GT_SINGLE;
EmitList[ - OP_GE_SINGLE ] := EmitOP_GE_SINGLE;
EmitList[ - OP_EQ_SINGLE ] := EmitOP_EQ_SINGLE;
EmitList[ - OP_NE_SINGLE ] := EmitOP_NE_SINGLE;
EmitList[ - OP_LT_EXTENDED ] := EmitOP_LT_EXTENDED;
EmitList[ - OP_LE_EXTENDED ] := EmitOP_LE_EXTENDED;
EmitList[ - OP_GT_EXTENDED ] := EmitOP_GT_EXTENDED;
EmitList[ - OP_GE_EXTENDED ] := EmitOP_GE_EXTENDED;
EmitList[ - OP_EQ_EXTENDED ] := EmitOP_EQ_EXTENDED;
EmitList[ - OP_NE_EXTENDED ] := EmitOP_NE_EXTENDED;
EmitList[ - OP_EXPORTS ] := EmitOP_EXPORTS;
EmitList[ - OP_PUSH_PROG ] := EmitOP_PUSH_PROG;
EmitList[ - OP_PUSH_ADDRESS ] := EmitOP_PUSH_ADDRESS;
EmitList[ - OP_PUSH_STRUCTURE ] := EmitOP_PUSH_STRUCTURE;
EmitList[ - OP_PUSH_SET ] := EmitOP_PUSH_SET;
EmitList[ - OP_PUSH_BYTE_IMM ] := EmitOP_PUSH_INT_IMM;
EmitList[ - OP_PUSH_BYTE ] := EmitOP_PUSH_INT;
EmitList[ - OP_PUSH_WORD_IMM ] := EmitOP_PUSH_INT_IMM;
EmitList[ - OP_PUSH_WORD ] := EmitOP_PUSH_INT;
EmitList[ - OP_PUSH_CARDINAL_IMM ] := EmitOP_PUSH_INT_IMM;
EmitList[ - OP_PUSH_CARDINAL ] := EmitOP_PUSH_INT;
EmitList[ - OP_PUSH_SMALLINT_IMM ] := EmitOP_PUSH_INT_IMM;
EmitList[ - OP_PUSH_SMALLINT ] := EmitOP_PUSH_INT;
EmitList[ - OP_PUSH_SHORTINT_IMM ] := EmitOP_PUSH_INT_IMM;
EmitList[ - OP_PUSH_SHORTINT ] := EmitOP_PUSH_INT;
EmitList[ - OP_PUSH_INT_IMM ] := EmitOP_PUSH_INT_IMM;
EmitList[ - OP_PUSH_INT ] := EmitOP_PUSH_INT;
EmitList[ - OP_PUSH_PTR ] := EmitOP_PUSH_INT;
EmitList[ - OP_PUSH_INST ] := EmitOP_PUSH_INST;
EmitList[ - OP_PUSH_CLSREF ] := EmitOP_PUSH_CLSREF;
EmitList[ - OP_UPDATE_INSTANCE ] := EmitOP_UPDATE_INSTANCE;
EmitList[ - OP_CLEAR_EDX ] := EmitOP_CLEAR_EDX;
EmitList[ - OP_PUSH_DYNARRAY ] := EmitOP_PUSH_DYNARRAY;
EmitList[ - OP_PUSH_OPENARRAY ] := EmitOP_PUSH_OPENARRAY;
EmitList[ - OP_PUSH_DATA ] := EmitOP_PUSH_DATA;
EmitList[ - OP_PUSH_EVENT ] := EmitOP_PUSH_EVENT;
EmitList[ - OP_PUSH_INT64 ] := EmitOP_PUSH_INT64;
EmitList[ - OP_PUSH_DOUBLE ] := EmitOP_PUSH_DOUBLE;
EmitList[ - OP_PUSH_CURRENCY ] := EmitOP_PUSH_CURRENCY;
EmitList[ - OP_PUSH_SINGLE ] := EmitOP_PUSH_SINGLE;
EmitList[ - OP_PUSH_EXTENDED ] := EmitOP_PUSH_EXTENDED;
{$IFNDEF PAXARM}
EmitList[ - OP_PUSH_ANSISTRING ] := EmitOP_PUSH_ANSISTRING;
EmitList[ - OP_PUSH_WIDESTRING ] := EmitOP_PUSH_WIDESTRING;
EmitList[ - OP_PUSH_SHORTSTRING ] := EmitOP_PUSH_SHORTSTRING;
EmitList[ - OP_PUSH_PANSICHAR_IMM ] := EmitOP_PUSH_PANSICHAR_IMM;
{$ENDIF}
EmitList[ - OP_PUSH_UNICSTRING ] := EmitOP_PUSH_UNICSTRING;
EmitList[ - OP_PUSH_PWIDECHAR_IMM ] := EmitOP_PUSH_PWIDECHAR_IMM;
EmitList[ - OP_BEGIN_CALL ] := EmitOP_BEGIN_CALL;
EmitList[ - OP_CALL ] := EmitOP_CALL;
EmitList[ - OP_INIT_SUB ] := EmitOP_INIT_SUB;
EmitList[ - OP_END_SUB ] := EmitOP_END_SUB;
EmitList[ - OP_FIN_SUB ] := EmitOP_FIN_SUB;
EmitList[ - OP_EPILOGUE_SUB ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_LOOP ] := EmitPCodeOperator;
EmitList[ - OP_EPILOGUE_LOOP ] := EmitPCodeOperator;
EmitList[ - OP_END_LOOP ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_GLOBAL_BLOCK ] := EmitPCodeOperator;
EmitList[ - OP_EPILOGUE_GLOBAL_BLOCK ] := EmitPCodeOperator;
EmitList[ - OP_END_GLOBAL_BLOCK ] := EmitPCodeOperator;
EmitList[ - OP_EXTRA_BYTECODE ] := EmitPCodeOperator;
EmitList[ - OP_RET ] := EmitOP_RET;
EmitList[ - OP_FIELD ] := EmitOP_FIELD;
EmitList[ - OP_GET_COMPONENT ] := EmitOP_GET_COMPONENT;
EmitList[ - OP_ELEM ] := EmitOP_ELEM;
EmitList[ - OP_PRINT_EX ] := EmitOP_PRINT_EX;
EmitList[ - OP_TO_FW_OBJECT ] := EmitOP_TO_FW_OBJECT;
EmitList[ - OP_PUSH_EBP ] := EmitOP_PUSH_EBP;
EmitList[ - OP_POP ] := EmitOP_POP;
EmitList[ - OP_SAVE_REGS ] := EmitOP_SAVE_REGS;
EmitList[ - OP_RESTORE_REGS ] := EmitOP_RESTORE_REGS;
EmitList[ - OP_INT_TO_INT64 ] := EmitOP_INT_TO_INT64;
EmitList[ - OP_BYTE_TO_INT64 ] := EmitOP_BYTE_TO_INT64;
EmitList[ - OP_WORD_TO_INT64 ] := EmitOP_WORD_TO_INT64;
EmitList[ - OP_CARDINAL_TO_INT64 ] := EmitOP_CARDINAL_TO_INT64;
EmitList[ - OP_SMALLINT_TO_INT64 ] := EmitOP_SMALLINT_TO_INT64;
EmitList[ - OP_SHORTINT_TO_INT64 ] := EmitOP_SHORTINT_TO_INT64;
EmitList[ - OP_INT_FROM_INT64 ] := EmitOP_INT_FROM_INT64;
EmitList[ - OP_BYTE_FROM_INT64 ] := EmitOP_BYTE_FROM_INT64;
EmitList[ - OP_WORD_FROM_INT64 ] := EmitOP_WORD_FROM_INT64;
EmitList[ - OP_CARDINAL_FROM_INT64 ] := EmitOP_CARDINAL_FROM_INT64;
EmitList[ - OP_SMALLINT_FROM_INT64 ] := EmitOP_SMALLINT_FROM_INT64;
EmitList[ - OP_SHORTINT_FROM_INT64 ] := EmitOP_SHORTINT_FROM_INT64;
EmitList[ - OP_INT_TO_UINT64 ] := EmitOP_INT_TO_INT64;
EmitList[ - OP_BYTE_TO_UINT64 ] := EmitOP_BYTE_TO_INT64;
EmitList[ - OP_WORD_TO_UINT64 ] := EmitOP_WORD_TO_INT64;
EmitList[ - OP_CARDINAL_TO_UINT64 ] := EmitOP_CARDINAL_TO_INT64;
EmitList[ - OP_SMALLINT_TO_UINT64 ] := EmitOP_SMALLINT_TO_INT64;
EmitList[ - OP_SHORTINT_TO_UINT64 ] := EmitOP_SHORTINT_TO_INT64;
EmitList[ - OP_INT_FROM_UINT64 ] := EmitOP_INT_FROM_INT64;
EmitList[ - OP_BYTE_FROM_UINT64 ] := EmitOP_BYTE_FROM_INT64;
EmitList[ - OP_WORD_FROM_UINT64 ] := EmitOP_WORD_FROM_INT64;
EmitList[ - OP_CARDINAL_FROM_UINT64 ] := EmitOP_CARDINAL_FROM_INT64;
EmitList[ - OP_SMALLINT_FROM_UINT64 ] := EmitOP_SMALLINT_FROM_INT64;
EmitList[ - OP_SHORTINT_FROM_UINT64 ] := EmitOP_SHORTINT_FROM_INT64;
EmitList[ - OP_INT_TO_DOUBLE ] := EmitOP_INT_TO_DOUBLE;
EmitList[ - OP_INT64_TO_DOUBLE ] := EmitOP_INT64_TO_DOUBLE;
EmitList[ - OP_UINT64_TO_DOUBLE ] := EmitOP_INT64_TO_DOUBLE;
EmitList[ - OP_INT_TO_SINGLE ] := EmitOP_INT_TO_SINGLE;
EmitList[ - OP_INT64_TO_SINGLE ] := EmitOP_INT64_TO_SINGLE;
EmitList[ - OP_UINT64_TO_SINGLE ] := EmitOP_INT64_TO_SINGLE;
EmitList[ - OP_INT_TO_EXTENDED ] := EmitOP_INT_TO_EXTENDED;
EmitList[ - OP_INT64_TO_EXTENDED ] := EmitOP_INT64_TO_EXTENDED;
EmitList[ - OP_UINT64_TO_EXTENDED ] := EmitOP_INT64_TO_EXTENDED;
EmitList[ - OP_MULT_INT64 ] := EmitOP_MULT_INT64;
EmitList[ - OP_IDIV_INT64 ] := EmitOP_IDIV_INT64;
EmitList[ - OP_MOD_INT64 ] := EmitOP_MOD_INT64;
EmitList[ - OP_SHL_INT64 ] := EmitOP_SHL_INT64;
EmitList[ - OP_SHR_INT64 ] := EmitOP_SHR_INT64;
EmitList[ - OP_ABS_INT64 ] := EmitOP_ABS_INT64;
EmitList[ - OP_CURRENCY_TO_EXTENDED ] := EmitOP_CURRENCY_TO_EXTENDED;
EmitList[ - OP_CURRENCY_TO_SINGLE ] := EmitOP_CURRENCY_TO_SINGLE;
EmitList[ - OP_DOUBLE_TO_SINGLE ] := EmitOP_DOUBLE_TO_SINGLE;
EmitList[ - OP_DOUBLE_TO_EXTENDED ] := EmitOP_DOUBLE_TO_EXTENDED;
EmitList[ - OP_SINGLE_TO_DOUBLE ] := EmitOP_SINGLE_TO_DOUBLE;
EmitList[ - OP_CURRENCY_TO_DOUBLE ] := EmitOP_CURRENCY_TO_DOUBLE;
EmitList[ - OP_SINGLE_TO_EXTENDED ] := EmitOP_SINGLE_TO_EXTENDED;
EmitList[ - OP_EXTENDED_TO_DOUBLE ] := EmitOP_EXTENDED_TO_DOUBLE;
EmitList[ - OP_EXTENDED_TO_SINGLE ] := EmitOP_EXTENDED_TO_SINGLE;
EmitList[ - OP_ADDRESS ] := EmitOP_ADDRESS;
EmitList[ - OP_TERMINAL ] := EmitOP_TERMINAL;
EmitList[ - OP_ADDRESS_PROG ] := EmitOP_ADDRESS_PROG;
EmitList[ - OP_ASSIGN_PROG ] := EmitOP_ASSIGN_PROG;
EmitList[ - OP_SET_INCLUDE ] := EmitOP_SET_INCLUDE;
EmitList[ - OP_SET_INCLUDE_INTERVAL ] := EmitOP_SET_INCLUDE_INTERVAL;
EmitList[ - OP_SET_EXCLUDE ] := EmitOP_SET_EXCLUDE;
EmitList[ - OP_SET_UNION ] := EmitOP_SET_UNION;
EmitList[ - OP_SET_DIFFERENCE ] := EmitOP_SET_DIFFERENCE;
EmitList[ - OP_SET_INTERSECTION ] := EmitOP_SET_INTERSECTION;
EmitList[ - OP_SET_SUBSET ] := EmitOP_SET_SUBSET;
EmitList[ - OP_SET_SUPERSET ] := EmitOP_SET_SUPERSET;
EmitList[ - OP_SET_EQUALITY ] := EmitOP_SET_EQUALITY;
EmitList[ - OP_SET_INEQUALITY ] := EmitOP_SET_INEQUALITY;
EmitList[ - OP_SET_MEMBERSHIP ] := EmitOP_SET_MEMBERSHIP;
EmitList[ - OP_SET_ASSIGN ] := EmitOP_SET_ASSIGN;
EmitList[ - OP_SET_COUNTER_ASSIGN ] := EmitOP_SET_COUNTER_ASSIGN;
EmitList[ - OP_ERR_ABSTRACT ] := EmitOP_ERR_ABSTRACT;
EmitList[ - OP_VAR_FROM_TVALUE ] := EmitOP_VAR_FROM_TVALUE;
{$IFNDEF PAXARM}
EmitList[ - OP_ANSISTRING_FROM_PANSICHAR ] := EmitOP_ANSISTRING_FROM_PANSICHAR;
EmitList[ - OP_ANSISTRING_FROM_PWIDECHAR ] := EmitOP_ANSISTRING_FROM_PWIDECHAR;
EmitList[ - OP_ANSISTRING_FROM_ANSICHAR ] := EmitOP_ANSISTRING_FROM_ANSICHAR;
EmitList[ - OP_ASSIGN_ANSISTRING ] := EmitOP_ASSIGN_ANSISTRING;
EmitList[ - OP_ASSIGN_SHORTSTRING ] := EmitOP_ASSIGN_SHORTSTRING;
EmitList[ - OP_ASSIGN_WIDESTRING ] := EmitOP_ASSIGN_WIDESTRING;
EmitList[ - OP_ASSIGN_UNICSTRING ] := EmitOP_ASSIGN_UNICSTRING;
EmitList[ - OP_ADD_ANSISTRING ] := EmitOP_ADD_ANSISTRING;
EmitList[ - OP_ADD_SHORTSTRING ] := EmitOP_ADD_SHORTSTRING;
EmitList[ - OP_ADD_WIDESTRING ] := EmitOP_ADD_WIDESTRING;
EmitList[ - OP_ANSISTRING_CLR ] := EmitOP_ANSISTRING_CLR;
EmitList[ - OP_WIDESTRING_CLR ] := EmitOP_WIDESTRING_CLR;
{$ENDIF}
EmitList[ - OP_ADD_UNICSTRING ] := EmitOP_ADD_UNICSTRING;
EmitList[ - OP_UNICSTRING_CLR ] := EmitOP_UNICSTRING_CLR;
EmitList[ - OP_INTERFACE_CLR ] := EmitOP_INTERFACE_CLR;
EmitList[ - OP_STRUCTURE_CLR ] := EmitOP_STRUCTURE_CLR;
EmitList[ - OP_CLASS_CLR ] := EmitOP_CLASS_CLR;
EmitList[ - OP_STRUCTURE_ADDREF ] := EmitOP_STRUCTURE_ADDREF;
EmitList[ - OP_ADDREF ] := EmitOP_ADDREF;
EmitList[ - OP_DYNARRAY_CLR ] := EmitOP_DYNARRAY_CLR;
EmitList[ - OP_DYNARRAY_HIGH ] := EmitOP_DYNARRAY_HIGH;
EmitList[ - OP_DYNARRAY_ASSIGN ] := EmitOP_DYNARRAY_ASSIGN;
EmitList[ - OP_CREATE_EMPTY_DYNARRAY ] := EmitOP_CREATE_EMPTY_DYNARRAY;
EmitList[ - OP_ASSIGN_TVarRec ] := EmitOP_ASSIGN_TVarRec;
{$IFNDEF PAXARM}
EmitList[ - OP_SHORTSTRING_FROM_PANSICHAR_LITERAL ] := EmitOP_SHORTSTRING_FROM_PANSICHAR_LITERAL;
EmitList[ - OP_SHORTSTRING_FROM_PWIDECHAR_LITERAL ] := EmitOP_SHORTSTRING_FROM_PWIDECHAR_LITERAL;
EmitList[ - OP_SHORTSTRING_FROM_ANSICHAR ] := EmitOP_SHORTSTRING_FROM_ANSICHAR;
EmitList[ - OP_SHORTSTRING_FROM_WIDECHAR ] := EmitOP_SHORTSTRING_FROM_WIDECHAR;
EmitList[ - OP_SHORTSTRING_FROM_ANSISTRING ] := EmitOP_SHORTSTRING_FROM_ANSISTRING;
EmitList[ - OP_SHORTSTRING_FROM_WIDESTRING ] := EmitOP_SHORTSTRING_FROM_WIDESTRING;
EmitList[ - OP_UNICSTRING_FROM_WIDESTRING ] := EmitOP_UNICSTRING_FROM_WIDESTRING;
EmitList[ - OP_SHORTSTRING_FROM_UNICSTRING ] := EmitOP_SHORTSTRING_FROM_UNICSTRING;
EmitList[ - OP_ANSISTRING_FROM_SHORTSTRING ] := EmitOP_ANSISTRING_FROM_SHORTSTRING;
EmitList[ - OP_EQ_ANSISTRING ] := EmitOP_EQ_ANSISTRING;
EmitList[ - OP_NE_ANSISTRING ] := EmitOP_NE_ANSISTRING;
EmitList[ - OP_EQ_SHORTSTRING ] := EmitOP_EQ_SHORTSTRING;
EmitList[ - OP_NE_SHORTSTRING ] := EmitOP_NE_SHORTSTRING;
EmitList[ - OP_EQ_WIDESTRING ] := EmitOP_EQ_WIDESTRING;
EmitList[ - OP_NE_WIDESTRING ] := EmitOP_NE_WIDESTRING;
EmitList[ - OP_GT_ANSISTRING ] := EmitOP_GT_ANSISTRING;
EmitList[ - OP_GE_ANSISTRING ] := EmitOP_GE_ANSISTRING;
EmitList[ - OP_LT_ANSISTRING ] := EmitOP_LT_ANSISTRING;
EmitList[ - OP_LE_ANSISTRING ] := EmitOP_LE_ANSISTRING;
EmitList[ - OP_GT_SHORTSTRING ] := EmitOP_GT_SHORTSTRING;
EmitList[ - OP_GE_SHORTSTRING ] := EmitOP_GE_SHORTSTRING;
EmitList[ - OP_LT_SHORTSTRING ] := EmitOP_LT_SHORTSTRING;
EmitList[ - OP_LE_SHORTSTRING ] := EmitOP_LE_SHORTSTRING;
EmitList[ - OP_GT_WIDESTRING ] := EmitOP_GT_WIDESTRING;
EmitList[ - OP_GE_WIDESTRING ] := EmitOP_GE_WIDESTRING;
EmitList[ - OP_LT_WIDESTRING ] := EmitOP_LT_WIDESTRING;
EmitList[ - OP_LE_WIDESTRING ] := EmitOP_LE_WIDESTRING;
{$ENDIF}
EmitList[ - OP_EQ_UNICSTRING ] := EmitOP_EQ_UNICSTRING;
EmitList[ - OP_NE_UNICSTRING ] := EmitOP_NE_UNICSTRING;
EmitList[ - OP_GT_UNICSTRING ] := EmitOP_GT_UNICSTRING;
EmitList[ - OP_GE_UNICSTRING ] := EmitOP_GE_UNICSTRING;
EmitList[ - OP_LT_UNICSTRING ] := EmitOP_LT_UNICSTRING;
EmitList[ - OP_LE_UNICSTRING ] := EmitOP_LE_UNICSTRING;
EmitList[ - OP_SHORTSTRING_HIGH ] := EmitOP_SHORTSTRING_HIGH;
EmitList[ - OP_LOCK_VARRAY ] := EmitOP_LOCK_VARRAY;
EmitList[ - OP_UNLOCK_VARRAY ] := EmitOP_UNLOCK_VARRAY;
EmitList[ - OP_VARIANT_CLR ] := EmitOP_VARIANT_CLR;
{$IFNDEF PAXARM}
EmitList[ - OP_WIDESTRING_FROM_PANSICHAR_LITERAL ] := EmitOP_WIDESTRING_FROM_PANSICHAR_LITERAL;
EmitList[ - OP_WIDESTRING_FROM_PWIDECHAR_LITERAL ] := EmitOP_WIDESTRING_FROM_PWIDECHAR_LITERAL;
EmitList[ - OP_WIDESTRING_FROM_ANSICHAR ] := EmitOP_WIDESTRING_FROM_ANSICHAR;
EmitList[ - OP_WIDESTRING_FROM_WIDECHAR ] := EmitOP_WIDESTRING_FROM_WIDECHAR;
EmitList[ - OP_ANSISTRING_FROM_WIDECHAR ] := EmitOP_ANSISTRING_FROM_WIDECHAR;
EmitList[ - OP_WIDESTRING_FROM_WIDECHAR_LITERAL ] := EmitOP_WIDESTRING_FROM_WIDECHAR_LITERAL;
EmitList[ - OP_WIDESTRING_FROM_ANSISTRING ] := EmitOP_WIDESTRING_FROM_ANSISTRING;
EmitList[ - OP_UNICSTRING_FROM_ANSISTRING ] := EmitOP_UNICSTRING_FROM_ANSISTRING;
EmitList[ - OP_WIDESTRING_FROM_SHORTSTRING ] := EmitOP_WIDESTRING_FROM_SHORTSTRING;
EmitList[ - OP_WIDESTRING_FROM_UNICSTRING ] := EmitOP_WIDESTRING_FROM_UNICSTRING;
EmitList[ - OP_UNICSTRING_FROM_SHORTSTRING ] := EmitOP_UNICSTRING_FROM_SHORTSTRING;
EmitList[ - OP_ANSISTRING_FROM_WIDESTRING ] := EmitOP_ANSISTRING_FROM_WIDESTRING;
EmitList[ - OP_ANSISTRING_FROM_UNICSTRING ] := EmitOP_ANSISTRING_FROM_UNICSTRING;
EmitList[ - OP_UNICSTRING_FROM_PANSICHAR_LITERAL ] := EmitOP_UNICSTRING_FROM_PANSICHAR_LITERAL;
EmitList[ - OP_UNICSTRING_FROM_ANSICHAR ] := EmitOP_UNICSTRING_FROM_ANSICHAR;
EmitList[ - OP_VARIANT_FROM_ANSICHAR ] := EmitOP_VARIANT_FROM_ANSICHAR;
{$ENDIF}
EmitList[ - OP_UNICSTRING_FROM_PWIDECHAR_LITERAL ] := EmitOP_UNICSTRING_FROM_PWIDECHAR_LITERAL;
EmitList[ - OP_UNICSTRING_FROM_WIDECHAR ] := EmitOP_UNICSTRING_FROM_WIDECHAR;
EmitList[ - OP_UNICSTRING_FROM_WIDECHAR_LITERAL ] := EmitOP_UNICSTRING_FROM_WIDECHAR_LITERAL;
EmitList[ - OP_VARIANT_FROM_INT ] := EmitOP_VARIANT_FROM_INT;
EmitList[ - OP_VARIANT_FROM_INT64 ] := EmitOP_VARIANT_FROM_INT64;
EmitList[ - OP_VARIANT_FROM_BYTE ] := EmitOP_VARIANT_FROM_BYTE;
EmitList[ - OP_VARIANT_FROM_BOOL ] := EmitOP_VARIANT_FROM_BOOL;
EmitList[ - OP_VARIANT_FROM_WORD ] := EmitOP_VARIANT_FROM_WORD;
EmitList[ - OP_VARIANT_FROM_CARDINAL ] := EmitOP_VARIANT_FROM_CARDINAL;
EmitList[ - OP_VARIANT_FROM_SMALLINT ] := EmitOP_VARIANT_FROM_SMALLINT;
EmitList[ - OP_VARIANT_FROM_SHORTINT ] := EmitOP_VARIANT_FROM_SHORTINT;
EmitList[ - OP_VARIANT_FROM_DOUBLE ] := EmitOP_VARIANT_FROM_DOUBLE;
EmitList[ - OP_VARIANT_FROM_CURRENCY ] := EmitOP_VARIANT_FROM_CURRENCY;
EmitList[ - OP_VARIANT_FROM_SINGLE ] := EmitOP_VARIANT_FROM_SINGLE;
EmitList[ - OP_VARIANT_FROM_EXTENDED ] := EmitOP_VARIANT_FROM_EXTENDED;
EmitList[ - OP_VARIANT_FROM_INTERFACE ] := EmitOP_VARIANT_FROM_INTERFACE;
{$IFNDEF PAXARM}
EmitList[ - OP_VARIANT_FROM_PANSICHAR_LITERAL ] := EmitOP_VARIANT_FROM_PANSICHAR_LITERAL;
EmitList[ - OP_VARIANT_FROM_ANSISTRING ] := EmitOP_VARIANT_FROM_ANSISTRING;
EmitList[ - OP_VARIANT_FROM_WIDESTRING ] := EmitOP_VARIANT_FROM_WIDESTRING;
EmitList[ - OP_VARIANT_FROM_SHORTSTRING ] := EmitOP_VARIANT_FROM_SHORTSTRING;
EmitList[ - OP_OLEVARIANT_FROM_ANSICHAR ] := EmitOP_OLEVARIANT_FROM_ANSICHAR;
{$ENDIF}
EmitList[ - OP_VARIANT_FROM_PWIDECHAR_LITERAL ] := EmitOP_VARIANT_FROM_PWIDECHAR_LITERAL;
EmitList[ - OP_VARIANT_FROM_UNICSTRING ] := EmitOP_VARIANT_FROM_UNICSTRING;
EmitList[ - OP_VARIANT_FROM_WIDECHAR ] := EmitOP_VARIANT_FROM_WIDECHAR;
EmitList[ - OP_VARIANT_FROM_WIDECHAR_LITERAL ] := EmitOP_VARIANT_FROM_WIDECHAR_LITERAL;
EmitList[ - OP_OLEVARIANT_FROM_VARIANT ] := EmitOP_OLEVARIANT_FROM_VARIANT;
EmitList[ - OP_OLEVARIANT_FROM_INT ] := EmitOP_OLEVARIANT_FROM_INT;
EmitList[ - OP_OLEVARIANT_FROM_INT64 ] := EmitOP_OLEVARIANT_FROM_INT64;
EmitList[ - OP_OLEVARIANT_FROM_BYTE ] := EmitOP_OLEVARIANT_FROM_BYTE;
EmitList[ - OP_OLEVARIANT_FROM_BOOL ] := EmitOP_OLEVARIANT_FROM_BOOL;
EmitList[ - OP_OLEVARIANT_FROM_WORD ] := EmitOP_OLEVARIANT_FROM_WORD;
EmitList[ - OP_OLEVARIANT_FROM_CARDINAL ] := EmitOP_OLEVARIANT_FROM_CARDINAL;
EmitList[ - OP_OLEVARIANT_FROM_SMALLINT ] := EmitOP_OLEVARIANT_FROM_SMALLINT;
EmitList[ - OP_OLEVARIANT_FROM_SHORTINT ] := EmitOP_OLEVARIANT_FROM_SHORTINT;
EmitList[ - OP_OLEVARIANT_FROM_DOUBLE ] := EmitOP_OLEVARIANT_FROM_DOUBLE;
EmitList[ - OP_OLEVARIANT_FROM_CURRENCY ] := EmitOP_OLEVARIANT_FROM_CURRENCY;
EmitList[ - OP_OLEVARIANT_FROM_SINGLE ] := EmitOP_OLEVARIANT_FROM_SINGLE;
EmitList[ - OP_OLEVARIANT_FROM_EXTENDED ] := EmitOP_OLEVARIANT_FROM_EXTENDED;
EmitList[ - OP_OLEVARIANT_FROM_INTERFACE ] := EmitOP_OLEVARIANT_FROM_INTERFACE;
{$IFNDEF PAXARM}
EmitList[ - OP_OLEVARIANT_FROM_PANSICHAR_LITERAL ] := EmitOP_OLEVARIANT_FROM_PANSICHAR_LITERAL;
EmitList[ - OP_OLEVARIANT_FROM_ANSISTRING ] := EmitOP_OLEVARIANT_FROM_ANSISTRING;
EmitList[ - OP_OLEVARIANT_FROM_WIDESTRING ] := EmitOP_OLEVARIANT_FROM_WIDESTRING;
EmitList[ - OP_OLEVARIANT_FROM_SHORTSTRING ] := EmitOP_OLEVARIANT_FROM_SHORTSTRING;
{$ENDIF}
EmitList[ - OP_OLEVARIANT_FROM_PWIDECHAR_LITERAL ] := EmitOP_OLEVARIANT_FROM_PWIDECHAR_LITERAL;
EmitList[ - OP_OLEVARIANT_FROM_UNICSTRING ] := EmitOP_OLEVARIANT_FROM_UNICSTRING;
EmitList[ - OP_OLEVARIANT_FROM_WIDECHAR ] := EmitOP_OLEVARIANT_FROM_WIDECHAR;
EmitList[ - OP_OLEVARIANT_FROM_WIDECHAR_LITERAL ] := EmitOP_OLEVARIANT_FROM_WIDECHAR_LITERAL;
EmitList[ - OP_BEGIN_LIBRARY ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_EXPORT ] := EmitPCodeOperator;
// js only
{$IFNDEF PAXARM}
EmitList[ - OP_ANSISTRING_FROM_INT ] := EmitOP_ANSISTRING_FROM_INT;
EmitList[ - OP_ANSISTRING_FROM_DOUBLE ] := EmitOP_ANSISTRING_FROM_DOUBLE;
EmitList[ - OP_ANSISTRING_FROM_SINGLE ] := EmitOP_ANSISTRING_FROM_SINGLE;
EmitList[ - OP_ANSISTRING_FROM_EXTENDED ] := EmitOP_ANSISTRING_FROM_EXTENDED;
EmitList[ - OP_ANSISTRING_FROM_BOOLEAN ] := EmitOP_ANSISTRING_FROM_BOOLEAN;
{$ENDIF}
EmitList[ - OP_UNICSTRING_FROM_INT ] := EmitOP_UNICSTRING_FROM_INT;
EmitList[ - OP_UNICSTRING_FROM_DOUBLE ] := EmitOP_UNICSTRING_FROM_DOUBLE;
EmitList[ - OP_UNICSTRING_FROM_SINGLE ] := EmitOP_UNICSTRING_FROM_SINGLE;
EmitList[ - OP_UNICSTRING_FROM_EXTENDED ] := EmitOP_UNICSTRING_FROM_EXTENDED;
EmitList[ - OP_UNICSTRING_FROM_BOOLEAN ] := EmitOP_UNICSTRING_FROM_BOOLEAN;
EmitList[ - OP_JS_FUNC_OBJ_FROM_VARIANT ] := EmitOP_JS_FUNC_OBJ_FROM_VARIANT;
{$IFNDEF PAXARM}
EmitList[ - OP_ANSICHAR_FROM_VARIANT ] := EmitOP_ANSICHAR_FROM_VARIANT;
EmitList[ - OP_ANSISTRING_FROM_VARIANT ] := EmitOP_ANSISTRING_FROM_VARIANT;
EmitList[ - OP_WIDESTRING_FROM_VARIANT ] := EmitOP_WIDESTRING_FROM_VARIANT;
EmitList[ - OP_SHORTSTRING_FROM_VARIANT ] := EmitOP_SHORTSTRING_FROM_VARIANT;
{$ENDIF}
EmitList[ - OP_WIDECHAR_FROM_VARIANT ] := EmitOP_WIDECHAR_FROM_VARIANT;
EmitList[ - OP_UNICSTRING_FROM_VARIANT ] := EmitOP_UNICSTRING_FROM_VARIANT;
EmitList[ - OP_DOUBLE_FROM_VARIANT ] := EmitOP_DOUBLE_FROM_VARIANT;
EmitList[ - OP_CURRENCY_FROM_VARIANT ] := EmitOP_CURRENCY_FROM_VARIANT;
EmitList[ - OP_SINGLE_FROM_VARIANT ] := EmitOP_SINGLE_FROM_VARIANT;
EmitList[ - OP_EXTENDED_FROM_VARIANT ] := EmitOP_EXTENDED_FROM_VARIANT;
EmitList[ - OP_INT_FROM_VARIANT ] := EmitOP_INT_FROM_VARIANT;
EmitList[ - OP_INT64_FROM_VARIANT ] := EmitOP_INT64_FROM_VARIANT;
EmitList[ - OP_UINT64_FROM_VARIANT ] := EmitOP_INT64_FROM_VARIANT;
EmitList[ - OP_BYTE_FROM_VARIANT ] := EmitOP_BYTE_FROM_VARIANT;
EmitList[ - OP_WORD_FROM_VARIANT ] := EmitOP_WORD_FROM_VARIANT;
EmitList[ - OP_CARDINAL_FROM_VARIANT ] := EmitOP_CARDINAL_FROM_VARIANT;
EmitList[ - OP_BOOL_FROM_VARIANT ] := EmitOP_BOOL_FROM_VARIANT;
EmitList[ - OP_BYTEBOOL_FROM_VARIANT ] := EmitOP_BYTEBOOL_FROM_VARIANT;
EmitList[ - OP_WORDBOOL_FROM_VARIANT ] := EmitOP_WORDBOOL_FROM_VARIANT;
EmitList[ - OP_LONGBOOL_FROM_VARIANT ] := EmitOP_LONGBOOL_FROM_VARIANT;
EmitList[ - OP_SMALLINT_FROM_VARIANT ] := EmitOP_SMALLINT_FROM_VARIANT;
EmitList[ - OP_SHORTINT_FROM_VARIANT ] := EmitOP_SHORTINT_FROM_VARIANT;
EmitList[ - OP_BOOL_FROM_BYTEBOOL ] := EmitOP_BOOL_FROM_BYTEBOOL;
EmitList[ - OP_BOOL_FROM_WORDBOOL ] := EmitOP_BOOL_FROM_WORDBOOL;
EmitList[ - OP_BOOL_FROM_LONGBOOL ] := EmitOP_BOOL_FROM_LONGBOOL;
EmitList[ - OP_NEG_VARIANT ] := EmitOP_NEG_VARIANT;
EmitList[ - OP_ABS_VARIANT ] := EmitOP_ABS_VARIANT;
EmitList[ - OP_NOT_VARIANT ] := EmitOP_NOT_VARIANT;
EmitList[ - OP_ADD_VARIANT ] := EmitOP_ADD_VARIANT;
EmitList[ - OP_SUB_VARIANT ] := EmitOP_SUB_VARIANT;
EmitList[ - OP_MULT_VARIANT ] := EmitOP_MULT_VARIANT;
EmitList[ - OP_DIV_VARIANT ] := EmitOP_DIV_VARIANT;
EmitList[ - OP_IDIV_VARIANT ] := EmitOP_IDIV_VARIANT;
EmitList[ - OP_MOD_VARIANT ] := EmitOP_MOD_VARIANT;
EmitList[ - OP_SHL_VARIANT ] := EmitOP_SHL_VARIANT;
EmitList[ - OP_SHR_VARIANT ] := EmitOP_SHR_VARIANT;
EmitList[ - OP_AND_VARIANT ] := EmitOP_AND_VARIANT;
EmitList[ - OP_OR_VARIANT ] := EmitOP_OR_VARIANT;
EmitList[ - OP_XOR_VARIANT ] := EmitOP_XOR_VARIANT;
EmitList[ - OP_LT_VARIANT ] := EmitOP_LT_VARIANT;
EmitList[ - OP_LE_VARIANT ] := EmitOP_LE_VARIANT;
EmitList[ - OP_GT_VARIANT ] := EmitOP_GT_VARIANT;
EmitList[ - OP_GE_VARIANT ] := EmitOP_GE_VARIANT;
EmitList[ - OP_EQ_VARIANT ] := EmitOP_EQ_VARIANT;
EmitList[ - OP_NE_VARIANT ] := EmitOP_NE_VARIANT;
EmitList[ - OP_CURRENCY_FROM_INT ] := EmitOP_CURRENCY_FROM_INT;
EmitList[ - OP_CURRENCY_FROM_INT64 ] := EmitOP_CURRENCY_FROM_INT64;
EmitList[ - OP_CURRENCY_FROM_UINT64 ] := EmitOP_CURRENCY_FROM_INT64;
EmitList[ - OP_CURRENCY_FROM_REAL ] := EmitOP_CURRENCY_FROM_REAL;
EmitList[ - OP_VARIANT_FROM_CLASS ] := EmitOP_VARIANT_FROM_CLASS;
EmitList[ - OP_VARIANT_FROM_POINTER ] := EmitOP_VARIANT_FROM_POINTER;
EmitList[ - OP_CLASS_FROM_VARIANT ] := EmitOP_CLASS_FROM_VARIANT;
EmitList[ - OP_INTERFACE_FROM_CLASS ] := EmitOP_INTERFACE_FROM_CLASS;
EmitList[ - OP_INTERFACE_CAST ] := EmitOP_INTERFACE_CAST;
EmitList[ - OP_ASSIGN_VARIANT ] := EmitOP_ASSIGN_VARIANT;
EmitList[ - OP_ASSIGN_OLEVARIANT ] := EmitOP_ASSIGN_OLEVARIANT;
EmitList[ - OP_ASSIGN_CLASS ] := EmitOP_ASSIGN_CLASS;
EmitList[ - OP_VARARRAY_GET ] := EmitOP_VARARRAY_GET;
EmitList[ - OP_VARARRAY_PUT ] := EmitOP_VARARRAY_PUT;
EmitList[ - OP_OLE_GET ] := EmitOP_OLE_GET;
EmitList[ - OP_OLE_SET ] := EmitOP_OLE_SET;
EmitList[ - OP_OLE_PARAM ] := EmitOP_OLE_PARAM;
EmitList[ - OP_IS ] := EmitOP_IS;
EmitList[ - OP_TYPEINFO ] := EmitOP_TYPEINFO;
EmitList[ - OP_ADD_TYPEINFO ] := EmitPCodeOperator;
EmitList[ - OP_PUSH_CONTEXT ] := EmitOP_PUSH_CONTEXT;
EmitList[ - OP_POP_CONTEXT ] := EmitOP_POP_CONTEXT;
EmitList[ - OP_FIND_CONTEXT ] := EmitOP_FIND_CONTEXT;
EmitList[ - OP_FIND_JS_FUNC ] := EmitOP_FIND_JS_FUNC;
EmitList[ - OP_GET_PROG ] := EmitOP_GET_PROG;
EmitList[ - OP_ONCREATE_HOST_OBJECT ] := EmitOP_ONCREATE_HOST_OBJECT;
EmitList[ - OP_ONDESTROY_HOST_OBJECT ] := EmitOP_ONDESTROY_HOST_OBJECT;
EmitList[ - OP_BEFORE_CALL_HOST ] := EmitOP_BEFORE_CALL_HOST;
EmitList[ - OP_AFTER_CALL_HOST ] := EmitOP_AFTER_CALL_HOST;
EmitList[ - OP_INIT_FWARRAY ] := EmitOP_INIT_FWARRAY;
EmitList[ - OP_ONCREATE_OBJECT ] := EmitOP_ONCREATE_OBJECT;
EmitList[ - OP_ON_AFTER_OBJECT_CREATION ] := EmitOP_ON_AFTER_OBJECT_CREATION;
EmitList[ - OP_CLASSNAME ] := EmitOP_CLASSNAME;
EmitList[ - OP_GET_DRTTI_PROP ] := EmitOP_GET_DRTTI_PROP;
EmitList[ - OP_SET_DRTTI_PROP ] := EmitOP_SET_DRTTI_PROP;
{$IFNDEF PAXARM}
EmitList[ - OP_GET_ANSISTR_PROP ] := EmitOP_GET_ANSISTR_PROP;
EmitList[ - OP_SET_ANSISTR_PROP ] := EmitOP_SET_ANSISTR_PROP;
EmitList[ - OP_GET_WIDESTR_PROP ] := EmitOP_GET_WIDESTR_PROP;
EmitList[ - OP_SET_WIDESTR_PROP ] := EmitOP_SET_WIDESTR_PROP;
{$ENDIF}
EmitList[ - OP_GET_UNICSTR_PROP ] := EmitOP_GET_UNICSTR_PROP;
EmitList[ - OP_SET_UNICSTR_PROP ] := EmitOP_SET_UNICSTR_PROP;
EmitList[ - OP_GET_ORD_PROP ] := EmitOP_GET_ORD_PROP;
EmitList[ - OP_SET_ORD_PROP ] := EmitOP_SET_ORD_PROP;
EmitList[ - OP_GET_INTERFACE_PROP ] := EmitOP_GET_INTERFACE_PROP;
EmitList[ - OP_SET_INTERFACE_PROP ] := EmitOP_SET_INTERFACE_PROP;
EmitList[ - OP_GET_SET_PROP ] := EmitOP_GET_SET_PROP;
EmitList[ - OP_SET_SET_PROP ] := EmitOP_SET_SET_PROP;
EmitList[ - OP_GET_FLOAT_PROP ] := EmitOP_GET_FLOAT_PROP;
EmitList[ - OP_SET_FLOAT_PROP ] := EmitOP_SET_FLOAT_PROP;
EmitList[ - OP_GET_VARIANT_PROP ] := EmitOP_GET_VARIANT_PROP;
EmitList[ - OP_SET_VARIANT_PROP ] := EmitOP_SET_VARIANT_PROP;
EmitList[ - OP_GET_INT64_PROP ] := EmitOP_GET_INT64_PROP;
EmitList[ - OP_SET_INT64_PROP ] := EmitOP_SET_INT64_PROP;
EmitList[ - OP_GET_EVENT_PROP ] := EmitOP_GET_EVENT_PROP;
EmitList[ - OP_SET_EVENT_PROP ] := EmitOP_SET_EVENT_PROP;
EmitList[ - OP_SET_EVENT_PROP2 ] := EmitOP_SET_EVENT_PROP2;
EmitList[ - OP_TRY_ON ] := EmitOP_TRY_ON;
EmitList[ - OP_EXCEPT_SEH ] := EmitOP_EXCEPT_SEH;
EmitList[ - OP_TRY_OFF ] := EmitOP_TRY_OFF;
EmitList[ - OP_FINALLY ] := EmitOP_FINALLY;
EmitList[ - OP_EXCEPT ] := EmitOP_EXCEPT;
EmitList[ - OP_EXCEPT_ON ] := EmitOP_EXCEPT_ON;
EmitList[ - OP_RAISE ] := EmitOP_RAISE;
EmitList[ - OP_EXIT ] := EmitOP_EXIT;
EmitList[ - OP_COND_RAISE ] := EmitOP_COND_RAISE;
EmitList[ - OP_BEGIN_EXCEPT_BLOCK ] := EmitOP_BEGIN_EXCEPT_BLOCK;
EmitList[ - OP_END_EXCEPT_BLOCK ] := EmitOP_END_EXCEPT_BLOCK;
EmitList[ - OP_OVERFLOW_CHECK ] := EmitOP_OVERFLOW_CHECK;
EmitList[ - OP_PAUSE ] := EmitOP_PAUSE;
EmitList[ - OP_CHECK_PAUSE ] := EmitOP_CHECK_PAUSE;
EmitList[ - OP_CHECK_PAUSE_LIGHT ] := EmitOP_CHECK_PAUSE_LIGHT;
EmitList[ - OP_HALT ] := EmitOP_HALT;
EmitList[ - OP_CREATE_OBJECT ] := EmitOP_CREATE_OBJECT;
EmitList[ - OP_DESTROY_OBJECT ] := EmitOP_DESTROY_OBJECT;
EmitList[ - OP_GET_VMT_ADDRESS ] := EmitOP_GET_VMT_ADDRESS;
EmitList[ - OP_SET_LENGTH ] := EmitOP_SET_LENGTH;
EmitList[ - OP_SET_LENGTH_EX ] := EmitOP_SET_LENGTH_EX;
EmitList[ - OP_PUSH_LENGTH ] := EmitPCodeOperator;
EmitList[ - OP_CREATE_METHOD ] := EmitOP_CREATE_METHOD;
EmitList[ - OP_DECLARE_TEMP_VAR ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_USING ] := EmitPCodeOperator;
EmitList[ - OP_END_USING ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_BLOCK ] := EmitPCodeOperator;
EmitList[ - OP_END_BLOCK ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_WITH ] := EmitPCodeOperator;
EmitList[ - OP_END_WITH ] := EmitPCodeOperator;
EmitList[ - OP_PARAM_CHANGED ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_SUB ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_CLASS_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_CLASS_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_RECORD_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_RECORD_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_HELPER_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_HELPER_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_ADD_ANCESTOR ] := EmitNothing;
{$IFNDEF PAXARM}
EmitList[ - OP_INIT_PANSICHAR_LITERAL ] := EmitNothing;
{$ENDIF}
EmitList[ - OP_INIT_PWIDECHAR_LITERAL ] := EmitNothing;
EmitList[ - OP_BEGIN_CRT_JS_FUNC_OBJECT ] := EmitOP_BEGIN_CRT_JS_FUNC_OBJECT;
EmitList[ - OP_END_CRT_JS_FUNC_OBJECT ] := EmitOP_END_CRT_JS_FUNC_OBJECT;
EmitList[ - OP_TO_JS_OBJECT ] := EmitOP_TO_JS_OBJECT;
EmitList[ - OP_JS_TYPEOF ] := EmitOP_JS_TYPEOF;
EmitList[ - OP_JS_VOID ] := EmitOP_JS_VOID;
EmitList[ - OP_GET_NEXTJSPROP ] := EmitOP_GET_NEXTJSPROP;
EmitList[ - OP_CLEAR_REFERENCES ] := EmitOP_CLEAR_REFERENCES;
EmitList[ - OP_DECLARE_LOCAL_VAR ] := EmitPCodeOperator;
EmitList[ - OP_LOAD_PROC ] := EmitPCodeOperator;
EmitList[ - OP_ADD_MESSAGE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_ARRAY_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_ARRAY_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_SET_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_SET_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_ENUM_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_ENUM_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_SUBRANGE_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_SUBRANGE_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_POINTER_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_POINTER_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_CLASSREF_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_CLASSREF_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_DYNARRAY_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_DYNARRAY_TYPE ] := EmitPCodeOperator;
{$IFNDEF PAXARM}
EmitList[ - OP_BEGIN_SHORTSTRING_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_SHORTSTRING_TYPE ] := EmitPCodeOperator;
{$ENDIF}
EmitList[ - OP_BEGIN_INTERFACE_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_INTERFACE_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_TEXT ] := EmitPCodeOperator;
EmitList[ - OP_END_TEXT ] := EmitPCodeOperator;
EmitList[ - OP_WARNINGS_ON ] := EmitPCodeOperator;
EmitList[ - OP_WARNINGS_OFF ] := EmitPCodeOperator;
EmitList[ - OP_FRAMEWORK_ON ] := EmitPCodeOperator;
EmitList[ - OP_FRAMEWORK_OFF ] := EmitPCodeOperator;
EmitList[ - OP_DECL_SUB ] := EmitPCodeOperator;
EmitList[ - OP_DECLARE_MEMBER ] := EmitPCodeOperator;
EmitList[ - OP_ABSOLUTE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_INCLUDED_FILE ] := EmitPCodeOperator;
EmitList[ - OP_END_INCLUDED_FILE ] := EmitPCodeOperator;
///
///
///
///
{$IFNDEF PAXARM}
if TargetPlatform = tpWIN64 then
begin
EmitList[ - OP_EMIT_ON ] := EmitOP_EMIT_ON;
EmitList[ - OP_EMIT_OFF] := EmitOP_EMIT_OFF;
EmitList[ - OP_NOP ] := EmitNothing;
EmitList[ - OP_BEGIN_NAMESPACE ] := EmitNothing;
EmitList[ - OP_END_NAMESPACE ] := EmitNothing;
EmitList[ - OP_GO ] := EmitOP_GO;
EmitList[ - OP_GO_1 ] := EmitOP_GO_1;
EmitList[ - OP_GO_2 ] := EmitOP_GO_2;
EmitList[ - OP_GO_3 ] := EmitOP_GO_3;
EmitList[ - OP_GO_TRUE ] := EmitOP_GO_TRUE_64;
EmitList[ - OP_GO_FALSE ] := EmitOP_GO_FALSE_64;
EmitList[ - OP_GO_DL ] := EmitOP_GO_DL_64;
EmitList[ - OP_SAVE_EDX ] := EmitOP_SAVE_EDX_64;
EmitList[ - OP_RESTORE_EDX ] := EmitOP_RESTORE_EDX_64;
EmitList[ - OP_ASSIGN_BYTE_I ] := EmitOP_ASSIGN_INT_I_64;
EmitList[ - OP_ASSIGN_BYTE_M ] := EmitOP_ASSIGN_INT_M_64;
EmitList[ - OP_ASSIGN_WORD_I ] := EmitOP_ASSIGN_INT_I_64;
EmitList[ - OP_ASSIGN_WORD_M ] := EmitOP_ASSIGN_INT_M_64;
EmitList[ - OP_ASSIGN_CARDINAL_I ] := EmitOP_ASSIGN_INT_I_64;
EmitList[ - OP_ASSIGN_CARDINAL_M ] := EmitOP_ASSIGN_INT_M_64;
EmitList[ - OP_ASSIGN_SMALLINT_I ] := EmitOP_ASSIGN_INT_I_64;
EmitList[ - OP_ASSIGN_SMALLINT_M ] := EmitOP_ASSIGN_INT_M_64;
EmitList[ - OP_ASSIGN_SHORTINT_I ] := EmitOP_ASSIGN_INT_I_64;
EmitList[ - OP_ASSIGN_SHORTINT_M ] := EmitOP_ASSIGN_INT_M_64;
EmitList[ - OP_ASSIGN_INT_I ] := EmitOP_ASSIGN_INT_I_64;
EmitList[ - OP_ASSIGN_INT_M ] := EmitOP_ASSIGN_INT_M_64;
EmitList[ - OP_ASSIGN_PANSICHAR ] := EmitOP_ASSIGN_PANSICHAR_64;
EmitList[ - OP_ASSIGN_PWIDECHAR ] := EmitOP_ASSIGN_PWIDECHAR_64;
EmitList[ - OP_ASSIGN_EVENT ] := EmitOP_ASSIGN_EVENT_64;
EmitList[ - OP_CREATE_EVENT ] := EmitOP_CREATE_EVENT_64;
EmitList[ - OP_ASSIGN_DOUBLE ] := EmitOP_ASSIGN_DOUBLE_64;
EmitList[ - OP_ASSIGN_CURRENCY ] := EmitOP_ASSIGN_CURRENCY_64;
EmitList[ - OP_ASSIGN_SINGLE ] := EmitOP_ASSIGN_SINGLE_64;
EmitList[ - OP_ASSIGN_EXTENDED ] := EmitOP_ASSIGN_EXTENDED_64;
EmitList[ - OP_ASSIGN_INT64 ] := EmitOP_ASSIGN_INT64_64;
EmitList[ - OP_ASSIGN_UINT64 ] := EmitOP_ASSIGN_INT64_64;
EmitList[ - OP_ASSIGN_RECORD ] := EmitOP_ASSIGN_RECORD_64;
EmitList[ - OP_ASSIGN_ARRAY ] := EmitOP_ASSIGN_RECORD_64;
EmitList[ - OP_ASSIGN_INTERFACE ] := EmitOP_ASSIGN_INTERFACE_64;
EmitList[ - OP_ADD_INT64 ] := EmitOP_ADD_INT64_64;
EmitList[ - OP_SUB_INT64 ] := EmitOP_SUB_INT64_64;
EmitList[ - OP_AND_INT64 ] := EmitOP_AND_INT64_64;
EmitList[ - OP_OR_INT64 ] := EmitOP_OR_INT64_64;
EmitList[ - OP_XOR_INT64 ] := EmitOP_XOR_INT64;
EmitList[ - OP_ADD_UINT64 ] := EmitOP_ADD_UINT64_64;
EmitList[ - OP_SUB_UINT64 ] := EmitOP_SUB_UINT64_64;
EmitList[ - OP_AND_UINT64 ] := EmitOP_AND_UINT64_64;
EmitList[ - OP_OR_UINT64 ] := EmitOP_OR_UINT64_64;
EmitList[ - OP_XOR_UINT64 ] := EmitOP_XOR_UINT64;
EmitList[ - OP_LT_INT64 ] := EmitOP_LT_INT64_64;
EmitList[ - OP_LE_INT64 ] := EmitOP_LE_INT64_64;
EmitList[ - OP_GT_INT64 ] := EmitOP_GT_INT64_64;
EmitList[ - OP_GE_INT64 ] := EmitOP_GE_INT64_64;
EmitList[ - OP_EQ_INT64 ] := EmitOP_EQ_INT64_64;
EmitList[ - OP_NE_INT64 ] := EmitOP_NE_INT64_64;
EmitList[ - OP_LT_UINT64 ] := EmitOP_LT_UINT64_64;
EmitList[ - OP_LE_UINT64 ] := EmitOP_LE_UINT64_64;
EmitList[ - OP_GT_UINT64 ] := EmitOP_GT_UINT64_64;
EmitList[ - OP_GE_UINT64 ] := EmitOP_GE_UINT64_64;
EmitList[ - OP_EQ_STRUCT ] := EmitOP_EQ_STRUCT_64;
EmitList[ - OP_NE_STRUCT ] := EmitOP_NE_STRUCT_64;
EmitList[ - OP_EQ_EVENT ] := EmitOP_EQ_EVENT_64;
EmitList[ - OP_NE_EVENT ] := EmitOP_NE_EVENT_64;
EmitList[ - OP_SUB_CURRENCY ] := EmitOP_SUB_CURRENCY_64;
EmitList[ - OP_MUL_CURRENCY ] := EmitOP_MUL_CURRENCY_64;
EmitList[ - OP_DIV_CURRENCY ] := EmitOP_DIV_CURRENCY_64;
EmitList[ - OP_ADD_INT_MI ] := EmitOP_ADD_INT_MI_64;
EmitList[ - OP_ADD_INT_MM ] := EmitOP_ADD_INT_MM_64;
EmitList[ - OP_ADD_CURRENCY ] := EmitOP_ADD_CURRENCY_64;
EmitList[ - OP_ADD_DOUBLE ] := EmitOP_ADD_DOUBLE_64;
EmitList[ - OP_ADD_SINGLE ] := EmitOP_ADD_SINGLE_64;
EmitList[ - OP_ADD_EXTENDED ] := EmitOP_ADD_EXTENDED_64;
EmitList[ - OP_NEG_INT ] := EmitOP_NEG_INT_64;
EmitList[ - OP_NEG_INT64 ] := EmitOP_NEG_INT64_64;
EmitList[ - OP_NEG_UINT64 ] := EmitOP_NEG_INT64_64;
EmitList[ - OP_NOT ] := EmitOP_NOT_64;
EmitList[ - OP_NOT_BOOL ] := EmitOP_NOT_BOOL64;
EmitList[ - OP_NOT_BYTEBOOL ] := EmitOP_NOT_BYTEBOOL64;
EmitList[ - OP_NOT_WORDBOOL ] := EmitOP_NOT_WORDBOOL64;
EmitList[ - OP_NOT_LONGBOOL ] := EmitOP_NOT_LONGBOOL64;
EmitList[ - OP_NEG_DOUBLE ] := EmitOP_NEG_DOUBLE_64;
EmitList[ - OP_NEG_CURRENCY ] := EmitOP_NEG_CURRENCY_64;
EmitList[ - OP_NEG_SINGLE ] := EmitOP_NEG_SINGLE_64;
EmitList[ - OP_NEG_EXTENDED ] := EmitOP_NEG_EXTENDED_64;
EmitList[ - OP_ABS_INT ] := EmitOP_ABS_INT_64;
EmitList[ - OP_ABS_DOUBLE ] := EmitOP_ABS_DOUBLE_64;
EmitList[ - OP_ABS_SINGLE ] := EmitOP_ABS_SINGLE_64;
EmitList[ - OP_ABS_EXTENDED ] := EmitOP_ABS_EXTENDED_64;
EmitList[ - OP_ABS_CURRENCY ] := EmitOP_ABS_CURRENCY_64;
EmitList[ - OP_SUB_INT_MI ] := EmitOP_SUB_INT_MI_64;
EmitList[ - OP_SUB_INT_MM ] := EmitOP_SUB_INT_MM_64;
EmitList[ - OP_SUB_DOUBLE ] := EmitOP_SUB_DOUBLE_64;
EmitList[ - OP_SUB_SINGLE ] := EmitOP_SUB_SINGLE_64;
EmitList[ - OP_SUB_EXTENDED ] := EmitOP_SUB_EXTENDED_64;
EmitList[ - OP_IMUL_INT_MI ] := EmitOP_IMUL_INT_MI_64;
EmitList[ - OP_IMUL_INT_MM ] := EmitOP_IMUL_INT_MM_64;
EmitList[ - OP_MUL_DOUBLE ] := EmitOP_MUL_DOUBLE_64;
EmitList[ - OP_MUL_SINGLE ] := EmitOP_MUL_SINGLE_64;
EmitList[ - OP_MUL_EXTENDED ] := EmitOP_MUL_EXTENDED_64;
EmitList[ - OP_IDIV_INT_MI ] := EmitOP_IDIV_INT_MI_64;
EmitList[ - OP_IDIV_INT_MM ] := EmitOP_IDIV_INT_MM_64;
EmitList[ - OP_IDIV_INT_IM ] := EmitOP_IDIV_INT_IM_64;
EmitList[ - OP_DIV_DOUBLE ] := EmitOP_DIV_DOUBLE_64;
EmitList[ - OP_DIV_SINGLE ] := EmitOP_DIV_SINGLE_64;
EmitList[ - OP_DIV_EXTENDED ] := EmitOP_DIV_EXTENDED_64;
EmitList[ - OP_MOD_INT_MI ] := EmitOP_MOD_INT_MI_64;
EmitList[ - OP_MOD_INT_MM ] := EmitOP_MOD_INT_MM_64;
EmitList[ - OP_MOD_INT_IM ] := EmitOP_MOD_INT_IM_64;
EmitList[ - OP_SHL_INT_MI ] := EmitOP_SHL_INT_MI_64;
EmitList[ - OP_SHL_INT_MM ] := EmitOP_SHL_INT_MM_64;
EmitList[ - OP_SHL_INT_IM ] := EmitOP_SHL_INT_IM_64;
EmitList[ - OP_SHR_INT_MI ] := EmitOP_SHR_INT_MI_64;
EmitList[ - OP_SHR_INT_MM ] := EmitOP_SHR_INT_MM_64;
EmitList[ - OP_SHR_INT_IM ] := EmitOP_SHR_INT_IM_64;
EmitList[ - OP_AND_INT_MI ] := EmitOP_AND_INT_MI_64;
EmitList[ - OP_AND_INT_MM ] := EmitOP_AND_INT_MM_64;
EmitList[ - OP_OR_INT_MI ] := EmitOP_OR_INT_MI_64;
EmitList[ - OP_OR_INT_MM ] := EmitOP_OR_INT_MM_64;
EmitList[ - OP_XOR_INT_MI ] := EmitOP_XOR_INT_MI_64;
EmitList[ - OP_XOR_INT_MM ] := EmitOP_XOR_INT_MM_64;
EmitList[ - OP_LT_INT_MI ] := EmitOP_LT_INT_MI_64;
EmitList[ - OP_LT_INT_MM ] := EmitOP_LT_INT_MM_64;
EmitList[ - OP_LE_INT_MI ] := EmitOP_LE_INT_MI_64;
EmitList[ - OP_LE_INT_MM ] := EmitOP_LE_INT_MM_64;
EmitList[ - OP_GT_INT_MI ] := EmitOP_GT_INT_MI_64;
EmitList[ - OP_GT_INT_MM ] := EmitOP_GT_INT_MM_64;
EmitList[ - OP_GE_INT_MI ] := EmitOP_GE_INT_MI_64;
EmitList[ - OP_GE_INT_MM ] := EmitOP_GE_INT_MM_64;
EmitList[ - OP_EQ_INT_MI ] := EmitOP_EQ_INT_MI_64;
EmitList[ - OP_EQ_INT_MM ] := EmitOP_EQ_INT_MM_64;
EmitList[ - OP_NE_INT_MI ] := EmitOP_NE_INT_MI_64;
EmitList[ - OP_NE_INT_MM ] := EmitOP_NE_INT_MM_64;
EmitList[ - OP_LT_DOUBLE ] := EmitOP_LT_DOUBLE_64;
EmitList[ - OP_LE_DOUBLE ] := EmitOP_LE_DOUBLE_64;
EmitList[ - OP_GT_DOUBLE ] := EmitOP_GT_DOUBLE_64;
EmitList[ - OP_GE_DOUBLE ] := EmitOP_GE_DOUBLE_64;
EmitList[ - OP_EQ_DOUBLE ] := EmitOP_EQ_DOUBLE_64;
EmitList[ - OP_NE_DOUBLE ] := EmitOP_NE_DOUBLE_64;
EmitList[ - OP_LT_CURRENCY ] := EmitOP_LT_CURRENCY_64;
EmitList[ - OP_LE_CURRENCY ] := EmitOP_LE_CURRENCY_64;
EmitList[ - OP_GT_CURRENCY ] := EmitOP_GT_CURRENCY_64;
EmitList[ - OP_GE_CURRENCY ] := EmitOP_GE_CURRENCY_64;
EmitList[ - OP_EQ_CURRENCY ] := EmitOP_EQ_CURRENCY_64;
EmitList[ - OP_NE_CURRENCY ] := EmitOP_NE_CURRENCY_64;
EmitList[ - OP_LT_SINGLE ] := EmitOP_LT_SINGLE_64;
EmitList[ - OP_LE_SINGLE ] := EmitOP_LE_SINGLE_64;
EmitList[ - OP_GT_SINGLE ] := EmitOP_GT_SINGLE_64;
EmitList[ - OP_GE_SINGLE ] := EmitOP_GE_SINGLE_64;
EmitList[ - OP_EQ_SINGLE ] := EmitOP_EQ_SINGLE_64;
EmitList[ - OP_NE_SINGLE ] := EmitOP_NE_SINGLE_64;
EmitList[ - OP_LT_EXTENDED ] := EmitOP_LT_EXTENDED_64;
EmitList[ - OP_LE_EXTENDED ] := EmitOP_LE_EXTENDED_64;
EmitList[ - OP_GT_EXTENDED ] := EmitOP_GT_EXTENDED_64;
EmitList[ - OP_GE_EXTENDED ] := EmitOP_GE_EXTENDED_64;
EmitList[ - OP_EQ_EXTENDED ] := EmitOP_EQ_EXTENDED_64;
EmitList[ - OP_NE_EXTENDED ] := EmitOP_NE_EXTENDED_64;
EmitList[ - OP_EXPORTS ] := EmitOP_EXPORTS_64;
EmitList[ - OP_PUSH_ADDRESS ] := EmitOP_PUSH_ADDRESS_64;
EmitList[ - OP_PUSH_STRUCTURE ] := EmitOP_PUSH_STRUCTURE_64;
EmitList[ - OP_PUSH_SET ] := EmitOP_PUSH_SET_64;
EmitList[ - OP_PUSH_BYTE_IMM ] := EmitOP_PUSH_INT_IMM_64;
EmitList[ - OP_PUSH_BYTE ] := EmitOP_PUSH_INT_64;
EmitList[ - OP_PUSH_WORD_IMM ] := EmitOP_PUSH_INT_IMM_64;
EmitList[ - OP_PUSH_WORD ] := EmitOP_PUSH_INT_64;
EmitList[ - OP_PUSH_CARDINAL_IMM ] := EmitOP_PUSH_INT_IMM_64;
EmitList[ - OP_PUSH_CARDINAL ] := EmitOP_PUSH_INT_64;
EmitList[ - OP_PUSH_SMALLINT_IMM ] := EmitOP_PUSH_INT_IMM_64;
EmitList[ - OP_PUSH_SMALLINT ] := EmitOP_PUSH_INT_64;
EmitList[ - OP_PUSH_SHORTINT_IMM ] := EmitOP_PUSH_INT_IMM_64;
EmitList[ - OP_PUSH_SHORTINT ] := EmitOP_PUSH_INT_64;
EmitList[ - OP_PUSH_INT_IMM ] := EmitOP_PUSH_INT_IMM_64;
EmitList[ - OP_PUSH_INT ] := EmitOP_PUSH_INT_64;
EmitList[ - OP_PUSH_PTR ] := EmitOP_PUSH_INT_64;
EmitList[ - OP_PUSH_INST ] := EmitOP_PUSH_INST_64;
EmitList[ - OP_PUSH_CLSREF ] := EmitOP_PUSH_CLSREF_64;
EmitList[ - OP_UPDATE_INSTANCE ] := EmitOP_UPDATE_INSTANCE_64;
EmitList[ - OP_CLEAR_EDX ] := EmitOP_CLEAR_EDX_64;
EmitList[ - OP_PUSH_DYNARRAY ] := EmitOP_PUSH_DYNARRAY_64;
EmitList[ - OP_PUSH_OPENARRAY ] := EmitOP_PUSH_OPENARRAY_64;
EmitList[ - OP_PUSH_DATA ] := EmitOP_PUSH_DATA_64;
EmitList[ - OP_PUSH_EVENT ] := EmitOP_PUSH_EVENT_64;
EmitList[ - OP_PUSH_INT64 ] := EmitOP_PUSH_INT64;
EmitList[ - OP_PUSH_INT64 ] := EmitOP_PUSH_INT_64;
EmitList[ - OP_PUSH_DOUBLE ] := EmitOP_PUSH_DOUBLE_64;
EmitList[ - OP_PUSH_CURRENCY ] := EmitOP_PUSH_INT_64;
EmitList[ - OP_PUSH_SINGLE ] := EmitOP_PUSH_SINGLE_64;
EmitList[ - OP_PUSH_EXTENDED ] := EmitOP_PUSH_DOUBLE_64;
EmitList[ - OP_PUSH_ANSISTRING ] := EmitOP_PUSH_ANSISTRING_64;
EmitList[ - OP_PUSH_WIDESTRING ] := EmitOP_PUSH_WIDESTRING_64;
EmitList[ - OP_PUSH_UNICSTRING ] := EmitOP_PUSH_UNICSTRING_64;
EmitList[ - OP_PUSH_SHORTSTRING ] := EmitOP_PUSH_SHORTSTRING_64;
EmitList[ - OP_PUSH_PANSICHAR_IMM ] := EmitOP_PUSH_PANSICHAR_IMM_64;
EmitList[ - OP_PUSH_PWIDECHAR_IMM ] := EmitOP_PUSH_PWIDECHAR_IMM_64;
EmitList[ - OP_BEGIN_CALL ] := EmitOP_BEGIN_CALL_64;
EmitList[ - OP_CALL ] := EmitOP_CALL_64;
EmitList[ - OP_INIT_SUB ] := EmitOP_INIT_SUB_64;
EmitList[ - OP_END_SUB ] := EmitOP_END_SUB_64;
EmitList[ - OP_FIN_SUB ] := EmitOP_FIN_SUB_64;
EmitList[ - OP_EPILOGUE_SUB ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_GLOBAL_BLOCK ] := EmitPCodeOperator;
EmitList[ - OP_EPILOGUE_GLOBAL_BLOCK ] := EmitPCodeOperator;
EmitList[ - OP_END_GLOBAL_BLOCK ] := EmitPCodeOperator;
EmitList[ - OP_EXTRA_BYTECODE ] := EmitPCodeOperator;
EmitList[ - OP_RET ] := EmitOP_RET_64;
EmitList[ - OP_FIELD ] := EmitOP_FIELD_64;
EmitList[ - OP_GET_COMPONENT ] := EmitOP_GET_COMPONENT_64;
EmitList[ - OP_ELEM ] := EmitOP_ELEM_64;
EmitList[ - OP_PRINT_EX ] := EmitOP_PRINT_EX_64;
EmitList[ - OP_TO_FW_OBJECT ] := EmitOP_TO_FW_OBJECT_64;
EmitList[ - OP_PUSH_EBP ] := EmitOP_PUSH_EBP_64;
EmitList[ - OP_POP ] := EmitOP_POP_64;
EmitList[ - OP_SAVE_REGS ] := EmitOP_SAVE_REGS_64;
EmitList[ - OP_RESTORE_REGS ] := EmitOP_RESTORE_REGS_64;
EmitList[ - OP_INT_TO_INT64 ] := EmitOP_INT_TO_INT64_64;
EmitList[ - OP_BYTE_TO_INT64 ] := EmitOP_BYTE_TO_INT64_64;
EmitList[ - OP_WORD_TO_INT64 ] := EmitOP_WORD_TO_INT64_64;
EmitList[ - OP_CARDINAL_TO_INT64 ] := EmitOP_CARDINAL_TO_INT64_64;
EmitList[ - OP_SMALLINT_TO_INT64 ] := EmitOP_SMALLINT_TO_INT64_64;
EmitList[ - OP_SHORTINT_TO_INT64 ] := EmitOP_SHORTINT_TO_INT64_64;
EmitList[ - OP_INT_FROM_INT64 ] := EmitOP_INT_FROM_INT64_64;
EmitList[ - OP_BYTE_FROM_INT64 ] := EmitOP_BYTE_FROM_INT64_64;
EmitList[ - OP_WORD_FROM_INT64 ] := EmitOP_WORD_FROM_INT64_64;
EmitList[ - OP_CARDINAL_FROM_INT64 ] := EmitOP_CARDINAL_FROM_INT64_64;
EmitList[ - OP_SMALLINT_FROM_INT64 ] := EmitOP_SMALLINT_FROM_INT64_64;
EmitList[ - OP_SHORTINT_FROM_INT64 ] := EmitOP_SHORTINT_FROM_INT64_64;
EmitList[ - OP_INT_TO_UINT64 ] := EmitOP_INT_TO_INT64_64;
EmitList[ - OP_BYTE_TO_UINT64 ] := EmitOP_BYTE_TO_INT64_64;
EmitList[ - OP_WORD_TO_UINT64 ] := EmitOP_WORD_TO_INT64_64;
EmitList[ - OP_CARDINAL_TO_UINT64 ] := EmitOP_CARDINAL_TO_INT64_64;
EmitList[ - OP_SMALLINT_TO_UINT64 ] := EmitOP_SMALLINT_TO_INT64_64;
EmitList[ - OP_SHORTINT_TO_UINT64 ] := EmitOP_SHORTINT_TO_INT64_64;
EmitList[ - OP_INT_FROM_UINT64 ] := EmitOP_INT_FROM_INT64_64;
EmitList[ - OP_BYTE_FROM_UINT64 ] := EmitOP_BYTE_FROM_INT64_64;
EmitList[ - OP_WORD_FROM_UINT64 ] := EmitOP_WORD_FROM_INT64_64;
EmitList[ - OP_CARDINAL_FROM_UINT64 ] := EmitOP_CARDINAL_FROM_INT64_64;
EmitList[ - OP_SMALLINT_FROM_UINT64 ] := EmitOP_SMALLINT_FROM_INT64_64;
EmitList[ - OP_SHORTINT_FROM_UINT64 ] := EmitOP_SHORTINT_FROM_INT64_64;
EmitList[ - OP_INT_TO_DOUBLE ] := EmitOP_INT_TO_DOUBLE_64;
EmitList[ - OP_INT64_TO_DOUBLE ] := EmitOP_INT64_TO_DOUBLE_64;
EmitList[ - OP_UINT64_TO_DOUBLE ] := EmitOP_INT64_TO_DOUBLE_64;
EmitList[ - OP_INT_TO_SINGLE ] := EmitOP_INT_TO_SINGLE_64;
EmitList[ - OP_INT64_TO_SINGLE ] := EmitOP_INT64_TO_SINGLE_64;
EmitList[ - OP_UINT64_TO_SINGLE ] := EmitOP_INT64_TO_SINGLE_64;
EmitList[ - OP_INT_TO_EXTENDED ] := EmitOP_INT_TO_EXTENDED_64;
EmitList[ - OP_INT64_TO_EXTENDED ] := EmitOP_INT64_TO_EXTENDED_64;
EmitList[ - OP_UINT64_TO_EXTENDED ] := EmitOP_INT64_TO_EXTENDED_64;
EmitList[ - OP_MULT_INT64 ] := EmitOP_MULT_INT64_64;
EmitList[ - OP_IDIV_INT64 ] := EmitOP_IDIV_INT64_64;
EmitList[ - OP_MOD_INT64 ] := EmitOP_MOD_INT64_64;
EmitList[ - OP_SHL_INT64 ] := EmitOP_SHL_INT64_64;
EmitList[ - OP_SHR_INT64 ] := EmitOP_SHR_INT64_64;
EmitList[ - OP_ABS_INT64 ] := EmitOP_ABS_INT64_64;
EmitList[ - OP_CURRENCY_TO_EXTENDED ] := EmitOP_CURRENCY_TO_EXTENDED_64;
EmitList[ - OP_CURRENCY_TO_SINGLE ] := EmitOP_CURRENCY_TO_SINGLE_64;
EmitList[ - OP_DOUBLE_TO_SINGLE ] := EmitOP_DOUBLE_TO_SINGLE_64;
EmitList[ - OP_DOUBLE_TO_EXTENDED ] := EmitOP_DOUBLE_TO_EXTENDED_64;
EmitList[ - OP_SINGLE_TO_DOUBLE ] := EmitOP_SINGLE_TO_DOUBLE_64;
EmitList[ - OP_CURRENCY_TO_DOUBLE ] := EmitOP_CURRENCY_TO_DOUBLE_64;
EmitList[ - OP_SINGLE_TO_EXTENDED ] := EmitOP_SINGLE_TO_EXTENDED_64;
EmitList[ - OP_EXTENDED_TO_DOUBLE ] := EmitOP_EXTENDED_TO_DOUBLE_64;
EmitList[ - OP_EXTENDED_TO_SINGLE ] := EmitOP_EXTENDED_TO_SINGLE_64;
EmitList[ - OP_ADDRESS ] := EmitOP_ADDRESS_64;
EmitList[ - OP_TERMINAL ] := EmitOP_TERMINAL_64;
EmitList[ - OP_ADDRESS_PROG ] := EmitOP_ADDRESS_PROG_64;
EmitList[ - OP_ASSIGN_PROG ] := EmitOP_ASSIGN_PROG_64;
EmitList[ - OP_SET_INCLUDE ] := EmitOP_SET_INCLUDE_64;
EmitList[ - OP_SET_INCLUDE_INTERVAL ] := EmitOP_SET_INCLUDE_INTERVAL_64;
EmitList[ - OP_SET_EXCLUDE ] := EmitOP_SET_EXCLUDE_64;
EmitList[ - OP_SET_UNION ] := EmitOP_SET_UNION_64;
EmitList[ - OP_SET_DIFFERENCE ] := EmitOP_SET_DIFFERENCE_64;
EmitList[ - OP_SET_INTERSECTION ] := EmitOP_SET_INTERSECTION_64;
EmitList[ - OP_SET_SUBSET ] := EmitOP_SET_SUBSET_64;
EmitList[ - OP_SET_SUPERSET ] := EmitOP_SET_SUPERSET_64;
EmitList[ - OP_SET_EQUALITY ] := EmitOP_SET_EQUALITY_64;
EmitList[ - OP_SET_INEQUALITY ] := EmitOP_SET_INEQUALITY_64;
EmitList[ - OP_SET_MEMBERSHIP ] := EmitOP_SET_MEMBERSHIP_64;
EmitList[ - OP_SET_ASSIGN ] := EmitOP_SET_ASSIGN_64;
EmitList[ - OP_SET_COUNTER_ASSIGN ] := EmitOP_SET_COUNTER_ASSIGN_64;
EmitList[ - OP_ERR_ABSTRACT ] := EmitOP_ERR_ABSTRACT_64;
EmitList[ - OP_VAR_FROM_TVALUE ] := EmitOP_VAR_FROM_TVALUE_64;
EmitList[ - OP_ANSISTRING_FROM_PANSICHAR ] := EmitOP_ANSISTRING_FROM_PANSICHAR_64;
EmitList[ - OP_ANSISTRING_FROM_PWIDECHAR ] := EmitOP_ANSISTRING_FROM_PWIDECHAR_64;
EmitList[ - OP_ANSISTRING_FROM_ANSICHAR ] := EmitOP_ANSISTRING_FROM_ANSICHAR_64;
EmitList[ - OP_ASSIGN_ANSISTRING ] := EmitOP_ASSIGN_ANSISTRING_64;
EmitList[ - OP_ASSIGN_SHORTSTRING ] := EmitOP_ASSIGN_SHORTSTRING_64;
EmitList[ - OP_ASSIGN_WIDESTRING ] := EmitOP_ASSIGN_WIDESTRING_64;
EmitList[ - OP_ASSIGN_UNICSTRING ] := EmitOP_ASSIGN_UNICSTRING_64;
EmitList[ - OP_ADD_ANSISTRING ] := EmitOP_ADD_ANSISTRING_64;
EmitList[ - OP_ADD_SHORTSTRING ] := EmitOP_ADD_SHORTSTRING_64;
EmitList[ - OP_ADD_WIDESTRING ] := EmitOP_ADD_WIDESTRING_64;
EmitList[ - OP_ADD_UNICSTRING ] := EmitOP_ADD_UNICSTRING_64;
EmitList[ - OP_ANSISTRING_CLR ] := EmitOP_ANSISTRING_CLR_64;
EmitList[ - OP_WIDESTRING_CLR ] := EmitOP_WIDESTRING_CLR_64;
EmitList[ - OP_UNICSTRING_CLR ] := EmitOP_UNICSTRING_CLR_64;
EmitList[ - OP_INTERFACE_CLR ] := EmitOP_INTERFACE_CLR_64;
EmitList[ - OP_STRUCTURE_CLR ] := EmitOP_STRUCTURE_CLR_64;
EmitList[ - OP_CLASS_CLR ] := EmitOP_CLASS_CLR_64;
EmitList[ - OP_STRUCTURE_ADDREF ] := EmitOP_STRUCTURE_ADDREF_64;
EmitList[ - OP_ADDREF ] := EmitOP_ADDREF_64;
EmitList[ - OP_DYNARRAY_CLR ] := EmitOP_DYNARRAY_CLR_64;
EmitList[ - OP_DYNARRAY_HIGH ] := EmitOP_DYNARRAY_HIGH_64;
EmitList[ - OP_DYNARRAY_ASSIGN ] := EmitOP_DYNARRAY_ASSIGN_64;
EmitList[ - OP_CREATE_EMPTY_DYNARRAY ] := EmitOP_CREATE_EMPTY_DYNARRAY_64;
EmitList[ - OP_ASSIGN_TVarRec ] := EmitOP_ASSIGN_TVarRec_64;
EmitList[ - OP_SHORTSTRING_FROM_PANSICHAR_LITERAL ] := EmitOP_SHORTSTRING_FROM_PANSICHAR_LITERAL_64;
EmitList[ - OP_SHORTSTRING_FROM_PWIDECHAR_LITERAL ] := EmitOP_SHORTSTRING_FROM_PWIDECHAR_LITERAL_64;
EmitList[ - OP_SHORTSTRING_FROM_ANSICHAR ] := EmitOP_SHORTSTRING_FROM_ANSICHAR_64;
EmitList[ - OP_SHORTSTRING_FROM_WIDECHAR ] := EmitOP_SHORTSTRING_FROM_WIDECHAR_64;
EmitList[ - OP_SHORTSTRING_FROM_ANSISTRING ] := EmitOP_SHORTSTRING_FROM_ANSISTRING_64;
EmitList[ - OP_SHORTSTRING_FROM_WIDESTRING ] := EmitOP_SHORTSTRING_FROM_WIDESTRING_64;
EmitList[ - OP_UNICSTRING_FROM_WIDESTRING ] := EmitOP_UNICSTRING_FROM_WIDESTRING_64;
EmitList[ - OP_SHORTSTRING_FROM_UNICSTRING ] := EmitOP_SHORTSTRING_FROM_UNICSTRING_64;
EmitList[ - OP_ANSISTRING_FROM_SHORTSTRING ] := EmitOP_ANSISTRING_FROM_SHORTSTRING_64;
EmitList[ - OP_EQ_ANSISTRING ] := EmitOP_EQ_ANSISTRING_64;
EmitList[ - OP_NE_ANSISTRING ] := EmitOP_NE_ANSISTRING_64;
EmitList[ - OP_EQ_SHORTSTRING ] := EmitOP_EQ_SHORTSTRING_64;
EmitList[ - OP_NE_SHORTSTRING ] := EmitOP_NE_SHORTSTRING_64;
EmitList[ - OP_EQ_WIDESTRING ] := EmitOP_EQ_WIDESTRING_64;
EmitList[ - OP_EQ_UNICSTRING ] := EmitOP_EQ_UNICSTRING_64;
EmitList[ - OP_NE_WIDESTRING ] := EmitOP_NE_WIDESTRING_64;
EmitList[ - OP_NE_UNICSTRING ] := EmitOP_NE_UNICSTRING_64;
EmitList[ - OP_GT_ANSISTRING ] := EmitOP_GT_ANSISTRING_64;
EmitList[ - OP_GE_ANSISTRING ] := EmitOP_GE_ANSISTRING_64;
EmitList[ - OP_LT_ANSISTRING ] := EmitOP_LT_ANSISTRING_64;
EmitList[ - OP_LE_ANSISTRING ] := EmitOP_LE_ANSISTRING_64;
EmitList[ - OP_GT_SHORTSTRING ] := EmitOP_GT_SHORTSTRING_64;
EmitList[ - OP_GE_SHORTSTRING ] := EmitOP_GE_SHORTSTRING_64;
EmitList[ - OP_LT_SHORTSTRING ] := EmitOP_LT_SHORTSTRING_64;
EmitList[ - OP_LE_SHORTSTRING ] := EmitOP_LE_SHORTSTRING_64;
EmitList[ - OP_GT_WIDESTRING ] := EmitOP_GT_WIDESTRING_64;
EmitList[ - OP_GE_WIDESTRING ] := EmitOP_GE_WIDESTRING_64;
EmitList[ - OP_LT_WIDESTRING ] := EmitOP_LT_WIDESTRING_64;
EmitList[ - OP_LE_WIDESTRING ] := EmitOP_LE_WIDESTRING_64;
EmitList[ - OP_GT_UNICSTRING ] := EmitOP_GT_UNICSTRING_64;
EmitList[ - OP_GE_UNICSTRING ] := EmitOP_GE_UNICSTRING_64;
EmitList[ - OP_LT_UNICSTRING ] := EmitOP_LT_UNICSTRING_64;
EmitList[ - OP_LE_UNICSTRING ] := EmitOP_LE_UNICSTRING_64;
EmitList[ - OP_SHORTSTRING_HIGH ] := EmitOP_SHORTSTRING_HIGH_64;
EmitList[ - OP_LOCK_VARRAY ] := EmitOP_LOCK_VARRAY_64;
EmitList[ - OP_UNLOCK_VARRAY ] := EmitOP_UNLOCK_VARRAY_64;
EmitList[ - OP_VARIANT_CLR ] := EmitOP_VARIANT_CLR_64;
EmitList[ - OP_WIDESTRING_FROM_PANSICHAR_LITERAL ] := EmitOP_WIDESTRING_FROM_PANSICHAR_LITERAL_64;
EmitList[ - OP_WIDESTRING_FROM_PWIDECHAR_LITERAL ] := EmitOP_WIDESTRING_FROM_PWIDECHAR_LITERAL_64;
EmitList[ - OP_WIDESTRING_FROM_ANSICHAR ] := EmitOP_WIDESTRING_FROM_ANSICHAR_64;
EmitList[ - OP_WIDESTRING_FROM_WIDECHAR ] := EmitOP_WIDESTRING_FROM_WIDECHAR_64;
EmitList[ - OP_ANSISTRING_FROM_WIDECHAR ] := EmitOP_ANSISTRING_FROM_WIDECHAR_64;
EmitList[ - OP_WIDESTRING_FROM_WIDECHAR_LITERAL ] := EmitOP_WIDESTRING_FROM_WIDECHAR_LITERAL_64;
EmitList[ - OP_WIDESTRING_FROM_ANSISTRING ] := EmitOP_WIDESTRING_FROM_ANSISTRING_64;
EmitList[ - OP_UNICSTRING_FROM_ANSISTRING ] := EmitOP_UNICSTRING_FROM_ANSISTRING_64;
EmitList[ - OP_WIDESTRING_FROM_SHORTSTRING ] := EmitOP_WIDESTRING_FROM_SHORTSTRING_64;
EmitList[ - OP_WIDESTRING_FROM_UNICSTRING ] := EmitOP_WIDESTRING_FROM_UNICSTRING_64;
EmitList[ - OP_UNICSTRING_FROM_SHORTSTRING ] := EmitOP_UNICSTRING_FROM_SHORTSTRING_64;
EmitList[ - OP_ANSISTRING_FROM_WIDESTRING ] := EmitOP_ANSISTRING_FROM_WIDESTRING_64;
EmitList[ - OP_ANSISTRING_FROM_UNICSTRING ] := EmitOP_ANSISTRING_FROM_UNICSTRING_64;
EmitList[ - OP_UNICSTRING_FROM_PANSICHAR_LITERAL ] := EmitOP_UNICSTRING_FROM_PANSICHAR_LITERAL_64;
EmitList[ - OP_UNICSTRING_FROM_PWIDECHAR_LITERAL ] := EmitOP_UNICSTRING_FROM_PWIDECHAR_LITERAL_64;
EmitList[ - OP_UNICSTRING_FROM_ANSICHAR ] := EmitOP_UNICSTRING_FROM_ANSICHAR_64;
EmitList[ - OP_UNICSTRING_FROM_WIDECHAR ] := EmitOP_UNICSTRING_FROM_WIDECHAR_64;
EmitList[ - OP_UNICSTRING_FROM_WIDECHAR_LITERAL ] := EmitOP_UNICSTRING_FROM_WIDECHAR_LITERAL_64;
EmitList[ - OP_VARIANT_FROM_ANSICHAR ] := EmitOP_VARIANT_FROM_ANSICHAR_64;
EmitList[ - OP_VARIANT_FROM_INT ] := EmitOP_VARIANT_FROM_INT_64;
EmitList[ - OP_VARIANT_FROM_INT64 ] := EmitOP_VARIANT_FROM_INT64_64;
EmitList[ - OP_VARIANT_FROM_BYTE ] := EmitOP_VARIANT_FROM_BYTE_64;
EmitList[ - OP_VARIANT_FROM_BOOL ] := EmitOP_VARIANT_FROM_BOOL_64;
EmitList[ - OP_VARIANT_FROM_WORD ] := EmitOP_VARIANT_FROM_WORD_64;
EmitList[ - OP_VARIANT_FROM_CARDINAL ] := EmitOP_VARIANT_FROM_CARDINAL_64;
EmitList[ - OP_VARIANT_FROM_SMALLINT ] := EmitOP_VARIANT_FROM_SMALLINT_64;
EmitList[ - OP_VARIANT_FROM_SHORTINT ] := EmitOP_VARIANT_FROM_SHORTINT_64;
EmitList[ - OP_VARIANT_FROM_DOUBLE ] := EmitOP_VARIANT_FROM_DOUBLE_64;
EmitList[ - OP_VARIANT_FROM_CURRENCY ] := EmitOP_VARIANT_FROM_CURRENCY_64;
EmitList[ - OP_VARIANT_FROM_SINGLE ] := EmitOP_VARIANT_FROM_SINGLE_64;
EmitList[ - OP_VARIANT_FROM_EXTENDED ] := EmitOP_VARIANT_FROM_EXTENDED_64;
EmitList[ - OP_VARIANT_FROM_INTERFACE ] := EmitOP_VARIANT_FROM_INTERFACE_64;
EmitList[ - OP_VARIANT_FROM_PANSICHAR_LITERAL ] := EmitOP_VARIANT_FROM_PANSICHAR_LITERAL_64;
EmitList[ - OP_VARIANT_FROM_PWIDECHAR_LITERAL ] := EmitOP_VARIANT_FROM_PWIDECHAR_LITERAL_64;
EmitList[ - OP_VARIANT_FROM_ANSISTRING ] := EmitOP_VARIANT_FROM_ANSISTRING_64;
EmitList[ - OP_VARIANT_FROM_WIDESTRING ] := EmitOP_VARIANT_FROM_WIDESTRING_64;
EmitList[ - OP_VARIANT_FROM_UNICSTRING ] := EmitOP_VARIANT_FROM_UNICSTRING_64;
EmitList[ - OP_VARIANT_FROM_SHORTSTRING ] := EmitOP_VARIANT_FROM_SHORTSTRING_64;
EmitList[ - OP_VARIANT_FROM_WIDECHAR ] := EmitOP_VARIANT_FROM_WIDECHAR_64;
EmitList[ - OP_VARIANT_FROM_WIDECHAR_LITERAL ] := EmitOP_VARIANT_FROM_WIDECHAR_LITERAL_64;
EmitList[ - OP_OLEVARIANT_FROM_VARIANT ] := EmitOP_OLEVARIANT_FROM_VARIANT_64;
EmitList[ - OP_OLEVARIANT_FROM_ANSICHAR ] := EmitOP_OLEVARIANT_FROM_ANSICHAR_64;
EmitList[ - OP_OLEVARIANT_FROM_INT ] := EmitOP_OLEVARIANT_FROM_INT_64;
EmitList[ - OP_OLEVARIANT_FROM_INT64 ] := EmitOP_OLEVARIANT_FROM_INT64_64;
EmitList[ - OP_OLEVARIANT_FROM_BYTE ] := EmitOP_OLEVARIANT_FROM_BYTE_64;
EmitList[ - OP_OLEVARIANT_FROM_BOOL ] := EmitOP_OLEVARIANT_FROM_BOOL_64;
EmitList[ - OP_OLEVARIANT_FROM_WORD ] := EmitOP_OLEVARIANT_FROM_WORD_64;
EmitList[ - OP_OLEVARIANT_FROM_CARDINAL ] := EmitOP_OLEVARIANT_FROM_CARDINAL_64;
EmitList[ - OP_OLEVARIANT_FROM_SMALLINT ] := EmitOP_OLEVARIANT_FROM_SMALLINT_64;
EmitList[ - OP_OLEVARIANT_FROM_SHORTINT ] := EmitOP_OLEVARIANT_FROM_SHORTINT_64;
EmitList[ - OP_OLEVARIANT_FROM_DOUBLE ] := EmitOP_OLEVARIANT_FROM_DOUBLE_64;
EmitList[ - OP_OLEVARIANT_FROM_CURRENCY ] := EmitOP_OLEVARIANT_FROM_CURRENCY_64;
EmitList[ - OP_OLEVARIANT_FROM_SINGLE ] := EmitOP_OLEVARIANT_FROM_SINGLE_64;
EmitList[ - OP_OLEVARIANT_FROM_EXTENDED ] := EmitOP_OLEVARIANT_FROM_EXTENDED_64;
EmitList[ - OP_OLEVARIANT_FROM_INTERFACE ] := EmitOP_OLEVARIANT_FROM_INTERFACE_64;
EmitList[ - OP_OLEVARIANT_FROM_PANSICHAR_LITERAL ] := EmitOP_OLEVARIANT_FROM_PANSICHAR_LITERAL_64;
EmitList[ - OP_OLEVARIANT_FROM_PWIDECHAR_LITERAL ] := EmitOP_OLEVARIANT_FROM_PWIDECHAR_LITERAL_64;
EmitList[ - OP_OLEVARIANT_FROM_ANSISTRING ] := EmitOP_OLEVARIANT_FROM_ANSISTRING_64;
EmitList[ - OP_OLEVARIANT_FROM_WIDESTRING ] := EmitOP_OLEVARIANT_FROM_WIDESTRING_64;
EmitList[ - OP_OLEVARIANT_FROM_UNICSTRING ] := EmitOP_OLEVARIANT_FROM_UNICSTRING_64;
EmitList[ - OP_OLEVARIANT_FROM_SHORTSTRING ] := EmitOP_OLEVARIANT_FROM_SHORTSTRING_64;
EmitList[ - OP_OLEVARIANT_FROM_WIDECHAR ] := EmitOP_OLEVARIANT_FROM_WIDECHAR_64;
EmitList[ - OP_OLEVARIANT_FROM_WIDECHAR_LITERAL ] := EmitOP_OLEVARIANT_FROM_WIDECHAR_LITERAL_64;
EmitList[ - OP_ANSISTRING_FROM_INT ] := EmitOP_ANSISTRING_FROM_INT_64;
EmitList[ - OP_ANSISTRING_FROM_DOUBLE ] := EmitOP_ANSISTRING_FROM_DOUBLE_64;
EmitList[ - OP_ANSISTRING_FROM_SINGLE ] := EmitOP_ANSISTRING_FROM_SINGLE_64;
EmitList[ - OP_ANSISTRING_FROM_EXTENDED ] := EmitOP_ANSISTRING_FROM_EXTENDED_64;
EmitList[ - OP_ANSISTRING_FROM_BOOLEAN ] := EmitOP_ANSISTRING_FROM_BOOLEAN_64;
EmitList[ - OP_UNICSTRING_FROM_INT ] := EmitOP_UNICSTRING_FROM_INT_64;
EmitList[ - OP_UNICSTRING_FROM_DOUBLE ] := EmitOP_UNICSTRING_FROM_DOUBLE_64;
EmitList[ - OP_UNICSTRING_FROM_SINGLE ] := EmitOP_UNICSTRING_FROM_SINGLE_64;
EmitList[ - OP_UNICSTRING_FROM_EXTENDED ] := EmitOP_UNICSTRING_FROM_EXTENDED_64;
EmitList[ - OP_UNICSTRING_FROM_BOOLEAN ] := EmitOP_UNICSTRING_FROM_BOOLEAN_64;
EmitList[ - OP_JS_FUNC_OBJ_FROM_VARIANT ] := EmitOP_JS_FUNC_OBJ_FROM_VARIANT_64;
EmitList[ - OP_ANSICHAR_FROM_VARIANT ] := EmitOP_ANSICHAR_FROM_VARIANT_64;
EmitList[ - OP_WIDECHAR_FROM_VARIANT ] := EmitOP_WIDECHAR_FROM_VARIANT_64;
EmitList[ - OP_ANSISTRING_FROM_VARIANT ] := EmitOP_ANSISTRING_FROM_VARIANT_64;
EmitList[ - OP_WIDESTRING_FROM_VARIANT ] := EmitOP_WIDESTRING_FROM_VARIANT_64;
EmitList[ - OP_UNICSTRING_FROM_VARIANT ] := EmitOP_UNICSTRING_FROM_VARIANT_64;
EmitList[ - OP_SHORTSTRING_FROM_VARIANT ] := EmitOP_SHORTSTRING_FROM_VARIANT_64;
EmitList[ - OP_DOUBLE_FROM_VARIANT ] := EmitOP_DOUBLE_FROM_VARIANT_64;
EmitList[ - OP_CURRENCY_FROM_VARIANT ] := EmitOP_CURRENCY_FROM_VARIANT_64;
EmitList[ - OP_SINGLE_FROM_VARIANT ] := EmitOP_SINGLE_FROM_VARIANT_64;
EmitList[ - OP_EXTENDED_FROM_VARIANT ] := EmitOP_EXTENDED_FROM_VARIANT_64;
EmitList[ - OP_INT_FROM_VARIANT ] := EmitOP_INT_FROM_VARIANT_64;
EmitList[ - OP_INT64_FROM_VARIANT ] := EmitOP_INT64_FROM_VARIANT_64;
EmitList[ - OP_UINT64_FROM_VARIANT ] := EmitOP_INT64_FROM_VARIANT_64;
EmitList[ - OP_BYTE_FROM_VARIANT ] := EmitOP_BYTE_FROM_VARIANT_64;
EmitList[ - OP_WORD_FROM_VARIANT ] := EmitOP_WORD_FROM_VARIANT_64;
EmitList[ - OP_CARDINAL_FROM_VARIANT ] := EmitOP_CARDINAL_FROM_VARIANT_64;
EmitList[ - OP_BOOL_FROM_VARIANT ] := EmitOP_BOOL_FROM_VARIANT_64;
EmitList[ - OP_BYTEBOOL_FROM_VARIANT ] := EmitOP_BYTEBOOL_FROM_VARIANT_64;
EmitList[ - OP_WORDBOOL_FROM_VARIANT ] := EmitOP_WORDBOOL_FROM_VARIANT_64;
EmitList[ - OP_LONGBOOL_FROM_VARIANT ] := EmitOP_LONGBOOL_FROM_VARIANT_64;
EmitList[ - OP_SMALLINT_FROM_VARIANT ] := EmitOP_SMALLINT_FROM_VARIANT_64;
EmitList[ - OP_SHORTINT_FROM_VARIANT ] := EmitOP_SHORTINT_FROM_VARIANT_64;
EmitList[ - OP_BOOL_FROM_BYTEBOOL ] := EmitOP_BOOL_FROM_BYTEBOOL_64;
EmitList[ - OP_BOOL_FROM_WORDBOOL ] := EmitOP_BOOL_FROM_WORDBOOL_64;
EmitList[ - OP_BOOL_FROM_LONGBOOL ] := EmitOP_BOOL_FROM_LONGBOOL_64;
EmitList[ - OP_NEG_VARIANT ] := EmitOP_NEG_VARIANT_64;
EmitList[ - OP_ABS_VARIANT ] := EmitOP_ABS_VARIANT_64;
EmitList[ - OP_NOT_VARIANT ] := EmitOP_NOT_VARIANT_64;
EmitList[ - OP_ADD_VARIANT ] := EmitOP_ADD_VARIANT_64;
EmitList[ - OP_SUB_VARIANT ] := EmitOP_SUB_VARIANT_64;
EmitList[ - OP_MULT_VARIANT ] := EmitOP_MULT_VARIANT_64;
EmitList[ - OP_DIV_VARIANT ] := EmitOP_DIV_VARIANT_64;
EmitList[ - OP_IDIV_VARIANT ] := EmitOP_IDIV_VARIANT_64;
EmitList[ - OP_MOD_VARIANT ] := EmitOP_MOD_VARIANT_64;
EmitList[ - OP_SHL_VARIANT ] := EmitOP_SHL_VARIANT_64;
EmitList[ - OP_SHR_VARIANT ] := EmitOP_SHR_VARIANT_64;
EmitList[ - OP_AND_VARIANT ] := EmitOP_AND_VARIANT_64;
EmitList[ - OP_OR_VARIANT ] := EmitOP_OR_VARIANT_64;
EmitList[ - OP_XOR_VARIANT ] := EmitOP_XOR_VARIANT_64;
EmitList[ - OP_LT_VARIANT ] := EmitOP_LT_VARIANT_64;
EmitList[ - OP_LE_VARIANT ] := EmitOP_LE_VARIANT_64;
EmitList[ - OP_GT_VARIANT ] := EmitOP_GT_VARIANT_64;
EmitList[ - OP_GE_VARIANT ] := EmitOP_GE_VARIANT_64;
EmitList[ - OP_EQ_VARIANT ] := EmitOP_EQ_VARIANT_64;
EmitList[ - OP_NE_VARIANT ] := EmitOP_NE_VARIANT_64;
EmitList[ - OP_CURRENCY_FROM_INT ] := EmitOP_CURRENCY_FROM_INT_64;
EmitList[ - OP_CURRENCY_FROM_INT64 ] := EmitOP_CURRENCY_FROM_INT64_64;
EmitList[ - OP_CURRENCY_FROM_UINT64 ] := EmitOP_CURRENCY_FROM_INT64_64;
EmitList[ - OP_CURRENCY_FROM_REAL ] := EmitOP_CURRENCY_FROM_REAL_64;
EmitList[ - OP_VARIANT_FROM_CLASS ] := EmitOP_VARIANT_FROM_CLASS_64;
EmitList[ - OP_VARIANT_FROM_POINTER ] := EmitOP_VARIANT_FROM_POINTER_64;
EmitList[ - OP_CLASS_FROM_VARIANT ] := EmitOP_CLASS_FROM_VARIANT_64;
EmitList[ - OP_INTERFACE_FROM_CLASS ] := EmitOP_INTERFACE_FROM_CLASS_64;
EmitList[ - OP_INTERFACE_CAST ] := EmitOP_INTERFACE_CAST_64;
EmitList[ - OP_ASSIGN_VARIANT ] := EmitOP_ASSIGN_VARIANT_64;
EmitList[ - OP_ASSIGN_OLEVARIANT ] := EmitOP_ASSIGN_OLEVARIANT_64;
EmitList[ - OP_ASSIGN_CLASS ] := EmitOP_ASSIGN_CLASS_64;
EmitList[ - OP_VARARRAY_GET ] := EmitOP_VARARRAY_GET_64;
EmitList[ - OP_VARARRAY_PUT ] := EmitOP_VARARRAY_PUT_64;
EmitList[ - OP_OLE_GET ] := EmitOP_OLE_GET_64;
EmitList[ - OP_OLE_SET ] := EmitOP_OLE_SET_64;
EmitList[ - OP_OLE_PARAM ] := EmitOP_OLE_PARAM_64;
EmitList[ - OP_IS ] := EmitOP_IS_64;
EmitList[ - OP_TYPEINFO ] := EmitOP_TYPEINFO_64;
EmitList[ - OP_ADD_TYPEINFO ] := EmitPCodeOperator;
EmitList[ - OP_PUSH_CONTEXT ] := EmitOP_PUSH_CONTEXT_64;
EmitList[ - OP_POP_CONTEXT ] := EmitOP_POP_CONTEXT_64;
EmitList[ - OP_FIND_CONTEXT ] := EmitOP_FIND_CONTEXT_64;
EmitList[ - OP_FIND_JS_FUNC ] := EmitOP_FIND_JS_FUNC_64;
EmitList[ - OP_GET_PROG ] := EmitOP_GET_PROG_64;
EmitList[ - OP_ONCREATE_HOST_OBJECT ] := EmitOP_ONCREATE_HOST_OBJECT_64;
EmitList[ - OP_ONDESTROY_HOST_OBJECT ] := EmitOP_ONDESTROY_HOST_OBJECT_64;
EmitList[ - OP_BEFORE_CALL_HOST ] := EmitOP_BEFORE_CALL_HOST_64;
EmitList[ - OP_AFTER_CALL_HOST ] := EmitOP_AFTER_CALL_HOST_64;
EmitList[ - OP_INIT_FWARRAY ] := EmitOP_INIT_FWARRAY_64;
EmitList[ - OP_ONCREATE_OBJECT ] := EmitOP_ONCREATE_OBJECT_64;
EmitList[ - OP_ON_AFTER_OBJECT_CREATION ] := EmitOP_ON_AFTER_OBJECT_CREATION_64;
EmitList[ - OP_CLASSNAME ] := EmitOP_CLASSNAME_64;
EmitList[ - OP_GET_DRTTI_PROP ] := EmitOP_GET_DRTTI_PROP_64;
EmitList[ - OP_SET_DRTTI_PROP ] := EmitOP_SET_DRTTI_PROP_64;
EmitList[ - OP_GET_ANSISTR_PROP ] := EmitOP_GET_ANSISTR_PROP_64;
EmitList[ - OP_SET_ANSISTR_PROP ] := EmitOP_SET_ANSISTR_PROP_64;
EmitList[ - OP_GET_WIDESTR_PROP ] := EmitOP_GET_WIDESTR_PROP_64;
EmitList[ - OP_SET_WIDESTR_PROP ] := EmitOP_SET_WIDESTR_PROP_64;
EmitList[ - OP_GET_UNICSTR_PROP ] := EmitOP_GET_UNICSTR_PROP_64;
EmitList[ - OP_SET_UNICSTR_PROP ] := EmitOP_SET_UNICSTR_PROP_64;
EmitList[ - OP_GET_ORD_PROP ] := EmitOP_GET_ORD_PROP_64;
EmitList[ - OP_SET_ORD_PROP ] := EmitOP_SET_ORD_PROP_64;
EmitList[ - OP_GET_INTERFACE_PROP ] := EmitOP_GET_INTERFACE_PROP_64;
EmitList[ - OP_SET_INTERFACE_PROP ] := EmitOP_SET_INTERFACE_PROP_64;
EmitList[ - OP_GET_SET_PROP ] := EmitOP_GET_SET_PROP_64;
EmitList[ - OP_SET_SET_PROP ] := EmitOP_SET_SET_PROP_64;
EmitList[ - OP_GET_FLOAT_PROP ] := EmitOP_GET_FLOAT_PROP_64;
EmitList[ - OP_SET_FLOAT_PROP ] := EmitOP_SET_FLOAT_PROP_64;
EmitList[ - OP_GET_VARIANT_PROP ] := EmitOP_GET_VARIANT_PROP_64;
EmitList[ - OP_SET_VARIANT_PROP ] := EmitOP_SET_VARIANT_PROP_64;
EmitList[ - OP_GET_INT64_PROP ] := EmitOP_GET_INT64_PROP_64;
EmitList[ - OP_SET_INT64_PROP ] := EmitOP_SET_INT64_PROP_64;
EmitList[ - OP_GET_EVENT_PROP ] := EmitOP_GET_EVENT_PROP_64;
EmitList[ - OP_SET_EVENT_PROP ] := EmitOP_SET_EVENT_PROP_64;
EmitList[ - OP_SET_EVENT_PROP2 ] := EmitOP_SET_EVENT_PROP2_64;
EmitList[ - OP_TRY_ON ] := EmitOP_TRY_ON_64;
EmitList[ - OP_EXCEPT_SEH ] := EmitOP_EXCEPT_SEH_64;
EmitList[ - OP_TRY_OFF ] := EmitOP_TRY_OFF_64;
EmitList[ - OP_FINALLY ] := EmitOP_FINALLY_64;
EmitList[ - OP_EXCEPT ] := EmitOP_EXCEPT_64;
EmitList[ - OP_EXCEPT_ON ] := EmitOP_EXCEPT_ON_64;
EmitList[ - OP_RAISE ] := EmitOP_RAISE_64;
EmitList[ - OP_EXIT ] := EmitOP_EXIT_64;
EmitList[ - OP_COND_RAISE ] := EmitOP_COND_RAISE_64;
EmitList[ - OP_BEGIN_EXCEPT_BLOCK ] := EmitOP_BEGIN_EXCEPT_BLOCK_64;
EmitList[ - OP_END_EXCEPT_BLOCK ] := EmitOP_END_EXCEPT_BLOCK_64;
EmitList[ - OP_OVERFLOW_CHECK ] := EmitOP_OVERFLOW_CHECK_64;
EmitList[ - OP_PAUSE ] := EmitOP_PAUSE_64;
EmitList[ - OP_CHECK_PAUSE ] := EmitOP_CHECK_PAUSE_64;
EmitList[ - OP_CHECK_PAUSE_LIGHT ] := EmitOP_CHECK_PAUSE_LIGHT_64;
EmitList[ - OP_HALT ] := EmitOP_HALT_64;
EmitList[ - OP_CREATE_OBJECT ] := EmitOP_CREATE_OBJECT_64;
EmitList[ - OP_DESTROY_OBJECT ] := EmitOP_DESTROY_OBJECT_64;
EmitList[ - OP_GET_VMT_ADDRESS ] := EmitOP_GET_VMT_ADDRESS_64;
EmitList[ - OP_SET_LENGTH ] := EmitOP_SET_LENGTH_64;
EmitList[ - OP_SET_LENGTH_EX ] := EmitOP_SET_LENGTH_EX_64;
EmitList[ - OP_PUSH_LENGTH ] := EmitPCodeOperator;
EmitList[ - OP_CREATE_METHOD ] := EmitOP_CREATE_METHOD_64;
EmitList[ - OP_DECLARE_TEMP_VAR ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_USING ] := EmitPCodeOperator;
EmitList[ - OP_END_USING ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_BLOCK ] := EmitPCodeOperator;
EmitList[ - OP_END_BLOCK ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_WITH ] := EmitPCodeOperator;
EmitList[ - OP_END_WITH ] := EmitPCodeOperator;
EmitList[ - OP_PARAM_CHANGED ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_SUB ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_CLASS_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_CLASS_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_RECORD_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_RECORD_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_HELPER_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_HELPER_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_ADD_ANCESTOR ] := EmitNothing;
EmitList[ - OP_INIT_PANSICHAR_LITERAL ] := EmitNothing;
EmitList[ - OP_INIT_PWIDECHAR_LITERAL ] := EmitNothing;
EmitList[ - OP_BEGIN_CRT_JS_FUNC_OBJECT ] := EmitOP_BEGIN_CRT_JS_FUNC_OBJECT_64;
EmitList[ - OP_END_CRT_JS_FUNC_OBJECT ] := EmitOP_END_CRT_JS_FUNC_OBJECT_64;
EmitList[ - OP_TO_JS_OBJECT ] := EmitOP_TO_JS_OBJECT_64;
EmitList[ - OP_JS_TYPEOF ] := EmitOP_JS_TYPEOF_64;
EmitList[ - OP_JS_VOID ] := EmitOP_JS_VOID_64;
EmitList[ - OP_GET_NEXTJSPROP ] := EmitOP_GET_NEXTJSPROP_64;
EmitList[ - OP_CLEAR_REFERENCES ] := EmitOP_CLEAR_REFERENCES_64;
EmitList[ - OP_DECLARE_LOCAL_VAR ] := EmitPCodeOperator;
EmitList[ - OP_LOAD_PROC ] := EmitPCodeOperator;
EmitList[ - OP_ADD_MESSAGE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_ARRAY_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_ARRAY_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_SET_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_SET_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_ENUM_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_ENUM_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_SUBRANGE_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_SUBRANGE_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_POINTER_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_POINTER_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_CLASSREF_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_CLASSREF_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_DYNARRAY_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_DYNARRAY_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_SHORTSTRING_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_SHORTSTRING_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_INTERFACE_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_END_INTERFACE_TYPE ] := EmitPCodeOperator;
EmitList[ - OP_BEGIN_TEXT ] := EmitPCodeOperator;
EmitList[ - OP_END_TEXT ] := EmitPCodeOperator;
EmitList[ - OP_WARNINGS_ON ] := EmitPCodeOperator;
EmitList[ - OP_WARNINGS_OFF ] := EmitPCodeOperator;
EmitList[ - OP_FRAMEWORK_ON ] := EmitPCodeOperator;
EmitList[ - OP_FRAMEWORK_OFF ] := EmitPCodeOperator;
EmitList[ - OP_DECL_SUB ] := EmitPCodeOperator;
EmitList[ - OP_DECLARE_MEMBER ] := EmitPCodeOperator;
EmitList[ - OP_ABSOLUTE ] := EmitPCodeOperator;
end;
{$ENDIF}
end;
function TEmitter.IsLocalPos: Boolean;
begin
with TKernel(kernel) do
result := Code.IsLocalPos(Code.N);
end;
function TEmitter.GetLanguage: Integer;
begin
with TKernel(kernel) do
result := Code[Code.N].Language;
end;
function TEmitter.GetOperName: String;
begin
result := Operators[- R.Op];
end;
function TEmitter.Host1: Boolean;
begin
result := GetSymbolRec(R.Arg1).Host;
end;
function TEmitter.Host2: Boolean;
begin
result := GetSymbolRec(R.Arg2).Host;
end;
function TEmitter.ByRef1: Boolean;
begin
result := GetSymbolRec(R.Arg1).ByRef or GetSymbolRec(R.Arg1).ByRefEx;
end;
function TEmitter.GetReg: Integer;
begin
result := registers.GetReg;
end;
function TEmitter.GetReg(Reg: Integer): Integer;
begin
registers.GetReg(Reg);
result := Reg;
end;
function TEmitter.GetRegEx: Integer;
begin
result := GetReg(_EBX);
end;
function TEmitter.GetReg64: Integer;
begin
result := registers.GetReg64;
end;
procedure TEmitter.FreeReg(Reg: Integer);
begin
Registers.FreeReg(Reg);
end;
function TEmitter.ImmValue1: Cardinal;
begin
result := SymbolRec1.Value;
end;
function TEmitter.ImmValue2: Cardinal;
begin
result := SymbolRec2.Value;
end;
function TEmitter.GetOffset(S: TSymbolRec): Integer;
begin
result := TKernel(kernel).GetOffset(S);
end;
function TEmitter.SymbolRec1: TSymbolRec;
begin
result := GetSymbolRec(R.Arg1);
end;
function TEmitter.SymbolRec2: TSymbolRec;
begin
result := GetSymbolRec(R.Arg2);
end;
function TEmitter.SymbolRecR: TSymbolRec;
begin
result := GetSymbolRec(R.Res);
end;
function TEmitter.Lookup(const S: String): Integer;
begin
result := SymbolTable.LookUp(S, 0, false);
end;
function TEmitter.CreateSymbolProgram(i_kernel: Pointer): TSymbolProg;
var
Code: TCode;
I, J, ShiftValue: Integer;
SymbolProgRec: TSymbolProgRec;
SymbolRec: TSymbolRec;
Modules: TModuleList;
b: Boolean;
K, KK: Integer;
SZ: Integer;
begin
Self.kernel := i_kernel;
EmitOff := false;
HandlesEvents := false;
Prg := TSymbolProg.Create(kernel);
Prg.Clear;
result := Prg;
Code := TKernel(kernel).Code;
// Prg.AsmAddREG_Imm(_ECX, $44);
// Prg.AsmAddREG_Imm(_R10, $44);
// Exit;
// Prg.AsmPutREG8_EBPPtr(_ecx, $444444);
// Prg.AsmPutREG8_EBPPtr(_r8, $444444);
// Prg.AsmMovREG8_REGPtr(_ecx, _ebx);
// Prg.AsmMovREGPtr_REG8(_ecx, _r11);
// Prg.AsmMovREGPtr_REG8(_r10, _ecx);
// Prg.AsmMovREGPtr_REG8(_r10, _r11);
// Prg.AsmMovREG8_REGPtr(_ecx, _ebx);
// exit;
{
Prg.AsmMovREGPtr_Imm(_R9, $80,$80);
Prg.AsmMovREGPtr_Imm(_R10, $80,$80);
Prg.AsmMovREGPtr_Imm(_R11, $80,$80);
Prg.AsmMovREGPtr_Imm(_R12, $80,$80);
Prg.AsmMovREGPtr_Imm(_R13, $80,$80);
Prg.AsmMovREGPtr_Imm(_R14, $80,$80);
Prg.AsmMovREGPtr_Imm(_R15, $80,$80);
Exit;
}
{
Prg.AsmMovREG64_RSPPtr(_EAX, $80);
Prg.AsmMovREG64_RSPPtr(_ECX, $80);
Prg.AsmMovREG64_RSPPtr(_EDX, $80);
Prg.AsmMovREG64_RSPPtr(_EBX, $80);
Prg.AsmMovREG64_RSPPtr(_ESI, $80);
Prg.AsmMovREG64_RSPPtr(_EDI, $80);
Prg.AsmMovREG64_RSPPtr(_R8D, $80);
Prg.AsmMovREG64_RSPPtr(_R9D, $80);
Exit;
}
// Prg.AsmPutREG64_RBPPtr(_R8D, $4000);
// Exit;
// Prg.AsmCmpREGPtr_Imm(_EAX, Code.GetSymbolRec(1000014), 4000000000);
// Prg.AsmNEG_REGPtr(_EAX, Code.GetSymbolRec(1000014));
// Prg.AsmMovREGPtr_Imm(_EAX, 4000000000, 4000000000);
// Prg.AsmFstpExtended_REGPtr(_EAX, Code.GetSymbolRec(1000014));
// Exit;
try
Prg.AsmJMP_Imm(0);
case TargetPlatform of
tpOSX32, tpIOSSim:
begin
Prg.AsmPush_REG(_EBP);
Prg.AsmPush_REG(_EBX);
Prg.AsmPush_REG(_ESI);
Prg.AsmPush_REG(_EDI);
Prg.AsmMovREG_REG(_EBP, _ESP);
Prg.AsmSubREG_Imm(_ESP, $10);
Prg.EmitGetCallerEIP;
end;
tpWIN64:
begin
Prg.AsmPush_REG(_EBP);
Prg.AsmSubReg_Imm(_ESP, $100);
Prg.AsmMovREG_REG(_EBP, _ESP);
end;
end;
for I:= 1 to Code.Card do
begin
R := Code.Records[I];
{$IFNDEF PAXARM}
if R.Op = OP_INIT_PANSICHAR_LITERAL then
begin
EmitOP_INIT_PCHAR_LITERAL;
R.Op := OP_NOP;
end
else
{$ENDIF}
if R.Op = OP_INIT_PWIDECHAR_LITERAL then
begin
EmitOP_INIT_PWIDECHAR_LITERAL;
R.Op := OP_NOP;
end;
end;
for I:= 1 to Code.Card do
begin
R := Code.Records[I];
if R.Op = OP_LOAD_PROC then
begin
if TargetPlatform = tpWIN64 then
EmitOP_LOAD_PROC_64
else
EmitOP_LOAD_PROC;
end;
end;
K := 0;
b := false;
for I:= 1 to Code.Card do
begin
R := Code.Records[I];
if R.Op = OP_BEGIN_INIT_CONST then
begin
b := true;
R.Op := OP_NOP;
Inc(K);
end
else if R.Op = OP_END_INIT_CONST then
begin
Dec(K);
if K = 0 then
b := false;
R.Op := OP_NOP;
end
else if b then
begin
Code.N := I;
Emit(I);
R.Op := OP_NOP;
end;
end;
for I:= 1 to Code.Card do
begin
R := Code.Records[I];
if R.Op = OP_ADD_MESSAGE then
begin
if TargetPlatform = tpWIN64 then
EmitOP_ADD_MESSAGE_64
else
EmitOP_ADD_MESSAGE;
end;
end;
Modules := TKernel(kernel).Modules;
Modules.Recalc;
// emit initialization sections
for J:=0 to Modules.LoadOrder.Count - 1 do
if Modules[J].PInitBegin > 0 then
for I:= Modules[J].PInitBegin + 1 to Modules[J].PInitEnd - 1 do
Emit(I);
EmitOP_CHECK_INIT_ONLY;
for KK:=1 to MAGIC_INITIALIZATION_JMP_COUNT do
Prg.AsmJMP_Imm(0);
case TargetPlatform of
tpOSX32, tpIOSSim:
begin
Prg.AsmPush_REG(_EBP);
Prg.AsmPush_REG(_EBX);
Prg.AsmPush_REG(_ESI);
Prg.AsmPush_REG(_EDI);
Prg.AsmMovREG_REG(_EBP, _ESP);
Prg.AsmSubREG_Imm(_ESP, $10);
Prg.EmitGetCallerEIP;
end;
tpWIN64:
begin
Prg.AsmPush_REG(_EBP);
Prg.AsmSubReg_Imm(_ESP, $100);
Prg.AsmMovREG_REG(_EBP, _ESP);
end;
end;
I := 1;
while I < Code.Card do
begin
R := Code.Records[I];
Code.N := I;
if R.Op = OP_BEGIN_CRT_JS_FUNC_OBJECT then
begin
EmitOP_BEGIN_CRT_JS_FUNC_OBJECT;
R.Op := OP_NOP;
repeat
Inc(I);
R := Code.Records[I];
Code.N := I;
Emit(I);
if R.Op = OP_END_CRT_JS_FUNC_OBJECT then
begin
R.Op := OP_NOP;
break;
end
else
R.Op := OP_NOP;
until false;
end;
Inc(I);
end;
I := 1;
while I <= Code.Card do
begin
R := Code.Records[I];
Code.N := I;
if R.Op = OP_SEPARATOR then
begin
EmitOP_SEPARATOR(I);
Inc(I);
continue;
end
else if R.Op = OP_EMIT_ON then
begin
EmitOP_EMIT_ON;
Inc(I);
continue;
end
else if R.Op = OP_EMIT_OFF then
begin
EmitOP_EMIT_OFF;
Inc(I);
continue;
end
else if R.Op = OP_END_INITIALIZATION then
begin
EmitOP_EMIT_ON;
Inc(I);
continue;
end
else if R.Op = OP_BEGIN_INITIALIZATION then
begin
EmitOP_EMIT_OFF;
Inc(I);
continue;
end
else if R.Op = OP_END_FINALIZATION then
begin
EmitOP_EMIT_ON;
Inc(I);
continue;
end
else if R.Op = OP_BEGIN_FINALIZATION then
begin
EmitOP_EMIT_OFF;
Inc(I);
continue;
end;
if not EmitOff then
Emit(I);
Inc(I);
end;
Prg.Optimization;
ShiftValue := 0;
for I:=1 to Prg.Card do
begin
Prg[I].ShiftValue := ShiftValue;
J := Prg[I].LabelId;
if J > 0 then
SymbolTable[J].Value := ShiftValue;
SZ := Prg[I].Size;
if SZ > 0 then
ShiftValue := ShiftValue + SZ;
end;
for I:=0 to List1.Count - 1 do
begin
SymbolProgRec := TSymbolProgRec(List1[I]); // record of symbol code
ShiftValue := SymbolProgRec.ShiftValue;
SymbolRec := TSymbolRec(List3[I]); // label
if SymbolProgRec.Op = ASM_JMP then
begin
ShiftValue := SymbolRec.Value - ShiftValue - SymbolProgRec.Size;
Move(ShiftValue, SymbolProgRec.code[1], 4);
SymbolProgRec.Decompile;
end
else if SymbolProgRec.Op = ASM_PUSH then // pause
begin
ShiftValue := SymbolRec.Value;
Move(ShiftValue, SymbolProgRec.code[1], 4);
SymbolProgRec.Decompile;
end
else
RaiseError(errInternalError, []);
end;
for I:=0 to List2.Count - 1 do
begin
SymbolProgRec := TSymbolProgRec(List2[I]); // record of symbol code
ShiftValue := SymbolTable[SymbolProgRec.SaveSubId].Value;
// if ShiftValue < 0 then
// RaiseError(errInternalError, []);
if TargetPlatform = tpWIN64 then
Move(ShiftValue, SymbolProgRec.code[3], 4)
else
begin
if SymbolProgRec.code[0] = $05 then // ADD EAX, Imm
Move(ShiftValue, SymbolProgRec.code[1], 4)
else
Move(ShiftValue, SymbolProgRec.code[2], 4);
end;
SymbolProgRec.Decompile;
end;
finally
end;
end;
procedure TEmitter.Emit(I: Integer);
var
Code: TCode;
J, KK, Op: Integer;
Modules: TModuleList;
begin
Code := TKernel(kernel).Code;
R := Code.Records[I];
Code.N := I;
Op := R.Op;
if Op = OP_SEPARATOR then
begin
EmitOP_SEPARATOR(I);
end
else if Op = OP_SET_CODE_LINE then
begin
Prg.AsmComment('***** N ****** ' + IntToStr(Code.N));
Prg.AsmMovREGPtr_Imm(_ESI, H_ByteCodePtr, I);
end
else if Op = OP_STMT then
begin
Prg.AsmMovREGPtr_Imm(_ESI, H_ByteCodePtr, I);
end
else if Op = OP_BEGIN_MODULE then
begin
Prg.AsmComment('Module ' + Code.GetModule(I).Name);
end
else if Op = OP_END_INTERFACE_SECTION then
begin
Prg.AsmComment('End of interface section of ' + Code.GetModule(I).Name);
end
else if Op = OP_END_MODULE then
begin
Prg.AsmComment('End of module ' + Code.GetModule(I).Name);
case TargetPlatform of
tpOSX32, tpIOSSim:
begin
Prg.AsmAddReg_Imm(_ESP, $10);
Prg.AsmPop_REG(_EDI);
Prg.AsmPop_REG(_ESI);
Prg.AsmPop_REG(_EBX);
Prg.AsmPop_REG(_EBP);
end;
tpWIN64:
begin
Prg.AsmAddReg_Imm(_ESP, $100);
Prg.AsmPop_REG(_EBP);
end;
end;
EmitOP_CHECK_BODY_ONLY;
for KK:=1 to MAGIC_FINALIZATION_JMP_COUNT do
Prg.AsmJMP_Imm(0);
case TargetPlatform of
tpOSX32, tpIOSSim:
begin
Prg.AsmPush_REG(_EBP);
Prg.AsmPush_REG(_EBX);
Prg.AsmPush_REG(_ESI);
Prg.AsmPush_REG(_EDI);
Prg.AsmMovREG_REG(_EBP, _ESP);
Prg.AsmSubReg_Imm(_ESP, $10);
Prg.EmitGetCallerEIP;
end;
tpWIN64:
begin
Prg.AsmPush_REG(_EBP);
Prg.AsmSubReg_Imm(_ESP, $100);
Prg.AsmMovREG_REG(_EBP, _ESP);
end;
end;
// emit finalization sections
Modules := TKernel(kernel).Modules;
for J:=Modules.LoadOrder.Count - 1 downto 0 do
if Modules[J].PFinBegin > 0 then
for I:= Modules[J].PFinBegin + 1 to Modules[J].PFinEnd - 1 do
Emit(I);
case TargetPlatform of
tpOSX32, tpIOSSim:
begin
Prg.AsmAddReg_Imm(_ESP, $10);
Prg.AsmPop_REG(_EDI);
Prg.AsmPop_REG(_ESI);
Prg.AsmPop_REG(_EBX);
Prg.AsmPop_REG(_EBP);
end;
tpWIN64:
begin
Prg.AsmAddReg_Imm(_ESP, $100);
Prg.AsmPop_REG(_EBP);
end;
end;
Prg.AsmRet;
end
else if Op = OP_LABEL then
EmitLabel(R.Arg1, GetSymbolRec(R.Arg1).Name)
else
EmitList[-Op];
end;
procedure TEmitter.RaiseError(const Message: string; params: array of Const);
begin
TKernel(kernel).RaiseError(Message, params);
end;
procedure TEmitter.CreateError(const Message: string; params: array of Const);
begin
TKernel(kernel).CreateError(Message, params);
end;
function TEmitter.GetSymbolRec(Id: Integer): TSymbolRec;
begin
result := TKernel(kernel).SymbolTable[Id];
end;
function TEmitter.SymbolTable: TSymbolTable;
begin
result := TKernel(kernel).SymbolTable;
end;
function TEmitter.ByteCode: TCode;
begin
result := TKernel(kernel).Code;
end;
procedure TEmitter.EmitPCodeOperator;
var
S: String;
N: Integer;
begin
N := TKernel(kernel).Code.N;
if (R.Op = OP_CALL) or (R.Op = OP_LOAD_PROC) then
begin
if SymbolRec1.MethodIndex > 0 then
S := '(' + IntToStr(SymbolRec1.MethodIndex) + ')' + ' *** N *** ' + IntToStr(N)
else
S := ' *** N *** ' + IntToStr(N);
Prg.AsmComment(' ' + OperName + ' ' +
GetSymbolRec(R.Arg1).FullName + '[' + IntToStr(R.Arg1) + ']' + S);
end
else
Prg.AsmComment(' ' + OperName + ' *** N *** ' + IntToStr(N));
end;
procedure TEmitter.EmitComment;
var
S: String;
begin
S := SymbolRec1.Value;
Prg.AsmComment(S);
end;
procedure TEmitter.EmitStartSub(SubId: Integer);
var
R: TSymbolProgRec;
begin
R := Prg.AsmComment('START SUB [' + IntToStr(SubId) + ']; // ' + GetSymbolRec(SubId).FullName);
if not GetSymbolRec(SubId).IsNestedSub then
R.MapSub := - SubId;
end;
procedure TEmitter.EmitFinSub(SubId: Integer);
var
R: TSymbolProgRec;
begin
R := Prg.AsmComment('FIN SUB [' + IntToStr(SubId) + ']; // ' + GetSymbolRec(SubId).FullName);
if not GetSymbolRec(SubId).IsNestedSub then
R.MapSub := SubId;
end;
procedure TEmitter.EmitOP_SEPARATOR(I: Integer);
{$IFDEF TRIAL}
var SubId: Integer;
{$ENDIF}
begin
{$IFDEF DUMP}
Prg.AsmComment('------------------------------------------------------');
Prg.AsmComment(TKernel(kernel).Code.GetSourceLine(I));
Prg.AsmComment('------------------------------------------------------');
{$ENDIF}
{$IFDEF TRIAL}
Inc(_Counter);
if _Counter mod 101 = 0 then
begin
SubId := TKernel(kernel).SymbolTable.LookUp(strShowTrial, 0, false);
EmitCallPro(SubId);
EmitStdCall(SubId);
end;
{$ENDIF}
end;
procedure TEmitter.EmitOP_GO;
begin
EmitPCodeOperator;
EmitJmp;
end;
procedure TEmitter.EmitOP_PAUSE_64;
begin
RaiseError(errNotImplementedYet, []);
end;
procedure TEmitter.EmitOP_PAUSE;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_Pause;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _ESP);
Prg.AsmPush_REG(Reg); // push _ESP
Prg.AsmMovREG_REG(Reg, _EBP);
Prg.AsmPush_REG(Reg); // push _EBP
Prg.AsmPush_Imm(0);
List3.Add(SymbolRec1);
List1.Add(Prg.Top);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_CHECK_PAUSE_64;
begin
// RaiseError(errNotImplementedYet, []);
end;
procedure TEmitter.EmitOP_CHECK_PAUSE;
begin
EmitPCodeOperator;
Prg.AsmNOP;
Prg.AsmNOP;
Prg.AsmNOP;
Prg.AsmNOP;
Prg.AsmNOP;
EmitCallPro(Id_CheckPause);
GetReg(_EAX);
Prg.AsmMovREG_REG(_EAX, _ESI);
Prg.AsmAddREG_Imm(_EAX, H_SelfPtr);
Prg.AsmMovREG_REGPtr(_EAX, _EAX); // load TProgram.Self
FreeReg(_EAX);
EmitStdCall(Id_CheckPause);
Prg.AsmCmpReg32Ptr_Imm(_ESI, H_Flag, 1);
Prg.AsmJNZ_Imm(29);
R.Op := OP_PAUSE;
EmitOP_PAUSE;
R.Op := OP_CHECK_PAUSE;
end;
procedure TEmitter.EmitOP_CHECK_PAUSE_LIGHT_64;
begin
RaiseError(errNotImplementedYet, []);
end;
procedure TEmitter.EmitOP_CHECK_PAUSE_LIGHT;
begin
EmitPCodeOperator;
Prg.AsmCmpReg32Ptr_Imm(_ESI, H_Flag, 1);
Prg.AsmJNZ_Imm(29);
R.Op := OP_PAUSE;
EmitOP_PAUSE;
R.Op := OP_CHECK_PAUSE;
end;
procedure TEmitter.EmitOP_HALT_64;
begin
RaiseError(errNotImplementedYet, []);
end;
procedure TEmitter.EmitOP_HALT;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_Halt;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmPush_Imm(SymbolRec1.Value);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_CHECK_INIT_ONLY;
begin
EmitPCodeOperator;
case TargetPlatform of
tpOSX32, tpIOSSim:
begin
Prg.AsmCmpReg32Ptr_Imm(_ESI, H_InitOnly, 2);
Prg.AsmJNZ_Imm(11);
Prg.AsmAddReg_Imm(_ESP, $10); // 6
Prg.AsmPop_REG(_EDI); // 1
Prg.AsmPop_REG(_ESI); // 1
Prg.AsmPop_REG(_EBX); // 1
Prg.AsmPop_REG(_EBP); // 1
Prg.AsmRet(); // 1
end;
tpWIN64:
begin
Prg.AsmCmpReg32Ptr_Imm(_ESI, H_InitOnly, 2);
Prg.AsmJNZ_Imm(9);
Prg.AsmAddReg_Imm(_ESP, $100); // 7
Prg.AsmPop_Reg(_EBP); // 1
Prg.AsmRet(); // 1
end;
else
begin
Prg.AsmCmpReg32Ptr_Imm(_ESI, H_InitOnly, 2);
Prg.AsmJNZ_Imm(1);
Prg.AsmRet();
end;
end;
end;
procedure TEmitter.EmitOP_CHECK_BODY_ONLY;
begin
EmitPCodeOperator;
Prg.AsmCmpReg32Ptr_Imm(_ESI, H_BodyOnly, 3);
Prg.AsmJNZ_Imm(1);
Prg.AsmRet();
end;
procedure TEmitter.EmitOP_TRY_ON_64;
begin
EmitPCodeOperator;
{
SubId := Id_TryOn;
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
Prg.AsmMovReg_Imm(Reg, R.Arg1); // block index
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_REG(_R8, _EBP);
Prg.AsmMovREG_REG(_R9, _ESP);
EmitGet_REG(Reg, SymbolTable[SubId]);
Prg.AsmCall_REG(Reg);
FreeReg(Reg);
}
end;
procedure TEmitter.EmitOP_TRY_ON;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
if TKernel(kernel).ModeSEH then
begin
Reg := _EAX;
Prg.AsmPush_REG(_ESP);
Prg.AsmPush_Imm(PAX_SEH); // magic
Prg.AsmPush_Imm(R.Arg1); // block index
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
Prg.AsmPush_Imm(0); // Self of method
Prg.AsmPush_REG(_EBP);
EmitGet_REG(Reg, SymbolTable[Id_PaxSEHHandler]);
Prg.AsmPush_REG(Reg); // push handler
Prg.AsmXorREG_REG(_EAX, _EAX);
Prg.AsmPush_FS_REGPtr(_EAX);
Prg.AsmMovFS_REGPtr_REG32(_EAX, _ESP);
Exit;
end;
SubId := Id_TryOn;
EmitCallPro(SubId);
if TargetPlatform = tpWIN64 then
begin
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
Prg.AsmMovReg_Imm(Reg, R.Arg1); // block index
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_REG(_R8, _EBP);
Prg.AsmMovREG_REG(_R9, _ESP);
FreeReg(Reg);
EmitStdCall(SubId);
end
else
begin
Prg.AsmPutREG_ESIPtr(_EDX, 0);
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _ESP);
Prg.AsmPush_REG(Reg); // push _ESP
Prg.AsmMovREG_REG(Reg, _EBP);
Prg.AsmPush_REG(Reg); // push _EBP
Prg.AsmPush_Imm(R.Arg1); // block index
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
Prg.AsmGetREG_ESIPtr(_EDX, 0);
end;
end;
procedure TEmitter.EmitOP_EXCEPT_SEH_64;
begin
end;
procedure TEmitter.EmitOP_EXCEPT_SEH;
begin
EmitPCodeOperator;
if TKernel(kernel).ModeSEH then
begin
Prg.AsmXorREG_REG(_EAX, _EAX);
Prg.AsmPop_REG(_EDX); // 4
Prg.AsmMovFS_REGPtr_REG32(_EAX, _EDX);
Prg.AsmAddREG_Imm(_ESP, SizeOf(TPaxExcFrame) - 4);
end;
end;
procedure TEmitter.EmitOP_TRY_OFF_64;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_TryOff;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
Prg.AsmMovReg_Imm(_EDX, R.Arg1); // block index
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_TRY_OFF;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
if TKernel(kernel).ModeSEH then
begin
exit;
end;
SubId := Id_TryOff;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmPush_Imm(R.Arg1); // block index
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_FINALLY_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_Finally;
EmitCallPro(SubId);
Reg := _ECX;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_FINALLY;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_Finally;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_EXCEPT_64;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_EXCEPT;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_EXCEPT_ON_64;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_EXCEPT_ON;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_EXIT_64;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_Exit;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
Prg.AsmMovREG_Imm(Reg, R.Res); // level
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_Imm(_R8, R.Arg2); // exit mode
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_EXIT;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_Exit;
EmitCallPro(SubId);
Prg.AsmPush_Imm(R.Arg2); // exit mode
Prg.AsmPush_Imm(R.Res); // level
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_RAISE_64;
begin
RaiseError(errNotImplementedYet, []);
end;
procedure TEmitter.EmitOP_RAISE;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_Raise;
EmitCallPro(SubId);
Prg.AsmPush_Reg(_ESP);
Prg.AsmPush_Imm(R.Arg2); // raise mode
Reg := GetReg;
if R.Arg1 = 0 then
Prg.AsmPush_Imm(R.Arg1) // block index
else
begin
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
end;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_OVERFLOW_CHECK_64;
begin
EmitPCodeOperator;
if R.Arg1 > 0 then
OverflowCheck := true
else
OverflowCheck := false;
end;
procedure TEmitter.EmitOP_OVERFLOW_CHECK;
begin
EmitPCodeOperator;
if R.Arg1 > 0 then
OverflowCheck := true
else
OverflowCheck := false;
end;
procedure TEmitter.EmitOP_BEGIN_EXCEPT_BLOCK_64;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_BeginExceptBlock;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_BEGIN_EXCEPT_BLOCK;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_BeginExceptBlock;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_END_EXCEPT_BLOCK_64;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_EndExceptBlock;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_END_EXCEPT_BLOCK;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_EndExceptBlock;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_COND_RAISE_64;
var
Reg, SubId, temp: Integer;
begin
EmitPCodeOperator;
SubId := Id_CondRaise;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
EmitLoadAddress(Reg, SymbolRecR); // IsExit
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_Imm(_R8, SymbolRecR.Level); // subid
Prg.AsmMovREG_Imm(_R9, R.Arg2); // last cond raise
Prg.AsmMovREG_Imm(Reg, _ESP); // subid
Prg.AsmMovRSPPtr_REG64(Reg, $20);
FreeReg(Reg);
EmitStdCall(SubId);
if R.Arg1 > 0 then
begin
Reg := EmitGetAddressRegister(SymbolRecR);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRecR, 0);
Prg.AsmJZ_Imm(5);
EmitJmp;
FreeReg(Reg);
if R.BreakLabel > 0 then
begin
Reg := EmitGetAddressRegister(SymbolRecR);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRecR, 0);
Prg.AsmJZ_Imm(5);
temp := R.Arg1;
R.Arg1 := R.BreakLabel;
EmitJmp;
R.Arg1 := temp;
FreeReg(Reg);
end;
end;
end;
procedure TEmitter.EmitOP_COND_RAISE;
var
Reg, SubId, temp: Integer;
begin
EmitPCodeOperator;
SubId := Id_CondRaise;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmPush_Reg(_ESP);
Prg.AsmPush_Imm(R.Arg2); // last cond raise
Prg.AsmPush_Imm(SymbolRecR.Level); // subid
EmitLoadAddress(Reg, SymbolRecR); // IsExit
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
if R.Arg1 > 0 then
begin
Reg := EmitGetAddressRegister(SymbolRecR);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRecR, 1);
Prg.AsmJNZ_Imm(5);
EmitJmp;
FreeReg(Reg);
if R.BreakLabel > 0 then
begin
Reg := EmitGetAddressRegister(SymbolRecR);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRecR, 2);
Prg.AsmJNZ_Imm(5);
temp := R.Arg1;
R.Arg1 := R.BreakLabel;
EmitJmp;
R.Arg1 := temp;
FreeReg(Reg);
end;
if R.ContinueLabel > 0 then
begin
Reg := EmitGetAddressRegister(SymbolRecR);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRecR, 3);
Prg.AsmJNZ_Imm(5);
temp := R.Arg1;
R.Arg1 := R.ContinueLabel;
EmitJmp;
R.Arg1 := temp;
FreeReg(Reg);
end;
end;
end;
procedure TEmitter.EmitOP_GO_1;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetRegEx;
EmitLoadIntVal(Reg, SymbolRec2);
Prg.AsmCmpREG_Imm(Reg, 1);
Prg.AsmJNZ_Imm(5);
EmitJmp;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_GO_2;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetRegEx;
EmitLoadIntVal(Reg, SymbolRec2);
Prg.AsmCmpREG_Imm(Reg, 2);
Prg.AsmJNZ_Imm(5);
EmitJmp;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_GO_3;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetRegEx;
EmitLoadIntVal(Reg, SymbolRec2);
Prg.AsmCmpREG_Imm(Reg, 3);
Prg.AsmJNZ_Imm(5);
EmitJmp;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_GO_TRUE_64;
begin
EmitOP_GO_TRUE;
end;
procedure TEmitter.EmitOP_GO_TRUE;
var
Reg: Integer;
begin
EmitPCodeOperator;
if SymbolRec2.Kind = kindCONST then
begin
if SymbolRec2.Value <> 0 then
EmitJmp;
Exit;
end;
{
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec2);
Prg.AsmCmpByteREGPtr_Imm(Reg, 0);
}
Reg := EmitGetAddressRegister(SymbolRec2);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec2, 0);
Prg.AsmJZ_Imm(5);
EmitJmp;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_GO_DL_64;
begin
EmitOP_GO_DL;
end;
procedure TEmitter.EmitOP_GO_DL;
begin
EmitPCodeOperator;
Prg.AsmTestREG8_REG8(_EDX, _EDX);
Prg.AsmJNZ_Imm(5);
EmitJmp;
end;
procedure TEmitter.EmitSaveRBX;
var
Id, SubId, S: Integer;
begin
SubId := ByteCode.GetCurrSubId(ByteCode.N);
if SubId > 0 then
begin
Id := SymbolTable.GetRBX_Id(SubId);
S := GetOffset(SymbolTable[Id]);
end
else
S := -4;
Prg.AsmPutREG32_EBPPtr(_EBX, S);
end;
procedure TEmitter.EmitRestoreRBX;
var
Id, SubId, S: Integer;
begin
SubId := ByteCode.GetCurrSubId(ByteCode.N);
if SubId > 0 then
begin
Id := SymbolTable.GetRBX_Id(SubId);
S := GetOffset(SymbolTable[Id]);
end
else
S := -4;
Prg.AsmGetREG32_EBPPtr(_EBX, S);
end;
procedure TEmitter.EmitSaveRDI;
var
Id, SubId, S: Integer;
begin
SubId := ByteCode.GetCurrSubId(ByteCode.N);
if SubId > 0 then
begin
Id := SymbolTable.GetRDI_Id(SubId);
S := GetOffset(SymbolTable[Id]);
end
else
S := -8;
Prg.AsmPutREG32_EBPPtr(_EDI, S);
end;
procedure TEmitter.EmitRestoreRDI;
var
Id, SubId, S: Integer;
begin
SubId := ByteCode.GetCurrSubId(ByteCode.N);
if SubId > 0 then
begin
Id := SymbolTable.GetRDI_Id(SubId);
S := GetOffset(SymbolTable[Id]);
end
else
S := -8;
Prg.AsmGetREG32_EBPPtr(_EDI, S);
end;
procedure TEmitter.EmitOP_SAVE_EDX_64;
begin
EmitOP_SAVE_EDX;
end;
procedure TEmitter.EmitOP_RESTORE_EDX_64;
begin
EmitOP_RESTORE_EDX;
end;
procedure TEmitter.EmitOP_SAVE_EDX;
var
SubId, DL_id: Integer;
begin
EmitPCodeOperator;
if TargetPlatform = tpWin32 then
Prg.AsmPush_REG(_EDX)
else
begin
SubId := ByteCode.GetCurrSubId(ByteCode.N);
Dl_Id := SymbolTable.GetDL_Id(SubId);
EmitSaveIntVal(_EDX, GetSymbolRec(DL_Id));
end;
end;
procedure TEmitter.EmitOP_RESTORE_EDX;
var
SubId, DL_id: Integer;
begin
EmitPCodeOperator;
if TargetPlatform = tpWin32 then
Prg.AsmPop_REG(_EDX)
else
begin
SubId := ByteCode.GetCurrSubId(ByteCode.N);
Dl_Id := SymbolTable.GetDL_Id(SubId);
EmitLoadIntVal(_EDX, GetSymbolRec(DL_Id));
end;
end;
procedure TEmitter.EmitOP_GO_FALSE_64;
begin
EmitOP_GO_FALSE;
end;
procedure TEmitter.EmitOP_GO_FALSE;
var
Reg: Integer;
begin
EmitPCodeOperator;
if SymbolRec2.Kind = kindCONST then
begin
if SymbolRec2.Value = 0 then
EmitJmp;
Exit;
end;
{
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec2);
Prg.AsmCmpByteREGPtr_Imm(Reg, 0);
}
Reg := EmitGetAddressRegister(SymbolRec2);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec2, 0);
Prg.AsmJNZ_Imm(5);
EmitJmp;
FreeReg(Reg);
end;
procedure TEmitter.EmitLabel(LabelId: Integer; const LabelName: String);
begin
Prg.AsmComment('LABEL: ' + LabelName);
Prg.Top.LabelId := LabelId;
end;
procedure TEmitter.EmitOP_ASSIGN_INT_I_64;
begin
EmitOP_ASSIGN_INT_I;
end;
procedure TEmitter.EmitOP_ASSIGN_INT_I;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmMovREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_ASSIGN_INT_M_64;
begin
EmitOP_ASSIGN_INT_M;
end;
procedure TEmitter.EmitOP_ASSIGN_INT_M;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRec1);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_ASSIGN_PANSICHAR_64;
begin
EmitOP_ASSIGN_PANSICHAR;
end;
procedure TEmitter.EmitOP_ASSIGN_PANSICHAR;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitGet_REG(Reg, SymbolRec2);
if SymbolRec2.Host or SymbolRec2.ByRef or SymbolRec2.ByRefEx then
Prg.AsmMovREG_REGPtr(Reg, Reg);
EmitSaveIntVal(Reg, SymbolRec1);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_ASSIGN_PWIDECHAR_64;
begin
EmitOP_ASSIGN_PWIDECHAR;
end;
procedure TEmitter.EmitOP_ASSIGN_PWIDECHAR;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitGet_REG(Reg, SymbolRec2);
if SymbolRec2.Host or SymbolRec2.ByRef or SymbolRec2.ByRefEx then
Prg.AsmMovREG_REGPtr(Reg, Reg);
EmitSaveIntVal(Reg, SymbolRec1);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_ASSIGN_EVENT_64;
begin
EmitOP_ASSIGN_EVENT;
end;
procedure TEmitter.EmitOP_ASSIGN_EVENT;
var
Reg, Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
HandlesEvents := true;
Reg := GetReg;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadAddress(Reg1, SymbolRec1);
EmitLoadAddress(Reg2, SymbolRec2);
Prg.AsmMovREG_REGPtr(Reg, Reg2);
Prg.AsmMovREGPtr_REG(Reg1, Reg);
Prg.AsmAddREG_Imm(Reg1, SizeOfPointer);
Prg.AsmAddREG_Imm(Reg2, SizeOfPointer);
Prg.AsmMovREG_REGPtr(Reg, Reg2);
Prg.AsmMovREGPtr_REG(Reg1, Reg);
FreeReg(Reg);
FreeReg(Reg1);
FreeReg(Reg2);
end;
procedure TEmitter.EmitOP_CREATE_EVENT_64;
begin
EmitOP_CREATE_EVENT;
end;
procedure TEmitter.EmitOP_CREATE_EVENT;
var
Reg, Reg1, Reg2: Integer;
SymbolProgRec: TSymbolProgRec;
begin
EmitPCodeOperator;
HandlesEvents := true;
Reg := GetReg;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadIntVal(Reg1, SymbolRec1); // instance
if SymbolRec2.IsVirtual then
begin
prg.AsmMovREG_REGPtr(Reg2, Reg1);
if SymbolRec2.MethodIndex = 0 then
begin
SymbolProgRec := prg.AsmAddREG_Imm(Reg2, 0);
SymbolProgRec.MustBeFixed := true;
SymbolProgRec.OpOffset := 2;
SymbolProgRec.SubId := SymbolRec2.Id;
end
else
prg.AsmAddREG_Imm(Reg2, (SymbolRec2.MethodIndex - 1) * SizeOfPointer);
prg.AsmMovREG_REGPtr(Reg2, Reg2);
end
else
begin
if Host2 then
EmitLoadAddress(Reg2, SymbolRec2) // address of method
else
begin
Prg.AsmMovREG_REG(Reg2, _EDI);
Prg.AsmAddREG_Imm(Reg2, 0);
Prg.Top.SaveSubId := R.Arg2;
List2.Add(Prg.Top);
end;
end;
EmitLoadAddress(Reg, SymbolRecR); // address of event
Prg.AsmMovREGPtr_REG(Reg, Reg2); // code
Prg.AsmAddREG_Imm(Reg, SizeOfPointer);
Prg.AsmMovREGPtr_REG(Reg, Reg1); // data
FreeReg(Reg);
FreeReg(Reg1);
FreeReg(Reg2);
end;
procedure TEmitter.EmitOP_ASSIGN_RECORD_64;
var
Reg, S, TypeId, SubId: Integer;
L: TIntegerList;
begin
TypeId := SymbolRec1.TerminalTypeId;
L := SymbolTable.GetShiftsOfDynamicFields(TypeId);
try
if L.Count = 0 then
begin
EmitPCodeOperator;
SubId := Id_RecordAssign;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRecR); // dest
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmMovREG_REG(_EDX, Reg);
S := SymbolRec1.PtrSize;
Prg.AsmMovREG_Imm(_R8, S);
FreeReg(Reg);
EmitStdCall(SubId);
end
else
EmitOP_ASSIGN_RECORD_EX;
finally
FreeAndNil(L);
end;
end;
procedure TEmitter.EmitOP_ASSIGN_RECORD;
var
Reg, S, TypeId, SubId: Integer;
L: TIntegerList;
begin
TypeId := SymbolRec1.TerminalTypeId;
L := SymbolTable.GetShiftsOfDynamicFields(TypeId);
try
if L.Count = 0 then
begin
EmitPCodeOperator;
SubId := Id_RecordAssign;
EmitCallPro(SubId);
Reg := GetRegEx;
S := SymbolRec1.PtrSize;
Prg.AsmPush_Imm(S);
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRecR); // dest
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end
else
EmitOP_ASSIGN_RECORD_EX;
finally
FreeAndNil(L);
end;
end;
procedure TEmitter.EmitOP_ASSIGN_RECORD_EX;
var SymbolTable: TSymbolTable;
procedure AssignArr(Reg1, Reg2, TypeId: Integer); forward;
procedure AssignRec(Reg1, Reg2, TypeId: Integer);
var
I, FT, Reg, SubId, S, K: Integer;
RI: TSymbolRec;
ArrayTypeId,
ElTypeId, ElFinalTypeId, ElSize,
ElTypeId2, ElFinalTypeId2, ElSize2: Integer;
begin
K := 0;
SubId := 0;
for I := TypeId + 1 to SymbolTable.Card do
begin
RI := SymbolTable[I];
if RI = SymbolTable.SR0 then
break;
if RI.Level <> TypeId then
continue;
if RI.Kind <> kindTYPE_FIELD then
continue;
FT := RI.FinalTypeId;
S := RI.PtrSize;
Inc(K);
Emit_PUSH_REGS;
if K > 1 then
begin
Prg.AsmAddREG_Imm(Reg1, RI.Shift);
Prg.AsmAddREG_Imm(Reg2, RI.Shift);
end;
case FT of
typeINTEGER, typeCARDINAL, typeLONGBOOL:
begin
Reg := GetReg;
Prg.AsmMovREG32_REGPtr(Reg, Reg2);
Prg.AsmMovREGPtr_REG32(Reg1, Reg);
FreeReg(Reg);
end;
typePOINTER, typePROC,
typeCLASS, typeCLASSREF:
begin
Reg := GetReg;
Prg.AsmMovREG_REGPtr(Reg, Reg2);
Prg.AsmMovREGPtr_REG(Reg1, Reg);
FreeReg(Reg);
end;
typeWORD, typeSMALLINT, typeWORDBOOL, typeWIDECHAR:
begin
Reg := GetReg;
Prg.AsmXorREG_REG(Reg, Reg);
Prg.AsmMovREG16_REGPtr(Reg, Reg2);
Prg.AsmMovREGPtr_REG16(Reg1, Reg);
FreeReg(Reg);
end;
typeBYTE,
typeBOOLEAN,
typeSHORTINT,
{$IFNDEF PAXARM}
typeANSICHAR,
{$ENDIF}
typeBYTEBOOL:
begin
Reg := GetReg;
Prg.AsmXorREG_REG(Reg, Reg);
Prg.AsmMovREG8_REGPtr(Reg, Reg2);
Prg.AsmMovREGPtr_REG8(Reg1, Reg);
FreeReg(Reg);
end;
{$IFNDEF PAXARM}
typeANSISTRING,
typeWIDESTRING,
typeSHORTSTRING,
{$ENDIF}
typeUNICSTRING,
typeVARIANT,
typeOLEVARIANT,
typeINTERFACE:
begin
case FT of
{$IFNDEF PAXARM}
typeANSISTRING: SubId := Id_AnsiStringAssign;
typeWIDESTRING: SubId := Id_WideStringAssign;
typeSHORTSTRING: SubId := Id_ShortStringAssign;
{$ENDIF}
typeUNICSTRING: SubId := Id_UnicStringAssign;
typeVARIANT, typeOLEVARIANT: SubId := Id_VariantAssign;
typeINTERFACE: SubId := Id_InterfaceAssign;
end;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmPush_REG(Reg1);
Prg.AsmPush_REG(Reg2);
FreeReg(Reg);
EmitStdCall(SubId);
end;
typeDYNARRAY:
begin
SubId := Id_DynarrayAssign;
EmitCallPro(SubId);
Reg := GetReg;
ArrayTypeId := RI.TerminalTypeId;
ElTypeId := GetSymbolRec(ArrayTypeId).PatternId;
ElFinalTypeId := GetSymbolRec(ElTypeId).FinalTypeId;
ElSize := SymbolTable[ElTypeId].Size;
ElTypeId2 := 0;
ElFinalTypeId2 := 0;
ElSize2 := 0;
if ElFinalTypeId = typeDYNARRAY then
begin
ElTypeId2 := GetSymbolRec(ElTypeId).TerminalTypeId;
ElTypeId2 := GetSymbolRec(ElTypeId2).PatternId;
ElFinalTypeId2 := GetSymbolRec(ElTypeId2).FinalTypeId;
ElSize2 := SymbolTable[ElTypeId2].Size;
end;
Prg.AsmPush_Imm(ElSize2);
Prg.AsmPush_Imm(ElTypeId2);
Prg.AsmPush_Imm(ElFinalTypeId2);
Prg.AsmPush_Imm(ElSize);
Prg.AsmPush_Imm(ElTypeId);
Prg.AsmPush_Imm(ElFinalTypeId);
Prg.AsmPush_REG(Reg1); // dest
Prg.AsmPush_REG(Reg2); // source
FreeReg(Reg);
EmitStdCall(SubId);
end;
typeRECORD:
AssignRec(Reg1, Reg2, RI.TerminalTypeId);
typeARRAY:
AssignArr(Reg1, Reg2, RI.TerminalTypeId);
else
begin
SubId := Id_RecordAssign;
EmitCallPro(SubId);
Prg.AsmPush_Imm(S);
Prg.AsmPush_REG(Reg2);
Prg.AsmPush_REG(Reg1);
EmitStdCall(SubId);
end;
end; // case
Emit_POP_REGS;
end;
end;
procedure AssignArr(Reg1, Reg2, TypeId: Integer);
var
RangeTypeId, ElemTypeId, H1, H2, FT, I, ElemSize, S, SubId, Reg: Integer;
begin
SymbolTable.GetArrayTypeInfo(TypeId, RangeTypeId, ElemTypeId);
H1 := SymbolTable.GetLowBoundRec(RangeTypeId).Value;
H2 := SymbolTable.GetHighBoundRec(RangeTypeId).Value;
ElemSize := SymbolTable[ElemTypeId].Size;
FT := SymbolTable[ElemTypeId].FinalTypeId;
SubId := 0;
case FT of
{$IFNDEF PAXARM}
typeANSISTRING,
typeWIDESTRING,
{$ENDIF}
typeUNICSTRING,
typeDYNARRAY,
typeVARIANT,
typeOLEVARIANT,
typeINTERFACE:
begin
case FT of
{$IFNDEF PAXARM}
typeANSISTRING: SubId := Id_AnsiStringAssign;
typeWIDESTRING: SubId := Id_WideStringAssign;
typeSHORTSTRING: SubId := Id_ShortStringAssign;
{$ENDIF}
typeUNICSTRING: SubId := Id_UnicStringAssign;
typeVARIANT, typeOLEVARIANT: SubId := Id_VariantAssign;
typeINTERFACE: SubId := Id_InterfaceAssign;
end;
for I:=0 to H2 - H1 do
begin
Emit_PUSH_REGS;
EmitCallPro(SubId);
Prg.AsmAddREG_Imm(Reg1, I * ElemSize);
Prg.AsmAddREG_Imm(Reg2, I * ElemSize);
Reg := GetReg;
Prg.AsmPush_REG(Reg1);
Prg.AsmPush_REG(Reg2);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
end;
typeRECORD:
begin
TypeID := SymbolTable.TerminalTypeOf(ElemTypeId);
for I:=0 to H2 - H1 do
begin
Emit_PUSH_REGS;
Prg.AsmAddREG_Imm(Reg1, I * ElemSize);
Prg.AsmAddREG_Imm(Reg2, I * ElemSize);
AssignRec(Reg1, Reg2, TypeId);
Emit_POP_REGS;
end;
end;
typeARRAY:
begin
TypeID := SymbolTable.TerminalTypeOf(ElemTypeId);
for I:=0 to H2 - H1 do
begin
Emit_PUSH_REGS;
Prg.AsmAddREG_Imm(Reg1, I * ElemSize);
Prg.AsmAddREG_Imm(Reg2, I * ElemSize);
AssignArr(Reg1, Reg2, TypeId);
Emit_POP_REGS;
end;
end;
else
begin
SubId := Id_RecordAssign;
EmitCallPro(SubId);
S := SymbolTable[TypeId].PtrSize;
Prg.AsmPush_Imm(S);
Prg.AsmPush_REG(Reg2);
Prg.AsmPush_REG(Reg1);
EmitStdCall(SubId);
end;
end; // case
end;
var
Reg1, Reg2, S, FT: Integer;
begin
EmitPCodeOperator;
SymbolTable := TKernel(kernel).SymbolTable;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadAddress(Reg1, SymbolRec1); // source
EmitLoadAddress(Reg2, SymbolRec2); // dest
FT := SymbolRec1.FinalTypeId;
case FT of
typeRECORD:
begin
AssignRec(Reg1, Reg2, SymbolRec1.TerminalTypeId);
end;
typeARRAY:
begin
AssignArr(Reg1, Reg2, SymbolRec1.TerminalTypeId);
end;
else
begin
EmitCallPro(Id_RecordAssign);
S := SymbolRec1.PtrSize;
Prg.AsmPush_Imm(S);
Prg.AsmPush_REG(Reg2);
Prg.AsmPush_REG(Reg1);
EmitStdCall(Id_RecordAssign);
end;
end;
FreeReg(Reg1);
FreeReg(Reg2);
end;
procedure TEmitter.EmitOP_ASSIGN_DOUBLE_64;
begin
EmitOP_ASSIGN_DOUBLE;
end;
procedure TEmitter.EmitOP_ASSIGN_DOUBLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFstp(SymbolRec1);
end;
procedure TEmitter.EmitOP_ASSIGN_CURRENCY_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRec1);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_ASSIGN_CURRENCY;
var
Reg, Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadAddress(Reg1, SymbolRec1);
EmitLoadAddress(Reg2, SymbolRec2);
Prg.AsmMovREG32_REGPtr(Reg, Reg2);
Prg.AsmMovREGPtr_REG32(Reg1, Reg);
Prg.AsmAddREG_Imm(Reg1, 4);
Prg.AsmAddREG_Imm(Reg2, 4);
Prg.AsmMovREG32_REGPtr(Reg, Reg2);
Prg.AsmMovREGPtr_REG32(Reg1, Reg);
FreeReg(Reg);
FreeReg(Reg1);
FreeReg(Reg2);
end;
procedure TEmitter.EmitOP_ASSIGN_SINGLE_64;
begin
EmitOP_ASSIGN_SINGLE;
end;
procedure TEmitter.EmitOP_ASSIGN_SINGLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFstp(SymbolRec1);
end;
procedure TEmitter.EmitOP_ASSIGN_EXTENDED_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRec1);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_ASSIGN_EXTENDED;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFstp(SymbolRec1);
end;
procedure TEmitter.EmitOP_ASSIGN_INT64_64;
begin
EmitOP_ASSIGN_INT64;
end;
procedure TEmitter.EmitOP_ASSIGN_INT64;
var
Reg, Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadAddress(Reg1, SymbolRec1);
EmitLoadAddress(Reg2, SymbolRec2);
Prg.AsmMovREG32_REGPtr(Reg, Reg2);
Prg.AsmMovREGPtr_REG32(Reg1, Reg);
Prg.AsmAddREG_Imm(Reg1, 4);
Prg.AsmAddREG_Imm(Reg2, 4);
Prg.AsmMovREG32_REGPtr(Reg, Reg2);
Prg.AsmMovREGPtr_REG32(Reg1, Reg);
FreeReg(Reg);
FreeReg(Reg1);
FreeReg(Reg2);
end;
procedure TEmitter.EmitFistp(S: TSymbolRec);
var
Reg: Integer;
begin
Reg := GetReg;
EmitLoadAddress(Reg, S);
Prg.AsmFistp_REG64Ptr(Reg);
FreeReg(Reg);
Prg.AsmWait;
end;
procedure TEmitter.EmitOP_CURRENCY_FROM_INT_64;
begin
EmitPCodeOperator;
EmitFild(SymbolRec2);
EmitFMul_10000;
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitOP_CURRENCY_FROM_INT;
begin
EmitPCodeOperator;
EmitFild(SymbolRec2);
EmitFMul_10000;
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitOP_CURRENCY_FROM_INT64_64;
begin
EmitPCodeOperator;
EmitFild(SymbolRec2);
EmitFMul_10000;
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitOP_CURRENCY_FROM_INT64;
begin
EmitPCodeOperator;
EmitFild(SymbolRec2);
EmitFMul_10000;
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitOP_CURRENCY_FROM_REAL_64;
begin
EmitPCodeOperator;
EmitFLD(SymbolRec2);
EmitFMul_10000;
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitOP_CURRENCY_FROM_REAL;
begin
EmitPCodeOperator;
EmitFLD(SymbolRec2);
EmitFMul_10000;
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitCheckOperResult(Reg: Integer);
var
SubId, T: Integer;
begin
if OverflowCheck = false then
Exit;
if TargetPlatform = tpWIN64 then
Exit;
if TargetPlatform in [tpOSX32, tpIOSSim] then
Exit;
T := SymbolRecR.FinalTypeId;
case T of
typeINTEGER:
begin
SubId := Id_IntOver;
GetReg(_EBX);
if TargetPlatform = tpWIN64 then
begin
Prg.AsmJNO_Imm(9);
EmitGet_REG(_EBX, SymbolTable[SubId]); // 6 bytes
Prg.AsmCall_REG(_EBX); // 3 bytes
end
else
begin
Prg.AsmJNO_Imm(8);
EmitGet_REG(_EBX, SymbolTable[SubId]); // 6 bytes
Prg.AsmCall_REG(_EBX); // 2 bytes
end;
FreeReg(_EBX);
end;
typeCARDINAL:
begin
GetReg(_EBX);
SubId := Id_IntOver;
if TargetPlatform = tpWIN64 then
begin
Prg.AsmJNC_Imm(9);
EmitGet_REG(_EBX, SymbolTable[SubId]); // 6 bytes
Prg.AsmCall_REG(_EBX); // 3 bytes
end
else
begin
Prg.AsmJNC_Imm(8);
EmitGet_REG(_EBX, SymbolTable[SubId]); // 6 bytes
Prg.AsmCall_REG(_EBX); // 2 bytes
end;
FreeReg(_EBX);
end;
typeBYTE:
begin
GetReg(_EBX);
SubId := Id_BoundError;
Prg.AsmCmpReg_Imm(Reg, $ff);
if TargetPlatform = tpWIN64 then
begin
Prg.AsmJBE_Imm(9);
EmitGet_REG(_EBX, SymbolTable[SubId]); // 6 bytes
Prg.AsmCall_REG(_EBX); // 3 bytes
end
else
begin
Prg.AsmJBE_Imm(8);
EmitGet_REG(_EBX, SymbolTable[SubId]); // 6 bytes
Prg.AsmCall_REG(_EBX); // 2 bytes
end;
FreeReg(_EBX);
end;
typeWORD:
begin
GetReg(_EBX);
SubId := Id_BoundError;
Prg.AsmCmpReg_Imm(Reg, $ffff);
if TargetPlatform = tpWIN64 then
begin
Prg.AsmJBE_Imm(9);
EmitGet_REG(_EBX, SymbolTable[SubId]); // 6 bytes
Prg.AsmCall_REG(_EBX); // 3 bytes
end
else
begin
Prg.AsmJBE_Imm(8);
EmitGet_REG(_EBX, SymbolTable[SubId]); // 6 bytes
Prg.AsmCall_REG(_EBX); // 2 bytes
end;
FreeReg(_EBX);
end;
end;
end;
procedure TEmitter.EmitOP_ADD_INT_MI_64;
begin
EmitOP_ADD_INT_MI;
end;
procedure TEmitter.EmitOP_ADD_INT_MI;
var
Reg: Integer;
begin
EmitPCodeOperator;
if (SymbolRec1 = SymbolRecR) and (SymbolRecR.Size = 4) then
begin
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmAddREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
EmitCheckOperResult(Reg);
FreeReg(Reg);
end
else
begin
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, ImmValue2);
EmitCheckOperResult(Reg);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
end;
procedure TEmitter.EmitOP_ADD_INT_MM_64;
begin
EmitOP_ADD_INT_MM;
end;
procedure TEmitter.EmitOP_ADD_INT_MM;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadIntVal(Reg1, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmAddREG_REG(Reg1, Reg2);
EmitCheckOperResult(Reg1);
FreeReg(Reg2);
EmitSaveIntVal(Reg1, SymbolRecR);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_NEG_INT_64;
begin
EmitOP_NEG_INT;
end;
procedure TEmitter.EmitOP_NEG_INT;
var
Reg: Integer;
begin
EmitPCodeOperator;
if (SymbolRec1 = SymbolRecR) and (SymbolRec1.PtrSize = SizeOfPointer) then
begin
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmNEG_REGPtr(Reg, SymbolRec1);
EmitCheckOperResult(Reg);
FreeReg(Reg);
end
else
begin
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmNEGREG(Reg);
EmitCheckOperResult(Reg);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
end;
procedure TEmitter.EmitOP_NOT_64;
begin
EmitOP_NOT;
end;
procedure TEmitter.EmitOP_NOT;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
EmitLoadIntVal(Reg1, SymbolRec1);
if SymbolRecR.FinalTypeId in BooleanTypes then
begin
Reg2 := GetReg;
Prg.AsmMovREG_Imm(Reg2, 1);
Prg.AsmXorREG_REG(Reg1, Reg2);
FreeReg(Reg2);
end
else
begin
Prg.AsmNotREG(Reg1);
end;
EmitSaveIntVal(Reg1, SymbolRecR);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_NOT_BOOL;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
EmitLoadIntVal(Reg1, SymbolRec1);
Reg2 := GetReg;
Prg.AsmMovREG_Imm(Reg2, 1);
Prg.AsmXorREG_REG(Reg1, Reg2);
FreeReg(Reg2);
EmitSaveIntVal(Reg1, SymbolRecR);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_NOT_BOOL64;
begin
EmitOP_NOT_BOOL;
end;
procedure TEmitter.EmitOP_NOT_BYTEBOOL;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmCmpReg_Imm(Reg, 0);
Prg.AsmJZ_Imm(7);
Prg.AsmXorREG_REG(Reg, Reg); //2
Prg.AsmJMP_Imm(5); //5
Prg.AsmMovREG_Imm(Reg, $ff); //5
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_NOT_BYTEBOOL64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmCmpReg_Imm(Reg, 0);
Prg.AsmJZ_Imm(8);
Prg.AsmXorREG_REG(Reg, Reg); //3
Prg.AsmJMP_Imm(10); //5
Prg.AsmMovREG_Imm(Reg, $ff); //10
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_NOT_WORDBOOL;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmCmpReg_Imm(Reg, 0);
Prg.AsmJZ_Imm(7);
Prg.AsmXorREG_REG(Reg, Reg); //2
Prg.AsmJMP_Imm(5); //5
Prg.AsmMovREG_Imm(Reg, $ffff); //5
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_NOT_WORDBOOL64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmCmpReg_Imm(Reg, 0);
Prg.AsmJZ_Imm(8);
Prg.AsmXorREG_REG(Reg, Reg); //3
Prg.AsmJMP_Imm(10); //5
Prg.AsmMovREG_Imm(Reg, $ffff); //10
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_NOT_LONGBOOL;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmCmpReg_Imm(Reg, 0);
Prg.AsmJZ_Imm(7);
Prg.AsmXorREG_REG(Reg, Reg); //2
Prg.AsmJMP_Imm(5); //5
Prg.AsmMovREG_Imm(Reg, $ffffffff); //5
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_NOT_LONGBOOL64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmCmpReg_Imm(Reg, 0);
Prg.AsmJZ_Imm(8);
Prg.AsmXorREG_REG(Reg, Reg); //3
Prg.AsmJMP_Imm(10); //5
Prg.AsmMovREG_Imm(Reg, $ffffffff); //10
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_SUB_INT_MI_64;
begin
EmitOP_SUB_INT_MI;
end;
procedure TEmitter.EmitOP_SUB_INT_MI;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmSubREG_Imm(Reg, ImmValue2);
EmitCheckOperResult(Reg);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_SUB_INT_MM_64;
begin
EmitOP_SUB_INT_MM;
end;
procedure TEmitter.EmitOP_SUB_INT_MM;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadIntVal(Reg1, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmSubREG_REG(Reg1, Reg2);
EmitCheckOperResult(Reg1);
FreeReg(Reg2);
EmitSaveIntVal(Reg1, SymbolRecR);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_IMUL_INT_MI_64;
begin
EmitOP_IMUL_INT_MI;
end;
procedure TEmitter.EmitOP_IMUL_INT_MI;
var
Reg2: Integer;
begin
EmitPCodeOperator;
GetReg(_EAX);
Reg2 := GetReg;
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmMovREG_Imm(Reg2, SymbolRec2.Value);
Prg.AsmIMulREG(Reg2);
EmitCheckOperResult(_EAX);
FreeReg(Reg2);
EmitSaveIntVal(_EAX, SymbolRecR);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_IMUL_INT_MM_64;
begin
EmitOP_IMUL_INT_MM;
end;
procedure TEmitter.EmitOP_IMUL_INT_MM;
var
Reg2: Integer;
begin
EmitPCodeOperator;
GetReg(_EAX);
Reg2 := GetReg;
EmitLoadIntVal(_EAX, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmIMulREG(Reg2);
EmitCheckOperResult(_EAX);
FreeReg(Reg2);
EmitSaveIntVal(_EAX, SymbolRecR);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_IDIV_INT_MI_64;
begin
EmitOP_IDIV_INT_MI;
end;
procedure TEmitter.EmitOP_IDIV_INT_MI;
begin
EmitPCodeOperator;
GetReg(_EAX);
GetReg(_ECX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmMovREG_Imm(_ECX, SymbolRec2.Value);
if SymbolRec1.FinalTypeId in UnsignedIntegerTypes then
begin
Prg.AsmXORReg_Reg(_EDX, _EDX);
Prg.AsmDivREG(_ECX);
end
else
begin
Prg.AsmCDQ;
Prg.AsmIDivREG(_ECX);
end;
FreeReg(_ECX);
EmitSaveIntVal(_EAX, SymbolRecR);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_IDIV_INT_MM_64;
begin
EmitOP_IDIV_INT_MM;
end;
procedure TEmitter.EmitOP_IDIV_INT_MM;
begin
EmitPCodeOperator;
GetReg(_EAX);
GetReg(_ECX);
EmitLoadIntVal(_EAX, SymbolRec1);
EmitLoadIntVal(_ECX, SymbolRec2);
if (SymbolRec1.FinalTypeId in UnsignedIntegerTypes) and
(SymbolRec2.FinalTypeId in UnsignedIntegerTypes) then
begin
Prg.AsmXORReg_Reg(_EDX, _EDX);
Prg.AsmDivREG(_ECX);
end
else
begin
Prg.AsmCDQ;
Prg.AsmIDivREG(_ECX);
end;
FreeReg(_ECX);
EmitSaveIntVal(_EAX, SymbolRecR);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_IDIV_INT_IM_64;
begin
EmitOP_IDIV_INT_IM;
end;
procedure TEmitter.EmitOP_IDIV_INT_IM;
begin
EmitPCodeOperator;
GetReg(_EAX);
GetReg(_ECX);
Prg.AsmMovREG_Imm(_EAX, SymbolRec1.Value);
EmitLoadIntVal(_ECX, SymbolRec2);
if SymbolRec2.FinalTypeId in UnsignedIntegerTypes then
begin
Prg.AsmXORReg_Reg(_EDX, _EDX);
Prg.AsmDivREG(_ECX);
end
else
begin
Prg.AsmCDQ;
Prg.AsmIDivREG(_ECX);
end;
FreeReg(_ECX);
EmitSaveIntVal(_EAX, SymbolRecR);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_MOD_INT_MI_64;
begin
EmitOP_MOD_INT_MI;
end;
procedure TEmitter.EmitOP_MOD_INT_MI;
begin
EmitPCodeOperator;
GetReg(_EAX);
GetReg(_EDX);
GetReg(_ECX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmMovREG_Imm(_ECX, SymbolRec2.Value);
if SymbolRec1.FinalTypeId in UnsignedIntegerTypes then
begin
Prg.AsmXORReg_Reg(_EDX, _EDX);
Prg.AsmDivREG(_ECX);
end
else
begin
Prg.AsmCDQ;
Prg.AsmIDivREG(_ECX);
end;
FreeReg(_ECX);
FreeReg(_EAX);
EmitSaveIntVal(_EDX, SymbolRecR);
FreeReg(_EDX);
end;
procedure TEmitter.EmitOP_MOD_INT_MM_64;
begin
EmitOP_MOD_INT_MM;
end;
procedure TEmitter.EmitOP_MOD_INT_MM;
begin
EmitPCodeOperator;
GetReg(_EAX);
GetReg(_EDX);
GetReg(_ECX);
EmitLoadIntVal(_EAX, SymbolRec1);
EmitLoadIntVal(_ECX, SymbolRec2);
if (SymbolRec1.FinalTypeId in UnsignedIntegerTypes) and
(SymbolRec2.FinalTypeId in UnsignedIntegerTypes) then
begin
Prg.AsmXORReg_Reg(_EDX, _EDX);
Prg.AsmDivREG(_ECX);
end
else
begin
Prg.AsmCDQ;
Prg.AsmIDivREG(_ECX);
end;
FreeReg(_ECX);
EmitSaveIntVal(_EDX, SymbolRecR);
FreeReg(_EDX);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_MOD_INT_IM_64;
begin
EmitOP_MOD_INT_IM;
end;
procedure TEmitter.EmitOP_MOD_INT_IM;
begin
EmitPCodeOperator;
GetReg(_EAX);
GetReg(_EDX);
GetReg(_ECX);
Prg.AsmMovREG_Imm(_EAX, SymbolRec1.Value);
EmitLoadIntVal(_ECX, SymbolRec2);
if SymbolRec1.FinalTypeId in UnsignedIntegerTypes then
begin
Prg.AsmXORReg_Reg(_EDX, _EDX);
Prg.AsmDivREG(_ECX);
end
else
begin
Prg.AsmCDQ;
Prg.AsmIDivREG(_ECX);
end;
FreeReg(_ECX);
EmitSaveIntVal(_EDX, SymbolRecR);
FreeReg(_EDX);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_SHL_INT_MI_64;
begin
EmitOP_SHL_INT_MI;
end;
procedure TEmitter.EmitOP_SHL_INT_MI;
var
Reg: Integer;
begin
EmitPCodeOperator;
GetReg(_ECX);
Reg := GetReg;
Prg.AsmXorREG_REG(Reg, Reg);
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmMovREG_Imm(_ECX, SymbolRec2.Value);
Prg.AsmShlREG(Reg);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SHL_INT_MM_64;
begin
EmitOP_SHL_INT_MM;
end;
procedure TEmitter.EmitOP_SHL_INT_MM;
var
Reg: Integer;
begin
EmitPCodeOperator;
GetReg(_ECX);
Reg := GetReg;
Prg.AsmXorREG_REG(Reg, Reg);
EmitLoadIntVal(Reg, SymbolRec1);
EmitLoadIntVal(_ECX, SymbolRec2);
Prg.AsmShlREG(Reg);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SHL_INT_IM_64;
begin
EmitOP_SHL_INT_IM;
end;
procedure TEmitter.EmitOP_SHL_INT_IM;
var
Reg: Integer;
begin
EmitPCodeOperator;
GetReg(_ECX);
Reg := GetReg;
Prg.AsmMovREG_Imm(Reg, SymbolRec1.Value);
EmitLoadIntVal(_ECX, SymbolRec2);
Prg.AsmShlREG(Reg);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SHR_INT_MI_64;
begin
EmitOP_SHR_INT_MI;
end;
procedure TEmitter.EmitOP_SHR_INT_MI;
var
Reg: Integer;
begin
EmitPCodeOperator;
GetReg(_ECX);
Reg := GetReg;
Prg.AsmXorREG_REG(Reg, Reg);
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmMovREG_Imm(_ECX, SymbolRec2.Value);
Prg.AsmShrREG(Reg);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SHR_INT_MM_64;
begin
EmitOP_SHR_INT_MM;
end;
procedure TEmitter.EmitOP_SHR_INT_MM;
var
Reg: Integer;
begin
EmitPCodeOperator;
GetReg(_ECX);
Reg := GetReg;
Prg.AsmXorREG_REG(Reg, Reg);
EmitLoadIntVal(Reg, SymbolRec1);
EmitLoadIntVal(_ECX, SymbolRec2);
Prg.AsmShrREG(Reg);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SHR_INT_IM_64;
begin
EmitOP_SHR_INT_IM;
end;
procedure TEmitter.EmitOP_SHR_INT_IM;
var
Reg: Integer;
begin
EmitPCodeOperator;
GetReg(_ECX);
Reg := GetReg;
Prg.AsmMovREG_Imm(Reg, SymbolRec1.Value);
EmitLoadIntVal(_ECX, SymbolRec2);
Prg.AsmShrREG(Reg);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_AND_INT_MI_64;
begin
EmitOP_AND_INT_MI;
end;
procedure TEmitter.EmitOP_AND_INT_MI;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadIntVal(Reg1, SymbolRec1);
Prg.AsmMovREG_Imm(Reg2, SymbolRec2.Value);
Prg.AsmAndREG_REG(Reg1, Reg2);
EmitSaveIntVal(Reg1, SymbolRecR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_AND_INT_MM_64;
begin
EmitOP_AND_INT_MM;
end;
procedure TEmitter.EmitOP_AND_INT_MM;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadIntVal(Reg1, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmAndREG_REG(Reg1, Reg2);
EmitSaveIntVal(Reg1, SymbolRecR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_OR_INT_MI_64;
begin
EmitOP_OR_INT_MI;
end;
procedure TEmitter.EmitOP_OR_INT_MI;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadIntVal(Reg1, SymbolRec1);
Prg.AsmMovREG_Imm(Reg2, SymbolRec2.Value);
Prg.AsmOrREG_REG(Reg1, Reg2);
EmitSaveIntVal(Reg1, SymbolRecR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_OR_INT_MM_64;
begin
EmitOP_OR_INT_MM;
end;
procedure TEmitter.EmitOP_OR_INT_MM;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadIntVal(Reg1, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmOrREG_REG(Reg1, Reg2);
EmitSaveIntVal(Reg1, SymbolRecR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_XOR_INT_MI_64;
begin
EmitOP_XOR_INT_MI;
end;
procedure TEmitter.EmitOP_XOR_INT_MI;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadIntVal(Reg1, SymbolRec1);
Prg.AsmMovREG_Imm(Reg2, SymbolRec2.Value);
Prg.AsmXorREG_REG(Reg1, Reg2);
EmitSaveIntVal(Reg1, SymbolRecR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_XOR_INT_MM_64;
begin
EmitOP_XOR_INT_MM;
end;
procedure TEmitter.EmitOP_XOR_INT_MM;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
EmitLoadIntVal(Reg1, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmXorREG_REG(Reg1, Reg2);
EmitSaveIntVal(Reg1, SymbolRecR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_ADD_INT64_64;
begin
EmitOP_ADD_INT64;
end;
procedure TEmitter.EmitOP_ADD_INT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
GetReg(_EAX);
GetReg(_EDX);
Prg.AsmClc;
// EAX:EDX <-- [N1]
EmitLoadAddress(_ECX, SymbolRec1);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
// ADD EAX, [N2]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmAddREG_REG(_EAX, _ECX);
Prg.AsmPushfd;
// ADC EDX, [N2 + 4]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmPopfd;
Prg.AsmAdcREG_REG(_EDX, _ECX);
// EAX:EDX --> [N2]
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_ADD_UINT64_64;
begin
EmitOP_ADD_UINT64;
end;
procedure TEmitter.EmitOP_ADD_UINT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
GetReg(_EAX);
GetReg(_EDX);
Prg.AsmClc;
// EAX:EDX <-- [N1]
EmitLoadAddress(_ECX, SymbolRec1);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
// ADD EAX, [N2]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmAddREG_REG(_EAX, _ECX);
Prg.AsmPushfd;
// ADC EDX, [N2 + 4]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmPopfd;
Prg.AsmAdcREG_REG(_EDX, _ECX);
// EAX:EDX --> [N2]
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_NEG_INT64_64;
begin
EmitOP_NEG_INT64;
end;
procedure TEmitter.EmitOP_NEG_INT64;
begin
EmitPCodeOperator;
GetReg(_EAX);
GetReg(_EDX);
GetReg(_ECX);
Prg.AsmClc;
// EAX:EDX <-- [N1]
EmitLoadAddress(_ECX, SymbolRec1);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
Prg.AsmXorREG_REG(_ECX, _ECX);
Prg.AsmNegREG(_EAX);
Prg.AsmXCHG(_EDX, _ECX);
Prg.AsmSbbREG_REG(_EDX, _ECX);
// EAX:EDX --> [N2]
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SUB_INT64_64;
begin
EmitOP_SUB_INT64;
end;
procedure TEmitter.EmitOP_SUB_INT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
GetReg(_EAX);
GetReg(_EDX);
// EAX:EDX <-- [N1]
EmitLoadAddress(_ECX, SymbolRec1);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
// SUB EAX, [N2]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmSubREG_REG(_EAX, _ECX);
Prg.AsmPushfd;
// SBB EDX, [N2 + 4]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmPopfd;
Prg.AsmSbbREG_REG(_EDX, _ECX);
// EAX:EDX --> [N2]
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SUB_UINT64_64;
begin
EmitOP_SUB_INT64;
end;
procedure TEmitter.EmitOP_SUB_UINT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
GetReg(_EAX);
GetReg(_EDX);
// EAX:EDX <-- [N1]
EmitLoadAddress(_ECX, SymbolRec1);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
// SUB EAX, [N2]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmSubREG_REG(_EAX, _ECX);
Prg.AsmPushfd;
// SBB EDX, [N2 + 4]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmPopfd;
Prg.AsmSbbREG_REG(_EDX, _ECX);
// EAX:EDX --> [N2]
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_AND_INT64_64;
begin
EmitOP_AND_INT64;
end;
procedure TEmitter.EmitOP_AND_INT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
GetReg(_EAX);
GetReg(_EDX);
// EAX:EDX <-- [N1]
EmitLoadAddress(_ECX, SymbolRec1);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
// AND EAX, [N2]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmAndREG_REG(_EAX, _ECX);
// AND EDX, [N2 + 4]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmAndREG_REG(_EDX, _ECX);
// EAX:EDX --> [N2]
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_AND_UINT64_64;
begin
EmitOP_AND_INT64;
end;
procedure TEmitter.EmitOP_AND_UINT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
GetReg(_EAX);
GetReg(_EDX);
// EAX:EDX <-- [N1]
EmitLoadAddress(_ECX, SymbolRec1);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
// AND EAX, [N2]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmAndREG_REG(_EAX, _ECX);
// AND EDX, [N2 + 4]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmAndREG_REG(_EDX, _ECX);
// EAX:EDX --> [N2]
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_OR_INT64_64;
begin
EmitOP_OR_INT64;
end;
procedure TEmitter.EmitOP_OR_INT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
GetReg(_EAX);
GetReg(_EDX);
// EAX:EDX <-- [N1]
EmitLoadAddress(_ECX, SymbolRec1);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
// OR EAX, [N2]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmOrREG_REG(_EAX, _ECX);
// OR EDX, [N2 + 4]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmOrREG_REG(_EDX, _ECX);
// EAX:EDX --> [N2]
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_OR_UINT64_64;
begin
EmitOP_OR_UINT64;
end;
procedure TEmitter.EmitOP_OR_UINT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
GetReg(_EAX);
GetReg(_EDX);
// EAX:EDX <-- [N1]
EmitLoadAddress(_ECX, SymbolRec1);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
// OR EAX, [N2]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmOrREG_REG(_EAX, _ECX);
// OR EDX, [N2 + 4]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmOrREG_REG(_EDX, _ECX);
// EAX:EDX --> [N2]
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_XOR_INT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
GetReg(_EAX);
GetReg(_EDX);
// EAX:EDX <-- [N1]
EmitLoadAddress(_ECX, SymbolRec1);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
// XOR EAX, [N2]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmXorREG_REG(_EAX, _ECX);
// XOR EDX, [N2 + 4]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmXorREG_REG(_EDX, _ECX);
// EAX:EDX --> [N2]
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_XOR_UINT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
GetReg(_EAX);
GetReg(_EDX);
// EAX:EDX <-- [N1]
EmitLoadAddress(_ECX, SymbolRec1);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
// XOR EAX, [N2]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmXorREG_REG(_EAX, _ECX);
// XOR EDX, [N2 + 4]
EmitLoadAddress(_ECX, SymbolRec2);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_ECX, _ECX);
Prg.AsmXorREG_REG(_EDX, _ECX);
// EAX:EDX --> [N2]
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitStdCall_Adr1(SubId: Integer);
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitCallPro(SubId);
if TargetPlatform = tpWIN64 then
begin
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string source
Prg.AsmMovREG_REG(_ECX, Reg);
end
else
begin
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1); // string source
Prg.AsmPush_REG(Reg);
end;
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitStdCall_Adr1_AdrR(SubId: Integer);
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitCallPro(SubId);
if TargetPlatform = tpWIN64 then
begin
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end
else
begin
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // dest
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
end;
procedure TEmitter.EmitStdCall_Adr1_from_Int2(SubId: Integer);
var
Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
if TargetPlatform = tpWIN64 then
begin
Reg := GetRegEx;
EmitLoadIntVal(Reg, SymbolRec2); // source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // dest
Prg.AsmMovREG_REG(_EDX, Reg);
end
else
begin
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // dest
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec2); // source
Prg.AsmPush_REG(Reg);
end;
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitStdCall_Adr1_from_Adr2(SubId: Integer);
var
Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
if TargetPlatform = tpWIN64 then
begin
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // dest
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmMovREG_REG(_EDX, Reg);
end
else
begin
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // dest
Prg.AsmPush_REG(Reg);
end;
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitStdCall_AdrR_from_Adr2(SubId: Integer);
var
Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
if TargetPlatform = tpWIN64 then
begin
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRecR); // dest
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmMovREG_REG(_EDX, Reg);
end
else
begin
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRecR); // dest
Prg.AsmPush_REG(Reg);
end;
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitStdCall_Adr1_Adr2_AdrR(SubId: Integer);
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitCallPro(SubId);
if TargetPlatform = tpWIN64 then
begin
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // 2 - par
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end
else
begin
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec2); // 2 - par
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
end;
procedure TEmitter.EmitStdCall_Lang_Adr1_Adr2_AdrR(SubId: Integer);
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitCallPro(SubId);
if TargetPlatform = tpWIN64 then
begin
Reg := GetRegEx;
Prg.AsmMovREG_Imm(Reg, Language); // lang
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // par 1
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // par 2
Prg.AsmMovREG_REG(_R8, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end
else
begin
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec2); // 2 - par
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(Language); // lang
FreeReg(Reg);
EmitStdCall(SubId);
end;
end;
procedure TEmitter.EmitOP_GT_INT64_64;
begin
EmitOP_GT_INT64;
end;
procedure TEmitter.EmitOP_GT_INT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64GreaterThan);
end;
procedure TEmitter.EmitOP_GE_INT64_64;
begin
EmitOP_GE_INT64;
end;
procedure TEmitter.EmitOP_GE_INT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64GreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_LT_INT64_64;
begin
EmitOP_LT_INT64;
end;
procedure TEmitter.EmitOP_LT_INT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64LessThan);
end;
procedure TEmitter.EmitOP_LE_INT64_64;
begin
EmitOP_LE_INT64;
end;
procedure TEmitter.EmitOP_LE_INT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64LessThanOrEqual);
end;
procedure TEmitter.EmitOP_EQ_INT64_64;
begin
EmitOP_EQ_INT64;
end;
procedure TEmitter.EmitOP_EQ_INT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64Equality);
end;
procedure TEmitter.EmitOP_NE_INT64_64;
begin
EmitOP_NE_INT64;
end;
procedure TEmitter.EmitOP_NE_INT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64NotEquality);
end;
procedure TEmitter.EmitOP_GT_UINT64_64;
begin
EmitOP_GT_UINT64;
end;
procedure TEmitter.EmitOP_GT_UINT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UInt64GreaterThan);
end;
procedure TEmitter.EmitOP_GE_UINT64_64;
begin
EmitOP_GE_UINT64;
end;
procedure TEmitter.EmitOP_GE_UINT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UInt64GreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_LT_UINT64_64;
begin
EmitOP_LT_UINT64;
end;
procedure TEmitter.EmitOP_LT_UINT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UInt64LessThan);
end;
procedure TEmitter.EmitOP_LE_UINT64_64;
begin
EmitOP_LE_UINT64;
end;
procedure TEmitter.EmitOP_LE_UINT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UInt64LessThanOrEqual);
end;
procedure TEmitter.EmitOP_ADD_CURRENCY_64;
begin
EmitOP_ADD_CURRENCY;
end;
procedure TEmitter.EmitOP_ADD_CURRENCY;
begin
EmitPCodeOperator;
if R.Arg1 <> 0 then
begin
if SymbolRec1.FinalTypeId <> typeCURRENCY then
begin
if SymbolRec1.FinalTypeId in IntegerTypes then
EmitFild(SymbolRec1)
else if SymbolRec1.FinalTypeId in RealTypes then
EmitFld(SymbolRec1)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(SymbolRec1);
end;
EmitFild(SymbolRec2);
Prg.AsmFAdd;
if R.Res <> 0 then
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitOP_SUB_CURRENCY_64;
begin
EmitOP_SUB_CURRENCY;
end;
procedure TEmitter.EmitOP_SUB_CURRENCY;
begin
EmitPCodeOperator;
if R.Arg1 <> 0 then
begin
if SymbolRec1.FinalTypeId <> typeCURRENCY then
begin
if SymbolRec1.FinalTypeId in IntegerTypes then
EmitFild(SymbolRec1)
else if SymbolRec1.FinalTypeId in RealTypes then
EmitFld(SymbolRec1)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
if TKernel(kernel).Code[TKernel(kernel).Code.N].SwappedArgs then
begin
Prg.AsmFChs;
EmitFild(SymbolRec2);
Prg.AsmFAdd;
EmitFistp(SymbolRecR);
Exit;
end;
end
else
EmitFild(SymbolRec1);
end;
EmitFild(SymbolRec2);
Prg.AsmFSub;
if R.Res <> 0 then
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitOP_MUL_CURRENCY_64;
begin
EmitOP_MUL_CURRENCY;
end;
procedure TEmitter.EmitOP_MUL_CURRENCY;
begin
EmitPCodeOperator;
if R.Arg1 <> 0 then
begin
if SymbolRec1.FinalTypeId <> typeCURRENCY then
begin
if SymbolRec1.FinalTypeId in IntegerTypes then
EmitFild(SymbolRec1)
else if SymbolRec1.FinalTypeId in RealTypes then
EmitFld(SymbolRec1)
else
RaiseError(errInternalError, []);
EmitFild(SymbolRec2);
Prg.AsmFMul;
EmitFistp(SymbolRecR);
Exit;
end
else
EmitFild(SymbolRec1);
end;
EmitFild(SymbolRec2);
Prg.AsmFMul;
EmitFDiv_10000;
if R.Res <> 0 then
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitOP_DIV_CURRENCY_64;
begin
EmitOP_DIV_CURRENCY;
end;
procedure TEmitter.EmitOP_DIV_CURRENCY;
begin
EmitPCodeOperator;
if R.Arg1 <> 0 then
begin
if SymbolRec1.FinalTypeId <> typeCURRENCY then
begin
if SymbolRec1.FinalTypeId in IntegerTypes then
EmitFild(SymbolRec1)
else if SymbolRec1.FinalTypeId in RealTypes then
EmitFld(SymbolRec1)
else
RaiseError(errInternalError, []);
EmitFild(SymbolRec2);
Prg.AsmFDiv;
EmitFMul_10000;
EmitFMul_10000;
EmitFistp(SymbolRecR);
Exit;
end
else
begin
EmitFild(SymbolRec1);
if SymbolRec2.FinalTypeId <> typeCURRENCY then
begin
if SymbolRec2.FinalTypeId in IntegerTypes then
EmitFild(SymbolRec2)
else if SymbolRec2.FinalTypeId in RealTypes then
EmitFld(SymbolRec2)
else
RaiseError(errInternalError, []);
Prg.AsmFDiv;
EmitFistp(SymbolRecR);
Exit;
end;
end;
end;
// both operands are currency
EmitFild(SymbolRec2);
Prg.AsmFDiv;
EmitFMul_10000;
if R.Res <> 0 then
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitOP_ADD_DOUBLE_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_DoubleAddition);
end;
procedure TEmitter.EmitOP_ADD_DOUBLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFAdd;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_ADD_SINGLE_64;
begin
EmitOP_ADD_SINGLE;
end;
procedure TEmitter.EmitOP_ADD_SINGLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFAdd;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_ADD_EXTENDED_64;
begin
EmitOP_ADD_DOUBLE_64;
end;
procedure TEmitter.EmitOP_ADD_EXTENDED;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFAdd;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_ABS_INT_64;
begin
EmitOP_ABS_INT;
end;
procedure TEmitter.EmitOP_ABS_INT;
begin
EmitPCodeOperator;
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmCDQ;
Prg.AsmXorREG_REG(_EAX, _EDX);
Prg.AsmSubREG_REG(_EAX, _EDX);
EmitSaveIntVal(_EAX, SymbolRecR);
FreeReg(_EAX);
FreeReg(_EDX);
end;
procedure TEmitter.EmitOP_ABS_DOUBLE_64;
begin
EmitOP_ABS_DOUBLE;
end;
procedure TEmitter.EmitOP_ABS_DOUBLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
Prg.AsmFAbs;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_ABS_SINGLE_64;
begin
EmitOP_ABS_SINGLE;
end;
procedure TEmitter.EmitOP_ABS_SINGLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
Prg.AsmFAbs;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_ABS_EXTENDED_64;
begin
EmitOP_ABS_EXTENDED;
end;
procedure TEmitter.EmitOP_ABS_EXTENDED;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
Prg.AsmFAbs;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_ABS_CURRENCY_64;
begin
EmitOP_ABS_CURRENCY;
end;
procedure TEmitter.EmitOP_ABS_CURRENCY;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
EmitFDiv_10000;
Prg.AsmFAbs;
EmitFMul_10000;
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitOP_NEG_DOUBLE_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_DoubleNegation;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_NEG_DOUBLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
Prg.AsmFChs;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_NEG_CURRENCY_64;
begin
EmitOP_NEG_CURRENCY;
end;
procedure TEmitter.EmitOP_NEG_CURRENCY;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFild_REG64Ptr(Reg);
Prg.AsmFChs;
FreeReg(Reg);
EmitFistp(SymbolRecR);
end;
procedure TEmitter.EmitOP_NEG_SINGLE_64;
begin
EmitOP_NEG_SINGLE;
end;
procedure TEmitter.EmitOP_NEG_SINGLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
Prg.AsmFChs;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_NEG_EXTENDED_64;
begin
EmitOP_NEG_DOUBLE_64;
end;
procedure TEmitter.EmitOP_NEG_EXTENDED;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
Prg.AsmFChs;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_SUB_DOUBLE_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_DoubleSubtraction);
end;
procedure TEmitter.EmitOP_SUB_DOUBLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFSub;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_SUB_SINGLE_64;
begin
EmitOP_SUB_SINGLE;
end;
procedure TEmitter.EmitOP_SUB_SINGLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFSub;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_SUB_EXTENDED_64;
begin
EmitOP_SUB_DOUBLE_64;
end;
procedure TEmitter.EmitOP_SUB_EXTENDED;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFSub;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_MUL_DOUBLE_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_DoubleMultiplication);
end;
procedure TEmitter.EmitOP_MUL_DOUBLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFMul;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_MUL_SINGLE_64;
begin
EmitOP_MUL_SINGLE;
end;
procedure TEmitter.EmitOP_MUL_SINGLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFMul;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_MUL_EXTENDED_64;
begin
EmitOP_MUL_DOUBLE_64;
end;
procedure TEmitter.EmitOP_MUL_EXTENDED;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFMul;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_DIV_DOUBLE_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_DoubleMultiplication);
end;
procedure TEmitter.EmitOP_DIV_DOUBLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFDiv;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_DIV_SINGLE_64;
begin
EmitOP_DIV_SINGLE;
end;
procedure TEmitter.EmitOP_DIV_SINGLE;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFDiv;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_DIV_EXTENDED_64;
begin
EmitOP_DIV_DOUBLE_64;
end;
procedure TEmitter.EmitOP_DIV_EXTENDED;
begin
EmitPCodeOperator;
EmitFld(SymbolRec1);
EmitFld(SymbolRec2);
Prg.AsmFDiv;
EmitFStp(SymbolRecR);
end;
procedure TEmitter.EmitOP_LT_INT_MI_64;
begin
EmitOP_LT_INT_MI;
end;
procedure TEmitter.EmitOP_LT_INT_MI;
var
Reg, RegR: Integer;
begin
EmitPCodeOperator;
if HasTheSameAddressRegister(SymbolRec1, SymbolRecR) then
begin
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
if SymbolRec1.FinalTypeId in UnsignedIntegerTypes then
Prg.AsmSet_REGPtr(ASM_SETB, Reg, SymbolRecR)
else
Prg.AsmSet_REGPtr(ASM_SETL, Reg, SymbolRecR);
FreeReg(Reg);
end
else
begin
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
if SymbolRec1.FinalTypeId in UnsignedIntegerTypes then
Prg.AsmSetB_REGPtr(RegR)
else
Prg.AsmSetL_REGPtr(RegR);
FreeReg(Reg);
FreeReg(RegR);
end;
end;
procedure TEmitter.EmitOP_LT_INT_MM_64;
begin
EmitOP_LT_INT_MM;
end;
procedure TEmitter.EmitOP_LT_INT_MM;
var
Reg1, Reg2, RegR: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
EmitLoadIntVal(Reg1, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmCmpREG_REG(Reg1, Reg2);
if (SymbolRec1.FinalTypeId in UnsignedIntegerTypes) and
(SymbolRec2.FinalTypeId in UnsignedIntegerTypes) then
Prg.AsmSetB_REGPtr(RegR)
else
Prg.AsmSetL_REGPtr(RegR);
FreeReg(RegR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_LE_INT_MI_64;
begin
EmitOP_LE_INT_MI;
end;
procedure TEmitter.EmitOP_LE_INT_MI;
var
Reg, RegR: Integer;
begin
EmitPCodeOperator;
if HasTheSameAddressRegister(SymbolRec1, SymbolRecR) then
begin
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
if SymbolRec1.FinalTypeId in UnsignedIntegerTypes then
Prg.AsmSet_REGPtr(ASM_SETBE, Reg, SymbolRecR)
else
Prg.AsmSet_REGPtr(ASM_SETLE, Reg, SymbolRecR);
FreeReg(Reg);
end
else
begin
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
if SymbolRec1.FinalTypeId in UnsignedIntegerTypes then
Prg.AsmSetBE_REGPtr(RegR)
else
Prg.AsmSetLE_REGPtr(RegR);
FreeReg(Reg);
FreeReg(RegR);
end;
end;
procedure TEmitter.EmitOP_LE_INT_MM_64;
begin
EmitOP_LE_INT_MM;
end;
procedure TEmitter.EmitOP_LE_INT_MM;
var
Reg1, Reg2, RegR: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
EmitLoadIntVal(Reg1, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmCmpREG_REG(Reg1, Reg2);
if (SymbolRec1.FinalTypeId in UnsignedIntegerTypes) and
(SymbolRec2.FinalTypeId in UnsignedIntegerTypes) then
Prg.AsmSetBE_REGPtr(RegR)
else
Prg.AsmSetLE_REGPtr(RegR);
FreeReg(RegR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_GT_INT_MI_64;
begin
EmitOP_GT_INT_MI;
end;
procedure TEmitter.EmitOP_GT_INT_MI;
var
Reg, RegR: Integer;
begin
EmitPCodeOperator;
if HasTheSameAddressRegister(SymbolRec1, SymbolRecR) then
begin
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
if SymbolRec1.FinalTypeId in UnsignedIntegerTypes then
Prg.AsmSet_REGPtr(ASM_SETNBE, Reg, SymbolRecR)
else
Prg.AsmSet_REGPtr(ASM_SETNLE, Reg, SymbolRecR);
FreeReg(Reg);
end
else
begin
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
if SymbolRec1.FinalTypeId in UnsignedIntegerTypes then
Prg.AsmSetNBE_REGPtr(RegR)
else
Prg.AsmSetNLE_REGPtr(RegR);
FreeReg(Reg);
FreeReg(RegR);
end;
end;
procedure TEmitter.EmitOP_GT_INT_MM_64;
begin
EmitOP_GT_INT_MM;
end;
procedure TEmitter.EmitOP_GT_INT_MM;
var
Reg1, Reg2, RegR: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
EmitLoadIntVal(Reg1, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmCmpREG_REG(Reg1, Reg2);
if (SymbolRec1.FinalTypeId in UnsignedIntegerTypes) and
(SymbolRec2.FinalTypeId in UnsignedIntegerTypes) then
Prg.AsmSetNBE_REGPtr(RegR)
else
Prg.AsmSetNLE_REGPtr(RegR);
FreeReg(RegR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_GE_INT_MI_64;
begin
EmitOP_GE_INT_MI;
end;
procedure TEmitter.EmitOP_GE_INT_MI;
var
Reg, RegR: Integer;
begin
EmitPCodeOperator;
if HasTheSameAddressRegister(SymbolRec1, SymbolRecR) then
begin
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
if SymbolRec1.FinalTypeId in UnsignedIntegerTypes then
Prg.AsmSet_REGPtr(ASM_SETNB, Reg, SymbolRecR)
else
Prg.AsmSet_REGPtr(ASM_SETNL, Reg, SymbolRecR);
FreeReg(Reg);
end
else
begin
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
if SymbolRec1.FinalTypeId in UnsignedIntegerTypes then
Prg.AsmSetNB_REGPtr(RegR)
else
Prg.AsmSetNL_REGPtr(RegR);
FreeReg(Reg);
FreeReg(RegR);
end;
end;
procedure TEmitter.EmitOP_GE_INT_MM_64;
begin
EmitOP_GE_INT_MM;
end;
procedure TEmitter.EmitOP_GE_INT_MM;
var
Reg1, Reg2, RegR: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
EmitLoadIntVal(Reg1, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmCmpREG_REG(Reg1, Reg2);
if (SymbolRec1.FinalTypeId in UnsignedIntegerTypes) and
(SymbolRec2.FinalTypeId in UnsignedIntegerTypes) then
Prg.AsmSetNB_REGPtr(RegR)
else
Prg.AsmSetNL_REGPtr(RegR);
FreeReg(RegR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_EQ_INT_MI_64;
begin
EmitOP_EQ_INT_MI;
end;
procedure TEmitter.EmitOP_EQ_INT_MI;
var
Reg, RegR: Integer;
begin
EmitPCodeOperator;
if HasTheSameAddressRegister(SymbolRec1, SymbolRecR) then
begin
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
Prg.AsmSet_REGPtr(ASM_SETZ, Reg, SymbolRecR);
FreeReg(Reg);
end
else
begin
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
Prg.AsmSetZ_REGPtr(RegR);
FreeReg(Reg);
FreeReg(RegR);
end;
end;
procedure TEmitter.EmitOP_EQ_INT_MM_64;
begin
EmitOP_EQ_INT_MM;
end;
procedure TEmitter.EmitOP_EQ_INT_MM;
var
Reg1, Reg2, RegR: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
EmitLoadIntVal(Reg1, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmCmpREG_REG(Reg1, Reg2);
Prg.AsmSetZ_REGPtr(RegR);
FreeReg(RegR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_NE_INT_MI_64;
begin
EmitOP_NE_INT_MI;
end;
procedure TEmitter.EmitOP_NE_INT_MI;
var
Reg, RegR: Integer;
begin
EmitPCodeOperator;
if HasTheSameAddressRegister(SymbolRec1, SymbolRecR) then
begin
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
Prg.AsmSet_REGPtr(ASM_SETNZ, Reg, SymbolRecR);
FreeReg(Reg);
end
else
begin
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
Reg := EmitGetAddressRegister(SymbolRec1);
Prg.AsmCmpREGPtr_Imm(Reg, SymbolRec1, ImmValue2);
Prg.AsmSetNZ_REGPtr(RegR);
FreeReg(Reg);
FreeReg(RegR);
end;
end;
procedure TEmitter.EmitOP_NE_INT_MM_64;
begin
EmitOP_NE_INT_MM;
end;
procedure TEmitter.EmitOP_NE_INT_MM;
var
Reg1, Reg2, RegR: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
RegR := GetReg;
EmitLoadAddress(RegR, SymbolRecR);
EmitLoadIntVal(Reg1, SymbolRec1);
EmitLoadIntVal(Reg2, SymbolRec2);
Prg.AsmCmpREG_REG(Reg1, Reg2);
Prg.AsmSetNZ_REGPtr(RegR);
FreeReg(RegR);
FreeReg(Reg2);
FreeReg(Reg1);
end;
procedure TEmitter.EmitOP_LT_CURRENCY_64;
begin
EmitOP_LT_CURRENCY;
end;
procedure TEmitter.EmitOP_LT_CURRENCY;
var
Reg: Integer;
S: TSymbolRec;
begin
EmitPCodeOperator;
S := SymbolRec2;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
S := SymbolRec1;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetB_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_LE_CURRENCY_64;
begin
EmitOP_LE_CURRENCY;
end;
procedure TEmitter.EmitOP_LE_CURRENCY;
var
Reg: Integer;
S: TSymbolRec;
begin
EmitPCodeOperator;
S := SymbolRec2;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
S := SymbolRec1;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetBE_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_GT_CURRENCY_64;
begin
EmitOP_GT_CURRENCY;
end;
procedure TEmitter.EmitOP_GT_CURRENCY;
var
Reg: Integer;
S: TSymbolRec;
begin
EmitPCodeOperator;
S := SymbolRec2;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
S := SymbolRec1;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNBE_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_GE_CURRENCY_64;
begin
EmitOP_GE_CURRENCY;
end;
procedure TEmitter.EmitOP_GE_CURRENCY;
var
Reg: Integer;
S: TSymbolRec;
begin
EmitPCodeOperator;
S := SymbolRec2;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
S := SymbolRec1;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNB_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_EQ_CURRENCY_64;
begin
EmitOP_EQ_CURRENCY;
end;
procedure TEmitter.EmitOP_EQ_CURRENCY;
var
Reg: Integer;
S: TSymbolRec;
begin
EmitPCodeOperator;
S := SymbolRec2;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
S := SymbolRec1;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetZ_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_NE_CURRENCY_64;
begin
EmitOP_NE_CURRENCY;
end;
procedure TEmitter.EmitOP_NE_CURRENCY;
var
Reg: Integer;
S: TSymbolRec;
begin
EmitPCodeOperator;
S := SymbolRec2;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
S := SymbolRec1;
if S.FinalTypeId <> typeCURRENCY then
begin
if S.FinalTypeId in IntegerTypes then
EmitFild(S)
else if S.FinalTypeId in RealTypes then
EmitFld(S)
else
RaiseError(errInternalError, []);
EmitFMul_10000;
end
else
EmitFild(S);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNZ_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_LT_DOUBLE_64;
begin
EmitOP_LT_DOUBLE;
end;
procedure TEmitter.EmitOP_LT_DOUBLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetB_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_LT_SINGLE_64;
begin
EmitOP_LT_SINGLE;
end;
procedure TEmitter.EmitOP_LT_SINGLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetB_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_LT_EXTENDED_64;
begin
EmitOP_LT_EXTENDED;
end;
procedure TEmitter.EmitOP_LT_EXTENDED;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetB_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_LE_DOUBLE_64;
begin
EmitOP_LE_DOUBLE;
end;
procedure TEmitter.EmitOP_LE_DOUBLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetBE_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_LE_SINGLE_64;
begin
EmitOP_LE_SINGLE;
end;
procedure TEmitter.EmitOP_LE_SINGLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetBE_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_LE_EXTENDED_64;
begin
EmitOP_LE_EXTENDED;
end;
procedure TEmitter.EmitOP_LE_EXTENDED;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetBE_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_GT_DOUBLE_64;
begin
EmitOP_GT_DOUBLE;
end;
procedure TEmitter.EmitOP_GT_DOUBLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNBE_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_GT_SINGLE_64;
begin
EmitOP_GT_SINGLE;
end;
procedure TEmitter.EmitOP_GT_SINGLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNBE_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_GT_EXTENDED_64;
begin
EmitOP_GT_EXTENDED;
end;
procedure TEmitter.EmitOP_GT_EXTENDED;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNBE_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_GE_DOUBLE_64;
begin
EmitOP_GE_DOUBLE;
end;
procedure TEmitter.EmitOP_GE_DOUBLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNB_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_GE_SINGLE_64;
begin
EmitOP_GE_SINGLE;
end;
procedure TEmitter.EmitOP_GE_SINGLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNB_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_GE_EXTENDED_64;
begin
EmitOP_GE_EXTENDED;
end;
procedure TEmitter.EmitOP_GE_EXTENDED;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNB_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_EQ_DOUBLE_64;
begin
EmitOP_EQ_DOUBLE;
end;
procedure TEmitter.EmitOP_EQ_DOUBLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetZ_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_EQ_SINGLE_64;
begin
EmitOP_EQ_SINGLE;
end;
procedure TEmitter.EmitOP_EQ_SINGLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetZ_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_EQ_EXTENDED_64;
begin
EmitOP_EQ_EXTENDED;
end;
procedure TEmitter.EmitOP_EQ_EXTENDED;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetZ_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_NE_DOUBLE_64;
begin
EmitOP_NE_DOUBLE;
end;
procedure TEmitter.EmitOP_NE_DOUBLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNZ_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_NE_SINGLE_64;
begin
EmitOP_NE_SINGLE;
end;
procedure TEmitter.EmitOP_NE_SINGLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNZ_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_NE_EXTENDED_64;
begin
EmitOP_NE_EXTENDED;
end;
procedure TEmitter.EmitOP_NE_EXTENDED;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFld(SymbolRec2);
EmitFld(SymbolRec1);
GetReg(_EAX);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFCompP;
Prg.AsmFstsw_AX;
Prg.AsmSahv;
Prg.AsmSetNZ_REGPtr(Reg);
FreeReg(Reg);
FreeReg(_EAX);
end;
procedure TEmitter.EmitOP_PUSH_STRUCTURE_64;
var
Reg, RegTemp: Integer;
SubId, ParamId, ParamNumber, SZ: Integer;
ByRefer: Boolean;
S: TSymbolRec;
begin
EmitPCodeOperator;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
S := GetSymbolRec(ParamId);
SZ := S.Size;
if SZ > 8 then
ByRefer := true
else
ByRefer := S.ByRef or (S.IsConst and (SZ > 8));
if (not ByRefer) and (SZ > 8) then
begin
while SZ mod 8 <> 0 do
Inc(SZ);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Dec(SZ, 8);
if SZ > 0 then
Prg.AsmAddREG_Imm(Reg, SZ);
RegTemp := GetReg;
repeat
if SZ = 0 then
Prg.AsmXorREG_REG(RegTemp, RegTemp);
Prg.AsmMovREG_REGPtr(RegTemp, Reg);
EmitPushParam(RegTemp);
Dec(SZ, 8);
if SZ < 0 then
break;
Prg.AsmSubREG_Imm(Reg, 8);
until false;
FreeReg(RegTemp);
FreeReg(Reg);
Exit;
end;
// push address or 4-byte value
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
EmitLoadAddress(Reg, SymbolRec1);
if not ByRefer then
Prg.AsmMovREG_REGPtr(Reg, Reg);
FreeReg(Reg);
Exit;
end;
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1);
if not ByRefer then
Prg.AsmMovREG_REGPtr(Reg, Reg);
EmitPushParam(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_STRUCTURE;
var
Reg, RegTemp: Integer;
SubId, ParamId, ParamNumber, SZ: Integer;
ByRefer: Boolean;
S: TSymbolRec;
begin
EmitPCodeOperator;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
S := GetSymbolRec(ParamId);
SZ := S.Size;
if (GetSymbolRec(SubId).CallConv = ccREGISTER) and (SZ > 4) then
ByRefer := true
else
ByRefer := S.ByRef or (S.IsConst and (SZ > 4));
if (not ByRefer) and (SZ > 4) then
begin
while SZ mod 4 <> 0 do
Inc(SZ);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Dec(SZ, 4);
if SZ > 0 then
Prg.AsmAddREG_Imm(Reg, SZ);
RegTemp := GetReg;
repeat
if SZ = 0 then
Prg.AsmXorREG_REG(RegTemp, RegTemp);
Prg.AsmMovREG_REGPtr(RegTemp, Reg);
Prg.AsmPush_REG(RegTemp);
Dec(SZ, 4);
if SZ < 0 then
break;
Prg.AsmSubREG_Imm(Reg, 4);
until false;
FreeReg(RegTemp);
FreeReg(Reg);
Exit;
end;
// push address or 4-byte value
if GetSymbolRec(SubId).CallConv in [ccREGISTER, ccMSFASTCALL] then
begin
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
EmitLoadAddress(Reg, SymbolRec1);
if not ByRefer then
Prg.AsmMovREG_REGPtr(Reg, Reg);
FreeReg(Reg);
Exit;
end;
end;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
if not ByRefer then
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_EXPORTS_64;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_EXPORTS;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_PUSH_ADDRESS_64;
begin
EmitOP_PUSH_ADDRESS;
end;
procedure TEmitter.EmitOP_PUSH_ADDRESS;
var
Reg: Integer;
SubId, ParamId, ParamNumber: Integer;
begin
EmitPCodeOperator;
SubId := R.Res;
ParamNumber := R.Arg2;
if GetSymbolRec(SubId).CallConv in [ccREGISTER, ccMSFASTCALL, cc64] then
begin
if GetSymbolRec(SubId).CallConv = cc64 then
if SubId = JS_FunctionCallId then
begin
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1);
if ParamNumber = 1 then
Prg.AsmMovREG_REG(_R9, Reg)
else if ParamNumber > 1 then
Prg.AsmMovRSPPtr_REG64(Reg, $20 + (ParamNumber - 2)*8)
else
RaiseError(errInternalError, []);
FreeReg(Reg);
Exit;
end;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
if SymbolRec1.Kind = KindSUB then
begin
if Host1 then
EmitGet_REG(Reg, SymbolRec1)
else
begin
Prg.AsmMovREG_REG(Reg, _EDI);
Prg.AsmAddREG_Imm(Reg, 0);
Prg.Top.SaveSubId := R.Arg1;
List2.Add(Prg.Top);
end;
end
else
EmitLoadAddress(Reg, SymbolRec1);
if SymbolRec1.FinalTypeId = typeRECORD then
if SymbolRec1.PtrSize <= 4 then
begin
Prg.AsmMovREG32_REGPtr(Reg, Reg);
end;
FreeReg(Reg);
Exit;
end;
end;
Reg := GetReg;
if SymbolRec1.Kind = KindSUB then
begin
if Host1 then
EmitGet_REG(Reg, SymbolRec1)
else
begin
Prg.AsmMovREG_REG(Reg, _EDI);
Prg.AsmAddREG_Imm(Reg, 0);
Prg.Top.SaveSubId := R.Arg1;
List2.Add(Prg.Top);
end;
end
else
EmitLoadAddress(Reg, SymbolRec1);
EmitPushParam(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_INT_IMM_64;
begin
EmitOP_PUSH_INT_IMM;
end;
procedure TEmitter.EmitOP_PUSH_INT_IMM;
var
Reg: Integer;
SubId, ParamId, ParamNumber: Integer;
begin
EmitPCodeOperator;
if R.Res = 0 then
begin
Prg.AsmPush_IMM(ImmValue1);
Exit;
end;
SubId := R.Res;
ParamNumber := R.Arg2;
if GetSymbolRec(SubId).CallConv in [ccREGISTER, ccMSFASTCALL] then
begin
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
Prg.AsmMovREG_IMM(Reg, ImmValue1);
FreeReg(Reg);
Exit;
end;
end
else if GetSymbolRec(SubId).CallConv = cc64 then
begin
if SubId = JS_FunctionCallId then
begin
Prg.AsmMovREG_IMM(_R8, ImmValue1);
Exit;
end;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
Prg.AsmMovREG_IMM(Reg, ImmValue1);
FreeReg(Reg);
Exit;
end;
Reg := GetRegEx;
Prg.AsmMovREG_Imm(Reg, ImmValue1);
EmitPushParam(Reg);
FreeReg(Reg);
Exit;
end;
Prg.AsmPush_IMM(ImmValue1);
end;
procedure TEmitter.EmitOP_PUSH_DATA_64;
begin
RaiseNotImpl;
end;
procedure TEmitter.EmitOP_PUSH_DATA;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetRegEx;
Emit_PUSH_REGS;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, SizeOfPointer);
Prg.AsmMovREG_REGPtr(Reg, Reg);
Emit_POP_REGS;
if SymbolRecR.CallConv in [ccREGISTER, ccMSFASTCALL] then
Prg.AsmMovREG_REG(_EAX, Reg)
else
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_INT_64;
begin
EmitOP_PUSH_INT;
end;
procedure TEmitter.EmitOP_PUSH_INT;
var
Reg: Integer;
SubId, ParamId, ParamNumber: Integer;
begin
EmitPCodeOperator;
if R.Res = 0 then
begin
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
Exit;
end;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
EmitLoadIntVal(Reg, SymbolRec1);
FreeReg(Reg);
Exit;
end;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
EmitPushParam(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_SET_64;
begin
EmitOP_PUSH_SET;
end;
procedure TEmitter.EmitOP_PUSH_SET;
var
Reg: Integer;
SubId, ParamId, ParamNumber, K: Integer;
begin
EmitPCodeOperator;
K := SymbolRec1.Kind;
try
SymbolRec1.Kind := KindVAR;
if R.Res = 0 then
begin
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
Exit;
end;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
EmitLoadIntVal(Reg, SymbolRec1);
FreeReg(Reg);
Exit;
end;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
EmitPushParam(Reg);
FreeReg(Reg);
finally
SymbolRec1.Kind := K;
end;
end;
procedure TEmitter.EmitOP_PUSH_DYNARRAY_64;
var
Reg, RegEx: Integer;
SubId, ParamId, ParamNumber, K, Z: Integer;
S: String;
begin
EmitPCodeOperator;
if R.Res = 0 then
begin
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
Exit;
end;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
S := SymbolTable[SubId].Name;
Reg := GetSymbolRec(ParamId).Register;
k := SymbolRec1.Count;
Z := GetSymbolRec(ParamId).RSPOffset;
if Reg > 0 then
begin
GetReg(Reg);
EmitLoadIntVal(Reg, SymbolRec1);
FreeReg(Reg);
if SymbolTable[ParamId].IsOpenArray then
begin
if Reg = _ECX then
RegEx := _EDX
else if Reg = _EDX then
RegEx := _R8
else if Reg = _R8 then
RegEx := _R9
else
RegEx := _EBX;
if (RegEx = _EBX) and (Reg <> _R9) then
begin
Prg.AsmMovRSPPtr_REG64(Reg, Z);
Inc(Z, 8);
end;
GetReg(RegEx);
// load high(A) into RegEx
Prg.AsmMovREG_Imm(RegEx, k - 1);
if RegEx = _EBX then
Prg.AsmMovRSPPtr_REG64(RegEx, Z);
FreeReg(RegEx);
end;
Exit;
end;
Reg := GetReg(_EBX);
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmMovRSPPtr_REG64(Reg, Z);
Inc(Z, 8);
if SymbolTable[ParamId].IsOpenArray then
begin
// load high(A) into RegEx
Prg.AsmMovREG_Imm(Reg, k - 1);
Prg.AsmMovRSPPtr_REG64(Reg, Z);
end;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_DYNARRAY;
var
Reg, RegEx: Integer;
SubId, ParamId, ParamNumber: Integer;
S: String;
begin
EmitPCodeOperator;
if R.Res = 0 then
begin
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
Exit;
end;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
S := SymbolTable[SubId].Name;
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
EmitLoadIntVal(Reg, SymbolRec1);
FreeReg(Reg);
if SymbolTable[ParamId].IsOpenArray then
begin
if Reg = _EAX then
RegEx := _EDX
else if Reg = _EDX then
RegEx := _ECX
else
RegEx := _EBX;
if (RegEx = _EBX) and (Reg <> _ECX) then
Prg.AsmPush_REG(Reg);
GetReg(RegEx);
if SymbolRec1.FinalTypeId = typeDYNARRAY then
begin
// load high(A) into RegEx
Prg.AsmMovREG_REG(RegEx, Reg);
Prg.AsmCmpREG_Imm(RegEx, 0);
Prg.AsmJZ_Imm(5 + 2);
Prg.AsmAddREG_Imm(RegEx, -4); // 5
Prg.AsmMovREG32_REGPtr(RegEx, RegEx); // 2
Prg.AsmAddREG_Imm(RegEx, -1);
end
else
begin
Prg.AsmMovREG_Imm(RegEx, 0);
end;
if RegEx = _EBX then
Prg.AsmPush_REG(RegEx);
FreeReg(RegEx);
end;
Exit;
end;
if GetSymbolRec(SubId).CallConv in [ccREGISTER, ccMSFASTCALL] then
begin
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
if SymbolTable[ParamId].IsOpenArray then
begin
if SymbolRec1.FinalTypeId = typeDYNARRAY then
begin
// load high(A) into RegEx
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmCmpREG_Imm(Reg, 0);
Prg.AsmJZ_Imm(5 + 2);
Prg.AsmAddREG_Imm(Reg, -4); //5
Prg.AsmMovREG32_REGPtr(Reg, Reg); //2
Prg.AsmAddREG_Imm(Reg, -1);
Prg.AsmPush_REG(Reg);
end
else
Prg.AsmPush_Imm(0);
end;
// EmitLoadIntVal(Reg, SymbolRec1);
// Prg.AsmPush_REG(Reg);
FreeReg(Reg);
Exit;
end;
Reg := GetReg;
if SymbolTable[ParamId].IsOpenArray then
begin
if SymbolRec1.FinalTypeId = typeDYNARRAY then
begin
// load high(A) into RegEx
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmCmpREG_Imm(Reg, 0);
Prg.AsmJZ_Imm(5 + 2);
Prg.AsmAddREG_Imm(Reg, -4); // 5
Prg.AsmMovREG32_REGPtr(Reg, Reg); // 2
Prg.AsmAddREG_Imm(Reg, -1);
Prg.AsmPush_REG(Reg);
end
else
Prg.AsmPush_Imm(0);
end;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_OPENARRAY_64;
begin
RaiseNotImpl;
end;
procedure TEmitter.EmitOP_PUSH_OPENARRAY;
var
Reg, RegEx: Integer;
SubId, ParamId, HighParamId, ParamNumber: Integer;
ArrayTypeId, RangeTypeId, ElemTypeId, B1, B2: Integer;
begin
EmitPCodeOperator;
if R.Res = 0 then
begin
RaiseError(errInternalError, []);
end;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
if SymbolRec1.IsOpenArray then
begin
GetReg(Reg);
EmitLoadIntVal(Reg, SymbolRec1);
FreeReg(Reg);
if Reg = _EAX then
RegEx := _EDX
else if Reg = _EDX then
RegEx := _ECX
else
RegEx := _EBX;
if (RegEx = _EBX) and (Reg <> _ECX) then
Prg.AsmPush_REG(Reg);
GetReg(RegEx);
// load high(A) into RegEx
HighParamId := SymbolTable.GetOpenArrayHighId(R.Arg1);
EmitLoadIntVal(RegEx, GetSymbolRec(HighParamId));
if RegEx = _EBX then
Prg.AsmPush_REG(RegEx);
FreeReg(RegEx);
end
else if SymbolRec1.FinalTypeId = typeARRAY then
begin
GetReg(Reg);
EmitLoadAddress(Reg, SymbolRec1);
FreeReg(Reg);
if Reg = _EAX then
RegEx := _EDX
else if Reg = _EDX then
RegEx := _ECX
else
RegEx := _EBX;
if (RegEx = _EBX) and (Reg <> _ECX) then
Prg.AsmPush_REG(Reg);
GetReg(RegEx);
// load high(A) into RegEx
ArrayTypeId := SymbolRec1.TerminalTypeId;
TKernel(kernel).SymbolTable.GetArrayTypeInfo(ArrayTypeId, RangeTypeId, ElemTypeId);
B1 := TKernel(kernel).SymbolTable.GetLowBoundRec(RangeTypeId).Value;
B2 := TKernel(kernel).SymbolTable.GetHighBoundRec(RangeTypeId).Value;
Prg.AsmMovREG_Imm(RegEx, B2 - B1);
if RegEx = _EBX then
Prg.AsmPush_REG(RegEx);
FreeReg(RegEx);
end
else if SymbolRec1.IsFWArrayVar then
begin
GetReg(Reg);
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmAddReg_Imm(Reg, FWArrayOffset);
Prg.AsmMovREG32_REGPtr(Reg, Reg);
FreeReg(Reg);
if Reg = _EAX then
RegEx := _EDX
else if Reg = _EDX then
RegEx := _ECX
else
RegEx := _EBX;
if (RegEx = _EBX) and (Reg <> _ECX) then
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(RegEx, Reg);
Prg.AsmCmpREG_Imm(RegEx, 0);
Prg.AsmJZ_Imm(5 + 2);
Prg.AsmAddREG_Imm(RegEx, -4); // 5
Prg.AsmMovREG32_REGPtr(RegEx, RegEx); // 2
Prg.AsmAddREG_Imm(RegEx, -1);
if RegEx = _EBX then
Prg.AsmPush_REG(RegEx);
end;
Exit;
end;
if GetSymbolRec(SubId).CallConv in [ccREGISTER, ccMSFASTCALL] then
begin
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
if SymbolRec1.IsOpenArray then
begin
// load high(A) into RegEx
HighParamId := SymbolTable.GetOpenArrayHighId(R.Arg1);
EmitLoadIntVal(Reg, GetSymbolRec(HighParamId));
Prg.AsmPush_REG(Reg);
end
else if SymbolRec1.FinalTypeId = typeARRAY then
begin
// load high(A) into RegEx
ArrayTypeId := SymbolRec1.TerminalTypeId;
TKernel(kernel).SymbolTable.GetArrayTypeInfo(ArrayTypeId, RangeTypeId, ElemTypeId);
B1 := TKernel(kernel).SymbolTable.GetLowBoundRec(RangeTypeId).Value;
B2 := TKernel(kernel).SymbolTable.GetHighBoundRec(RangeTypeId).Value;
Prg.AsmMovREG_Imm(Reg, B2 - B1);
Prg.AsmPush_REG(Reg);
end;
FreeReg(Reg);
Exit;
end;
if SymbolRec1.IsFWArrayVar then
begin
Reg := GetReg;
// load high(A) into RegEx
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmAddReg_Imm(Reg, FWArrayOffset);
Prg.AsmMovREG32_REGPtr(Reg, Reg);
Prg.AsmCmpREG_Imm(Reg, 0);
Prg.AsmJZ_Imm(5 + 2);
Prg.AsmAddREG_Imm(Reg, -4); //5
Prg.AsmMovREG32_REGPtr(Reg, Reg); //2
Prg.AsmAddREG_Imm(Reg, -1);
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmAddReg_Imm(Reg, FWArrayOffset);
Prg.AsmMovREG32_REGPtr(Reg, Reg);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
Exit;
end;
Reg := GetReg;
if SymbolRec1.IsOpenArray then
begin
// load high(A) into Reg
HighParamId := SymbolTable.GetOpenArrayHighId(R.Arg1);
EmitLoadIntVal(Reg, GetSymbolRec(HighParamId));
Prg.AsmPush_REG(Reg);
end
else if SymbolRec1.FinalTypeId = typeARRAY then
begin
// load high(A) into RegEx
ArrayTypeId := SymbolRec1.TerminalTypeId;
TKernel(kernel).SymbolTable.GetArrayTypeInfo(ArrayTypeId, RangeTypeId, ElemTypeId);
B1 := TKernel(kernel).SymbolTable.GetLowBoundRec(RangeTypeId).Value;
B2 := TKernel(kernel).SymbolTable.GetHighBoundRec(RangeTypeId).Value;
Prg.AsmMovREG_Imm(Reg, B2 - B1);
Prg.AsmPush_REG(Reg);
end;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_CLEAR_EDX_64;
begin
EmitOP_CLEAR_EDX;
end;
procedure TEmitter.EmitOP_CLEAR_EDX;
begin
EmitPCodeOperator;
Prg.AsmMovREG_Imm(_EDX, 0);
end;
procedure TEmitter.EmitOP_UPDATE_INSTANCE_64;
var
Reg: Integer;
SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_UpdateInstance;
EmitCallPro(SubId);
Reg := GetRegEx;
Emit_PUSH_REGS;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_UPDATE_INSTANCE;
var
Reg: Integer;
SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_UpdateInstance;
EmitCallPro(SubId);
Reg := GetRegEx;
Emit_PUSH_REGS;
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_PUSH_INST_64;
var
Reg: Integer;
SubId: Integer;
L, K: Integer;
SR: TSymbolRec;
begin
EmitPCodeOperator;
L := GetSymbolRec(R.Res).Level;
if GetSymbolRec(L).FinalTypeId = typeHELPER then
L := GetSymbolRec(L).PatternId;
K := SymbolTable[R.Res].Kind;
if (K = kindCONSTRUCTOR) and
(SymbolTable[SymbolTable[R.Res].Level].FinalTypeId <> typeRECORD) and
SymbolTable[R.Res].Host and
(not SymbolTable[R.Res].IsExternal) then
begin
SubId := Id_ToParentClass;
EmitCallPro(SubId);
Reg := GetRegEx;
Emit_PUSH_REGS;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
GetReg(_ECX);
if GetSymbolRec(L).FinalTypeId in [typeCLASS, typeINTERFACE] then
EmitLoadIntVal(_ECX, SymbolRec1)
else
EmitLoadAddress(_ECX, SymbolRec1);
if SymbolRecR.IsSharedMethod then
if not StrEql(SymbolRecR.Name, 'ClassType') then
Prg.AsmMovREG_REGPtr(_ECX, _ECX);
FreeReg(_ECX);
SR := SymbolTable[R.Res];
if SR.Kind in [kindCONSTRUCTOR, kindDESTRUCTOR] then
begin
Prg.AsmMovREG_Imm(_EDX, 0);
end
else if SR.IsFakeMethod then
if SR.ExtraParamNeeded then
begin
Prg.AsmMovREG_REG(_EDX, _ECX);
end;
end;
procedure TEmitter.EmitOP_PUSH_INST;
var
Reg: Integer;
SubId: Integer;
L, K: Integer;
begin
EmitPCodeOperator;
L := GetSymbolRec(R.Res).Level;
if GetSymbolRec(L).FinalTypeId = typeHELPER then
L := GetSymbolRec(L).PatternId;
if SymbolTable[R.Res].CallConv in [ccREGISTER, ccMSFASTCALL] then
begin
K := SymbolTable[R.Res].Kind;
if (K = kindCONSTRUCTOR) and
(SymbolTable[SymbolTable[R.Res].Level].FinalTypeId <> typeRECORD) and
SymbolTable[R.Res].Host and
(not SymbolTable[R.Res].IsExternal) then
begin
SubId := Id_ToParentClass;
EmitCallPro(SubId);
Reg := GetRegEx;
Emit_PUSH_REGS;
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
GetReg(_EAX);
if GetSymbolRec(L).FinalTypeId in [typeCLASS, typeINTERFACE] then
EmitLoadIntVal(_EAX, SymbolRec1)
else
EmitLoadAddress(_EAX, SymbolRec1);
if SymbolRecR.IsSharedMethod then
if not StrEql(SymbolRecR.Name, 'ClassType') then
Prg.AsmMovREG_REGPtr(_EAX, _EAX);
FreeReg(_EAX);
if SymbolTable[R.Res].Kind in [kindCONSTRUCTOR, kindDESTRUCTOR] then
begin
Prg.AsmMovREG_Imm(_EDX, 0);
end;
end
else
begin
if (SymbolTable[R.Res].Kind = kindCONSTRUCTOR) and
SymbolTable[R.Res].Host and
(not SymbolTable[R.Res].IsExternal) then
begin
SubId := Id_ToParentClass;
EmitCallPro(SubId);
Reg := GetRegEx;
Emit_PUSH_REGS;
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
GetReg(_EAX);
Reg := _EAX;
if GetSymbolRec(L).FinalTypeId in [typeCLASS, typeINTERFACE] then
EmitLoadIntVal(Reg, SymbolRec1)
else
EmitLoadAddress(Reg, SymbolRec1);
if SymbolRecR.IsSharedMethod then
if not StrEql(SymbolRecR.Name, 'ClassType') then
Prg.AsmMovREG_REGPtr(_EAX, _EAX);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
end;
end;
procedure TEmitter.EmitOP_PUSH_CLSREF_64;
begin
EmitPCodeOperator;
if SymbolRecR.Kind = kindCONSTRUCTOR then
begin
GetReg(_ECX);
GetReg(_EDX);
{$IFDEF FPC}
if SymbolRecR.Host then
begin
EmitLoadIntVal(_EDX, SymbolRec1);
Prg.AsmMovREG_Imm(_ECX, 0);
end
else
begin
EmitLoadIntVal(_ECX, SymbolRec1);
Prg.AsmMovREG_Imm(_EDX, 1);
end;
{$ELSE}
EmitLoadIntVal(_ECX, SymbolRec1);
Prg.AsmMovREG_Imm(_EDX, 1);
{$ENDIF}
FreeReg(_EDX);
FreeReg(_ECX);
if SymbolRecR.IsExternal then
begin
Emit_PUSH_REGS;
Prg.AsmPush_REG(_EAX);
Prg.AsmMovREG_REG(_EBX, _ESI);
Prg.AsmAddREG_Imm(_EBX, H_SelfPtr);
Prg.AsmMovREG_REGPtr(_EBX, _EBX); // load TProgram.Self
Prg.AsmPush_REG(_EBX);
Prg.AsmGetREG_ESIPtr(_EBX, GetOffset(SymbolTable[Id_LoadClassRef]));
Prg.AsmCall_REG(_EBX);
Emit_POP_REGS;
end;
end
else
begin
GetReg(_EAX);
EmitLoadIntVal(_EAX, SymbolRec1);
if SymbolTable[R.Res].CallConv <> ccREGISTER then
Prg.AsmPush_REG(_EAX);
FreeReg(_EAX);
end;
end;
procedure TEmitter.EmitOP_PUSH_CLSREF;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
if SymbolRecR.Kind = kindCONSTRUCTOR then
begin
GetReg(_EAX);
GetReg(_EDX);
{$IFDEF FPC}
if SymbolRecR.Host then
begin
EmitLoadIntVal(_EDX, SymbolRec1);
Prg.AsmMovREG_Imm(_EAX, 0);
end
else
begin
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmMovREG_Imm(_EDX, 1);
end;
{$ELSE}
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmMovREG_Imm(_EDX, 1);
{$ENDIF}
FreeReg(_EDX);
FreeReg(_EAX);
if SymbolRecR.IsExternal then
begin
Emit_PUSH_REGS;
SubId := Id_LoadClassRef;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmPush_REG(_EAX);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
end
else
begin
GetReg(_EAX);
EmitLoadIntVal(_EAX, SymbolRec1);
if SymbolTable[R.Res].CallConv <> ccREGISTER then
Prg.AsmPush_REG(_EAX);
FreeReg(_EAX);
end;
end;
procedure TEmitter.EmitOP_PUSH_INT64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
if Host1 or ByRef1 then
begin
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmPush_REGPtr(Reg);
Prg.AsmAddREG_Imm(Reg, -4);
Prg.AsmPush_REGPtr(Reg);
end
else
begin
EmitGet_REG(Reg, SymbolRec1, + 4);
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
end;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_EVENT_64;
begin
RaiseNotImpl;
end;
procedure TEmitter.EmitOP_PUSH_EVENT;
var
Reg: Integer;
begin
EmitPCodeOperator;
HandlesEvents := true;
Reg := GetReg;
if Host1 or ByRef1 then
begin
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmPush_REGPtr(Reg);
Prg.AsmAddREG_Imm(Reg, -4);
Prg.AsmPush_REGPtr(Reg);
end
else
begin
EmitGet_REG(Reg, SymbolRec1, + 4);
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
end;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_DOUBLE_64;
var
Reg, SubId, ParamNumber, ParamId: Integer;
S: TSymbolRec;
begin
EmitPCodeOperator;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
S := GetSymbolRec(ParamId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
if S.XMMReg > 0 then
begin
Prg.AsmMovsdXMM_RegPtr(S.XMMReg, Reg);
end
else
begin
Prg.AsmMovsdXMM_RegPtr(_XMM4, Reg);
Prg.AsmMovREG_REG(Reg, _ESP);
Prg.AsmAddREG_Imm(Reg, S.RSPOffset);
Prg.AsmMovsdRegPtr_XMM(_XMM4, Reg);
end;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_DOUBLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
if Host1 or ByRef1 then
begin
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmPush_REGPtr(Reg);
Prg.AsmAddREG_Imm(Reg, -4);
Prg.AsmPush_REGPtr(Reg);
end
else
begin
EmitGet_REG(Reg, SymbolRec1, + 4);
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
end;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_CURRENCY;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
if Host1 or ByRef1 then
begin
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmPush_REGPtr(Reg);
Prg.AsmAddREG_Imm(Reg, -4);
Prg.AsmPush_REGPtr(Reg);
end
else
begin
EmitGet_REG(Reg, SymbolRec1, + 4);
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
end;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_EXTENDED;
var
RegAddr, RegE: Integer;
begin
EmitPCodeOperator;
RegAddr := GetReg;
EmitLoadAddress(RegAddr, SymbolRec1);
if TargetPlatform in [tpOSX32, tpIOSSim] then
begin
Prg.AsmAddREG_Imm(RegAddr, 12);
Prg.AsmPush_REGPtr(RegAddr);
Prg.AsmAddREG_Imm(RegAddr, -4);
Prg.AsmPush_REGPtr(RegAddr);
Prg.AsmAddREG_Imm(RegAddr, -4);
Prg.AsmPush_REGPtr(RegAddr);
Prg.AsmAddREG_Imm(RegAddr, -4);
Prg.AsmPush_REGPtr(RegAddr);
end
else
begin
RegE := GetReg;
Prg.AsmAddREG_Imm(RegAddr, 8);
Prg.AsmMovREG16_REGPtr(RegE, RegAddr);
Prg.AsmPush_REG(RegE);
Prg.AsmAddREG_Imm(RegAddr, -4);
Prg.AsmPush_REGPtr(RegAddr);
Prg.AsmAddREG_Imm(RegAddr, -4);
Prg.AsmPush_REGPtr(RegAddr);
FreeReg(RegE);
end;
FreeReg(RegAddr);
end;
procedure TEmitter.EmitOP_PUSH_SINGLE_64;
var
Reg, SubId, ParamNumber, ParamId: Integer;
S: TSymbolRec;
begin
EmitPCodeOperator;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
S := GetSymbolRec(ParamId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
if S.XMMReg > 0 then
begin
Prg.AsmMovssXMM_RegPtr(S.XMMReg, Reg);
end
else
begin
Prg.AsmMovssXMM_RegPtr(_XMM4, Reg);
Prg.AsmMovREG_REG(Reg, _ESP);
Prg.AsmAddREG_Imm(Reg, S.RSPOffset);
Prg.AsmMovssRegPtr_XMM(_XMM4, Reg);
end;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_SINGLE;
var
Reg: Integer;
I: Integer;
S: Single;
begin
EmitPCodeOperator;
if SymbolRec1.Kind = KindCONST then
begin
S := SymbolRec1.Value;
Move(S, I, SizeOf(Single));
Prg.AsmPush_IMM(I);
end
else
begin
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
end;
end;
procedure TEmitter.EmitOP_PUSH_ANSISTRING_64;
begin
EmitOP_PUSH_ANSISTRING;
end;
procedure TEmitter.EmitOP_PUSH_ANSISTRING;
var
Reg: Integer;
SubId, ParamId, ParamNumber: Integer;
begin
EmitPCodeOperator;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
EmitLoadIntVal(Reg, SymbolRec1);
FreeReg(Reg);
Exit;
end;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
EmitPushParam(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_WIDESTRING_64;
begin
EmitOP_PUSH_WIDESTRING;
end;
procedure TEmitter.EmitOP_PUSH_WIDESTRING;
var
Reg: Integer;
SubId, ParamId, ParamNumber: Integer;
begin
EmitPCodeOperator;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
EmitLoadIntVal(Reg, SymbolRec1);
FreeReg(Reg);
Exit;
end;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
EmitPushParam(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_UNICSTRING_64;
begin
EmitOP_PUSH_UNICSTRING;
end;
procedure TEmitter.EmitOP_PUSH_UNICSTRING;
var
Reg: Integer;
SubId, ParamId, ParamNumber: Integer;
begin
EmitPCodeOperator;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
EmitLoadIntVal(Reg, SymbolRec1);
FreeReg(Reg);
Exit;
end;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
EmitPushParam(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_PUSH_SHORTSTRING_64;
begin
EmitOP_PUSH_SHORTSTRING;
end;
procedure TEmitter.EmitOP_PUSH_SHORTSTRING;
var
Reg: Integer;
SubId, ParamId, ParamNumber: Integer;
begin
EmitPCodeOperator;
// push address
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
EmitLoadAddress(Reg, SymbolRec1);
FreeReg(Reg);
Exit;
end;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
EmitPushParam(Reg);
FreeReg(Reg);
end;
{$IFNDEF PAXARM}
procedure TEmitter.EmitOP_PUSH_PANSICHAR_IMM_64;
begin
EmitOP_PUSH_PANSICHAR_IMM;
end;
procedure TEmitter.EmitOP_PUSH_PANSICHAR_IMM;
var
Reg: Integer;
SubId, ParamId, ParamNumber, Id: Integer;
begin
EmitPCodeOperator;
// to provide unique constant address
Id := SymbolTable.FindPAnsiCharConst(SymbolRec1.Value, R.Arg1 - 1);
if Id > 0 then
if SymbolTable.InCode[Id] then
R.Arg1 := Id;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
EmitGet_REG(Reg, SymbolRec1); // pchar source
FreeReg(Reg);
Exit;
end;
Reg := GetReg;
EmitGet_REG(Reg, SymbolRec1); // pchar source
EmitPushParam(Reg);
FreeReg(Reg);
end;
{$ENDIF}
procedure TEmitter.EmitOP_PUSH_PWIDECHAR_IMM_64;
begin
EmitOP_PUSH_PWIDECHAR_IMM;
end;
procedure TEmitter.EmitOP_PUSH_PWIDECHAR_IMM;
var
Reg: Integer;
SubId, ParamId, ParamNumber, Id: Integer;
begin
EmitPCodeOperator;
// to provide unique constant address
Id := SymbolTable.FindPWideCharConst(SymbolRec1.Value, R.Arg1 - 1);
if Id > 0 then
if SymbolTable.InCode[Id] then
R.Arg1 := Id;
SubId := R.Res;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Reg := GetSymbolRec(ParamId).Register;
if Reg > 0 then
begin
GetReg(Reg);
EmitGet_REG(Reg, SymbolRec1); // pchar source
FreeReg(Reg);
Exit;
end;
Reg := GetReg;
EmitGet_REG(Reg, SymbolRec1); // pchar source
EmitPushParam(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_ADDREF_64;
begin
EmitOP_ADDREF;
end;
procedure TEmitter.EmitOP_ADDREF;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
SubId := 0;
case SymbolRec1.FinalTypeId of
{$IFNDEF PAXARM}
typeANSISTRING: SubId := Id_StringAddRef;
typeWIDESTRING: SubId := Id_WideStringAddRef;
{$ENDIF}
typeUNICSTRING: SubId := Id_UnicStringAddRef;
typeVARIANT, typeOLEVARIANT: SubId := Id_VariantAddRef;
typeDYNARRAY: SubId := Id_DynarrayAddRef;
typeINTERFACE: SubId := Id_InterfaceAddRef;
else
RaiseError(errInternalError, []);
end;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_BEGIN_CALL_64;
begin
EmitOP_BEGIN_CALL;
end;
procedure TEmitter.EmitOP_BEGIN_CALL;
var
Reg, I, SubId: Integer;
Code: TCode;
begin
EmitPCodeOperator;
SubId := SymbolRec1.Id;
if not SymbolRec1.IsNestedSub then
SaveRegisters([_ESI, _EDI], 4 * SizeOfPointer);
EmitCallPro(SubId);
if SymbolRec1.CallConv = ccSAFECALL then
begin
Code := TKernel(kernel).Code;
I := Code.N;
while I < Code.Card do
begin
Inc(I);
if Code[I].Op = OP_CALL then
if Code[I].Arg1 = SubId then
begin
if Code[I].Res > 0 then
begin
Reg := GetReg;
EmitLoadAddress(Reg, GetSymbolRec(Code[I].Res));
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
Exit;
end;
break;
end;
end;
if Code[I].Res > 0 then
RaiseError(errInternalError, []);
end;
end;
procedure TEmitter.EmitOP_CALL_64;
begin
EmitOP_CALL;
end;
procedure TEmitter.EmitOP_CALL;
function DiscardVirtualCall: Boolean;
var
Code: TCode;
I: Integer;
begin
Code := TKernel(kernel).Code;
I := Code.N - 1;
while Code[I].Op <> OP_PUSH_INST do
Dec(I);
result := Code[I].CodeRecTag = TAG_DISCARD_VIRTUAL_CALL;
end;
procedure EmitInterfaceAddress(MethodIndex: Integer);
var
Code: TCode;
I, RegInstance: Integer;
{$IFDEF FPC}
b: Boolean;
{$ENDIF}
begin
{$IFDEF FPC}
b := GetSymbolRec(SymbolRec1.Level).FinalTypeId = typeINTERFACE;
{$ENDIF}
if TargetPlatform = tpWIN64 then
RegInstance := _ECX
else
RegInstance := _EAX;
Code := TKernel(kernel).Code;
I := Code.N - 1;
while Code[I].Op <> OP_PUSH_INST do
Dec(I);
if I = Code.N - 1 then
begin
prg.AsmMovREG_REGPtr(_EBX, RegInstance);
prg.AsmAddREG_Imm(_EBX, (MethodIndex - 1) * SizeOfPointer);
{$IFDEF FPC}
if not b then
prg.AsmAddREG_Imm(_EBX, FPC_VIRTUAL_OFFSET);
{$ENDIF}
prg.AsmMovREG_REGPtr(_EBX, _EBX);
end
else
begin
Emit_PUSH_REGS;
EmitLoadIntVal(_EAX, GetSymbolRec(Code[I].Arg1));
prg.AsmMovREG_REGPtr(_EBX, RegInstance);
prg.AsmAddREG_Imm(_EBX, (MethodIndex - 1) * SizeOfPointer);
{$IFDEF FPC}
if not b then
prg.AsmAddREG_Imm(_EBX, FPC_VIRTUAL_OFFSET);
{$ENDIF}
prg.AsmMovREG_REGPtr(_EBX, _EBX);
Emit_POP_REGS;
end;
end;
function FindBeginCall: TCodeRec;
var
RR: TCodeRec;
I, K, SubId: Integer;
Code: TCode;
begin
result := nil;
Code := TKernel(kernel).Code;
I := Code.N - 1;
RR := Code[Code.N];
SubId := RR.Arg1;
K := 0;
repeat
if (Code[I].Op = OP_CALL) and (Code[I].Arg1 = SubId) then
Dec(K)
else if (Code[I].Op = OP_BEGIN_CALL) and (Code[I].Arg1 = SubId) then
begin
if K = 0 then
begin
result := Code[I];
Exit;
end;
Inc(K);
end;
Dec(I);
until I = 0;
end;
var
Reg, ParamId, I, K, T: Integer;
{$IFDEF FPC}
SubId: Integer;
{$ENDIF}
Code: TCode;
TrueSubId, cc: Integer;
RR: TCodeRec;
begin
EmitPCodeOperator;
Code := TKernel(kernel).Code;
if SymbolRec1.Kind = KindVAR then
begin
T := SymbolRec1.TerminalTypeId;
TrueSubId := GetSymbolRec(T).PatternId;
if not (GetSymbolRec(TrueSubId).Kind in kindSUBS) then
begin
K := Code.N - 1;
repeat
if Code[K] .Op = OP_GET_VMT_ADDRESS then
if Code[K] .Res = SymbolRec1.Id then
begin
TrueSubId := Code[K] .Arg2;
break;
end;
if Code[K] .Op = OP_SEPARATOR then
break;
Dec(K);
until false;
end
else
begin
// ok
end;
end
else
TrueSubId := SymbolRec1.Id;
cc := GetSymbolRec(TrueSubId).CallConv;
if (GetSymbolRec(TrueSubId).Level = H_TObject) then
if (GetSymbolRec(TrueSubId).Name = 'ClassName') then
begin
if Code[Code.N - 1].Op = OP_PUSH_CLSREF then
begin
if TargetPlatform = tpWIN64 then
begin
Prg.AsmMovREG_REG(_EDX, _ECX);
Prg.AsmMovREG_Imm(_ECX, 1);
end
else
Prg.AsmPush_Imm(1);
end
else if Code[Code.N - 1].Op = OP_PUSH_INST then
begin
I := Code.GetCurrSelfId(Code.N);
if I = Code[Code.N - 1].Arg1 then
begin
I := Code.GetCurrSubId(Code.N);
if GetSymbolRec(I).IsStatic then
begin
if TargetPlatform = tpWIN64 then
begin
Prg.AsmMovREG_REG(_R8, _ECX);
Prg.AsmMovREG_Imm(_EDX, 1);
end
else
Prg.AsmPush_Imm(1);
end
else
begin
if TargetPlatform = tpWIN64 then
begin
Prg.AsmMovREG_REG(_R8, _ECX);
Prg.AsmMovREG_Imm(_EDX, 0);
end
else
Prg.AsmPush_Imm(0);
end;
end
else
begin
if TargetPlatform = tpWIN64 then
begin
Prg.AsmMovREG_REG(_R8, _ECX);
Prg.AsmMovREG_Imm(_EDX, 0);
end
else
Prg.AsmPush_Imm(0);
end;
end
else
begin
if TargetPlatform = tpWIN64 then
begin
Prg.AsmMovREG_REG(_R8, _ECX);
Prg.AsmMovREG_Imm(_EDX, 0);
end
else
Prg.AsmPush_Imm(0);
end;
end;
{$IFDEF TRIAL}
Inc(_Counter);
{$ENDIF}
Reg := GetReg(_EBX);
if SymbolRec1.RunnerParameter then
begin
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmAddREG_Imm(Reg, RUNNER_OWNER_OFFSET);
Prg.AsmMovREG_REGPtr(_EDI, Reg);
end;
if Host1 and (SymbolRec1.PushProgRequired) then
begin
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
if TargetPlatform = tpWIN64 then
Prg.AsmMovREG_REG(_ECX, Reg) // push TProgram.Self
else
Prg.AsmPush_REG(Reg); // push TProgram.Self
end;
if GetSymbolRec(TrueSubId).ExtraParamNeeded and (cc <> ccSAFECALL) then
begin
if GetSymbolRec(TrueSubId).CallConv = ccREGISTER then
begin
K := 0;
if (GetSymbolRec(TrueSubId).IsMethod or
(GetSymbolRec(TrueSubId-1).FinalTypeId = typeEVENT) and (GetSymbolRec(TrueSubId-1).PatternId = TrueSubId)) and
(GetSymbolRec(TrueSubId).CallMode <> cmSTATIC) then
Inc(K);
for I:= 0 to R.Arg2 - 1 do
begin
ParamId := SymbolTable.GetParamId(TrueSubId, I);
if GetSymbolRec(ParamId).Register > 0 then
begin
Inc(K);
if GetSymbolRec(ParamId).FinalTypeId in [typeDYNARRAY, typeOPENARRAY] then
if GetSymbolRec(ParamId).IsOpenArray then
Inc(K);
end;
end;
case K of
0:
begin
GetReg(_EAX);
EmitLoadAddress(_EAX, SymbolRecR);
FreeReg(_EAX);
end;
1:
begin
GetReg(_EDX);
EmitLoadAddress(_EDX, SymbolRecR);
FreeReg(_EDX);
end;
2:
begin
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
FreeReg(_ECX);
end;
else
begin
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmPush_REG(Reg);
end;
end;
end //ccREGISTER
else if GetSymbolRec(TrueSubId).CallConv = cc64 then
begin
K := 0;
if (GetSymbolRec(TrueSubId).IsMethod or
(GetSymbolRec(TrueSubId-1).FinalTypeId = typeEVENT) and (GetSymbolRec(TrueSubId-1).PatternId = TrueSubId)) and
(GetSymbolRec(TrueSubId).CallMode <> cmSTATIC) then
Inc(K);
if GetSymbolRec(TrueSubId).IsNestedSub then
K := 1;
if (GetSymbolRec(TrueSubId).Level = H_TObject) then
if (GetSymbolRec(TrueSubId).Name = 'ClassName') then
K := 0;
if GetSymbolRec(TrueSubId).IsFakeMethod then
K := 0;
case K of
0:
begin
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
FreeReg(_ECX);
end;
1:
begin
GetReg(_EDX);
EmitLoadAddress(_EDX, SymbolRecR);
FreeReg(_EDX);
end;
else
begin
RaiseError(errInternalError, []);
end;
end;
end //cc64
else
begin
if (GetSymbolRec(TrueSubId).CallConv = ccPASCAL) and
(GetSymbolRec(TrueSubId).IsMethod) then
begin
GetReg(_EDX);
Prg.AsmPop_REG(_EDX);
FreeReg(_EDX);
end;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmPush_REG(Reg);
if (GetSymbolRec(TrueSubId).CallConv = ccPASCAL) and
(GetSymbolRec(TrueSubId).IsMethod) then
begin
GetReg(_EDX);
Prg.AsmPush_REG(_EDX);
FreeReg(_EDX);
end;
end;
end; // extra param needed
if Host1 then
begin
if (SymbolRec1.MethodIndex > 0) and (GetSymbolRec(SymbolRec1.Level).FinalTypeId = typeINTERFACE) then
EmitInterfaceAddress(SymbolRec1.MethodIndex)
else
EmitGet_REG(Reg, SymbolRec1);
end
else
begin
if (SymbolRec1.MethodIndex > 0) and (not DiscardVirtualCall) then
EmitInterfaceAddress(SymbolRec1.MethodIndex)
else if SymbolRec1.Kind = kindVAR then
EmitLoadIntVal(Reg, SymbolRec1)
else
begin
Prg.AsmMovREG_REG(Reg, _EDI);
Prg.AsmAddREG_Imm(Reg, 0);
Prg.Top.SaveSubId := R.Arg1;
List2.Add(Prg.Top);
end;
end;
if SymbolRec1.Kind = KindVAR then
if SymbolRec1.Host then
if SymbolRec1.FinalTypeId = typeEVENT then
begin
Prg.AsmMovREG_REGPtr(Reg, Reg);
end;
if GetSymbolRec(TrueSubId).IsNestedSub then
begin
if ContextStack.Count >= 2 then
begin
if TargetPlatform = tpWin64 then
EmitRestoreEBP(_ECX, GetSymbolRec(TrueSubId))
else
EmitRestoreEBP(_EAX, GetSymbolRec(TrueSubId));
end
else
begin
if TargetPlatform = tpWin64 then
Prg.AsmMovREG_REG(_ECX, _EBP)
else
Prg.AsmMovREG_REG(_EAX, _EBP);
end;
end;
if TargetPlatform in [tpOSX32, tpIOSSim] then
begin
EmitSaveRDI;
Prg.AsmMovREG_REG(_EDI, Reg);
EmitRestoreRBX;
Prg.AsmCall_REG(_EDI);
EmitRestoreRDI;
end
else
Prg.AsmCall_REG(Reg);
EmitCallEpi(TrueSubId);
if not (TargetPlatform in [tpOSX32, tpIOSSim]) then
begin
if SymbolRec1.Kind = KindVAR then
begin
T := SymbolRec1.TerminalTypeId;
K := GetSymbolRec(T).PatternId;
if GetSymbolRec(K).CallConv = ccCDECL then
Prg.AsmAddREG_Imm(_ESP, SymbolTable.GetSizeOfParams(K));
end
else
begin
if SymbolRec1.CallConv = ccCDECL then
Prg.AsmAddREG_Imm(_ESP, SymbolTable.GetSizeOfParams(R.Arg1));
end;
end;
if not SymbolRec1.IsNestedSub then
begin
RestoreRegisters([_ESI, _EDI], 4 * SizeOfPointer);
end;
if R.Res <> 0 then if cc <> ccSAFECALL then
begin
case GetSymbolRec(TrueSubId).FinalTypeId of
typeVOID:
begin
// ok
end;
typeBOOLEAN, typeBYTEBOOL, typeWORDBOOL, typeLONGBOOL,
{$IFNDEF PAXARM}
typeANSICHAR,
{$ENDIF}
typeWIDECHAR, typeENUM, typePOINTER,
typeINTEGER, typeBYTE, typeWORD, typeSMALLINT, typeSHORTINT,
typeCARDINAL, typeCLASS, typeCLASSREF:
begin
if SymbolRec1.CallConv = ccSAFECALL then
begin
RR := FindBeginCall;
if RR = nil then
RaiseError(errInternalError, []);
EmitLoadIntVal(_EAX, GetSymbolRec(RR.Res));
end;
EmitPut_REG(_EAX, SymbolRecR);
end;
typeINT64, typeUINT64:
begin
GetReg(_ECX);
GetReg(_EDX);
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_ECX);
FreeReg(_EDX);
end;
{$IFNDEF PAXARM}
typeANSISTRING:
begin
{$IFDEF FPC}
{
GetReg(_EAX);
Prg.AsmPush_REG(_EAX); // save result of function
EmitLoadAddress(_EAX, SymbolRecR); // load address into EAX
SubId := Id_DecStringCounter;
// SubId := Id_IncStringCounter;
EmitGet_REG(_EBX, TKernel(kernel).SymbolTable[SubId]);
Prg.AsmCall_REG(_EBX);
EmitLoadAddress(_EAX, SymbolRecR); // load address into EAX
Prg.AsmPop_REG(_EBX);
Prg.AsmMovREGPtr_REG(_EAX, _EBX);
FreeReg(_EAX);
}
{$ELSE}
// ok
{$ENDIF}
end;
typeSHORTSTRING:
begin
// ok
end;
typeWIDESTRING:
begin
// ok
end;
{$ENDIF}
typeUNICSTRING:
begin
// ok
end;
typeINTERFACE:
begin
// ok
end;
typeVARIANT, typeOLEVARIANT:
begin
// ok
end;
typeRECORD:
begin
if GetSymbolRec(TrueSubId).CallConv = ccMSFASTCALL then
begin
T := GetSymbolRec(TrueSubId).TerminalTypeId;
if GetSymbolRec(T).Size <= 4 then
begin
EmitPut_REG(_EAX, SymbolRecR);
end
else if GetSymbolRec(T).Size <= 8 then
begin
GetReg(_ECX);
GetReg(_EDX);
EmitLoadAddress(_ECX, SymbolRecR);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_ECX);
FreeReg(_EDX);
end;
end
else
begin
T := GetSymbolRec(TrueSubId).TerminalTypeId;
if GetSymbolRec(T).Size <= SizeOf(Pointer) then
begin
EmitPut_REG(_EAX, SymbolRecR);
end
end;
end;
typeARRAY:
begin
T := GetSymbolRec(TrueSubId).TerminalTypeId;
if GetSymbolRec(T).Size <= SizeOf(Pointer) then
begin
EmitPut_REG(_EAX, SymbolRecR);
end
end;
typeDYNARRAY:
begin
// ok
end;
typeSET:
begin
if not GetSymbolRec(TrueSubId).ExtraParamNeeded then
EmitPut_REG(_EAX, SymbolRecR);
// else - ok
end;
typeDOUBLE:
begin
EmitLoadAddress(Reg, SymbolRecR);
if TargetPlatform = tpWIN64 then
Prg.AsmMovsdRegPtr_XMM(_XMM0, Reg)
else
Prg.AsmFStpDouble_REGPtr(Reg);
end;
typeSINGLE:
begin
EmitLoadAddress(Reg, SymbolRecR);
if TargetPlatform = tpWIN64 then
Prg.AsmMovsdRegPtr_XMM(_XMM0, Reg)
else
Prg.AsmFStpSingle_REGPtr(Reg);
end;
typeEXTENDED:
begin
EmitLoadAddress(Reg, SymbolRecR);
if TargetPlatform = tpWIN64 then
Prg.AsmMovsdRegPtr_XMM(_XMM0, Reg)
else
Prg.AsmFStpExtended_REGPtr(Reg);
end;
typeCURRENCY:
begin
EmitLoadAddress(Reg, SymbolRecR);
EmitFistp(SymbolRecR);
end;
typeEVENT:
begin
// ok
end;
else
RaiseError(errInternalError, []);
end;
end;
FreeReg(Reg);
if TrueSubId = Id_TObject_Free then
begin
I := Code[Code.N - 1].Arg1;
Reg := EmitGetAddressRegister(SymbolTable[I]);
Prg.AsmMovREGPtr_Imm(Reg, SymbolTable[I], 0);
FreeReg(Reg);
end;
if HandlesEvents then
begin
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
if TargetPlatform = tpWIN64 then
Prg.AsmMovREG_REG(_ECX, Reg)
else
Prg.AsmPush_REG(Reg); // push TProgram.Self
EmitGet_REG(Reg, SymbolTable[Id_CondHalt]);
Prg.AsmCall_REG(Reg);
FreeReg(Reg);
end;
end;
procedure TEmitter.EmitOP_INIT_SUB_64;
begin
EmitOP_INIT_SUB;
end;
procedure TEmitter.EmitOP_INIT_SUB;
var
SubId, I, J, T, TypeID, Reg, RegEx, S, ParamId, ParamCount, SZ, FT, SubId2: Integer;
L, TypeList, ProtectedShits: TIntegerList;
HighParamId: Integer;
begin
EmitPCodeOperator;
ProtectedShits := TIntegerList.Create;
try
SubId := R.Arg1;
ParamCount := GetSymbolRec(SubId).Count;
EmitStartSub(SubId);
for I:=0 to ParamCount - 1 do
begin
ParamId := SymbolTable.GetParamId(SubId, I);
if GetSymbolRec(ParamId).Register > 0 then
ProtectedShits.Add(GetSymbolRec(ParamId).Shift);
if GetSymbolRec(ParamId).IsOpenArray then
begin
ParamId := SymbolTable.GetOpenArrayHighId(ParamId);
ProtectedShits.Add(GetSymbolRec(ParamId).Shift);
end;
end;
case TargetPlatform of
tpOSX32, tpIOSSim:
begin
Prg.AsmPush_REG(_EBP);
Prg.AsmPush_REG(_ESI);
Prg.AsmPush_REG(_EDI);
Prg.AsmPush_REG(_EBX);
Prg.AsmMovREG_REG(_EBP, _ESP);
Prg.AsmAddREG_Imm(_ESP, - SymbolTable.GetSizeOfLocalsEx(SubId));
end;
tpWIN64:
begin
Prg.AsmPush_REG(_EBP);
Prg.AsmPush_REG(_ESI);
Prg.AsmPush_REG(_EDI);
Prg.AsmPush_REG(_EBX);
Prg.AsmSubREG_Imm(_ESP, SymbolTable.GetSubRSPSize(SubId));
Prg.AsmMovREG_REG(_EBP, _ESP);
end;
else
begin
Prg.AsmPush_REG(_EBP);
Prg.AsmPush_REG(_ESI);
Prg.AsmPush_REG(_EDI);
Prg.AsmPush_REG(_EBX);
Prg.AsmMovREG_REG(_EBP, _ESP);
Prg.AsmAddREG_Imm(_ESP, - SymbolTable.GetSizeOfLocalsEx(SubId));
end;
end;
Prg.EmitZ;
ContextStack.Push(SubId);
if GetSymbolRec(SubId).CallConv = cc64 then
begin
if SymbolRec1.IsNestedSub then
begin
ParamId := SymbolTable.GetRBP_Id(SubId);
Prg.AsmPutREG_EBPPtr(_ECX, GetOffset(GetSymbolRec(ParamId)));
end;
ParamId := SymbolTable.GetSelfId(SubId);
if GetSymbolRec(ParamId).Register > 0 then
Prg.AsmPutREG_EBPPtr(GetSymbolRec(ParamId).Register, GetOffset(GetSymbolRec(ParamId)));
for I:=0 to GetSymbolRec(SubId).Count - 1 do
begin
ParamId := SymbolTable.GetParamId(SubId, I);
if GetSymbolRec(ParamId).XMMReg > 0 then
begin
Prg.AsmMovREG_REG(_EBX, _EBP);
Prg.AsmAddREG_Imm(_EBX, GetOffset(GetSymbolRec(ParamId)));
if GetSymbolRec(ParamId).FinalTypeId = typeSINGLE then
Prg.AsmMovssRegPtr_XMM(GetSymbolRec(ParamId).XMMReg, _EBX)
else
Prg.AsmMovsdRegPtr_XMM(GetSymbolRec(ParamId).XMMReg, _EBX);
end
else if GetSymbolRec(ParamId).Register > 0 then
begin
Prg.AsmPutREG_EBPPtr(GetSymbolRec(ParamId).Register, GetOffset(GetSymbolRec(ParamId)));
if GetSymbolRec(ParamId).FinalTypeId = typeOPENARRAY then
begin
Reg := GetSymbolRec(ParamId).Register;
HighParamId := SymbolTable.GetOpenArrayHighId(ParamId);
if Reg > 0 then
begin
if Reg <> _R9 then
begin
if Reg = _ECX then
Reg := _EDX
else if Reg = _EDX then
Reg := _R8
else if Reg = _R8 then
Reg := _R9;
Prg.AsmPutREG32_EBPPtr(Reg, GetOffset(GetSymbolRec(HighParamId)));
end
else
begin
Prg.AsmGetREG32_EBPPtr(_EBX, 8);
Prg.AsmPutREG32_EBPPtr(_EBX, GetOffset(GetSymbolRec(HighParamId)));
end;
end;
end;
end
else
if GetSymbolRec(ParamId).FinalTypeId = typeOPENARRAY then
begin
HighParamId := SymbolTable.GetOpenArrayHighId(ParamId);
Prg.AsmGetREG32_EBPPtr(_EBX, GetOffset(GetSymbolRec(ParamId)) - 4);
Prg.AsmPutREG32_EBPPtr(_EBX, GetOffset(GetSymbolRec(HighParamId)));
end;
end;
if GetSymbolRec(SubId).ExtraParamNeeded then
begin
ParamId := SymbolTable.GetResultId(SubId);
RegEx := GetSymbolRec(ParamId).Register;
if RegEx > 0 then
begin
Prg.AsmPutREG_EBPPtr(RegEx, GetOffset(GetSymbolRec(ParamId)));
end
else
begin
RaiseError(errInternalError, []);
end;
end;
end //cc64
else if GetSymbolRec(SubId).CallConv in [ccREGISTER, ccMSFASTCALL] then
begin
ParamId := SymbolTable.GetSelfId(SubId);
if GetSymbolRec(ParamId).Register > 0 then
Prg.AsmPutREG32_EBPPtr(GetSymbolRec(ParamId).Register, GetOffset(GetSymbolRec(ParamId)));
for I:=0 to GetSymbolRec(SubId).Count - 1 do
begin
ParamId := SymbolTable.GetParamId(SubId, I);
if GetSymbolRec(ParamId).Register > 0 then
begin
Prg.AsmPutREG32_EBPPtr(GetSymbolRec(ParamId).Register, GetOffset(GetSymbolRec(ParamId)));
if GetSymbolRec(ParamId).FinalTypeId = typeOPENARRAY then
begin
Reg := GetSymbolRec(ParamId).Register;
HighParamId := SymbolTable.GetOpenArrayHighId(ParamId);
if Reg > 0 then
begin
if Reg <> _ECX then
begin
if Reg = _EAX then
Reg := _EDX
else if Reg = _EDX then
Reg := _ECX;
Prg.AsmPutREG32_EBPPtr(Reg, GetOffset(GetSymbolRec(HighParamId)));
end
else
begin
Prg.AsmGetREG32_EBPPtr(_EBX, 8);
Prg.AsmPutREG32_EBPPtr(_EBX, GetOffset(GetSymbolRec(HighParamId)));
end;
end;
end;
end
else
if GetSymbolRec(ParamId).FinalTypeId = typeOPENARRAY then
begin
HighParamId := SymbolTable.GetOpenArrayHighId(ParamId);
Prg.AsmGetREG32_EBPPtr(_EBX, GetOffset(GetSymbolRec(ParamId)) - 4);
Prg.AsmPutREG32_EBPPtr(_EBX, GetOffset(GetSymbolRec(HighParamId)));
end;
end;
if GetSymbolRec(SubId).ExtraParamNeeded then
begin
ParamId := SymbolTable.GetResultId(SubId);
if GetSymbolRec(ParamId).Register > 0 then
Prg.AsmPutREG32_EBPPtr(GetSymbolRec(ParamId).Register, GetOffset(GetSymbolRec(ParamId)));
end;
end
else if GetSymbolRec(SubId).CallConv in [ccSTDCALL, ccCDECL, ccSAFECALL] then
begin
if SymbolRec1.IsNestedSub then
begin
ParamId := SymbolTable.GetRBP_Id(SubId);
Prg.AsmPutREG_EBPPtr(_EAX, GetSymbolRec(ParamId).Shift);
ProtectedShits.Add(GetSymbolRec(ParamId).Shift);
end;
for I:=0 to GetSymbolRec(SubId).Count - 1 do
begin
ParamId := SymbolTable.GetParamId(SubId, I);
if GetSymbolRec(ParamId).FinalTypeId = typeOPENARRAY then
begin
HighParamId := SymbolTable.GetOpenArrayHighId(ParamId);
Prg.AsmGetREG32_EBPPtr(_EBX, GetOffset(GetSymbolRec(ParamId)) + 4);
Prg.AsmPutREG32_EBPPtr(_EBX, GetOffset(GetSymbolRec(HighParamId)));
end;
end;
end;
// init dynamic vars
for I:=0 to ParamCount - 1 do
begin
ParamId := SymbolTable.GetParamId(SubId, I);
FT := SymbolTable[ParamId].FinalTypeId;
if FT in [typeRECORD, typeARRAY] then
if SymbolTable[I].UnionId = 0 then
if not (SymbolTable[ParamId].ByRef or SymbolTable[ParamId].ByRefEx) then
begin
TypeId := SymbolTable[ParamId].TerminalTypeId;
L := SymbolTable.GetShiftsOfDynamicFields(TypeId);
TypeList := SymbolTable.GetTypesOfDynamicFields(TypeId);
if TypeList.Count <> L.Count then
RaiseError(errInternalError, []);
try
Reg := GetReg;
for J:=0 to L.Count - 1 do
begin
S := L[J];
SubId2 := 0;
case GetSymbolRec(TypeList[J]).FinalTypeId of
{$IFNDEF PAXARM}
typeANSISTRING: SubId2 := Id_StringAddRef;
typeWIDESTRING: SubId2 := Id_WideStringAddRef;
{$ENDIF}
typeUNICSTRING: SubId2 := Id_UnicStringAddRef;
typeVARIANT, typeOLEVARIANT: SubId2 := Id_VariantAddRef;
typeDYNARRAY: SubId2 := Id_DynarrayAddRef;
typeINTERFACE: SubId2 := Id_InterfaceAddRef;
else
RaiseError(errInternalError, []);
end;
EmitCallPro(SubId2);
EmitLoadAddress(Reg, SymbolTable[ParamId]);
Prg.AsmAddREG_Imm(Reg, S);
Prg.AsmPush_REG(Reg);
EmitStdCall(SubId2);
end;
FreeReg(Reg);
finally
FreeAndNil(L);
FreeAndNil(TypeList);
end;
end;
end;
for I:=SubId + 1 to SymbolTable.Card do
begin
if SymbolTable[I].Level = SubId then
if SymbolTable[I].Kind = KindVAR then
begin
if SymbolTable[I].UnionId = 0 then
if (not (SymbolTable[I].ByRef or SymbolTable[I].ByRefEx)) then
begin
if SymbolTable[I].Local and (not SymbolTable[I].Param) then
if ProtectedShits.IndexOf(SymbolTable[I].Shift) = -1 then
begin
T := SymbolTable[I].FinalTypeId;
case T of
{$IFNDEF PAXARM}
typeANSISTRING,
typeWIDESTRING,
{$ENDIF}
typeUNICSTRING,
typeDYNARRAY,
typeINTERFACE,
typeCLASS,
typeCLASSREF:
begin
Reg := EmitGetAddressRegister(SymbolTable[I]);
Prg.AsmMovREGPtr_Imm(Reg, SymbolTable[I], 0);
FreeReg(Reg);
end;
typeSET:
begin
T := SymbolTable[I].TerminalTypeId;
Reg := GetReg;
case SymbolTable.GetSizeOfSetType(T) of
1, 2, 4:
begin
Prg.AsmMovREG_Imm(Reg, 0);
EmitSaveIntVal(Reg, SymbolTable[I]);
end;
else
begin
SZ := SymbolTable.GetSizeOfSetType(T) div 4;
if SZ = 0 then
SZ := 1;
EmitLoadAddress(Reg, SymbolTable[I]);
for J := 1 to SZ do
begin
Prg.AsmMovREGPtr_Imm(Reg, 0);
if J < SZ then
Prg.AsmAddREG_Imm(Reg, 4);
end;
end;
end; // case
FreeReg(Reg);
end;
typeVARIANT, typeOLEVARIANT:
begin
Reg := GetReg;
EmitLoadAddress(Reg, SymbolTable[I]);
Prg.AsmMovREGPtr_Imm(Reg, 0);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmMovREGPtr_Imm(Reg, 0);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmMovREGPtr_Imm(Reg, 0);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmMovREGPtr_Imm(Reg, 0);
FreeReg(Reg);
end;
typeINTEGER,
typeBYTE,
typeSMALLINT,
typeWORD,
typeSHORTINT,
typeCARDINAL,
typePOINTER:
if TKernel(Kernel).DEBUG_MODE then
begin
Reg := EmitGetAddressRegister(SymbolTable[I]);
Prg.AsmMovREGPtr_Imm(Reg, SymbolTable[I], 0);
FreeReg(Reg);
end;
typeSINGLE:
if TKernel(Kernel).DEBUG_MODE then
begin
Reg := GetReg;
EmitLoadAddress(Reg, SymbolTable[I]);
Prg.AsmMovREGPtr_Imm(Reg, 0);
FreeReg(Reg);
end;
typeDOUBLE, typeCURRENCY, typeINT64, typeUINT64:
if TKernel(Kernel).DEBUG_MODE then
begin
Reg := GetReg;
EmitLoadAddress(Reg, SymbolTable[I]);
Prg.AsmMovREGPtr_Imm(Reg, 0);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmMovREGPtr_Imm(Reg, 0);
FreeReg(Reg);
end;
typeEXTENDED:
if TKernel(Kernel).DEBUG_MODE then
begin
Reg := GetReg;
EmitLoadAddress(Reg, SymbolTable[I]);
Prg.AsmMovREGPtr_Imm(Reg, 0);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmMovREGPtr_Imm(Reg, 0);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmMovREGPtr_Imm(Reg, 0);
FreeReg(Reg);
end;
typeRECORD, typeARRAY:
begin
TypeId := SymbolTable[I].TerminalTypeId;
L := SymbolTable.GetShiftsOfDynamicFields(TypeId);
Reg := GetReg;
for J:=0 to L.Count - 1 do
begin
S := L[J];
EmitLoadAddress(Reg, SymbolTable[I]);
Prg.AsmAddREG_Imm(Reg, S);
Prg.AsmMovREGPtr_Imm(Reg, 0);
end;
if TypeId = H_TValue then
begin
EmitLoadAddress(Reg, SymbolTable[I]);
Prg.AsmMovREGPtr_Imm(Reg, 0);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmMovREGPtr_Imm(Reg, 0);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmMovREGPtr_Imm(Reg, 0);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmMovREGPtr_Imm(Reg, 0); //16
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmMovREGPtr_Imm(Reg, 0);
Prg.AsmAddREG_Imm(Reg, 4);
Prg.AsmMovREGPtr_Imm(Reg, 0); // 24
end;
FreeReg(Reg);
FreeAndNil(L);
end;
end;
end; // local
end;
end;
end;
if TargetPlatform in [tpOSX32, tpIOSSim] then
begin
Prg.EmitGetCallerEIP;
EmitSaveRBX;
end;
if TKernel(Kernel).DEBUG_MODE then
begin
Prg.AsmComment('***** N ****** ' + IntToStr(TKernel(kernel).Code.N));
// Prg.AsmMovREGPtr32_Imm(_ESI, H_ByteCodePtr, TKernel(kernel).Code.N);
Emit_PUSH_REGS_EX;
EmitCallPro(Id_InitSub);
if TargetPlatform = tpWin64 then
begin
Prg.AsmMovREG_REG(_ECX, _ESI);
Prg.AsmAddREG_Imm(_ECX, H_SelfPtr);
Prg.AsmMovREG_REGPtr(_ECX, _ECX); // load TProgram.Self
Prg.AsmMovREG_Imm(_EDX, SubId);
Prg.AsmMovREG_REG(_R8, _EBP);
end
else
begin
Prg.AsmMovREG_REG(_EAX, _ESI);
Prg.AsmAddREG_Imm(_EAX, H_SelfPtr);
Prg.AsmMovREG_REGPtr(_EAX, _EAX); // load TProgram.Self
Prg.AsmMovREG_Imm(_EDX, SubId);
Prg.AsmMovREG_REG(_ECX, _EBP);
end;
EmitStdCall(Id_InitSub);
Emit_POP_REGS_EX;
end;
finally
FreeAndNil(ProtectedShits);
end;
end;
procedure TEmitter.EmitOP_END_SUB_64;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_END_SUB;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_FIN_SUB_64;
begin
EmitOP_FIN_SUB;
end;
procedure TEmitter.EmitOP_FIN_SUB;
var
TypeID, ResultId, SubId, Reg,
T, I, J, ParamId, ParamCount, FT, SubId2, S,
ArrayTypeId,
ElTypeId, ElFinalTypeId, ElSize: Integer;
ElTypeId2, ElFinalTypeId2, ElSize2: Integer;
L, TypeList: TIntegerList;
begin
EmitPCodeOperator;
SubId := R.Arg1;
I := SymbolTable[SubId].Level;
if I > 0 then
if SymbolTable[I].FinalTypeId = typeINTERFACE then
Exit;
ParamCount := GetSymbolRec(SubId).Count;
// clear dynamic fields in parameters
for I:=0 to ParamCount - 1 do
begin
ParamId := SymbolTable.GetParamId(SubId, I);
FT := SymbolTable[ParamId].FinalTypeId;
if FT in [typeRECORD, typeARRAY] then
if not (SymbolTable[ParamId].ByRef or SymbolTable[ParamId].ByRefEx) then
begin
TypeId := SymbolTable[ParamId].TerminalTypeId;
L := SymbolTable.GetShiftsOfDynamicFields(TypeId);
TypeList := SymbolTable.GetTypesOfDynamicFields(TypeId);
if TypeList.Count <> L.Count then
RaiseError(errInternalError, []);
try
Reg := GetReg;
for J:=0 to L.Count - 1 do
begin
S := L[J];
SubId2 := 0;
case GetSymbolRec(TypeList[J]).FinalTypeId of
{$IFNDEF PAXARM}
typeANSISTRING: SubId2 := Id_AnsiStringClr;
typeWIDESTRING: SubId2 := Id_WideStringClr;
{$ENDIF}
typeUNICSTRING: SubId2 := Id_UnicStringClr;
typeVARIANT, typeOLEVARIANT: SubId2 := Id_VariantClr;
typeDYNARRAY:
begin
SubId2 := Id_DynarrayClr;
ArrayTypeId := TypeList[J];
ElTypeId := GetSymbolRec(ArrayTypeId).PatternId;
ElFinalTypeId := GetSymbolRec(ElTypeId).FinalTypeId;
ElSize := SymbolTable[ElTypeId].Size;
ElTypeId2 := 0;
ElFinalTypeId2 := 0;
ElSize2 := 0;
if ElFinalTypeId = typeDYNARRAY then
begin
ElTypeId2 := GetSymbolRec(ElTypeId).TerminalTypeId;
ElTypeId2 := GetSymbolRec(ElTypeId2).PatternId;
ElFinalTypeId2 := GetSymbolRec(ElTypeId2).FinalTypeId;
ElSize2 := SymbolTable[ElTypeId2].Size;
end;
Prg.AsmPush_Imm(ElSize2);
Prg.AsmPush_Imm(ElTypeId2);
Prg.AsmPush_Imm(ElFinalTypeId2);
Prg.AsmPush_Imm(ElSize);
Prg.AsmPush_Imm(ElTypeId);
Prg.AsmPush_Imm(ElFinalTypeId);
end;
typeINTERFACE: SubId2 := Id_InterfaceClr;
else
RaiseError(errInternalError, []);
end;
EmitCallPro(SubId2);
EmitLoadAddress(Reg, SymbolTable[ParamId]);
Prg.AsmAddREG_Imm(Reg, S);
Prg.AsmPush_REG(Reg);
EmitStdCall(SubId2);
end;
FreeReg(Reg);
finally
FreeAndNil(L);
FreeAndNil(TypeList);
end;
end;
end;
if TKernel(Kernel).DEBUG_MODE then
begin
EmitCallPro(Id_EndSub);
if TargetPlatform = tpWIN64 then
begin
Prg.AsmMovREG_REG(_ECX, _ESI);
Prg.AsmAddREG_Imm(_ECX, H_SelfPtr);
Prg.AsmMovREG_REGPtr(_ECX, _ECX); // load TProgram.Self
end
else
begin
Prg.AsmMovREG_REG(_EAX, _ESI);
Prg.AsmAddREG_Imm(_EAX, H_SelfPtr);
Prg.AsmMovREG_REGPtr(_EAX, _EAX); // load TProgram.Self
end;
EmitStdCall(Id_EndSub);
end;
TypeID := SymbolRec1.FinalTypeID;
ResultId := SymbolTable.GetResultId(SubId);
if SymbolRec1.Kind = KindCONSTRUCTOR then
begin
ResultId := SymbolTable.GetSelfId(SubId);
EmitGet_REG(_EAX, SymbolTable[ResultId]);
end
else if SymbolRec1.Kind = KindDESTRUCTOR then
begin
// ok
end
else if TypeID in INT64Types then
begin
GetReg(_EAX);
GetReg(_EDX);
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolTable[ResultId]);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end
else if (TypeID = typeRECORD) and
(SymbolRec1.CallConv = ccMSFASTCALL) then
begin
T := SymbolRec1.TerminalTypeId;
if GetSymbolRec(T).Size <= SizeOf(Pointer) then
begin
EmitGet_REG(_EAX, SymbolTable[ResultId]);
end
else if GetSymbolRec(T).Size <= 8 then
begin
GetReg(_EAX);
GetReg(_EDX);
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolTable[ResultId]);
Prg.AsmMovREG32_REGPtr(_EAX, _ECX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREG32_REGPtr(_EDX, _ECX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
end
else if TypeID in (OrdinalTypes +
[
{$IFNDEF PAXARM}
typeANSISTRING, typeWIDESTRING,
{$ENDIF}
typeUNICSTRING, typeVARIANT,
typeOLEVARIANT,
typePOINTER, typeCLASS, typeCLASSREF, typeDYNARRAY,
typeINTERFACE]) then
begin
EmitGet_REG(_EAX, SymbolTable[ResultId]);
end
else if TypeID = typeSET then
begin
if not SymbolTable[SubId].ExtraParamNeeded then
EmitGet_REG(_EAX, SymbolTable[ResultId]);
end
else if TypeID = typeDOUBLE then
begin
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _EBP);
Prg.AsmAddREG_Imm(Reg, GetOffset(SymbolTable[ResultId]));
Prg.AsmFldDouble_REGPtr(Reg);
FreeReg(Reg);
end
else if TypeID = typeSINGLE then
begin
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _EBP);
Prg.AsmAddREG_Imm(Reg, GetOffset(SymbolTable[ResultId]));
Prg.AsmFldSingle_REGPtr(Reg);
FreeReg(Reg);
end
else if TypeID = typeEXTENDED then
begin
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _EBP);
Prg.AsmAddREG_Imm(Reg, GetOffset(SymbolTable[ResultId]));
Prg.AsmFldExtended_REGPtr(Reg);
FreeReg(Reg);
end
else if TypeID = typeCURRENCY then
begin
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _EBP);
Prg.AsmAddREG_Imm(Reg, GetOffset(SymbolTable[ResultId]));
Prg.AsmFild_REG64Ptr(Reg);
FreeReg(Reg);
end;
case TargetPlatform of
tpOSX32, tpIOSSim:
begin
Prg.AsmMovREG_REG(_ESP, _EBP);
Prg.AsmPop_REG(_EBX);
Prg.AsmPop_REG(_EDI);
Prg.AsmPop_REG(_ESI);
Prg.AsmPop_REG(_EBP);
end;
tpWIN64:
begin
// Prg.AsmLeaRSP_RBPPtr(TKernel(kernel).GetSubRSPSize(SubId));
Prg.AsmAddREG_Imm(_ESP, SymbolTable.GetSubRSPSize(SubId));
Prg.AsmPop_REG(_EBX);
Prg.AsmPop_REG(_EDI);
Prg.AsmPop_REG(_ESI);
Prg.AsmPop_REG(_EBP);
end;
else
begin
Prg.AsmMovREG_REG(_ESP, _EBP);
Prg.AsmPop_REG(_EBX);
Prg.AsmPop_REG(_EDI);
Prg.AsmPop_REG(_ESI);
Prg.AsmPop_REG(_EBP);
end;
end;
if SymbolTable[SubId].CallConv = ccCDECL then
Prg.AsmRet(0)
else
begin
if TargetPlatform = tpWIN64 then
Prg.AsmRet(0)
else
Prg.AsmRet(SymbolTable.GetSizeOfParams(R.Arg1));
end;
ContextStack.Pop;
EmitFinSub(SubId);
end;
procedure TEmitter.EmitOP_PUSH_EBP_64;
begin
EmitPCodeOperator;
Prg.AsmMovREG_REG(_ECX, _EBP);
end;
procedure TEmitter.EmitOP_PUSH_EBP;
var
SubId, CurrSubId, Height, CurrHeight, Reg, I, D: Integer;
begin
EmitPCodeOperator;
if ContextStack.Count >= 2 then
begin
SubId := SymbolRecR.Id;
EmitRestoreEBP(_EAX, GetSymbolRec(SubId));
end
else
Prg.AsmMovREG_REG(_EAX, _EBP);
end;
procedure TEmitter.EmitOP_POP_64;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_POP;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_SAVE_REGS_64;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
end;
procedure TEmitter.EmitOP_SAVE_REGS;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
end;
procedure TEmitter.EmitOP_RESTORE_REGS_64;
begin
EmitPCodeOperator;
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_RESTORE_REGS;
begin
EmitPCodeOperator;
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_RET_64;
begin
EmitPCodeOperator;
Prg.AsmRet;
end;
procedure TEmitter.EmitOP_RET;
begin
EmitPCodeOperator;
Prg.AsmRet;
end;
procedure TEmitter.EmitOP_FIELD_64;
var
Reg: Integer;
PatternId: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1); // load address of record
PatternId := SymbolRec2.PatternId; // find id of pattern field
if SymbolRec1.FinalTypeId = typeCLASS then
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmAddREG_Imm(Reg, GetOffset(SymbolTable[PatternId]));
EmitPut_REG(Reg, SymbolRec2);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_FIELD;
var
Reg: Integer;
PatternId: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1); // load address of record
PatternId := SymbolRec2.PatternId; // find id of pattern field
if SymbolRec1.FinalTypeId = typeCLASS then
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmAddREG_Imm(Reg, GetOffset(SymbolTable[PatternId]));
EmitPut_REG(Reg, SymbolRec2);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_GET_COMPONENT_64;
var
Reg: Integer;
SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_GetComponent;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadIntVal(Reg, SymbolRec1); // the first parameter
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_Imm(_EDX, R.Arg2); // the second parameter
EmitLoadAddress(Reg, SymbolRecR); // the third parameter
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_COMPONENT;
var
Reg: Integer;
SubId: Integer;
begin
EmitPCodeOperator;
SubId := Id_GetComponent;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // the third parameter
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(R.Arg2); // the second parameter
EmitLoadIntVal(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ELEM_64;
begin
EmitOP_ELEM;
end;
procedure TEmitter.EmitOP_ELEM;
function LeftPartOfAssignment: Boolean;
var
I, N, Res, Op: Integer;
Code: TCode;
begin
result := false;
Code := TKernel(kernel).Code;
N := Code.N;
Res := Code[N].Res;
I := N;
repeat
Inc(I);
if I > Code.Card then
Exit;
Op := Code[I].GenOp;
if Op = OP_STMT then
Exit;
if Op = OP_ASSIGN then
if Code[I].Arg1 = Res then
begin
result := true;
Exit;
end;
until false;
end;
var
Reg, RegIndex: Integer;
ArrayTypeId, RangeTypeId, ElemTypeId, H1, ElSize: Integer;
IsFWArray: Boolean;
begin
EmitPCodeOperator;
ElemTypeId := SymbolRec2.FinalTypeId;
if not (ElemTypeId in OrdinalTypes + INT64Types) then
TKernel(kernel).CreateError(errIncompatibleTypesNoArgs, []);
{$IFNDEF PAXARM}
if SymbolRec1.HasPAnsiCharType then // pchar
begin
RegIndex := GetReg;
Reg := GetReg;
if SymbolRec2.Kind = KindCONST then
Prg.AsmMovReg_Imm(RegIndex, SymbolRec2.Value)
else
EmitLoadIntVal(RegIndex, SymbolRec2); // RegIndex := <index value>
EmitLoadAddress(Reg, SymbolRec1); // Reg := <address of string>
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmAddREG_REG(Reg, RegIndex); // Reg := Reg + RegIndex
EmitPut_REG(Reg, SymbolTable[R.Res]); // save address
FreeReg(Reg);
FreeReg(RegIndex);
end
else
{$ENDIF}
if SymbolRec1.HasPWideCharType then // pchar
begin
RegIndex := GetReg;
Reg := GetReg;
if SymbolRec2.Kind = KindCONST then
Prg.AsmMovReg_Imm(RegIndex, SymbolRec2.Value)
else
EmitLoadIntVal(RegIndex, SymbolRec2); // RegIndex := <index value>
EmitLoadAddress(Reg, SymbolRec1); // Reg := <address of string>
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmAddREG_REG(Reg, RegIndex); // Reg := Reg + RegIndex
Prg.AsmAddREG_REG(Reg, RegIndex); // Reg := Reg + RegIndex
EmitPut_REG(Reg, SymbolTable[R.Res]); // save address
FreeReg(Reg);
FreeReg(RegIndex);
end
{$IFNDEF PAXARM}
else if SymbolRec1.FinalTypeId = typeANSISTRING then
begin
if LeftPartOfAssignment then
begin
SaveRegisters([_ESI, _EDI]);
EmitCallPro(Id_UniqueAnsiString);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1); // Reg := <address of string>
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(Id_UniqueAnsiString);
RestoreRegisters([_ESI, _EDI]);
end;
RegIndex := GetReg;
Reg := GetReg;
if SymbolRec2.Kind = KindCONST then
begin
Prg.AsmMovReg_Imm(RegIndex, SymbolRec2.Value - 1);
end
else
begin
EmitLoadIntVal(RegIndex, SymbolRec2); // RegIndex := <index value>
Prg.AsmAddReg_Imm(RegIndex, -1);
end;
EmitLoadAddress(Reg, SymbolRec1); // Reg := <address of string>
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmAddREG_REG(Reg, RegIndex); // Reg := Reg + RegIndex
EmitPut_REG(Reg, SymbolTable[R.Res]); // save address
FreeReg(Reg);
FreeReg(RegIndex);
end
{$ENDIF}
else if SymbolRec1.FinalTypeId in [{$IFNDEF PAXARM}typeWIDESTRING,{$ENDIF} typeUNICSTRING] then
begin
if SymbolRec1.FinalTypeId = typeUNICSTRING then
if LeftPartOfAssignment then
begin
SaveRegisters([_ESI, _EDI]);
Reg := GetReg;
EmitCallPro(Id_UniqueUnicString);
EmitLoadAddress(Reg, SymbolRec1); // Reg := <address of string>
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(Id_UniqueUnicString);
RestoreRegisters([_ESI, _EDI]);
end;
RegIndex := GetReg;
Reg := GetReg;
if SymbolRec2.Kind = KindCONST then
begin
Prg.AsmMovReg_Imm(RegIndex, (SymbolRec2.Value - 1) * SizeOf(WideChar));
end
else
begin
EmitLoadIntVal(RegIndex, SymbolRec2); // RegIndex := <index value>
Prg.AsmAddReg_Imm(RegIndex, -1);
Prg.AsmAddREG_REG(RegIndex, RegIndex);
end;
EmitLoadAddress(Reg, SymbolRec1); // Reg := <address of string>
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmAddREG_REG(Reg, RegIndex); // Reg := Reg + RegIndex
EmitPut_REG(Reg, SymbolTable[R.Res]); // save address
FreeReg(Reg);
FreeReg(RegIndex);
end
{$IFNDEF PAXARM}
else if SymbolRec1.FinalTypeId = typeSHORTSTRING then
begin
RegIndex := GetReg;
Reg := GetReg;
EmitLoadIntVal(RegIndex, SymbolRec2); // RegIndex := <index value>
EmitLoadAddress(Reg, SymbolRec1); // Reg := <address of string>
Prg.AsmAddREG_REG(Reg, RegIndex); // Reg := Reg + RegIndex
EmitPut_REG(Reg, SymbolTable[R.Res]); // save address
FreeReg(Reg);
FreeReg(RegIndex);
end
{$ENDIF}
else if (SymbolRec1.FinalTypeId = typeDYNARRAY) or // dynamic array
(SymbolRec1.FinalTypeId = typeOPENARRAY) or
(SymbolRec1.IsFWArrayVar) then
begin
IsFWArray := SymbolRec1.IsFWArrayVar;
ArrayTypeId := SymbolRec1.TerminalTypeId;
ElemTypeId := GetSymbolRec(ArrayTypeId).PatternId;
if IsFWArray then
ElemTypeId := GetSymbolRec(ElemTypeId).PatternId;
ElSize := SymbolTable[ElemTypeId].Size;
// emit
RegIndex := _EAX;
GetReg(RegIndex);
Reg := GetReg;
EmitLoadIntVal(RegIndex, SymbolRec2); // RegIndex := <index value>
Prg.AsmMovREG_Imm(Reg, ElSize); // Reg := <size of element>
Prg.AsmMulREG(Reg); // RegIndex := RegIndex * Reg
EmitLoadAddress(Reg, SymbolRec1); // Reg := <address of array>
if IsFWArray then
begin
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmAddReg_Imm(Reg, FWArrayOffset);
end;
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmAddREG_REG(Reg, RegIndex); // Reg := Reg + RegIndex
EmitPut_REG(Reg, SymbolTable[R.Res]); // save address
FreeReg(Reg);
FreeReg(RegIndex);
end
else // static array
begin
ArrayTypeId := SymbolRec1.TerminalTypeId;
SymbolTable.GetArrayTypeInfo(ArrayTypeId, RangeTypeId, ElemTypeId);
H1 := SymbolTable.GetLowBoundRec(RangeTypeId).Value;
ElSize := SymbolTable[ElemTypeId].Size;
// emit
RegIndex := _EAX;
GetReg(RegIndex);
Reg := GetReg;
EmitLoadIntVal(RegIndex, SymbolRec2); // RegIndex := <index value>
Prg.AsmAddREG_Imm(RegIndex, - H1); // RegIndex := RegIndex - H1
Prg.AsmMovREG_Imm(Reg, ElSize); // Reg := <size of element>
Prg.AsmMulREG(Reg); // RegIndex := RegIndex * Reg
EmitLoadAddress(Reg, SymbolRec1); // Reg := <address of array>
Prg.AsmAddREG_REG(Reg, RegIndex); // Reg := Reg + RegIndex
EmitPut_REG(Reg, SymbolTable[R.Res]); // save address
FreeReg(Reg);
FreeReg(RegIndex);
end;
end;
procedure TEmitter.EmitOP_INT_TO_INT64_64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmCDQ;
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_INT_TO_INT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmCDQ;
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_BYTE_TO_INT64_64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmXorREG_REG(_EDX, _EDX);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_BYTE_TO_INT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmXorREG_REG(_EDX, _EDX);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_WORD_TO_INT64_64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmXorREG_REG(_EDX, _EDX);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_WORD_TO_INT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmXorREG_REG(_EDX, _EDX);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_CARDINAL_TO_INT64_64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmXorREG_REG(_EDX, _EDX);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_CARDINAL_TO_INT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmXorREG_REG(_EDX, _EDX);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SMALLINT_TO_INT64_64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmXorREG_REG(_EDX, _EDX);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SMALLINT_TO_INT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmXorREG_REG(_EDX, _EDX);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SHORTINT_TO_INT64_64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmXorREG_REG(_EDX, _EDX);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SHORTINT_TO_INT64;
begin
EmitPCodeOperator;
GetReg(_ECX);
EmitLoadAddress(_ECX, SymbolRecR);
GetReg(_EAX);
GetReg(_EDX);
EmitLoadIntVal(_EAX, SymbolRec1);
Prg.AsmXorREG_REG(_EDX, _EDX);
Prg.AsmMovREGPtr_REG32(_ECX, _EAX);
Prg.AsmAddREG_Imm(_ECX, 4);
Prg.AsmMovREGPtr_REG32(_ECX, _EDX);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_INT_TO_DOUBLE_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpDouble_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT_TO_DOUBLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpDouble_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT64_TO_DOUBLE_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFild_REG64Ptr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpDouble_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT64_TO_DOUBLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFild_REG64Ptr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpDouble_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT_TO_SINGLE_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpSingle_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT_TO_SINGLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpSingle_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT64_TO_SINGLE_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFild_REG64Ptr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpSingle_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT64_TO_SINGLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFild_REG64Ptr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpSingle_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT_TO_EXTENDED_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpExtended_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT_TO_EXTENDED;
var
Reg: Integer;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpExtended_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT64_TO_EXTENDED_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFild_REG64Ptr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpExtended_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT64_TO_EXTENDED;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFild_REG64Ptr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpExtended_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_DOUBLE_TO_SINGLE_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmCvtsd2ssXMM_RegPtr(_XMM4, Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmMovsdRegPtr_XMM(_XMM4, Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_DOUBLE_TO_SINGLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFldDouble_REGPtr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpSingle_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_DOUBLE_TO_EXTENDED_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmMovsdXMM_RegPtr(_XMM4, Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmMovsdRegPtr_XMM(_XMM4, Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_DOUBLE_TO_EXTENDED;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFldDouble_REGPtr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpExtended_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_EXTENDED_TO_DOUBLE_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmMovsdXMM_RegPtr(_XMM4, Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmMovsdRegPtr_XMM(_XMM4, Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_EXTENDED_TO_DOUBLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFldExtended_REGPtr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpDouble_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_EXTENDED_TO_SINGLE_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmCvtsd2ssXMM_RegPtr(_XMM4, Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmMovsdRegPtr_XMM(_XMM4, Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_EXTENDED_TO_SINGLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFldExtended_REGPtr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpSingle_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_SINGLE_TO_DOUBLE_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmCvtss2sdXMM_RegPtr(_XMM4, Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmMovsdRegPtr_XMM(_XMM4, Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_SINGLE_TO_DOUBLE;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFldSingle_REGPtr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpDouble_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitFDiv_10000;
begin
Prg.AsmFDiv_ESIPtr32(GetOffset(GetSymbolRec(CURR_FMUL_Id)));
end;
procedure TEmitter.EmitFMul_10000;
begin
Prg.AsmFMul_ESIPtr32(GetOffset(GetSymbolRec(CURR_FMUL_Id)));
end;
procedure TEmitter.EmitOP_CURRENCY_TO_DOUBLE_64;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
EmitFDiv_10000;
EmitFstp(SymbolRecR);
end;
procedure TEmitter.EmitOP_CURRENCY_TO_DOUBLE;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
EmitFDiv_10000;
EmitFstp(SymbolRecR);
end;
procedure TEmitter.EmitOP_CURRENCY_TO_SINGLE_64;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
EmitFDiv_10000;
EmitFstp(SymbolRecR);
end;
procedure TEmitter.EmitOP_CURRENCY_TO_SINGLE;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
EmitFDiv_10000;
EmitFstp(SymbolRecR);
end;
procedure TEmitter.EmitOP_CURRENCY_TO_EXTENDED_64;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
EmitFDiv_10000;
EmitFstp(SymbolRecR);
end;
procedure TEmitter.EmitOP_CURRENCY_TO_EXTENDED;
begin
EmitPCodeOperator;
EmitFild(SymbolRec1);
EmitFDiv_10000;
EmitFstp(SymbolRecR);
end;
procedure TEmitter.EmitOP_SINGLE_TO_EXTENDED_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmCvtss2sdXMM_RegPtr(_XMM4, Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmMovsdRegPtr_XMM(_XMM4, Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_SINGLE_TO_EXTENDED;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmFldSingle_REGPtr(Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmFstpExtended_REGPtr(Reg);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_ADDRESS_PROG_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_ADDRESS_PROG;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_ASSIGN_PROG_64;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
Reg := GetRegEx;
SubId := JS_AssignProgId;
EmitCallPro(SubId);
EmitLoadIntVal(Reg, SymbolRecR);
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ASSIGN_PROG;
var
Reg, SubId: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
SubId := JS_AssignProgId;
EmitCallPro(SubId);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRecR);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ADDRESS_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
if SymbolRec1.Kind in KindSUBS then
begin
if Host1 then
EmitGet_REG(Reg, SymbolRec1)
else
begin
Prg.AsmMovREG_REG(Reg, _EDI);
Prg.AsmAddREG_Imm(Reg, 0);
Prg.Top.SaveSubId := R.Arg1;
List2.Add(Prg.Top);
end;
EmitSaveIntVal(Reg, SymbolRecR);
end
else
begin
EmitLoadAddress(Reg, SymbolRec1);
EmitSaveIntVal(Reg, SymbolRecR);
end;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_ADDRESS;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
if SymbolRec1.Kind in KindSUBS then
begin
if Host1 then
EmitGet_REG(Reg, SymbolRec1)
else
begin
Prg.AsmMovREG_REG(Reg, _EDI);
Prg.AsmAddREG_Imm(Reg, 0);
Prg.Top.SaveSubId := R.Arg1;
List2.Add(Prg.Top);
end;
EmitSaveIntVal(Reg, SymbolRecR);
end
else
begin
EmitLoadAddress(Reg, SymbolRec1);
EmitSaveIntVal(Reg, SymbolRecR);
end;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INIT_PCHAR_LITERAL;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, 12);
EmitSaveIntVal(Reg, SymbolRec1);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INIT_PWIDECHAR_LITERAL;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, 8);
EmitSaveIntVal(Reg, SymbolRec1);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_TERMINAL_64;
var
Reg, temp: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
SymbolRecR.ByRef := false;
temp := SymbolRecR.TypeID;
SymbolRecR.TypeID := TypePOINTER;
EmitSaveIntVal(Reg, SymbolRecR);
SymbolRecR.ByRef := true;
SymbolRecR.TypeID := temp;
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_TERMINAL;
var
Reg, temp: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1);
SymbolRecR.ByRef := false;
temp := SymbolRecR.TypeID;
SymbolRecR.TypeID := TypePOINTER;
EmitSaveIntVal(Reg, SymbolRecR);
SymbolRecR.ByRef := true;
SymbolRecR.TypeID := temp;
FreeReg(Reg);
end;
procedure TEmitter.CheckSetElement(S: TSymbolRec);
var
I: Integer;
begin
if S.Kind = KindCONST then
if not IsVarObject(S.Value) then
begin
I := S.Value;
if (I < 0) or (I > 255) then
CreateError(errInvalidSet, []);
end;
end;
procedure TEmitter.EmitOP_SET_INCLUDE_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
CheckSetElement(SymbolRec1);
SubId := Id_SetInclude;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec2); // 2 - par
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_INCLUDE;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
CheckSetElement(SymbolRec2);
SubId := Id_SetInclude;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2); // the second parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_INCLUDE_INTERVAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
CheckSetElement(SymbolRec1);
CheckSetElement(SymbolRec2);
SubId := Id_SetIncludeInterval;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // the first parameter
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec2); // the second parameter
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadIntVal(Reg, SymbolRecR); // the third parameter
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_INCLUDE_INTERVAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
CheckSetElement(SymbolRec1);
CheckSetElement(SymbolRec2);
SubId := Id_SetIncludeInterval;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRecR); // the third parameter
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec2); // the second parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_EXCLUDE_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
CheckSetElement(SymbolRec1);
SubId := Id_SetExclude;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec2); // 2 - par
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_EXCLUDE;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
CheckSetElement(SymbolRec2);
SubId := Id_SetExclude;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2); // the second parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_UNION_64;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetUnion;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // 2 - par
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // 3 - par
Prg.AsmMovREG_REG(_R8, Reg);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovREG_REG(_R9, Reg);
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovRSPPtr_REG64(Reg, $20);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_UNION;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetUnion;
EmitCallPro(SubId);
Reg := GetReg;
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
EmitLoadAddress(Reg, SymbolRecR); // the third parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec2); // the second parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_DIFFERENCE_64;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetDifference;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // 2 - par
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // 3 - par
Prg.AsmMovREG_REG(_R8, Reg);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovREG_REG(_R9, Reg);
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovRSPPtr_REG64(Reg, $20);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_DIFFERENCE;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetDifference;
EmitCallPro(SubId);
Reg := GetReg;
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
EmitLoadAddress(Reg, SymbolRecR); // the third parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec2); // the second parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_INTERSECTION_64;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetIntersection;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // 2 - par
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // 3 - par
Prg.AsmMovREG_REG(_R8, Reg);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovREG_REG(_R9, Reg);
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovRSPPtr_REG64(Reg, $20);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_INTERSECTION;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetIntersection;
EmitCallPro(SubId);
Reg := GetReg;
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
EmitLoadAddress(Reg, SymbolRecR); // the third parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec2); // the second parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_SUBSET_64;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetSubset;
EmitCallPro(SubId);
GetReg(_EAX);
Reg := _EAX;
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // 2 - par
Prg.AsmMovREG_REG(_EDX, Reg);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovREG_REG(_R8, Reg);
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
EmitPut_REG(_EAX, SymbolRecR);
end;
procedure TEmitter.EmitOP_SET_SUBSET;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetSubset;
EmitCallPro(SubId);
GetReg(_EAX);
Reg := _EAX;
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
EmitLoadAddress(Reg, SymbolRec2); // the second parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
EmitPut_REG(_EAX, SymbolRecR);
end;
procedure TEmitter.EmitOP_SET_SUPERSET_64;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetSuperset;
EmitCallPro(SubId);
GetReg(_EAX);
Reg := _EAX;
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // 2 - par
Prg.AsmMovREG_REG(_EDX, Reg);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovREG_REG(_R8, Reg);
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
EmitPut_REG(_EAX, SymbolRecR);
end;
procedure TEmitter.EmitOP_SET_SUPERSET;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetSuperset;
EmitCallPro(SubId);
GetReg(_EAX);
Reg := _EAX;
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
EmitLoadAddress(Reg, SymbolRec2); // the second parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
EmitPut_REG(_EAX, SymbolRecR);
end;
procedure TEmitter.EmitOP_SET_EQUALITY_64;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetEquality;
EmitCallPro(SubId);
GetReg(_EAX);
Reg := _EAX;
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // 2 - par
Prg.AsmMovREG_REG(_EDX, Reg);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovREG_REG(_R8, Reg);
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
EmitPut_REG(_EAX, SymbolRecR);
end;
procedure TEmitter.EmitOP_SET_EQUALITY;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetEquality;
EmitCallPro(SubId);
GetReg(_EAX);
Reg := _EAX;
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
EmitLoadAddress(Reg, SymbolRec2); // the second parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
EmitPut_REG(_EAX, SymbolRecR);
end;
procedure TEmitter.EmitOP_SET_INEQUALITY_64;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetInequality;
EmitCallPro(SubId);
GetReg(_EAX);
Reg := _EAX;
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // 2 - par
Prg.AsmMovREG_REG(_EDX, Reg);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovREG_REG(_R8, Reg);
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmMovREG_Imm(Reg, SZ);
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
EmitPut_REG(_EAX, SymbolRecR);
end;
procedure TEmitter.EmitOP_SET_INEQUALITY;
var
SubId, Reg, T, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetInequality;
EmitCallPro(SubId);
GetReg(_EAX);
Reg := _EAX;
T := SymbolRec2.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
T := SymbolRec1.TerminalTypeId;
SZ := SymbolTable.GetSizeOfSetType(T);
Prg.AsmPush_Imm(SZ);
EmitLoadAddress(Reg, SymbolRec2); // the second parameter
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
EmitPut_REG(_EAX, SymbolRecR);
end;
procedure TEmitter.EmitOP_SET_MEMBERSHIP_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetMembership;
EmitCallPro(SubId);
GetReg(_EAX);
Reg := _EAX;
EmitLoadIntVal(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // 2 - par
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
EmitPut_REG(_EAX, SymbolRecR);
end;
procedure TEmitter.EmitOP_SET_MEMBERSHIP;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_SetMembership;
EmitCallPro(SubId);
GetReg(_EAX);
Reg := _EAX;
EmitLoadAddress(Reg, SymbolRec2); // the second parameter
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // the first parameter
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
EmitPut_REG(_EAX, SymbolRecR);
end;
procedure TEmitter.EmitOP_SET_ASSIGN_64;
var
Reg1, Reg2, TypeId, SetSize: Integer;
begin
EmitPCodeOperator;
GetReg(_ECX);
Reg1 := GetReg;
Reg2 := GetReg;
TypeId := SymbolRec1.TerminalTypeId;
SetSize := TKernel(kernel).SymbolTable.GetSizeOfSetType(TypeId);
EmitLoadAddress(Reg1, SymbolRec1);
EmitLoadAddress(Reg2, SymbolRec2);
Prg.AsmPush_Reg(_ESI);
Prg.AsmPush_Reg(_EDI);
Prg.AsmMovREG_REG(_ESI, Reg2);
Prg.AsmMovREG_REG(_EDI, Reg1);
Prg.AsmMovREG_Imm(_ECX, SetSize);
Prg.AsmRep_MOVSB;
Prg.AsmPop_Reg(_EDI);
Prg.AsmPop_Reg(_ESI);
FreeReg(Reg2);
FreeReg(Reg1);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SET_ASSIGN;
var
Reg1, Reg2, TypeId, SetSize: Integer;
begin
EmitPCodeOperator;
GetReg(_ECX);
Reg1 := GetReg;
Reg2 := GetReg;
TypeId := SymbolRec1.TerminalTypeId;
SetSize := TKernel(kernel).SymbolTable.GetSizeOfSetType(TypeId);
EmitLoadAddress(Reg1, SymbolRec1);
EmitLoadAddress(Reg2, SymbolRec2);
SaveRegisters([_ESI, _EDI]);
Prg.AsmMovREG_REG(_ESI, Reg2);
Prg.AsmMovREG_REG(_EDI, Reg1);
Prg.AsmMovREG_Imm(_ECX, SetSize);
Prg.AsmRep_MOVSB;
RestoreRegisters([_ESI, _EDI]);
FreeReg(Reg2);
FreeReg(Reg1);
FreeReg(_ECX);
end;
procedure TEmitter.EmitOP_SET_COUNTER_ASSIGN_64;
var
Reg, TypeId, SetSize: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
TypeId := SymbolRec2.TerminalTypeId;
SetSize := TKernel(kernel).SymbolTable.GetSizeOfSetType(TypeId);
Prg.AsmMovREG_Imm(Reg, SetSize * 8);
EmitSaveIntVal(Reg, SymbolRec1);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_SET_COUNTER_ASSIGN;
var
Reg, TypeId, SetSize: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
TypeId := SymbolRec2.TerminalTypeId;
SetSize := TKernel(kernel).SymbolTable.GetSizeOfSetType(TypeId);
Prg.AsmMovREG_Imm(Reg, SetSize * 8);
EmitSaveIntVal(Reg, SymbolRec1);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_CREATE_METHOD_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_CreateMethod;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadIntVal(Reg, SymbolRec1); // 1 - par - data
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec2); // 2 - par - code
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_CREATE_METHOD;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_CreateMethod;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec2); // code
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // data
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_TO_JS_OBJECT_64;
var
SubId, Reg, FinTypeId: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := JS_ToObjectId;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // source
Prg.AsmMovREG_REG(_EDX, Reg);
if (SymbolRec1.Kind = kindCONST) and
(SymbolRec1.FinalTypeId in IntegerTypes) then
begin
{
Id := SymbolRec1.Value;
Id := TKernel(kernel).SymbolTable.AddInt64Const(Id).Id;
Prg.AsmPush_Imm(typeINT64);
EmitLoadAddress(Reg, GetSymbolRec(Id)); // source
}
RaiseError(errInternalError, []);
end
else
begin
FinTypeId := GetSymbolRec(R.Arg1).FinalTypeId;
Prg.AsmMovREG_Imm(Reg, FinTypeId);
Prg.AsmMovREG_REG(_R8, Reg);
end;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_TO_JS_OBJECT;
var
SubId, Reg, FinTypeId: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := JS_ToObjectId;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
if (SymbolRec1.Kind = kindCONST) and
(SymbolRec1.FinalTypeId in IntegerTypes) then
begin
{
Id := SymbolRec1.Value;
Id := TKernel(kernel).SymbolTable.AddInt64Const(Id).Id;
Prg.AsmPush_Imm(typeINT64);
EmitLoadAddress(Reg, GetSymbolRec(Id)); // source
}
RaiseError(errInternalError, []);
end
else
begin
FinTypeId := GetSymbolRec(R.Arg1).FinalTypeId;
Prg.AsmPush_Imm(FinTypeId);
EmitLoadAddress(Reg, SymbolRec1); // source
end;
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_GET_NEXTJSPROP_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(JS_GetNextPropId);
end;
procedure TEmitter.EmitOP_GET_NEXTJSPROP;
begin
EmitStdCall_Adr1_Adr2_AdrR(JS_GetNextPropId);
end;
procedure TEmitter.EmitOP_CLEAR_REFERENCES_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := JS_ClearReferencesId;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_CLEAR_REFERENCES;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := JS_ClearReferencesId;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_JS_TYPEOF_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := JS_TypeOfId;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // 1 - par
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // 2 - result
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_JS_TYPEOF;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := JS_TypeOfId;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // 1st arg - object
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_JS_VOID_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := JS_VoidId;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // 1st arg - object
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_JS_VOID;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := JS_VoidId;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // 1st arg - object
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
{$IFNDEF PAXARM}
procedure TEmitter.EmitOP_SHORTSTRING_FROM_PANSICHAR_LITERAL_64;
var
T1, L, L1, L2: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
L2 := Length(SymbolRec2.Value);
if L2 < L1 then
L := L2
else
L := L1;
GetReg(_EAX);
GetReg(_EDX);
GetReg(_ECX);
Prg.AsmMovREG_Imm(_ECX, L);
EmitLoadAddress(_EAX, SymbolRec1); // string dest
Prg.AsmMovREGPtr_REG8(_EAX, _ECX); // s[0] := length
EmitGet_REG(_EDX, SymbolRec2); // pchar source
Prg.AsmPush_REG(_ESI);
Prg.AsmPush_REG(_EDI);
Prg.AsmMovREG_REG(_ESI, _EDX);
Prg.AsmAddREG_Imm(_EAX, 1);
Prg.AsmMovREG_REG(_EDI, _EAX);
Prg.AsmRep_MOVSB;
Prg.AsmPop_REG(_EDI);
Prg.AsmPop_REG(_ESI);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_PANSICHAR_LITERAL;
var
T1, L, L1, L2: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
L2 := Length(SymbolRec2.Value);
if L2 < L1 then
L := L2
else
L := L1;
GetReg(_EAX);
GetReg(_EDX);
GetReg(_ECX);
Prg.AsmMovREG_Imm(_ECX, L);
EmitLoadAddress(_EAX, SymbolRec1); // string dest
Prg.AsmMovREGPtr_REG8(_EAX, _ECX); // s[0] := length
EmitGet_REG(_EDX, SymbolRec2); // pchar source
SaveRegisters([_ESI, _EDI]);
Prg.AsmMovREG_REG(_ESI, _EDX);
Prg.AsmAddREG_Imm(_EAX, 1);
Prg.AsmMovREG_REG(_EDI, _EAX);
Prg.AsmRep_MOVSB;
RestoreRegisters([_ESI, _EDI]);
FreeReg(_EAX);
FreeReg(_EDX);
FreeReg(_ECX);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_PWIDECHAR_LITERAL_64;
var
T1, L1, SubId, Reg: Integer;
begin
SubId := Id_ShortStringFromPWideChar;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_ECX, Reg);
//
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
Prg.AsmMovREG_Imm(Reg, L1);
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_REG(_R8, Reg);
EmitGet_REG(Reg, SymbolRec2); // pwidechar source
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_PWIDECHAR_LITERAL;
var
T1, L1, SubId, Reg: Integer;
begin
SubId := Id_ShortStringFromPWideChar;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
Reg := GetReg;
EmitGet_REG(Reg, SymbolRec2); // pwidechar source
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(L1);
Prg.AsmPush_Imm(L1);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
{$ENDIF}
procedure TEmitter.EmitOP_WIDESTRING_FROM_PANSICHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_WideStringFromPAnsiChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_PANSICHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_WideStringFromPAnsiChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_PANSICHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_UnicStringFromPAnsiChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_ECX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_PANSICHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_UnicStringFromPAnsiChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_PWIDECHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_WideStringFromPWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_PWIDECHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_WideStringFromPWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_PWIDECHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_UnicStringFromPWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_PWIDECHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_UnicStringFromPWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_VARIANT_FROM_PANSICHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_VariantFromPAnsiChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // variant dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_VARIANT_FROM_PANSICHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_VariantFromPAnsiChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // variant dest
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_VARIANT_FROM_PWIDECHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_VariantFromPWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // variant dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_VARIANT_FROM_PWIDECHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_VariantFromPWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // variant dest
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_PANSICHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_OleVariantFromPAnsiChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // variant dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_PANSICHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_OleVariantFromPAnsiChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // variant dest
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_PWIDECHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_OleVariantFromPWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // variant dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_PWIDECHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_OleVariantFromPWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // variant dest
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
{$IFNDEF PAXARM}
procedure TEmitter.EmitOP_SHORTSTRING_FROM_ANSISTRING_64;
var
T1, L1, SubId, Reg: Integer;
begin
SubId := Id_ShortStringFromAnsiString;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
Reg := GetRegEx;
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_Imm(Reg, L1);
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_REG(_R8, Reg);
EmitLoadAddress(Reg, SymbolRec2); // string source
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_ANSISTRING;
var
T1, L1, SubId, Reg: Integer;
begin
SubId := Id_ShortStringFromAnsiString;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec2); // string source
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(L1);
Prg.AsmPush_Imm(L1);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_WIDESTRING_64;
var
T1, L1, SubId, Reg: Integer;
begin
SubId := Id_ShortStringFromWideString;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
Reg := GetRegEx;
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_Imm(Reg, L1);
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_REG(_R8, Reg);
EmitLoadAddress(Reg, SymbolRec2); // string source
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_WIDESTRING;
var
T1, L1, SubId, Reg: Integer;
begin
SubId := Id_ShortStringFromWideString;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec2); // string source
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(L1);
Prg.AsmPush_Imm(L1);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_UNICSTRING_64;
var
T1, L1, SubId, Reg: Integer;
begin
SubId := Id_ShortStringFromUnicString;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
Reg := GetRegEx;
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_Imm(Reg, L1);
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_REG(_R8, Reg);
EmitLoadAddress(Reg, SymbolRec2); // string source
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_UNICSTRING;
var
T1, L1, SubId, Reg: Integer;
begin
SubId := Id_ShortStringFromUnicString;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec2); // string source
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(L1);
Prg.AsmPush_Imm(L1);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
{$ENDIF}
procedure TEmitter.EmitOP_ANSISTRING_FROM_SHORTSTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_AnsiStringFromShortString);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_SHORTSTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_AnsiStringFromShortString);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_WIDESTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_UnicStringFromWideString);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_WIDESTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_UnicStringFromWideString);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_SHORTSTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_WideStringFromShortString);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_SHORTSTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_WideStringFromShortString);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_UNICSTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_WideStringFromUnicString);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_UNICSTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_WideStringFromUnicString);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_SHORTSTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_UnicStringFromShortString);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_SHORTSTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_UnicStringFromShortString);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_WIDESTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_AnsiStringFromWideString);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_WIDESTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_AnsiStringFromWideString);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_UNICSTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_AnsiStringFromUnicString);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_UNICSTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_AnsiStringFromUnicString);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_ANSISTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_WideStringFromAnsiString);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_ANSISTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_WideStringFromAnsiString);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_ANSISTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_UnicStringFromAnsiString);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_ANSISTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_UnicStringFromAnsiString);
end;
procedure TEmitter.EmitOP_INTERFACE_CAST_64;
var
SubId, Reg: Integer;
GuidId: Integer;
begin
EmitPCodeOperator;
SubId := Id_InterfaceCast;
EmitCallPro(SubId);
GuidId := SymbolRec2.TerminalTypeId + 1;
EmitPCodeOperator;
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRecR); // interface dest
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, GetSymbolRec(GuidId));
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // interface source
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_INTERFACE_CAST;
var
SubId, Reg: Integer;
GuidId: Integer;
begin
EmitPCodeOperator;
SubId := Id_InterfaceCast;
GuidId := SymbolRec2.TerminalTypeId + 1;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1); // interface source
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, GetSymbolRec(GuidId));
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRecR); // interface dest
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_INTERFACE_FROM_CLASS_64;
var
SubId, Reg: Integer;
GuidId: Integer;
begin
SubId := Id_InterfaceFromClass;
GuidId := SymbolRec1.TerminalTypeId + 1;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // interface dest
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, GetSymbolRec(GuidId));
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // object
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_INTERFACE_FROM_CLASS;
var
SubId, Reg: Integer;
GuidId: Integer;
begin
SubId := Id_InterfaceFromClass;
GuidId := SymbolRec1.TerminalTypeId + 1;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec2); // object
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, GetSymbolRec(GuidId));
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // interface dest
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_ASSIGN_INTERFACE_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_InterfaceAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_INTERFACE;
begin
EmitStdCall_Adr1_from_Adr2(Id_InterfaceAssign);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_CLASS_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromClass);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_CLASS;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromClass);
end;
procedure TEmitter.EmitOP_CLASS_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_ClassFromVariant);
end;
procedure TEmitter.EmitOP_CLASS_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_ClassFromVariant);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_POINTER_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromPointer);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_POINTER;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromPointer);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_ANSISTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromAnsiString);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_ANSISTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromAnsiString);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_ANSISTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromAnsiString);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_ANSISTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromAnsiString);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_VARIANT_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromVariant);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_VARIANT;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromVariant);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_WIDESTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromWideString);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_WIDESTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromWideString);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_UNICSTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromUnicString);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_UNICSTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromUnicString);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_WIDESTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromWideString);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_WIDESTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromWideString);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_UNICSTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromUnicString);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_UNICSTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromUnicString);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_SHORTSTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromShortString);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_SHORTSTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromShortString);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_SHORTSTRING_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromShortString);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_SHORTSTRING;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromShortString);
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_ANSICHAR_64;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
Prg.AsmMovREG_Imm(Reg2, 1);
EmitLoadAddress(Reg1, SymbolRec1); // string dest
Prg.AsmMovREGPtr_REG8(Reg1, Reg2); // s[0] := length
EmitGet_REG(Reg2, SymbolRec2); // char
Prg.AsmAddREG_Imm(Reg1, 1);
Prg.AsmMovREGPtr_REG8(Reg1, Reg2);
FreeReg(Reg1);
FreeReg(Reg2);
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_ANSICHAR;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
Prg.AsmMovREG_Imm(Reg2, 1);
EmitLoadAddress(Reg1, SymbolRec1); // string dest
Prg.AsmMovREGPtr_REG8(Reg1, Reg2); // s[0] := length
EmitGet_REG(Reg2, SymbolRec2); // char
Prg.AsmAddREG_Imm(Reg1, 1);
Prg.AsmMovREGPtr_REG8(Reg1, Reg2);
FreeReg(Reg1);
FreeReg(Reg2);
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_WIDECHAR_64;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
Prg.AsmMovREG_Imm(Reg2, 1);
EmitLoadAddress(Reg1, SymbolRec1); // string dest
Prg.AsmMovREGPtr_REG8(Reg1, Reg2); // s[0] := length
EmitGet_REG(Reg2, SymbolRec2); // char
Prg.AsmAddREG_Imm(Reg1, 1);
Prg.AsmMovREGPtr_REG8(Reg1, Reg2);
FreeReg(Reg1);
FreeReg(Reg2);
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_WIDECHAR;
var
Reg1, Reg2: Integer;
begin
EmitPCodeOperator;
Reg1 := GetReg;
Reg2 := GetReg;
Prg.AsmMovREG_Imm(Reg2, 1);
EmitLoadAddress(Reg1, SymbolRec1); // string dest
Prg.AsmMovREGPtr_REG8(Reg1, Reg2); // s[0] := length
EmitGet_REG(Reg2, SymbolRec2); // char
Prg.AsmAddREG_Imm(Reg1, 1);
Prg.AsmMovREGPtr_REG8(Reg1, Reg2);
FreeReg(Reg1);
FreeReg(Reg2);
end;
procedure TEmitter.EmitOP_BEGIN_CRT_JS_FUNC_OBJECT_64;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_BEGIN_CRT_JS_FUNC_OBJECT;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_END_CRT_JS_FUNC_OBJECT_64;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_END_CRT_JS_FUNC_OBJECT;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_LOAD_PROC_64;
var
SubId, Reg, SubShift, OverCount: Integer;
begin
EmitPCodeOperator;
Prg.AsmSubReg_Imm(_ESP, $100);
Emit_PUSH_REGS;
SubId := Id_LoadProc;
EmitCallPro(SubId);
SymbolRec1.Host := true;
SubShift := GetOffset(SymbolRec1);
OverCount := SymbolRec1.OverCount;
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_Imm(Reg, SubShift);
Prg.AsmMovREG_REG(_EDX, Reg);
EmitGet_REG(Reg, SymbolRec2); // proc name (pchar const)
Prg.AsmMovREG_REG(_R8, Reg);
EmitGet_REG(Reg, SymbolRecR); // dll name (pchar const)
Prg.AsmMovREG_REG(_R9, Reg);
Prg.AsmMovREG_Imm(Reg, OverCount);
Prg.AsmMovRSPPtr_REG64(Reg, $20);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
Prg.AsmAddReg_Imm(_ESP, $100);
end;
procedure TEmitter.EmitOP_LOAD_PROC;
var
SubId, Reg, SubShift, OverCount: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_LoadProc;
EmitCallPro(SubId);
SymbolRec1.Host := true;
SubShift := GetOffset(SymbolRec1);
OverCount := SymbolRec1.OverCount;
Reg := GetRegEx;
Prg.AsmPush_Imm(OverCount);
EmitGet_REG(Reg, SymbolRecR); // dll name (pchar const)
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // proc name (pchar const)
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(SubShift);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_ADD_MESSAGE_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_AddMessage;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec2); // message id
Prg.AsmMovREG_REG(_EDX, Reg);
EmitGet_REG(Reg, SymbolRecR); // FullName (pchar const)
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ADD_MESSAGE;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_AddMessage;
EmitCallPro(SubId);
Reg := GetReg;
EmitGet_REG(Reg, SymbolRecR); // FullName (pchar const)
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec2); // message id
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_VAR_FROM_TVALUE_64;
var
SubId, Reg, T: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_VarFromTValue;
EmitCallPro(SubId);
if SubId <= 0 then
RaiseError(errInternalError, []);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmMovREG_REG(_ECX, Reg);
T := SymbolRec1.FinalTypeId;
Prg.AsmMovREG_Imm(Reg, T);
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // dest
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_VAR_FROM_TVALUE;
var
SubId, Reg, T: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_VarFromTValue;
EmitCallPro(SubId);
if SubId <= 0 then
RaiseError(errInternalError, []);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // dest
Prg.AsmPush_REG(Reg);
T := SymbolRec1.FinalTypeId;
Prg.AsmPush_Imm(T);
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_PANSICHAR_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_AnsiStringFromPAnsiChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_PANSICHAR;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_AnsiStringFromPAnsiChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_PWIDECHAR_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_AnsiStringFromPWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_PWIDECHAR;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_AnsiStringFromPWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // pchar source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_ERR_ABSTRACT_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_ErrAbstract;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec1); // pchar source
Prg.AsmMovREG_REG(_ECX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ERR_ABSTRACT;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_ErrAbstract;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitGet_REG(Reg, SymbolRec1); // pchar source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_ANSICHAR_64;
begin
EmitStdCall_Adr1_from_Int2(Id_AnsiStringFromAnsiChar);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_ANSICHAR;
begin
EmitStdCall_Adr1_from_Int2(Id_AnsiStringFromAnsiChar);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_ANSICHAR_64;
begin
EmitStdCall_Adr1_from_Int2(Id_WideStringFromAnsiChar);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_ANSICHAR;
begin
EmitStdCall_Adr1_from_Int2(Id_WideStringFromAnsiChar);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_ANSICHAR_64;
begin
EmitStdCall_Adr1_from_Int2(Id_UnicStringFromAnsiChar);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_ANSICHAR;
begin
EmitStdCall_Adr1_from_Int2(Id_UnicStringFromAnsiChar);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_ANSICHAR_64;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromAnsiChar);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_ANSICHAR;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromAnsiChar);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_ANSICHAR_64;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromAnsiChar);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_ANSICHAR;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromAnsiChar);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_INT_64;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromInt);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_INT;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromInt);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_INT_64;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromInt);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_INT;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromInt);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_INTERFACE_64;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromInterface);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_INTERFACE;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromInterface);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_INTERFACE_64;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromInterface);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_INTERFACE;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromInterface);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_INT64_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromInt64);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_INT64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromInt64);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_INT64_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromInt64);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_INT64;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromInt64);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_BYTE_64;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromByte);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_BYTE;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromByte);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_BYTE_64;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromByte);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_BYTE;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromByte);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_BOOL_64;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromBool);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_BOOL;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromBool);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_BOOL_64;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromBool);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_BOOL;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromBool);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_WORD_64;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromWord);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_WORD;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromWord);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_WORD_64;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromWord);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_WORD;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromWord);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_CARDINAL_64;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromCardinal);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_CARDINAL;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromCardinal);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_CARDINAL_64;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromCardinal);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_CARDINAL;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromCardinal);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_SMALLINT_64;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromSmallInt);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_SMALLINT;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromSmallInt);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_SMALLINT_64;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromSmallInt);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_SMALLINT;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromSmallInt);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_SHORTINT_64;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromShortInt);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_SHORTINT;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromShortInt);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_SHORTINT_64;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromShortInt);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_SHORTINT;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromShortInt);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_DOUBLE_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromDouble);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_DOUBLE;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromDouble);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_DOUBLE_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromDouble);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_DOUBLE;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromDouble);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_CURRENCY_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromCurrency);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_CURRENCY;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromCurrency);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_CURRENCY_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromCurrency);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_CURRENCY;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromCurrency);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_SINGLE_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromSingle);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_SINGLE;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromSingle);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_SINGLE_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromSingle);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_SINGLE;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromSingle);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_EXTENDED_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromExtended);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_EXTENDED;
begin
EmitStdCall_Adr1_from_Adr2(Id_VariantFromExtended);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_EXTENDED_64;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromExtended);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_EXTENDED;
begin
EmitStdCall_Adr1_from_Adr2(Id_OleVariantFromExtended);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_INT_64; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromInt);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_INT; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromInt);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_DOUBLE_64; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromDouble);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_DOUBLE; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromDouble);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_SINGLE_64; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromSingle);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_SINGLE; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromSingle);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_EXTENDED_64; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromExtended);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_EXTENDED; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromExtended);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_BOOLEAN_64; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromBoolean);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_BOOLEAN; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromBoolean);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_INT_64; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromInt);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_INT; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromInt);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_DOUBLE_64; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromDouble);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_DOUBLE; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromDouble);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_SINGLE_64; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromSingle);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_SINGLE; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromSingle);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_EXTENDED_64; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromExtended);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_EXTENDED; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromExtended);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_BOOLEAN_64; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromBoolean);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_BOOLEAN; // JS only
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromBoolean);
end;
procedure TEmitter.EmitOP_JS_FUNC_OBJ_FROM_VARIANT_64; // JS only
begin
EmitStdCall_Adr1_AdrR(Id_FuncObjFromVariant);
end;
procedure TEmitter.EmitOP_JS_FUNC_OBJ_FROM_VARIANT; // JS only
begin
EmitStdCall_Adr1_AdrR(Id_FuncObjFromVariant);
end;
procedure TEmitter.EmitOP_ANSICHAR_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiCharFromVariant);
end;
procedure TEmitter.EmitOP_ANSICHAR_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiCharFromVariant);
end;
procedure TEmitter.EmitOP_WIDECHAR_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_WideCharFromVariant);
end;
procedure TEmitter.EmitOP_WIDECHAR_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_WideCharFromVariant);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromVariant);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringFromVariant);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_WideStringFromVariant);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_WideStringFromVariant);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromVariant);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringFromVariant);
end;
{$IFNDEF PAXARM}
procedure TEmitter.EmitOP_SHORTSTRING_FROM_VARIANT_64;
var
T1, L1, SubId, Reg: Integer;
begin
SubId := Id_ShortStringFromVariant;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
Reg := GetRegEx;
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_Imm(Reg, L1);
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_REG(_R8, Reg);
EmitLoadAddress(Reg, SymbolRec2); // string source
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SHORTSTRING_FROM_VARIANT;
var
T1, L1, SubId, Reg: Integer;
begin
SubId := Id_ShortStringFromVariant;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec2); // string source
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(L1);
Prg.AsmPush_Imm(L1);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
{$ENDIF}
procedure TEmitter.EmitOP_DOUBLE_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_DoubleFromVariant);
end;
procedure TEmitter.EmitOP_DOUBLE_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_DoubleFromVariant);
end;
procedure TEmitter.EmitOP_CURRENCY_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_CurrencyFromVariant);
end;
procedure TEmitter.EmitOP_CURRENCY_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_CurrencyFromVariant);
end;
procedure TEmitter.EmitOP_SINGLE_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_SingleFromVariant);
end;
procedure TEmitter.EmitOP_SINGLE_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_SingleFromVariant);
end;
procedure TEmitter.EmitOP_EXTENDED_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_ExtendedFromVariant);
end;
procedure TEmitter.EmitOP_EXTENDED_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_ExtendedFromVariant);
end;
procedure TEmitter.EmitOP_INT_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_IntFromVariant);
end;
procedure TEmitter.EmitOP_INT_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_IntFromVariant);
end;
procedure TEmitter.EmitOP_INT64_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_Int64FromVariant);
end;
procedure TEmitter.EmitOP_INT64_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_Int64FromVariant);
end;
procedure TEmitter.EmitOP_INT_FROM_INT64_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_INT_FROM_INT64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_BYTE_FROM_INT64_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_BYTE_FROM_INT64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_WORD_FROM_INT64_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_WORD_FROM_INT64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_CARDINAL_FROM_INT64_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_CARDINAL_FROM_INT64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_SMALLINT_FROM_INT64_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_SMALLINT_FROM_INT64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_SHORTINT_FROM_INT64_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_SHORTINT_FROM_INT64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_BYTE_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_ByteFromVariant);
end;
procedure TEmitter.EmitOP_BYTE_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_ByteFromVariant);
end;
procedure TEmitter.EmitOP_WORD_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_WordFromVariant);
end;
procedure TEmitter.EmitOP_WORD_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_WordFromVariant);
end;
procedure TEmitter.EmitOP_CARDINAL_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_CardinalFromVariant);
end;
procedure TEmitter.EmitOP_CARDINAL_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_CardinalFromVariant);
end;
procedure TEmitter.EmitOP_SMALLINT_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_SmallIntFromVariant);
end;
procedure TEmitter.EmitOP_SMALLINT_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_SmallIntFromVariant);
end;
procedure TEmitter.EmitOP_SHORTINT_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_ShortIntFromVariant);
end;
procedure TEmitter.EmitOP_SHORTINT_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_ShortIntFromVariant);
end;
procedure TEmitter.EmitOP_BOOL_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_BoolFromVariant);
end;
procedure TEmitter.EmitOP_BOOL_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_BoolFromVariant);
end;
procedure TEmitter.EmitOP_BOOL_FROM_BYTEBOOL;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
Prg.AsmCmpREG_Imm(Reg, 0);
Prg.AsmJZ_Imm(5);
Prg.AsmMovREG_Imm(Reg, 1);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_BOOL_FROM_BYTEBOOL_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetRegEx;
EmitLoadIntVal(Reg, SymbolRec2);
Prg.AsmCmpREG_Imm(Reg, 0);
Prg.AsmJZ_Imm(10);
Prg.AsmMovREG_Imm(Reg, 1);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_BOOL_FROM_WORDBOOL;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
Prg.AsmCmpREG_Imm(Reg, 0);
Prg.AsmJZ_Imm(5);
Prg.AsmMovREG_Imm(Reg, 1);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_BOOL_FROM_WORDBOOL_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetRegEx;
EmitLoadIntVal(Reg, SymbolRec2);
Prg.AsmCmpREG_Imm(Reg, 0);
Prg.AsmJZ_Imm(10);
Prg.AsmMovREG_Imm(Reg, 1);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_BOOL_FROM_LONGBOOL;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2);
Prg.AsmCmpREG_Imm(Reg, 0);
Prg.AsmJZ_Imm(5);
Prg.AsmMovREG_Imm(Reg, 1);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_BOOL_FROM_LONGBOOL_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetRegEx;
EmitLoadIntVal(Reg, SymbolRec2);
Prg.AsmCmpREG_Imm(Reg, 0);
Prg.AsmJZ_Imm(10);
Prg.AsmMovREG_Imm(Reg, 1);
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_BYTEBOOL_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_ByteBoolFromVariant);
end;
procedure TEmitter.EmitOP_BYTEBOOL_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_ByteBoolFromVariant);
end;
procedure TEmitter.EmitOP_WORDBOOL_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_WordBoolFromVariant);
end;
procedure TEmitter.EmitOP_WORDBOOL_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_WordBoolFromVariant);
end;
procedure TEmitter.EmitOP_LONGBOOL_FROM_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_LongBoolFromVariant);
end;
procedure TEmitter.EmitOP_LONGBOOL_FROM_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_LongBoolFromVariant);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_WIDECHAR_64;
begin
EmitStdCall_Adr1_from_Int2(Id_WideStringFromWideChar);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_WIDECHAR;
begin
EmitStdCall_Adr1_from_Int2(Id_WideStringFromWideChar);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_WIDECHAR_64;
begin
EmitStdCall_Adr1_from_Int2(Id_UnicStringFromWideChar);
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_WIDECHAR;
begin
EmitStdCall_Adr1_from_Int2(Id_UnicStringFromWideChar);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_WIDECHAR_64;
begin
EmitStdCall_Adr1_from_Int2(Id_AnsiStringFromWideChar);
end;
procedure TEmitter.EmitOP_ANSISTRING_FROM_WIDECHAR;
begin
EmitStdCall_Adr1_from_Int2(Id_AnsiStringFromWideChar);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_WIDECHAR_64;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromWideChar);
end;
procedure TEmitter.EmitOP_VARIANT_FROM_WIDECHAR;
begin
EmitStdCall_Adr1_from_Int2(Id_VariantFromWideChar);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_WIDECHAR_64;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromWideChar);
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_WIDECHAR;
begin
EmitStdCall_Adr1_from_Int2(Id_OleVariantFromWideChar);
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_WIDECHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_WideStringFromWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovReg_Imm(Reg, SymbolRec2.Value); // widechar walue
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_WIDESTRING_FROM_WIDECHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_WideStringFromWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(SymbolRec2.Value); // widechar walue
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_WIDECHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_UnicStringFromWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_Imm(Reg, SymbolRec2.Value); // widechar walue
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_UNICSTRING_FROM_WIDECHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_UnicStringFromWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(SymbolRec2.Value); // widechar walue
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_VARIANT_FROM_WIDECHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_VariantFromWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmPush_Imm(SymbolRec2.Value); // widechar walue
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_VARIANT_FROM_WIDECHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_VariantFromWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(SymbolRec2.Value); // widechar walue
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_WIDECHAR_LITERAL_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_OleVariantFromWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmPush_Imm(SymbolRec2.Value); // widechar walue
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_OLEVARIANT_FROM_WIDECHAR_LITERAL;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
SubId := Id_OleVariantFromWideChar;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // string dest
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(SymbolRec2.Value); // widechar walue
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_ASSIGN_VARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_VariantAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_VARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_VariantAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_OLEVARIANT_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_OleVariantAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_OLEVARIANT;
begin
EmitStdCall_AdrR_from_Adr2(Id_OleVariantAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_CLASS_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_ClassAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_CLASS;
begin
EmitStdCall_AdrR_from_Adr2(Id_ClassAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_ANSISTRING_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_ANSISTRING;
begin
EmitStdCall_AdrR_from_Adr2(Id_AnsiStringAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_WIDESTRING_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_WideStringAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_WIDESTRING;
begin
EmitStdCall_AdrR_from_Adr2(Id_WideStringAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_UNICSTRING_64;
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringAssign);
end;
procedure TEmitter.EmitOP_ASSIGN_UNICSTRING;
begin
EmitStdCall_AdrR_from_Adr2(Id_UnicStringAssign);
end;
{$IFNDEF PAXARM}
procedure TEmitter.EmitOP_ASSIGN_SHORTSTRING_64;
var
L, T, SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_ShortStringAssign;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec2); // string source
Prg.AsmMovREG_REG(_ECX, Reg);
T := SymbolRecR.TerminalTypeID;
if T = typeSHORTSTRING then
L := 255
else
L := GetSymbolRec(T).Count;
Prg.AsmMovREG_Imm(Reg, L);
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // string dest
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ASSIGN_SHORTSTRING;
var
L, T, SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_ShortStringAssign;
EmitCallPro(SubId);
T := SymbolRecR.TerminalTypeID;
if T = typeSHORTSTRING then
L := 255
else
L := GetSymbolRec(T).Count;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // string dest
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(L);
EmitLoadAddress(Reg, SymbolRec2); // string source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
{$ENDIF}
procedure TEmitter.EmitOP_ADD_ANSISTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringAddition);
end;
procedure TEmitter.EmitOP_ADD_ANSISTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringAddition);
end;
procedure TEmitter.EmitOP_ADD_WIDESTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringAddition);
end;
procedure TEmitter.EmitOP_ADD_WIDESTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringAddition);
end;
procedure TEmitter.EmitOP_ADD_UNICSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringAddition);
end;
procedure TEmitter.EmitOP_ADD_UNICSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringAddition);
end;
procedure TEmitter.EmitOP_ADD_SHORTSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringAddition);
end;
procedure TEmitter.EmitOP_ADD_SHORTSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringAddition);
end;
procedure TEmitter.EmitOP_MULT_INT64_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64Multiplication);
end;
procedure TEmitter.EmitOP_MULT_INT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64Multiplication);
end;
procedure TEmitter.EmitOP_IDIV_INT64_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64Division);
end;
procedure TEmitter.EmitOP_IDIV_INT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64Division);
end;
procedure TEmitter.EmitOP_MOD_INT64_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64Modulo);
end;
procedure TEmitter.EmitOP_MOD_INT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64Modulo);
end;
procedure TEmitter.EmitOP_SHL_INT64_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64LeftShift);
end;
procedure TEmitter.EmitOP_SHL_INT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64LeftShift);
end;
procedure TEmitter.EmitOP_SHR_INT64_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64RightShift);
end;
procedure TEmitter.EmitOP_SHR_INT64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_Int64RightShift);
end;
procedure TEmitter.EmitOP_NEG_VARIANT_64;
begin
EmitStdCall_Adr1_AdrR(Id_VariantNegation);
end;
procedure TEmitter.EmitOP_NEG_VARIANT;
begin
EmitStdCall_Adr1_AdrR(Id_VariantNegation);
end;
procedure TEmitter.EmitOP_ABS_VARIANT_64;
begin
EmitStdCall_Adr1_AdrR(Id_VariantAbs);
end;
procedure TEmitter.EmitOP_ABS_VARIANT;
begin
EmitStdCall_Adr1_AdrR(Id_VariantAbs);
end;
procedure TEmitter.EmitOP_ABS_INT64_64;
begin
EmitStdCall_Adr1_AdrR(Id_Int64Abs);
end;
procedure TEmitter.EmitOP_ABS_INT64;
begin
EmitStdCall_Adr1_AdrR(Id_Int64Abs);
end;
procedure TEmitter.EmitOP_NOT_VARIANT_64;
begin
EmitStdCall_Adr1_AdrR(Id_VariantNot);
end;
procedure TEmitter.EmitOP_NOT_VARIANT;
begin
EmitStdCall_Adr1_AdrR(Id_VariantNot);
end;
procedure TEmitter.EmitOP_ADD_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantAddition);
end;
procedure TEmitter.EmitOP_ADD_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantAddition);
end;
procedure TEmitter.EmitOP_SUB_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantSubtraction);
end;
procedure TEmitter.EmitOP_SUB_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantSubtraction);
end;
procedure TEmitter.EmitOP_MULT_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantMultiplication);
end;
procedure TEmitter.EmitOP_MULT_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantMultiplication);
end;
procedure TEmitter.EmitOP_DIV_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantDivision);
end;
procedure TEmitter.EmitOP_DIV_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantDivision);
end;
procedure TEmitter.EmitOP_IDIV_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantIDivision);
end;
procedure TEmitter.EmitOP_IDIV_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantIDivision);
end;
procedure TEmitter.EmitOP_MOD_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantModulo);
end;
procedure TEmitter.EmitOP_MOD_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantModulo);
end;
procedure TEmitter.EmitOP_SHL_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantLeftShift);
end;
procedure TEmitter.EmitOP_SHL_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantLeftShift);
end;
procedure TEmitter.EmitOP_SHR_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantRightShift);
end;
procedure TEmitter.EmitOP_SHR_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantRightShift);
end;
procedure TEmitter.EmitOP_AND_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantAnd);
end;
procedure TEmitter.EmitOP_AND_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantAnd);
end;
procedure TEmitter.EmitOP_OR_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantOr);
end;
procedure TEmitter.EmitOP_OR_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantOr);
end;
procedure TEmitter.EmitOP_XOR_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantXor);
end;
procedure TEmitter.EmitOP_XOR_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantXor);
end;
procedure TEmitter.EmitOP_LT_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantLessThan);
end;
procedure TEmitter.EmitOP_LT_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantLessThan);
end;
procedure TEmitter.EmitOP_LE_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantLessThanOrEqual);
end;
procedure TEmitter.EmitOP_LE_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantLessThanOrEqual);
end;
procedure TEmitter.EmitOP_GT_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantGreaterThan);
end;
procedure TEmitter.EmitOP_GT_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantGreaterThan);
end;
procedure TEmitter.EmitOP_GE_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantGreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_GE_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantGreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_EQ_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantEquality);
end;
procedure TEmitter.EmitOP_EQ_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantEquality);
end;
procedure TEmitter.EmitOP_NE_VARIANT_64;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantNotEquality);
end;
procedure TEmitter.EmitOP_NE_VARIANT;
begin
EmitStdCall_Lang_Adr1_Adr2_AdrR(Id_VariantNotEquality);
end;
procedure TEmitter.EmitOP_EQ_STRUCT_64;
var
SubId, Reg, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_StructEquality;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // s1
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // s2
Prg.AsmMovREG_REG(_EDX, Reg);
sz := SymbolRec1.PtrSize;
Prg.AsmMovREG_Imm(Reg, sz);
Prg.AsmMovREG_REG(_R8, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_EQ_STRUCT;
var
SubId, Reg, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_StructEquality;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
sz := SymbolRec1.PtrSize;
Prg.AsmPush_Imm(sz);
EmitLoadAddress(Reg, SymbolRec2); // s2
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // s1
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_NE_STRUCT_64;
var
SubId, Reg, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_StructNotEquality;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // s1
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // s2
Prg.AsmMovREG_REG(_EDX, Reg);
sz := SymbolRec1.PtrSize;
Prg.AsmMovREG_Imm(Reg, sz);
Prg.AsmMovREG_REG(_R8, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_NE_STRUCT;
var
SubId, Reg, SZ: Integer;
begin
EmitPCodeOperator;
SubId := Id_StructNotEquality;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
sz := SymbolRec1.PtrSize;
Prg.AsmPush_Imm(sz);
EmitLoadAddress(Reg, SymbolRec2); // s2
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // s1
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_EQ_ANSISTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringEquality);
end;
procedure TEmitter.EmitOP_EQ_ANSISTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringEquality);
end;
procedure TEmitter.EmitOP_GT_ANSISTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringGreaterThan);
end;
procedure TEmitter.EmitOP_GT_ANSISTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringGreaterThan);
end;
procedure TEmitter.EmitOP_GE_ANSISTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringGreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_GE_ANSISTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringGreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_LT_ANSISTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringLessThan);
end;
procedure TEmitter.EmitOP_LT_ANSISTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringLessThan);
end;
procedure TEmitter.EmitOP_LE_ANSISTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringLessThanOrEqual);
end;
procedure TEmitter.EmitOP_LE_ANSISTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringLessThanOrEqual);
end;
procedure TEmitter.EmitOP_GT_SHORTSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringGreaterThan);
end;
procedure TEmitter.EmitOP_GT_SHORTSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringGreaterThan);
end;
procedure TEmitter.EmitOP_GE_SHORTSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringGreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_GE_SHORTSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringGreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_LT_SHORTSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringLessThan);
end;
procedure TEmitter.EmitOP_LT_SHORTSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringLessThan);
end;
procedure TEmitter.EmitOP_LE_SHORTSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringLessThanOrEqual);
end;
procedure TEmitter.EmitOP_LE_SHORTSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringLessThanOrEqual);
end;
procedure TEmitter.EmitOP_GT_WIDESTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringGreaterThan);
end;
procedure TEmitter.EmitOP_GT_WIDESTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringGreaterThan);
end;
procedure TEmitter.EmitOP_GT_UNICSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringGreaterThan);
end;
procedure TEmitter.EmitOP_GT_UNICSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringGreaterThan);
end;
procedure TEmitter.EmitOP_GE_WIDESTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringGreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_GE_WIDESTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringGreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_GE_UNICSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringGreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_GE_UNICSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringGreaterThanOrEqual);
end;
procedure TEmitter.EmitOP_LT_WIDESTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringLessThan);
end;
procedure TEmitter.EmitOP_LT_WIDESTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringLessThan);
end;
procedure TEmitter.EmitOP_LT_UNICSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringLessThan);
end;
procedure TEmitter.EmitOP_LT_UNICSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringLessThan);
end;
procedure TEmitter.EmitOP_LE_WIDESTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringLessThanOrEqual);
end;
procedure TEmitter.EmitOP_LE_WIDESTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringLessThanOrEqual);
end;
procedure TEmitter.EmitOP_LE_UNICSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringLessThanOrEqual);
end;
procedure TEmitter.EmitOP_LE_UNICSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringLessThanOrEqual);
end;
procedure TEmitter.EmitOP_NE_ANSISTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringNotEquality);
end;
procedure TEmitter.EmitOP_NE_ANSISTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_AnsiStringNotEquality);
end;
procedure TEmitter.EmitOP_EQ_SHORTSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringEquality);
end;
procedure TEmitter.EmitOP_EQ_SHORTSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringEquality);
end;
procedure TEmitter.EmitOP_NE_SHORTSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringNotEquality);
end;
procedure TEmitter.EmitOP_NE_SHORTSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_ShortStringNotEquality);
end;
procedure TEmitter.EmitOP_EQ_WIDESTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringEquality);
end;
procedure TEmitter.EmitOP_EQ_WIDESTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringEquality);
end;
procedure TEmitter.EmitOP_EQ_UNICSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringEquality);
end;
procedure TEmitter.EmitOP_EQ_UNICSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringEquality);
end;
procedure TEmitter.EmitOP_NE_WIDESTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringNotEquality);
end;
procedure TEmitter.EmitOP_NE_WIDESTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_WideStringNotEquality);
end;
procedure TEmitter.EmitOP_NE_UNICSTRING_64;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringNotEquality);
end;
procedure TEmitter.EmitOP_NE_UNICSTRING;
begin
EmitStdCall_Adr1_Adr2_AdrR(Id_UnicStringNotEquality);
end;
procedure TEmitter.EmitOP_VARARRAY_GET_64;
var
SubId: Integer;
begin
SubId := 0;
case R.Arg2 of
1: SubId := Id_VarArrayGet1;
2: SubId := Id_VarArrayGet2;
3: SubId := Id_VarArrayGet3;
else
RaiseError(errInternalError, []);
end;
EmitStdCall_Adr1_AdrR(SubId);
end;
procedure TEmitter.EmitOP_VARARRAY_GET;
var
SubId: Integer;
begin
SubId := 0;
case R.Arg2 of
1: SubId := Id_VarArrayGet1;
2: SubId := Id_VarArrayGet2;
3: SubId := Id_VarArrayGet3;
else
RaiseError(errInternalError, []);
end;
EmitStdCall_Adr1_AdrR(SubId);
end;
procedure TEmitter.EmitOP_VARARRAY_PUT_64;
var
SubId: Integer;
begin
SubId := 0;
case R.Arg2 of
1: SubId := Id_VarArrayPut1;
2: SubId := Id_VarArrayPut2;
3: SubId := Id_VarArrayPut3;
else
RaiseError(errInternalError, []);
end;
EmitStdCall_Adr1_AdrR(SubId);
end;
procedure TEmitter.EmitOP_VARARRAY_PUT;
var
SubId: Integer;
begin
SubId := 0;
case R.Arg2 of
1: SubId := Id_VarArrayPut1;
2: SubId := Id_VarArrayPut2;
3: SubId := Id_VarArrayPut3;
else
RaiseError(errInternalError, []);
end;
EmitStdCall_Adr1_AdrR(SubId);
end;
procedure TEmitter.EmitOP_GENERAL_GET_64;
var
Reg, SubId, PropNameId: Integer;
Code: TCode;
I, NP: Integer;
L: TIntegerList;
begin
EmitPCodeOperator;
SubId := JS_GetGenericPropertyId;
PropNameId := SymbolRec2.Id;
Code := TKernel(kernel).Code;
L := TIntegerList.Create;
for I:=Code.N downto 1 do
if Code.Records[I].Op = OP_OLE_PARAM then
if Code.Records[I].Res = PropNameId then
L.Insert(0, Code.Records[I].Arg1);
Reg := GetRegEx;
NP := L.Count;
EmitCallPro(SubId, (NP + 5) * SizeOf(Pointer));
if NP > 0 then
for I:=0 to NP - 1 do
begin
EmitLoadAddress(Reg, GetSymbolRec(L[I]));
Prg.AsmMovRSPPtr_REG64(Reg, $20 + I * 8);
end;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // object
Prg.AsmMovREG_REG(_EDX, Reg);
EmitGet_REG(Reg, SymbolRec2); // prop name - pchar
Prg.AsmMovREG_REG(_R8, Reg);
Prg.AsmMovREG_Imm(_R9, NP);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R10, Reg);
Prg.AsmMovREG_REG(_EAX, _ESP);
Prg.AsmAddREG_Imm(_EAX, $20);
FreeReg(Reg);
EmitStdCall(SubId, (NP + 5) * SizeOf(Pointer));
end;
procedure TEmitter.EmitOP_GENERAL_GET;
var
Reg, SubId, PropNameId: Integer;
Code: TCode;
I, NP: Integer;
L: TIntegerList;
begin
EmitPCodeOperator;
SubId := JS_GetGenericPropertyId;
PropNameId := SymbolRec2.Id;
Code := TKernel(kernel).Code;
L := TIntegerList.Create;
for I:=Code.N downto 1 do
if Code.Records[I].Op = OP_OLE_PARAM then
if Code.Records[I].Res = PropNameId then
L.Insert(0, Code.Records[I].Arg1);
Reg := GetReg;
NP := L.Count;
EmitCallPro(SubId, (NP + 5) * SizeOf(Pointer));
if NP > 0 then
for I:=NP - 1 downto 0 do
begin
EmitLoadAddress(Reg, GetSymbolRec(L[I]));
Prg.AsmPush_REG(Reg);
end;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(NP);
EmitGet_REG(Reg, SymbolRec2); // prop name - pchar
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // object
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId, (NP + 5) * SizeOf(Pointer));
end;
procedure TEmitter.EmitOP_GENERAL_PUT_64;
var
Reg, SubId, PropNameId: Integer;
Code: TCode;
I, NP: Integer;
L: TIntegerList;
begin
EmitPCodeOperator;
SubId := JS_PutGenericPropertyId;
PropNameId := SymbolRec2.Id;
Code := TKernel(kernel).Code;
L := TIntegerList.Create;
for I:=Code.N downto 1 do
if Code.Records[I].Op = OP_OLE_PARAM then
if Code.Records[I].Res = PropNameId then
L.Insert(0, Code.Records[I].Arg1);
Reg := GetRegEx;
NP := L.Count;
EmitCallPro(SubId, (NP + 5) * SizeOf(Pointer));
if NP > 0 then
for I:=0 to NP - 1 do
begin
EmitLoadAddress(Reg, GetSymbolRec(L[I]));
Prg.AsmMovRSPPtr_REG64(Reg, $20 + I * 8);
end;
EmitLoadAddress(Reg, SymbolRec1); // object
Prg.AsmMovREG_REG(_ECX, Reg);
EmitGet_REG(Reg, SymbolRec2); // prop name - pchar
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_Imm(Reg, NP);
Prg.AsmMovREG_REG(_R8, Reg);
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmMovREG_REG(_R9, Reg);
Prg.AsmMovREG_REG(_EAX, _ESP);
Prg.AsmAddREG_Imm(_EAX, $20);
FreeReg(Reg);
EmitStdCall(SubId, (NP + 5) * SizeOf(Pointer));
end;
procedure TEmitter.EmitOP_GENERAL_PUT;
var
Reg, SubId, PropNameId: Integer;
Code: TCode;
I, NP: Integer;
L: TIntegerList;
begin
EmitPCodeOperator;
SubId := JS_PutGenericPropertyId;
PropNameId := SymbolRec2.Id;
Code := TKernel(kernel).Code;
L := TIntegerList.Create;
for I:=Code.N downto 1 do
if Code.Records[I].Op = OP_OLE_PARAM then
if Code.Records[I].Res = PropNameId then
L.Insert(0, Code.Records[I].Arg1);
Reg := GetReg;
NP := L.Count;
EmitCallPro(SubId, (NP + 4) * SizeOf(Pointer));
if NP > 0 then
for I:=NP - 1 downto 0 do
begin
EmitLoadAddress(Reg, GetSymbolRec(L[I]));
Prg.AsmPush_REG(Reg);
end;
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(NP);
EmitGet_REG(Reg, SymbolRec2); // prop name - pchar
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // object
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId, (NP + 4) * SizeOf(Pointer));
end;
procedure TEmitter.EmitOP_OLE_GET_64;
begin
RaiseError(errNotImplementedYet, []);
end;
procedure TEmitter.EmitOP_OLE_GET;
var
Reg, SubId, PropNameId: Integer;
Code: TCode;
I: Integer;
L: TIntegerList;
begin
if R.Language = JS_LANGUAGE then
begin
if TargetPlatform = tpWIN64 then
EmitOP_GENERAL_GET_64
else
EmitOP_GENERAL_GET;
Exit;
end;
EmitPCodeOperator;
SubId := LookUp(_strGetOLEProperty);
if SubId = 0 then
RaiseError(errIMPORT_ActiveX, []);
PropNameId := SymbolRec2.Id;
Code := TKernel(kernel).Code;
L := TIntegerList.Create;
try
for I:=Code.N downto 1 do
if Code.Records[I].Op = OP_OLE_PARAM then
if Code.Records[I].Res = PropNameId then
L.Insert(0, Code.Records[I].Arg1);
Reg := GetReg;
for I:=L.Count - 1 downto 0 do
begin
EmitLoadAddress(Reg, GetSymbolRec(L[I]));
Prg.AsmPush_REG(Reg);
end;
Prg.AsmPush_Imm(L.Count);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // prop name - pchar
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // object
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolTable[SubId]);
Prg.AsmCall_REG(Reg);
FreeReg(Reg);
finally
FreeAndNil(L);
end;
end;
procedure TEmitter.EmitOP_OLE_SET_64;
begin
RaiseError(errNotImplementedYet, []);
end;
procedure TEmitter.EmitOP_OLE_SET;
var
Reg, SubId, PropNameId: Integer;
Code: TCode;
I: Integer;
L: TIntegerList;
begin
if R.Language = JS_LANGUAGE then
begin
if TargetPlatform = tpWIN64 then
EmitOP_GENERAL_PUT_64
else
EmitOP_GENERAL_PUT;
Exit;
end;
EmitPCodeOperator;
SubId := LookUp(_strSetOLEProperty);
if SubId = 0 then
RaiseError(errIMPORT_ActiveX, []);
PropNameId := SymbolRec2.Id;
Code := TKernel(kernel).Code;
L := TIntegerList.Create;
try
for I:=Code.N downto 1 do
if Code.Records[I].Op = OP_OLE_PARAM then
if Code.Records[I].Res = PropNameId then
L.Insert(0, Code.Records[I].Arg1);
Reg := GetReg;
for I:=L.Count - 1 downto 0 do
begin
EmitLoadAddress(Reg, GetSymbolRec(L[I]));
Prg.AsmPush_REG(Reg);
end;
Prg.AsmPush_Imm(L.Count);
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // prop name - pchar
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec1); // object
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolTable[SubId]);
Prg.AsmCall_REG(Reg);
FreeReg(Reg);
finally
FreeAndNil(L);
end;
end;
procedure TEmitter.EmitOP_OLE_PARAM_64;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_OLE_PARAM;
begin
EmitPCodeOperator;
end;
procedure TEmitter.EmitOP_ANSISTRING_CLR;
begin
EmitStdCall_Adr1(Id_AnsiStringClr);
end;
procedure TEmitter.EmitOP_ANSISTRING_CLR_64;
begin
EmitStdCall_Adr1(Id_AnsiStringClr);
end;
procedure TEmitter.EmitOP_SET_LENGTH_64;
var
SubId, Reg, FinTypeId, T1, L1: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
L1 := 0;
FinTypeId := SymbolRec1.FinalTypeId;
case FinTypeId of
typeVARIANT: SubId := Id_SetVariantLength;
typeUNICSTRING: SubId := Id_SetUnicStringLength;
{$IFNDEF PAXARM}
typeANSISTRING: SubId := Id_SetStringLength;
typeWIDESTRING: SubId := Id_SetWideStringLength;
typeSHORTSTRING:
begin
SubId := Id_SetShortStringLength;
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
end;
{$ENDIF}
else
begin
SubId := 0;
RaiseError(errInternalError, []);
end;
end;
EmitCallPro(SubId);
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRec1); // source
Prg.AsmMovREG_REG(_ECX, Reg);
{$IFNDEF PAXARM}
if FinTypeId = typeSHORTSTRING then
Prg.AsmMovREG_Imm(Reg, L1)
else
{$ENDIF}
if FinTypeId = typeVARIANT then
Prg.AsmMovREG_Imm(Reg, varVariant);
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadIntVal(Reg, SymbolRec2); // L
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SET_LENGTH;
var
SubId, Reg, FinTypeId, T1, L1: Integer;
begin
EmitPCodeOperator;
Emit_PUSH_REGS;
L1 := 0;
FinTypeId := SymbolRec1.FinalTypeId;
case FinTypeId of
typeVARIANT: SubId := Id_SetVariantLength;
typeUNICSTRING: SubId := Id_SetUnicStringLength;
{$IFNDEF PAXARM}
typeANSISTRING: SubId := Id_SetStringLength;
typeWIDESTRING: SubId := Id_SetWideStringLength;
typeSHORTSTRING:
begin
SubId := Id_SetShortStringLength;
T1 := SymbolRec1.TerminalTypeID;
L1 := GetSymbolRec(T1).Count;
if T1 = typeSHORTSTRING then
L1 := 255;
end;
{$ENDIF}
else
begin
SubId := 0;
RaiseError(errInternalError, []);
end;
end;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec2); // L
Prg.AsmPush_REG(Reg);
{$IFNDEF PAXARM}
if FinTypeId = typeSHORTSTRING then
Prg.AsmPush_Imm(L1)
else
{$ENDIF}
if FinTypeId = typeVARIANT then
Prg.AsmPush_Imm(varVariant);
EmitLoadAddress(Reg, SymbolRec1); // source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SET_LENGTH_EX_64;
begin
RaiseError(errNotImplementedYet, []);
end;
procedure TEmitter.EmitOP_SET_LENGTH_EX;
var
I, K, SubId, Reg, FinTypeId,Id: Integer;
Lst: TIntegerList;
Code: TCode;
ElFinalTypeID, ElTypeID, ElSize: Integer;
IsFWArray: Boolean;
begin
Lst := TIntegerList.Create;
SubId := 0;
EmitPCodeOperator;
Emit_PUSH_REGS;
Reg := GetReg;
try
K := SymbolRec2.Id;
Code := TKernel(kernel).Code;
for I := Code.N downto 1 do
if Code[I].GenOp = OP_PUSH_LENGTH then
begin
Lst.Add(Code[I].Arg1);
if Lst.Count = K then
break;
end;
FinTypeId := SymbolRec1.FinalTypeId;
if FinTypeId = typeCLASS then
begin
FinTypeId := typeDYNARRAY;
IsFWArray := true;
end
else
IsFWArray := false;
case FinTypeId of
typeVARIANT:
case K of
1: SubId := Id_SetVariantLength;
2: SubId := Id_SetVariantLength2;
3: SubId := Id_SetVariantLength3;
else
RaiseError(errInternalError, []);
end;
typeDYNARRAY:
case K of
1: SubId := Id_DynarraySetLength;
2: SubId := Id_DynarraySetLength2;
3: SubId := Id_DynarraySetLength3;
else
RaiseError(errInternalError, []);
end;
else
RaiseError(errInternalError, []);
end;
EmitCallPro(SubId);
if FinTypeId = typeDYNARRAY then
begin
ElTypeID := SymbolRec1.TerminalTypeId;
if IsFWArray then
ElTypeID := GetSymbolRec(ElTypeId).PatternId;
ElTypeID := GetSymbolRec(ElTypeId).PatternId;
while GetSymbolRec(ElTypeId).FinalTypeId = typeDYNARRAY do
begin
ElTypeID := GetSymbolRec(ElTypeId).TerminalTypeId;
ElTypeID := GetSymbolRec(ElTypeId).PatternId;
end;
ElFinalTypeID := GetSymbolRec(ElTypeId).FinalTypeId;
ElSize := GetSymbolRec(ElTypeId).Size;
Prg.AsmPush_Imm(ElSize);
Prg.AsmPush_Imm(ElTypeID);
Prg.AsmPush_Imm(ElFinalTypeID);
for I := 0 to Lst.Count - 1 do
begin
Id := Lst[I];
EmitLoadIntVal(Reg, GetSymbolRec(Id));
Prg.AsmPush_REG(Reg);
end;
EmitLoadAddress(Reg, SymbolRec1); // address of array
if IsFWArray then
begin
Prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmAddReg_Imm(Reg, FWArrayOffset);
end;
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Exit;
end;
for I := 0 to Lst.Count - 1 do
begin
Id := Lst[I];
EmitLoadIntVal(Reg, GetSymbolRec(Id));
Prg.AsmPush_REG(Reg);
end;
Prg.AsmPush_Imm(varVariant);
EmitLoadAddress(Reg, SymbolRec1); // source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
finally
Emit_POP_REGS;
FreeAndNil(Lst);
end;
end;
procedure TEmitter.EmitOP_WIDESTRING_CLR_64;
begin
EmitStdCall_Adr1(Id_WideStringClr);
end;
procedure TEmitter.EmitOP_WIDESTRING_CLR;
begin
EmitStdCall_Adr1(Id_WideStringClr);
end;
procedure TEmitter.EmitOP_UNICSTRING_CLR_64;
begin
EmitStdCall_Adr1(Id_UnicStringClr);
end;
procedure TEmitter.EmitOP_UNICSTRING_CLR;
begin
EmitStdCall_Adr1(Id_UnicStringClr);
end;
procedure TEmitter.EmitOP_INTERFACE_CLR_64;
begin
EmitStdCall_Adr1(Id_InterfaceClr);
end;
procedure TEmitter.EmitOP_INTERFACE_CLR;
begin
EmitStdCall_Adr1(Id_InterfaceClr);
end;
procedure TEmitter.EmitOP_CLASS_CLR_64;
begin
EmitStdCall_Adr1(Id_ClassClr);
end;
procedure TEmitter.EmitOP_CLASS_CLR;
begin
EmitStdCall_Adr1(Id_ClassClr);
end;
procedure TEmitter.EmitOP_SHORTSTRING_HIGH_64;
begin
EmitStdCall_Adr1_AdrR(Id_ShortstringHigh);
end;
procedure TEmitter.EmitOP_SHORTSTRING_HIGH;
begin
EmitStdCall_Adr1_AdrR(Id_ShortstringHigh);
end;
procedure TEmitter.EmitOP_LOCK_VARRAY_64;
begin
EmitStdCall_Adr1_AdrR(Id_LockVArray);
end;
procedure TEmitter.EmitOP_LOCK_VARRAY;
begin
EmitStdCall_Adr1_AdrR(Id_LockVArray);
end;
procedure TEmitter.EmitOP_UNLOCK_VARRAY_64;
begin
EmitStdCall_Adr1(Id_UnLockVArray);
end;
procedure TEmitter.EmitOP_UNLOCK_VARRAY;
begin
EmitStdCall_Adr1(Id_UnLockVArray);
end;
procedure TEmitter.EmitOP_VARIANT_CLR_64;
begin
EmitStdCall_Adr1(Id_VariantClr);
end;
procedure TEmitter.EmitOP_VARIANT_CLR;
begin
EmitStdCall_Adr1(Id_VariantClr);
end;
procedure TEmitter.EmitOP_DYNARRAY_CLR_64;
var
SubId, Reg,
ArrayTypeId,
ElSize, ElTypeId, ElFinalTypeId: Integer;
ElSize2, ElTypeId2, ElFinalTypeId2: Integer;
begin
EmitPCodeOperator;
SubId := Id_DynarrayClr;
EmitCallPro(SubId);
Reg := GetRegEx;
ArrayTypeId := SymbolRec1.TerminalTypeId;
ElTypeId := GetSymbolRec(ArrayTypeId).PatternId;
ElFinalTypeId := GetSymbolRec(ElTypeId).FinalTypeId;
ElSize := SymbolTable[ElTypeId].Size;
ElTypeId2 := 0;
ElFinalTypeId2 := 0;
ElSize2 := 0;
if ElFinalTypeId = typeDYNARRAY then
begin
ElTypeId2 := GetSymbolRec(ElTypeId).TerminalTypeId;
ElTypeId2 := GetSymbolRec(ElTypeId2).PatternId;
ElFinalTypeId2 := GetSymbolRec(ElTypeId2).FinalTypeId;
ElSize2 := SymbolTable[ElTypeId2].Size;
end;
EmitLoadAddress(Reg, SymbolRec1); // source
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_Imm(Reg, ElFinalTypeId);
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_Imm(Reg, ElTypeId);
Prg.AsmMovREG_REG(_R8, Reg);
Prg.AsmMovREG_Imm(Reg, ElSize);
Prg.AsmMovREG_REG(_R9, Reg);
Prg.AsmMovREG_Imm(Reg, ElFinalTypeId2);
Prg.AsmMovRSPPtr_REG64(Reg, $20);
Prg.AsmMovREG_Imm(Reg, ElTypeId2);
Prg.AsmMovRSPPtr_REG64(Reg, $28);
Prg.AsmMovREG_Imm(Reg, ElSize2);
Prg.AsmMovRSPPtr_REG64(Reg, $30);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_DYNARRAY_CLR;
var
SubId, Reg,
ArrayTypeId,
ElSize, ElTypeId, ElFinalTypeId: Integer;
ElSize2, ElTypeId2, ElFinalTypeId2: Integer;
begin
EmitPCodeOperator;
SubId := Id_DynarrayClr;
EmitCallPro(SubId);
Reg := GetReg;
ArrayTypeId := SymbolRec1.TerminalTypeId;
ElTypeId := GetSymbolRec(ArrayTypeId).PatternId;
ElFinalTypeId := GetSymbolRec(ElTypeId).FinalTypeId;
ElSize := SymbolTable[ElTypeId].Size;
ElTypeId2 := 0;
ElFinalTypeId2 := 0;
ElSize2 := 0;
if ElFinalTypeId = typeDYNARRAY then
begin
ElTypeId2 := GetSymbolRec(ElTypeId).TerminalTypeId;
ElTypeId2 := GetSymbolRec(ElTypeId2).PatternId;
ElFinalTypeId2 := GetSymbolRec(ElTypeId2).FinalTypeId;
ElSize2 := SymbolTable[ElTypeId2].Size;
end;
Prg.AsmPush_Imm(ElSize2);
Prg.AsmPush_Imm(ElTypeId2);
Prg.AsmPush_Imm(ElFinalTypeId2);
Prg.AsmPush_Imm(ElSize);
Prg.AsmPush_Imm(ElTypeId);
Prg.AsmPush_Imm(ElFinalTypeId);
EmitLoadAddress(Reg, SymbolRec1); // source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_CREATE_EMPTY_DYNARRAY_64;
begin
Emit_PUSH_REGS;
EmitStdCall_Adr1(Id_CreateEmptyDynarray);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_CREATE_EMPTY_DYNARRAY;
begin
Emit_PUSH_REGS;
EmitStdCall_Adr1(Id_CreateEmptyDynarray);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_DYNARRAY_HIGH_64;
begin
EmitStdCall_Adr1_AdrR(Id_DynarrayHigh);
end;
procedure TEmitter.EmitOP_DYNARRAY_HIGH;
begin
EmitStdCall_Adr1_AdrR(Id_DynarrayHigh);
end;
procedure TEmitter.EmitOP_DYNARRAY_ASSIGN_64;
var
SubId, Reg,
ArrayTypeId,
ElSize, ElTypeId, ElFinalTypeId,
ElSize2, ElTypeId2, ElFinalTypeId2: Integer;
begin
EmitPCodeOperator;
SubId := Id_DynarrayAssign;
EmitCallPro(SubId);
Reg := GetRegEx;
ArrayTypeId := SymbolRec1.TerminalTypeId;
ElTypeId := GetSymbolRec(ArrayTypeId).PatternId;
ElFinalTypeId := GetSymbolRec(ElTypeId).FinalTypeId;
ElSize := SymbolTable[ElTypeId].Size;
ElTypeId2 := 0;
ElFinalTypeId2 := 0;
ElSize2 := 0;
if ElFinalTypeId = typeDYNARRAY then
begin
ElTypeId2 := GetSymbolRec(ElTypeId).TerminalTypeId;
ElTypeId2 := GetSymbolRec(ElTypeId2).PatternId;
ElFinalTypeId2 := GetSymbolRec(ElTypeId2).FinalTypeId;
ElSize2 := SymbolTable[ElTypeId2].Size;
end;
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // dest
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_Imm(Reg, ElFinalTypeId);
Prg.AsmMovREG_REG(_R8, Reg);
Prg.AsmMovREG_Imm(Reg, ElTypeId);
Prg.AsmMovREG_REG(_R9, Reg);
Prg.AsmMovREG_Imm(Reg, ElSize);
Prg.AsmMovRSPPtr_REG64(Reg, $20);
Prg.AsmMovREG_Imm(Reg, ElFinalTypeId2);
Prg.AsmMovRSPPtr_REG64(Reg, $28);
Prg.AsmMovREG_Imm(Reg, ElTypeId2);
Prg.AsmMovRSPPtr_REG64(Reg, $30);
Prg.AsmMovREG_Imm(Reg, ElSize2);
Prg.AsmMovRSPPtr_REG64(Reg, $38);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_DYNARRAY_ASSIGN;
var
SubId, Reg,
ArrayTypeId,
ElSize, ElTypeId, ElFinalTypeId,
ElSize2, ElTypeId2, ElFinalTypeId2: Integer;
begin
EmitPCodeOperator;
SubId := Id_DynarrayAssign;
EmitCallPro(SubId);
Reg := GetReg;
ArrayTypeId := SymbolRec1.TerminalTypeId;
ElTypeId := GetSymbolRec(ArrayTypeId).PatternId;
ElFinalTypeId := GetSymbolRec(ElTypeId).FinalTypeId;
ElSize := SymbolTable[ElTypeId].Size;
ElTypeId2 := 0;
ElFinalTypeId2 := 0;
ElSize2 := 0;
if ElFinalTypeId = typeDYNARRAY then
begin
ElTypeId2 := GetSymbolRec(ElTypeId).TerminalTypeId;
ElTypeId2 := GetSymbolRec(ElTypeId2).PatternId;
ElFinalTypeId2 := GetSymbolRec(ElTypeId2).FinalTypeId;
ElSize2 := SymbolTable[ElTypeId2].Size;
end;
Prg.AsmPush_Imm(ElSize2);
Prg.AsmPush_Imm(ElTypeId2);
Prg.AsmPush_Imm(ElFinalTypeId2);
Prg.AsmPush_Imm(ElSize);
Prg.AsmPush_Imm(ElTypeId);
Prg.AsmPush_Imm(ElFinalTypeId);
EmitLoadAddress(Reg, SymbolRec1); // dest
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ASSIGN_TVarRec_64;
var
SubId, Reg,
FinalTypeId: Integer;
begin
EmitPCodeOperator;
SubId := Id_AssignTVarRec;
EmitCallPro(SubId);
Reg := GetRegEx;
FinalTypeId := SymbolRec2.FinalTypeId;
{$IFNDEF PAXARM}
if SymbolRec2.HasPAnsiCharType then
begin
if SymbolRec2.Kind <> KindCONST then
FinalTypeId := typeANSISTRING
else
FinalTypeId := typePANSICHAR;
end
else
{$ENDIF}
if SymbolRec2.HasPWideCharType then
begin
if SymbolRec2.Kind <> KindCONST then
FinalTypeId := typeUNICSTRING
else
FinalTypeId := typePWIDECHAR;
end;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // dest
Prg.AsmMovREG_REG(_R8, Reg);
Prg.AsmMovREG_Imm(Reg, FinalTypeId);
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ASSIGN_TVarRec;
var
SubId, Reg,
FinalTypeId: Integer;
begin
EmitPCodeOperator;
SubId := Id_AssignTVarRec;
EmitCallPro(SubId);
Reg := GetReg;
FinalTypeId := SymbolRec2.FinalTypeId;
{$IFNDEF PAXARM}
if SymbolRec2.HasPAnsiCharType then
begin
if SymbolRec2.Kind <> KindCONST then
FinalTypeId := typeANSISTRING
else
FinalTypeId := typePANSICHAR;
end
else
{$ENDIF}
if SymbolRec2.HasPWideCharType then
begin
if SymbolRec2.Kind <> KindCONST then
FinalTypeId := typeUNICSTRING
else
FinalTypeId := typePWIDECHAR;
end;
Prg.AsmPush_Imm(FinalTypeId);
EmitLoadAddress(Reg, SymbolRec1); // dest
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec2); // source
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_STRUCTURE_CLR_64;
var
SubId, Reg, TypeId, I, S, FT,
ArrayTypeId, DestructorId,
ElTypeId, ElFinalTypeId, ElSize: Integer;
ElTypeId2, ElFinalTypeId2, ElSize2: Integer;
L, T: TIntegerList;
begin
EmitPCodeOperator;
TypeId := SymbolRec1.TerminalTypeId;
if TKernel(kernel).SymbolTable[TypeId].FinalTypeId = typeRECORD then
begin
DestructorId := TKernel(kernel).SymbolTable.FindDestructorId(TypeId);
if DestructorId <> 0 then
begin
EmitCallPro(DestructorId, 0);
if GetSymbolRec(DestructorId).Host then
begin
Reg := _EBX;
EmitGet_REG(Reg, GetSymbolRec(DestructorId));
Prg.AsmCall_REG(Reg);
end
else
begin
EmitLoadAddress(_EAX, SymbolRec1);
Reg := _EBX;
Prg.AsmMovREG_REG(Reg, _EDI);
Prg.AsmAddREG_Imm(Reg, 0);
Prg.Top.SaveSubId := DestructorId;
List2.Add(Prg.Top);
Prg.AsmCall_REG(Reg);
end;
EmitCallEpi(DestructorId, 0);
end;
end;
L := TKernel(kernel).SymbolTable.GetShiftsOfDynamicFields(TypeId);
T := TKernel(kernel).SymbolTable.GetTypesOfDynamicFields(TypeId);
if T.Count <> L.Count then
RaiseError(errInternalError, []);
try
for I:=0 to L.Count - 1 do
begin
Reg := GetRegEx;
S := L[I];
FT := GetSymbolRec(T[I]).FinalTypeId;
SubId := 0;
case FT of
{$IFNDEF PAXARM}
typeANSISTRING: SubId := Id_AnsiStringClr;
typeWIDESTRING: SubId := Id_WideStringClr;
{$ENDIF}
typeUNICSTRING: SubId := Id_UnicStringClr;
typeVARIANT, typeOLEVARIANT: SubId := Id_VariantClr;
typeDYNARRAY: SubId := Id_DynarrayClr;
typeINTERFACE: SubId := Id_InterfaceClr;
typeCLASS: SubId := Id_ClassClr;
else
RaiseError(errInternalError, []);
end;
EmitCallPro(SubId);
if FT = typeDYNARRAY then
begin
ArrayTypeId := T[I];
ElTypeId := GetSymbolRec(ArrayTypeId).PatternId;
ElFinalTypeId := GetSymbolRec(ElTypeId).FinalTypeId;
ElSize := SymbolTable[ElTypeId].Size;
ElTypeId2 := 0;
ElFinalTypeId2 := 0;
ElSize2 := 0;
if ElFinalTypeId = typeDYNARRAY then
begin
ElTypeId2 := GetSymbolRec(ElTypeId).TerminalTypeId;
ElTypeId2 := GetSymbolRec(ElTypeId2).PatternId;
ElFinalTypeId2 := GetSymbolRec(ElTypeId2).FinalTypeId;
ElSize2 := SymbolTable[ElTypeId2].Size;
end;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, S);
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_Imm(Reg, ElFinalTypeId);
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_Imm(Reg, ElTypeId);
Prg.AsmMovREG_REG(_R8, Reg);
Prg.AsmMovREG_Imm(Reg, ElSize);
Prg.AsmMovREG_REG(_R9, Reg);
Prg.AsmMovREG_Imm(Reg, ElFinalTypeId2);
Prg.AsmMovRSPPtr_REG64(Reg, $20);
Prg.AsmMovREG_Imm(Reg, ElTypeId2);
Prg.AsmMovRSPPtr_REG64(Reg, $28);
Prg.AsmMovREG_Imm(Reg, ElSize2);
Prg.AsmMovRSPPtr_REG64(Reg, $30);
end
else
begin
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, S);
Prg.AsmMovREG_REG(_ECX, Reg);
end;
FreeReg(Reg);
EmitStdCall(SubId);
end; // for-loop
finally
FreeAndNil(L);
FreeAndNil(T);
end;
end;
procedure TEmitter.EmitOP_STRUCTURE_CLR;
var
SubId, Reg, TypeId, I, S, FT,
ArrayTypeId, DestructorId,
ElTypeId, ElFinalTypeId, ElSize: Integer;
ElTypeId2, ElFinalTypeId2, ElSize2: Integer;
L, T: TIntegerList;
begin
EmitPCodeOperator;
TypeId := SymbolRec1.TerminalTypeId;
if TKernel(kernel).SymbolTable[TypeId].FinalTypeId = typeRECORD then
begin
DestructorId := TKernel(kernel).SymbolTable.FindDestructorId(TypeId);
if DestructorId <> 0 then
begin
SubId := DestructorId;
EmitCallPro(SubId);
if GetSymbolRec(DestructorId).Host then
begin
EmitStdCall(SubId);
end
else
begin
EmitLoadAddress(_EAX, SymbolRec1);
Reg := _EDX;
Prg.AsmMovREG_REG(Reg, _EDI);
Prg.AsmAddREG_Imm(Reg, 0);
Prg.Top.SaveSubId := DestructorId;
List2.Add(Prg.Top);
Prg.AsmCall_REG(Reg);
EmitCallEpi(SubId);
end;
end;
end;
L := TKernel(kernel).SymbolTable.GetShiftsOfDynamicFields(TypeId);
T := TKernel(kernel).SymbolTable.GetTypesOfDynamicFields(TypeId);
if T.Count <> L.Count then
RaiseError(errInternalError, []);
try
for I:=0 to L.Count - 1 do
begin
Reg := GetReg;
S := L[I];
FT := GetSymbolRec(T[I]).FinalTypeId;
SubId := 0;
case FT of
{$IFNDEF PAXARM}
typeANSISTRING: SubId := Id_AnsiStringClr;
typeWIDESTRING: SubId := Id_WideStringClr;
{$ENDIF}
typeUNICSTRING: SubId := Id_UnicStringClr;
typeVARIANT, typeOLEVARIANT: SubId := Id_VariantClr;
typeDYNARRAY: SubId := Id_DynarrayClr;
typeINTERFACE: SubId := Id_InterfaceClr;
typeCLASS: SubId := Id_ClassClr;
else
RaiseError(errInternalError, []);
end;
EmitCallPro(SubId);
if FT = typeDYNARRAY then
begin
ArrayTypeId := T[I];
ElTypeId := GetSymbolRec(ArrayTypeId).PatternId;
ElFinalTypeId := GetSymbolRec(ElTypeId).FinalTypeId;
ElSize := SymbolTable[ElTypeId].Size;
ElTypeId2 := 0;
ElFinalTypeId2 := 0;
ElSize2 := 0;
if ElFinalTypeId = typeDYNARRAY then
begin
ElTypeId2 := GetSymbolRec(ElTypeId).TerminalTypeId;
ElTypeId2 := GetSymbolRec(ElTypeId2).PatternId;
ElFinalTypeId2 := GetSymbolRec(ElTypeId2).FinalTypeId;
ElSize2 := SymbolTable[ElTypeId2].Size;
end;
Prg.AsmPush_Imm(ElSize2);
Prg.AsmPush_Imm(ElTypeId2);
Prg.AsmPush_Imm(ElFinalTypeId2);
Prg.AsmPush_Imm(ElSize);
Prg.AsmPush_Imm(ElTypeId);
Prg.AsmPush_Imm(ElFinalTypeId);
end;
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, S);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end; // for-loop
finally
FreeAndNil(L);
FreeAndNil(T);
end;
end;
procedure TEmitter.EmitOP_STRUCTURE_ADDREF_64;
var
SubId, Reg, TypeId, I, S, FT: Integer;
L, T: TIntegerList;
begin
EmitPCodeOperator;
TypeId := SymbolRec1.TerminalTypeId;
L := TKernel(kernel).SymbolTable.GetShiftsOfDynamicFields(TypeId);
T := TKernel(kernel).SymbolTable.GetTypesOfDynamicFields(TypeId);
if T.Count <> L.Count then
RaiseError(errInternalError, []);
try
for I:=0 to L.Count - 1 do
begin
Reg := GetRegEx;
S := L[I];
FT := GetSymbolRec(T[I]).FinalTypeId;
SubId := 0;
case FT of
{$IFNDEF PAXARM}
typeANSISTRING: SubId := Id_StringAddRef;
{$ENDIF}
typeUNICSTRING: SubId := Id_UnicStringAddRef;
typeVARIANT, typeOLEVARIANT: SubId := Id_VariantAddRef;
typeDYNARRAY: SubId := Id_DynarrayAddRef;
typeINTERFACE: SubId := Id_InterfaceAddRef;
else
RaiseError(errInternalError, []);
end;
EmitCallPro(SubId);
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, S);
Prg.AsmMovREG_REG(_ECX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end; // for-loop
finally
FreeAndNil(L);
FreeAndNil(T);
end;
end;
procedure TEmitter.EmitOP_STRUCTURE_ADDREF;
var
SubId, Reg, TypeId, I, S, FT: Integer;
L, T: TIntegerList;
begin
EmitPCodeOperator;
TypeId := SymbolRec1.TerminalTypeId;
L := TKernel(kernel).SymbolTable.GetShiftsOfDynamicFields(TypeId);
T := TKernel(kernel).SymbolTable.GetTypesOfDynamicFields(TypeId);
if T.Count <> L.Count then
RaiseError(errInternalError, []);
try
for I:=0 to L.Count - 1 do
begin
Reg := GetReg;
S := L[I];
FT := GetSymbolRec(T[I]).FinalTypeId;
SubId := 0;
case FT of
{$IFNDEF PAXARM}
typeANSISTRING: SubId := Id_StringAddRef;
{$ENDIF}
typeVARIANT, typeOLEVARIANT: SubId := Id_VariantAddRef;
typeDYNARRAY: SubId := Id_DynarrayAddRef;
typeINTERFACE: SubId := Id_InterfaceAddRef;
else
RaiseError(errInternalError, []);
end;
EmitCallPro(SubId);
EmitLoadAddress(Reg, SymbolRec1);
Prg.AsmAddREG_Imm(Reg, S);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end; // for-loop
finally
FreeAndNil(L);
FreeAndNil(T);
end;
end;
procedure TEmitter.EmitOP_PRINT_EX_64;
var
Reg, SubId, L, FT, K: Integer;
begin
EmitPCodeOperator;
SubId := Id_PrintEx;
EmitCallPro(SubId);
K := SymbolRec1.Kind;
{$IFNDEF PAXARM}
if SymbolRec1.HasPAnsiCharType then
FT := typePANSICHAR
else
{$ENDIF}
if SymbolRec1.HasPWideCharType then
FT := typePWIDECHAR
else
FT := SymbolRec1.FinalTypeId;
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
if K = KindCONST then
begin
if FT in INT64Types then
begin
Prg.AsmMovREG_Imm(_EDX, ImmValue1);
end
else if FT in OrdinalTypes then
Prg.AsmMovREG_Imm(_EDX, ImmValue1)
{$IFNDEF PAXARM}
else if FT = typePANSICHAR then
begin
EmitGet_REG(Reg, SymbolRec1); // pchar source
Prg.AsmMovREG_REG(_EDX, Reg);
end
{$ENDIF}
else if FT = typePWIDECHAR then
begin
EmitGet_REG(Reg, SymbolRec1); // pchar source
Prg.AsmMovREG_REG(_EDX, Reg);
end
else
begin
EmitLoadAddress(Reg, SymbolRec1); // value
Prg.AsmMovREG_REG(_EDX, Reg);
end;
end
else
begin
EmitLoadAddress(Reg, SymbolRec1); // value
Prg.AsmMovREG_REG(_EDX, Reg);
end;
Prg.AsmMovREG_Imm(_R8, K);
Prg.AsmMovREG_Imm(_R9, FT);
///////////////////////////////////////////////////////////////////
L := R.Arg2;
if L > 0 then
begin
if GetSymbolRec(L).Kind = KindCONST then
begin
Prg.AsmMovREG_Imm(Reg, Cardinal(GetSymbolRec(L).Value));
Prg.AsmMovRSPPtr_REG64(Reg, $20);
end
else
begin
EmitLoadIntVal(Reg, GetSymbolRec(L));
Prg.AsmMovRSPPtr_REG64(Reg, $20);
end;
end
else
begin
Prg.AsmMovREG_Imm(Reg, 0);
Prg.AsmMovRSPPtr_REG64(Reg, $20);
end;
L := R.Res;
if L > 0 then
begin
if GetSymbolRec(L).Kind = KindCONST then
begin
Prg.AsmMovREG_Imm(Reg, Cardinal(GetSymbolRec(L).Value));
Prg.AsmMovRSPPtr_REG64(Reg, $28);
end
else
begin
EmitLoadIntVal(Reg, GetSymbolRec(L));
Prg.AsmMovRSPPtr_REG64(Reg, $28);
end;
end
else
begin
Prg.AsmMovREG_Imm(Reg, 0);
Prg.AsmMovRSPPtr_REG64(Reg, $28);
end;
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_PRINT_EX;
var
Reg, SubId, L, FT, K: Integer;
begin
EmitPCodeOperator;
SubId := Id_PrintEx;
EmitCallPro(SubId);
Reg := GetReg;
L := R.Res;
if L > 0 then
begin
if GetSymbolRec(L).Kind = KindCONST then
Prg.AsmPush_Imm(Cardinal(GetSymbolRec(L).Value))
else
begin
EmitLoadIntVal(Reg, GetSymbolRec(L));
Prg.AsmPush_REG(Reg);
end;
end
else
Prg.AsmPush_Imm(0);
L := R.Arg2;
if L > 0 then
begin
if GetSymbolRec(L).Kind = KindCONST then
Prg.AsmPush_Imm(Cardinal(GetSymbolRec(L).Value))
else
begin
EmitLoadIntVal(Reg, GetSymbolRec(L));
Prg.AsmPush_REG(Reg);
end;
end
else
Prg.AsmPush_Imm(0);
{$IFNDEF PAXARM}
if SymbolRec1.HasPAnsiCharType then
FT := typePANSICHAR
else
{$ENDIF}
if SymbolRec1.HasPWideCharType then
FT := typePWIDECHAR
else
FT := SymbolRec1.FinalTypeId;
K := SymbolRec1.Kind;
Prg.AsmPush_Imm(FT);
Prg.AsmPush_Imm(K);
if K = KindCONST then
begin
if FT in INT64Types then
begin
Prg.AsmPush_Imm(ImmValue1);
end
else if FT in OrdinalTypes then
Prg.AsmPush_Imm(ImmValue1)
{$IFNDEF PAXARM}
else if FT = typePANSICHAR then
begin
EmitGet_REG(Reg, SymbolRec1); // pchar source
Prg.AsmPush_REG(Reg);
end
{$ENDIF}
else if FT = typePWIDECHAR then
begin
EmitGet_REG(Reg, SymbolRec1); // pchar source
Prg.AsmPush_REG(Reg);
end
else
begin
EmitLoadAddress(Reg, SymbolRec1); // value
Prg.AsmPush_REG(Reg);
end;
end
else
begin
EmitLoadAddress(Reg, SymbolRec1); // value
Prg.AsmPush_REG(Reg);
end;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_TO_FW_OBJECT_64;
var
Reg, SubId, FT, K: Integer;
begin
EmitPCodeOperator;
SubId := Id_ToFWObject;
EmitCallPro(SubId);
Reg := GetRegEx;
K := SymbolRec1.Kind;
{$IFNDEF PAXARM}
if SymbolRec1.HasPAnsiCharType then
FT := typePANSICHAR
else
{$ENDIF}
if SymbolRec1.HasPWideCharType then
FT := typePWIDECHAR
else
FT := SymbolRec1.FinalTypeId;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
if K = KindCONST then
begin
if FT in INT64Types then
begin
Prg.AsmMovREG_Imm(Reg, ImmValue1);
Prg.AsmMovREG_REG(_EDX, Reg);
end
else if FT in OrdinalTypes then
begin
Prg.AsmMovREG_Imm(Reg, ImmValue1);
Prg.AsmMovREG_REG(_EDX, Reg);
end
{$IFNDEF PAXARM}
else if FT = typePANSICHAR then
begin
EmitGet_REG(Reg, SymbolRec1); // pchar source
Prg.AsmMovREG_REG(_EDX, Reg);
end
{$ENDIF}
else if FT = typePWIDECHAR then
begin
EmitGet_REG(Reg, SymbolRec1); // pchar source
Prg.AsmMovREG_REG(_EDX, Reg);
end
else
begin
EmitLoadAddress(Reg, SymbolRec1); // value
Prg.AsmMovREG_REG(_EDX, Reg);
end;
end
else
begin
EmitLoadAddress(Reg, SymbolRec1); // value
Prg.AsmMovREG_REG(_EDX, Reg);
end;
Prg.AsmMovREG_Imm(Reg, K);
Prg.AsmMovREG_REG(_R8, Reg);
Prg.AsmMovREG_Imm(Reg, FT);
Prg.AsmMovREG_REG(_R9, Reg);
Prg.AsmMovREG_Imm(Reg, SymbolRec1.TypeId);
Prg.AsmMovRSPPtr_REG64(Reg, $20);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovRSPPtr_REG64(Reg, $28);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_TO_FW_OBJECT;
var
Reg, SubId, FT, K: Integer;
begin
EmitPCodeOperator;
SubId := Id_ToFWObject;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
{$IFNDEF PAXARM}
if SymbolRec1.HasPAnsiCharType then
FT := typePANSICHAR
else
{$ENDIF}
if SymbolRec1.HasPWideCharType then
FT := typePWIDECHAR
else
FT := SymbolRec1.FinalTypeId;
K := SymbolRec1.Kind;
Prg.AsmPush_Imm(SymbolRec1.TypeId);
Prg.AsmPush_Imm(FT);
Prg.AsmPush_Imm(K);
if K = KindCONST then
begin
if FT in INT64Types then
begin
Prg.AsmPush_Imm(ImmValue1);
end
else if FT in OrdinalTypes then
Prg.AsmPush_Imm(ImmValue1)
{$IFNDEF PAXARM}
else if FT = typePANSICHAR then
begin
EmitGet_REG(Reg, SymbolRec1); // pchar source
Prg.AsmPush_REG(Reg);
end
{$ENDIF}
else if FT = typePWIDECHAR then
begin
EmitGet_REG(Reg, SymbolRec1); // pchar source
Prg.AsmPush_REG(Reg);
end
else
begin
EmitLoadAddress(Reg, SymbolRec1); // value
Prg.AsmPush_REG(Reg);
end;
end
else
begin
EmitLoadAddress(Reg, SymbolRec1); // value
Prg.AsmPush_REG(Reg);
end;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_PUSH_CONTEXT_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_PushContext;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_PUSH_CONTEXT;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_PushContext;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_FIND_CONTEXT_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_FindContext;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitGet_REG(Reg, SymbolRec1); // prop name - pchar
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // alt
Prg.AsmMovREG_REG(_R8, Reg);
Prg.AsmMovREG_Imm(Reg, SymbolRec2.FinalTypeId);
Prg.AsmMovREG_REG(_R9, Reg);
EmitLoadAddress(Reg, SymbolRecR); // (var) result
Prg.AsmMovRSPPtr_REG64(Reg, $20);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_FIND_CONTEXT;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_FindContext;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // (var) result
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(SymbolRec2.FinalTypeId);
EmitLoadAddress(Reg, SymbolRec2); // alt
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec1); // prop name - pchar
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_FIND_JS_FUNC_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := JS_FindFuncId;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitGet_REG(Reg, SymbolRec1); // prop name - pchar
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRec2); // alt
Prg.AsmMovREG_REG(_R8, Reg);
EmitLoadAddress(Reg, SymbolRecR); // (var) result
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_FIND_JS_FUNC;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := JS_FindFuncId;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // (var) result
Prg.AsmPush_REG(Reg);
EmitLoadAddress(Reg, SymbolRec2); // alt
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec1); // prop name - pchar
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_POP_CONTEXT_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_PopContext;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_POP_CONTEXT;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_PopContext;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_IS_64;
var
SubId, Reg, TypeId: Integer;
begin
EmitPCodeOperator;
SubId := Id_Is;
EmitCallPro(SubId);
Reg := GetRegEx;
TypeId := SymbolRec2.TerminalTypeId;
EmitLoadIntVal(Reg, GetSymbolRec(TypeId + 1)); // instance
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_IS;
var
SubId, Reg, TypeId: Integer;
begin
EmitPCodeOperator;
SubId := Id_Is;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
TypeId := SymbolRec2.TerminalTypeId;
EmitLoadIntVal(Reg, GetSymbolRec(TypeId + 1)); // instance
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_PROG_64;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_GET_PROG;
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
EmitSaveIntVal(Reg, SymbolRecR);
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_TYPEINFO_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_TypeInfo;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitGet_REG(Reg, SymbolRec2); // prop name - pchar
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_TYPEINFO;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_TypeInfo;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolRec2); // prop name - pchar
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_INIT_FWARRAY_64;
var
SubId, Reg, T: Integer;
begin
EmitPCodeOperator;
SubId := Id_InitFWArray;
EmitCallPro(SubId);
T := SymbolRec1.TerminalTypeId;
T := TKernel(kernel).SymbolTable[T].PatternId; //ArrayTypeId
T := TKernel(kernel).SymbolTable[T].PatternId; //ElemTypeId
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
Prg.AsmMovREG_Imm(Reg, R.Arg2); // NBounds
Prg.AsmMovREG_REG(_R8, Reg);
Prg.AsmMovREG_Imm(Reg, TKernel(kernel).SymbolTable[T].FinalTypeId);
Prg.AsmMovREG_REG(_R9, Reg);
Prg.AsmMovREG_Imm(Reg, T); // ElemTypeId
Prg.AsmMovRSPPtr_REG64(Reg, $20);
Prg.AsmMovREG_Imm(Reg, TKernel(kernel).SymbolTable[T].FinSize);
Prg.AsmMovRSPPtr_REG64(Reg, $28);
Prg.AsmMovREG_Imm(Reg, R.Res);
Prg.AsmMovRSPPtr_REG64(Reg, $30);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_INIT_FWARRAY;
var
SubId, Reg, T: Integer;
begin
EmitPCodeOperator;
SubId := Id_InitFWArray;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(R.Arg2); // NBounds
T := SymbolRec1.TerminalTypeId;
T := TKernel(kernel).SymbolTable[T].PatternId; //ArrayTypeId
T := TKernel(kernel).SymbolTable[T].PatternId; //ElemTypeId
Prg.AsmPush_Imm(TKernel(kernel).SymbolTable[T].FinalTypeId);
Prg.AsmPush_Imm(T); // ElemTypeId
Prg.AsmPush_Imm(TKernel(kernel).SymbolTable[T].FinSize);
Prg.AsmPush_Imm(R.Res); // ElemTypeId
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_BEFORE_CALL_HOST;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_BeforeCallHost;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmPush_Imm(SymbolRec1.Id);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_AFTER_CALL_HOST;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_AfterCallHost;
EmitCallPro(SubId);
Reg := GetReg;
Prg.AsmPush_Imm(SymbolRec1.Id);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_BEFORE_CALL_HOST_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_BeforeCallHost;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_Imm(_EDX, SymbolRec1.Id);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_AFTER_CALL_HOST_64;
var
SubId, Reg: Integer;
begin
EmitPCodeOperator;
SubId := Id_AfterCallHost;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_Imm(_EDX, SymbolRec1.Id);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ONCREATE_HOST_OBJECT_64;
var
SubId, Reg: Integer;
begin
SubId := Id_OnCreateHostObject;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ONCREATE_HOST_OBJECT;
var
SubId, Reg: Integer;
begin
SubId := Id_OnCreateHostObject;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ONDESTROY_HOST_OBJECT_64;
var
SubId, Reg: Integer;
begin
SubId := Id_OnDestroyHostObject;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ONDESTROY_HOST_OBJECT;
var
SubId, Reg: Integer;
begin
SubId := Id_OnDestroyHostObject;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ONCREATE_OBJECT_64;
var
SubId, Reg: Integer;
begin
SubId := Id_OnCreateObject;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ONCREATE_OBJECT;
var
SubId, Reg: Integer;
begin
SubId := Id_OnCreateObject;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ON_AFTER_OBJECT_CREATION_64;
var
SubId, Reg: Integer;
begin
SubId := Id_OnAfterObjectCreation;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_ON_AFTER_OBJECT_CREATION;
var
SubId, Reg: Integer;
begin
SubId := Id_OnAfterObjectCreation;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_CLASSNAME_64;
begin
EmitStdCall_Adr1_AdrR(Id_ClassName);
end;
procedure TEmitter.EmitOP_CLASSNAME;
begin
EmitStdCall_Adr1_AdrR(Id_ClassName);
end;
procedure TEmitter.EmitOP_GET_DRTTI_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift, FT: Integer;
begin
FT := SymbolRecR.FinalTypeId;
if FT in INT64Types then
SubId := Id_GetDRTTIInt64Property
else if FT in IntegerTypes then
SubId := Id_GetDRTTIIntegerProperty
else if FT in StringTypes then
SubId := Id_GetDRTTIStringProperty
else if FT in RealTypes then
SubId := Id_GetDRTTIExtendedProperty
else if FT in VariantTypes then
SubId := Id_GetDRTTIVariantProperty
else
SubId := Id_GetDRTTIProperty;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_DRTTI_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift, FT: Integer;
begin
FT := SymbolRecR.FinalTypeId;
if FT in INT64Types then
SubId := Id_GetDRTTIInt64Property
else if FT in IntegerTypes then
SubId := Id_GetDRTTIIntegerProperty
else if FT in StringTypes then
SubId := Id_GetDRTTIStringProperty
else if FT in RealTypes then
SubId := Id_GetDRTTIExtendedProperty
else if FT in VariantTypes then
SubId := Id_GetDRTTIVariantProperty
else
SubId := Id_GetDRTTIProperty;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_DRTTI_PROP_64;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetDRTTIProperty;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_DRTTI_PROP;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetDRTTIProperty;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_ANSISTR_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetAnsiStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_ANSISTR_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetAnsiStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_ANSISTR_PROP_64;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetAnsiStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
{$IFNDEF PAXARM}
if SymbolRecR.HasPAnsiCharType then
EmitGet_REG(Reg, SymbolRecR)
else
{$ENDIF}
EmitLoadIntVal(Reg, SymbolRecR); // value
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_ANSISTR_PROP;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetAnsiStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
{$IFNDEF PAXARM}
if SymbolRecR.HasPAnsiCharType then
EmitGet_REG(Reg, SymbolRecR)
else
{$ENDIF}
EmitLoadIntVal(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_WIDESTR_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetWideStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_WIDESTR_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetWideStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_WIDESTR_PROP_64;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetWideStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
{$IFNDEF PAXARM}
if SymbolRecR.HasPAnsiCharType then
EmitGet_REG(Reg, SymbolRecR)
else
{$ENDIF}
EmitLoadIntVal(Reg, SymbolRecR); // value
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_WIDESTR_PROP;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetWideStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
{$IFNDEF PAXARM}
if SymbolRecR.HasPAnsiCharType then
EmitGet_REG(Reg, SymbolRecR)
else
{$ENDIF}
EmitLoadIntVal(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_UNICSTR_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetUnicStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_UNICSTR_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetUnicStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_UNICSTR_PROP_64;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetUnicStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
if SymbolRecR.HasPWideCharType then
EmitGet_REG(Reg, SymbolRecR)
else
EmitLoadIntVal(Reg, SymbolRecR); // value
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_UNICSTR_PROP;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetUnicStrProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
if SymbolRecR.HasPWideCharType then
EmitGet_REG(Reg, SymbolRecR)
else
EmitLoadIntVal(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_ORD_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetOrdProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_ORD_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetOrdProp;
EmitPCodeOperator;
Emit_PUSH_REGS;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_SET_ORD_PROP_64;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetOrdProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadIntVal(Reg, SymbolRecR); // value
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_ORD_PROP;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetOrdProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_INTERFACE_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetInterfaceProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_INTERFACE_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetInterfaceProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_INTERFACE_PROP_64;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetOrdProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadIntVal(Reg, SymbolRecR); // value
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_INTERFACE_PROP;
var
SubId, Reg, PropIndex, ClassId, Shift: Integer;
begin
SubId := Id_SetOrdProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadIntVal(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_SET_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetSetProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_SET_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetSetProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_SET_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_SetSetProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_SET_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_SetSetProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_FLOAT_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetFloatProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_FLOAT_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetFloatProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_FLOAT_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_SetFloatProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_FLOAT_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_SetFloatProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_VARIANT_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetVariantProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_VARIANT_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetVariantProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_VARIANT_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_SetVariantProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_VARIANT_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_SetVariantProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_INT64_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetInt64Prop;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_INT64_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetInt64Prop;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_INT64_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_SetInt64Prop;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_INT64_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_SetInt64Prop;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // value
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_EVENT_PROP_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetEventProp;
EmitPCodeOperator;
EmitCallPro(SubId);
HandlesEvents := true;
Reg := GetRegEx;
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R8, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_GET_EVENT_PROP;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_GetEventProp;
EmitPCodeOperator;
EmitCallPro(SubId);
HandlesEvents := true;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_EVENT_PROP2_64;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_SetEventProp2;
EmitPCodeOperator;
EmitCallPro(SubId);
HandlesEvents := true;
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_R8, Reg);
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmMovREG_REG(_R9, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_EVENT_PROP2;
var
SubId, Reg, ClassId, PropIndex, Shift: Integer;
begin
SubId := Id_SetEventProp2;
EmitPCodeOperator;
EmitCallPro(SubId);
HandlesEvents := true;
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR); // result
Prg.AsmPush_REG(Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_EVENT_PROP_64;
var
SubId, Reg, ClassId,
PropIndex, Shift, CodeId, DataId, CallConv, RetSize: Integer;
R: TSymbolRec;
begin
SubId := Id_SetEventProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetRegEx;
HandlesEvents := true;
if SymbolRecR.Id = TKernel(kernel).SymbolTable.NilId then
begin
R := TKernel(kernel).SymbolTable.AddIntegerConst(0);
R.MustBeAllocated := true;
DataId := R.Id;
R := TKernel(kernel).SymbolTable.AddIntegerConst(0);
R.MustBeAllocated := true;
CodeId := R.Id;
CallConv := ccREGISTER;
RetSize := 0;
end
else
begin
DataId := SymbolRecR.OwnerId;
CodeId := SymbolRecR.PatternId;
if GetSymbolRec(DataId).Kind = KindTYPE then
Inc(DataId);
CallConv := GetSymbolRec(CodeId).CallConv;
RetSize := SymbolTable.GetSizeOfParams(CodeId);
end;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmMovREG_REG(_ECX, Reg); // push TProgram.Self
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmMovREG_REG(_R8, Reg);
if GetSymbolRec(CodeId).Host then
begin
EmitGet_REG(Reg, GetSymbolRec(CodeId));
end
else
begin
Prg.AsmMovREG_REG(Reg, _EDI);
Prg.AsmAddREG_Imm(Reg, 0);
Prg.Top.SaveSubId := CodeId;
List2.Add(Prg.Top);
end;
Prg.AsmMovREG_REG(_R9, Reg);
EmitLoadIntVal(Reg, GetSymbolRec(DataId)); // data
Prg.AsmMovRSPPtr_REG64(Reg, $20);
Prg.AsmMovREG_Imm(Reg, CallConv);
Prg.AsmMovRSPPtr_REG64(Reg, $28);
Prg.AsmMovREG_Imm(Reg, RetSize);
Prg.AsmMovRSPPtr_REG64(Reg, $30);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_SET_EVENT_PROP;
var
SubId, Reg, ClassId,
PropIndex, Shift, CodeId, DataId, CallConv, RetSize: Integer;
R: TSymbolRec;
begin
SubId := Id_SetEventProp;
EmitPCodeOperator;
EmitCallPro(SubId);
Reg := GetReg;
HandlesEvents := true;
if SymbolRecR.Id = TKernel(kernel).SymbolTable.NilId then
begin
R := TKernel(kernel).SymbolTable.AddIntegerConst(0);
R.MustBeAllocated := true;
DataId := R.Id;
R := TKernel(kernel).SymbolTable.AddIntegerConst(0);
R.MustBeAllocated := true;
CodeId := R.Id;
CallConv := ccREGISTER;
RetSize := 0;
end
else
begin
DataId := SymbolRecR.OwnerId;
CodeId := SymbolRecR.PatternId;
if GetSymbolRec(DataId).Kind = KindTYPE then
Inc(DataId);
CallConv := GetSymbolRec(CodeId).CallConv;
RetSize := SymbolTable.GetSizeOfParams(CodeId);
end;
Prg.AsmPush_Imm(RetSize);
Prg.AsmPush_Imm(CallConv);
EmitLoadIntVal(Reg, GetSymbolRec(DataId)); // data
Prg.AsmPush_REG(Reg);
if GetSymbolRec(CodeId).Host then
begin
EmitGet_REG(Reg, GetSymbolRec(CodeId));
Prg.AsmPush_REG(Reg);
end
else
begin
Prg.AsmMovREG_REG(Reg, _EDI);
Prg.AsmAddREG_Imm(Reg, 0);
Prg.Top.SaveSubId := CodeId;
List2.Add(Prg.Top);
Prg.AsmPush_REG(Reg);
end;
EmitLoadIntVal(Reg, SymbolRec1); // instance
Prg.AsmPush_REG(Reg);
// push ppi
PropIndex := SymbolRec2.PropIndex;
ClassId := GetSymbolRec(SymbolRec1.TerminalHostClassId).Id;
Shift := GetOffset(GetSymbolRec(ClassId + 1));
Inc(Shift, (PropIndex + 1) * SizeOfPointer);
Prg.AsmGetREG_ESIPtr(Reg, Shift);
Prg.AsmPush_REG(Reg);
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_EMIT_ON;
begin
EmitPCodeOperator;
EmitOff := false;
end;
procedure TEmitter.EmitOP_EMIT_OFF;
begin
EmitPCodeOperator;
EmitOff := true;
end;
procedure TEmitter.EmitOP_CREATE_OBJECT_64;
var
Reg, SubId, Id: Integer;
begin
EmitPCodeOperator;
SubId := Id_CreateObject;
EmitCallPro(SubId);
Reg := GetRegEx;
Id := TKernel(kernel).Code.GetCurrSelfId(TKernel(kernel).Code.N);
EmitLoadIntVal(Reg, GetSymbolRec(Id));
Prg.AsmMovREG_REG(_ECX, Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmMovREG_REG(_EDX, Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_CREATE_OBJECT;
var
Reg, SubId, Id: Integer;
begin
EmitPCodeOperator;
SubId := Id_CreateObject;
EmitCallPro(SubId);
Reg := GetReg;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmPush_REG(Reg);
// TypeId := SymbolRec1.TerminalTypeId;
// EmitLoadIntVal(Reg, GetSymbolRec(TypeId + 1));
Id := TKernel(kernel).Code.GetCurrSelfId(TKernel(kernel).Code.N);
EmitLoadIntVal(Reg, GetSymbolRec(Id));
Prg.AsmPush_REG(Reg);
FreeReg(Reg);
EmitStdCall(SubId);
end;
procedure TEmitter.EmitOP_DESTROY_OBJECT_64;
begin
end;
procedure TEmitter.EmitOP_DESTROY_OBJECT;
begin
end;
procedure TEmitter.EmitOP_PUSH_PROG; // stdcall expected on win32
var
Reg: Integer;
begin
EmitPCodeOperator;
Reg := GetRegEx;
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, H_SelfPtr);
Prg.AsmMovREG_REGPtr(Reg, Reg); // load TProgram.Self
if TargetPlatform = tpWIN64 then
Prg.AsmMovREG_REG(_ECX, Reg) // push TProgram.Self
else
Prg.AsmPush_REG(Reg); // push TProgram.Self
FreeReg(Reg);
end;
procedure TEmitter.EmitOP_GET_VMT_ADDRESS_64;
var
Reg, MethodIndex, I, msg_id: Integer;
SymbolProgRec: TSymbolProgRec;
begin
EmitPCodeOperator;
msg_id := SymbolRec2.DynamicMethodIndex;
if msg_id = 0 then
begin
I := TKernel(kernel).MessageList.IndexOf(SymbolRec2.FullName);
if I >= 0 then
msg_id := TKernel(kernel).MessageList[I].msg_id;
end;
if msg_id <> 0 then
begin
Emit_PUSH_REGS;
Reg := GetRegEx;
EmitLoadIntVal(Reg, SymbolRec1); // instance
if SymbolRec1.FinalTypeId <> typeCLASSREF then
prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmMovREG_REG(_ECX, Reg);
Prg.AsmMovREG_Imm(Reg, msg_id);
Prg.AsmMovREG_REG(_EDX, Reg);
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmMovREG_REG(_R8, Reg);
EmitGet_REG(Reg, SymbolTable[Id_GetDynamicMethodAddress]);
Prg.AsmCall_REG(Reg);
FreeReg(Reg);
Emit_POP_REGS;
Exit;
end;
if IsLocalPos then
Emit_PUSH_REGS;
Reg := GetRegEx;
MethodIndex := SymbolRec2.MethodIndex;
EmitLoadIntVal(Reg, SymbolRec1); // instance
if SymbolRec1.FinalTypeId <> typeCLASSREF then
prg.AsmMovREG_REGPtr(Reg, Reg);
if MethodIndex = 0 then
begin
SymbolProgRec := prg.AsmAddREG_Imm(Reg, 0);
SymbolProgRec.MustBeFixed := true;
SymbolProgRec.OpOffset := 2;
SymbolProgRec.SubId := SymbolRec2.Id;
end
else
begin
prg.AsmAddREG_Imm(Reg, (MethodIndex - 1) * SizeOfPointer);
{$IFDEF FPC}
prg.AsmAddREG_Imm(Reg, FPC_VIRTUAL_OFFSET);
{$ENDIF}
end;
prg.AsmMovREG_REGPtr(Reg, Reg);
EmitSaveIntVal(Reg, SymbolRecR); // result
FreeReg(Reg);
if IsLocalPos then
Emit_POP_REGS;
end;
procedure TEmitter.EmitOP_GET_VMT_ADDRESS;
var
Reg, MethodIndex, I, msg_id: Integer;
SymbolProgRec: TSymbolProgRec;
begin
EmitPCodeOperator;
msg_id := SymbolRec2.DynamicMethodIndex;
if msg_id = 0 then
begin
I := TKernel(kernel).MessageList.IndexOf(SymbolRec2.FullName);
if I >= 0 then
msg_id := TKernel(kernel).MessageList[I].msg_id;
end;
if msg_id <> 0 then
begin
Emit_PUSH_REGS;
Reg := GetRegEx;
EmitLoadAddress(Reg, SymbolRecR);
Prg.AsmPush_REG(Reg);
Prg.AsmPush_Imm(msg_id);
EmitLoadIntVal(Reg, SymbolRec1); // instance
if SymbolRec1.FinalTypeId <> typeCLASSREF then
prg.AsmMovREG_REGPtr(Reg, Reg);
Prg.AsmPush_REG(Reg);
EmitGet_REG(Reg, SymbolTable[Id_GetDynamicMethodAddress]);
Prg.AsmCall_REG(Reg);
FreeReg(Reg);
Emit_POP_REGS;
Exit;
end;
if IsLocalPos then
Emit_PUSH_REGS;
Reg := GetRegEx;
MethodIndex := SymbolRec2.MethodIndex;
EmitLoadIntVal(Reg, SymbolRec1); // instance
if SymbolRec1.FinalTypeId <> typeCLASSREF then
prg.AsmMovREG_REGPtr(Reg, Reg);
if MethodIndex = 0 then
begin
SymbolProgRec := prg.AsmAddREG_Imm(Reg, 0);
SymbolProgRec.MustBeFixed := true;
SymbolProgRec.OpOffset := 2;
SymbolProgRec.SubId := SymbolRec2.Id;
end
else
begin
prg.AsmAddREG_Imm(Reg, (MethodIndex - 1) * SizeOfPointer);
{$IFDEF FPC}
prg.AsmAddREG_Imm(Reg, FPC_VIRTUAL_OFFSET);
{$ENDIF}
end;
prg.AsmMovREG_REGPtr(Reg, Reg);
EmitSaveIntVal(Reg, SymbolRecR); // result
FreeReg(Reg);
if IsLocalPos then
Emit_POP_REGS;
end;
function TEmitter.HasTheSameAddressRegister(S1, S2: TSymbolRec): Boolean;
var
t: Integer;
function RR(S: TSymbolRec): Integer;
begin
Inc(t);
if (S.Local or S.Param) and (not S.OverScript) then // local
begin
if S.ByRef or S.ByRefEx then
result := t
else
begin
if S.Level = ContextStack.Top then
result := _EBP
else
result := t;
end;
end
else // global
begin
if S.Host or S.ByRef or S.ByRefEx then
result := t
else
result := _ESI;
end;
end;
begin
t := 100;
result := RR(S1) = RR(S2);
end;
function TEmitter.EmitGetAddressRegister(S: TSymbolRec): Integer;
// returns a register.
// If it returns ESI or EBP, address = result + S.Shift !!
// otherwise, address = result
// Caller must free the register !!
var
temp: Integer;
begin
if (S.Local or S.LocalInternalField or S.Param) and (not S.OverScript) then
begin
if S.ByRef or S.ByRefEx then
begin
result := GetReg;
EmitGet_REG(result, S);
end
else
begin
if S.Level = ContextStack.Top then
result := _EBP
else
begin
result := GetReg;
EmitRestoreEBP(result, S);
Prg.AsmAddREG_Imm(result, GetOffset(S));
end;
end;
end
else // global
begin
if S.Host or S.ByRef or S.ByRefEx then
begin
result := GetReg;
temp := S.FinSize;
S.FinSize := SizeOf(IntPax);
EmitGet_REG(result, S);
S.FinSize := temp;
end
else
result := _ESI;
end;
end;
procedure TEmitter.EmitFLD(S: TSymbolRec);
var
Reg: Integer;
begin
Reg := EmitGetAddressRegister(S);
case S.FinalTypeId of
typeDOUBLE: Prg.AsmFldDouble_REGPtr(Reg, S);
typeSINGLE: Prg.AsmFldSingle_REGPtr(Reg, S);
typeEXTENDED: Prg.AsmFldExtended_REGPtr(Reg, S);
else
RaiseError(errInternalError, []);
end;
FreeReg(Reg);
end;
procedure TEmitter.EmitFild(S: TSymbolRec);
var
Reg, TempReg: Integer;
begin
Reg := GetReg;
EmitLoadAddress(Reg, S);
if S.PtrSize = 8 then
Prg.AsmFild_REG64Ptr(Reg)
else if S.FinalTypeId in IntegerTypes then
begin
EmitLoadAddress(Reg, S);
case S.PtrSize of
1:
begin
TempReg := GetReg;
Prg.AsmXorREG_REG(TempReg, TempReg);
Prg.AsmMovREG8_REGPtr(TempReg, Reg);
Prg.AsmPush_REG(TempReg);
Prg.AsmMovREG_REG(TempReg, _ESP);
Prg.AsmFild_REG32Ptr(TempReg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
2: Prg.AsmFild_REG16Ptr(Reg);
4: Prg.AsmFild_REG32Ptr(Reg);
end;
end
else
RaiseError(errInternalError, []);
FreeReg(Reg);
end;
procedure TEmitter.EmitFSTP(S: TSymbolRec);
var
Reg: Integer;
begin
Reg := EmitGetAddressRegister(S);
case S.FinalTypeId of
typeDOUBLE: Prg.AsmFStpDouble_REGPtr(Reg, S);
typeSINGLE: Prg.AsmFStpSingle_REGPtr(Reg, S);
typeEXTENDED: Prg.AsmFStpExtended_REGPtr(Reg, S);
else
RaiseError(errInternalError, []);
end;
FreeReg(Reg);
end;
procedure TEmitter.EmitJmp;
begin
List3.Add(SymbolRec1);
Prg.AsmJMP_Imm(0);
List1.Add(Prg.Top);
end;
procedure TEmitter.EmitOP_EQ_EVENT_64;
begin
RaiseNotImpl;
end;
procedure TEmitter.EmitOP_NE_EVENT_64;
begin
RaiseNotImpl;
end;
procedure TEmitter.EmitLoadAddress(Reg: Integer; S: TSymbolRec);
var
temp: Integer;
begin
if (S.Local or S.LocalInternalField or S.Param) and (not S.OverScript) then
begin
if S.ByRef or S.ByRefEx then
begin
EmitGet_REG(Reg, S);
end
else
begin
if S.Level = ContextStack.Top then
begin
Prg.AsmMovREG_REG(Reg, _EBP);
Prg.AsmAddREG_Imm(Reg, GetOffset(S));
end
else
begin
EmitRestoreEBP(Reg, S);
Prg.AsmAddREG_Imm(Reg, GetOffset(S));
end;
end;
end
else // global
begin
if S.Host or S.ByRef or S.ByRefEx then
begin
temp := S.FinSize;
S.FinSize := SizeOf(IntPax);
EmitGet_REG(Reg, S);
S.FinSize := temp;
end
else
begin
Prg.AsmMovREG_REG(Reg, _ESI);
Prg.AsmAddREG_Imm(Reg, GetOffset(S));
end;
end;
end;
procedure TEmitter.EmitLoadIntVal(Reg: Integer; S: TSymbolRec);
var
TempReg, Temp: Integer;
C: Cardinal;
begin
if (S.Kind = KindCONST) and (not (S.FinalTypeId in RealTypes + [typeCURRENCY])) then
begin
C := S.Value;
Prg.AsmMovREG_Imm(Reg, C);
end
else
begin
if S.Host or S.ByRef or S.ByRefEx then
begin
temp := S.FinSize;
S.FinSize := SizeOf(IntPax);
EmitGet_REG(Reg, S);
S.FinSize := temp;
case S.PtrSize of
1:
begin
if TargetPlatform = tpWIN64 then
TempReg := GetReg64
else
TempReg := GetReg;
Prg.AsmPush_REG(TempReg);
Prg.AsmMovREG_Imm(TempReg, 0);
Prg.AsmMovREG8_REGPtr(TempReg, Reg);
Prg.AsmMovREG_REG(Reg, TempReg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
2:
begin
if TargetPlatform = tpWIN64 then
TempReg := GetReg64
else
TempReg := GetReg;
Prg.AsmPush_REG(TempReg);
Prg.AsmMovREG_Imm(TempReg, 0);
Prg.AsmMovREG16_REGPtr(TempReg, Reg);
Prg.AsmMovREG_REG(Reg, TempReg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
else
begin
if TargetPlatform = tpWIN64 then
begin
case S.PtrSize of
4: Prg.AsmMovREG32_REGPtr(Reg, Reg);
8: Prg.AsmMovREG64_REGPtr(Reg, Reg);
else
RaiseError(errInternalError, []);
end;
end
else
Prg.AsmMovREG32_REGPtr(Reg, Reg);
end;
end; //case
end
else
begin
if S.PtrSize < SizeOfPointer then
Prg.AsmMovREG_Imm(Reg, 0);
EmitGet_REG(Reg, S);
end;
end;
end;
procedure TEmitter.EmitSaveIntVal(Reg: Integer; S: TSymbolRec);
var
RegR: Integer;
begin
if S.Host or S.ByRef or S.ByRefEx then
begin
RegR := GetReg;
EmitLoadAddress(RegR, S);
case S.PtrSize of
1: Prg.AsmMovREGPtr_REG8(RegR, Reg);
2: Prg.AsmMovREGPtr_REG16(RegR, Reg);
else
begin
if TargetPlatform = tpWIN64 then
begin
case S.PtrSize of
4: Prg.AsmMovREGPtr_REG32(RegR, Reg);
8: Prg.AsmMovREGPtr_REG64(RegR, Reg);
else
RaiseError(errInternalError, []);
end;
end
else
Prg.AsmMovREGPtr_REG32(RegR, Reg);
end;
end;
FreeReg(RegR);
end
else
EmitPut_REG(Reg, S);
end;
procedure TEmitter.EmitPut_REG_64(Reg: Integer; S: TSymbolRec; ExtraShift: Integer = 0);
// Reg contains a 32-bit value
// S - destination
var
SZ, TempReg: Integer;
begin
SZ := S.Size;
case SZ of
1:
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmPutREG8_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg64;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREGPtr_REG8(TempReg, Reg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
Prg.AsmPutREG8_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
2:
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmPutREG16_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg64;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREGPtr_REG16(TempReg, Reg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
Prg.AsmPutREG16_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
4:
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmPutREG32_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg64;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREGPtr_REG32(TempReg, Reg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
Prg.AsmPutREG32_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
8:
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmPutREG64_RBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg64;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREGPtr_REG64(TempReg, Reg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
Prg.AsmPutREG64_RSIPtr(Reg, GetOffset(S) + ExtraShift);
end;
else
RaiseError(errInternalError, []);
end;
end;
procedure TEmitter.EmitPut_REG(Reg: Integer; S: TSymbolRec; ExtraShift: Integer = 0);
// Reg contains a 32-bit value
// S - destination
var
SZ, TempReg: Integer;
begin
if TargetPlatform = tpWIN64 then
begin
EmitPut_REG_64(Reg, S, ExtraShift);
Exit;
end;
SZ := S.Size;
case SZ of
1:
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmPutREG8_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREGPtr_REG8(TempReg, Reg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
Prg.AsmPutREG8_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
2:
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmPutREG16_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREGPtr_REG16(TempReg, Reg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
Prg.AsmPutREG16_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
else
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmPutREG32_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREGPtr_REG32(TempReg, Reg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
Prg.AsmPutREG32_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
end;
end;
procedure TEmitter.EmitGet_REG_64(Reg: Integer; S: TSymbolRec; ExtraShift: Integer = 0);
// S - source
// Reg - destination
var
SZ, TempReg: Integer;
begin
SZ := S.Size;
case SZ of
1:
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmGetREG8_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg64;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREG_Imm(Reg, 0);
Prg.AsmMovREG8_REGPtr(Reg, TempReg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
begin
Prg.AsmMovREG_Imm(Reg, 0);
Prg.AsmGetREG8_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
end;
2:
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmGetREG16_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg64;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREG_Imm(Reg, 0);
Prg.AsmMovREG16_REGPtr(Reg, TempReg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
begin
Prg.AsmMovREG_Imm(Reg, 0);
Prg.AsmGetREG16_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
end;
4:
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmGetREG32_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg64;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREG32_REGPtr(Reg, TempReg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
Prg.AsmGetREG32_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
else
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmGetREG64_RBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg64;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREG64_REGPtr(Reg, TempReg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
Prg.AsmGetREG64_RSIPtr(Reg, GetOffset(S) + ExtraShift);
end;
end;
end;
procedure TEmitter.EmitGet_REG(Reg: Integer; S: TSymbolRec; ExtraShift: Integer = 0);
// S - source
// Reg - destination
var
SZ, TempReg: Integer;
begin
if TargetPlatform = tpWIN64 then
begin
EmitGet_REG_64(Reg, S, ExtraShift);
Exit;
end;
SZ := S.Size;
case SZ of
1:
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmGetREG8_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmXorREG_REG(Reg, Reg);
Prg.AsmMovREG8_REGPtr(Reg, TempReg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
begin
Prg.AsmXorREG_REG(Reg, Reg);
Prg.AsmGetREG8_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
end;
2:
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmGetREG16_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmXorREG_REG(Reg, Reg);
Prg.AsmMovREG16_REGPtr(Reg, TempReg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
begin
Prg.AsmXorREG_REG(Reg, Reg);
Prg.AsmGetREG16_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
end;
else
begin
if (S.Param or S.Local or S.LocalInternalField) and (not S.OverScript) then // local
begin
if S.Level = ContextStack.Top then
Prg.AsmGetREG32_EBPPtr(Reg, GetOffset(S) + ExtraShift)
else
begin
TempReg := GetReg;
Prg.AsmPush_REG(TempReg);
EmitRestoreEBP(TempReg, S);
Prg.AsmAddREG_Imm(TempReg, GetOffset(S) + ExtraShift);
Prg.AsmMovREG32_REGPtr(Reg, TempReg);
Prg.AsmPop_REG(TempReg);
FreeReg(TempReg);
end;
end
else // global
Prg.AsmGetREG32_ESIPtr(Reg, GetOffset(S) + ExtraShift);
end;
end;
end;
procedure TEmitter.EmitRestoreEBP_64(Reg: Integer; S: TSymbolRec);
var
I, Index, SubId, RBP_Id: Integer;
begin
SubId := S.Level;
Index := ContextStack.IndexOf(SubId);
if ContextStack.Count > 2 then
Prg.AsmPush_REG(_EBP);
for I:=ContextStack.Count - 1 downto Index + 1 do
begin
SubId := ContextStack[I];
RBP_Id := SymbolTable.GetRBP_Id(SubId);
Prg.AsmGetREG64_RBPPtr(Reg, GetOffset(GetSymbolRec(RBP_Id)));
if ContextStack.Count > 2 then
if I <> Index + 1 then
Prg.AsmMovREG_REG(_EBP, Reg);
end;
if ContextStack.Count > 2 then
Prg.AsmPop_REG(_EBP);
end;
procedure TEmitter.EmitRestoreEBP(Reg: Integer; S: TSymbolRec);
var
I, Index, SubId, EBP_Id: Integer;
begin
if TargetPlatform = tpWIN64 then
begin
EmitRestoreEBP_64(Reg, S);
Exit;
end;
SubId := S.Level;
Index := ContextStack.IndexOf(SubId);
if ContextStack.Count > 2 then
Prg.AsmPush_REG(_EBP);
for I:=ContextStack.Count - 1 downto Index + 1 do
begin
SubId := ContextStack[I];
EBP_Id := SymbolTable.GetRBP_Id(SubId);
Prg.AsmGetREG_EBPPtr(Reg, GetOffset(GetSymbolRec(EBP_Id)));
if ContextStack.Count > 2 then
if I <> Index + 1 then
Prg.AsmMovREG_REG(_EBP, Reg);
end;
if ContextStack.Count > 2 then
Prg.AsmPop_REG(_EBP);
end;
procedure TEmitter.Emit_PUSH_REGS(SubId: Integer = 0);
begin
if SubId > 0 then
if not (GetSymbolRec(SubId).CallConv in [ccREGISTER, cc64, ccMSFASTCALL]) then
Exit;
case TargetPlatform of
tpOSX32, tpIOSSim: SaveRegisters([_EAX, _ECX, _EDX, _EBX]);
tpWIN64: SaveRegisters([_ECX, _EDX, _R8, _R9]);
else
SaveRegisters([_EAX, _ECX, _EDX]);
end;
end;
procedure TEmitter.Emit_POP_REGS(SubId: Integer = 0);
begin
if SubId > 0 then
if not (GetSymbolRec(SubId).CallConv in [ccREGISTER, cc64, ccMSFASTCALL]) then
Exit;
case TargetPlatform of
tpOSX32, tpIOSSim: RestoreRegisters([_EAX, _ECX, _EDX, _EBX]);
tpWIN64: RestoreRegisters([_ECX, _EDX, _R8, _R9]);
else
RestoreRegisters([_EAX, _ECX, _EDX]);
end;
end;
procedure TEmitter.Emit_PUSH_REGS_EX;
begin
case TargetPlatform of
tpOSX32, tpIOSSim: SaveRegisters([_EAX, _ECX, _EDX, _EBX, _ESI, _EDI]);
tpWIN64: SaveRegisters([_EAX, _ECX, _EDX, _ESI, _EDI]);
else
SaveRegisters([_EAX, _ECX, _EDX, _ESI, _EDI]);
end;
end;
procedure TEmitter.Emit_POP_REGS_EX;
begin
case TargetPlatform of
tpOSX32, tpIOSSim: RestoreRegisters([_EAX, _ECX, _EDX, _EBX, _ESI, _EDI]);
tpWIN64: RestoreRegisters([_EAX, _ECX, _EDX, _ESI, _EDI]);
else
RestoreRegisters([_EAX, _ECX, _EDX, _ESI, _EDI]);
end;
end;
procedure TEmitter.CopyContextStack(AStack: TIntegerStack);
var
I: Integer;
begin
for I := 0 to AStack.Count - 1 do
ContextStack.Push(AStack[I]);
end;
function TEmitter.GetSaveRegAreaOffset: Integer;
begin
result := $60;
end;
procedure TEmitter.SaveRegisters(const A: array of Integer;
ExtraOffset: Integer = 0);
var
I, S, Reg: Integer;
begin
case TargetPlatform of
tpOSX32, tpIOSSim:
begin
for I := 0 to System.Length(A) - 1 do
Prg.AsmPush_REG(A[I]);
S := System.Length(A) mod 4;
if S <> 0 then
Prg.AsmSubREG_Imm(_ESP, 16 - S * 4);
end;
tpWIN64:
begin
S := GetSaveRegAreaOffset + ExtraOffset;
for I := 0 to System.Length(A) - 1 do
begin
Reg := A[I];
Prg.AsmMovRSPPtr_REG64(Reg, S);
Inc(S, 8);
end;
end;
else
for I := 0 to System.Length(A) - 1 do
Prg.AsmPush_REG(A[I]);
end;
end;
procedure TEmitter.RestoreRegisters(const A: array of Integer;
ExtraOffset: Integer = 0);
var
I, S, Reg: Integer;
begin
case TargetPlatform of
tpOSX32, tpIOSSim:
begin
S := System.Length(A) mod 4;
if S <> 0 then
Prg.AsmAddREG_Imm(_ESP, 16 - S * 4);
for I := System.Length(A) - 1 downto 0 do
Prg.AsmPop_REG(A[I]);
end;
tpWIN64:
begin
S := GetSaveRegAreaOffset + ExtraOffset;
for I := 0 to System.Length(A) - 1 do
begin
Reg := A[I];
Prg.AsmMovREG64_RSPPtr(Reg, S);
Inc(S, 8);
end;
end;
else
for I := System.Length(A) - 1 downto 0 do
Prg.AsmPop_REG(A[I]);
end;
end;
procedure TEmitter.EmitPushParam_64(Reg: Integer);
var
SubId, ParamNumber, ParamId: Integer;
begin
SubId := R.Res;
if GetSymbolRec(SubId).CallConv <> cc64 then
begin
Prg.AsmPush_REG(Reg);
Exit;
end;
ParamNumber := R.Arg2;
ParamId := SymbolTable.GetParamId(SubId, ParamNumber);
Prg.AsmMovRSPPtr_REG64(Reg, GetSymbolRec(ParamId).RSPOffset);
end;
procedure TEmitter.EmitPushParam(Reg: Integer);
begin
if TargetPlatform = tpWIN64 then
EmitPushParam_64(Reg)
else
Prg.AsmPush_REG(Reg);
end;
procedure TEmitter.EmitCallPro(SubId: Integer; InitSize: Integer = - 1);
var
K, cc, sz, S: Integer;
begin
if not (TargetPlatform in [tpOSX32, tpIOSSim]) then
Exit;
K := GetSymbolRec(SubId).Kind;
if not (K in KindSUBS) then
Exit;
// Prg.EmitGetCallerEIP;
// EmitSaveRBX;
cc := GetSymbolRec(SubId).CallConv;
if InitSize = - 1 then
sz := TKernel(kernel).SymbolTable.GetSizeOfParams(SubId)
else
sz := InitSize;
case cc of
ccREGISTER:
begin
S := 12 - (sz mod 16);
prg.AsmSubREG_Imm(_ESP, S);
end;
ccSTDCALL:
begin
prg.AsmPush_Imm($80000000 + R1(sz));
prg.AsmPush_Reg(_EBP);
prg.AsmPush_Imm($beeffeed);
prg.AsmSubREG_Imm(_ESP, R2(sz));
end;
ccCDECL:
begin
prg.AsmPush_Imm(R1(sz));
prg.AsmPush_Reg(_EBP);
prg.AsmPush_Imm($beeffeed);
prg.AsmSubREG_Imm(_ESP, R2(sz));
end;
ccPASCAL:
begin
S := 12 - (sz mod 16);
prg.AsmSubREG_Imm(_ESP, S);
end;
else
RIE;
end;
end;
procedure TEmitter.EmitStdCall(SubId: Integer; InitSize: Integer = - 1);
begin
if TargetPlatform in [tpOSX32, tpIOSSim] then
begin
EmitSaveRDI;
EmitRestoreRBX;
EmitGet_REG(_EDI, SymbolTable[SubId]);
Prg.AsmCall_REG(_EDI);
EmitCallEpi(SubId, InitSize);
EmitRestoreRDI;
end
else
begin
EmitGet_REG(_EBX, SymbolTable[SubId]);
Prg.AsmCall_REG(_EBX);
EmitCallEpi(SubId, InitSize);
end;
end;
procedure TEmitter.EmitCallEpi(SubId: Integer; InitSize: Integer = -1);
var
K, cc, sz, S: Integer;
begin
if not (TargetPlatform in [tpOSX32, tpIOSSim]) then
Exit;
K := GetSymbolRec(SubId).Kind;
if not (K in KindSUBS) then
Exit;
cc := GetSymbolRec(SubId).CallConv;
if InitSize = - 1 then
sz := TKernel(kernel).SymbolTable.GetSizeOfParams(SubId)
else
sz := InitSize;
case cc of
ccREGISTER:
begin
S := 12 - (sz mod 16);
prg.AsmAddREG_Imm(_ESP, S);
end;
ccSTDCALL:
begin
prg.AsmAddREG_Imm(_ESP, R2(sz));
prg.AsmAddREG_Imm(_ESP, $0c);
Prg.AsmIncBytePtr(_ESP, - $0c);
end;
ccCDECL:
begin
prg.AsmAddREG_Imm(_ESP, R3(sz));
Prg.AsmIncBytePtr(_ESP, - $0c);
end;
ccPASCAL:
begin
S := 12 - (sz mod 16);
prg.AsmAddREG_Imm(_ESP, S);
end
else
RIE;
end;
end;
function TEmitter.GetSizeOfPointer: Integer;
begin
if TargetPlatform = tpWIN64 then
result := 8
else
result := 4;
end;
function TEmitter.GetTargetPlatform: TTargetPlatform;
begin
result := TKernel(kernel).TargetPlatform;
end;
procedure EmitProgProc(akernel, aprog: Pointer; context: Pointer = nil);
var
kernel: TKernel;
prog: TProgram;
Emitter: TEmitter;
SymbolProgram: TSymbolProg;
IsEval: Boolean;
begin
kernel := TKernel(akernel);
prog := TProgram(aprog);
IsEval := context <> nil;
Emitter := TEmitter.Create(kernel);
if IsEval then
Emitter.CopyContextStack(TIntegerStack(context));
SymbolProgram := Emitter.CreateSymbolProgram(kernel);
try
if not IsEval then
begin
kernel.Code.CreateMapping(prog.ScriptMapTable, false,
prog.HostMapTable, prog.ScriptMapTable);
prog.CreateMapOffsets;
kernel.Code.CreateExportList(prog.ScriptMapTable);
end;
SymbolProgram.CreateProgram(prog, IsEval);
Dump_All(DUMP_PATH, kernel, prog, SymbolProgram);
finally
FreeAndNil(Emitter);
FreeAndNil(SymbolProgram);
end;
end;
end.
|
unit ConexaoBanco;
interface
uses
SqlExpr, IniFiles, SysUtils, Forms, Windows;
type
TConexaoBanco = class
private
function oConexaoBanco: TSQLConnection;
public
constructor Create;
destructor Destroy; override;
function getConexao: TSQLConnection;
property ConexaoBanco: TSQLConnection read getConexao;
end;
implementation
uses
StrUtils, Math, Messages, DMConexao;
{ TConexaoBanco }
constructor TConexaoBanco.Create;
var
ArquivoIni, Servidor, DataBase, DriverName, UserName, PassWord, MsgERRO: string;
LocalServer: Integer;
Configuracoes: TIniFile;
procedure InicializarVariaveis;
begin
Servidor := '';
DataBase := '';
DriverName := '';
UserName := '';
PassWord := '';
MsgERRO := '';
end;
begin
ArquivoIni := ExtractFilePath(Application.ExeName) + '\config.ini';
InicializarVariaveis;
if not FileExists(ArquivoIni) then
begin
Application.MessageBox('Arquivo de configuração não encontrado.', 'Erro de conexão', MB_ICONERROR or MB_OK);
try
Configuracoes := TIniFile.Create(ArquivoIni);
Configuracoes.WriteString('Dados', 'Servidor', '127.0.0.1');
Configuracoes.WriteString('Dados', 'DataBase', 'wk_felypeprado');
Configuracoes.WriteString('Dados', 'UserName', 'root');
Configuracoes.WriteString('Dados', 'PassWord', 'masterkey');
finally
FreeAndNil(Configuracoes);
end;
end;
begin
Configuracoes := TIniFile.Create(ArquivoIni);
try
Servidor := Configuracoes.ReadString('Dados', 'Servidor', Servidor);
DataBase := Configuracoes.ReadString('Dados', 'DataBase', DataBase);
DriverName := Configuracoes.ReadString('Dados', 'DriverName', DriverName);
UserName := Configuracoes.ReadString('Dados', 'UserName', UserName);
PassWord := Configuracoes.ReadString('Dados', 'PassWord', PassWord);
finally
FreeAndNil(Configuracoes);
end;
if not Assigned(DMConexaoF) then
Application.CreateForm(TDMConexaoF, DMConexaoF);
oConexaoBanco.Connected := False;
oConexaoBanco.LoginPrompt := False;
try
Servidor := IfThen(Trim(Servidor) = '', '127.0.0.1', Servidor);
DataBase := IfThen(Trim(DataBase) = '', 'wk_felypeprado', DataBase);
DriverName := IfThen(Trim(DriverName) = '', 'MySQL', DriverName);
UserName := IfThen(Trim(UserName) = '', 'root', UserName);
PassWord := IfThen(Trim(PassWord) = '', 'masterkey', PassWord);
oConexaoBanco.Params.Values['Database'] := DataBase;
oConexaoBanco.Params.Values['Hostname'] := Servidor;
oConexaoBanco.Params.Values['UserName'] := UserName;
oConexaoBanco.Params.Values['PassWord'] := PassWord;
oConexaoBanco.Connected := True;
except
on e: Exception do
begin
MsgERRO := 'Ocorreu o seguinte erro ao tentar conectar no MySQL.'+#13+#10#13+#10+'Erro "'+e.Message+'".';
Application.MessageBox(PWideChar(MsgERRO), 'Erro de conexão MySQL', MB_ICONERROR + MB_OK);
end;
end;
end;
end;
destructor TConexaoBanco.Destroy;
begin
DMConexaoF.SQLConexao.Close;
FreeAndNil(DMConexaoF);
inherited;
end;
function TConexaoBanco.getConexao: TSQLConnection;
begin
// Result := oConexaoBanco;
Result := DMConexao.DMConexaoF.SQLConexao;
end;
function TConexaoBanco.oConexaoBanco: TSQLConnection;
begin
Result := DMConexao.DMConexaoF.SQLConexao;
end;
end.
|
//------------------------------------------------------------------------------
//CGroundItemRemovalEventThread UNIT
//------------------------------------------------------------------------------
// What it does-
// This thread currently only for one purpose:
// To clean up ground items...
//
// Changes -
// [2008/12/05] Aeomin - Created.
//
//------------------------------------------------------------------------------
unit GroundItemRemovalEventThread;
{$IFDEF FPC}
{$MODE Delphi}
{$ENDIF}
interface
uses
{RTL/VCL}
Classes,
{Project}
{Third Party}
IdThread
;
type
//------------------------------------------------------------------------------
//TCharacterEventThread
//------------------------------------------------------------------------------
TGroundItemEventThread = class(TIdThread)
public
GroundItemList : TThreadList;
constructor Create(AGroundItemList : TThreadList);reintroduce;
procedure Run;override;
end;
//------------------------------------------------------------------------------
implementation
uses
{RTL/VCL}
SysUtils,
SyncObjs,
{Project}
Main,
Event,
ItemInstance,
{3rd Party}
WinLinux
;
//------------------------------------------------------------------------------
//Create CONSTRUCTOR
//------------------------------------------------------------------------------
// What it does-
// Initializes our EventThread
//
// Changes -
// [2008/12/05] Aeomin - Created
//
//------------------------------------------------------------------------------
Constructor TGroundItemEventThread.Create(AGroundItemList : TThreadList);
begin
inherited Create(TRUE, TRUE, 'GroundItemRemovalThread');
GroundItemList := AGroundItemList;
end;{Create}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//Run PROCEDURE
//------------------------------------------------------------------------------
// What it does-
// Let's do it!
//
// Changes -
// [2008/12/05] Aeomin - Created
//
//------------------------------------------------------------------------------
Procedure TGroundItemEventThread.Run;
var
EventIndex : Integer;
CurrentTime : LongWord;
AnItem : TItemInstance;
AGroundItemList : TList;
CriticalSection : TCriticalSection;
begin
//Get the current "Tick" or time.
CurrentTime := GetTick;
CriticalSection := TCriticalSection.Create;
//Loop through the character list
CriticalSection.Enter;
AGroundItemList := GroundItemList.LockList;
try
//Loop through each character's eventlist.
for EventIndex := (AGroundItemList.Count - 1) downto 0 do
begin
AnItem := AGroundItemList[EventIndex];
//Check to see if the event needs to be fired.
if CurrentTime >= AnItem.RemovalTime then
begin
AGroundItemList.Delete(EventIndex);
AnItem.RemoveFromGround;
AnItem.Free;
end;
end;
finally
GroundItemList.UnlockList;
end;
CriticalSection.Leave;
CriticalSection.Free;
//Free up the processor
Sleep(MainProc.ZoneServer.Options.EventTick);
end;//Run
//------------------------------------------------------------------------------
end. |
{: WaterPlane demo
}
unit Unit1;
interface
uses
SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, GLScene, GLObjects, GLLCLViewer, GLWaterPlane,
GLCadencer, ExtCtrls, GLTexture, GLUserShader, OpenGL1x,
GLVectorGeometry, GLGraph, GLVectorTypes, GLState, GLCrossPlatform, GLMaterial,
GLCoordinates, GLBaseClasses, GLRenderContextInfo;
type
TForm1 = class(TForm)
GLScene1: TGLScene;
GLSceneViewer1: TGLSceneViewer;
GLCamera1: TGLCamera;
DCTarget: TGLDummyCube;
GLCadencer1: TGLCadencer;
Timer1: TTimer;
GLWaterPlane1: TGLWaterPlane;
GLMaterialLibrary1: TGLMaterialLibrary;
GLUserShader1: TGLUserShader;
GLSphere1: TGLSphere;
GLDirectOpenGL1: TGLDirectOpenGL;
GLHeightField1: TGLHeightField;
GLLightSource1: TGLLightSource;
procedure Timer1Timer(Sender: TObject);
procedure GLCadencer1Progress(Sender: TObject;
const deltaTime, newTime: double);
procedure FormCreate(Sender: TObject);
procedure GLSceneViewer1MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: integer);
procedure GLSceneViewer1MouseMove(Sender: TObject; Shift: TShiftState;
X, Y: integer);
procedure GLUserShader1DoApply(Sender: TObject; var rci: TRenderContextInfo);
procedure GLSceneViewer1BeforeRender(Sender: TObject);
procedure GLDirectOpenGL1Render(Sender: TObject; var rci: TRenderContextInfo);
procedure GLHeightField1GetHeight(const x, y: single; var z: single;
var color: TVector4f; var texPoint: TTexPoint);
procedure GLUserShader1DoUnApply(Sender: TObject; Pass: integer;
var rci: TRenderContextInfo; var Continue: boolean);
private
{ Private declarations }
public
{ Public declarations }
mx, my: integer;
reflectionToggle: boolean;
procedure ClickWater(x, y: integer);
end;
var
Form1: TForm1;
implementation
{$R *.lfm}
uses GLUtils, OpenGLTokens, GLContext;
procedure TForm1.ClickWater(x, y: integer);
var
ip: TVector;
begin
// create a ripple in the pond on a right-mousebutton click
GLSceneViewer1.Buffer.ScreenVectorIntersectWithPlaneXZ(
VectorMake(x, GLSceneViewer1.Height - y, 0),
GLWaterPlane1.Position.Y, ip);
GLWaterPlane1.CreateRippleAtWorldPos(ip);
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
SetGLSceneMediaDir();
// Load the cube map which is used both for environment and as reflection texture
with GLMaterialLibrary1.Materials[0].Material.Texture do
begin
ImageClassName := TGLCubeMapImage.ClassName;
with Image as TGLCubeMapImage do
begin
// Load all 6 texture map components of the cube map
// The 'PX', 'NX', etc. refer to 'positive X', 'negative X', etc.
// and follow the RenderMan specs/conventions
Picture[cmtPX].LoadFromFile('cm_left.jpg');
Picture[cmtNX].LoadFromFile('cm_right.jpg');
Picture[cmtPY].LoadFromFile('cm_top.jpg');
Picture[cmtNY].LoadFromFile('cm_bottom.jpg');
Picture[cmtPZ].LoadFromFile('cm_back.jpg');
Picture[cmtNZ].LoadFromFile('cm_front.jpg');
end;
end;
GLWaterPlane1.Mask.LoadFromFile('basinMask.bmp');
GLHeightField1.Material.Texture.Image.LoadFromFile('clover.jpg');
end;
procedure TForm1.GLSceneViewer1MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: integer);
begin
mx := x;
my := y;
if ssRight in Shift then
ClickWater(x, y);
end;
procedure TForm1.GLSceneViewer1MouseMove(Sender: TObject; Shift: TShiftState;
X, Y: integer);
begin
if ssLeft in Shift then
begin
GLCamera1.MoveAroundTarget(my - y, mx - x);
// pseudo-fresnel
with GLMaterialLibrary1.LibMaterialByName('CubeMap').Material do
FrontProperties.Diffuse.Alpha :=
0.3 + 0.5 * Sqr(1 - GLCamera1.Position.Y / GLCamera1.DistanceToTarget);
end
else if ssRight in Shift then
ClickWater(x, y);
mx := x;
my := y;
end;
procedure TForm1.GLUserShader1DoApply(Sender: TObject; var rci: TRenderContextInfo);
var
cubeMapMode : Integer;
begin
// Here is the shader trick: the same cubemap is used in reflection mode
// for the pond, and in normal mode for the environment sphere
// Our basic user shader takes care of that.
if reflectionToggle then begin
cubeMapMode:=GL_REFLECTION_MAP_ARB;
rci.GLStates.Enable(stBlend);
end else begin
cubeMapMode:=GL_NORMAL_MAP_ARB;
rci.GLStates.Disable(stBlend);
end;
GL.TexGeni(GL_S, GL_TEXTURE_GEN_MODE, cubeMapMode);
GL.TexGeni(GL_T, GL_TEXTURE_GEN_MODE, cubeMapMode);
GL.TexGeni(GL_R, GL_TEXTURE_GEN_MODE, cubeMapMode);
rci.GLStates.SetBlendFunc(bfSrcAlpha, bfOneMinusSrcAlpha);
end;
procedure TForm1.GLUserShader1DoUnApply(Sender: TObject; Pass: integer;
var rci: TRenderContextInfo; var Continue: boolean);
begin
rci.GLStates.Disable(stBlend);
end;
procedure TForm1.GLSceneViewer1BeforeRender(Sender: TObject);
begin
reflectionToggle := False; // toggle for environment sphere
end;
procedure TForm1.GLDirectOpenGL1Render(Sender: TObject; var rci: TRenderContextInfo);
begin
reflectionToggle := True; // toggle for pond/water plane
end;
procedure TForm1.Timer1Timer(Sender: TObject);
begin
Caption := GLSceneViewer1.FramesPerSecondText + Format(
' / %.3f ms', [GLWaterPlane1.LastIterationStepTime * 1000]);
GLSceneViewer1.ResetPerformanceMonitor;
end;
procedure TForm1.GLCadencer1Progress(Sender: TObject; const deltaTime, newTime: double);
begin
GLSceneViewer1.Invalidate;
end;
procedure TForm1.GLHeightField1GetHeight(const x, y: single; var z: single;
var color: TVector4f; var texPoint: TTexPoint);
begin
z := 0.5 - (GLWaterPlane1.Mask.Bitmap.Canvas.Pixels[Round(x + 64), Round(y + 64)] and
$FF) / 255;
end;
end.
|
unit Unit1;
interface
uses
MVCFramework,
MVCFramework.Commons,
MVCFramework.Serializer.Commons,
MVCFramework.ActiveRecord,
System.Generics.Collections;
type
[ MVCPath('/api') ]
TMyController = class(TMVCController)
public
[ MVCPath ]
[ MVCHTTPMethod([ httpGET ]) ]
procedure Index;
protected
procedure OnBeforeAction(Context: TWebContext; const AActionName: string; var Handled: Boolean); override;
procedure OnAfterAction(Context: TWebContext; const AActionName: string); override;
public
//Sample CRUD Actions for a "Customer" entity
[ MVCPath('/artistas') ]
[ MVCHTTPMethod([ httpGET ]) ]
procedure GetArtistas;
[ MVCPath('/artistas/($id)') ]
[ MVCHTTPMethod([ httpGET ]) ]
procedure GetArtista(id: Integer);
[ MVCPath('/artistas') ]
[ MVCHTTPMethod([ httpPOST ]) ]
procedure CreateArtista;
[ MVCPath('/artistas/($id)') ]
[ MVCHTTPMethod([ httpPUT ]) ]
procedure UpdateArtista(id: Integer);
[ MVCPath('/artistas/($id)') ]
[ MVCHTTPMethod([ httpDELETE ]) ]
procedure DeleteArtista(id: Integer);
constructor Create;override;
destructor Destroy;override;
end;
implementation
uses
System.SysUtils,
MVCFramework.Logger,
System.StrUtils,
EntitiesU, Unit3;
procedure TMyController.Index;
begin
//use Context property to access to the HTTP request and response
Render('Hello DelphiMVCFramework World');
end;
procedure TMyController.OnAfterAction(Context: TWebContext; const AActionName: string);
begin
{ Executed after each action }
inherited;
end;
procedure TMyController.OnBeforeAction(Context: TWebContext; const AActionName: string; var Handled: Boolean);
begin
{ Executed before each action
if handled is true (or an exception is raised) the actual
action will not be called }
inherited;
end;
procedure TMyController.GetArtistas;
var
LArtistas: TObjectList<TArtist>;
begin
LArtistas := TMVCActiveRecord.All<TArtist>;
Render<TArtist>(LArtistas);
end;
procedure TMyController.GetArtista(id: Integer);
var
LArtista : TArtist;
begin
LArtista := TMVCActiveRecord.GetByPK<TArtist>(id);
Render(LArtista);
end;
constructor TMyController.Create;
begin
inherited;
DataModule3 := TDataModule3.Create(nil);
ActiveRecordConnectionsRegistry.AddDefaultConnection(DataModule3.FDConnection1);
end;
procedure TMyController.CreateArtista;
var
LArtista : TArtist;
begin
LArtista := Context.Request.BodyAs<TArtist>;
LArtista.Insert;
Render(201, LArtista);
end;
procedure TMyController.UpdateArtista(id: Integer);
var
LArtista :TArtist;
begin
LArtista := Context.Request.BodyAs<TArtist>;
LArtista.Artistid := id;
LArtista.Update;
Render(LArtista);
end;
procedure TMyController.DeleteArtista(id: Integer);
var
LArtista :TArtist;
begin
LArtista := TMVCActiveRecord.GetByPK<TArtist>(id);
if Assigned(LArtista) then
begin
LArtista.Delete;
Render(200,'Apagado');
end
else
Render(404,'Artista não encontrado.');
end;
destructor TMyController.Destroy;
begin
ActiveRecordConnectionsRegistry.RemoveDefaultConnection;
// DataModule3.Free;
inherited;
end;
end.
|
unit E_UtilsStr;
//------------------------------------------------------------------------------
// Модуль подпрограмм манипуляций со строками
//------------------------------------------------------------------------------
// Содержит утилиты по манипуляциям со строками
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
interface
uses
SysUtils;
//------------------------------------------------------------------------------
//! преобразовать string в ShortString
//------------------------------------------------------------------------------
function String2Short(
const AString: string
): ShortString;
//------------------------------------------------------------------------------
//! преобразовать ShortString в string
//------------------------------------------------------------------------------
function Short2String(
const AString: ShortString
): string;
//------------------------------------------------------------------------------
//! заменить все вхождения символа в строке на другой
//------------------------------------------------------------------------------
function ReplaceSymbol(
const AStr: string;
const AFrom: Char;
const ATo: Char
): string;
//------------------------------------------------------------------------------
//! добавить символ в конец строки, если его там ещё нет
//------------------------------------------------------------------------------
function IncludeLastDelimiter(
const AStr: string;
const ADelim: Char
): string;
//------------------------------------------------------------------------------
//! удалить символ из конца строки, если он совпадает с заданным
//! удаляется только 1 символ
//------------------------------------------------------------------------------
function ExcludeLastDelimiter(
const AStr: string;
const ADelim: Char
): string;
//------------------------------------------------------------------------------
//! найти позицию первого вхождения символа
//! возвращает 0 если символ не найден
//------------------------------------------------------------------------------
function PosFirstDelimiter(
const AStr: string;
const ADelim: Char
): Integer;
//------------------------------------------------------------------------------
//! найти позицию последнего вхождения символа
//! возвращает 0 если символ не найден
//------------------------------------------------------------------------------
function PosLastDelimiter(
const AStr: string;
const ADelim: Char
): Integer;
//------------------------------------------------------------------------------
//!
//------------------------------------------------------------------------------
function ConvHexToByte(
var RPtr: PAnsiChar
): Byte;
//------------------------------------------------------------------------------
implementation
function String2Short(
const AString: string
): ShortString;
var
//!
LString: AnsiString;
//------------------------------------------------------------------------------
begin
LString := AnsiString( AString );
Result := ShortString( LString );
end;
function Short2String(
const AString: ShortString
): string;
var
//!
LString: AnsiString;
//------------------------------------------------------------------------------
begin
LString := AnsiString( AString );
Result := string( AString );
end;
function ReplaceSymbol(
const AStr: string;
const AFrom: Char;
const ATo: Char
): string;
var
//!
LPtr: PChar;
//------------------------------------------------------------------------------
begin
Result := AStr;
if ( Result = '' ) then Exit;
UniqueString( Result );
LPtr := PChar( Result );
while ( LPtr^ <> #0 ) do
begin
if ( LPtr^ = AFrom ) then
LPtr^ := ATo;
Inc( LPtr );
end;
end;
function IncludeLastDelimiter(
const AStr: string;
const ADelim: Char
): string;
begin
if ( AStr = '' ) then Exit( ADelim );
Result := AStr;
if ( Result[Length( Result )] <> ADelim ) then
Result := Result + ADelim;
end;
function ExcludeLastDelimiter(
const AStr: string;
const ADelim: Char
): string;
begin
if ( AStr = '' ) then Exit( '' );
if ( AStr[Length( AStr )] = ADelim ) then
Result := Copy( AStr, 1, Length( AStr ) - 1 )
else
Result := AStr;
end;
function PosFirstDelimiter(
const AStr: string;
const ADelim: Char
): Integer;
begin
for Result := 1 to Length( AStr ) do
begin
if ( AStr[Result] = ADelim ) then Exit;
end;
Result := 0;
end;
function PosLastDelimiter(
const AStr: string;
const ADelim: Char
): Integer;
begin
for Result := Length( AStr ) downto 1 do
begin
if ( AStr[Result] = ADelim ) then Exit;
end;
Result := 0;
end;
function ConvHexToByte(
var RPtr: PAnsiChar
): Byte;
var
//!
UpChar: AnsiChar;
//------------------------------------------------------------------------------
begin
Result := 0;
UpChar := UpCase( RPtr^ );
if ( UpChar >= '1' ) and ( UpChar <= '9' ) then
Result := Result + Ord( UpChar ) - 48
else if ( UpChar >= 'A' ) and ( UpChar <= 'F' ) then
Result := Result + Ord( UpChar ) - 55
else
raise Exception.Create( 'Не шестнадцатеричный символ.' );
Inc( RPtr );
//
Result := Result shl 4;
UpChar := UpCase( RPtr^ );
if ( UpChar >= '1' ) and ( UpChar <= '9' ) then
Result := Result + Ord( UpChar ) - 48
else if ( UpChar >= 'A' ) and ( UpChar <= 'F' ) then
Result := Result + Ord( UpChar ) - 55
else
raise Exception.Create( 'Не шестнадцатеричный символ.' );
Inc( RPtr );
end;
end.
|
{
This demo demonstrates the used of the TGLFractalHDS and other functions included
into the ahGLRandomHDS unit. The dialogbox interfaces almost all object
properties allowing you to get a feeling about what they are controlling.
The TGLFractalHDS is used in the same way as the other GLScene HDS. You must
link it to a TGLTerrainRenderer to see something. But it does much more as it
actually:
1) builds its own HDS on the base of a few user-chosen parameters,
2) computes lighting and
3) computes its own texture. The user really has not
much to do apart choosing the parameter combination that fits its needs. Its
creativity is to be used in the OnDrawtexture event which defines how colors will
be draped on the heightfield according to coordinates and topography.
To understand how everything works, give a look at the agGLRandomHDS unit and
at the following methods of the present unit:
- FormCreate: How to declare and create the FractalHDS (not a plug-and-play component)
- btApplyClick: Setting the properties
- GenerateLandscape: How to load textures, build the landscape and free them
afterward
- OnDrawTexture: This function select the right color to display at a particular
cell on the landscape, depending on its coordinates, elevation and slope. This
function use the textures loaded in the GenerateLandscape procedure to drape
them on the height field. Although the Drawtexture allows you to completely
control the look of your landscape and to produce the most dramatic effects,
it is not mandatory. If no OnDrawTexture event handler is supplied to the
TGLFractalHDS, a default function will be used.
All the other methods on this form are just maintenance code for the demo;
they are not related directly to landscape generation.
The code of this demo was originally based on the demo SynthTerr, although
there is not much of it still to be seen.
Alexandre Hirzel, June 2003
History
*******
25.06.2003
- Added new land-cover types
22.06.2003
- DummyCube for scaling
- Cadencer replaced by an AsyncTimer
21.06.2003:
- First implementation
}
unit dlgFracLanU;
interface
uses
Winapi.Windows,
Winapi.Messages,
System.SysUtils,
System.Classes,
System.Math,
Vcl.Graphics,
Vcl.Controls,
Vcl.Forms,
Vcl.Dialogs,
Vcl.ExtDlgs,
Vcl.ExtCtrls,
Vcl.StdCtrls,
Vcl.Samples.Spin,
Vcl.ComCtrls,
Vcl.Buttons,
GLScene,
GLTerrainRenderer,
GLObjects,
GLHeightData,
GLTexture,
GLWin32Viewer,
GLVectorGeometry,
GLAsyncTimer,
GLMaterial,
GLCoordinates,
GLCrossPlatform,
GLBaseClasses,
GLColor,
GLRandomHDS;
type
TdlgFracLan = class(TForm)
GLSceneViewer1: TGLSceneViewer;
GLScene1: TGLScene;
GLCamera1: TGLCamera;
TerrainRenderer1: TGLTerrainRenderer;
GLMaterialLibrary1: TGLMaterialLibrary;
PageControl1: TPageControl;
Panel1: TPanel;
lblDebug: TLabel;
TabSheet1: TTabSheet;
TabSheet2: TTabSheet;
TabSheet3: TTabSheet;
GroupBox1: TGroupBox;
tbSeaLevel: TTrackBar;
Label2: TLabel;
GroupBox2: TGroupBox;
Label3: TLabel;
Label4: TLabel;
seDepth: TSpinEdit;
tbRoughness: TTrackBar;
ckSea: TCheckBox;
GroupBox3: TGroupBox;
ckLighting: TCheckBox;
ckShadows: TCheckBox;
Label1: TLabel;
tbSunHeight: TTrackBar;
GroupBox4: TGroupBox;
Label5: TLabel;
tbIntensity: TTrackBar;
Label6: TLabel;
tbAmbient: TTrackBar;
Label7: TLabel;
shColor: TShape;
GroupBox5: TGroupBox;
Label8: TLabel;
ckSeaErosion: TCheckBox;
tbBeachHeight: TTrackBar;
GroupBox6: TGroupBox;
Label9: TLabel;
ckRainErosion: TCheckBox;
tbErosionRate: TTrackBar;
Label10: TLabel;
tbDepositionRate: TTrackBar;
Label11: TLabel;
seSeed: TSpinEdit;
GroupBox7: TGroupBox;
ckLifeErosion: TCheckBox;
Label12: TLabel;
tbRobustness: TTrackBar;
Label13: TLabel;
tbAmplitude: TTrackBar;
TabSheet4: TTabSheet;
GroupBox8: TGroupBox;
Label14: TLabel;
ckTexture: TCheckBox;
tbTextureScale: TTrackBar;
grpStrata: TGroupBox;
Label15: TLabel;
Label16: TLabel;
tbSnow: TTrackBar;
tbSteep: TTrackBar;
TabSheet5: TTabSheet;
GroupBox11: TGroupBox;
Label19: TLabel;
Label20: TLabel;
tbFocalLength: TTrackBar;
tbDepthOfView: TTrackBar;
GroupBox10: TGroupBox;
Label17: TLabel;
ckFog: TCheckBox;
tbFogStart: TTrackBar;
GroupBox12: TGroupBox;
Label18: TLabel;
tbScaleX: TTrackBar;
ckCyclic: TCheckBox;
lblScaleY: TLabel;
tbScaleY: TTrackBar;
lblScaleZ: TLabel;
tbScaleZ: TTrackBar;
ckIsometric: TCheckBox;
Label21: TLabel;
tbTransparency: TTrackBar;
TabSheet6: TTabSheet;
Memo1: TMemo;
GroupBox13: TGroupBox;
Label22: TLabel;
Label23: TLabel;
TrackBar1: TTrackBar;
TrackBar2: TTrackBar;
Label24: TLabel;
Label25: TLabel;
TrackBar3: TTrackBar;
TrackBar4: TTrackBar;
DummyTrackbar: TTrackBar;
Timer1: TTimer;
AsyncTimer1: TGLAsyncTimer;
GLDummyCube1: TGLDummyCube;
rgTextureQuality: TRadioGroup;
GroupBox14: TGroupBox;
Label26: TLabel;
ckStepped: TCheckBox;
seStepCount: TSpinEdit;
grpDefaultTexture: TGroupBox;
Label27: TLabel;
edDefaultTexture: TEdit;
btDefaultTexture: TButton;
OpenPictureDialog1: TOpenPictureDialog;
btApply: TBitBtn;
procedure GLSceneViewer1MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure GLSceneViewer1MouseMove(Sender: TObject; Shift: TShiftState;
X, Y: Integer);
procedure Timer1Timer(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure FormActivate(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure OnTopographyChanged(Sender: TObject);
procedure OnLightChanged(Sender: TObject);
procedure shColorMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure btApplyClick(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure OnCameraChanged(Sender: TObject);
procedure OnScaleChanged(Sender: TObject);
procedure ckIsometricClick(Sender: TObject);
procedure GLSceneViewer1MouseEnter(Sender: TObject);
procedure TrackBar2Change(Sender: TObject);
procedure PageControl1Change(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure AsyncTimer1Timer(Sender: TObject);
procedure btDefaultTextureClick(Sender: TObject);
private
mx, my: Integer;
FCamHeight: Single;
LandscapeGenerated: boolean;
TopographyChanged: boolean;
LightChanged: boolean;
Start: cardinal;
FRendering: boolean;
procedure SetRendering(const Value: boolean);
function OnDrawTexture(const Sender: tGLBaseRandomHDS; X, Y: Integer;
z: double; aNormal: tVector): TColorVector;
function OnDrawTextureFlashy(const Sender: tGLBaseRandomHDS; X, Y: Integer;
z: double; aNormal: tVector): TColorVector;
function OnDrawTextureSlope(const Sender: tGLBaseRandomHDS; X, Y: Integer;
z: double; aNormal: tVector): TColorVector;
function OnDrawTextureGrass(const Sender: tGLBaseRandomHDS; X, Y: Integer;
z: double; aNormal: tVector): TColorVector;
public
FractalHDS: tGLFractalHDS;
procedure GenerateLandscape;
procedure ProcessKeyboard(const DeltaTime: double);
property Rendering: boolean read FRendering write SetRendering;
end;
var
dlgFracLan: TdlgFracLan;
covFlat, covSteep: Single; // Slope strata
covLow, covHigh: Single; // Elevation strata
implementation
{$R *.DFM}
uses
GLKeyboard, OpenGL1x, dlgProgressU;
var
Forest, Sea, Beach, Snow, Grass, Cliff, BrownSoil: tBitmap;
function TextureSea(const X, Y: Integer): TColorVector;
begin
with Sea do
Result := ConvertWinColor(Canvas.Pixels[X * 5 mod Width, Y * 5 mod Height]);
// Result:=TextureBlue(x,y);
end;
function TextureForest(const X, Y: Integer): TColorVector;
begin
with Forest do
Result := ConvertWinColor(Canvas.Pixels[X mod Width, Y mod Height]);
AddVector(Result, 0.2); // Original texture is too dark
// Result:=TextureDarkGreen(x,y);
end;
function TextureGrass(const X, Y: Integer): TColorVector;
begin
with Grass do
Result := ConvertWinColor(Canvas.Pixels[X mod Width, Y mod Height]);
AddVector(Result, 0.2); // Original texture is too dark
end;
function TextureSnow(const X, Y: Integer): TColorVector;
begin
with Snow do
Result := ConvertWinColor(Canvas.Pixels[X mod Width, Y mod Height]);
end;
function TextureBeach(const X, Y: Integer): TColorVector;
begin
with Beach do
Result := ConvertWinColor(Canvas.Pixels[X mod Width, Y mod Height]);
end;
function TextureCliff(const X, Y: Integer): TColorVector;
begin
with Cliff do
Result := ConvertWinColor(Canvas.Pixels[X * 2 mod Width, Y * 2 mod Height]);
end;
function TextureBrownSoil(const X, Y: Integer): TColorVector;
begin
with BrownSoil do
Result := ConvertWinColor(Canvas.Pixels[X mod Width, Y mod Height]);
end;
procedure TdlgFracLan.FormCreate(Sender: TObject);
begin
{ Terrain Renderer initialisation }
TerrainRenderer1.MaterialLibrary := GLMaterialLibrary1;
TerrainRenderer1.TileSize := 32;
TopographyChanged := True;
LightChanged := True;
end;
function TdlgFracLan.OnDrawTexture(const Sender: tGLBaseRandomHDS;
X, Y: Integer; z: double; aNormal: tVector): TColorVector;
{ Select the color to paint depending on height(z) and normal. x and y are used to
drape a texture.
This is here that you play with texture effects and express your artistic mind.
Here, I only used three strata (+sea), but you can't imagine anything.
The magic numbers here are the result of tweaking, not calculus. }
const
f = VerticalScalingFactor;
var
z1: Single;
slope: Single;
begin
with tGLFractalHDS(Sender) do
begin
z := z - SeaLevel * f; // we make all elevations relative to sea level
{ Then, we use the vertical component of the normal to compute the slope.
The other components could be used to differentiate a North face from a
South face, for instance. }
slope := RadianToDeg(ArcCosine(aNormal.Y)) + random * 10 - 5;
z1 := z * (1 + (random * 2 - 1) * 0.001) / f;
if z <= 0 then
begin
Result := TextureSea(X, Y); // Deep water
{ Where sea depth is small and transparency must be faked, the sea surface
is 1 unit higher, and scaled to what was the sea bottom elevation.
Although this is not detectable in 3D, you can use it to change water
colour }
if z > -1 then
begin // Shallow water
Result.Y := Result.Y + (1 + z) * 0.4; // Add some green
Result.z := Result.z + (1 + z) * 0.3; // Add some blue
end // if
end // if
else if z / f < covLow then // Low altitude
if slope < covSteep then
Result := TextureSand(X, Y)
else
Result := TextureBrownSoil(X, Y)
else if z1 < covHigh then // Medium altitude (fuzzy)
if slope < covFlat then
Result := TextureGrass(X, Y)
else if slope < covSteep then
Result := TextureForest(X, Y)
else
Result := TextureCliff(X, Y)
else
begin // High altitude
if slope < covSteep then
Result := TextureSnow(X, Y)
else
Result := TextureCliff(X, Y)
end; // else
end; // with
end;
function TdlgFracLan.OnDrawTextureFlashy(const Sender: tGLBaseRandomHDS;
X, Y: Integer; z: double; aNormal: tVector): TColorVector;
{ Flashy version of the regular OnDrawTexture. Helps debugging textures. }
const
f = VerticalScalingFactor;
var
z1: Single;
slope: Single;
begin
with tGLFractalHDS(Sender) do
begin
z := z - SeaLevel * f; // we make all elevations relative to sea level
{ Then, we use the vertical component of the normal to compute the slope.
The other components could be used to differentiate a North face from a
South face, for instance. }
slope := RadianToDeg(ArcCosine(aNormal.Y)) + random * 10 - 5;
z1 := z * (1 + (random * 2 - 1) * 0.001) / f;
if z <= 0 then
begin
Result := clrBlue;
if z > -1 then
begin // Shallow water
Result.Y := Result.Y + (1 + z) * 0.4; // Add some green
Result.z := Result.z + (1 + z) * 0.3; // Add some blue
end; // if
end // if
else if z / f < covLow then // Low altitude
if slope < covSteep then
Result := clrYellow
else
Result := clrBrown
else if z1 < covHigh then // Medium altitude (fuzzy)
if slope < covFlat then
Result := clrGreenYellow
else if slope < covSteep then
Result := clrGreen
else
Result := clrGray75
else
begin // High altitude
if slope < covSteep then
Result := clrWhite
else
Result := clrBlack
end; // else
end; // with
end;
function TdlgFracLan.OnDrawTextureSlope(const Sender: tGLBaseRandomHDS;
X, Y: Integer; z: double; aNormal: tVector): TColorVector;
{ An alternative OnDrawTextureEvent that render slope by a grey scale (flat=black,
vertical=white }
var
slope: Single;
begin
slope := aNormal.Y * pi;
MakeVector(Result, cos(slope), sin(slope), slope); // False colour
end;
function TdlgFracLan.OnDrawTextureGrass(const Sender: tGLBaseRandomHDS;
X, Y: Integer; z: double; aNormal: tVector): TColorVector;
begin
Result := TextureGrass(X, Y);
end;
// Movement, mouse handling etc.
procedure TdlgFracLan.GLSceneViewer1MouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
mx := X;
my := Y;
end;
procedure TdlgFracLan.GLSceneViewer1MouseMove(Sender: TObject;
Shift: TShiftState; X, Y: Integer);
begin
{ not workable !
if ssLeft in Shift then
GLCamera1.MoveAroundTarget(my - Y, mx - X);
mx := X;
my := Y;
}
if ssLeft in Shift then
begin
if abs(X - mx) > abs(my - Y) then
begin
GLCamera1.Turn(X - mx);
// GLCamera1.Up.SetVector(0,1,0);
end
else
GLCamera1.Pitch(my - Y);
mx := X;
my := Y;
end;
end;
procedure TdlgFracLan.Timer1Timer(Sender: TObject);
begin
Caption := Format('%.1f FPS - %d', [GLSceneViewer1.FramesPerSecond,
TerrainRenderer1.LastTriangleCount]);
GLSceneViewer1.ResetPerformanceMonitor;
end;
procedure TdlgFracLan.FormActivate(Sender: TObject);
begin
if not LandscapeGenerated then
begin
btApplyClick(Sender);
Start := GetTickCount;
end; // if
LandscapeGenerated := True;
OnCameraChanged(Sender);
OnScaleChanged(Sender);
end;
procedure TdlgFracLan.GenerateLandscape;
begin
try
Rendering := False; // No rendering while the landscape is built
dlgProgress.lblTask.Caption := 'Landscape generation';
dlgProgress.Execute;
Screen.Cursor := crHourGlass;
{ Load temporary textures }
Forest := LoadJPGtexture('Forest.jpg');
Sea := LoadJPGtexture('Sea.jpg');
Snow := LoadJPGtexture('Snow.jpg');
Cliff := LoadJPGtexture('Cliff.jpg');
BrownSoil := LoadJPGtexture('BrownSoil.jpg');
Grass := LoadJPGtexture('Grass.jpg');
Beach := LoadJPGtexture('Beach.jpg');
{
Forest := LoadJPGtexture('mousse_1.jpg');
Sea := LoadJPGtexture('Sea.jpg');
Snow := LoadJPGtexture('004_neige.jpg');
Cliff := LoadJPGtexture('017Roche.jpg');
BrownSoil := LoadJPGtexture('058terresable-sombre.jpg');
Grass := LoadJPGtexture('nature073-Terre+Herbe.jpg');
// Grass:=LoadJPGTexture('nature093-Gazon.jpg');
Beach := LoadJPGtexture('057terresable-Clair.jpg');
}
with FractalHDS do
begin
BuildLandscape; // Rebuild everything
{ Camera initial position, in the middle of the tile }
FCamHeight := 10 * Scale.Y;
// Initial camera height offset (controled with pageUp/pageDown)
GLCamera1.Position.X := -Size * Scale.X / 2;
GLCamera1.Position.Y := FCamHeight;
GLCamera1.Position.z := Size * Scale.z / 2;
TopographyChanged := False;
LightChanged := False;
btApply.Enabled := False;
end; // with
finally // Finalisation
Sea.Free; // The bitmaps are only needed while landscape is being built
Forest.Free;
Snow.Free;
Cliff.Free;
Grass.Free;
Beach.Free;
BrownSoil.Free;
dlgProgress.Close;
Screen.Cursor := crDefault;
Rendering := True; // Enable rendering
end;
end;
procedure TdlgFracLan.FormClose(Sender: TObject; var Action: TCloseAction);
begin
Rendering := False;
end;
procedure TdlgFracLan.OnTopographyChanged(Sender: TObject);
begin
DummyTrackbar.SetFocus;
TopographyChanged := True;
btApply.Enabled := True;
end;
procedure TdlgFracLan.OnLightChanged(Sender: TObject);
begin
DummyTrackbar.SetFocus;
LightChanged := True;
btApply.Enabled := True;
grpStrata.Visible := ckTexture.Checked;
rgTextureQuality.Visible := ckTexture.Checked;
grpDefaultTexture.Visible := not ckTexture.Checked;
end;
procedure TdlgFracLan.shColorMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
LightChanged := True;
btApply.Enabled := True;
end;
procedure TdlgFracLan.btApplyClick(Sender: TObject);
begin
if FractalHDS <> nil then
FractalHDS.Free;
GLMaterialLibrary1.Materials.DeleteUnusedMaterials;
FractalHDS := tGLFractalHDS.Create(Self);
FractalHDS.TerrainRenderer := TerrainRenderer1;
// Link the HDS to the Renderer
FractalHDS.Name := 'Landscape';
{ Update HDS properties }
with FractalHDS do
begin
{ Topographic properties }
Depth := seDepth.Value;
Cyclic := ckCyclic.Checked; // Cyclic landscape
Seed := seSeed.Value;
Amplitude := tbAmplitude.Position;
Roughness := tbRoughness.Position / 10;
Sea := ckSea.Checked;
SeaLevel := (tbSeaLevel.Position - 5) / 10 * Amplitude;
if not Cyclic then
SeaLevel := SeaLevel * 2; // to cope with the larger variance
SeaTransparency := tbTransparency.Position / 10 *
(SeaLevel + Amplitude / 2);
{ Erosion properties }
{
ErosionByRain.Enabled := ckRainErosion.Checked;
ErosionByRain.ErosionRate := tbErosionRate.Position / 10;
ErosionByRain.DepositRate := tbDepositionRate.Position / 10;
ErosionBySea.Enabled := ckSeaErosion.Checked;
ErosionBySea.BeachHeight := tbBeachHeight.Position / 100 * Amplitude;
ErosionByLife.Enabled := ckLifeErosion.Checked;
ErosionByLife.Robustness := IntPower(10, tbRobustness.Position);
Steps.Enabled := ckStepped.Checked;
Steps.Count := seStepCount.Value;
{ }
{ Lighting properties }
// LightColor:=ConvertWinColor(shColor.Brush.Color);
AmbientLight := tbAmbient.Position / 10;
LightDirection := VectorMake(-tbSunHeight.Position / 10,
-sqrt(1 - sqr(-tbSunHeight.Position / 10)), -tbSunHeight.Position / 10);
Lighting := ckLighting.Checked;
Shadows := ckShadows.Checked;
{ Topographic strata used for land-cover assignation }
covLow := ErosionBySea.BeachHeight * 1.2;
covHigh := tbSnow.Position / 10 * Amplitude / 2;
covFlat := 5;
covSteep := tbSteep.Position;
{ Texture properties }
LandCover := ckTexture.Checked;
TextureScale := Round(IntPower(2, tbTextureScale.Position));
// Number of texture pixels by HDS cell
if LandCover then
begin
case rgTextureQuality.ItemIndex of
0:
OnDrawTexture := nil;
1:
OnDrawTexture := OnDrawTextureFlashy;
2:
OnDrawTexture := OnDrawTextureSlope;
3:
OnDrawTexture := Self.OnDrawTexture
// Function defining the cover to be applied
end; // case
// TextureScale:=1;
end
else
begin
OnDrawTexture := nil; // Revert to the default (basic) OnDrawTexture event
with TerrainRenderer.MaterialLibrary.AddTextureMaterial('Default',
edDefaultTexture.Text) do
begin
end; // with
MaterialName := 'Default';
end; // else
// PrimerLandscape:=True;
// PrimerIsland(1000,fHeight);
end; // with
GenerateLandscape;
end;
procedure TdlgFracLan.FormDestroy(Sender: TObject);
begin
FractalHDS.Free;
end;
procedure TdlgFracLan.OnCameraChanged(Sender: TObject);
begin
DummyTrackbar.SetFocus;
with GLCamera1 do
begin
DepthOfView := FractalHDS.Size * 1.4142 * tbDepthOfView.Position / 10 *
GLDummyCube1.Scale.X;
FocalLength := tbFocalLength.Position;
end; // with
with GLSceneViewer1.Buffer do
begin
FogEnable := ckFog.Checked;
FogEnvironment.FogStart := GLCamera1.DepthOfView * tbFogStart.Position / 10;
FogEnvironment.FogEnd := GLCamera1.DepthOfView * 1.2;
end; // with
TerrainRenderer1.QualityDistance := GLCamera1.DepthOfView / 2;
end;
procedure TdlgFracLan.OnScaleChanged(Sender: TObject);
begin
DummyTrackbar.SetFocus;
if ckIsometric.Checked then
begin
tbScaleY.Position := tbScaleX.Position;
tbScaleZ.Position := tbScaleX.Position;
end; // if
with GLDummyCube1.Scale do
begin
X := tbScaleX.Position;
Y := tbScaleY.Position;
z := tbScaleZ.Position;
end; // with }
end;
procedure TdlgFracLan.ckIsometricClick(Sender: TObject);
begin
tbScaleY.Enabled := not ckIsometric.Checked;
tbScaleZ.Enabled := not ckIsometric.Checked;
lblScaleY.Enabled := not ckIsometric.Checked;
lblScaleZ.Enabled := not ckIsometric.Checked;
if ckIsometric.Checked then
begin
tbScaleY.Position := tbScaleX.Position;
tbScaleZ.Position := tbScaleX.Position;
end; // if
end;
procedure TdlgFracLan.GLSceneViewer1MouseEnter(Sender: TObject);
begin
DummyTrackbar.SetFocus;
end;
procedure TdlgFracLan.TrackBar2Change(Sender: TObject);
begin
DummyTrackbar.SetFocus;
end;
procedure TdlgFracLan.PageControl1Change(Sender: TObject);
begin
DummyTrackbar.SetFocus;
end;
procedure TdlgFracLan.Button1Click(Sender: TObject);
begin
// AsyncTimer1.Enabled:=True;
// AsyncTimer1.Enabled:=False;
end;
procedure TdlgFracLan.AsyncTimer1Timer(Sender: TObject);
var
DeltaTime: double;
begin
DeltaTime := (GetTickCount - Start) / 1000;
Start := GetTickCount;
lblDebug.Caption := Format('%f,%f,%f', [GLCamera1.Position.X,
GLCamera1.Position.Y, GLCamera1.Position.z]);
ProcessKeyboard(DeltaTime);
end;
procedure TdlgFracLan.ProcessKeyboard(const DeltaTime: double);
var
Speed: Single;
begin
if IsKeyDown(VK_SHIFT) then
Speed := 5 * DeltaTime
else
Speed := DeltaTime;
with GLCamera1.Position do
begin
if IsKeyDown(VK_RIGHT) then
GLCamera1.Turn(Speed * 10);
if IsKeyDown(VK_LEFT) then
GLCamera1.Turn(-Speed * 10);
if IsKeyDown(VK_UP) then
GLCamera1.Move(Speed * 10);
if IsKeyDown(VK_DOWN) then
GLCamera1.Move(-Speed * 10);
if IsKeyDown(VK_PRIOR) then
FCamHeight := FCamHeight + 10 * Speed;
if IsKeyDown(VK_NEXT) then
FCamHeight := FCamHeight - 10 * Speed;
if IsKeyDown(VK_ESCAPE) then
Close;
{ Don't leave the map }
if not FractalHDS.Cyclic then
begin
if X < -FractalHDS.XMoveBoundary * GLDummyCube1.Scale.X then
X := -FractalHDS.XMoveBoundary * GLDummyCube1.Scale.X;
if z > FractalHDS.ZMoveBoundary * GLDummyCube1.Scale.z then
z := FractalHDS.ZMoveBoundary * GLDummyCube1.Scale.z;
if X > 0 then
X := 0;
if z < 0 then
z := 0;
end; // if
{ Don't fall through terrain! }
if FCamHeight < 0 then
FCamHeight := 1;
Y := (TerrainRenderer1.InterpolatedHeight(AsVector) + FCamHeight) *
GLDummyCube1.Scale.Y;
end; // with
end;
procedure TdlgFracLan.SetRendering(const Value: boolean);
begin
FRendering := Value;
AsyncTimer1.Enabled := FRendering;
GLSceneViewer1.Enabled := FRendering;
if FRendering = False then
TerrainRenderer1.HeightDataSource := nil
else
TerrainRenderer1.HeightDataSource := FractalHDS;
end;
procedure TdlgFracLan.btDefaultTextureClick(Sender: TObject);
begin
with OpenPictureDialog1 do
begin
if not Execute then
exit;
edDefaultTexture.Text := FileName;
LightChanged := True;
end; // with
end;
end.
|
unit UZEmailConf;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, cxLookAndFeelPainters, cxMaskEdit, cxSpinEdit, StdCtrls,
cxControls, cxContainer, cxEdit, cxTextEdit, cxButtons, ExtCtrls,
cxCheckBox, cxDropDownEdit, IdBaseComponent, IdComponent,
IdTCPConnection, IdTCPClient, IdMessageClient, IdIMAP4,
IdExplicitTLSClientServerBase, cxMemo, ComCtrls;
type
TfrmZEmailConf = class(TForm)
Panel1: TPanel;
Panel2: TPanel;
cxButton1: TcxButton;
cxButton2: TcxButton;
IMAP: TIdIMAP4;
PageControl1: TPageControl;
TabSheet1: TTabSheet;
TabSheet2: TTabSheet;
Label1: TLabel;
SMTP_server: TcxTextEdit;
Label2: TLabel;
SMTP_port: TcxSpinEdit;
Label11: TLabel;
IMAP_port: TcxSpinEdit;
Label3: TLabel;
SMTP_user: TcxTextEdit;
Label4: TLabel;
SMTP_password: TcxTextEdit;
Label5: TLabel;
SMTP_account: TcxTextEdit;
CheckHistoryMailBox: TcxCheckBox;
HistoryMailBox: TcxComboBox;
cxCheckBox1: TcxCheckBox;
Label10: TLabel;
Proxy_type: TcxComboBox;
Label6: TLabel;
Proxy_server: TcxTextEdit;
Label7: TLabel;
Proxy_port: TcxSpinEdit;
Label8: TLabel;
Proxy_user: TcxTextEdit;
Label9: TLabel;
Proxy_password: TcxTextEdit;
Body_template: TcxMemo;
Panel3: TPanel;
Label12: TLabel;
Label13: TLabel;
Label14: TLabel;
cxTextEdit1: TcxTextEdit;
Label15: TLabel;
Label16: TLabel;
TabSheet3: TTabSheet;
TabSheet4: TTabSheet;
Label17: TLabel;
body_info_template: TcxMemo;
Label18: TLabel;
INFO_SUBJECT_TEMPLATE: TcxTextEdit;
Panel4: TPanel;
Label19: TLabel;
Label20: TLabel;
Label21: TLabel;
Label22: TLabel;
body_pswrd_template: TcxMemo;
Label23: TLabel;
PSWRD_SUBJECT_TEMPLATE: TcxTextEdit;
Panel5: TPanel;
Label24: TLabel;
Label25: TLabel;
Label26: TLabel;
Label27: TLabel;
procedure cxButton1Click(Sender: TObject);
procedure cxButton2Click(Sender: TObject);
procedure cxCheckBox1Click(Sender: TObject);
procedure CheckHistoryMailBoxPropertiesChange(Sender: TObject);
private
UsersFolders: TStringList;
{ Private declarations }
public
{ Public declarations }
constructor Create(AOwner:TComponent);reintroduce;
destructor Destroy;override;
end;
implementation
{$R *.dfm}
procedure TfrmZEmailConf.cxButton1Click(Sender: TObject);
begin
ModalResult:=mrYes;
end;
procedure TfrmZEmailConf.cxButton2Click(Sender: TObject);
begin
ModalResult:=mrNo;
end;
procedure TfrmZEmailConf.cxCheckBox1Click(Sender: TObject);
begin
Proxy_server.Enabled:=cxCheckBox1.Checked;
Proxy_port.Enabled:=cxCheckBox1.Checked;
Proxy_user.Enabled:=cxCheckBox1.Checked;
Proxy_password.Enabled:=cxCheckBox1.Checked;
Proxy_type.Enabled:=cxCheckBox1.Checked;
end;
procedure TfrmZEmailConf.CheckHistoryMailBoxPropertiesChange(
Sender: TObject);
var i:Integer;
begin
HistoryMailBox.Enabled:=CheckHistoryMailBox.Checked;
if CheckHistoryMailBox.Checked
then begin
IMAP.Host :=SMTP_server.Text;
IMAP.Port :=IMAP_port.EditValue;
IMAP.Username:=SMTP_user.Text;
IMAP.Password:=SMTP_password.Text;
try
IMAP.Connect;
if (IMAP.Connected)
and ((IMAP.ConnectionState = csAuthenticated) or (IMAP.ConnectionState = csSelected))
then begin
if Imap.ListMailBoxes(UsersFolders)
then begin
for i := 0 to UsersFolders.Count-1 do
begin
HistoryMailBox.Properties.Items.Add(UsersFolders[i]);
end;
end;
end;
except on E:Exception do
begin
end;
end;
end;
end;
constructor TfrmZEmailConf.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
UsersFolders:=TStringList.Create;
PageControl1.ActivePageIndex:=0;
end;
destructor TfrmZEmailConf.Destroy;
begin
UsersFolders.Free;
inherited Destroy;
end;
end.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.