Published sets in FPC are limited to 32 elements

[Fred vS]

It is  few short for what I need, why this limitation?

[cdbc]

Hi Fred
It has been discussed here in the forum, also with a solution...
It was a year or more likely 2 back, so gather your "Find-Voodoo" 
I think you can get Grok to trawl the forum 
Regards Benny

[Fred vS]

Hello Benny.

Yes, I did some research before asking, and it seems the best solution is to split the set.

Okay (but, in my opinion, 32 elements in 2026 is a small number).

[valdir.marcos]

Published sets in FPC are limited to 31 elements.
It is  few short for what I need, why this limitation?

https://www.freepascal.org/docs-html/ref/refsu16.html

3.3.3 Set types
Free Pascal supports the set types as in Turbo Pascal. The prototype of a set declaration is:

_________________________________________________________________________________________________________
Set Types
  set type set  of  ordinal type
___________________________________________________________________

Each of the elements of SetType must be of type TargetType. TargetType can be any ordinal type with a range between 0 and 255. A set can contain at most 256 elements. The following are valid set declaration:

Type 
  Junk = Set of Char; 
  Days = (Mon, Tue, Wed, Thu, Fri, Sat, Sun); 
 
Var 
  WorkDays : Set of days;
Given these declarations, the following assignment is legal:

WorkDays := [Mon, Tue, Wed, Thu, Fri];

Several operations can be done on sets: taking unions or differences, adding or removing elements, comparisons. These are documented in section 12.8.6, page 639

How the compiler stores sets depends on the mode and can be controlled with a directive. For more information, see the programmer’s guide.

Page generated on 2025-07-18.

https://en.wikibooks.org/wiki/Pascal_Programming/Sets

Memory restrictions
Although a set of integer is legal and complies with all Pascal standards, many compilers do not support such large sets. Per definition, a set of integer can contain (at most) all values in the range -maxInt..maxInt. That is a lot (try writeLn(maxInt) or read your compiler’s documentation to find out this value). On a 64‑bit platform this value (usually) is 2⁶³−1, i. e. 9,223,372,036,854,775,808. As of the year 2020 many computers will quickly run out of main memory if they attempted to hold that many Boolean values.

As a consequence, BP restricts permissible set’s base types. In BP the base type’s largest and smallest values’ ordinal values have to be in the range 0..255. The value 255 is 2⁸−1. As of version 3.2.0, the FPC sets the same limitations.

The GPC allows set definitions beyond 28 elements, although some configuration is required: You need to specify the ‑‑setlimit command-line parameter or a specially crafted comment in your source code:

program largeSetDemo;
{$setLimit=2147483647} // this is 2³¹ − 1
type
   // 1073741823 is 2³⁰ − 1
   characteristicInteger = -1073741823..1073741823;
   integers = set of characteristicInteger;
var
   manyManyIntegers: integers;
begin
   manyManyIntegers := [];
   include(manyManyIntegers, 1073741823);
end.
This will instruct the GPC that a set of characteristicInteger can only store up to this many characteristicInteger values.

By default, the size of set is 4 or 32 bytes, depends of elements range. Sets with at most 32 elements are store in 4 bytes, otherwise 32. Short example:

Code: Pascal  [Select][+][-]

1. {$MODE OBJFPC}{$LONGSTRINGS ON}
2.  
3. type
4.   TFewElement       = 0 .. 2;
5.   TMoreElement      = 0 .. 31;
6.   TEvenMoreElement  = 0 .. 32;
7.   TManyElement      = 0 .. 255;
8.  
9. type
10.   TFewElements      = set of TFewElement;
11.   TMoreElements     = set of TMoreElement;
12.   TEvenMoreElements = set of TEvenMoreElement;
13.   TManyElements     = set of TManyElement;
14.  
15. begin
16.   WriteLn('TFewElements:      ', SizeOf(TFewElements));
17.   WriteLn('TMoreElements:     ', SizeOf(TMoreElements));
18.   WriteLn('TEvenMoreElements: ', SizeOf(TEvenMoreElements));
19.   WriteLn('TManyElements:     ', SizeOf(TManyElements));
20.  
21.   ReadLn();
22. end.

