home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 March / Chip_2004-03_cd1.bin / program / delphi / download / kompon / d234567 / DIIconv.exe / Source / DI.inc next >
Encoding:
Text File  |  2004-01-02  |  16.2 KB  |  486 lines

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