"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

[MaBuSE]

Hallo,
ich habe mir dass noch mal genauer angesehen.

Folgender Test in D2007 (win32):

Mit folgender Procedure erzeuge ich etwas Quellcode:

Delphi-Quellcode:

...
var
  z: shortstring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890ßäöüÄÖÜ!"§$%&/()=?+*#-_.:,;@€~<>|^°[]\';

procedure TForm1.Button1Click(Sender: TObject);
var
  i, j: Integer;
  s: string;
begin
  Memo1.Lines.BeginUpdate;
  Memo1.Lines.Add('  Result := TStringList.Create;');
  for i := 1 to 2000 do
  begin
    s := '';
    for j := 1 to 50 do
    begin
      s := s + z[Random(100)+1];
    end;
    Memo1.Lines.Add('  Result.Add('''+s+''');');
//    Memo1.Lines.Add('  Result.Add(''12345678901234567890123456789012345678901234567890'');');
  end;
  Memo1.Lines.EndUpdate;
end;
...

Unter Delphi 2007 gibt es diese Fehlermeldung auch !!!

Es lassen sich 1093 Zeilen kompilieren. Bei 1094 Zeilen gibt es diese Fehlermeldung.

Delphi-Quellcode:

...
procedure TForm1.Button2Click(Sender: TObject);
begin
  with GetMyText do
  try
    Memo1.Lines.Text := Text;
  finally
    Free;
  end;
end;

function TForm1.GetMyText: TStrings;
begin
  Result := TStringList.Create;
  Result.Add('gsWS!\ß!3J&OX;§r]PDSAlnkItyuÖ*5Zl7,9Z!4,kkß=tU!-/€');
  Result.Add('S)ad"t°SBW@g:(°bn-CYFyqAP"fn3aPdH"h=ü5@CZ;ÜDPPppOA');
  Result.Add('1(6X:GwHkÄU+1pD\QEFK+^LV(]xD8+<zÄ\(§@\%=BkfH=a.~E@');
  Result.Add('<wÜlq&!ißy°K\C0jzö*ä^xw\XTrÜ/D0+uQäH°=,rAW6;Fv>:.$');
  Result.Add(']VPÄ#SB*5urO?,J8?Vvoy"=fD9dFuVIü.iev~$pI+ZDi;:rZqk');
  Result.Add('üqä/*t20eYo$üR°Dg@uz,Öp7O[vPf0*wNuOhÄ#.PR&biYD€ÜIÄ');
  Result.Add('B07)T@*öw=&Tl€1,$d8Kijq6~Ö%\jJob<XmI1z2WTp°y6ll=~Ü');
  Result.Add('61<WC[x[U#JrG\m":#nüb:SkpI°ASKGäb+L!ow1K>g^b?.qyc$');
  Result.Add('hqr[k7"wRgpwjuGS\4t@#8pd_6cö;ZßEv#:W[Ä"a€Xvj+9CpWx');
  Result.Add('zZ49h6("Q<s§43z%@39_qC|D%€Zö>=FJj;U|7]?mCC9=uy%>bQ');
  ...
end;

Was ich Interesannt finde ist das aber 2000 Zeilen möglich sind, wenn man folgende Funktion kompiliert:

Delphi-Quellcode:

...
function TForm1.GetMyText: TStrings;
begin
  Result := TStringList.Create;
  Result.Add('12345678901234567890123456789012345678901234567890');
  Result.Add('12345678901234567890123456789012345678901234567890');
  Result.Add('12345678901234567890123456789012345678901234567890');
  Result.Add('12345678901234567890123456789012345678901234567890');
  Result.Add('12345678901234567890123456789012345678901234567890');
  ...
end;

Es sind auch 2000 Zeilen mit folgender Funktion möglich:

Delphi-Quellcode:

...
function TForm1.GetMyText: TStrings;
begin
  Result := TStringList.Create;
  Result.Add('AD:UbÖfQlqIvH_Fd~k)g');
  Result.Add('kkß=tU!-/€S)ad"t°SBW');
  Result.Add('@g:(°bn-CYFyqAP"fn3a');
  Result.Add('PdH"h=ü5@CZ;ÜDPPppOA');
  Result.Add('1(6X:GwHkÄU+1pD\QEFK');
  Result.Add('+^LV(]xD8+<zÄ\(§@\%=');
  Result.Add('BkfH=a.~E@<wÜlq&!ißy');
  Result.Add('°K\C0jzö*ä^xw\XTrÜ/D');
  Result.Add('0+uQäH°=,rAW6;Fv>:.$');
  Result.Add(']VPÄ#SB*5urO?,J8?Vvo');
  ...
end;

Evtl wird der String im Speicher komprimiert abgelegt. Und der komprimierte String darf eine gewisse Größe nicht überschreiten.

Was noch selsam ist:

Eine Umwandlung von den Add()'s ind ein 'bla' + #13#10 + 'bla'... hat bei mir funktioniert.
Der String wurde aber eigentlich nicht kürzer.

[himitsu]

Zitat von MaBuSE:

Was ich Interesannt finde ist das aber 2000 Zeilen möglich sind, wenn man folgende Funktion kompiliert:

Das meinte ich ja grade.
Delphi merkt in diesem Fall, daß es die selben "Strings" sind und erzeugt deshalb nur die erste Stringkonstante, wärend nachvolgend immer wieder die selbe Konstante genutzt wird ... es ist also immer nur eine lokale Konstante, egal wie oft man sie verwendet.

PS: So ähnlich wie du hatte ich damals auch meinen Testquellcode erzeugt.

[Patito]

Ok himitsu, Du hast damit recht. Bei gleichen oder ähnlichen Strings packt D7 sehr viele Adds.
Mit GUIDs der Art

Delphi-Quellcode:

AktList := TStringList.Create;
AktList.Add('{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}');
...

stoße ich mit D7 bei 1367 Adds an ein Limit. (64k ?!?)