Output:

Code: Pascal  [Select][+][-]

1. TFewElements:      4
2. TMoreElements:     4
3. TEvenMoreElements: 32
4. TManyElements:     32

And then with {$PACKSET 1}:

Code: Pascal  [Select][+][-]

1. TFewElements:      1
2. TMoreElements:     4
3. TEvenMoreElements: 5
4. TManyElements:     32

and then with {$PACKSET 2}:

Code: Pascal  [Select][+][-]

1. TFewElements:      2
2. TMoreElements:     4
3. TEvenMoreElements: 6
4. TManyElements:     32

Thats how it works. Play with it.

is there a size limit on Pascal's sets, if so, then why?

The upper limit on set size is arbitrary, in the sense that you can implement sets of any size by designing the compiler accordingly.
Presumably the upper limit of 256 elements was chosen on grounds of practicality. It is a classic tradeoff between size and speed.
Given that the native integer size on commonly available 64-bit hardware is 8 bytes, a multiple of 8 bytes (or 64 elements) is clearly a sensible choice.
A maximum set size four times the native integer size still allows for pretty fast processing and covers all common use cases (allowing for up to 256 elements).
Where more than 256 set elements are needed, you just have to code the TLargeSet routines yourself, and not rely on the code already written and debugged by the compiler developers.
Perhaps the upper limit was chosen at a time when hardware was commonly 32-bit or even 16-bit. But similar considerations would have applied.
But as taazz points out, who regularly needs such large sets? Probably only people who are heavily into mathematical stuff, people who are well able to code what they need anyway.
If you're dealing with more than 256 elements you're probably interested in more than a simple boolean flag associated with each element, and you're verging on needing a proper database.

In trunk there are  -in generic.collections -generic sets that can contain an arbitrary number of elements and support set operations.

I believe I gave this before:

Code: Pascal  [Select][+][-]

