rm_jvinterpreter_classes.pas

这是一个功能强大

  TStringList(Args.Obj).Insert(Args.Values[0], Args.Values[1]);
end;

{ procedure Sort; }

procedure TStringList_Sort(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStringList(Args.Obj).Sort;
end;

{ property Read Duplicates: TDuplicates }

procedure TStringList_Read_Duplicates(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStringList(Args.Obj).Duplicates;
end;

{ property Write Duplicates(Value: TDuplicates) }

procedure TStringList_Write_Duplicates(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStringList(Args.Obj).Duplicates := Value;
end;

{ property Read Sorted: Boolean }

procedure TStringList_Read_Sorted(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStringList(Args.Obj).Sorted;
end;

{ property Write Sorted(Value: Boolean) }

procedure TStringList_Write_Sorted(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStringList(Args.Obj).Sorted := Value;
end;

{ TStream }

{ function Read(var Buffer; Count: Longint): Longint; }

procedure TStream_Read(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStream(Args.Obj).Read(Args.Values[0], Args.Values[1]);
end;

{ function Write(const Buffer; Count: Longint): Longint; }

procedure TStream_Write(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStream(Args.Obj).Write(Args.Values[0], Args.Values[1]);
end;

{ function Seek(Offset: Longint; Origin: Word): Longint; }

procedure TStream_Seek(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStream(Args.Obj).Seek(Args.Values[0], Args.Values[1]);
end;

{ procedure ReadBuffer(var Buffer; Count: Longint); }

procedure TStream_ReadBuffer(var Value: Variant; Args: TJvInterpreterArgs);
var
  P: PChar;
  S: string;
begin
  SetLength(S, Integer(Args.Values[1]));
  P := PChar(S);
  TStream(Args.Obj).ReadBuffer(P^, Args.Values[1]);
  Args.Values[0] := S;
end;

{ procedure WriteBuffer(const Buffer; Count: Longint); }

procedure TStream_WriteBuffer(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStream(Args.Obj).WriteBuffer(Args.Values[0], Args.Values[1]);
end;

{ function CopyFrom(Source: TStream; Count: Longint): Longint; }

procedure TStream_CopyFrom(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStream(Args.Obj).CopyFrom(V2O(Args.Values[0]) as TStream, Args.Values[1]);
end;

{ function ReadComponent(Instance: TComponent): TComponent; }

procedure TStream_ReadComponent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStream(Args.Obj).ReadComponent(V2O(Args.Values[0]) as TComponent));
end;

{ function ReadComponentRes(Instance: TComponent): TComponent; }

procedure TStream_ReadComponentRes(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStream(Args.Obj).ReadComponentRes(V2O(Args.Values[0]) as TComponent));
end;

{ procedure WriteComponent(Instance: TComponent); }

procedure TStream_WriteComponent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStream(Args.Obj).WriteComponent(V2O(Args.Values[0]) as TComponent);
end;

{ procedure WriteComponentRes(const ResName: string; Instance: TComponent); }

procedure TStream_WriteComponentRes(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStream(Args.Obj).WriteComponentRes(Args.Values[0], V2O(Args.Values[1]) as TComponent);
end;

{ procedure WriteDescendent(Instance, Ancestor: TComponent); }

procedure TStream_WriteDescendent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStream(Args.Obj).WriteDescendent(V2O(Args.Values[0]) as TComponent, V2O(Args.Values[1]) as TComponent);
end;

{ procedure WriteDescendentRes(const ResName: string; Instance, Ancestor: TComponent); }

procedure TStream_WriteDescendentRes(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStream(Args.Obj).WriteDescendentRes(Args.Values[0], V2O(Args.Values[1]) as TComponent, V2O(Args.Values[2]) as
    TComponent);
end;

{ procedure ReadResHeader; }

procedure TStream_ReadResHeader(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStream(Args.Obj).ReadResHeader;
end;

{ property Read Position: Longint }

procedure TStream_Read_Position(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStream(Args.Obj).Position;
end;

{ property Write Position(Value: Longint) }

procedure TStream_Write_Position(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStream(Args.Obj).Position := Value;
end;

{ property Read Size: Longint }

procedure TStream_Read_Size(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStream(Args.Obj).Size;
end;

{ property Write Size(Value: Longint) }

procedure TStream_Write_Size(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStream(Args.Obj).Size := Value;
end;

{ TFileStream }

{ constructor Create(FileName: string; Mode: Word) }

procedure TFileStream_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  {$IFDEF MSWINDOWS}
  Value := O2V(TFileStream.Create(Args.Values[0], Args.Values[1]));
  {$ENDIF MSWINDOWS}
  {$IFDEF UNIX}
  Value := O2V(TFileStream.Create(VarToStr(Args.Values[0]), Args.Values[1]));
  {$ENDIF UNIX}
end;

{ TMemoryStream }

{ constructor Create }

procedure TMemoryStream_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TMemoryStream.Create);
end;

{ TJvStringStream  }

{ constructor Create(AString: string) }

procedure TStringStream_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStringStream.Create(Args.Values[0]));
end;

{ function Read(var Buffer; Count: Longint): Longint; }

procedure TStringStream_Read(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStringStream(Args.Obj).Read(Args.Values[0], Args.Values[1]);
end;

{ function ReadString(Count: Longint): string; }

procedure TStringStream_ReadString(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStringStream(Args.Obj).ReadString(Args.Values[0]);
end;

{ function Seek(Offset: Longint; Origin: Word): Longint; }

procedure TStringStream_Seek(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStringStream(Args.Obj).Seek(Args.Values[0], Args.Values[1]);
end;

{ function Write(const Buffer; Count: Longint): Longint; }

procedure TStringStream_Write(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStringStream(Args.Obj).Write(Args.Values[0], Args.Values[1]);
end;

{ procedure WriteString(const AString: string); }

procedure TStringStream_WriteString(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStringStream(Args.Obj).WriteString(Args.Values[0]);
end;

{ property Read DataString: string }

procedure TStringStream_Read_DataString(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStringStream(Args.Obj).DataString;
end;

{ TComponent }

{ constructor Create(AOwner: TComponent) }

procedure TComponent_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TComponent.Create(V2O(Args.Values[0]) as TComponent));
end;

{ procedure DestroyComponents; }

procedure TComponent_DestroyComponents(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TComponent(Args.Obj).DestroyComponents;
end;

{ procedure Destroying; }

procedure TComponent_Destroying(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TComponent(Args.Obj).Destroying;
end;

{ function FindComponent(const AName: string): TComponent; }

procedure TComponent_FindComponent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TComponent(Args.Obj).FindComponent(Args.Values[0]));
end;

{ procedure FreeNotification(AComponent: TComponent); }

procedure TComponent_FreeNotification(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TComponent(Args.Obj).FreeNotification(V2O(Args.Values[0]) as TComponent);
end;

{ procedure FreeOnRelease; }

procedure TComponent_FreeOnRelease(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TComponent(Args.Obj).FreeOnRelease;
end;

{ function GetParentComponent: TComponent; }

procedure TComponent_GetParentComponent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TComponent(Args.Obj).GetParentComponent);
end;

{ function HasParent: Boolean; }

procedure TComponent_HasParent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TComponent(Args.Obj).HasParent;
end;

{ procedure InsertComponent(AComponent: TComponent); }

procedure TComponent_InsertComponent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TComponent(Args.Obj).InsertComponent(V2O(Args.Values[0]) as TComponent);
end;

{ procedure RemoveComponent(AComponent: TComponent); }

procedure TComponent_RemoveComponent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TComponent(Args.Obj).RemoveComponent(V2O(Args.Values[0]) as TComponent);
end;

{ function SafeCallException(ExceptObject: TObject; ExceptAddr: Pointer): Integer; }

procedure TComponent_SafeCallException(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TComponent(Args.Obj).SafeCallException(V2O(Args.Values[0]), V2P(Args.Values[1]));
end;

{ property Read ComObject: IUnknown }

procedure TComponent_Read_ComObject(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TComponent(Args.Obj).ComObject;
end;

{ property Read Components[Integer]: TComponent }

procedure TComponent_Read_Components(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TComponent(Args.Obj).Components[Args.Values[0]]);
end;

{ property Read ComponentCount: Integer }

procedure TComponent_Read_ComponentCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TComponent(Args.Obj).ComponentCount;
end;