Sprach-Feature wird nicht unterstützt

[TomTaylor001]

Hallo ich hab da ein Problem, vielleicht kann mir ja jemand dabei helfen?

Und zwar ich möchte eine Delphi Komponente im BCB nutzen. Bekomme aber immer eine Fehlermeldung
[[Pascal Fehler] GR_System.pas(274): Sprach-Feature wird nicht unterstützt: 'Object']

Kann mir vielleich jemand sagen was ich ändern muss

Grund des Fehlers: TGRCounter = object

Delphi-Quellcode:

unit GR_System;

interface

{$I Setting.inc}

uses
  SysUtils,
  {$IFDEF CLX}
  Qt, Types {$IFDEF LINUX}, Libc {$ELSE}, Windows{$ENDIF}
  {$ELSE}
  Windows
  {$ENDIF};

type

  //like the record do not call constructor to create a instance.
  //faster than class.
  TGRCounter = object
  private
    FStartValue, FStopValue: Int64;
    function GetElapsed: Extended;
    function GetCalibrate: Int64;
    function GetFrequency: Int64;
  protected
  public
    procedure Start;
    procedure Stop;
    function ReadMilliseconds: String;
    //the Elapsed TickCount value
    function ReadValue: Int64;

    //return the ns .
    property Elapsed: Extended read GetElapsed;
    property Calibrate: Int64 read GetCalibrate;
    property Frequency: Int64 read GetFrequency;
  end;


function StartCounter: TGRCounter;
function StopCounter(const aCounter: TGRCounter): Single;

implementation


var
  FCalibrate: Int64;
  FFrequency: Int64;
  {$IFDEF LINUX}
  FCalibrateUSleep: Int64;
  {$ENDIF}

function RDTSC: Int64;
asm
  dw 310Fh
end;

function GetFrequency: Int64;
begin
{$IFDEF LINUX}
  MeasureFrequency;
{$ENDIF}
{$IFDEF MSWINDOWS}
  QueryPerformanceFrequency(FFrequency);
{$ENDIF}
  Result:= FFrequency;
  {on LINUX this is the real Frequency, but not on Windows}
end;

{$IFDEF LINUX}
procedure CalibrateLinux;
var
  StartValue, StopValue: Int64;
  Val1, Val2, Val3, Val4, Val5: Int64;
begin
  USleep(1);

  StartValue:= RDTSC;
  StopValue:=  RDTSC;
  Val1:= (StopValue - StartValue);

  StartValue:= RDTSC;
  StopValue:=  RDTSC;
  Val2:= (StopValue - StartValue);

  StartValue:= RDTSC;
  StopValue:=  RDTSC;
  Val3:= (StopValue - StartValue);

  StartValue:= RDTSC;
  StopValue:=  RDTSC;
  Val4:= (StopValue - StartValue);

  StartValue:= RDTSC;
  StopValue:=  RDTSC;
  Val5:= (StopValue - StartValue);

  FCalibrate:=  (Val1 + Val2 + Val3 + Val4 + Val5) div 5;
end;

procedure CalibrateUSleep;
var
  StartValue, StopValue: Int64;
  Val1, Val2, Val3, Val4, Val5: Int64;
begin
  USleep(1);

  StartValue:= RDTSC;
  USleep(0);
  StopValue:=  RDTSC;
  Val1:= (StopValue - StartValue);

  StartValue:= RDTSC;
  USleep(0);
  StopValue:=  RDTSC;
  Val2:= (StopValue - StartValue);

  StartValue:= RDTSC;
  USleep(0);
  StopValue:=  RDTSC;
  Val3:= (StopValue - StartValue);

  StartValue:= RDTSC;
  USleep(0);
  StopValue:=  RDTSC;
  Val4:= (StopValue - StartValue);

  StartValue:= RDTSC;
  USleep(0);
  StopValue:=  RDTSC;
  Val5:= (StopValue - StartValue);

  FCalibrateUSleep := (Val1 + Val2 + Val3 + Val4 + Val5)div 5;
end;

procedure  MeasureFrequency;
var
  StartValue, StopValue: Int64;
  Val1, Val2, Val3, Val4, Val5: Int64;
begin
  CalibrateUSleep;

  StartValue:= RDTSC;
  USleep(1);
  StopValue:=  RDTSC;
  Val1:= (StopValue - StartValue -FCalibrateUSleep);

  StartValue:= RDTSC;
  USleep(1);
  StopValue:=  RDTSC;
  Val2:= (StopValue - StartValue -FCalibrateUSleep);

  StartValue:= RDTSC;
  USleep(1);
  StopValue:=  RDTSC;
  Val3:= (StopValue - StartValue -FCalibrateUSleep);

  StartValue:= RDTSC;
  USleep(1);
  StopValue:=  RDTSC;
  Val4:= (StopValue - StartValue -FCalibrateUSleep);

  StartValue:= RDTSC;
  USleep(1);
  StopValue:=  RDTSC;
  Val5:= (StopValue - StartValue -FCalibrateUSleep);

  FFrequency := (Val1 + Val2 + Val3 + Val4 + Val5) div 5 * 100;
end;
{$ENDIF}

{$IFDEF MSWINDOWS}
procedure CalibrateWindows;
var
  StartValue, StopValue: Int64;
begin
  QueryPerformanceCounter(StartValue);
  QueryPerformanceCounter(StopValue);
  FCalibrate:= StopValue - StartValue;
end;
{$ENDIF}

function TGRCounter.GetElapsed: Extended;
begin
  Result := (FStopValue - FStartValue - FCalibrate) / FFrequency;
end;

function TGRCounter.GetFrequency: Int64;
begin
  Result := FFrequency;