1. {$mode objfpc}{$inline on}
2. { A simple way to implement large or huge sets.
3.  (c) 2019 Thaddy de Koning. No license and not
4.  re-licensable: free for all to use.
5.  Copyright holds:
6.  You can not claim license nor copyrigths }
7. unit largesets;
8. { Operator      Action
9.   ---------------------------------------------
10.   +             Union
11.   -             Difference
12.   *             Intersection
13.   ><        Symmetric difference
14.   <=        Contains
15.   include   Include an element in the set
16.   exclude   Exclude an element from the set
17.   in        Check if an element is in a set
18. }
19. interface
20. uses
21.   generics.collections;
22.  
23. type
24.   TWordSet  = specialize TSortedHashSet<word >;
25.   { The next two can cause some real memory pressure, be careful }
26.   TDWordSet = specialize TSortedHashSet<dword>;
27.   TQWordSet = specialize TSortedHashSet<Qword>;
28.  
29.   { union }
30.   operator + (const a,b:TWordset ):TWordSet;
31.   operator + (const a,b:TDWordset):TDWordSet;
32.   operator + (const a,b:TQWordset):TQWordSet;
33.  
34.   { difference }
35.   operator - (const a,b:Twordset ):TWordSet;
36.   operator - (const a,b:TDwordset):TDWordSet;
37.   operator - (const a,b:TQwordset):TQWordSet;
38.  
39.   { intersection }
40.   operator * (const a,b:TwordSet ):TWordSet;
41.   operator * (const a,b:TDwordSet):TDWordSet;
42.   operator * (const a,b:TQwordSet):TQWordSet;
43.  
44.   { symmetric difference }
45.   operator >< (const a,b:TWordSet ):TWordSet;
46.   operator >< (const a,b:TDWordSet):TDWordSet;
47.   operator >< (const a,b:TQWordSet):TQWordSet;
48.  
49.   { contains }
50.   operator <= (const a,b:TWordSet ):Boolean;
51.   operator <= (const a,b:TDWordSet):Boolean;
52.   operator <= (const a,b:TQWordSet):Boolean;
53.  
54.   { in }
55.   operator in (const a:word; const b:TWordset ):Boolean;
56.   operator in (const a:dword;const b:TDWordset):Boolean;
57.   operator in (const a:qword;const b:TQWordset):Boolean;
58.  
59.   { include }
60.   procedure include(const a:TWordSet; const b:Word);
61.   procedure include(const a:TDWordSet;const b:DWord);
62.   procedure include(const a:TQWordSet;const b:QWord);
63.  
64.   { exclude }
65.   procedure exclude(const a:TWordSet;const  b:Word);
66.   procedure exclude(const a:TDWordSet;const b:DWord);
67.   procedure exclude(const a:TQWordSet;const b:QWord);
68.  
69. implementation
70.  
71.   { union }
72.   operator + (const a,b:TWordset):TWordSet;
73.   begin  
74.     b.UnionWith(a);
75.     Result := b;
76.   end;  
77.  
78.   operator + (const a,b:TDWordset):TDWordSet;
79.   begin
80.     b.UnionWith(a);
81.     Result := b;
82.   end;
83.  
84.   operator + (const a,b:TQWordset):TQWordSet;
85.   begin
86.     b.UnionWith(a);
87.     Result := b;
88.   end;
89.  
90.   { difference }
91.   operator -(const a,b:Twordset):TWordSet;
92.   begin
93.     b.ExceptWith(a);
94.     result:=b;
95.   end;
96.  
97.   operator -(const a,b:TDwordset):TDWordSet;
98.   begin
99.     b.ExceptWith(a);
100.     result:=b;
101.   end;
102.  
103.   operator -(const a,b:TQwordset):TQWordSet;
104.   begin
105.     b.ExceptWith(a);
106.     result:=b;
107.   end;
108.  
109.   { intersection }
110.   operator *(const a,b:TwordSet):TWordSet;
111.   begin
112.     b.IntersectWith(a);
113.     Result := b;
114.   end;
115.  
116.   operator *(const a,b:TDwordSet):TDWordSet;
117.   begin
118.     b.IntersectWith(a);
119.     Result := b;
120.   end;
121.  
122.   operator *(const a,b:TQwordSet):TQWordSet;
123.   begin
124.     b.IntersectWith(a);
125.     Result := b;
126.   end;
127.  
128.   { symmetric difference }
129.   operator ><(const a,b:TWordSet):TWordSet;
130.   begin
131.     b.SymmetricExceptWith(a);
132.     Result := b;
133.   end;
134.  
135.   operator ><(const a,b:TDWordSet):TDWordSet;
136.   begin
137.     b.SymmetricExceptWith(a);
138.     Result := b;
139.   end;
140.  
141.   operator ><(const a,b:TQWordSet):TQWordSet;
142.   begin
143.     b.SymmetricExceptWith(a);
144.     Result := b;
145.   end;
146.  
147.   { contains }
148.   operator <=(const a,b:TWordSet):Boolean;
149.   var
150.     c:word;
151.   begin
152.     Result := true;
153.     for c in a do
154.     if not b.contains(c) then
155.     begin
156.       Result := False;
157.       break;
158.     end;
159.   end;
160.  
161.   operator <=(const a,b:TDWordSet):Boolean;
162.   var
163.     c:word;
164.   begin
165.     Result := true;
166.     for c in a do
167.     if not b.contains(c) then
168.     begin
169.       Result := False;
170.       break;
171.     end;
172.   end;
173.  
174.   operator <=(const a,b:TQWordSet):Boolean;
175.   var
176.     c:word;
177.   begin
178.     Result := true;
179.     for c in a do
180.     if not b.contains(c) then
181.     begin
182.       Result := False;
183.       break;
184.     end;
185.   end;
186.  
187.   { in }
188.   operator in (const a:word;const b:TWordset):Boolean;
189.   begin
190.     Result := b.Contains(a);
191.   end;  
192.  
193.   operator in (const a:dword;const b:TDWordset):Boolean;
194.   begin
195.     Result := b.Contains(a);
196.   end;
197.  
198.   operator in (const a:qword;const b:TQWordset):Boolean;
199.   begin
200.     Result := b.Contains(a);
201.   end;
202.  
203.   { include }
204.   procedure include(const a:TWordSet;const b:Word);
205.   begin
206.     a.Add(b);
207.   end;
208.  
209.   procedure include(const a:TDWordSet;const b:DWord);
210.   begin
211.     a.Add(b);
212.   end;
213.  
214.   procedure include(const a:TQWordSet;const b:QWord);
215.   begin
216.     a.Add(b);
217.   end;
218.  
219.   { exclude }
220.   procedure exclude(const a:TWordSet;const b:Word);
221.   begin
222.     a.Remove(b);
223.   end;
224.  
225.   procedure exclude(const a:TDWordSet;const b:DWord);
226.   begin
227.     a.Remove(b);
228.   end;
229.  
230.   procedure exclude(const a:TQWordSet;const b:QWord);
231.   begin
232.     a.Remove(b);
233.   end;
234.  
235. end.

