dxpascalscript.pas

Well known and usefull component for delphi 7

procedure TDXPascalScript.AddConstructor(AClass:TClass; Address:Pointer);
begin
  JavaScript.AddConstructor(AClass, Address);
end;

procedure TDXPascalScript.AddProperty(AClass:TClass;const Name:String;ReadAddr,WriteAddr:Pointer);
begin
  JavaScript.AddProperty(AClass,Name,ReadAddr,WriteAddr);
end;

procedure TDXPascalScript.RemoveProperty(AClass:TClass; const Name: String);
begin
  JavaScript.RemoveProperty(AClass,Name);
end;

procedure TDXPascalScript.AddObject(const Name:String; Instance:TObject);
begin
  JavaScript.AddObject(Name, Instance);
end;

procedure TDXPascalScript.AddHostVariable(const Name:String; Address: Pointer);
begin
  JavaScript.AddHostVariable(Name, Address);
end;

procedure TDXPascalScript.AddConstant(const Name: String; const Value: Variant);
begin
  JavaScript.AddConstant(Name, Value);
end;

function TDXPascalScript.Compile: Boolean;
//var
//  I: Integer; // v.1.2
begin
  if Assigned(fOnLoadBeforeCompile) then fOnLoadBeforeCompile(Self);
  Result := JavaScript.Parse;
  fCompiled := Result;
end;

function TDXPascalScript.Run(RunMode: Integer = rmRun): Boolean;
begin
{$IFDEF TRIAL}
  AskToRegister;
{$ENDIF}
(* // v1.5
  result := true;
  if Assigned(fOnBeforeRun) then fOnBeforeRun(Self);
  if not Compiled then
    result := Compile;
  if result then
  try
    result := JavaScript.Run(RunMode);
    if result then
    begin
      JavaScript.ExtractCallStack(CallStack);
      if EndOfScript then
        ResetRun;
    end;
  except
    JavaScript.ExtractCallStack(CallStack);
  end;
  if Assigned(fOnAfterRun) then fOnAfterRun(Self);
*)
  if not Compiled then result := Compile
  Else result := true;
  if result then begin
     if Assigned(fOnBeforeRun) then fOnBeforeRun(Self);
try

     ResetRun;
     result := JavaScript.Run(RunMode);
     if Assigned(fOnAfterRun) then fOnAfterRun(Self);
     if result then begin
        JavaScript.ExtractCallStack(CallStack);
        if EndOfScript then ResetRun;
     end;
except
     JavaScript.ExtractCallStack(CallStack);
end;
   End;
end;

function TDXPascalScript.Execute(const Source: String): Boolean;
begin
  JavaScript.Reset;
  AddCode(Source);
  Result := Run;
  Compiled := False;
end;

class function TDXPascalScript.ToBoolean(const Value: Variant): Boolean;
begin
  result := DXJS_MAIN.ToBoolean(Value);
end;

class function TDXPascalScript.ToNumber(const Value: Variant): Double;
begin
  result := DXJS_MAIN.ToNumber(Value);
end;

class function TDXPascalScript.ToInteger(const Value: Variant): Integer;
begin
  result := DXJS_MAIN.ToInteger(Value);
end;

class function TDXPascalScript.ToString(const Value: Variant): String;
begin
  result := DXJS_MAIN.ToString(Value);
end;

class function TDXPascalScript.GetProperty(const ScriptObject: Variant; const PropertyName: String): Variant;
begin
  result := DXJS_MAIN.GetProperty(ScriptObject, PropertyName);
end;

class function TDXPascalScript.IsPrimitive(const Value: Variant): boolean;
begin
  result := DXJS_MAIN.IsPrimitive(Value);
end;

class function TDXPascalScript.DelphiObjectToVariant(Instance: TObject): Variant;
begin
  result := DXJS_MAIN.DelphiObjectToVariant(Instance);
end;

class function TDXPascalScript.VariantToDelphiObject(const Value: Variant): TObject;
begin
  result := DXJS_MAIN.ToDelphiObject(Value);
end;

procedure TDXPascalScript.SourceDump;
begin
  JavaScript.Print;
end;

function TDXPascalScript.CallFunction(const Name: String;
                                    const Parameters: array of Variant): Variant;
var
  ID: Integer;
begin
//  result := true;
//  if Assigned(fOnBeforeRun) then fOnBeforeRun(Self);
//  if not Compiled then result := Compile;
  if not Compiled then result := Compile
  Else result := true;
  if result then begin
    if Assigned(fOnBeforeRun) then fOnBeforeRun(Self);
    ID := GetID(Name);
    if ID > 0 then
      result := JavaScript.CallFunction(ID, Parameters);
    if Assigned(fOnAfterRun) then fOnAfterRun(Self);
  end;
