| blob | 65a8e5e97f535de900f0f7ce0cd4e4d5dac859a6 |
1 \r
2 { ---------------------------------------------------------------------------- }\r
3 { Version Information - Do not change. }\r
4 { ---------------------------------------------------------------------------- }\r
5 \r
6 { ---------------------------------------------------------------------------- }\r
7 { Windows }\r
8 { ---------------------------------------------------------------------------- }\r
9 \r
10 {$IFDEF Win32}\r
11 {$IFNDEF MSWINDOWS}\r
12 {$DEFINE MSWINDOWS}\r
13 {$ENDIF}\r
14 {$ENDIF}\r
15 \r
16 {$IFDEF MSWINDOWS}\r
17 \r
18 { ---------------------------------------------------------------------------- }\r
19 { VERXXX to COMPILER_X, DELPHI_X and CPPB_X mappings\r
20 { ---------------------------------------------------------------------------- }\r
21 \r
22 {$IFDEF VER150}\r
23 {$DEFINE COMPILER_7}\r
24 {$DEFINE DELPHI}\r
25 {$DEFINE DELPHI_7}\r
26 {$ENDIF}\r
27 \r
28 {$IFDEF VER140}\r
29 {$DEFINE COMPILER_6}\r
30 {$IFDEF BCB}\r
31 {$DEFINE CPPB}\r
32 {$DEFINE CPPB_6}\r
33 {$ELSE}\r
34 {$DEFINE DELPHI}\r
35 {$DEFINE DELPHI_6}\r
36 {$ENDIF}\r
37 {$ENDIF}\r
38 \r
39 {$IFDEF VER130}\r
40 {$DEFINE COMPILER_5}\r
41 {$IFDEF BCB}\r
42 {$DEFINE CPPB}\r
43 {$DEFINE CPPB_5}\r
44 {$ELSE}\r
45 {$DEFINE DELPHI}\r
46 {$DEFINE DELPHI_5}\r
47 {$ENDIF}\r
48 {$ENDIF}\r
49 \r
50 {$IFDEF VER125}\r
51 {$DEFINE COMPILER_4}\r
52 {$DEFINE CPPB}\r
53 {$DEFINE CPPB_4}\r
54 {$ENDIF}\r
55 \r
56 {$IFDEF VER120}\r
57 {$DEFINE COMPILER_4}\r
58 {$DEFINE DELPHI}\r
59 {$DEFINE DELPHI_4}\r
60 {$ENDIF}\r
61 \r
62 {$IFDEF VER110}\r
63 {$DEFINE COMPILER_3}\r
64 {$DEFINE CPPB}\r
65 {$DEFINE CPPB_3}\r
66 {$ENDIF}\r
67 \r
68 {$IFDEF VER100}\r
69 {$DEFINE COMPILER_3}\r
70 {$DEFINE DELPHI}\r
71 {$DEFINE DELPHI_3}\r
72 {$ENDIF}\r
73 \r
74 {$IFDEF VER93}\r
75 {$DEFINE COMPILER_2} // C++ Builder v1 compiler is really v2\r
76 {$DEFINE CPPB}\r
77 {$DEFINE CPPB_1}\r
78 {$ENDIF}\r
79 \r
80 {$IFDEF VER90}\r
81 {$DEFINE COMPILER_2}\r
82 {$DEFINE DELPHI}\r
83 {$DEFINE DELPHI_2}\r
84 {$ENDIF}\r
85 \r
86 {$IFDEF VER80}\r
87 {$DEFINE COMPILER_1}\r
88 {$DEFINE DELPHI}\r
89 {$DEFINE DELPHI_1}\r
90 {$ENDIF}\r
91 \r
92 { ---------------------------------------------------------------------------- }\r
93 { DELPHI_X_UP from DELPHI_X mappings\r
94 { ---------------------------------------------------------------------------- }\r
95 \r
96 {$IFDEF DELPHI_1}\r
97 {$DEFINE DELPHI_1_UP}\r
98 {$ENDIF}\r
99 \r
100 {$IFDEF DELPHI_2}\r
101 {$DEFINE DELPHI_1_UP}\r
102 {$DEFINE DELPHI_2_UP}\r
103 {$ENDIF}\r
104 \r
105 {$IFDEF DELPHI_3}\r
106 {$DEFINE DELPHI_1_UP}\r
107 {$DEFINE DELPHI_2_UP}\r
108 {$DEFINE DELPHI_3_UP}\r
109 {$ENDIF}\r
110 \r
111 {$IFDEF DELPHI_4}\r
112 {$DEFINE DELPHI_1_UP}\r
113 {$DEFINE DELPHI_2_UP}\r
114 {$DEFINE DELPHI_3_UP}\r
115 {$DEFINE DELPHI_4_UP}\r
116 {$ENDIF}\r
117 \r
118 {$IFDEF DELPHI_5}\r
119 {$DEFINE DELPHI_1_UP}\r
120 {$DEFINE DELPHI_2_UP}\r
121 {$DEFINE DELPHI_3_UP}\r
122 {$DEFINE DELPHI_4_UP}\r
123 {$DEFINE DELPHI_5_UP}\r
124 {$ENDIF}\r
125 \r
126 {$IFDEF DELPHI_6}\r
127 {$DEFINE DELPHI_1_UP}\r
128 {$DEFINE DELPHI_2_UP}\r
129 {$DEFINE DELPHI_3_UP}\r
130 {$DEFINE DELPHI_4_UP}\r
131 {$DEFINE DELPHI_5_UP}\r
132 {$DEFINE DELPHI_6_UP}\r
133 {$ENDIF}\r
134 \r
135 {$IFDEF DELPHI_7}\r
136 {$DEFINE DELPHI_1_UP}\r
137 {$DEFINE DELPHI_2_UP}\r
138 {$DEFINE DELPHI_3_UP}\r
139 {$DEFINE DELPHI_4_UP}\r
140 {$DEFINE DELPHI_5_UP}\r
141 {$DEFINE DELPHI_6_UP}\r
142 {$DEFINE DELPHI_7_UP}\r
143 {$ENDIF}\r
144 \r
145 { ---------------------------------------------------------------------------- }\r
146 { CPPB_X_UP from CPPB_X mappings\r
147 { ---------------------------------------------------------------------------- }\r
148 \r
149 {$IFDEF CPPB_1}\r
150 {$DEFINE CPPB_1_UP}\r
151 {$ENDIF}\r
152 \r
153 {$IFDEF CPPB_3}\r
154 {$DEFINE CPPB_1_UP}\r
155 {$DEFINE CPPB_3_UP}\r
156 {$ENDIF}\r
157 \r
158 {$IFDEF CPPB_4}\r
159 {$DEFINE CPPB_1_UP}\r
160 {$DEFINE CPPB_3_UP}\r
161 {$DEFINE CPPB_4_UP}\r
162 {$ENDIF}\r
163 \r
164 {$IFDEF CPPB_5}\r
165 {$DEFINE CPPB_1_UP}\r
166 {$DEFINE CPPB_3_UP}\r
167 {$DEFINE CPPB_4_UP}\r
168 {$DEFINE CPPB_5_UP}\r
169 {$ENDIF}\r
170 \r
171 {$IFDEF CPPB_3_UP}\r
172 // C++ Builder requires this if you use Delphi components in run-time packages.\r
173 {$OBJEXPORTALL ON}\r
174 {$ENDIF}\r
175 \r
176 {$ENDIF}\r
177 \r
178 { ---------------------------------------------------------------------------- }\r
179 { Linux }\r
180 { ---------------------------------------------------------------------------- }\r
181 \r
182 {$IFDEF LINUX}\r
183 \r
184 {$IFDEF VER150}\r
185 {$DEFINE COMPILER_7}\r
186 {$DEFINE KYLIX}\r
187 {$DEFINE KYLIX_3}\r
188 {$ENDIF}\r
189 \r
190 {$IFDEF VER140}\r
191 {$DEFINE COMPILER_6}\r
192 {$DEFINE KYLIX}\r
193 {$DEFINE KYLIX_2}\r
194 {$ENDIF}\r
195 \r
196 {$IFDEF KYLIX_2}\r
197 {$DEFINE KYLIX_1_UP}\r
198 {$DEFINE KYLIX_2_UP}\r
199 {$ENDIF}\r
200 \r
201 {$IFDEF KYLIX_3}\r
202 {$DEFINE KYLIX_1_UP}\r
203 {$DEFINE KYLIX_2_UP}\r
204 {$DEFINE KYLIX_3_UP}\r
205 {$ENDIF}\r
206 \r
207 {$ENDIF}\r
208 \r
209 { ---------------------------------------------------------------------------- }\r
210 { COMPIlER_X_UP from COMPILER_X mappings\r
211 { ---------------------------------------------------------------------------- }\r
212 \r
213 {$IFDEF COMPILER_1}\r
214 {$DEFINE COMPILER_1_UP}\r
215 {$ENDIF}\r
216 \r
217 {$IFDEF COMPILER_2}\r
218 {$DEFINE COMPILER_1_UP}\r
219 {$DEFINE COMPILER_2_UP}\r
220 {$ENDIF}\r
221 \r
222 {$IFDEF COMPILER_3}\r
223 {$DEFINE COMPILER_1_UP}\r
224 {$DEFINE COMPILER_2_UP}\r
225 {$DEFINE COMPILER_3_UP}\r
226 {$ENDIF}\r
227 \r
228 {$IFDEF COMPILER_4}\r
229 {$DEFINE COMPILER_1_UP}\r
230 {$DEFINE COMPILER_2_UP}\r
231 {$DEFINE COMPILER_3_UP}\r
232 {$DEFINE COMPILER_4_UP}\r
233 {$ENDIF}\r
234 \r
235 {$IFDEF COMPILER_5}\r
236 {$DEFINE COMPILER_1_UP}\r
237 {$DEFINE COMPILER_2_UP}\r
238 {$DEFINE COMPILER_3_UP}\r
239 {$DEFINE COMPILER_4_UP}\r
240 {$DEFINE COMPILER_5_UP}\r
241 {$ENDIF}\r
242 \r
243 {$IFDEF COMPILER_6}\r
244 {$DEFINE COMPILER_1_UP}\r
245 {$DEFINE COMPILER_2_UP}\r
246 {$DEFINE COMPILER_3_UP}\r
247 {$DEFINE COMPILER_4_UP}\r
248 {$DEFINE COMPILER_5_UP}\r
249 {$DEFINE COMPILER_6_UP}\r
250 {$ENDIF}\r
251 \r
252 {$IFDEF COMPILER_7}\r
253 {$DEFINE COMPILER_1_UP}\r
254 {$DEFINE COMPILER_2_UP}\r
255 {$DEFINE COMPILER_3_UP}\r
256 {$DEFINE COMPILER_4_UP}\r
257 {$DEFINE COMPILER_5_UP}\r
258 {$DEFINE COMPILER_6_UP}\r
259 {$DEFINE COMPILER_7_UP}\r
260 {$ENDIF}\r
261 \r
262 { ---------------------------------------------------------------------------- }\r
263 { General }\r
264 { ---------------------------------------------------------------------------- }\r
265 \r
266 {.$DEFINE DI_Check_Free}// Default: Off\r
267 { If DI_Check_Free is defined, objects keep track if they were freed before the\r
268 application exits. Disabeling DI_Check_Free will generate smaller and faster\r
269 code. You need the DIContainers Library if you want to enable this option. }\r
270 \r
271 {.$DEFINE DI_Use_Wide_Char_Set_Consts}// Default: Off\r
272 { If defined, code will use constants of WideChar sets. WideChar set constants\r
273 will, however, cause a compiler error when compiled with TD32 debug info.\r
274 This error was detected in D4, D5, D6 and D7. }\r
275 \r
276 {.$DEFINE DI_No_Range_Checking}// Default: Off\r
277 { Defining DI_No_Range_Checking will suppress generation of code which checks\r
278 for ranges errors. No error messages will be thrown in case of violations.\r
279 Enabeling DI_No_Range_Checking generates faster and smaller code. }\r
280 \r
281 {.$DEFINE DI_No_Classes}// Default: Off\r
282 { If defined, The Delphi Inspiration libraries try to avoid using and linking\r
283 Delphi's Classes.pas. Not using Classes.pas usually results in a 15-17 KB\r
284 smaller exe file size for console applications. For Delphi GUI applications,\r
285 turning on DI_No_Classes may actually create larger file sizes. }\r
286 \r
287 {$DEFINE FLOAT_EXTENDED_PRECISION} // Default\r
288 {.$DEFINE FLOAT_DOUBLE_PRECISION}\r
289 {.$DEFINE FLOAT_SINGLE_PRECISION}\r
290 { Math precision selection, mutually exclusive. }\r
291 \r
292 {.$DEFINE DI_No_Win_9x_Support}// Default: Off\r
293 { Define DI_No_Win_9x_Support if you want to compile your application without\r
294 support for the Win9x platforms Windows 95 and Windows 98. They will then\r
295 run only on Windows NT / Windows 2000 / Windows XP. }\r
296 \r
297 {.$DEFINE DI_Show_Hints}// Default: Off\r
298 { Generation of hints has been disabled for code which is known to be safe.\r
299 To enable these hints, turn on DI_Show_Hints. }\r
300 \r
301 {.$DEFINE DI_Show_Warnings}// Default: Off\r
302 { Generation of warnings has been disabled for code which is known to be safe.\r
303 To enable these warnings, turn on DI_Show_Warnings. }\r
304 \r
305 { ---------------------------------------------------------------------------- }\r
306 { DIContainers }\r
307 { ---------------------------------------------------------------------------- }\r
308 \r
309 {.$DEFINE DI_No_Containers_Assign}// Default: Off\r
310 { If defined, the general assignment capabilities will not be compiled into\r
311 DIContainers. Enabeling DI_No_Containers_Assign will generate smaller exe\r
312 files.\r
313 \r
314 This option is only available for the DIContainers source code. }\r
315 \r
316 {.$DEFINE DI_No_Containers_Persistent}// Default: Off\r
317 { If DI_No_Containers_Persistent is defined, all DIContainers will inherit\r
318 directly from TObject instead of TPersistent and they will not have\r
319 full streaming support in the IDE. Enabeling DI_No_Containers_Persistent will\r
320 generate smaller exe files.\r
321 \r
322 This option is only available for the DIContainers source code. }\r
323 \r
324 {.$DEFINE DIC_Design} // Default: Off\r
325 { This option is only relevant for modifications to the the DIContainers source code. }\r
326 \r
327 { ---------------------------------------------------------------------------- }\r
328 { DIFileFinder }\r
329 { ---------------------------------------------------------------------------- }\r
330 \r
331 {.$DEFINE DI_No_FileFinder_Component}// Default: Off\r
332 { If DI_No_FileFinder_Component is defined, TDIFileFinder inherites from TObject\r
333 instead of TComponent. Enabling DI_No_FileFinder_Component creates smaller\r
334 executable files, even more so if Classes.pas is not used. This can be\r
335 useful for console or CGI applications.\r
336 \r
337 This option is only available for the TDIFileFinder source code. }\r
338 \r
339 { ---------------------------------------------------------------------------- }\r
340 { DIPcre }\r
341 { ---------------------------------------------------------------------------- }\r
342 \r
343 {.$DEFINE DI_No_Pcre_Component}// Default: Off\r
344 { If DI_No_Pcre_Component is defined, TDIPcre inherites from TObject\r
345 instead of TComponent. Enabling DI_No_Pcre_Component creates smaller\r
346 executable files, even more so if Classes.pas is not used. This can be\r
347 useful for console applications or CGI / ISAPI DLLs.\r
348 \r
349 This option is only available for the DIPcre source code. }\r
350 \r
351 {.$DEFINE DI_No_Pcre_Range_Checking}// Default: Off\r
352 { Defining DI_No_Pcre_Range_Checking will suppress generation of code which\r
353 checks for ranges errors. No error messages will be thrown in case of\r
354 violations. Enabeling DI_No_Pcre_Range_Checking generates faster and smaller\r
355 code.\r
356 \r
357 This option is only available for the DIPcre source code. }\r
358 \r
359 { ---------------------------------------------------------------------------- }\r
360 { DIUnicode }\r
361 { ---------------------------------------------------------------------------- }\r
362 \r
363 {.$DEFINE DI_No_Unicode_Component}// Default: Off\r
364 { If DI_No_Unicode_Component is defined, the DIUnicode classes inherit from\r
365 TObject instead of TComponent. Enabling DI_No_Unicode_Component creates\r
366 smaller executable files, even more so if Classes.pas is not used. This can be\r
367 useful for console applications or CGI / ISAPI DLLs.\r
368 \r
369 This option is only available for the DIUnicode source code. }\r
370 \r
371 { ---------------------------------------------------------------------------- }\r
372 { DIZipWriter }\r
373 { ---------------------------------------------------------------------------- }\r
374 \r
375 {.$DEFINE DI_No_ZipWriter_Component}// Default: Off\r
376 { If DI_No_ZipWriter_Component is defined, TDIZipWriter inherites from TObject\r
377 instead of TComponent. Enabling DI_No_ZipWriter_Component creates smaller\r
378 executable files, even more so if Classes.pas is not used. This can be\r
379 useful for console applications or CGI / ISAPI DLLs.\r
380 \r
381 This option is only available for the DIZipWriter source code. }\r
382 \r
383 { ---------------------------------------------------------------------------- }\r
384 { Do not modify below here. }\r
385 { ---------------------------------------------------------------------------- }\r
386 \r
387 { Check if one of the components requires Classes.pas\r
388 and undefine DI_No_Classes accordingly. }\r
389 \r
390 {$IFNDEF DI_No_Containers_Persistent}\r
391 {$UNDEF DI_No_Classes} // TPersistent is defined in Classes.pas.\r
392 {$ENDIF}\r
393 \r
394 {$IFNDEF DI_No_FileFinder_component}\r
395 {$UNDEF DI_No_Classes} // TComponent is defined in Classes.pas.\r
396 {$ENDIF}\r
397 \r
398 {$IFNDEF DI_No_Pcre_component}\r
399 {$UNDEF DI_No_Classes} // TComponent is defined in Classes.pas.\r
400 {$ENDIF}\r
401 \r
402 {$IFNDEF DI_No_Unicode_component}\r
403 {$UNDEF DI_No_Classes} // TComponent is defined in Classes.pas.\r
404 {$ENDIF}\r
405 \r
406 {$IFNDEF DI_No_ZipWriter_component}\r
407 {$UNDEF DI_No_Classes} // TComponent is defined in Classes.pas.\r
408 {$ENDIF}\r
409 \r
410 { ---------------------------------------------------------------------------- }\r
411 { Compiler }\r
412 { ---------------------------------------------------------------------------- }\r
413 \r
414 {$A+}\r
415 (* The $A directive controls alignment of fields in record types.\r
416 \r
417 In the {$A+} state, fields in record types that are declared without the\r
418 packed modifier are aligned. In the {$A-} state, fields in record types\r
419 are never aligned. Record type field alignment is described in the Object\r
420 Pascal Language Guide.\r
421 \r
422 Regardless of the state of the $A directive, variables and typed constants\r
423 are always aligned for optimal access. In the {$A+} state, execution\r
424 will be faster. *)\r
425 \r
426 {$B-}\r
427 (* The $B directive switches between the two different models of code\r
428 generation for the and and or Boolean operators.\r
429 \r
430 In the {$B+} state, the compiler generates code for complete Boolean\r
431 expression evaluation. This means that every operand of a Boolean\r
432 expression built from the and and or operators is guaranteed to be\r
433 evaluated, even when the result of the entire expression is already known.\r
434 \r
435 In the {$B-} state, the compiler generates code for short-circuit Boolean\r
436 expression evaluation, which means that evaluation stops as soon as the\r
437 result of the entire expression becomes evident in left to right order\r
438 of evaluation. *)\r
439 \r
440 {$H+}\r
441 (* The $H directive controls the meaning of the reserved word string when\r
442 used alone in a type declaration. The generic type string can represent\r
443 either a long, dynamically-allocated string (the fundamental type AnsiString)\r
444 or a short, statically-allocated string (the fundamental type ShortString).\r
445 \r
446 By default {$H+}, Delphi defines the generic string type to be the long\r
447 AnsiString. All components in the Visual Component Library are compiled\r
448 in this state. If you write components, they should also use long strings,\r
449 as should any code that receives data from VCL string-type properties.\r
450 \r
451 The {$H-} state is mostly useful for using code from versions of Object\r
452 Pascal that used short strings by default. You can locally override the\r
453 meaning of string-type definitions to ensure generation of short strings.\r
454 You can also change declarations of short string types to string[255] or\r
455 ShortString, which are unambiguous and independent of the $H setting. *)\r
456 \r
457 {$J-}\r
458 (* The $J directive controls whether typed constants can be modified or not.\r
459 In the {$J+} state, typed constants can be modified, and are in essence\r
460 initialized variables. In the {$J-} state, typed constants are truly\r
461 constant, and any attempt to modify a typed constant causes the compiler\r
462 to report an error. *)\r
463 \r
464 {$T+}\r
465 (* The $T directive controls the types of pointer values generated by the\r
466 @ operator and the compatibility of pointer types.\r
467 \r
468 In the {$T-} state, the result of the @ operator is always an untyped\r
469 pointer (Pointer) that is compatible with all other pointer types.\r
470 When @ is applied to a variable reference in the {$T+} state, the result\r
471 is a typed pointer that is compatible only with Pointer and with other\r
472 pointers to the type of the variable. *)\r
473 \r
474 {$IFDEF COMPILER_7_UP}\r
475 {$WARN UNSAFE_CAST OFF}\r
476 {$WARN UNSAFE_CODE OFF}\r
477 {$WARN UNSAFE_TYPE OFF}\r
478 {$ENDIF}\r
479 (* Disables .NET warnings for Delphi 7 and later. *)\r
480 \r
481 {$X+}\r
482 (* The $X directive enables or disables Delphi's extended syntax. *)\r
483 \r
484 { }\r
485 \r