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

[MaBuSE]

Was soll das denn???

Ich bin gerade dabei funktionierenen Quelltext von D2007 nach DXE zu portieren.

Dabei gibt es eine Prozedur, die wie folgt aussieht:

Delphi-Quellcode:

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

Es geht hier um ca. 1200 Zeilen.

Unter D2007 ging das !!!
Mit XE gibt es folgenden Fehler:

Delphi Hilfe

E2283: Zu viele lokale Konstanten. Verwenden Sie kürzere Prozeduren (Delphi)
Eine oder mehrere Ihrer Prozeduren enthält so viele String-Konstanten, dass die interne Speichergrenze des Compilers überschritten wurde. Dieses Problem kann in automatisch generiertem Code auftreten. Kürzen Sie die betreffenden Prozeduren, oder deklarieren Sie Konstanten anstelle der vielen Literale.

Retrieved from "http://docwiki.embarcadero.com/RADStudio/XE/de/E2283:_Zu_viele_lokale_Konstanten._Verwenden_Sie_k %C3%BCrzere_Prozeduren_(Delphi)"
Category: RAD Studio – Referenz

Lösung:

Delphi-Quellcode:

function blabla: TStrings
begin
  ...
  Result.Text := 'blabla' + #13#10 + 
    'blabla' + #13#10 + 
    'blabla' + #13#10 + 
    ...
    'blabla' + #13#10;
end;

Diese neue künstliche Beschränkung finde ich doof ;-/

mfg
MaBuSE

ps: Habe gerade gesehen, dass auch schon andere auf das Problem gestossen sind:
http://www.delphipraxis.net/106236-f...bersetzen.html

[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]

[himitsu]

Sobald ein + drin vorkommt, wird jeder Teil als einzelnes Stringliteral verwaltet.

1024 ... war nicht schon bei 255 Zeichen Schluß?