//  if Assigned(fOnAfterRun) then fOnAfterRun(Self);
end;

function TDXPascalScript.AddBreakpoint(LineNumber: Integer; const ModuleName: String = ''): boolean;
begin
  if ModuleName = '' then
    result := JavaScript.AddBreakpoint(ModuleMain, LineNumber)
  else
    result := JavaScript.AddBreakpoint(ModuleName, LineNumber);
end;

function TDXPascalScript.RemoveBreakpoint(LineNumber: Integer; const ModuleName: String = ''): boolean;
begin
  if ModuleName = '' then
    result := JavaScript.RemoveBreakpoint(ModuleMain, LineNumber)
  else
    result := JavaScript.RemoveBreakpoint(ModuleName, LineNumber);
end;

procedure TDXPascalScript.RemoveAllBreakpoints;
begin
  JavaScript.Postfix.BreakpointList.Clear;
end;

function TDXPascalScript.CurrentLineNumber: Integer;
begin
  result := JavaScript.CurrentLineNumber;
end;

function TDXPascalScript.CurrentModule: String;
begin
  result := JavaScript.CurrentModule;
end;

function TDXPascalScript.CurrentLine: String;
begin
  result := JavaScript.CurrentLine;
end;

procedure TDXPascalScript.ClearCallStack;
var
  I: Integer;
begin
  for I:=0 to CallStack.Count - 1 do
    CallStack.Objects[I].Free;
  CallStack.Clear;
end;

procedure TDXPascalScript.ResetRun;
begin
  JavaScript.ResetRun;
end;

procedure TDXPascalScript.Terminate; // OZZ
var
  I: Integer;
  Instance: TForm;
begin
   If Compiled then begin
    for I:=0 to JavaScript.OpenWindows.Count - 1 do
    begin
      Instance := TForm(JavaScript.OpenWindows[I]);
      if Instance <> nil then Begin
        Instance.Close;
        Instance.Free; //1-17-2003 OZZ
      End;
    end;
    JavaScript.OpenWindows.Clear;
   End;
end;

procedure TDXPascalScript.Enum(Variables, Functions: TStringList);
begin
  JavaScript.SymbolTable.Enum(Variables, Functions);
end;

function TDXPascalScript.EndOfScript: boolean;
begin
  result := JavaScript.Postfix.EndOfScript;
end;

function TDXPascalScript.Eval(const Code: String): Variant;
begin
  result := JavaScript.Eval(Code);
end;

function TDXPascalScript_ToBoolean(const Value: Variant): Boolean;
begin
  result := DXJS_MAIN.ToBoolean(Value);
end;

function TDXPascalScript_ToNumber(const Value: Variant): Double;
begin
  result := DXJS_MAIN.ToNumber(Value);
end;

function TDXPascalScript_ToInteger(const Value: Variant): Integer;
begin
  result := DXJS_MAIN.ToInteger(Value);
end;

function TDXPascalScript_ToString(const Value: Variant): String;
begin
  result := DXJS_MAIN.ToString(Value);
end;

function TDXPascalScript_GetProperty(const ScriptObject: Variant; const PropertyName: String): Variant;
begin
  result := DXJS_MAIN.GetProperty(ScriptObject, PropertyName);
end;

function TDXPascalScript_IsPrimitive(const Value: Variant): boolean;
begin
  result := DXJS_MAIN.IsPrimitive(Value);
end;

function TDXPascalScript_DelphiObjectToVariant(Instance: TObject): Variant;
begin
  result := DXJS_MAIN.DelphiObjectToVariant(Instance);
end;

function TDXPascalScript_VariantToDelphiObject(const Value: Variant): TObject;
begin
  result := DXJS_MAIN.ToDelphiObject(Value);
end;

function GetParamName(const FuncDecl: String; ParamNumber: Integer): String;

function ReadName(const S: String; P: Integer): String;
begin
  result := '';
  while S[P] in [#8, #9, #10, #13, #32] do
    Inc(P);
  while S[P] in ['a'..'z','A'..'Z','_','0'..'9'] do
  begin
    result := result + S[P];
    Inc(P);
  end;
end;

var
  I, K: Integer;
begin
  result := '';
  K := 0;
  for I:=1 to Length(FuncDecl) do
    if FuncDecl[I] in ['(',','] then
    begin
      Inc(K);
      if K = ParamNumber then
      begin
        result := ReadName(FuncDecl, I + 1);
        Exit;
      end;
    end;
end;

end.