Codecompletion - Aufrufkonventionen

[Socke]

Wenn ich eine Funktion folgendermaßen deklariere:

Code: Alles auswählen

interface
 
function abc(arg1, arg2: Integer): Integer; stdcall;

wird mit ++ folgendes Gerüst erstellt:

Code: Alles auswählen

implementation
 
function abc ( arg1, arg2: Integer ) : Integer;
begin
 
end;

Dieser Fehler tritt bei mir bei jeder Aufrufkonvention (pascal, register, stdcall, safecall) außer cdecl auf. Diese wird richtig ergänzt.
Kann das jemand bestätigen?

[RSE]

Hm, ich seh jetzt den fehler nich... (außer, dass beim 2. Argument aus arb2 plötzlich arg2 geworden ist, was aber wohl eher ein Schreibfehler deinerseits ist)

Falls du das stdcall; meinst, das wird nur im Interface benötigt, wenn ich nicht irre. Ist es im Implementation-Abschnitt überhaupt erlaubt?

[Euklid]

Ist es im Implementation-Abschnitt überhaupt erlaubt?

Nach der FreePascal-Referenz

ftp://ftp.freepascal.org/pub/fpc/docs-pdf/ref.pdf" onclick="window.open(this.href);return false;

gehören diese Aufrufkonventionen hinter die Deklaration der Funktion/Prozedur.

Soweit ich weiß, sind sie im Implementation-Bereich nicht verboten - ich nehme an, dort werden sie einfach ignoriert.

[pluto]

Zu diesem Fehler kann ich nix sagen mir ist aber noch ein andere aufgefallen. Hier erstmal eine kurze Beschreibung. Evlt. füge ich später noch ein Beispiel Soruce-Code hinzu:
Wenn ich eine klasse erstelle.
In dieser Klasse füge ich Methoden hinzu und Fehler.

Jetzt leite ich von dieser Klasse ab.
Füge dort Methoden hinzu. Vervollstände sie mit hilfe von strg+shift+c
dann fügt er bei mir immer zwei Variablen Doppelt hinzu die es eigentlich schon in gerbten klasse gibt. Das stört immer wieder, da ich diese Zwei Variablen löschen muss.
Da er sonst das nicht Kompeliert.

Ich gebe zu dir Beschreibung ist alles anders als gut.... ich werde noch mal versuchen den Fehler genauer zu studieren.

nix, gegen dieser strg+shift+c Funktion. die ist toll. sowas habe ich in Delphi immer vermist.... Die meisten sachen gehen ja auch.... bei dieser Defniation bin ich mir nicht sicher ob es jetzt an mir liegt oder auch ein Fehler von dieser Funktion ist:

property TestItem[index:Integer]:Boolean index 0 read GetTestItem write SettTestItem
Jetzt wird folgende Funktion erstellen:
function (index, index:Integer; AValue:Boolean);
der Fehler ist das es zweimal index gibt. Das könnte aber auch an mir liegen da ich ja ein index ändern könnte.... sehe ich das richtig ?

Aber auch die Code-Tools könnten ja drauf achten, und die Parameter entsprechend ändern !

[Socke]

beim 2. Argument aus arb2 plötzlich arg2 geworden ist[...]

berichtigt

gehören diese Aufrufkonventionen hinter die Deklaration der Funktion/Prozedur.

Genau da hab ich sie ja hingeschrieben. In der FreePascal-Referenz hab ich nicht mehr als du darüber gefunden.
Aber Folgendes kann mein FPC 2.2.0 nicht compilieren:

Code: Alles auswählen

unit Unit1; 
 
{$mode objfpc}{$H+}
 
interface
 
function test(arg1, arg2: Integer): Integer; stdcall;
 
implementation
 
function test ( arg1, arg2: Integer ) : Integer;
begin
 
end;
 
end.

Fehlermeldung(en):

Unit1.pp(11,10) Error: Calling convention doesn't match forward
Unit1.pp(7,10) Hint: Found declaration: test(LongInt, LongInt):LongInt;StdCall

Daraus schließe ich, dass sie erforderlich sind und nicht einfach ignoriert werden

So, und nun zu pluto:
Was du genau meinst, kann ich deinem text nicht entnehmen, beispielcode wäre super...
Wenn das mit der Sichtbarkeit der Felder/methoden zusammenhängt, bei Wikipedia gibts 'ne schöne Tabelle (leider für Delphi, aber in FreePascel dürfte das ähnlich sein).

Zu deinen Indizes:

Code: Alles auswählen

property TestItem[index:Integer]:Boolean index 0 read GetTestItem write SettTestItem

