array of const

[Mathias]

In der Unit xlib habe ich folgendes gefunden:

Code: Alles auswählen

function XGetIMValues(para1:PXIM; dotdotdot:array of const):Pchar;cdecl;external libX11;

Da wird eine "array of const" verlangt.
Da wollte ich folgendes deklarieren;

Code: Alles auswählen

  var
    ac:array of const;

Da motzt der Colpiler "Illegal expression"

Das habe ich noch probier, bei

Code: Alles auswählen

XGetIMValues(im, xnq)

den Cursor auf "xng" setzen und [Ctrl+Shft+c] zu drücken.
Dann hüpft er aber in der "xlib" auf folgende Zeile:

Code: Alles auswählen

function XGetIMValues(para1:PXIM; dotdotdot:array of const):Pchar;cdecl;external libX11;

Mit dem Fehler: "xlib.pp(1759,54) Error: Bezeichner erwartet, statt dessen const gefunden"

Wie kann ich dieses Problem lösen ?


Nachtrag:

Code: Alles auswählen

  function test(ac:array of const):Pchar;
  begin
  end;

Aber sowas kompiliert er.

[theo]

Da wird eine "array of const" verlangt.

Eine FPC Doku gibt es ja durchaus:
https://www.freepascal.org/docs-html/ref/refsu69.html

[PascalDragon]

In der Unit xlib habe ich folgendes gefunden:

Code: Alles auswählen

function XGetIMValues(para1:PXIM; dotdotdot:array of const):Pchar;cdecl;external libX11;

Da wird eine "array of const" verlangt.

Im Fall einer externen cdecl Funktion heißt das einfach, dass du beliebige Parameter mit Array-Klammern nutzen kannst:

Code: Alles auswählen

XGetIMValues(im, [a, b, 42, p])

Es gibt aber keinen Typ dafür.

[fliegermichl]

Das wird ja auch bei Format verwendet.

Code: Alles auswählen

procedure TForm1.Button1Click(Sender : TObject)
begin
 Memo1.Lines.Add(Format('%s %d %.3f', ['Hallo', 14, 1.414]));
end;

[Mathias]

Die Funtion von "XGetIMValues" ist in der Xlib.h sowieso etwas merkwürdig.

Code: Alles auswählen

extern char *XGetIMValues(
    XIM /* im */, ...
) _X_SENTINEL(0);

Was bedeuten da die "..." ?
In Pascal ist sie so:

Code: Alles auswählen

function XGetIMValues(para1:PXIM; dotdotdot:array of const):Pchar;cdecl;external libX11;

Da sind 2 Parameter.

Und in einem funktionierendem C-Programm sind es 4 Parameter.

Code: Alles auswählen

#define XNQueryInputStyle "queryInputStyle"
...
   failed_arg = XGetIMValues(im, XNQueryInputStyle, &styles, NULL);

Die Sprache C zu verstehen, ist zwischendurch echt schwer.

Haben die "..." in C etwa die gleiche Bedeutung wie in Pascal "array of char" ?

[fliegermichl]

Das ist in C wie die Deklaration array of const und bedeutet, daß hier noch mehr Parameter folgen können.
Deren Anzahl ist nicht begrenzt.

In Pascal ist das nur bei spziellen Prozeduren wie z.B. writeln möglich.

[Mathias]

So geht es in Pascal:

Code: Alles auswählen

XGetIMValues(im, [XNQueryInputStyle, @styles, nil]);

Und so in C:

Code: Alles auswählen

XGetIMValues(im, XNQueryInputStyle, &styles, NULL);

Anscheinend braucht C keine [] bei einer offenen Array.

[PascalDragon]

Code: Alles auswählen

XGetIMValues(im, XNQueryInputStyle, &styles, NULL);

Anscheinend braucht C keine [] bei einer offenen Array.

Das ist kein offenes Array , sondern eine „variable Argumentliste”. Konzeptionell sind das zwei verschiedene Konzepte: ein offenes Array ist ein einzelner Parameter, während bei einer variablen Argumentliste auch wirklich alles einzeln übergeben wird.

Deswegen habe ich beim array of const das cdecl im Zusammenhang mit external explizit erwähnt, da sich hier der Parameter nicht wie ein Array verhält, sondern eben wie eine variable Argumentliste, auch wenn es als Array deklariert wird. Eine Alternative ist der varargs Modifizierer:

Code: Alles auswählen

function XGetIMValues(para1:PXIM):Pchar;cdecl;varargs;external libX11;

In dem Fall kannst du XGetIMValues wie in C nutzen.

In Pascal ist das nur bei spziellen Prozeduren wie z.B. writeln möglich.

Writeln ist ein Intrinsic und keine Prozedur, deswegen folgt es auch nicht den üblichen Begrenzungen bei Prozeduren/Funktionen.

[Mathias]

Eine Alternative ist der varargs Modifizierer:

Ich kann mit vorstellen, da die xlib Unit schon recht alt ist, das da FPC varargs gar noch nicht kannte.
Wäre dies ein Bug-Report wert ?

[PascalDragon]

Eine Alternative ist der varargs Modifizierer:

Ich kann mit vorstellen, da die xlib Unit schon recht alt ist, das da FPC varargs gar noch nicht kannte.
Wäre dies ein Bug-Report wert ?