Behaves near to identical to the built-in set type.

[Thausand]

@valdir.marcos:
yes is packset for make more bigger but is no work for publish property > 31 element.

Code: [Select]

Error: This kind of property cannot be published


[valdir.marcos]

Hello Benny.

Yes, I did some research before asking, and it seems the best solution is to split the set.

Okay (but, in my opinion, 31 elements in 2026 is a small number).

I also agree that 31 elements is a small number.

By default, the size of set is 4 or 32 bytes, depends of elements range. Sets with at most 32 elements are store in 4 bytes, otherwise 32. Short example:
...
Thats how it works. Play with it.

Even though a size of 4 bytes [32 elements, 0..31] fits most cases, 32 bytes [256 elements, 0..255] is still a necessity.

For instance:


https://dsiders.gitlab.io/lazdocsnext/lcl/grids/tgridoptions.html

Source position: grids.pas line 120

type TGridOptions = set of (
  goFixedVertLine,  Shows vertical lines around fixed cells.
  goFixedHorzLine,  Shows horizontal lines around fixed cells.
  goVertLine,  Show vertical lines.
  goHorzLine,  Show horizontal lines.
  goRangeSelect,  Enables range selection for grid cells.
  goDrawFocusSelected,  Enables drawing using the SelectedColor for selected cell(s) and FocusColor for the focus rectangle (or rubber band).
  goRowSizing,  Allow user to change row height.
  goColSizing,  Allow user to change column width.
  goRowMoving,  Enables moving the position of an entire row in a grid.
  goColMoving,  Enables moving the position of an entire column in a grid.
  goEditing,  Allows editing in grid cells.
  goAutoAddRows,  Automatically add new rows. Does not add rows if the last cell is empty and goAutoAddRowsSkipContentCheck is not set.
  goTabs,  Controls Tab key behavior in the grid. When enabled, the Tab key changes the active cell within the grid. When omitted, the Tab key changes to the next active control.
  goRowSelect,  Select the whole row instead of only one cell.
  goAlwaysShowEditor,  Always shows the cell editor. If not set, the user has to enter edit mode by data characters for the cell, or by pressing the F2 key.
  goThumbTracking,  Enables tracking of the thumb position in grid scroll bars.
  goColSpanning,  Enable cell extent calculations.
  goRelaxedRowSelect,  User can see focused cell on goRowSelect.
  goDblClickAutoSize,  Enables using double click on a column border (on headers) to resize a column.  goSmoothScroll,  Enables smooth scrolling mode. Default is pixel scroll.
  goFixedRowNumbering,  Causes row numbers to be displayed in the first column in FixedCols. The displayed row numbers starts with 1. The row number is displayed when no text has been directly assigned to the fixed cell.
  goScrollKeepVisible,  Keeps focused cell visible while scrolling.
  goHeaderHotTracking,  Header cells change look when mouse is over them.
  goHeaderPushedLook,  Header cells looks pushed when clicked.
  goSelectionActive,  Setting a grid selection also moves the cell cursor.
  goFixedColSizing,  Enables resizing of fixed columns.
  goDontScrollPartCell,  When enabled, selecting a partially visible cell will not scroll the grid content.
  goCellHints,  Show individual cell hints. Requires the ShowHint property to be set to True. If set, the Hint will be ignored. Instead the OnGetCellHint event will be called for each cell.
  goTruncCellHints,  Truncates cell hints when they are longer than the cell content.
  goCellEllipsis,  Shows an Ellipsis (...) at the end of truncated cell hints.
  goAutoAddRowsSkipContentCheck,  Adds a row if last row is empty. goAutoAddRows must also be set. Otherwise this option does not take effect.
  goRowHighlight  Highlights the current Row in a grid control.
);