bei mir ist recht interessant:

Code: Alles auswählen

// aus
  TMyClas = class
  private
  public
    property test[Index: Integer]: Integer index 0 read GetInt write SetInt;
  end;
// wird
  TMyClas = class
  private
    function GetInt ( AIndex: integer; Index: Integer ) : Integer;
    procedure SetInt ( AIndex: integer; Index: Integer; const AValue: Integer
      ) ;
  public
    property test[Index: Integer]: Integer index 0 read GetInt write SetInt;
  end;

Was da wo übergeben wird habe ich aber nicht überprüft. Sonderbar ist auch, dass er einmal "integer" und einmal "Integer" schreibt.

Das könnte aber auch an mir liegen da ich ja ein index ändern könnte.... sehe ich das richtig ?

Das erste "index" ist ein einfacher Bezeichner, kann also geändert werden, während der zweite ein Sschlüsselwort ist und nicht geändert werden kann. Also gehe ich davon aus, dass in meinem Beispiel oben das AIndex dem Index der Array-Eigenschaft entspricht (also das Index in den eckigen Klammern).

Aber auch die Code-Tools könnten ja drauf achten, und die Parameter entsprechend ändern !

Das wird sehr, sehr viel aufwand, da du überprüfen musst, ob dieser oder jener Parameter schon irgendwo deklariert ist....


Ich hoffe die Verwirrung ist nun komplett verwirrt

Socke

[pluto]

Ja genauso war es bei mir auch gestern. Als mir das aufgefallen ist. Ich habe es auch nur angewendet weil es bei meinem Problem als sinnvoll erschienen ist.

Allerdings gehe ich davon aus, wenn die prüfen würden das zweimal index verwendet wird, könnten die doch ein Index umbenennen. Oder halt eine Fehler Meldung ausgeben. oder ?

[Socke]

Ja genauso war es bei mir auch gestern.

Ich hoffe du meinst mein Beispiel zum CodeCompletion von Array-Eigenschaften

könnten die doch ein Index umbenennen

aus "index" und "index" wird "AIndex" und "Index". Wurde da etwas umbenannt? Ich glaube schon.

Mal eine Frage am Rande:
Wenn ich das Richtig sehe, hast du zwei Methoden (einen Getter und einen Setter), die du für mehrere Eigenschaften verwenden willst. Da darunter eine Array-Eigenschaft ist, besitzen diese Methoden zwei Index-Parameter: einmal den Index des Arrays und einmal einen Index der Eigenschaft. Hast du mehrere solcher Eigenschaften? oder möchtest du nicht mehr Methoden verwenden (dann hätte ein Index nur bei der Array-Eigenschaft einen sinnvollen wert)?

P.S. kann jemand den von mir ursprünglich beschriebenen Fehler nachvollziehen?

[pluto]

>Wurde da etwas umbenannt?
Bei mir nicht... ich meine dein beispiel vom Letzten Pos
da stand zwei mal index.
Ich habe davon mehrer im Moment sind es 8 es werden aber 10 werden.

Code: Alles auswählen

property ViewHPenLeft[index:Integer]:Boolean index 0 read GetView write SetView;
    property ViewHPenTop[index:Integer]:Boolean index 1 read GetView write SetView;
    property ViewHPenRight[index:Integer]:Boolean index 2 read GetView write SetView;
    property ViewHPenBottom[index:Integer]:Boolean index 3 read GetView write SetView;
    property ViewHPen[index:Integer]:Boolean index 4 read GetView write SetView;
 
    property PenHLeft[index:Integer]:TMyPen index 0 read GetPen write SenPen;
    property PenHTop[index:Integer]:TMyPen index 1 read GetPen write SenPen;
    property PenHRight[index:Integer]:TMyPen index 2 read GetPen write SenPen;
    property PenHBottom[index:Integer]:TMyPen index 3 read GetPen write SenPen;
    property PenH[index:Integer]:TMyPen index 4 read GetPen write SenPen;

da kommen aber noch zwei hinzu..

Naja der Fehler macht ja nix... ich habe es Manuel angepasst. und es scheint soweit zu klappen.
Aber es währe dennoch schön, wenn die Code Tools entweder prüfen oder prüfen und dann den ersten index nach aindex umwandeln. und den zweiten so lassen.

So eine Defnination habe ich auch noch bis her nicht erstellt *G*

PS: Dein Fehler kann ich bisher nicht nach vollziehen ! aber dafür meinen *G*

EVLT: muss du stdcall; auch unten wo die Funktion erstellt wird hinschreiben...

[Socke]

