dxvisualbasicscript.pas

Well known and usefull component for delphi 7

procedure TDXVisualBasicScript.SetZeroBasedStringIndex(Value: boolean);
begin
  JavaScript.ZeroBasedStringIndex := Value;
end;

function TDXVisualBasicScript.GetID(const Name: String): Integer;
var
  Index: Integer;
begin
  Index := fIDCache.IndexOf(Name);
  if Index = - 1 then
  begin
    result := JavaScript.GetID(Name);
    If Result>0 then // OZZ
    fIDCache.AddObject(Name, Pointer(result));
  end
  else
    result := Integer(fIDCache.Objects[Index]);
end;

function TDXVisualBasicScript.GetVariable(const Name: String): Variant;
var
  ID: Integer;
begin
  ID := GetID(Name);
  if ID > 0 then
    result := JavaScript.GetValue(ID);
end;

procedure TDXVisualBasicScript.SetVariable(const Name: String; const Value: Variant);
var
  ID: Integer;
begin
  ID := GetID(Name);
  if ID > 0 then
    JavaScript.PutValue(ID, Value);
end;

procedure TDXVisualBasicScript.SetShowError(Value: TScriptEvent);
begin
  JavaScript.fOnShowError := Value;
end;

procedure TDXVisualBasicScript.AddCode(Code: String; const ModuleName: String = '');
begin
  Compiled := false;
  if ModuleName = '' then JavaScript.AddCode(ModuleMain, Code)
  else JavaScript.AddCode(ModuleName, Code);
end;

procedure TDXVisualBasicScript.LoadFromFile(const FileName: String);
var
  FName: String;
begin
  Compiled := false;
  FName := FileName;
  if not FileExists(FName) then FName := Filename+'.js';
  if FileExists(FName) then begin
    JavaScript.Reset;
    JavaScript.AddCodeFromFile(ModuleMain, FName);
  end;
end;

procedure TDXVisualBasicScript.LoadFromStream(Stream: TStream);
var
  Ws: String;
begin
  Compiled := false;
  SetLength(Ws, Stream.Size-Stream.Position);
  Stream.Read(Ws[1], Length(Ws));
  JavaScript.Reset;
  AddCode(Ws, ModuleMain);
end;

procedure TDXVisualBasicScript.SaveCompiledScript(Stream: TStream);
begin
  if not Compiled then Compile;
  JavaScript.SaveToStream(Stream)
end;

procedure TDXVisualBasicScript.LoadCompiledScript(Stream: TStream);
begin
  JavaScript.Reset;
  JavaScript.LoadFromStream(Stream);
  Compiled := true;
end;

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

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

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

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

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

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

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

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

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

function TDXVisualBasicScript.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 TDXVisualBasicScript.Execute(const Source: String): Boolean;
begin
  JavaScript.Reset;
  AddCode(Source);
  Result := Run;
  Compiled := False;
end;

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

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

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

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

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

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

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

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

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

function TDXVisualBasicScript.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 TDXVisualBasicScript.AddBreakpoint(LineNumber: Integer; const ModuleName: String = ''): boolean;
begin
  if ModuleName = '' then
    result := JavaScript.AddBreakpoint(ModuleMain, LineNumber)
  else
    result := JavaScript.AddBreakpoint(ModuleName, LineNumber);
end;

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

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

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

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

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

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

procedure TDXVisualBasicScript.ResetRun;
begin
  JavaScript.ResetRun;
end;

procedure TDXVisualBasicScript.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 TDXVisualBasicScript.Enum(Variables, Functions: TStringList);
begin
  JavaScript.SymbolTable.Enum(Variables, Functions);
end;

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

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

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

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

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

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

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

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

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

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