Nein, weil das die Kompatibilität der Unit brechen wurde (Aufruf mit eckigen Klammern vs. ohne).

[Mathias]

Bei folgender function musste ich zwingend eckige Klammer verwende:

Code: Alles auswählen

function XCreateIC(para1:PXIM; dotdotdot:array of const):PXIC;cdecl;external libX11;

Bei GTK2 bin ich auf folgende Funktion gestossen:

Code: Alles auswählen

procedure gtk_dialog_add_buttons(dialog:PGtkDialog; first_button_text:Pgchar; args:array of const); overload; cdecl; external gtklib;
procedure gtk_dialog_add_buttons(dialog:PGtkDialog; first_button_text:Pgchar); cdecl; overload; varargs; external gtklib;

Bei der GTK2 function werden keine eckigen Klammer verlangt.
Ich sehe das "varargs", aber nur in der "overload" function, welche keine "array of const" hat. Aber anscheinend verwendet es diese, obwohl dort nur ein PChar definiert ist.

Dies würde folgender Test beweisen, welcher anstandslos kompiliert wird:

Code: Alles auswählen

program project1;
const
  gtklib = 'libgtk-x11-2.0.so';
  //procedure gtk_dialog_add_buttons(dialog:Pointer; first_button_text:Pchar; args:array of const); overload; cdecl; external gtklib;
  procedure gtk_dialog_add_buttons(dialog: Pointer; first_button_text: PChar); cdecl; overload; varargs; external gtklib;
begin
  gtk_dialog_add_buttons(nil, 'Beenden', 100, 'Abbrechen', 101, 'Speichern', 102, nil);
end.

Anscheinend ist "varargs" eine recht magische Sache.
https://www.freepascal.org/docs-html/ref/refsu97.html

[PascalDragon]

Bei der GTK2 function werden keine eckigen Klammer verlangt.
Ich sehe das "varargs", aber nur in der "overload" function, welche keine "array of const" hat. Aber anscheinend verwendet es diese, obwohl dort nur ein PChar definiert ist.

Bei einer Routine, welche einen array of const-Parameter hat, müssen die Werte mit Hilfe eines Array-Konstruktors übergeben werden, schließlich handelt es sich um einen offenen Array Parameter. Bei einer externen cdecl Routine werden diese Werte dann passend für eine variadische C Routine übergeben.
Bei einer Routine, welche mit varargs markiert ist, werden die Parameter wie in C Code direkt im Aufruf ohne einen offenen Array Konstruktor angegeben und die Parameter passend an die C Routine übergeben.

Hast du zwei überladene Routinen, von denen eine mit array of const und die andere mit varargs markiert ist, heißt das einfach nur, dass du wählen kannst, ob du die Parameter auf die eine oder die andere Weise übergeben möchtest.

Anscheinend ist "varargs" eine recht magische Sache.
https://www.freepascal.org/docs-html/ref/refsu97.html

Die array of const-Variante ist magischer als die varargs-Variante, schließlich ist letzteres das was quasi jeder C Compiler beherrscht, um Funktionen wie printf oder scanf umzusetzen.

[fliegermichl]

Wenn aber der FPC varargs beherrscht, weshalb stehen diese dem FPC Programmierer nicht zur Verfügung?
Also außer um externe C Routinen aufzurufen.

[Socke]

Wenn aber der FPC varargs beherrscht, weshalb stehen diese dem FPC Programmierer nicht zur Verfügung?
Also außer um externe C Routinen aufzurufen.

Ein Beispiel wie das in C genutzt wird findest du hier: https://www.tutorialspoint.com/cprogram ... uments.htm. Die Referenz gibt da ein paar gute Gründe, das Konstrukt nicht zu verwenden:

If the type of the next argument in ap (after promotions) is not compatible with T, the behavior is undefined, unless:

one type is a signed integer type, the other type is the corresponding unsigned integer type, and the value is representable in both types; or
one type is pointer to void and the other is a pointer to a character type.

Damit hast du zwei Punkte, die ein Pascal Array of Const besser macht:

• Die Länge des Arrays wird immer korrekt mitgegeben.
• Es werden Typinformationen der Argumente übergeben.

Letzteres gilt natürlich nur innerhalb von Pascal. Wenn ein Array of Const an eine externe C-Funktion übergeben wird, fallen die Typinformationen natürlich weg (werden in C nicht unterstützt).

[PascalDragon]

Wenn aber der FPC varargs beherrscht, weshalb stehen diese dem FPC Programmierer nicht zur Verfügung?
Also außer um externe C Routinen aufzurufen.

Weil die Seite der Implementierung um einiges schwieriger umzusetzen ist. Man braucht zum Beispiel Mechanismen, um auf die Parameter zugreifen zu können (in C und C++ die va_arg und Freunde Funktionen/Makros) und das auch für jede Plattform. Die Möglichkeit solche Funktionen aufzurufen bekommt man im Gegensatz dazu quasi gratis, wenn man die ABI der Plattform implementiert.

Und wie Socke geschrieben hat: array of const ist da um einiges mächtiger und typsicherer. Wir brauchen da nicht noch einen weiteren Mechnismus, den die Leute dann missbrauchen und sich wundern warum was nicht funktioniert.