vielleicht ist statt View* Display* oder Show* besser (ich denke nicht, dass dein Objekt deine Stifte (pen) anguckt)

Umbenannt wurde bei mir nicht die Deklaration der Eigenschaft sondern die Methodenparameter, die bei eins-zu-eins-Übertragung beide "index" heißen müssten. Ob die Funktionen/bzw. die Eigenschaften so funktionieren wie sie sollen habe ich nicht überprüft (ich gehe aber davon aus).

Nochmal mein Problem:

Code: Alles auswählen

unit Unit1; 
 
{$mode objfpc}{$H+}
 
interface
{ Beide Funktionsdeklarationen sind identisch (Name ausgenommen) }
  function CompiliertNicht(arg1, arg2: Integer): Integer; stdcall;
 
  function CompiliertDoch(arg1, arg2: Integer): Integer; stdcall;
 
implementation
 
function CompiliertNicht ( arg1, arg2: Integer ) : Integer;
{ Das hier wird durch CodeCompletion erzeugt. Der Aufrufmodifizierer (deutsch für
  calling modifier) wurde nicht übertragen. Hier gibt der Compiler einen Fehler
  und einen Hinweis aus:
  Unit1.pp(13,10) Error: Calling convention doesn't match forward
  Unit1.pp(7,12) Hint: Found declaration: CompiliertNicht(LongInt, LongInt):LongInt;StdCall
  }
begin
  Result := arg1+arg2;
end;
 
function CompiliertDoch ( arg1, arg2: Integer ) : Integer; stdcall;
{ Hier habe ich stdcall; manuell hinzugefügt. Es treten keine Fehler auf. }
begin
  Result := arg1+arg2;
end;
 
end.

EVLT: muss du stdcall; auch unten wo die Funktion erstellt wird hinschreiben...

Nicht nur evtl. aber die Code-Completion-Funktion von Lazarus fügt die Aufrufkonvention nur bei cdecl hinzu. (Ich suche eine Bestätigung des Fehlers für einen Bug-Tracker-Eintrag)

[pluto]

aha, jetzt verstehe ich dein Problem.

vielleicht ist statt View* Display* oder Show* besser (ich denke nicht, dass dein Objekt deine Stifte (pen) anguckt)

Wie ?
Ich dachte halt ViewPenleft soll heißen ob die Linke seite gezeichnet werden soll oder nicht...
und über PenLeft kann man die seite Konfigurieren...

Was dein Problem angeht: evlt. werde ich es bei Gelegenheit ausprobieren...

[Socke]

View = sehen
Display/Show = anzeigen
Draw = zeichnen
demnach wäre ViewPen (oder so ählich) schaue den Stift an und nicht zeichne oder zeige den stift... hilft vielleicht beim verstehen, wenn man den quelltext ein paar monate nicht gelesen hat

[pluto]

ach so... Danke für den Hinweis. werde ich ändern. Bei Gelegenheit. Du meinst also ich sollte es DrawPenLeft:TMyPen ändern ?
und ShowPenLeft:Boolean ?
Zeige die Linkte Zeite an.
Zeichne die Linke seite. bzw. eigentlich währe setzten bzw. ändern besser oder ?
also ChangePenLeft oder sowas.

[Socke]

property : TPen; kannst du so lassen (Pen kommt ja auch raus)
property ShowPenLeft: Boolean ist besser als ViewPenLeft (zeigen nicht gucken) oder PenVisible[Index] (sichtbar/nichtsichtbar)
Change/Set/Get nur für Methoden (die Eigenschaften bestimmen ja nicht, ob das gemacht wird; ChangePenLeft: Boolean hieße soviel wie ändere den linken Stift: ja/nein)

[pluto]

Stimmt. Aber dann ergibt sich aber ein Problem:
Bei den Eigenschaften kann ich ja setzten oder auslesen.
und ShowPenLeft hätte ich ja schon.Evlt. währe VisiblePenLeft besser oder ?
weil
ViewPen heißt bei mir soll die seite angezeigt werden ?
und Pen welche konfiguation dies seite hat.

[Socke]

Stimmt. Für eine Eigenschaft ist VisblePenLeft oder PenLeftVisible besser als ShowPenLeft (das eher für eine Prozedur/Funktion).
Es geht darum, den Quellcode lesbar und verständlich zu halten. D.h. Funktionen und Prozeduren sollten mit einem Verb, das aussagt, was gemacht wird, beginnen. Eigenschaften hingegen können nichts tun, dort sind Nomen besser. Bsp: property Visible(Nomen): Boolean read GetVisible(Verb) write SetVisible(Verb);