"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:

Zitat von himitsu (Beitrag 1079406)

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:

Zitat von himitsu (Beitrag 1079406)

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:

Zitat von sx2008 (Beitrag 1079446)

...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

Delphi-Quellcode:

');^p  Result.Add('

wird einfach

Delphi-Quellcode:

'+#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

Delphi-Quellcode:

.Add(...);

in

Delphi-Quellcode:

.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:

Zitat von MaBuSE (Beitrag 1079469)

Mit wenig Aufwand kann man dann auch noch das

Delphi-Quellcode:

.Add(...);

in

Delphi-Quellcode:

.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:

Zitat von sx2008 (Beitrag 1080027)

Zitat:

Zitat von MaBuSE (Beitrag 1079469)

Mit wenig Aufwand kann man dann auch noch das

Delphi-Quellcode:

.Add(...);

in

Delphi-Quellcode:

.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ß?

[Mike_]

Zitat:

Zitat von himitsu (Beitrag 1080035)

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

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

Richtig, zumindest für Delphi <= 2007 kann ich dir das Bestätigen.

[DCC Error] Unit2.pas(29): E2056 String literals may have at most 255 elements
[DCC Error] Project1.dpr(5): F2063 Could not compile used unit 'Unit2.pas'

[DeddyH]

IIRC gelten die 1024 für Resourcestrings.

[Patito]

Ich hab gerade mal eine Prozedur mit 40000 Adds zu einer StringList getestet.
Mit D7 anscheinend kein Problem...

[himitsu]

40000 Add's ... Doch nicht etwa alles mit der "selben" String-Konstante? :roll:

[Patito]

Nein. 40000 Literale genau so wie im Code vom ersten Beitrag hier...

[himitsu]

Delphi-Quellcode:

SL.Add('abc');
SL.Add('abc');
SL.Add('abc');
SL.Add('abc');

Ich meine es so: 40.000 Mal das Selbe oder Alle unterschiedlich?

