dxjavascript.pas

Well known and usefull component for delphi 7

procedure TDXJavaScript.LoadCompiledScriptFile(const Filename:String);
Var
   FStream:TFileStream;

begin
   FStream:=TFileStream.Create(FileName,fmOpenRead or fmShareDenyNone);
   JavaScript.Reset;
   JavaScript.LoadFromStream(FStream);
   Compiled := true;
   FStream.Free;
end;

procedure TDXJavaScript.AddRoutine(const Name:String; Address:Pointer);
begin
  JavaScript.AddRoutine(Name,Address);
end;

procedure TDXJavaScript.AddMethod(AClass:TClass;const Name:String; Address:Pointer);
begin
  JavaScript.AddMethod(AClass, Name, Address);
end;

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

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

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

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

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

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

function TDXJavaScript.Compile: Boolean;
begin
  if Assigned(fOnLoadBeforeCompile) then fOnLoadBeforeCompile(Self);
  Result := JavaScript.Parse;
  fCompiled := Result;
end;

function TDXJavaScript.Run(RunMode: Integer = rmRun): Boolean;
begin
{$IFDEF TRIAL}
  AskToRegister;
{$ENDIF}
  if not Compiled then result := Compile
  Else result := true;
  if result then begin
     if Assigned(fOnBeforeRun) then fOnBeforeRun(Self);
try
     result := JavaScript.Run(RunMode);
     if Assigned(fOnAfterRun) then fOnAfterRun(Self);
     if result then begin
        JavaScript.ExtractCallStack(fCallStack);
        if EndOfScript then ResetRun;
     end;
except
     JavaScript.ExtractCallStack(fCallStack);
//     raise; // Sept 2003
end;
   End;
end;

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

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

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

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

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

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

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

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

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

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

function TDXJavaScript.CallFunction(const Name: String;
                                    const Parameters: array of Variant): Variant;
var
  ID: Integer;
begin
  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;
end;

function TDXJavaScript.FunctionExist(const Name: String): Boolean;
Begin
   Result:=GetID(Name)>0;
End;

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

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

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

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

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

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

function TDXJavaScript.CurrentFunction: String;
begin
  result := JavaScript.CurrentFunction;
end;

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

procedure TDXJavaScript.ResetRun;
begin
  JavaScript.ResetRun;
end;

procedure TDXJavaScript.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;

    ClearHandlers;
   End;
end;

procedure TDXJavaScript.ClearHandlers;
begin
  JavaScript.EventHandlerList.ClearHandlers;
end;

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

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

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

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

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

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

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

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

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

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

function TDXJavaScript_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.