https://dsiders.gitlab.io/lazdocsnext/lcl/grids/tgridoptions2.html

Source position: grids.pas line 131

type TGridOptions2 = set of (
  goScrollToLastCol,  Allows scrolling to last column (so that last column can be leftcol).
  goScrollToLastRow,  Allows scrolling to last row (so the last row can also be TopRow).
  goEditorParentColor,  Sets the color in a cell editor to the color for the parent control.
  goEditorParentFont,  Sets the font in a cell editor to the font for the parent control.
  goCopyWithoutTrailingLinebreak,  Copies cell(s) to the clipboard without trailing linebreak sequence.
  goFixedColClick,  Enables an OnClick event when a fixed column is clicked.
  goFixedRowClick  Enables an OnClick event when a fixed row is clicked.
);

[CM630]

I have wondered why tSTringGrid has Options and Options2 

[cdbc]

Hi
This:

Code: Pascal  [Select][+][-]

1. type chset = set of char;
2. const allch: chset = [#0..#255];
3. ...
4. if #88 in allch then writeln('#88 is in set');
5.  

compiles ~ I dunno what to think 
Regards Benny

[marcov]

(note that some of the set sizes are Turbo specifc, Delphi also allowed sets to be any size between 1 and 32 bytes except for 3 as far as I know).

I assume it has something to do with the size of a set not being in the RTTI, and thus always publishes as 32-bit set, so that the reader. Changing this breaks (classic) RTTI compatibility.

[Fred vS]

Thanks to everybody for the nice answers.

@cdbc: I am talking about published sets not public sets that can have 256 elements.

@CM630: Yes, I fear it is the best solution: splitting.

[cdbc]

Hi
Hmmm, would 'or'ing 'ptruint' values & 'and'ing them be a solution, perhaps?
Isn't that what Microsoft does?
Regards Benny

[Khrys]

Hmmm, would 'or'ing 'ptruint' values & 'and'ing them be a solution, perhaps?

I have a hunch that this is about GUI component properties that should show up in the object inspector (apart from niche uses of RTTI, why else would you require that a set be published?)
A bunch of named checkboxes are more user-friendly than some magic hexadecimal number 

[marcov]

I have a hunch that this is about GUI component properties that should show up in the object inspector (apart from niche uses of RTTI, why else would you require that a set be published?)
A bunch of named checkboxes are more user-friendly than some magic hexadecimal number 

The niche uses could use "modern" (D2010+, FPC 3.3.1) extended RTTI via the RTTI unit. The "old" RTTI is specifically for the designer.

(I don't know much about extended RTTI though, as I don't use it on FPC or Delphi. So I don't know if it supports all set sizes)

[PascalDragon]

I assume it has something to do with the size of a set not being in the RTTI, and thus always publishes as 32-bit set, so that the reader. Changing this breaks (classic) RTTI compatibility.

The set size is part of the RTTI (TTypeData.SetSizeOrType in Delphi and TTypeData.SetSize in FPC), but nevertheless Delphi forbids sets with more than 32 elements as published properties as well.

[BildatBoffin]

64 elements should be allowed nowadays. The real origin of the problem is that when you use RTTI to get the setter then the setter might be a bit funky if the backing type is wider than a register size as then you work on a record type. It's an ABI limitation.