[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. :stupid:

[himitsu]

Zitat:

Zitat von MaBuSE (Beitrag 1080068)

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. :zwinker:

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

[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 ?!?)

[MaBuSE]

Zitat:

Zitat von MaBuSE (Beitrag 1080068)

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. :stupid:

Und wie passt das zusammen?

Folgende Funktion mit 2000 Zeilen geht auch:

Delphi-Quellcode:

...
function TForm1.GetMyText4: TStrings;
begin
  Result := TStringList.Create;
  Result.Text :=
  'AD:UbÖfQlqIvH_Fd~k)g!_§eQguY#bwO,c)[x;#COOyC8A)ü)"' + #13#10 +
  '4UÜ8^ö\YÖdI)x;y6^ÜhA"])&TO~=7:ÜcJßc,Qb3°RPaR6xcP9%' + #13#10 +
  '&IHFK?+m0r&xi**OJGGTÖW6Zk-ffü!€fvd(&4$p38;ÄLvoLF3Ö' + #13#10 +
  'I<-Ü<b"%xÄPX|kM]eFK:4!KÄBe&#8364;2gs&#8364;ijwH.(S<xM@oU+7Kß<3' + #13#10 +
  'gsWS!\ß!3J&OX;§r]PDSAlnkItyuÖ*5Zl7,9Z!4,kkß=tU!-/&#8364;' + #13#10 +
  'S)ad"t°SBW@g:(°bn-CYFyqAP"fn3aPdH"h=ü5@CZ;ÜDPPppOA' + #13#10 +
  '1(6X:GwHkÄU+1pD\QEFK+^LV(]xD8+<zÄ\(§@\%=BkfH=a.~E@' + #13#10 +
  '<wÜlq&!ißy°K\C0jzö*ä^xw\XTrÜ/D0+uQäH°=,rAW6;Fv>:.$' + #13#10 +
  ']VPÄ#SB*5urO?,J8?Vvoy"=fD9dFuVIü.iev~$pI+ZDi;:rZqk' + #13#10 +
  'üqä/*t20eYo$üR°Dg@uz,Öp7O[vPf0*wNuOhÄ#.PR&biYD&#8364;ÜIÄ' + #13#10 +
  'B07)T@*öw=&Tl&#8364;1,$d8Kijq6~Ö%\jJob<XmI1z2WTp°y6ll=~Ü' + #13#10 +
  '61<WC[x[U#JrG\m":#nüb:SkpI°ASKGäb+L!ow1K>g^b?.qyc$' + #13#10 +
  'hqr[k7"wRgpwjuGS\4t@#8pd_6cö;ZßEv#:W[Ä"a&#8364;Xvj+9CpWx' + #13#10 +
  'zZ49h6("Q<s§43z%@39_qC|D%&#8364;Zö>=FJj;U|7]?mCC9=uy%>bQ' + #13#10 +
  'N\NhPpxKmdbGd_Yl7FanH(pD§zs$AJY1+ßa-vtEÄÄqX6jJ.7-C' + #13#10 +
  'ÄÄ_k#+~Haz&)tmQ@vO<ß8IsD!NTJißr6e!pJ§°V+q"]qD%K80@' + #13#10 +
  '9)fß,baHlBg;RH,lPZv~qPMäen6.-Q&(!Qjd<pVYD:-BS1cß35' + #13#10 +
  'u=R$YQ;@JZ@!Mprr=;p@5B;7n<~6ömMI\z°boÖuGI/O,V4P0ä^' + #13#10 +
...
  '[aBaT]^*O1c9yfg)IÜ@En&#8364;wp?JÖ:cM&#8364;*IY^n.)|KAc§XoKÖDÄ[';
end;
...

[edit]
Ich habe das gerade noch mal mit 5.000 Zeilen getestet. Also fast 5 mal so viel wie bei der Add-Orgie.
-> Es funktioniert !!!
[/edit]

[Patito]

Vermutlich wird jeder String vom Compiler erst mal komprimiert,
und das geht eben besser wenn man nur einen großen String hat.

Taucht jeder Buchstabe einzeln in einer Add-Zeile auf, gäbe es ja praktisch gar keine Möglichkeit etwas zu komprimieren. Dass man das Limit mit einem einzelnen längeren String erst später erreicht ist dann eigentlich logisch.

Das Limit an sich ist aber so oder so zum kotzen.
Ich erinnere mich dunkel, dass ich mal eine Unit, in der es darum gieng einen längeren konfigurierbaren Text zusammenzubasteln, wegen diesem Unfug umschreiben mußte.

Delphi-Quellcode:

if (MyConfig.WantItemXYZ) then 
 List.Add('xyz')
else
 List.Add('---');
 ...

Wenn man viele solche Zeilen hat, nützen einem die Komprimier-Tricks vom Compiler nix.

[himitsu]

Ich bin mir relativ sicher, daß der Compiler nichts komprimiert.

Denn wozu soll das gut sein?
- er bekommt die Strings unkomprimiert
- er muß die Strings dann unkomprimiert abspeichern/verarbeiten
- beim Vergleichen von Strings macht sich schwieriger (falls es mal gleiche gibt, welche man dann als einen String verwalten könnte)
- das Debuggen des Compilers verbessert es auch nicht, da dann ja quasi alles "verschlüsselt" wäre
= kurz um, er kommt mit unkomprimierten Strings besser aus ... Alles andere wäre nur umständlich und eine zusätzliche Fehlerquelle ... ich als Compilerentwickler hätte mir diese zusätzliche Arbeit garantiert erspart.

[Patito]

Es spricht viel dafür, dass der Compiler intern für die Strings ein Dictionary anlegt.
Und letztenendes ist es nur Wortklauberei, ob man das jetzt Komprimierung nennt oder nicht.
(Dictionary compression...)