"E2283: Zu viele lokale Konstanten. Verwenden Sie kürzere Prozeduren" Fehler

[Memnarch]

Hatte D2007 schon Unicode? Wenn nicht. waren die Strings in D2007 einfach kleine(ca die Hälfte).
In XE schwellen die dan per Unicode vllt auf die doppelte Größe von D2007 an?

Geh mal nach D2007 und verdopple dort die anzahl der Strings. Vllt rüttelts da den selben effekt?

MFG
Memnarch

[himitsu]

Ja, es ist weniger geworden.
Nein, es gibt keine schöne Lösung im Quellcode, außer die Strings auszulagern ... z.B. in die Ressourcen oder in andere Prozeduren.

Delphi-Quellcode:

procedure blablaA(Result: TStrings);
begin
  ...
  Result.Add('blabla');
  Result.Add('blabla');
  Result.Add('blabla');
  ...
end;

procedure blablaB(Result: TStrings);
begin
  ...
  Result.Add('blabla');
  Result.Add('blabla');
  Result.Add('blabla');
  ...
end;

function blabla: TStrings
begin
  ...
  blablaA(Result);
  blablaB(Result);
  ...
end;

PS:
http://www.delphipraxis.net/150786-d...enden-sie.html
http://www.delphipraxis.net/127145-l...-begrenzt.html

[USchuster]

Zitat von himitsu:

Ja, es ist weniger geworden.

Ich glaube im Compiler existiert ein Limit von etwa 64KB für lokale Konstanten. Dies ist gleichgeblieben, aber die Stringkonstanten benötigen seit D2009 den doppelten Platz.

Zitat von himitsu:

Nein, es gibt keine schöne Lösung im Quellcode, außer die Strings auszulagern ... z.B. in die Ressourcen oder in andere Prozeduren.

Delphi-Quellcode:

procedure blablaA(Result: TStrings);
begin
  ...
  Result.Add('blabla');
  Result.Add('blabla');
  Result.Add('blabla');
  ...
end;

procedure blablaB(Result: TStrings);
begin
  ...
  Result.Add('blabla');
  Result.Add('blabla');
  Result.Add('blabla');
  ...
end;

function blabla: TStrings
begin
  ...
  blablaA(Result);
  blablaB(Result);
  ...
end;

Es muss keine separate Prozedur/Funktion sein - nested Prozeduren zu verwenden geht auch

Delphi-Quellcode:

function blabla: TStrings;

  procedure blablaA;
  begin
    ...
    Result.Add('blabla');
    Result.Add('blabla');
    Result.Add('blabla');
    ...
  end;

  procedure blablaB;
  begin
    ...
    Result.Add('blabla');
    Result.Add('blabla');
    Result.Add('blabla');
    ...
  end;

begin
  ...
  blablaA;
  blablaB;
  ...
end;

[sx2008]

Also ich würde ein Konstantenarray einsetzen:

Delphi-Quellcode:

const
  MyList : array[0..1200] of AnsiString = (
   'blabla',
   'blabla2',
   ...
  );

function blabla: TStrings
begin
  ...
  for i:=Low(MyList) to High(MyList) do
    result.Add(Mylist[i]);

Das hat den Vorteil, dass deine 1200 Zeilen "dichter" (also ohne immer ein result.Add()) zusammen sind.
Ausserdem spart man auch den Code für ungefähr 1200 Methodenaufrufe.
Allerdings habe ich früher schon mal festgestellt, dass bei sehr grossen Konstantenarrays der
Compiler extrem langsam (einige Minuten) werden kann.
Dieser Performanceeinbruch steigt dann auch noch quadratisch mit der Anzahl der Einträge

[himitsu]

Eventuell auch mal resourcestring oder eben direkt die Ressourcen verwenden.
Bei Letzerem hat man die Zeilen noch dichter beieinander ... z.B. direkt in einer Textdatei, welche dann einfach nur noch über eine .RC/.RES ins Programm gelinkt wird.

[MaBuSE]

Vielen Dank für Eure Antworten

Zitat von sx2008:

...Das hat den Vorteil, dass deine 1200 Zeilen "dichter" (also ohne immer ein result.Add()) zusammen sind.
Ausserdem spart man auch den Code für ungefähr 1200 Methodenaufrufe....

Also ich finde, dass der Code genauso dicht zusammen steht

Die Lösung, die ich im 1. Beitrag gezeigt habe, hat für mich einen großen Vorteil:

Es handelt sich bei mir um automatisch generierten Code.
Ich möchte es also vermeiden nach jedem Update wieder alle Änderungen von Hand zu machen.

Meine Lösung hat den Vorteil, dass es einfach mit einem Suchen und Ersetzen erledigt ist

Aus ');^p Result.Add(' wird einfach '+#13#10+^p ' Damit habe ich dann auch nur noch einen Add Aufruf.
Das ist auch schneller als 1200 Einzelne oder 1200 in einer Schleife.

Mit wenig Aufwand kann man dann auch noch das .Add(...); in .Text := ... ; ersetzen.

Fertig.
Aufwand: 20 Sekunden.

Aus diesem Grund habe ich die Lösung gleich mit gepostet.
(Ich habe allerdings den Vorteil nicht dazugeschrieben)

Viel Spaß
MaBuSE

[sx2008]

Zitat von MaBuSE:

Mit wenig Aufwand kann man dann auch noch das .Add(...); in .Text := ... ; ersetzen.

Das würde wohl Probleme machen, denn dann müssten alle Zeilen zu einen einzigen Stringliteral zusammengefügt werden.
Der Compiler verarbeitet aber nur Stringliterale bis zu einer best. Länge (1023, wenn ich mich nicht irre).

Delphi-Quellcode:

.Text := 'blabla'#13#10'blabla2'#13#10'blabla3'#13#10+
'blabla4'#13#10....

[MaBuSE]

Zitat von sx2008:

Zitat von MaBuSE:

Mit wenig Aufwand kann man dann auch noch das .Add(...); in .Text := ... ; ersetzen.

Das würde wohl Probleme machen, denn dann müssten alle Zeilen zu einen einzigen Stringliteral zusammengefügt werden.
Der Compiler verarbeitet aber nur Stringliterale bis zu einer best. Länge (1023, wenn ich mich nicht irre).

Delphi-Quellcode:

.Text := 'blabla'#13#10'blabla2'#13#10'blabla3'#13#10+
'blabla4'#13#10....

Du musst Dich irren

Genau so habe ich es gemacht.
(-> mehr als 1200 Add-Zeilen zu einem String Literal.)

-> Es funktioniert!

Das ist es ja, was mich verwundert hat.
Die Fehlermeldung bedeutet zu viele Konstanten.
Nicht zu viel Inhalt in den Konstanten !!!

[edit]
Anmerkung:
Ich habe gerade mal den Quelltext gecheckt.´
Der String ist 68186 Byte groß (Ansi)
Er belegt also intern ca. 128 kByte als UnicodeString

Damit stimmt auch die Anmerkung von der 64kByte Grenze für Strings nicht. (s.o.)
[/edit]