end;

function TGRCounter.GetCalibrate: Int64;
begin
  Result := FCalibrate;
end;

function TGRCounter.ReadMilliseconds: String;
begin
  Result := FloatToStr(Round(1000000 * Elapsed) / 1000); 
end;

function TGRCounter.ReadValue: Int64;
begin
  Result := FStopValue - FStartValue - FCalibrate; 
end;

procedure TGRCounter.Start;
begin
{$IFDEF LINUX}
  FStartValue:= RDTSC;
{$ENDIF}
{$IFDEF MSWINDOWS}
  QueryPerformanceCounter(FStartValue);
{$ENDIF}
end;

procedure TGRCounter.Stop;
begin
{$IFDEF LINUX}
  FStopValue:= RDTSC;
{$ENDIF}
{$IFDEF MSWINDOWS}
  QueryPerformanceCounter(FStopValue);
{$ENDIF}
end;

{ Timer Routines ==============================================================}

function StartCounter: TGRCounter;
begin
  Result.Start;
end;

function StopCounter(const aCounter: TGRCounter): Single;
begin
  //Result := 0.0;
  aCounter.Stop;
  Result := aCounter.Elapsed;
end;

initialization
  {$IFDEF LINUX}
  CalibrateLinux;
  {$ENDIF}
  {$IFDEF MSWINDOWS}
  CalibrateWindows;
  {$ENDIF}
  GetFrequency;
end.

Gruß tom

[mkinzler]

TGRCounter = object class

[3_of_8]

Das soll C++ sein? O_o

Also object ist ein Datentyp, der noch aus TurboPascal-Zeiten stammt und heute meistens nicht mehr verwendet wird. Das ganze ist so eine Art Mittelding zwischen Klasse und Record, es kann Methoden mit Sichtbarkeitsstufen besitzen, muss aber nicht erzeugt und freigegeben werden (bzw. das erledigt der Compiler).

Mir ist nicht ganz klar, warum object in deiner Delphi-Version nicht unterstützt wird, welche hast du denn? Falls du Delphi.NET verwendest, ist die Sache natürlich klar, das sieht aber eher nach Win32 aus.

Unter Win32 und mit Delphi>=2006/TurboDelphi würde ich einfach mal private/public/protected löschen und statt "object" einen "record" verwenden, dann geht zwar die Kapselung flöten, aber das ist nicht wirklich schlimm, und als schneller Workaround taugt es allemal.

@mkinzler: Möglich, aber dann muss er auch den Konstruktor und Free aufrufen, also größere Codeteile ändern.

[TomTaylor001]

das ist nicht der cpp code sondern der delphi code.
ich versuche es mal mit class ich hoffe es klappt

gruß tom

[TomTaylor001]

Danke es klappt. Ich glaube ich muss mal mit delphi anfangen.

gruß tom

[uligerhardt]

Zitat von TomTaylor001:

Danke es klappt.

Nur, wenn das Ding nicht benutzt wird. Und dann wäre es vielleicht besser, es ganz auszukommentieren statt es halb zu reparieren.
Einfach an einer Stelle object durch class ersetzen reicht jedenfalls nicht.

Zitat von TomTaylor001:

Ich glaube ich muss mal mit delphi anfangen.

Ich vermute, das wäre für nen BCB-Nutzer ne Super-Idee.

Uli.

[MarioR]

Hallo,

ich habe ein ähnliches, besser das gleiche Problem.

Von einem Kollegen, der in Delphi programmiert habe ich ein paar
*.pas-Units bekommen. Diese möchte ich in mein C++Builder-Projekt
einbinden.

Beim kompilieren bekomme ich den Fehler.

Was muß ich im Delphi-Quelltext umstellen, daß es der C++Builder6
schluckt?

Gruß Mario

[Phoenix]

Zitat von MarioR:

Beim kompilieren bekomme ich den Fehler.

Was muß ich im Delphi-Quelltext umstellen, daß es der C++Builder6
schluckt?

Okay.. meine Glaskugel meint, dass Du mit 'bekomme ich den Fehler' meinst, dass Du die Meldung "Sprach-Feature wird nicht unterstützt" bekommst. Sollte meine Glaskugel kaputt sein sag mir das bitte gleich.

Was Du an Deinem Quelltext umstellen musst.. hrm.. gute Frage. Keine Ahnung? Solange Du die Quellen nicht zeigst wird Dir das aber auch niemand anderes sagen können.

[MarioR]

Zitat von Phoenix:

Okay.. meine Glaskugel meint, dass Du mit 'bekomme ich den Fehler' meinst, dass Du die Meldung "Sprach-Feature wird nicht unterstützt" bekommst. Sollte meine Glaskugel kaputt sein sag mir das bitte gleich.

Was Du an Deinem Quelltext umstellen musst.. hrm.. gute Frage. Keine Ahnung? Solange Du die Quellen nicht zeigst wird Dir das aber auch niemand anderes sagen können.

... Ja deine Glaskugel hat recht, deshalb habe ich auch in diesen Thread gepostet.

Den Quellcode posten, da muß ich erst meinen Kollegen fragen, da es sein Eigentum, bzw. das unserer Firma ist.

Vom Prinzip her crasht es an der Stelle, wo steht ... = object

Delphi-Quellcode:

type
  TGRCounter = object [b]<<<<<[/b]
  private 
  ...

[Phoenix]

Tja.. da würde ich das eher an Deinen Kollegen zurückgeben.
Der soll Dir compilierfähigen Code geben. Das ist eigentlich nicht Dein Problem, oder?

Denn wie gesagt - nur object durch class ersetzen ist nicht unbedingt das Heilmitel.