rm_jvinterpreter_classes.pas

这是一个功能强大

{ property Read ItemClass: TCollectionItemClass }

procedure TCollection_Read_ItemClass(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TObject(TCollection(Args.Obj).ItemClass));
end;

{ property Read Items[Integer]: TCollectionItem }

procedure TCollection_Read_Items(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCollection(Args.Obj).Items[Args.Values[0]]);
end;

{ property Write Items[Integer]: TCollectionItem }

procedure TCollection_Write_Items(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCollection(Args.Obj).Items[Args.Values[0]] := V2O(Value) as TCollectionItem;
end;

{ TStrings }

{ function Add(const S: string): Integer; }

procedure TStrings_Add(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).Add(Args.Values[0]);
end;

{ function AddObject(const S: string; AObject: TObject): Integer; }

procedure TStrings_AddObject(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).AddObject(Args.Values[0], V2O(Args.Values[1]));
end;

{ procedure Append(const S: string); }

procedure TStrings_Append(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Append(Args.Values[0]);
end;

{ procedure AddStrings(Strings: TStrings); }

procedure TStrings_AddStrings(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).AddStrings(V2O(Args.Values[0]) as TStrings);
end;

{ procedure Assign(Source: TPersistent); }

procedure TStrings_Assign(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Assign(V2O(Args.Values[0]) as TPersistent);
end;

{ procedure BeginUpdate; }

procedure TStrings_BeginUpdate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).BeginUpdate;
end;

{ procedure Clear; }

procedure TStrings_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Clear;
end;

{ procedure Delete(Index: Integer); }

procedure TStrings_Delete(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Delete(Args.Values[0]);
end;

{ procedure EndUpdate; }

procedure TStrings_EndUpdate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).EndUpdate;
end;

{ function Equals(Strings: TStrings): Boolean; }

procedure TStrings_Equals(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).Equals(V2O(Args.Values[0]) as TStrings);
end;

{ procedure Exchange(Index1, Index2: Integer); }

procedure TStrings_Exchange(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Exchange(Args.Values[0], Args.Values[1]);
end;

{ function IndexOf(const S: string): Integer; }

procedure TStrings_IndexOf(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).IndexOf(Args.Values[0]);
end;

{ function IndexOfName(const Name: string): Integer; }

procedure TStrings_IndexOfName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).IndexOfName(Args.Values[0]);
end;

{ function IndexOfObject(AObject: TObject): Integer; }

procedure TStrings_IndexOfObject(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).IndexOfObject(V2O(Args.Values[0]));
end;

{ procedure Insert(Index: Integer; const S: string); }

procedure TStrings_Insert(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Insert(Args.Values[0], Args.Values[1]);
end;

{ procedure InsertObject(Index: Integer; const S: string; AObject: TObject); }

procedure TStrings_InsertObject(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).InsertObject(Args.Values[0], Args.Values[1], V2O(Args.Values[2]));
end;

{ procedure LoadFromFile(const FileName: string); }

procedure TStrings_LoadFromFile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).LoadFromFile(Args.Values[0]);
end;

{ procedure LoadFromStream(Stream: TStream); }

procedure TStrings_LoadFromStream(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).LoadFromStream(V2O(Args.Values[0]) as TStream);
end;

{ procedure Move(CurIndex, NewIndex: Integer); }

procedure TStrings_Move(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Move(Args.Values[0], Args.Values[1]);
end;

{ procedure SaveToFile(const FileName: string); }

procedure TStrings_SaveToFile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).SaveToFile(Args.Values[0]);
end;

{ procedure SaveToStream(Stream: TStream); }

procedure TStrings_SaveToStream(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).SaveToStream(V2O(Args.Values[0]) as TStream);
end;

{ property Read Capacity: Integer }

procedure TStrings_Read_Capacity(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).Capacity;
end;

{ property Write Capacity(Value: Integer) }

procedure TStrings_Write_Capacity(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Capacity := Value;
end;

{ property Read CommaText: string }

procedure TStrings_Read_CommaText(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).CommaText;
end;

{ property Write CommaText(Value: string) }

procedure TStrings_Write_CommaText(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).CommaText := Value;
end;

{ property Read Count: Integer }

procedure TStrings_Read_Count(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).Count;
end;

{ property Read Names[Integer]: string }

procedure TStrings_Read_Names(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).Names[Args.Values[0]];
end;

{ property Read Values[Integer]: string }

procedure TStrings_Read_Values(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).Values[Args.Values[0]];
end;

{ property Write Values[Integer]: string }// ivan_ra

procedure TStrings_Write_Values(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Values[Args.Values[0]] := Value;
end;

{ property Read Objects[Integer]: TObject }

procedure TStrings_Read_Objects(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStrings(Args.Obj).Objects[Args.Values[0]]);
end;

{ property Write Objects[Integer]: TObject }

procedure TStrings_Write_Objects(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Objects[Args.Values[0]] := V2O(Value);
end;

{ property Read Strings[Integer]: string }

procedure TStrings_Read_Strings(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).Strings[Args.Values[0]];
end;

{ property Write Strings[Integer]: string }

procedure TStrings_Write_Strings(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Strings[Args.Values[0]] := Value;
end;

{ property Read Text: string }

procedure TStrings_Read_Text(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).Text;
end;

{ property Write Text(Value: string) }

procedure TStrings_Write_Text(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStrings(Args.Obj).Text := Value;
end;

{ property Read StringsAdapter: IStringsAdapter }

procedure TStrings_Read_StringsAdapter(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStrings(Args.Obj).StringsAdapter;
end;

{ property Write StringsAdapter(Value: IStringsAdapter) }

procedure TStrings_Write_StringsAdapter(const Value: Variant; Args: TJvInterpreterArgs);
begin
//  TStrings(Args.Obj).StringsAdapter := Value;
  NotImplemented('TStrings.StringsAdapter');
end;

{ TStringList }

{ constructor }

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

{ function Add(const S: string): Integer; }

procedure TStringList_Add(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStringList(Args.Obj).Add(Args.Values[0]);
end;

{ procedure Clear; }

procedure TStringList_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStringList(Args.Obj).Clear;
end;

{ procedure Delete(Index: Integer); }

procedure TStringList_Delete(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStringList(Args.Obj).Delete(Args.Values[0]);
end;

{ procedure Exchange(Index1, Index2: Integer); }

procedure TStringList_Exchange(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStringList(Args.Obj).Exchange(Args.Values[0], Args.Values[1]);
end;

{ function Find(const S: string; var Index: Integer): Boolean; }

procedure TStringList_Find(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStringList(Args.Obj).Find(Args.Values[0], TVarData(Args.Values[1]).vInteger);
end;

{ function IndexOf(const S: string): Integer; }

procedure TStringList_IndexOf(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStringList(Args.Obj).IndexOf(Args.Values[0]);
end;

{ procedure Insert(Index: Integer; const S: string); }

procedure TStringList_Insert(var Value: Variant; Args: TJvInterpreterArgs);
begin