Merged revisions 13627-13631,13637-13638,13640,13642-13648,13650-13653,13656-13658,13660,13664-13667,13672-13675,13680,13682,13687 via svnmerge from

svn+ssh://[email protected]/FPC/svn/fpc/trunk

git-svn-id: branches/objc@13697 -

.gitattributes

@@ -2114,6 +2114,22 @@ packages/ggi/fpmake.pp svneol=native#text/plain
 packages/ggi/src/ggi.pp svneol=native#text/plain
 packages/ggi/src/ggi2d.pp svneol=native#text/plain
 packages/ggi/src/gii.pp svneol=native#text/plain
+packages/gmp/Makefile svneol=native#text/plain
+packages/gmp/Makefile.fpc svneol=native#text/plain
+packages/gmp/examples/Makefile svneol=native#text/plain
+packages/gmp/examples/Makefile.fpc svneol=native#text/plain
+packages/gmp/examples/gmp_accept_test.pas svneol=native#text/plain
+packages/gmp/examples/gmp_test_impl.inc svneol=native#text/plain
+packages/gmp/examples/gmp_test_intf.inc svneol=native#text/plain
+packages/gmp/examples/gmp_testcase.pas svneol=native#text/plain
+packages/gmp/examples/pidigits_example.pas svneol=native#text/plain
+packages/gmp/examples/pidigits_example2.pas svneol=native#text/plain
+packages/gmp/examples/printf_example.pas svneol=native#text/plain
+packages/gmp/examples/printf_example2.pas svneol=native#text/plain
+packages/gmp/examples/scanf_example.pas svneol=native#text/plain
+packages/gmp/examples/scanf_example2.pas svneol=native#text/plain
+packages/gmp/readme svneol=native#text/plain
+packages/gmp/src/gmp.pas svneol=native#text/plain
 packages/gnome1/Makefile svneol=native#text/plain
 packages/gnome1/Makefile.fpc svneol=native#text/plain
 packages/gnome1/examples/gconfcallback1.pp svneol=native#text/plain
@@ -5356,6 +5372,8 @@ packages/winunits-base/src/wininet.pp svneol=native#text/plain
 packages/winunits-base/src/winver.pp svneol=native#text/plain
 packages/winunits-base/tests/OOHelper.pp svneol=native#text/plain
 packages/winunits-base/tests/OOTest.pp svneol=native#text/plain
+packages/winunits-base/tests/hhex.pp svneol=native#text/pascal
+packages/winunits-base/tests/hhex2.pp svneol=native#text/pascal
 packages/winunits-base/tests/testcom1.pp svneol=native#text/plain
 packages/winunits-base/tests/testcom2.pp svneol=native#text/plain
 packages/winunits-base/tests/testver.pp svneol=native#text/plain
@@ -8379,7 +8397,57 @@ tests/test/tasout.pp svneol=native#text/plain
 tests/test/tbopr.pp svneol=native#text/plain
 tests/test/tbrtlevt.pp svneol=native#text/plain
 tests/test/tcase1.pp svneol=native#text/plain
+tests/test/tcase10.pp svneol=native#text/pascal
+tests/test/tcase11.pp svneol=native#text/pascal
+tests/test/tcase12.pp svneol=native#text/pascal
+tests/test/tcase13.pp svneol=native#text/pascal
+tests/test/tcase14.pp svneol=native#text/pascal
+tests/test/tcase15.pp svneol=native#text/pascal
+tests/test/tcase16.pp svneol=native#text/pascal
+tests/test/tcase17.pp svneol=native#text/pascal
+tests/test/tcase18.pp svneol=native#text/pascal
+tests/test/tcase19.pp svneol=native#text/pascal
 tests/test/tcase2.pp svneol=native#text/plain
+tests/test/tcase20.pp svneol=native#text/pascal
+tests/test/tcase21.pp svneol=native#text/pascal
+tests/test/tcase22.pp svneol=native#text/pascal
+tests/test/tcase23.pp svneol=native#text/pascal
+tests/test/tcase24.pp svneol=native#text/pascal
+tests/test/tcase25.pp svneol=native#text/pascal
+tests/test/tcase26.pp svneol=native#text/pascal
+tests/test/tcase27.pp svneol=native#text/pascal
+tests/test/tcase28.pp svneol=native#text/pascal
+tests/test/tcase29.pp svneol=native#text/pascal
+tests/test/tcase3.pp svneol=native#text/pascal
+tests/test/tcase30.pp svneol=native#text/pascal
+tests/test/tcase31.pp svneol=native#text/pascal
+tests/test/tcase32.pp svneol=native#text/pascal
+tests/test/tcase33.pp svneol=native#text/pascal
+tests/test/tcase34.pp svneol=native#text/pascal
+tests/test/tcase35.pp svneol=native#text/pascal
+tests/test/tcase36.pp svneol=native#text/pascal
+tests/test/tcase37.pp svneol=native#text/pascal
+tests/test/tcase38.pp svneol=native#text/pascal
+tests/test/tcase39.pp svneol=native#text/pascal
+tests/test/tcase4.pp svneol=native#text/pascal
+tests/test/tcase40.pp svneol=native#text/pascal
+tests/test/tcase41.pp svneol=native#text/pascal
+tests/test/tcase42.pp svneol=native#text/pascal
+tests/test/tcase43.pp svneol=native#text/pascal
+tests/test/tcase44.pp svneol=native#text/pascal
+tests/test/tcase45.pp svneol=native#text/pascal
+tests/test/tcase45_2.pp svneol=native#text/pascal
+tests/test/tcase46.pp svneol=native#text/pascal
+tests/test/tcase46_2.pp svneol=native#text/pascal
+tests/test/tcase47.pp svneol=native#text/pascal
+tests/test/tcase47_2.pp svneol=native#text/pascal
+tests/test/tcase48.pp svneol=native#text/pascal
+tests/test/tcase48_2.pp svneol=native#text/pascal
+tests/test/tcase5.pp svneol=native#text/pascal
+tests/test/tcase6.pp svneol=native#text/pascal
+tests/test/tcase7.pp svneol=native#text/pascal
+tests/test/tcase8.pp svneol=native#text/pascal
+tests/test/tcase9.pp svneol=native#text/pascal
 tests/test/tcg1.pp svneol=native#text/plain
 tests/test/tcint64.pp svneol=native#text/plain
 tests/test/tclass1.pp svneol=native#text/plain
@@ -9563,6 +9631,8 @@ tests/webtbs/tw14418.pp svneol=native#text/plain
 tests/webtbs/tw1445.pp svneol=native#text/plain
 tests/webtbs/tw1450.pp svneol=native#text/plain
 tests/webtbs/tw1451.pp svneol=native#text/plain
+tests/webtbs/tw14514.pp svneol=native#text/plain
+tests/webtbs/tw14536.pp svneol=native#text/plain
 tests/webtbs/tw1470.pp svneol=native#text/plain
 tests/webtbs/tw1472.pp svneol=native#text/plain
 tests/webtbs/tw1477.pp svneol=native#text/plain

compiler/constexp.pas

@@ -45,6 +45,8 @@ type  Tconstexprint=record
             (svalue:int64);
       end;
 
+      Tconststring = type pchar;
+
       errorproc=procedure (i:longint);
 
 {"Uses verbose" gives a dependency on cpuinfo through globals. This leads

compiler/cresstr.pas

@@ -156,6 +156,7 @@ uses
         namelab,
         valuelab : tasmlabel;
         resstrlab : tasmsymbol;
+        endsymlab : tasmsymbol;
         R : TResourceStringItem;
       begin
         { Put resourcestrings in a new objectfile. Putting it in multiple files
@@ -213,16 +214,19 @@ uses
             R:=TResourceStringItem(R.Next);
           end;
         new_section(current_asmdata.asmlists[al_resourcestrings],sec_data,make_mangledname('RESSTR',current_module.localsymtable,'3_END'),sizeof(pint));
-        current_asmdata.AsmLists[al_resourcestrings].concat(tai_symbol.createname_global(
-          make_mangledname('RESSTR',current_module.localsymtable,'END'),AT_DATA,0));
+        endsymlab:=current_asmdata.DefineAsmSymbol(make_mangledname('RESSTR',current_module.localsymtable,'END'),AB_GLOBAL,AT_DATA);
+        current_asmdata.AsmLists[al_resourcestrings].concat(tai_symbol.create_global(endsymlab,0));
         { The darwin/ppc64 assembler or linker seems to have trouble       }
         { if a section ends with a global label without any data after it. }
         { So for safety, just put a dummy value here.                      }
         { Further, the regular linker also kills this symbol when turning  }
         { on smart linking in case no value appears after it, so put the   }
         { dummy byte there always                                          }
+        { Update: the Mac OS X 10.6 linker orders data that needs to be    }
+        { relocated before all other data, so make this data relocatable,  }
+        { otherwise the end label won't be moved with the rest             }
         if (target_info.system in systems_darwin) then   
-          current_asmdata.asmlists[al_resourcestrings].concat(Tai_const.create_8bit(0));
+          current_asmdata.asmlists[al_resourcestrings].concat(Tai_const.create_sym(endsymlab));
       end;
 
 

compiler/dbgdwarf.pas

@@ -1358,18 +1358,16 @@ implementation
             { no known size, no known upper bound }
             if assigned(def.typesym) then
               append_entry(DW_TAG_array_type,true,[
-                DW_AT_name,DW_FORM_string,symname(def.typesym)+#0,
-                elestrideattr,DW_FORM_udata,elesize
+                DW_AT_name,DW_FORM_string,symname(def.typesym)+#0
                 ])
             else
-              append_entry(DW_TAG_array_type,true,[
-                elestrideattr,DW_FORM_udata,elesize
-                ]);
+              append_entry(DW_TAG_array_type,true,[]);
             append_labelentry_ref(DW_AT_type,def_dwarf_lab(def.elementdef));
             finish_entry;
             { a missing upper bound means "unknown"/default }
             append_entry(DW_TAG_subrange_type,false,[
-              DW_AT_lower_bound,DW_FORM_sdata,def.lowrange
+              DW_AT_lower_bound,DW_FORM_sdata,def.lowrange,
+              elestrideattr,DW_FORM_udata,elesize
               ]);
           end
         else
@@ -1378,20 +1376,19 @@ implementation
             if assigned(def.typesym) then
               append_entry(DW_TAG_array_type,true,[
                 DW_AT_name,DW_FORM_string,symname(def.typesym)+#0,
-                DW_AT_byte_size,DW_FORM_udata,size,
-                elestrideattr,DW_FORM_udata,elesize
+                DW_AT_byte_size,DW_FORM_udata,size
                 ])
             else
               append_entry(DW_TAG_array_type,true,[
-                DW_AT_byte_size,DW_FORM_udata,size,
-                elestrideattr,DW_FORM_udata,elesize
+                DW_AT_byte_size,DW_FORM_udata,size
                 ]);
             append_labelentry_ref(DW_AT_type,def_dwarf_lab(def.elementdef));
             finish_entry;
             { to simplify things, we don't write a multidimensional array here }
             append_entry(DW_TAG_subrange_type,false,[
               DW_AT_lower_bound,DW_FORM_sdata,def.lowrange,
-              DW_AT_upper_bound,DW_FORM_sdata,def.highrange
+              DW_AT_upper_bound,DW_FORM_sdata,def.highrange,
+              elestrideattr,DW_FORM_udata,elesize
               ]);
           end;
         append_labelentry_ref(DW_AT_type,def_dwarf_lab(def.rangedef));

compiler/defutil.pas

@@ -27,7 +27,7 @@ interface
 
     uses
        cclasses,
-       globtype,globals,constexp,
+       globtype,globals,constexp,node,
        symconst,symbase,symtype,symdef,
        cgbase,cpubase;
 
@@ -43,6 +43,9 @@ interface
     {# Returns true, if definition defines an ordinal type }
     function is_ordinal(def : tdef) : boolean;
 
+    {# Returns true, if definition defines a string type }
+    function is_string(def : tdef): boolean;
+
     {# Returns the minimal integer value of the type }
     function get_min_value(def : tdef) : TConstExprInt;
 
@@ -374,6 +377,12 @@ implementation
          end;
       end;
 
+    { true if p is a string }
+    function is_string(def : tdef) : boolean;
+      begin
+        is_string := (assigned(def) and (def.typ = stringdef));
+      end;
+
 
     { returns the min. value of the type }
     function get_min_value(def : tdef) : TConstExprInt;

compiler/msg/errore.msg

@@ -1237,7 +1237,7 @@ parser_e_no_objc_unique=03263_E_It is not yet possible to make unique copies of
 #
 # Type Checking
 #
-# 04089 is the last used one
+# 04091 is the last used one
 #
 % \section{Type checking errors}
 % This section lists all errors that can occur when type checking is
@@ -1535,9 +1535,13 @@ type_e_no_type_info=04087_E_No type info available for this type
 % Type information is not generated for some types, such as enumerations with gaps
 % in their value range (this includes enumerations whose lower bound is different
 % from zero).
-type_e_protocol_type_expected=04088_E_Objective-C protocol type expected, but got "$1"
+type_e_ordinal_or_string_expr_expected=04088_E_Ordinal or string expression expected
+% The expression must be an ordinal or string type.
+type_e_string_expr_expected=04089_E_String expression expected
+% The expression must be a string type.
+type_e_protocol_type_expected=04090_E_Objective-C protocol type expected, but got "$1"
 % The compiler expected a protocol type name, but found something else.
-type_e_objc_type_unsupported=04089_E_The type "$1" is not supported for interaction with the Objective-C runtime.
+type_e_objc_type_unsupported=04091_E_The type "$1" is not supported for interaction with the Objective-C runtime.
 % Objective-C makes extensive use of run time type information (RTTI). This format
 % is defined by the maintainers of the run time and can therefore not be adapted
 % to all possible Object Pascal types. In particular, types that depend on
@@ -2612,7 +2616,9 @@ option_unsupported_target_for_feature=11045_F_The feature "$1" is not, or not ye
 option_dwarf_smart_linking=11046_N_DWARF debug information cannot be used with smart linking on this target, switching to static linking
 % Smart linking is currently incompatble with DWARF debug information on most
 % platforms, so smart linking is disabled in such cases.
-
+option_ignored_target=11047_W_Option "$1" is ignored for the current target platform.
+% Not all options are supported or implemented for all target platforms. This message informs you that a chosen
+% option is ignored for the currently selected target platform.
 %\end{description}
 # EndOfTeX
 

compiler/msgidx.inc

@@ -429,8 +429,10 @@ const
   type_e_expected_objc_method_but_got=04085;
   type_e_expected_objc_method=04086;
   type_e_no_type_info=04087;
-  type_e_protocol_type_expected=04088;
-  type_e_objc_type_unsupported=04089;
+  type_e_ordinal_or_string_expr_expected=04088;
+  type_e_string_expr_expected=04089;
+  type_e_protocol_type_expected=04090;
+  type_e_objc_type_unsupported=04091;
   sym_e_id_not_found=05000;
   sym_f_internal_error_in_symtablestack=05001;
   sym_e_duplicate_id=05002;
@@ -780,6 +782,7 @@ const
   option_unsupported_target=11044;
   option_unsupported_target_for_feature=11045;
   option_dwarf_smart_linking=11046;
+  option_ignored_target=11047;
   wpo_cant_find_file=12000;
   wpo_begin_processing=12001;
   wpo_end_processing=12002;
@@ -804,9 +807,9 @@ const
   option_info=11024;
   option_help_pages=11025;
 
-  MsgTxtSize = 52913;
+  MsgTxtSize = 53058;
 
   MsgIdxMax : array[1..20] of longint=(
-    24,87,264,90,66,51,108,22,202,62,
-    47,20,1,1,1,1,1,1,1,1
+    24,87,264,92,66,51,108,22,202,62,
+    48,20,1,1,1,1,1,1,1,1
   );

compiler/msgtxt.inc

@@ -1,7 +1,7 @@
 {$ifdef Delphi}
-const msgtxt : array[0..000220] of string[240]=(
+const msgtxt : array[0..000221] of string[240]=(
 {$else Delphi}
-const msgtxt : array[0..000220,1..240] of char=(
+const msgtxt : array[0..000221,1..240] of char=(
 {$endif Delphi}
   '01000_T_Compiler: $1'#000+
   '01001_D_Compiler OS: $1'#000+
@@ -505,435 +505,440 @@ const msgtxt : array[0..000220,1..240] of char=(
   '04085_E_Expected ','Objective-C method, but got $1'#000+
   '04086_E_Expected Objective-C method or constant method name'#000+
   '04087_E_No type info available for this type'#000+
-  '04088_E_Objective-C protocol type expected, but got "$1"'#000+
-  '04089_E_The type "$1" is not supported for inte','raction with the Obje'+
-  'ctive-C runtime.'#000+
+  '04088_E_Ordinal or string expression expected'#000+
+  '04089_E_String expression expected'#000+
+  '04090_E_Objective-C pro','tocol type expected, but got "$1"'#000+
+  '04091_E_The type "$1" is not supported for interaction with the Object'+
+  'ive-C runtime.'#000+
   '05000_E_Identifier not found "$1"'#000+
   '05001_F_Internal Error in SymTableStack()'#000+
   '05002_E_Duplicate identifier "$1"'#000+
-  '05003_H_Identifier already defined in $1 at line $2'#000+
+  '05003_H_Ide','ntifier already defined in $1 at line $2'#000+
   '05004_E_Unknown identifier "$1"'#000+
-  '05005_E_','Forward declaration not solved "$1"'#000+
+  '05005_E_Forward declaration not solved "$1"'#000+
   '05007_E_Error in type definition'#000+
   '05009_E_Forward type not resolved "$1"'#000+
-  '05010_E_Only static variables can be used in static methods or outside'+
-  ' methods'#000+
+  '05010_E_Only static variables can be used in static',' methods or outsi'+
+  'de methods'#000+
   '05012_F_record or class type expected'#000+
-  '05013_E_Instanc','es of classes or objects with an abstract method are '+
-  'not allowed'#000+
+  '05013_E_Instances of classes or objects with an abstract method are no'+
+  't allowed'#000+
   '05014_W_Label not defined "$1"'#000+
   '05015_E_Label used but not defined "$1"'#000+
-  '05016_E_Illegal label declaration'#000+
+  '05016_E_Illegal label d','eclaration'#000+
   '05017_E_GOTO and LABEL are not supported (use switch -Sg)'#000+
-  '05018_E_Labe','l not found'#000+
+  '05018_E_Label not found'#000+
   '05019_E_identifier isn'#039't a label'#000+
   '05020_E_label already defined'#000+
   '05021_E_illegal type declaration of set elements'#000+
-  '05022_E_Forward class definition not resolved "$1"'#000+
+  '05022_E_Forward class definition no','t resolved "$1"'#000+
   '05023_H_Unit "$1" not used in $2'#000+
-  '05024_H_Parameter "$1" not used'#000,
+  '05024_H_Parameter "$1" not used'#000+
   '05025_N_Local variable "$1" not used'#000+
   '05026_H_Value parameter "$1" is assigned but never used'#000+
   '05027_N_Local variable "$1" is assigned but never used'#000+
-  '05028_H_Local $1 "$2" is not used'#000+
+  '05028_H_Loc','al $1 "$2" is not used'#000+
   '05029_N_Private field "$1.$2" is never used'#000+
-  '05030_N_Privat','e field "$1.$2" is assigned but never used'#000+
+  '05030_N_Private field "$1.$2" is assigned but never used'#000+
   '05031_N_Private method "$1.$2" never used'#000+
   '05032_E_Set type expected'#000+
-  '05033_W_Function result does not seem to be set'#000+
+  '05033_W_Function result does not seem to be set'#000,
   '05034_W_Type "$1" is not aligned correctly in current record for C'#000+
-  '05035_E_Unknow','n record field identifier "$1"'#000+
+  '05035_E_Unknown record field identifier "$1"'#000+
   '05036_W_Local variable "$1" does not seem to be initialized'#000+
   '05037_W_Variable "$1" does not seem to be initialized'#000+
-  '05038_E_identifier idents no member "$1"'#000+
+  '05038_E_identi','fier idents no member "$1"'#000+
   '05039_H_Found declaration: $1'#000+
-  '05040_E_Data element too',' large'#000+
+  '05040_E_Data element too large'#000+
   '05042_E_No matching implementation for interface method "$1" found'#000+
   '05043_W_Symbol "$1" is deprecated'#000+
   '05044_W_Symbol "$1" is not portable'#000+
-  '05055_W_Symbol "$1" is not implemented'#000+
+  '05055_W_Symbol ','"$1" is not implemented'#000+
   '05056_E_Can'#039't create unique type from this type'#000+
-  '05057_H_L','ocal variable "$1" does not seem to be initialized'#000+
+  '05057_H_Local variable "$1" does not seem to be initialized'#000+
   '05058_H_Variable "$1" does not seem to be initialized'#000+
-  '05059_W_Function result variable does not seem to initialized'#000+
+  '05059_W_Function result variable does not seem to init','ialized'#000+
   '05060_H_Function result variable does not seem to be initialized'#000+
-  '05061_W_','Variable "$1" read but nowhere assigned'#000+
+  '05061_W_Variable "$1" read but nowhere assigned'#000+
   '05062_H_Found abstract method: $1'#000+
   '05063_W_Symbol "$1" is experimental'#000+
-  '05064_W_Forward declaration "$1" not resolved, assumed external'#000+
-  '05065_E_Mismatch between number of declared parameters and number ','of'+
-  ' colons in message string.'#000+
+  '05064_W_Forward declaration "$1" not resolved, as','sumed external'#000+
+  '05065_E_Mismatch between number of declared parameters and number of c'+
+  'olons in message string.'#000+
   '06009_E_Parameter list size exceeds 65535 bytes'#000+
   '06012_E_File types must be var parameters'#000+
-  '06013_E_The use of a far pointer isn'#039't allowed there'#000+
+  '06013_E_The use of a far pointer isn'#039't a','llowed there'#000+
   '06015_E_EXPORT declared functions can'#039't be called'#000+
-  '06016_W_Possible i','llegal call of constructor or destructor'#000+
+  '06016_W_Possible illegal call of constructor or destructor'#000+
   '06017_N_Inefficient code'#000+
   '06018_W_unreachable code'#000+
   '06020_E_Abstract methods can'#039't be called directly'#000+
-  '06027_DL_Register $1 weight $2 $3'#000+
+  '06027_DL_Register ','$1 weight $2 $3'#000+
   '06029_DL_Stack frame is omitted'#000+
-  '06031_E_Object or class methods c','an'#039't be inline.'#000+
+  '06031_E_Object or class methods can'#039't be inline.'#000+
   '06032_E_Procvar calls cannot be inline.'#000+
   '06033_E_No code for inline procedure stored'#000+
-  '06035_E_Element zero of an ansi/wide- or longstring can'#039't be acces'+
-  'sed, use (set)length instead'#000+
-  '06037_E_Constructors or destructors can not b','e called inside a '#039'w'+
-  'ith'#039' clause'#000+
+  '06035_E_Element zero of an ansi/wide- or longstring can'#039't b','e acc'+
+  'essed, use (set)length instead'#000+
+  '06037_E_Constructors or destructors can not be called inside a '#039'wi'+
+  'th'#039' clause'#000+
   '06038_E_Cannot call message handler methods directly'#000+
   '06039_E_Jump in or outside of an exception block'#000+
-  '06040_E_Control flow statements aren'#039't allowed in a finally block'#000+
-  '06041_W_Parameters size exceeds limit fo','r certain cpu'#039's'#000+
+  '06040_E_Control flow stat','ements aren'#039't allowed in a finally bloc'+
+  'k'#000+
+  '06041_W_Parameters size exceeds limit for certain cpu'#039's'#000+
   '06042_W_Local variable size exceed limit for certain cpu'#039's'#000+
   '06043_E_Local variables size exceeds supported limit'#000+
   '06044_E_BREAK not allowed'#000+
-  '06045_E_CONTINUE not allowed'#000+
-  '06046_F_Unknown compilerproc "$1". Check if you use the c','orrect run '+
-  'time library.'#000+
+  '06045','_E_CONTINUE not allowed'#000+
+  '06046_F_Unknown compilerproc "$1". Check if you use the correct run ti'+
+  'me library.'#000+
   '06047_F_Cannot find system type "$1". Check if you use the correct run'+
   ' time library.'#000+
-  '06048_H_Inherited call to abstract method ignored'#000+
+  '06048_H_Inherited call to abstract method ignored',#000+
   '06049_E_Goto label "$1" not defined or optimized away'#000+
-  '06050_F_Cannot find type "','$1" in unit "$2". Check if you use the cor'+
-  'rect run time library.'#000+
+  '06050_F_Cannot find type "$1" in unit "$2". Check if you use the corre'+
+  'ct run time library.'#000+
   '07000_DL_Starting $1 styled assembler parsing'#000+
   '07001_DL_Finished $1 styled assembler parsing'#000+
-  '07002_E_Non-label pattern contains @'#000+
+  '07','002_E_Non-label pattern contains @'#000+
   '07004_E_Error building record offset'#000+
-  '07005_E_O','FFSET used without identifier'#000+
+  '07005_E_OFFSET used without identifier'#000+
   '07006_E_TYPE used without identifier'#000+
   '07007_E_Cannot use local variable or parameters here'#000+
   '07008_E_need to use OFFSET here'#000+
-  '07009_E_need to use $ here'#000+
+  '07009_E','_need to use $ here'#000+
   '07010_E_Cannot use multiple relocatable symbols'#000+
-  '07011_E_Reloc','atable symbol can only be added'#000+
+  '07011_E_Relocatable symbol can only be added'#000+
   '07012_E_Invalid constant expression'#000+
   '07013_E_Relocatable symbol is not allowed'#000+
   '07014_E_Invalid reference syntax'#000+
-  '07015_E_You can not reach $1 from that code'#000+
-  '07016_E_Local symbols/labels aren'#039't allowed as refere','nces'#000+
+  '07015_E_You can ','not reach $1 from that code'#000+
+  '07016_E_Local symbols/labels aren'#039't allowed as references'#000+
   '07017_E_Invalid base and index register usage'#000+
   '07018_W_Possible error in object field handling'#000+
   '07019_E_Wrong scale factor specified'#000+
-  '07020_E_Multiple index register usage'#000+
+  '07020_E_Multiple index ','register usage'#000+
   '07021_E_Invalid operand type'#000+
-  '07022_E_Invalid string as opcode oper','and: $1'#000+
+  '07022_E_Invalid string as opcode operand: $1'#000+
   '07023_W_@CODE and @DATA not supported'#000+
   '07024_E_Null label references are not allowed'#000+
   '07025_E_Divide by zero in asm evaluator'#000+
-  '07026_E_Illegal expression'#000+
+  '07026_E_Illegal expression'#000,
   '07027_E_escape sequence ignored: $1'#000+
   '07028_E_Invalid symbol reference'#000+
-  '07029_W_Fwai','t can cause emulation problems with emu387'#000+
+  '07029_W_Fwait can cause emulation problems with emu387'#000+
   '07030_W_$1 without operand translated into $1P'#000+
   '07031_W_ENTER instruction is not supported by Linux kernel'#000+
-  '07032_W_Calling an overload function in assembler'#000+
-  '07033_E_Unsupported symbol type for opera','nd'#000+
+  '07032_W_Ca','lling an overload function in assembler'#000+
+  '07033_E_Unsupported symbol type for operand'#000+
   '07034_E_Constant value out of bounds'#000+
   '07035_E_Error converting decimal $1'#000+
   '07036_E_Error converting octal $1'#000+
   '07037_E_Error converting binary $1'#000+
-  '07038_E_Error converting hexadecimal $1'#000+
+  '07038_E_Error ','converting hexadecimal $1'#000+
   '07039_H_$1 translated to $2'#000+
-  '07040_W_$1 is associated to',' an overloaded function'#000+
+  '07040_W_$1 is associated to an overloaded function'#000+
   '07041_E_Cannot use SELF outside a method'#000+
   '07042_E_Cannot use OLDEBP outside a nested procedure'#000+
-  '07043_W_Procedures can'#039't return any value in asm code'#000+
+  '07043_W_Procedures can'#039't return any value',' in asm code'#000+
   '07044_E_SEG not supported'#000+
-  '07045_E_Size suffix and destination or sou','rce size do not match'#000+
+  '07045_E_Size suffix and destination or source size do not match'#000+
   '07046_W_Size suffix and destination or source size do not match'#000+
   '07047_E_Assembler syntax error'#000+
-  '07048_E_Invalid combination of opcode and operands'#000+
+  '07048_E_Invalid combination of opcode and ','operands'#000+
   '07049_E_Assembler syntax error in operand'#000+
-  '07050_E_Assembler syntax error',' in constant'#000+
+  '07050_E_Assembler syntax error in constant'#000+
   '07051_E_Invalid String expression'#000+
   '07052_W_constant with symbol $1 for address which is not on a pointer'#000+
   '07053_E_Unrecognized opcode $1'#000+
-  '07054_E_Invalid or missing opcode'#000+
+  '07054_E_Inv','alid or missing opcode'#000+
   '07055_E_Invalid combination of prefix and opcode: $1'#000+
-  '07056','_E_Invalid combination of override and opcode: $1'#000+
+  '07056_E_Invalid combination of override and opcode: $1'#000+
   '07057_E_Too many operands on line'#000+
   '07058_W_NEAR ignored'#000+
   '07059_W_FAR ignored'#000+
-  '07060_E_Duplicate local symbol $1'#000+
+  '07060_E_Duplicate local symbol $1'#000,
   '07061_E_Undefined local symbol $1'#000+
   '07062_E_Unknown label identifier $1'#000+
-  '07063_E_Inv','alid register name'#000+
+  '07063_E_Invalid register name'#000+
   '07064_E_Invalid floating point register name'#000+
   '07066_W_Modulo not supported'#000+
   '07067_E_Invalid floating point constant $1'#000+
-  '07068_E_Invalid floating point expression'#000+
+  '07068_E_Invalid floatin','g point expression'#000+
   '07069_E_Wrong symbol type'#000+
-  '07070_E_Cannot index a local var or ','parameter with a register'#000+
+  '07070_E_Cannot index a local var or parameter with a register'#000+
   '07071_E_Invalid segment override expression'#000+
   '07072_W_Identifier $1 supposed external'#000+
   '07073_E_Strings not allowed as constants'#000+
-  '07074_No type of variable specified'#000+
+  '07074_No',' type of variable specified'#000+
   '07075_E_assembler code not returned to text section'#000+
-  '0','7076_E_Not a directive or local symbol $1'#000+
+  '07076_E_Not a directive or local symbol $1'#000+
   '07077_E_Using a defined name as a local label'#000+
   '07078_E_Dollar token is used without an identifier'#000+
-  '07079_W_32bit constant created for address'#000+
-  '07080_N_.align is target specific, use .balign or .p2align',#000+
+  '07079_W_32bit consta','nt created for address'#000+
+  '07080_N_.align is target specific, use .balign or .p2align'#000+
   '07081_E_Can'#039't access fields directly for parameters'#000+
   '07082_E_Can'#039't access fields of objects/classes directly'#000+
-  '07083_E_No size specified and unable to determine the size of the oper'+
-  'ands'#000+
+  '07083_E_No size specified and unable to determine ','the size of the op'+
+  'erands'#000+
   '07084_E_Cannot use RESULT in this function'#000+
-  '07086_W_"$1" ','without operand translated into "$1 %st,%st(1)"'#000+
+  '07086_W_"$1" without operand translated into "$1 %st,%st(1)"'#000+
   '07087_W_"$1 %st(n)" translated into "$1 %st,%st(n)"'#000+
   '07088_W_"$1 %st(n)" translated into "$1 %st(n),%st"'#000+
-  '07089_E_Char < not allowed here'#000+
+  '07089_E','_Char < not allowed here'#000+
   '07090_E_Char > not allowed here'#000+
-  '07093_W_ALIGN not suppor','ted'#000+
+  '07093_W_ALIGN not supported'#000+
   '07094_E_Inc and Dec cannot be together'#000+
   '07095_E_Invalid reglist for movem'#000+
   '07096_E_Reglist invalid for opcode'#000+
   '07097_E_Higher cpu mode required ($1)'#000+
-  '07098_W_No size specified and unable to determine the size of the oper'+
-  'ands, using DWORD as',' default'#000+
+  '07098_W_N','o size specified and unable to determine the size of the op'+
+  'erands, using DWORD as default'#000+
   '07099_E_Syntax error while trying to parse a shifter operand'#000+
   '07100_E_Address of packed component is not at a byte boundary'#000+
-  '07101_W_No size specified and unable to determine the size of the oper'+
-  'ands, using BYTE as default'#000+
-  '07102_W_Us','e of +offset(%ebp) for parameters invalid here'#000+
+  '07101_W_No size specified a','nd unable to determine the size of the op'+
+  'erands, using BYTE as default'#000+
+  '07102_W_Use of +offset(%ebp) for parameters invalid here'#000+
   '07103_W_Use of +offset(%ebp) is not compatible with regcall convention'+
   #000+
-  '07104_W_Use of -offset(%ebp) is not recommended for local variable acc'+
-  'ess'#000+
-  '07105_W_Use of -offset(%esp), access may cause a',' crash or value may '+
-  'be lost'#000+
+  '07104_W_Use of -offset(%ebp) is not recom','mended for local variable a'+
+  'ccess'#000+
+  '07105_W_Use of -offset(%esp), access may cause a crash or value may be'+
+  ' lost'#000+
   '07106_E_VMTOffset must be used in combination with a virtual method, a'+
   'nd "$1" is not virtual'#000+
-  '07107_E_Generating PIC, but reference is not PIC-safe'#000+
+  '07107_E_Generating PIC, but reference ','is not PIC-safe'#000+
   '08000_F_Too many assembler files'#000+
-  '08001_F_Selected assembler outpu','t not supported'#000+
+  '08001_F_Selected assembler output not supported'#000+
   '08002_F_Comp not supported'#000+
   '08003_F_Direct not support for binary writers'#000+
   '08004_E_Allocating of data is only allowed in bss section'#000+
-  '08005_F_No binary writer selected'#000+
+  '08005_F_No b','inary writer selected'#000+
   '08006_E_Asm: Opcode $1 not in table'#000+
-  '08007_E_Asm: $1 invalid',' combination of opcode and operands'#000+
+  '08007_E_Asm: $1 invalid combination of opcode and operands'#000+
   '08008_E_Asm: 16 Bit references not supported'#000+
   '08009_E_Asm: Invalid effective address'#000+
-  '08010_E_Asm: Immediate or reference expected'#000+
+  '08010_E_Asm: Immediate or reference exp','ected'#000+
   '08011_E_Asm: $1 value exceeds bounds $2'#000+
-  '08012_E_Asm: Short jump is out of r','ange $1'#000+
+  '08012_E_Asm: Short jump is out of range $1'#000+
   '08013_E_Asm: Undefined label $1'#000+
   '08014_E_Asm: Comp type not supported for this target'#000+
   '08015_E_Asm: Extended type not supported for this target'#000+
-  '08016_E_Asm: Duplicate label $1'#000+
+  '08016_E_A','sm: Duplicate label $1'#000+
   '08017_E_Asm: Redefined label $1'#000+
-  '08018_E_Asm: First defined',' here'#000+
+  '08018_E_Asm: First defined here'#000+
   '08019_E_Asm: Invalid register $1'#000+
   '08020_E_Asm: 16 or 32 Bit references not supported'#000+
   '08021_E_Asm: 64 Bit operands not supported'#000+
-  '09000_W_Source operating system redefined'#000+
+  '09000_W_Source operating s','ystem redefined'#000+
   '09001_I_Assembling (pipe) $1'#000+
-  '09002_E_Can'#039't create assembler file:',' $1'#000+
+  '09002_E_Can'#039't create assembler file: $1'#000+
   '09003_E_Can'#039't create object file: $1'#000+
   '09004_E_Can'#039't create archive file: $1'#000+
   '09005_E_Assembler $1 not found, switching to external assembling'#000+
-  '09006_T_Using assembler: $1'#000+
+  '09006_T_Using a','ssembler: $1'#000+
   '09007_E_Error while assembling exitcode $1'#000+
-  '09008_E_Can'#039't call the as','sembler, error $1 switching to external'+
-  ' assembling'#000+
+  '09008_E_Can'#039't call the assembler, error $1 switching to external a'+
+  'ssembling'#000+
   '09009_I_Assembling $1'#000+
   '09010_I_Assembling with smartlinking $1'#000+
-  '09011_W_Object $1 not found, Linking may fail !'#000+
+  '09011_W_Object $1 not found, Linking may fail ','!'#000+
   '09012_W_Library $1 not found, Linking may fail !'#000+
   '09013_E_Error while linking'#000+
-  '09','014_E_Can'#039't call the linker, switching to external linking'#000+
+  '09014_E_Can'#039't call the linker, switching to external linking'#000+
   '09015_I_Linking $1'#000+
   '09016_E_Util $1 not found, switching to external linking'#000+
   '09017_T_Using util $1'#000+
-  '09018_E_Creation of Executables not supported'#000+
-  '09019_E_Creation of Dynamic/Shared Li','braries not supported'#000+
+  '09','018_E_Creation of Executables not supported'#000+
+  '09019_E_Creation of Dynamic/Shared Libraries not supported'#000+
   '09020_I_Closing script $1'#000+
   '09021_E_resource compiler "$1" not found, switching to external mode'#000+
   '09022_I_Compiling resource $1'#000+
-  '09023_T_unit $1 can'#039't be statically linked, switching to smart lin'+
-  'king'#000+
-  '09024_T_unit $1 can'#039't ','be smart linked, switching to static linki'+
-  'ng'#000+
+  '09023_T_unit',' $1 can'#039't be statically linked, switching to smart l'+
+  'inking'#000+
+  '09024_T_unit $1 can'#039't be smart linked, switching to static linking'+
+  #000+
   '09025_T_unit $1 can'#039't be shared linked, switching to static linkin'+
   'g'#000+
-  '09026_E_unit $1 can'#039't be smart or static linked'#000+
+  '09026_E_unit $1 can'#039't be smart or static linke','d'#000+
   '09027_E_unit $1 can'#039't be shared or static linked'#000+
-  '09028_D_Calling resource compi','ler "$1" with "$2" as command line'#000+
+  '09028_D_Calling resource compiler "$1" with "$2" as command line'#000+
   '09029_E_Error while compiling resources'#000+
   '09030_E_Can'#039't call the resource compiler "$1", switching to extern'+
   'al mode'#000+
-  '09031_E_Can'#039't open resource file "$1"'#000+
+  '09031_E_Ca','n'#039't open resource file "$1"'#000+
   '09032_E_Can'#039't write resource file "$1"'#000+
-  '09128_F_Can'#039't ','post process executable $1'#000+
+  '09128_F_Can'#039't post process executable $1'#000+
   '09129_F_Can'#039't open executable $1'#000+
   '09130_X_Size of Code: $1 bytes'#000+
   '09131_X_Size of initialized data: $1 bytes'#000+
-  '09132_X_Size of uninitialized data: $1 bytes'#000+
+  '09132_X_Size of uninitial','ized data: $1 bytes'#000+
   '09133_X_Stack space reserved: $1 bytes'#000+
-  '09134_X_Stack space co','mmitted: $1 bytes'#000+
+  '09134_X_Stack space committed: $1 bytes'#000+
   '09200_F_Executable image size is too big for $1 target.'#000+
   '09201_W_Object file "$1" contains 32-bit absolute relocation to symbol'+
   ' "$2".'#000+
-  '10000_T_Unitsearch: $1'#000+
+  '10000_T_','Unitsearch: $1'#000+
   '10001_T_PPU Loading $1'#000+
   '10002_U_PPU Name: $1'#000+
-  '10003_U_PPU Flags: $1'#000,
+  '10003_U_PPU Flags: $1'#000+
   '10004_U_PPU Crc: $1'#000+
   '10005_U_PPU Time: $1'#000+
   '10006_U_PPU File too short'#000+
   '10007_U_PPU Invalid Header (no PPU at the begin)'#000+
   '10008_U_PPU Invalid Version $1'#000+
-  '10009_U_PPU is compiled for another processor'#000+
+  '10009_U_PPU',' is compiled for another processor'#000+
   '10010_U_PPU is compiled for an other target'#000+
-  '10','011_U_PPU Source: $1'#000+
+  '10011_U_PPU Source: $1'#000+
   '10012_U_Writing $1'#000+
   '10013_F_Can'#039't Write PPU-File'#000+
   '10014_F_Error reading PPU-File'#000+
   '10015_F_unexpected end of PPU-File'#000+
-  '10016_F_Invalid PPU-File entry: $1'#000+
+  '10016_F_Invalid PPU-File',' entry: $1'#000+
   '10017_F_PPU Dbx count problem'#000+
   '10018_E_Illegal unit name: $1'#000+
-  '10019_F_To','o much units'#000+
+  '10019_F_Too much units'#000+
   '10020_F_Circular unit reference between $1 and $2'#000+
   '10021_F_Can'#039't compile unit $1, no sources available'#000+
   '10022_F_Can'#039't find unit $1 used by $2'#000+
-  '10023_W_Unit $1 was not found but $2 exists'#000+
+  '10023_','W_Unit $1 was not found but $2 exists'#000+
   '10024_F_Unit $1 searched but $2 found'#000+
-  '10025','_W_Compiling the system unit requires the -Us switch'#000+
+  '10025_W_Compiling the system unit requires the -Us switch'#000+
   '10026_F_There were $1 errors compiling module, stopping'#000+
   '10027_U_Load from $1 ($2) unit $3'#000+
-  '10028_U_Recompiling $1, checksum changed for $2'#000+
+  '10028_U_Recompil','ing $1, checksum changed for $2'#000+
   '10029_U_Recompiling $1, source found only'#000+
-  '10030_U','_Recompiling unit, static lib is older than ppufile'#000+
+  '10030_U_Recompiling unit, static lib is older than ppufile'#000+
   '10031_U_Recompiling unit, shared lib is older than ppufile'#000+
-  '10032_U_Recompiling unit, obj and asm are older than ppufile'#000+
+  '10032_U_Recompiling unit, obj and asm are older ','than ppufile'#000+
   '10033_U_Recompiling unit, obj is older than asm'#000+
-  '10034_U_Parsing inte','rface of $1'#000+
+  '10034_U_Parsing interface of $1'#000+
   '10035_U_Parsing implementation of $1'#000+
   '10036_U_Second load for unit $1'#000+
   '10037_U_PPU Check file $1 time $2'#000+
-  '10040_W_Can'#039't recompile unit $1, but found modifed include files'#000+
+  '10040_W_Can'#039't recompile unit $1, but found m','odifed include files'+
+  #000+
   '10041_U_File $1 is newer than PPU file $2'#000+
-  '10042_U_Trying to ','use a unit which was compiled with a different FPU'+
-  ' mode'#000+
+  '10042_U_Trying to use a unit which was compiled with a different FPU m'+
+  'ode'#000+
   '10043_U_Loading interface units from $1'#000+
   '10044_U_Loading implementation units from $1'#000+
-  '10045_U_Interface CRC changed for unit $1'#000+
+  '10045_U_Interface ','CRC changed for unit $1'#000+
   '10046_U_Implementation CRC changed for unit $1'#000+
-  '10047_U_Fi','nished compiling unit $1'#000+
+  '10047_U_Finished compiling unit $1'#000+
   '10048_U_Add dependency of $1 to $2'#000+
   '10049_U_No reload, is caller: $1'#000+
   '10050_U_No reload, already in second compile: $1'#000+
-  '10051_U_Flag for reload: $1'#000+
+  '10051_U_Flag for ','reload: $1'#000+
   '10052_U_Forced reloading'#000+
   '10053_U_Previous state of $1: $2'#000+
-  '10054_U_Alre','ady compiling $1, setting second compile'#000+
+  '10054_U_Already compiling $1, setting second compile'#000+
   '10055_U_Loading unit $1'#000+
   '10056_U_Finished loading unit $1'#000+
   '10057_U_Registering new unit $1'#000+
-  '10058_U_Re-resolving unit $1'#000+
+  '10058_U_Re-resolving unit $1'#000,
   '10059_U_Skipping re-resolving unit $1, still loading used units'#000+
-  '10060_U_Unloading',' resource unit $1 (not needed)'#000+
+  '10060_U_Unloading resource unit $1 (not needed)'#000+
   '10061_E_Unit $1 was compiled using a different whole program optimizat'+
-  'ion feedback input ($2, $3); recompile it without wpo or use the same '+
-  'wpo feedback input file for this compilation invocation'#000+
-  '11000_O_$1 [o','ptions] <inputfile> [options]'#000+
+  'ion feedback input ($2, $3); recompile it without wpo or u','se the sam'+
+  'e wpo feedback input file for this compilation invocation'#000+
+  '11000_O_$1 [options] <inputfile> [options]'#000+
   '11001_W_Only one source file supported, changing source file to compil'+
   'e from "$1" into "$2"'#000+
-  '11002_W_DEF file can be created only for OS/2'#000+
+  '11002_W_DEF file can be created only ','for OS/2'#000+
   '11003_E_nested response files are not supported'#000+
-  '11004_F_No source file n','ame in command line'#000+
+  '11004_F_No source file name in command line'#000+
   '11005_N_No option inside $1 config file'#000+
   '11006_E_Illegal parameter: $1'#000+
   '11007_H_-? writes help pages'#000+
   '11008_F_Too many config files nested'#000+
-  '11009_F_Unable to open file $1'#000+
+  '110','09_F_Unable to open file $1'#000+
   '11010_D_Reading further options from $1'#000+
-  '11011_W_Targe','t is already set to: $1'#000+
+  '11011_W_Target is already set to: $1'#000+
   '11012_W_Shared libs not supported on DOS platform, reverting to static'+
   #000+
-  '11013_F_In options file $1 at line $2 too many \var{\#IF(N)DEFs} encou'+
-  'ntered'#000+
-  '11014_F_In options file $1 at line $2 unexpected \var{\#ENDIFs} enco','u'+
-  'ntered'#000+
+  '11013_F_In options file $1 at line $2 too many \var{\#IF(N)DEFs}',' enc'+
+  'ountered'#000+
+  '11014_F_In options file $1 at line $2 unexpected \var{\#ENDIFs} encoun'+
+  'tered'#000+
   '11015_F_Open conditional at the end of the options file'#000+
   '11016_W_Debug information generation is not supported by this executab'+
   'le'#000+
-  '11017_H_Try recompiling with -dGDB'#000+
+  '11017_H_Try recompilin','g with -dGDB'#000+
   '11018_W_You are using the obsolete switch $1'#000+
-  '11019_W_You are using t','he obsolete switch $1, please use $2'#000+
+  '11019_W_You are using the obsolete switch $1, please use $2'#000+
   '11020_N_Switching assembler to default source writing assembler'#000+
-  '11021_W_Assembler output selected "$1" is not compatible with "$2"'#000+
+  '11021_W_Assembler output selected "$1" is not compatible w','ith "$2"'#000+
   '11022_W_"$1" assembler use forced'#000+
   '11026_T_Reading options from file $1'#000+
-  '1','1027_T_Reading options from environment $1'#000+
+  '11027_T_Reading options from environment $1'#000+
   '11028_D_Handling option "$1"'#000+
   '11029_O_*** press enter ***'#000+
   '11030_H_Start of reading config file $1'#000+
-  '11031_H_End of reading config file $1'#000+
+  '11031_H_End of read','ing config file $1'#000+
   '11032_D_interpreting option "$1"'#000+
-  '11036_D_interpreting firstpas','s option "$1"'#000+
+  '11036_D_interpreting firstpass option "$1"'#000+
   '11033_D_interpreting file option "$1"'#000+
   '11034_D_Reading config file "$1"'#000+
   '11035_D_found source file name "$1"'#000+
   '11039_E_Unknown code page'#000+
-  '11040_F_Config file $1 is a directory'#000+
-  '11041_W_Assembler output selected "$1" cannot generate ','debug info, d'+
-  'ebugging disabled'#000+
+  '11040_F_Conf','ig file $1 is a directory'#000+
+  '11041_W_Assembler output selected "$1" cannot generate debug info, deb'+
+  'ugging disabled'#000+
   '11042_W_Use of ppc386.cfg is deprecated, please use fpc.cfg instead'#000+
-  '11043_F_In options file $1 at line $2 \var{\#ELSE} directive without \'+
-  'var{\#IF(N)DEF} found'#000+
-  '11044_F_Option "$1" is not, or not yet, supported',' on the current tar'+
-  'get platform'#000+
+  '11043_F_In options file $1 at line $2 \var{\#ELSE} directive',' without'+
+  ' \var{\#IF(N)DEF} found'#000+
+  '11044_F_Option "$1" is not, or not yet, supported on the current targe'+
+  't platform'#000+
   '11045_F_The feature "$1" is not, or not yet, supported on the selected'+
   ' target platform'#000+
-  '11046_N_DWARF debug information cannot be used with smart linking on t'+
-  'his target, switching to static linking'#000+
-  '12000_F_Can','not open whole program optimization feedback file "$1"'#000+
-  '12001_D_Processing whole program optimization information in wpo feedb'+
-  'ack file "$1"'#000+
+  '11046_N_DWARF debug information cannot b','e used with smart linking on'+
+  ' this target, switching to static linking'#000+
+  '11047_W_Option "$1" is ignored for the current target platform.'#000+
+  '12000_F_Cannot open whole program optimization feedback file "$1"'#000+
+  '12001_D_Processing whole program optimiz','ation information in wpo fee'+
+  'dback file "$1"'#000+
   '12002_D_Finished processing the whole program optimization information'+
   ' in wpo feedback file "$1"'#000+
-  '1200','3_E_Expected section header, but got "$2" at line $1 of wpo feed'+
-  'back file'#000+
-  '12004_W_No handler registered for whole program optimization section "'+
-  '$2" at line $1 of wpo feedback file, ignoring'#000+
-  '12005_D_Found whole program optimization section "','$1" with informati'+
-  'on about "$2"'#000+
-  '12006_F_The selected whole program optimizations require a previously '+
-  'generated feedback file (use -Fw to specify)'#000+
+  '12003_E_Expected section header, but got "$2" at line $1 of wpo feedba'+
+  'ck file'#000+
+  '12004_W_No handler re','gistered for whole program optimization section'+
+  ' "$2" at line $1 of wpo feedback file, ignoring'#000+
+  '12005_D_Found whole program optimization section "$1" with information'+
+  ' about "$2"'#000+
+  '12006_F_The selected whole program optimizations require a prev','iousl'+
+  'y generated feedback file (use -Fw to specify)'#000+
   '12007_E_No collected information necessary to perform "$1" whole progr'+
   'am optimization found'#000+
-  '1','2008_F_Specify a whole program optimization feedback file to store '+
-  'the generated info in (using -FW)'#000+
+  '12008_F_Specify a whole program optimization feedback file to store th'+
+  'e generated info in (using',' -FW)'#000+
   '12009_E_Not generating any whole program optimization information, yet'+
   ' a feedback file was specified (using -FW)'#000+
-  '12010_E_Not performing any',' whole program optimizations, yet an input'+
-  ' feedback file was specified (using -Fw)'#000+
-  '12011_D_Skipping whole program optimization section "$1", because not '+
-  'needed by the requested optimizations'#000+
-  '12012_W_Overriding previously read information fo','r "$1" from feedbac'+
-  'k input file using information in section "$2"'#000+
-  '12013_E_Cannot extract symbol liveness information from program when s'+
-  'tripping symbols, use -Xs-'#000+
+  '12010_E_Not performing any whole program optimizations, yet an input f'+
+  'eedback file was specified (using -Fw)'#000+
+  '12011_D_Skip','ping whole program optimization section "$1", because no'+
+  't needed by the requested optimizations'#000+
+  '12012_W_Overriding previously read information for "$1" from feedback '+
+  'input file using information in section "$2"'#000+
+  '12013_E_Cannot extract symbol',' liveness information from program when'+
+  ' stripping symbols, use -Xs-'#000+
   '12014_E_Cannot extract symbol liveness information from program when w'+
-  'hen not',' linking'#000+
+  'hen not linking'#000+
   '12015_F_Cannot find "$1" or "$2" to extract symbol liveness informatio'+
-  'n from linked program'#000+
+  'n from linked pr','ogram'#000+
   '12016_E_Error during reading symbol liveness information produced by "'+
   '$1"'#000+
-  '12017_F_Error executing "$1" (exitcode: $2) to extract symbol inf','orm'+
-  'ation from linked program'#000+
-  '12018_E_Collection of symbol liveness information can only help when u'+
-  'sing smart linking, use -CX -XX'#000+
+  '12017_F_Error executing "$1" (exitcode: $2) to extract symbol informat'+
+  'ion from linked program'#000+
+  '12018_E_Collection of symbol liveness information can only help wh','en'+
+  ' using smart linking, use -CX -XX'#000+
   '12019_E_Cannot create specified whole program optimisation feedback fi'+
   'le "$1"'#000+
-  '11023_Free Pascal Compiler vers','ion $FPCFULLVERSION [$FPCDATE] for $F'+
-  'PCCPU'#010+
+  '11023_Free Pascal Compiler version $FPCFULLVERSION [$FPCDATE] for $FPC'+
+  'CPU'#010+
   'Copyright (c) 1993-2009 by Florian Klaempfl'#000+
-  '11024_Free Pascal Compiler version $FPCVERSION'#010+
+  '11024_Fr','ee Pascal Compiler version $FPCVERSION'#010+
   #010+
   'Compiler Date      : $FPCDATE'#010+
   'Compiler CPU Target: $FPCCPU'#010+
@@ -941,12 +946,12 @@ const msgtxt : array[0..000220,1..240] of char=(
   'Supported targets:'#010+
   '  $OSTARGETS'#010+
   #010+
-  'Supported CP','U instruction sets:'#010+
+  'Supported CPU instruction sets:'#010+
   '  $INSTRUCTIONSETS'#010+
   #010+
   'Supported FPU instruction sets:'#010+
   '  $FPUINSTRUCTIONSETS'#010+
-  #010+
+  #010,
   'Supported ABI targets:'#010+
   '  $ABITARGETS'#010+
   #010+
@@ -955,295 +960,298 @@ const msgtxt : array[0..000220,1..240] of char=(
   #010+
   'Supported Whole Program Optimizations:'#010+
   '  All'#010+
-  '  $WPOPTIMIZATIONS'#010,
+  '  $WPOPTIMIZATIONS'#010+
   #010+
   'Supported Microcontroller types:'#010+
   '  $CONTROLLERTYPES'#010+
   #010+
-  'This program comes under the GNU General Public Licence'#010+
+  'This program comes under the GNU General ','Public Licence'#010+
   'For more information read COPYING.FPC'#010+
   #010+
   'Report bugs, suggestions, etc. to:'#010+
   '                 http://bugs.freepascal.org'#010+
   'or'#010+
-  '         ','        [email protected]'#000+
-  '11025_**0*_Put + after a boolean switch option to enable it, - to disa'+
-  'ble it'#010+
+  '                 [email protected]'#000+
+  '11025_**0*_Put + after a boolean switch option to enable it, - to d','i'+
+  'sable it'#010+
   '**1a_The compiler doesn'#039't delete the generated assembler file'#010+
   '**2al_List sourcecode lines in assembler file'#010+
-  '**2an_List node info in ass','embler file'#010+
+  '**2an_List node info in assembler file'#010+
   '*L2ap_Use pipes instead of creating temporary assembler files'#010+
-  '**2ar_List register allocation/release info in assembler file'#010+
+  '**2ar_List register a','llocation/release info in assembler file'#010+
   '**2at_List temp allocation/release info in assembler file'#010+
   '**1A<x>_Output format:'#010+
-  '**2Adefault_Use default',' assembler'#010+
+  '**2Adefault_Use default assembler'#010+
   '3*2Aas_Assemble using GNU AS'#010+
   '3*2Anasmcoff_COFF (Go32v2) file using Nasm'#010+
-  '3*2Anasmelf_ELF32 (Linux) file using Nasm'#010+
+  '3*2Anasmelf_','ELF32 (Linux) file using Nasm'#010+
   '3*2Anasmwin32_Win32 object file using Nasm'#010+
   '3*2Anasmwdosx_Win32/WDOSX object file using Nasm'#010+
-  '3*2Awasm_Obj file using',' Wasm (Watcom)'#010+
+  '3*2Awasm_Obj file using Wasm (Watcom)'#010+
   '3*2Anasmobj_Obj file using Nasm'#010+
   '3*2Amasm_Obj file using Masm (Microsoft)'#010+
-  '3*2Atasm_Obj file using Tasm (Borland)'#010+
+  '3*2Atas','m_Obj file using Tasm (Borland)'#010+
   '3*2Aelf_ELF (Linux) using internal writer'#010+
   '3*2Acoff_COFF (Go32v2) using internal writer'#010+
-  '3*2Apecoff_PE-COFF (Win32)',' using internal writer'#010+
+  '3*2Apecoff_PE-COFF (Win32) using internal writer'#010+
   '4*2Aas_Assemble using GNU AS'#010+
   '6*2Aas_Unix o-file using GNU AS'#010+
-  '6*2Agas_GNU Motorola assembler'#010+
+  '6*2Agas_GNU',' Motorola assembler'#010+
   '6*2Amit_MIT Syntax (old GAS)'#010+
   '6*2Amot_Standard Motorola assembler'#010+
   'A*2Aas_Assemble using GNU AS'#010+
   'P*2Aas_Assemble using GNU AS'#010+
-  'S*','2Aas_Assemble using GNU AS'#010+
+  'S*2Aas_Assemble using GNU AS'#010+
   '**1b_Generate browser info'#010+
   '**2bl_Generate local symbol info'#010+
-  '**1B_Build all modules'#010+
+  '**1B_Bui','ld all modules'#010+
   '**1C<x>_Code generation options:'#010+
   '**2Ca<x>_Select ABI, see fpc -i for possible values'#010+
   '**2Cb_Generate big-endian code'#010+
-  '**2Cc<x>_Set d','efault calling convention to <x>'#010+
+  '**2Cc<x>_Set default calling convention to <x>'#010+
   '**2CD_Create also dynamic library (not supported)'#010+
-  '**2Ce_Compilation with emulated floating point opcodes'#010+
+  '**2Ce_Compil','ation with emulated floating point opcodes'#010+
   '**2Cf<x>_Select fpu instruction set to use, see fpc -i for possible va'+
   'lues'#010+
-  '**2CF<x>_Minimal floating p','oint constant precision (default, 32, 64)'+
-  #010+
+  '**2CF<x>_Minimal floating point constant precision (default, 32, 64)'#010+
   '**2Cg_Generate PIC code'#010+
-  '**2Ch<n>_<n> bytes heap (between 1023 and 67107840)'#010+
+  '**2Ch<n>_<n> bytes heap (betw','een 1023 and 67107840)'#010+
   '**2Ci_IO-checking'#010+
   '**2Cn_Omit linking stage'#010+
   '**2Co_Check overflow of integer operations'#010+
-  '**2CO_Check for possible overflow of',' integer operations'#010+
+  '**2CO_Check for possible overflow of integer operations'#010+
   '**2Cp<x>_Select instruction set, see fpc -i for possible values'#010+
-  '**2CP<x>=<y>_ packing settings'#010+
+  '**2CP<x>=<y','>_ packing settings'#010+
   '**3CPPACKSET=<y>_ <y> set allocation: 0, 1 or DEFAULT or NORMAL, 2, 4 '+
   'and 8'#010+
   '**2Cr_Range checking'#010+
-  '**2CR_Verify object method c','all validity'#010+
+  '**2CR_Verify object method call validity'#010+
   '**2Cs<n>_Set stack checking size to <n>'#010+
-  '**2Ct_Stack checking (for testing only, see manual)'#010+
+  '**2Ct_Stack checking (for testing only, se','e manual)'#010+
   '**2CX_Create also smartlinked library'#010+
   '**1d<x>_Defines the symbol <x>'#010+
   '**1D_Generate a DEF file'#010+
   '**2Dd<x>_Set description to <x>'#010+
-  '**2Dv<x>_','Set DLL version to <x>'#010+
+  '**2Dv<x>_Set DLL version to <x>'#010+
   '*O2Dw_PM application'#010+
   '**1e<x>_Set path to executable'#010+
   '**1E_Same as -Cn'#010+
-  '**1fPIC_Same as -Cg'#010+
+  '**1','fPIC_Same as -Cg'#010+
   '**1F<x>_Set file names and paths:'#010+
   '**2Fa<x>[,y]_(for a program) load units <x> and [y] before uses is par'+
   'sed'#010+
-  '**2Fc<x>_Set input c','odepage to <x>'#010+
+  '**2Fc<x>_Set input codepage to <x>'#010+
   '**2FC<x>_Set RC compiler binary name to <x>'#010+
-  '**2Fd_Disable the compiler'#039's internal directory cache'#010+
+  '**2Fd_Disable the compiler'#039's interna','l directory cache'#010+
   '**2FD<x>_Set the directory where to search for compiler utilities'#010+
   '**2Fe<x>_Redirect error output to <x>'#010+
-  '**2Ff<x>_Add <x> to fra','mework path (Darwin only)'#010+
+  '**2Ff<x>_Add <x> to framework path (Darwin only)'#010+
   '**2FE<x>_Set exe/unit output path to <x>'#010+
-  '**2Fi<x>_Add <x> to include path'#010+
+  '**2Fi<x>_Add <x> to include ','path'#010+
   '**2Fl<x>_Add <x> to library path'#010+
   '**2FL<x>_Use <x> as dynamic linker'#010+
   '**2Fm<x>_Load unicode conversion table from <x>.txt in the compiler di'+
-  'r'#010,
+  'r'#010+
   '**2Fo<x>_Add <x> to object path'#010+
   '**2Fr<x>_Load error message file <x>'#010+
-  '**2FR<x>_Set resource (.res) linker to <x>'#010+
+  '**2FR<x>_Set resource (.re','s) linker to <x>'#010+
   '**2Fu<x>_Add <x> to unit path'#010+
   '**2FU<x>_Set unit output path to <x>, overrides -FE'#010+
-  '**2FW<x>_Store generated whole-program optimiz','ation feedback in <x>'#010+
+  '**2FW<x>_Store generated whole-program optimization feedback in <x>'#010+
   '**2Fw<x>_Load previously stored whole-program optimization feedback fr'+
-  'om <x>'#010+
+  'om ','<x>'#010+
   '*g1g_Generate debug information (default format for target)'#010+
   '*g2gc_Generate checks for pointers'#010+
-  '*g2gh_Use heaptrace unit (for memory leak/corr','uption debugging)'#010+
+  '*g2gh_Use heaptrace unit (for memory leak/corruption debugging)'#010+
   '*g2gl_Use line info unit (show more info with backtraces)'#010+
-  '*g2go<x>_Set debug information options'#010+
+  '*g2go<x>_Set debug ','information options'#010+
   '*g3godwarfsets_ Enable DWARF set debug information (breaks gdb < 6.5)'#010+
-  '*g3gostabsabsincludes_ Store absolute/full include file',' paths in Sta'+
-  'bs'#010+
+  '*g3gostabsabsincludes_ Store absolute/full include file paths in Stabs'+
+  #010+
   '*g2gp_Preserve case in stabs symbol names'#010+
-  '*g2gs_Generate Stabs debug information'#010+
+  '*g2gs_Generate Stabs debug informatio','n'#010+
   '*g2gt_Trash local variables (to detect uninitialized uses)'#010+
   '*g2gv_Generates programs traceable with Valgrind'#010+
-  '*g2gw_Generate DWARFv2 debug inform','ation (same as -gw2)'#010+
+  '*g2gw_Generate DWARFv2 debug information (same as -gw2)'#010+
   '*g2gw2_Generate DWARFv2 debug information'#010+
-  '*g2gw3_Generate DWARFv3 debug information'#010+
+  '*g2gw3_Generate DWARFv3 debug in','formation'#010+
   '**1i_Information'#010+
   '**2iD_Return compiler date'#010+
   '**2iV_Return short compiler version'#010+
   '**2iW_Return full compiler version'#010+
-  '**2iSO_Return compil','er OS'#010+
+  '**2iSO_Return compiler OS'#010+
   '**2iSP_Return compiler host processor'#010+
   '**2iTO_Return target OS'#010+
-  '**2iTP_Return target processor'#010+
+  '**2iTP_Return target proces','sor'#010+
   '**1I<x>_Add <x> to include path'#010+
   '**1k<x>_Pass <x> to the linker'#010+
   '**1l_Write logo'#010+
   '**1M<x>_Set language mode to <x>'#010+
-  '**2Mfpc_Free Pascal dialect (','default)'#010+
+  '**2Mfpc_Free Pascal dialect (default)'#010+
   '**2Mobjfpc_FPC mode with Object Pascal support'#010+
-  '**2Mdelphi_Delphi 7 compatibility mode'#010+
+  '**2Mdelphi_Delphi 7 compatibility mode'#010,
   '**2Mtp_TP/BP 7.0 compatibility mode'#010+
   '**2Mmacpas_Macintosh Pascal dialects compatibility mode'#010+
   '**1n_Do not read the default config files'#010+
-  '**1N<x>_Nod','e tree optimizations'#010+
+  '**1N<x>_Node tree optimizations'#010+
   '**2Nu_Unroll loops'#010+
-  '**1o<x>_Change the name of the executable produced to <x>'#010+
+  '**1o<x>_Change the name of the executable produced to <','x>'#010+
   '**1O<x>_Optimizations:'#010+
   '**2O-_Disable optimizations'#010+
   '**2O1_Level 1 optimizations (quick and debugger friendly)'#010+
-  '**2O2_Level 2 optimizations (-O1 ','+ quick optimizations)'#010+
+  '**2O2_Level 2 optimizations (-O1 + quick optimizations)'#010+
   '**2O3_Level 3 optimizations (-O2 + slow optimizations)'#010+
-  '**2Oa<x>=<y>_Set alignment'#010+
+  '**2Oa<x>=<y>_Set ','alignment'#010+
   '**2Oo[NO]<x>_Enable or disable optimizations, see fpc -i for possible '+
   'values'#010+
-  '**2Op<x>_Set target cpu for optimizing, see fpc -i for pos','sible valu'+
-  'es'#010+
+  '**2Op<x>_Set target cpu for optimizing, see fpc -i for possible values'+
+  #010+
   '**2OW<x>_Generate whole-program optimization feedback for optimization'+
-  ' <x>, see fpc -i for possible values'#010+
+  ' <x>, see fp','c -i for possible values'#010+
   '**2Ow<x>_Perform whole-program optimization <x>, see fpc -i for possib'+
   'le values'#010+
-  '**2Os_Optimize for size rather than spee','d'#010+
+  '**2Os_Optimize for size rather than speed'#010+
   '**1pg_Generate profile code for gprof (defines FPC_PROFILE)'#010+
-  '**1R<x>_Assembler reading style:'#010+
+  '**1R<x>_Assembler reading style:'#010,
   '**2Rdefault_Use default assembler for target'#010+
   '3*2Ratt_Read AT&T style assembler'#010+
   '3*2Rintel_Read Intel style assembler'#010+
-  '6*2RMOT_Read motorola style a','ssembler'#010+
+  '6*2RMOT_Read motorola style assembler'#010+
   '**1S<x>_Syntax options:'#010+
   '**2S2_Same as -Mobjfpc'#010+
-  '**2Sc_Support operators like C (*=,+=,/= and -=)'#010+
+  '**2Sc_Support operators like C (*=,+=,/','= and -=)'#010+
   '**2Sa_Turn on assertions'#010+
   '**2Sd_Same as -Mdelphi'#010+
   '**2Se<x>_Error options. <x> is a combination of the following:'#010+
-  '**3*_<n> : Compiler halt','s after the <n> errors (default is 1)'#010+
+  '**3*_<n> : Compiler halts after the <n> errors (default is 1)'#010+
   '**3*_w : Compiler also halts after warnings'#010+
-  '**3*_n : Compiler also halts after notes'#010+
+  '**3*_n : Comp','iler also halts after notes'#010+
   '**3*_h : Compiler also halts after hints'#010+
   '**2Sg_Enable LABEL and GOTO (default in -Mtp and -Mdelphi)'#010+
-  '**2Sh_Use ansistr','ings by default instead of shortstrings'#010+
-  '**2Si_Turn on inlining of procedures/functions declared as "inline"'#010+
+  '**2Sh_Use ansistrings by default instead of shortstrings'#010+
+  '**2Si_Turn on inlining of procedures/functions declared',' as "inline"'#010+
   '**2Sk_Load fpcylix unit'#010+
   '**2SI<x>_Set interface style to <x>'#010+
   '**3SIcom_COM compatible interface (default)'#010+
-  '**3SIcorba_CORBA compatible ','interface'#010+
+  '**3SIcorba_CORBA compatible interface'#010+
   '**2Sm_Support macros like C (global)'#010+
   '**2So_Same as -Mtp'#010+
-  '**2Ss_Constructor name must be init (destructor must be done)'#010+
+  '**2Ss_Constructor name must b','e init (destructor must be done)'#010+
   '**2St_Allow static keyword in objects'#010+
   '**2Sx_Enable exception keywords (default in Delphi/ObjFPC modes)'#010+
-  '**1s_Do n','ot call assembler and linker'#010+
+  '**1s_Do not call assembler and linker'#010+
   '**2sh_Generate script to link on host'#010+
-  '**2st_Generate script to link on target'#010+
+  '**2st_Generate script to lin','k on target'#010+
   '**2sr_Skip register allocation phase (use with -alr)'#010+
   '**1T<x>_Target operating system:'#010+
-  '3*2Temx_OS/2 via EMX (including EMX/RSX extende','r)'#010+
+  '3*2Temx_OS/2 via EMX (including EMX/RSX extender)'#010+
   '3*2Tfreebsd_FreeBSD'#010+
   '3*2Tgo32v2_Version 2 of DJ Delorie DOS extender'#010+
   '3*2Tlinux_Linux'#010+
-  '3*2Tnetbsd_NetBSD'#010+
+  '3*2Tnetb','sd_NetBSD'#010+
   '3*2Tnetware_Novell Netware Module (clib)'#010+
   '3*2Tnetwlibc_Novell Netware Module (libc)'#010+
   '3*2Topenbsd_OpenBSD'#010+
   '3*2Tos2_OS/2 / eComStation'#010+
-  '3*2Ts','unos_SunOS/Solaris'#010+
+  '3*2Tsunos_SunOS/Solaris'#010+
   '3*2Tsymbian_Symbian OS'#010+
   '3*2Twatcom_Watcom compatible DOS extender'#010+
-  '3*2Twdosx_WDOSX DOS extender'#010+
+  '3*2Twdosx_W','DOSX DOS extender'#010+
   '3*2Twin32_Windows 32 Bit'#010+
   '3*2Twince_Windows CE'#010+
   '4*2Tlinux_Linux'#010+
   '6*2Tamiga_Commodore Amiga'#010+
   '6*2Tatari_Atari ST/STe/TT'#010+
-  '6*2Tlinux_Lin','ux/m68k'#010+
+  '6*2Tlinux_Linux/m68k'#010+
   '6*2Tmacos_Macintosh m68k (not supported)'#010+
   '6*2Tpalmos_PalmOS'#010+
   'A*2Tlinux_Linux'#010+
-  'A*2Twince_Windows CE'#010+
+  'A*2Twince_Wi','ndows CE'#010+
   'P*2Tamiga_AmigaOS on PowerPC'#010+
   'P*2Tdarwin_Darwin and Mac OS X on PowerPC'#010+
   'P*2Tlinux_Linux on PowerPC'#010+
-  'P*2Tmacos_Mac OS (classic) on PowerPC'#010,
+  'P*2Tmacos_Mac OS (classic) on PowerPC'#010+
   'P*2Tmorphos_MorphOS'#010+
   'S*2Tlinux_Linux'#010+
   '**1u<x>_Undefines the symbol <x>'#010+
   '**1U_Unit options:'#010+
-  '**2Un_Do not check where the unit name matches the file name'#010+
+  '**2Un_D','o not check where the unit name matches the file name'#010+
   '**2Ur_Generate release unit files (never automatically recompiled)'#010+
-  '**2Us_Compile a system u','nit'#010+
+  '**2Us_Compile a system unit'#010+
   '**1v<x>_Be verbose. <x> is a combination of the following letters:'#010+
-  '**2*_e : Show errors (default)       0 : Show nothing (except errors)'#010+
+  '**2*_e : Show errors (de','fault)       0 : Show nothing (except errors'+
+  ')'#010+
   '**2*_w : Show warnings               u : Show unit info'#010+
-  '**2*_n : Show notes                  t : Sh','ow tried/used files'#010+
+  '**2*_n : Show notes                  t : Show tried/used files'#010+
   '**2*_h : Show hints                  c : Show conditionals'#010+
-  '**2*_i : Show general info           d : Show debug info'#010+
+  '**2*_i : Show ge','neral info           d : Show debug info'#010+
   '**2*_l : Show linenumbers            r : Rhide/GCC compatibility mode'#010+
-  '**2*_s : Show time stamps         ','   q : Show message numbers'#010+
-  '**2*_a : Show everything             x : Executable info (Win32 only)'#010+
+  '**2*_s : Show time stamps            q : Show message numbers'#010+
+  '**2*_a : Show everything             x : Executable info (Win32 onl','y'+
+  ')'#010+
   '**2*_b : Write file names messages   p : Write tree.log with parse tre'+
   'e'#010+
   '**2*_    with full path              v : Write fpcdebug.txt with'#010+
-  '**2*_','                                    lots of debugging info'#010+
-  '**2*_m<x>,<y> : Don'#039't show messages numbered <x> and <y>'#010+
+  '**2*_                                    lots of debugging info'#010+
+  '**2*_m<x>,<y> : Don'#039't show messages ','numbered <x> and <y>'#010+
   '3*1W<x>_Target-specific options (targets)'#010+
   'A*1W<x>_Target-specific options (targets)'#010+
-  'P*1W<x>_Target-specific options (targets',')'#010+
+  'P*1W<x>_Target-specific options (targets)'#010+
   'p*1W<x>_Target-specific options (targets)'#010+
-  '3*2Wb_Create a bundle instead of a library (Darwin)'#010+
+  '3*2Wb_Create a bundle instead of a library (Darwin)',#010+
   'P*2Wb_Create a bundle instead of a library (Darwin)'#010+
   'p*2Wb_Create a bundle instead of a library (Darwin)'#010+
-  '3*2WB_Create a relocatable image (Window','s)'#010+
+  '3*2WB_Create a relocatable image (Windows)'#010+
   'A*2WB_Create a relocatable image (Windows, Symbian)'#010+
-  '3*2WC_Specify console type application (EMX, OS/2, Windows)'#010+
+  '3*2WC_Specify console type application (','EMX, OS/2, Windows)'#010+
   'A*2WC_Specify console type application (Windows)'#010+
   'P*2WC_Specify console type application (Classic Mac OS)'#010+
-  '3*2WD_Use DEFFILE to',' export functions of DLL or EXE (Windows)'#010+
-  'A*2WD_Use DEFFILE to export functions of DLL or EXE (Windows)'#010+
+  '3*2WD_Use DEFFILE to export functions of DLL or EXE (Windows)'#010+
+  'A*2WD_Use DEFFILE to export functions of DLL or EXE (','Windows)'#010+
   '3*2We_Use external resources (Darwin)'#010+
   'P*2We_Use external resources (Darwin)'#010+
   'p*2We_Use external resources (Darwin)'#010+
-  '3*2WF_Specify full-scr','een type application (EMX, OS/2)'#010+
+  '3*2WF_Specify full-screen type application (EMX, OS/2)'#010+
   '3*2WG_Specify graphic type application (EMX, OS/2, Windows)'#010+
-  'A*2WG_Specify graphic type application (Windows)'#010+
+  'A*','2WG_Specify graphic type application (Windows)'#010+
   'P*2WG_Specify graphic type application (Classic Mac OS)'#010+
   '3*2Wi_Use internal resources (Darwin)'#010+
-  'P*2W','i_Use internal resources (Darwin)'#010+
+  'P*2Wi_Use internal resources (Darwin)'#010+
   'p*2Wi_Use internal resources (Darwin)'#010+
-  '3*2WN_Do not generate relocation code, needed for debugging (Windows)'#010+
+  '3*2WN_Do not generate r','elocation code, needed for debugging (Windows'+
+  ')'#010+
   'A*2WN_Do not generate relocation code, needed for debugging (Windows)'#010+
-  '3*2WR_Generate relocation co','de (Windows)'#010+
+  '3*2WR_Generate relocation code (Windows)'#010+
   'A*2WR_Generate relocation code (Windows)'#010+
-  'P*2WT_Specify MPW tool type application (Classic Mac OS)'#010+
+  'P*2WT_Specify MPW tool type application (','Classic Mac OS)'#010+
   '3*2WX_Enable executable stack (Linux)'#010+
   'A*2WX_Enable executable stack (Linux)'#010+
   'p*2WX_Enable executable stack (Linux)'#010+
-  'P*2WX_Enable ex','ecutable stack (Linux)'#010+
+  'P*2WX_Enable executable stack (Linux)'#010+
   '**1X_Executable options:'#010+
-  '**2Xc_Pass --shared/-dynamic to the linker (BeOS, Darwin, FreeBSD, Lin'+
-  'ux)'#010+
+  '**2Xc_Pass --shared/-dynamic to the linker (BeO','S, Darwin, FreeBSD, L'+
+  'inux)'#010+
   '**2Xd_Do not use standard library search path (needed for cross compil'+
   'e)'#010+
   '**2Xe_Use external linker'#010+
-  '**2Xg_Create debugi','nfo in a separate file and add a debuglink sectio'+
-  'n to executable'#010+
-  '**2XD_Try to link units dynamically      (defines FPC_LINK_DYNAMIC)'#010+
+  '**2Xg_Create debuginfo in a separate file and add a debuglink section '+
+  'to executable'#010+
+  '**2XD_Try to link units dynami','cally      (defines FPC_LINK_DYNAMIC)'#010+
   '**2Xi_Use internal linker'#010+
   '**2Xm_Generate link map'#010+
-  '**2XM<x>_Set the name of the '#039'main'#039' program routine (defa','ult'+
-  ' is '#039'main'#039')'#010+
+  '**2XM<x>_Set the name of the '#039'main'#039' program routine (default i'+
+  's '#039'main'#039')'#010+
   '**2XP<x>_Prepend the binutils names with the prefix <x>'#010+
-  '**2Xr<x>_Set the linker'#039's rlink-path to <x> (needed for cross comp'+
-  'ile, see the ld manual for more information) (BeOS, Linux)'#010+
-  '**2XR<x>_Prepend <x> to all linker search pa','ths (BeOS, Darwin, FreeB'+
-  'SD, Linux, Mac OS, Solaris)'#010+
+  '**2Xr<x>_Set the linker'#039,'s rlink-path to <x> (needed for cross com'+
+  'pile, see the ld manual for more information) (BeOS, Linux)'#010+
+  '**2XR<x>_Prepend <x> to all linker search paths (BeOS, Darwin, FreeBSD'+
+  ', Linux, Mac OS, Solaris)'#010+
   '**2Xs_Strip all symbols from executable'#010+
-  '**2XS_Try to link units statically (default, defines FPC_LINK_STATIC)'#010+
+  '**2','XS_Try to link units statically (default, defines FPC_LINK_STATIC'+
+  ')'#010+
   '**2Xt_Link with static libraries (-static is passed to linker)'#010+
-  '**2XX_Try to sm','artlink units             (defines FPC_LINK_SMART)'#010+
+  '**2XX_Try to smartlink units             (defines FPC_LINK_SMART)'#010+
   '**1*_'#010+
   '**1?_Show this help'#010+
-  '**1h_Shows this help without waiting'
+  '**1h_Shows this he','lp without waiting'
 );

compiler/ncon.pas

@@ -191,6 +191,7 @@ interface
 
     { some helper routines }
     function get_ordinal_value(p : tnode) : TConstExprInt;
+    function get_string_value(p : tnode; is_wide : boolean = false) : TConstString;
     function is_constresourcestringnode(p : tnode) : boolean;
     function is_emptyset(p : tnode):boolean;
     function genconstsymtree(p : tconstsym) : tnode;
@@ -199,7 +200,7 @@ implementation
 
     uses
       cutils,
-      verbose,systems,
+      verbose,systems,sysutils,
       defutil,
       cpubase,cgbase,
       nld;
@@ -236,6 +237,73 @@ implementation
           Message(type_e_constant_expr_expected);
       end;
 
+    function get_string_value(p : tnode; is_wide : boolean) : TConstString;
+      var
+        pCharVal: pchar;
+        stringVal: string;
+        pWideStringVal: pcompilerwidestring;
+        ordValRecord: TConstExprInt;
+      begin
+        get_string_value := '';
+        if is_conststring_or_constcharnode(p) then
+          begin
+            if is_constcharnode(p) or is_constwidecharnode(p) then
+              begin
+                { if we have case like 'aa'..'b' the right part will never be ordinal }
+                { but in case 'a' it will go here }
+                ordValRecord := tordconstnode(p).value;
+                if (not is_wide) then
+                  begin
+                    if ordValRecord.signed then
+                      stringVal := char(ordValRecord.svalue) + ''#0
+                    else
+                      stringVal := char(ordValRecord.uvalue) + ''#0;
+                    getmem(pCharVal, length(stringVal));
+                    strpcopy(pCharVal, stringVal);
+                    get_string_value := pCharVal;
+                  end
+                else
+                  begin
+                    initwidestring(pWideStringVal);
+                    if ordValRecord.signed then
+                      concatwidestringchar(pWideStringVal, tcompilerwidechar(ordValRecord.svalue))
+                    else
+                      concatwidestringchar(pWideStringVal, tcompilerwidechar(ordValRecord.uvalue));
+                    get_string_value := TConstString(pWideStringVal);
+                  end;
+              end
+            else
+              begin
+                if is_wide then
+                  begin
+                    if (tstringconstnode(p).cst_type in [cst_widestring, cst_unicodestring]) then
+                      get_string_value := tstringconstnode(p).value_str
+                    else
+                      { if string must be wide, but actually was parsed as usual }
+                      begin
+                        initwidestring(pWideStringVal);
+                        ascii2unicode(tstringconstnode(p).value_str, tstringconstnode(p).len, pWideStringVal);
+                        get_string_value := TConstString(pWideStringVal);
+                      end;
+                  end
+                else
+                  begin
+                    if (tstringconstnode(p).cst_type in [cst_widestring, cst_unicodestring]) then
+                      { string is wide but it must be usual }
+                      begin
+                        getmem(pCharVal, pcompilerwidestring(tstringconstnode(p).value_str)^.len + 1);
+                        unicode2ascii(pcompilerwidestring(tstringconstnode(p).value_str), pCharVal);
+                        pCharVal[pcompilerwidestring(tstringconstnode(p).value_str)^.len] := #0;
+                        get_string_value := pCharVal;
+                      end
+                    else
+                      get_string_value := tstringconstnode(p).value_str;
+                  end;
+              end;
+          end
+        else
+          Message(type_e_string_expr_expected);
+      end;
 
     function is_constresourcestringnode(p : tnode) : boolean;
       begin

compiler/node.pas

@@ -477,6 +477,9 @@ interface
     function is_constenumnode(p : tnode) : boolean;
     function is_constwidecharnode(p : tnode) : boolean;
     function is_constpointernode(p : tnode) : boolean;
+    function is_conststringnode(p : tnode) : boolean;
+    function is_constwidestringnode(p : tnode) : boolean;
+    function is_conststring_or_constcharnode(p : tnode) : boolean;
 
 
 implementation
@@ -693,6 +696,25 @@ implementation
          is_constpointernode:=(p.nodetype=pointerconstn);
       end;
 
+    function is_conststringnode(p : tnode) : boolean;
+      begin
+         is_conststringnode :=
+           (p.nodetype = stringconstn) and is_chararray(p.resultdef);
+      end;
+
+    function is_constwidestringnode(p : tnode) : boolean;
+      begin
+         is_constwidestringnode :=
+           (p.nodetype = stringconstn) and is_widechararray(p.resultdef);
+      end;
+
+    function is_conststring_or_constcharnode(p : tnode) : boolean;
+      begin
+        is_conststring_or_constcharnode :=
+          is_conststringnode(p) or is_constcharnode(p) or
+          is_constwidestringnode(p) or is_constwidecharnode(p);
+      end;
+
 
 {****************************************************************************
                                  TNODE

compiler/nset.pas

@@ -28,19 +28,32 @@ interface
     uses
        cclasses,constexp,
        node,globtype,globals,
-       aasmbase,aasmtai,aasmdata,symtype;
+       aasmbase,aasmtai,aasmdata,ncon,symtype,strings;
 
     type
+       TLabelType = (ltOrdinal, ltConstString);
+
        pcaselabel = ^tcaselabel;
        tcaselabel = record
-          { range }
-          _low,
-          _high   : TConstExprInt;
           { unique blockid }
           blockid : longint;
           { left and right tree node }
           less,
           greater : pcaselabel;
+
+          { range type }
+          case label_type : TLabelType of
+            ltOrdinal:
+            (
+              _low,
+              _high       : TConstExprInt;
+            );
+            ltConstString:
+            (
+              _low_str,
+              _high_str   : TConstString;
+              _str_type   : TConstStringType;
+            );
        end;
 
        pcaseblock = ^tcaseblock;
@@ -88,7 +101,8 @@ interface
           function pass_typecheck:tnode;override;
           function pass_1 : tnode;override;
           function docompare(p: tnode): boolean; override;
-          procedure addlabel(blockid:longint;l,h : TConstExprInt);
+          procedure addlabel(blockid:longint;l,h : TConstExprInt); overload;
+          procedure addlabel(blockid:longint;l,h : TConstString; str_type : TConstStringType); overload;
           procedure addblock(blockid:longint;instr:tnode);
           procedure addelseblock(instr:tnode);
        end;
@@ -115,7 +129,8 @@ implementation
       verbose,
       symconst,symdef,symsym,symtable,defutil,defcmp,
       htypechk,pass_1,
-      nbas,ncnv,ncon,nld,nflw,cgobj,cgbase;
+      nadd,nbas,ncnv,nld,nflw,cgobj,cgbase,
+      widestr;
 
 
 {*****************************************************************************
@@ -353,8 +368,19 @@ implementation
 *****************************************************************************}
 
     constructor trangenode.create(l,r : tnode);
+      var
+        value: string;
 
       begin
+         { if right is char and left is string then }
+         { right should be treated as one-symbol string }
+         if is_conststringnode(l) and is_constcharnode(r) then
+           begin
+             value := char(tordconstnode(r).value.uvalue) + ''#0;
+             r.free;
+             r := cstringconstnode.createstr(value);
+             do_typecheckpass(r);
+           end;
          inherited create(rangen,l,r);
       end;
 
@@ -446,6 +472,19 @@ implementation
            deletecaselabels(p^.greater);
          if assigned(p^.less) then
            deletecaselabels(p^.less);
+         if (p^.label_type = ltConstString) then
+           begin
+             if (p^._str_type in [cst_widestring, cst_unicodestring]) then
+               begin
+                 donewidestring(pcompilerwidestring(p^._low_str));
+                 donewidestring(pcompilerwidestring(p^._high_str));
+               end
+             else
+               begin
+                 freemem(p^._low_str);
+                 freemem(p^._high_str);
+               end;
+           end;
          dispose(p);
       end;
 
@@ -457,6 +496,27 @@ implementation
       begin
          new(n);
          n^:=p^;
+         if (p^.label_type = ltConstString) then
+           begin
+             if (p^._str_type in [cst_widestring, cst_unicodestring]) then
+               begin
+                 initwidestring(pcompilerwidestring(n^._low_str));
+                 initwidestring(pcompilerwidestring(n^._high_str));
+                 copywidestring(
+                   pcompilerwidestring(p^._low_str), pcompilerwidestring(n^._low_str));
+                 copywidestring(
+                   pcompilerwidestring(p^._high_str), pcompilerwidestring(n^._high_str));
+               end
+             else
+               begin
+                 getmem(n^._low_str, strlen(p^._low_str) + 1);
+                 strcopy(n^._low_str, p^._low_str);
+                 n^._low_str[strlen(p^._low_str)] := #0;
+                 getmem(n^._high_str, strlen(p^._high_str) + 1);
+                 strcopy(n^._high_str, p^._high_str);
+                 n^._high_str[strlen(p^._high_str)] := #0;
+               end;
+           end;
          if assigned(p^.greater) then
            n^.greater:=copycaselabel(p^.greater);
          if assigned(p^.less) then
@@ -466,11 +526,42 @@ implementation
 
 
     procedure ppuwritecaselabel(ppufile:tcompilerppufile;p : pcaselabel);
+
+      procedure ppuwritestring(str_type : tconststringtype; value : pchar);
+
+        var
+          len : integer;
+        begin
+          if str_type in [cst_widestring, cst_unicodestring] then
+            begin
+              len := pcompilerwidestring(value)^.len;
+              ppufile.putlongint(len);
+              ppufile.putdata(pcompilerwidestring(value)^.data, len * sizeof(tcompilerwidechar));
+            end
+          else
+            begin
+              len := strlen(value);
+              ppufile.putlongint(len);
+              ppufile.putdata(value^, len);
+            end;
+        end;
+
       var
         b : byte;
       begin
-        ppufile.putexprint(p^._low);
-        ppufile.putexprint(p^._high);
+        ppufile.putbyte(byte(p^.label_type = ltConstString));
+        if (p^.label_type = ltConstString) then
+          begin
+            ppufile.putbyte(byte(p^._str_type));
+            ppuwritestring(p^._str_type, p^._low_str);
+            ppuwritestring(p^._str_type, p^._high_str);
+          end
+        else
+          begin
+            ppufile.putexprint(p^._low);
+            ppufile.putexprint(p^._high);
+          end;
+
         ppufile.putlongint(p^.blockid);
         b:=0;
         if assigned(p^.greater) then
@@ -486,13 +577,50 @@ implementation
 
 
     function ppuloadcaselabel(ppufile:tcompilerppufile):pcaselabel;
+
+      procedure ppuloadstring(str_type : tconststringtype; out value : pchar);
+
+        var
+          pw : pcompilerwidestring;
+          len : integer;
+        begin
+          len := ppufile.getlongint;
+          if str_type in [cst_widestring, cst_unicodestring] then
+            begin
+              initwidestring(pw);
+              setlengthwidestring(pw, len);
+              ppufile.getdata(pw^.data, pw^.len * sizeof(tcompilerwidechar));
+              pcompilerwidestring(value) := pw
+            end
+          else
+            begin
+              getmem(value, len + 1);
+              ppufile.getdata(value^, len);
+              value[len] := #0;
+            end;
+        end;
+
       var
         b : byte;
         p : pcaselabel;
       begin
         new(p);
-        p^._low:=ppufile.getexprint;
-        p^._high:=ppufile.getexprint;
+        if boolean(ppufile.getbyte) then
+          begin
+            p^.label_type := ltConstString;
+            p^._str_type := tconststringtype(ppufile.getbyte);
+
+            ppuloadstring(p^._str_type, p^._low_str);
+            ppuloadstring(p^._str_type, p^._high_str);
+          end
+        else
+          begin
+            p^.label_type := ltOrdinal;
+
+            p^._low:=ppufile.getexprint;
+            p^._high:=ppufile.getexprint;
+          end;
+
         p^.blockid:=ppufile.getlongint;
         b:=ppufile.getbyte;
         if (b and 1)=1 then
@@ -599,10 +727,90 @@ implementation
     function tcasenode.pass_1 : tnode;
       var
          i  : integer;
-         node_thenblock,node_elseblock : tnode;
+         node_thenblock,node_elseblock,if_node : tnode;
+         tempcaseexpr : ttempcreatenode;
+         if_block, init_block : tblocknode;
+         stmt : tstatementnode;
+
+      function makeifblock(const labtree : pcaselabel; prevconditblock : tnode): tnode;
+        var
+          condit : tnode;
+        begin
+          result := nil;
+          if assigned(labtree^.less) then
+            result := makeifblock(labtree^.less, prevconditblock)
+          else
+            result := prevconditblock;
+          prevconditblock := nil;
+
+          if (labtree^._str_type in [cst_widestring, cst_unicodestring]) then
+            begin
+              condit := caddnode.create(
+                equaln, left.getcopy,
+                cstringconstnode.createwstr(pcompilerwidestring(labtree^._low_str)));
+ 
+              if (
+                comparewidestrings(
+                  pcompilerwidestring(labtree^._low_str),
+                  pcompilerwidestring(labtree^._high_str)) <> 0) then
+                begin
+                  condit.nodetype := gten;
+                  condit := caddnode.create(
+                    andn, condit, caddnode.create(
+                      lten, left.getcopy, cstringconstnode.createwstr(
+                        pcompilerwidestring(labtree^._high_str))));
+                end;
+            end
+          else
+            begin
+              condit := caddnode.create(
+                equaln, left.getcopy, cstringconstnode.createstr(labtree^._low_str));
+
+              if (strcomp(labtree^._low_str, labtree^._high_str) <> 0) then
+                begin
+                  condit.nodetype := gten;
+                  condit := caddnode.create(
+                    andn, condit, caddnode.create(
+                      lten, left.getcopy, cstringconstnode.createstr(labtree^._high_str)));
+                end;
+            end;
+          
+          result :=
+            cifnode.create(
+              condit, pcaseblock(blocks[labtree^.blockid])^.statement, result);
+          pcaseblock(blocks[labtree^.blockid])^.statement := nil;
+
+          if assigned(labtree^.greater) then
+            result := makeifblock(labtree^.greater, result);
+
+          typecheckpass(result);
+        end;
+
       begin
          result:=nil;
+         init_block:=nil;
          expectloc:=LOC_VOID;
+
+         { Load caseexpr into temp var if complex. }
+         { No need to do this for ordinal, because }
+         { in that case caseexpr is generated once }
+         if (labels^.label_type = ltConstString) and (not valid_for_addr(left, false)) then
+           begin
+             init_block := internalstatements(stmt);
+             tempcaseexpr :=
+               ctempcreatenode.create(
+                 left.resultdef, left.resultdef.size, tt_persistent, true);
+             typecheckpass(tnode(tempcaseexpr));
+
+             addstatement(stmt, tempcaseexpr);
+             addstatement(
+               stmt, cassignmentnode.create(
+                 ctemprefnode.create(tempcaseexpr), left));
+
+             left := ctemprefnode.create(tempcaseexpr);
+             typecheckpass(left);
+           end;
+
          { evalutes the case expression }
          firstpass(left);
          set_varstate(left,vs_read,[vsf_must_be_valid]);
@@ -633,6 +841,24 @@ implementation
                exit;
              end;
 
+         if (labels^.label_type = ltConstString) then
+           begin
+             if_node := makeifblock(labels, elseblock);
+             if assigned(init_block) then
+               begin
+                 firstpass(tnode(init_block));
+                 if_block := internalstatements(stmt);
+                 addstatement(stmt, init_block);
+                 addstatement(stmt, if_node);
+                 result := if_block;
+               end
+             else
+               result := if_node;
+             init_block := nil;
+             elseblock := nil;
+             exit;
+           end;
+
          if is_boolean(left.resultdef) then
            begin
              case blocks.count of
@@ -712,7 +938,7 @@ implementation
                end;
            end
          else
-           n.labels:=nil;
+           n.blocks:=nil;
          dogetcopy:=n;
       end;
 
@@ -826,11 +1052,69 @@ implementation
         new(hcaselabel);
         fillchar(hcaselabel^,sizeof(tcaselabel),0);
         hcaselabel^.blockid:=blockid;
+        hcaselabel^.label_type:=ltOrdinal;
         hcaselabel^._low:=l;
         hcaselabel^._high:=h;
         insertlabel(labels);
       end;
 
+    procedure tcasenode.addlabel(blockid : longint; l, h : TConstString; str_type : TConstStringType);
+
+      function str_compare(l, h : TConstString) : longint;
+        begin
+          if (str_type in [cst_widestring, cst_unicodestring]) then
+            result := comparewidestrings(pcompilerwidestring(l), pcompilerwidestring(h))
+          else
+            result := strcomp(l, h);
+        end;
+
+      var
+        hcaselabel : pcaselabel;
+
+      function insertlabel(var p : pcaselabel) : pcaselabel;
+        begin
+          if not assigned(p) then
+            begin
+              p := hcaselabel;
+              result := p;
+            end
+          else
+            if (str_compare(p^._low_str, hcaselabel^._high_str) > 0) then
+              result := insertlabel(p^.less)
+          else
+            if (str_compare(p^._high_str, hcaselabel^._low_str) < 0) then
+              result := insertlabel(p^.greater)
+          else
+            Message(parser_e_double_caselabel);
+        end;
+
+      begin
+        new(hcaselabel);
+        fillchar(hcaselabel^, sizeof(tcaselabel), 0);
+        hcaselabel^.blockid := blockid;
+        hcaselabel^.label_type := ltConstString;
+
+        if (str_type in [cst_widestring, cst_unicodestring]) then
+          begin
+            initwidestring(pcompilerwidestring(hcaselabel^._low_str));
+            initwidestring(pcompilerwidestring(hcaselabel^._high_str));
+            copywidestring(pcompilerwidestring(l), pcompilerwidestring(hcaselabel^._low_str));
+            copywidestring(pcompilerwidestring(h), pcompilerwidestring(hcaselabel^._high_str));
+          end
+        else
+          begin
+            getmem(hcaselabel^._low_str, strlen(l) + 1);
+            getmem(hcaselabel^._high_str, strlen(h) + 1);
+            strcopy(hcaselabel^._low_str, l);
+            strcopy(hcaselabel^._high_str, h);
+            hcaselabel^._low_str[strlen(l)] := #0;
+            hcaselabel^._high_str[strlen(h)] := #0;
+          end;
+
+        hcaselabel^._str_type := str_type;
+        insertlabel(labels);
+      end;
+
 begin
    csetelementnode:=tsetelementnode;
    cinnode:=tinnode;

compiler/options.pas

@@ -51,6 +51,7 @@ Type
     procedure WriteQuickInfo;
     procedure IllegalPara(const opt:string);
     procedure UnsupportedPara(const opt:string);
+    procedure IgnoredPara(const opt:string);
     function  Unsetbool(var Opts:TCmdStr; Pos: Longint):boolean;
     procedure interpret_option(const opt :string;ispara:boolean);
     procedure Interpret_envvar(const envname : string);
@@ -120,6 +121,10 @@ const
                         + [system_i386_freebsd]
                         + [system_i386_netbsd]
                         + [system_i386_wdosx];
+                        
+  suppported_targets_x_smallr = system_linux
+                             + [system_i386_haiku]
+                             + [system_i386_beos];
 
 {****************************************************************************
                                  Defines
@@ -447,6 +452,12 @@ begin
 end;
 
 
+procedure toption.IgnoredPara(const opt: string);
+begin
+  Message1(option_ignored_target,opt);
+end;
+
+
 procedure toption.ForceStaticLinking;
 begin
   def_system_macro('FPC_LINK_STATIC');
@@ -1617,9 +1628,14 @@ begin
                     'p' : ; { Ignore used by fpc.pp }
                     'r' :
                       begin
-                        rlinkpath:=Copy(more,2,length(More)-1);
-                        DefaultReplacements(rlinkpath);
-                        More:='';
+                        if (target_info.system in suppported_targets_x_smallr) then
+                          begin
+                            rlinkpath:=Copy(more,2,length(More)-1);
+                            DefaultReplacements(rlinkpath);
+                          end
+                        else
+                          IgnoredPara('-Xr');
+                        more:='';
                       end;
                     'R' :
                       begin

compiler/pdecsub.pas

@@ -106,14 +106,16 @@ implementation
 
 {$if defined(i386)}
            { For left to right add it at the end to be delphi compatible }
-           if pd.proccalloption in (pushleftright_pocalls+[pocall_safecall])  then
+           if (target_info.system in system_all_windows) and
+              (pd.proccalloption in (pushleftright_pocalls+[pocall_safecall])) then
              paranr:=paranr_result_leftright
            else
 {$elseif defined(x86) or defined(arm)}
            { other platforms don't have a "safecall" convention,
              and never reverse the parameter pushing order
            }
-           if (pd.proccalloption = pocall_safecall)  then
+           if (target_info.system in system_all_windows) and
+              (pd.proccalloption = pocall_safecall)  then
              paranr:=paranr_result_leftright
            else
 {$endif}

compiler/pstatmnt.pas

@@ -42,7 +42,7 @@ implementation
        cutils,cclasses,
        { global }
        globtype,globals,verbose,constexp,
-       systems,
+       strings,systems,
        { aasm }
        cpubase,aasmbase,aasmtai,aasmdata,
        { symtable }
@@ -57,7 +57,9 @@ implementation
        { codegen }
        procinfo,cgbase,
        { assembler reader }
-       rabase
+       rabase,
+       { wide- and unicodestrings}
+       widestr
        ;
 
 
@@ -113,12 +115,17 @@ implementation
 
 
     function case_statement : tnode;
+      const
+        st2cst : array[tstringtype] of tconststringtype = (
+          cst_shortstring,cst_longstring,cst_ansistring,
+          cst_widestring,cst_unicodestring);
       var
          casedef : tdef;
          caseexpr,p : tnode;
          blockid : longint;
          hl1,hl2 : TConstExprInt;
-         casedeferror : boolean;
+         sl1,sl2 : TConstString;
+         casedeferror, caseofstring : boolean;
          casenode : tcasenode;
       begin
          consume(_CASE);
@@ -134,10 +141,16 @@ implementation
          set_varstate(caseexpr,vs_read,[vsf_must_be_valid]);
          casedeferror:=false;
          casedef:=caseexpr.resultdef;
+         { case of string must be rejected in delphi-, }
+         { tp7/bp7-, mac-compatibility modes.          }
+         caseofstring :=
+           ([m_delphi, m_mac, m_tp7] * current_settings.modeswitches = []) and
+           is_string(casedef);
+
          if (not assigned(casedef)) or
-            not(is_ordinal(casedef)) then
+            ( not(is_ordinal(casedef)) and (not caseofstring) ) then
           begin
-            CGMessage(type_e_ordinal_expr_expected);
+            CGMessage(type_e_ordinal_or_string_expr_expected);
             { create a correct tree }
             caseexpr.free;
             caseexpr:=cordconstnode.create(0,u32inttype,false);
@@ -168,14 +181,29 @@ implementation
                        do_typecheckpass(p);
                     end;
                end;
-
              hl1:=0;
              hl2:=0;
+             sl1:='';
+             sl2:='';
              if (p.nodetype=rangen) then
                begin
-                  { type checking for case statements }
-                  if is_subequal(casedef, trangenode(p).left.resultdef) and
-                     is_subequal(casedef, trangenode(p).right.resultdef) then
+                  { type check for string case statements }
+                  if caseofstring and
+                    is_conststring_or_constcharnode(trangenode(p).left) and
+                    is_conststring_or_constcharnode(trangenode(p).right) then
+                  begin
+                    sl1 := get_string_value(trangenode(p).left, is_wide_or_unicode_string(casedef));
+                    sl2 := get_string_value(trangenode(p).right, is_wide_or_unicode_string(casedef));
+                    if (
+                      (is_wide_or_unicode_string(casedef) and (
+                        comparewidestrings(pcompilerwidestring(sl1), pcompilerwidestring(sl2)) > 0)) or
+                      ((not is_wide_or_unicode_string(casedef)) and (strcomp(sl1, sl2) > 0))) then
+                      CGMessage(parser_e_case_lower_less_than_upper_bound);
+                  end
+                  { type checking for ordinal case statements }
+                  else if (not caseofstring) and
+                    is_subequal(casedef, trangenode(p).left.resultdef) and
+                    is_subequal(casedef, trangenode(p).right.resultdef) then
                     begin
                       hl1:=get_ordinal_value(trangenode(p).left);
                       hl2:=get_ordinal_value(trangenode(p).right);
@@ -189,17 +217,30 @@ implementation
                     end
                   else
                     CGMessage(parser_e_case_mismatch);
-                  casenode.addlabel(blockid,hl1,hl2);
+
+                  if caseofstring then
+                    casenode.addlabel(blockid,sl1,sl2,st2cst[tstringdef(casedef).stringtype])
+                  else
+                    casenode.addlabel(blockid,hl1,hl2);
                end
              else
-               begin
-                  { type checking for case statements }
-                  if not is_subequal(casedef, p.resultdef) then
+               begin                
+                  { type check for string case statements }
+                  if (caseofstring and (not is_conststring_or_constcharnode(p))) or
+                  { type checking for ordinal case statements }
+                    ((not caseofstring) and (not is_subequal(casedef, p.resultdef))) then
                     CGMessage(parser_e_case_mismatch);
-                  hl1:=get_ordinal_value(p);
-                  if not casedeferror then
-                    testrange(casedef,hl1,false);
-                  casenode.addlabel(blockid,hl1,hl1);
+                  
+                  if caseofstring then begin
+                    sl1:=get_string_value(p, is_wide_or_unicode_string(casedef));
+                    casenode.addlabel(blockid,sl1,sl1,st2cst[tstringdef(casedef).stringtype]);
+                  end
+                  else begin
+                    hl1:=get_ordinal_value(p);
+                    if not casedeferror then
+                      testrange(casedef,hl1,false);
+                    casenode.addlabel(blockid,hl1,hl1);
+                  end;
                end;
              p.free;
              if token=_COMMA then

compiler/systems/i_gba.pas

@@ -34,8 +34,8 @@ unit i_gba;
             system       : system_arm_gba;
             name         : 'GameBoy Advance';
             shortname    : 'gba';
-            flags        : [tf_needs_symbol_size,tf_files_case_sensitive,tf_use_function_relative_addresses
-	                          ,tf_smartlink_sections,tf_requires_proper_alignment];
+            flags        : [tf_needs_symbol_size,tf_files_case_sensitive,
+                            tf_use_function_relative_addresses,tf_requires_proper_alignment,tf_smartlink_sections];
             cpu          : cpu_arm;
             unit_env     : '';
             extradefines : '';
@@ -88,7 +88,7 @@ unit i_gba;
               );
             first_parm_offset : 8;
             stacksize    : 16384;
-            abi : abi_default
+            abi : abi_eabi
           );
 
   implementation

compiler/systems/i_nds.pas

@@ -1,5 +1,5 @@
 {
-    This unit implements support information structures for GameBoy Advance
+    This unit implements support information structures for Nintendo DS
 
     Copyright (c) 1998-2002 by Peter Vreman
 
@@ -34,8 +34,8 @@ unit i_nds;
             system       : system_arm_nds;
             name         : 'Nintendo DS';
             shortname    : 'nds';
-            flags        : [tf_needs_symbol_size,tf_files_case_sensitive,tf_use_function_relative_addresses
-                           ,tf_requires_proper_alignment,tf_smartlink_sections];
+            flags        : [tf_needs_symbol_size,tf_files_case_sensitive,
+                            tf_use_function_relative_addresses,tf_requires_proper_alignment,tf_smartlink_sections];
             cpu          : cpu_arm;
             unit_env     : '';
             extradefines : '';
@@ -88,7 +88,7 @@ unit i_nds;
               );
             first_parm_offset : 8;
             stacksize    : $3CFF; //15615? or 16384?;
-            abi : abi_default
+            abi : abi_eabi
           );
 
   implementation

compiler/systems/t_bsd.pas

@@ -161,14 +161,14 @@ begin
                On 64bit systems, page zero is 4GB by default, so no problems
                there.
              }
-             ExeCmd[1]:='ld $PRTOBJ $OPT $DYNLINK $STATIC $GCSECTIONS $STRIP -pagezero_size 0x10000 -no_dead_strip_inits_and_terms -multiply_defined suppress -L. -o $EXE `cat $RES`';
+             ExeCmd[1]:='ld $PRTOBJ $OPT $DYNLINK $STATIC $GCSECTIONS $STRIP -pagezero_size 0x10000 -multiply_defined suppress -L. -o $EXE `cat $RES`';
 {$else ndef cpu64bitaddr}
-             ExeCmd[1]:='ld $PRTOBJ $OPT $DYNLINK $STATIC $GCSECTIONS $STRIP -no_dead_strip_inits_and_terms -multiply_defined suppress -L. -o $EXE `cat $RES`';
+             ExeCmd[1]:='ld $PRTOBJ $OPT $DYNLINK $STATIC $GCSECTIONS $STRIP -multiply_defined suppress -L. -o $EXE `cat $RES`';
 {$endif ndef cpu64bitaddr}
              if (apptype<>app_bundle) then
-               DllCmd[1]:='libtool $PRTOBJ $OPT -no_dead_strip_inits_and_terms -dynamic -multiply_defined suppress -L. -o $EXE `cat $RES`'
+               DllCmd[1]:='ld $PRTOBJ $OPT -dynamic -dylib -multiply_defined suppress -L. -o $EXE `cat $RES`'
              else
-               DllCmd[1]:='ld $PRTOBJ $OPT -no_dead_strip_inits_and_terms -dynamic -bundle -multiply_defined suppress -L. -o $EXE `cat $RES`'
+               DllCmd[1]:='ld $PRTOBJ $OPT -dynamic -bundle -multiply_defined suppress -L. -o $EXE `cat $RES`'
            end
        end
      else
@@ -232,7 +232,10 @@ begin
             result:='/usr/lib/bundle1.o'
         end
       else
-        result:=''
+        begin
+          if not librarysearchpath.FindFile('dylib1.o',false,result) then
+            result:='/usr/lib/dylib1.o'
+        end;
     end;
 end;    
 
@@ -497,7 +500,7 @@ var
   DynLinkStr : string[60];
   GCSectionsStr,
   StaticStr,
-  StripStr   : string[40];
+  StripStr   : string[63];
   success : boolean;
 begin
   if not(cs_link_nolink in current_settings.globalswitches) then
@@ -528,7 +531,7 @@ begin
     if not(target_info.system in systems_darwin) then
       GCSectionsStr:='--gc-sections'
     else
-      GCSectionsStr:='-dead_strip';
+      GCSectionsStr:='-dead_strip -no_dead_strip_inits_and_terms';
 
    if(not(target_info.system in systems_darwin) and
       (cs_profile in current_settings.moduleswitches)) or

compiler/systems/t_gba.pas

@@ -30,6 +30,7 @@ interface
 implementation
 
     uses
+       aasmbase,
        SysUtils,
        cutils,cfileutl,cclasses,
        globtype,globals,systems,verbose,script,fmodule,i_gba,link;
@@ -554,14 +555,22 @@ var
   StaticStr,
   GCSectionsStr,
   DynLinkStr,
+  MapStr,
   StripStr: string;
 begin
   { for future use }
   StaticStr:='';
   StripStr:='';
   DynLinkStr:='';
-
-  GCSectionsStr:='--gc-sections';
+  MapStr:='';
+
+  if (cs_link_strip in current_settings.globalswitches) and
+     not(cs_link_separate_dbg_file in current_settings.globalswitches) then
+   StripStr:='-s';
+  if (cs_link_map in current_settings.globalswitches) then
+   StripStr:='-Map '+maybequoted(ChangeFileExt(current_module.exefilename^,'.map'));
+  if create_smartlink_sections then
+   GCSectionsStr:='--gc-sections';
   //if not(cs_link_extern in current_settings.globalswitches) then
   if not(cs_link_nolink in current_settings.globalswitches) then
    Message1(exec_i_linking,current_module.exefilename^);
@@ -572,24 +581,15 @@ begin
 { Call linker }
   SplitBinCmd(Info.ExeCmd[1],binstr,cmdstr);
   Replace(cmdstr,'$OPT',Info.ExtraOptions);
-  if not(cs_link_on_target in current_settings.globalswitches) then
-   begin
-    Replace(cmdstr,'$EXE',(maybequoted(ScriptFixFileName(ChangeFileExt(current_module.exefilename^,'.elf')))));
-    Replace(cmdstr,'$RES',(maybequoted(ScriptFixFileName(outputexedir+Info.ResName))));
-    Replace(cmdstr,'$STATIC',StaticStr);
-    Replace(cmdstr,'$STRIP',StripStr);
-    Replace(cmdstr,'$GCSECTIONS',GCSectionsStr);
-    Replace(cmdstr,'$DYNLINK',DynLinkStr);
-   end
-  else
-   begin
-    Replace(cmdstr,'$EXE',maybequoted(ScriptFixFileName(ChangeFileExt(current_module.exefilename^,'.elf'))));
-    Replace(cmdstr,'$RES',maybequoted(ScriptFixFileName(outputexedir+Info.ResName)));
-    Replace(cmdstr,'$STATIC',StaticStr);
-    Replace(cmdstr,'$STRIP',StripStr);
-    Replace(cmdstr,'$GCSECTIONS',GCSectionsStr);
-    Replace(cmdstr,'$DYNLINK',DynLinkStr);
-   end;
+
+  Replace(cmdstr,'$EXE',(maybequoted(ScriptFixFileName(ChangeFileExt(current_module.exefilename^,'.elf')))));
+  Replace(cmdstr,'$RES',(maybequoted(ScriptFixFileName(outputexedir+Info.ResName))));
+  Replace(cmdstr,'$STATIC',StaticStr);
+  Replace(cmdstr,'$STRIP',StripStr);
+  Replace(cmdstr,'$GCSECTIONS',GCSectionsStr);
+  Replace(cmdstr,'$MAP',MapStr);
+  Replace(cmdstr,'$DYNLINK',DynLinkStr);
+
   success:=DoExec(FindUtil(utilsprefix+BinStr),cmdstr,true,false);
 
 { Remove ReponseFile }

compiler/systems/t_nds.pas

@@ -1,6 +1,6 @@
 {
     This unit implements support import,export,link routines
-    for the (arm) GameBoy Advance target
+    for the (arm) Nintendo DS target
 
     Copyright (c) 2001-2002 by Peter Vreman
 
@@ -30,6 +30,7 @@ interface
 implementation
 
     uses
+       aasmbase,
        SysUtils,
        cutils,cfileutl,cclasses,
        globtype,globals,systems,verbose,script,fmodule,i_nds,link;
@@ -705,19 +706,27 @@ var
   StaticStr,
   GCSectionsStr,
   DynLinkStr,
+  MapStr,
   StripStr: string;
   preName: string;
 begin
   { for future use }
   StaticStr:='';
   StripStr:='';
+  MapStr:='';
   DynLinkStr:='';
   case apptype of
    app_arm9: preName:='.nef';
    app_arm7: preName:='.nlf';
   end;
 
-  GCSectionsStr:='--gc-sections';
+  if (cs_link_strip in current_settings.globalswitches) and
+     not(cs_link_separate_dbg_file in current_settings.globalswitches) then
+   StripStr:='-s';
+  if (cs_link_map in current_settings.globalswitches) then
+   StripStr:='-Map '+maybequoted(ChangeFileExt(current_module.exefilename^,'.map'));
+  if create_smartlink_sections then
+   GCSectionsStr:='--gc-sections';
   if not(cs_link_nolink in current_settings.globalswitches) then
    Message1(exec_i_linking,current_module.exefilename^);
 
@@ -733,6 +742,7 @@ begin
   Replace(cmdstr,'$STATIC',StaticStr);
   Replace(cmdstr,'$STRIP',StripStr);
   Replace(cmdstr,'$GCSECTIONS',GCSectionsStr);
+  Replace(cmdstr,'$MAP',MapStr);
   Replace(cmdstr,'$DYNLINK',DynLinkStr);
   
   success:=DoExec(FindUtil(utilsprefix+BinStr),cmdstr,true,false);

ide/wchmhwrap.pas

@@ -25,22 +25,31 @@ Type
 
      TChmWrapper = Class
                      private
-                       ffs   : Classes.TFileStream;
-                       fchmr : TChmReader;
-                       findex: TChmSiteMap;
-                       ftopic: TChmSiteMap;
-                       floaded  : boolean;
+                       ffs   	   : Classes.TFileStream;
+                       fchmr 	   : TChmReader;
+                       findex	   : TChmSiteMap;
+                       ftopic	   : TChmSiteMap;
+                       floaded     : boolean;
+                       fileid	   : integer;
+                       fshortname  : string;
+                       flongname   : string;
+                       fTopicLinks : PTopicLinkCollection;
                      public
-                      constructor Create(name:String);
+                      constructor Create(name:String;aid:integer;TopicLinks:PTopicLinkCollection);
                       function	  LoadIndex(id:integer;TopicLinks: PTopicLinkCollection;IndexEntries : PUnsortedIndexEntryCollection;helpfacility:PHelpFacility):boolean;
                       function    GetTopic(name:string):PMemoryTextFile;
                       destructor  Destroy;override;
                     end;
 
 function combinepaths(relpath,basepath:String):String;
+function CHMResolve( href: ansistring; var AFileId,ALinkId : longint):boolean;
 
+function stringreplace(const s:ansistring;const oldstr:ansistring; const newstr:ansistring):ansistring;
 implementation
 
+var CHMIndex : TStringList; // list to register open CHMs.
+
+
 function combinepaths(relpath,basepath:String):String;
 
 begin
@@ -72,27 +81,28 @@ begin
   result:=basepath+relpath;
 end;
 
-
-Constructor TChmWrapper.Create(name:string);
+Constructor TChmWrapper.Create(name:string;aid:integer;TopicLinks:PTopicLinkCollection);
 
 begin
   ffs:=Classes.TFileStream.create(name,fmOpenRead or fmsharedenynone);
   fchmr:=TChmReader.Create(ffs,True); // owns ffs
   findex:=nil;
+  FTopicLinks:=TopicLinks;
   if not fchmr.isvalidfile then
     begin
       freeandnil(fchmr);
       freeandnil(ffs);
       exit;
     end;
+  fileid:=aid;
+  flongname:=name;
+  fshortname:=lowercase(extractfilename(name)); // We assume ms-its: urls are case insensitive wrt filename.
+  chmindex.addobject(fshortname,self);
   {$ifdef wdebug}
-    debugmessageS({$i %file%},'TCHMWrapper: before sitemap creation ',{$i %line%},'1',0,0);
+    debugmessageS({$i %file%},'TCHMWrapper.Create: before sitemap creation '+fshortname+' id='+inttostr(aid),{$i %line%},'1',0,0);
   {$endif}
   findex:=TChmSiteMap.create(stindex);
   ftopic:=TChmSiteMap.create(sttoc);
-  {$ifdef wdebug}
-    debugmessageS({$i %file%},'TCHMWrapper: after sitemap creation ',{$i %line%},'1',0,0);
-  {$endif}
   floaded:=false;
 end;
 
@@ -113,8 +123,8 @@ var
     tli: integer;
 begin
  result:=false;
- if not assigned (fchmr) then exit;
  if floaded then exit;
+ if not assigned (fchmr) then exit;
  {$ifdef wdebug}
      debugmessageS({$i %file%},'TCHMWrapper: indexfilename:'+fchmr.indexfile,{$i %line%},'1',0,0);
  {$endif}
@@ -228,10 +238,18 @@ begin
   end;
 end;
 
-
 destructor TChmWrapper.Destroy;
 
+var i : integer;
 begin
+  i:=chmindex.indexof(fshortname);
+  if i<>-1 then
+    begin
+      chmindex.delete(i);
+      {$ifdef wdebug}
+       debugmessageS({$i %file%},'TCHMWrapper: deregistering '+fshortname,{$i %line%},'1',0,0);
+      {$endif}
+    end;
   freeandnil(ftopic);
   freeandnil(findex);
   freeandnil(fchmr);
@@ -241,4 +259,49 @@ begin
 
 end;
 
+function CHMResolve( href: ansistring; var AFileId,ALinkId : longint):boolean;
+
+var filename, restlink : ansistring;
+    I :integer;
+    chmw: TCHMWrapper;
+begin
+  result:=false;
+  if copy(href,1,7)='ms-its:' then
+    begin
+      {$ifdef wdebug}
+              debugmessageS({$i %file%},'TCHMWrapper: resolving '+href,{$i %line%},'1',0,0);
+      {$endif}
+
+       delete(href,1,7);
+       i:=pos('::',href);
+       if i<>0 then
+         begin
+           filename:=lowercase(copy(href,1,i-1));
+           restlink:=lowercase(copy(href,i+2,length(href)-(I+2)+1));
+           i:=chmindex.indexof(filename);
+           if i<>-1 then
+             begin
+               {$ifdef wdebug}
+                 debugmessageS({$i %file%},'TCHMWrapper: resolving '+filename+' '+inttostr(i),{$i %line%},'1',0,0);
+                 debugmessageS({$i %file%},'TCHMWrapper: resolving '+restlink+' ',{$i %line%},'1',0,0);
+               {$endif}
+               chmw:=TCHMWrapper(chmindex.objects[i]);
+               Afileid:=chmw.fileid;
+               alinkid:=chmw.fTopicLinks.additem(restlink);
+               result:=true;
+            end;    
+         end;
+    end
+end;
+
+function stringreplace(const s:ansistring;const oldstr:ansistring; const newstr:ansistring):ansistring;
+
+begin
+  result:=sysutils.stringreplace(s,oldstr,newstr,[rfreplaceall]);
+end;
+initialization
+  ChmIndex:=TStringlist.create;
+  ChmIndex.sorted:=true;
+finalization
+  ChmIndex.Free;
 end.

ide/whtmlhlp.pas

@@ -111,6 +111,7 @@ type
       procedure DocTableItem(Entered: boolean); virtual;
       procedure DocHorizontalRuler; virtual;
       function CanonicalizeURL(const Base,Relative:String):string; virtual;
+      procedure Resolve( href: ansistring; var AFileId,ALinkId : sw_integer); virtual;
     public
       function  GetSectionColor(Section: THTMLSection; var Color: byte): boolean; virtual;
     private
@@ -133,6 +134,7 @@ type
       CurHeadLevel: integer;
       PAlign: TParagraphAlign;
       LinkIndexes: array[0..MaxTopicLinks] of sw_integer;
+      FileIDLinkIndexes: array[0..MaxTopicLinks] of sw_integer;
       LinkPtr: sw_integer;
       LastTextChar: char;
 {      Anchor: TAnchor;}
@@ -148,6 +150,7 @@ type
     PCHMTopicRenderer = ^TCHMTopicRenderer;
     TCHMTopicRenderer = object(THTMLTopicRenderer)
       function CanonicalizeURL(const Base,Relative:String):string; virtual;
+      procedure Resolve( href: ansistring; var AFileId,ALinkId : sw_integer); virtual;
       end;
 
     PCustomHTMLHelpFile = ^TCustomHTMLHelpFile;
@@ -624,6 +627,7 @@ end;
 
 procedure THTMLTopicRenderer.DocAnchor(Entered: boolean);
 var HRef,Name: string;
+    lfileid,llinkid : sw_integer;
 begin
   if Entered and InAnchor then DocAnchor(false);
   if Entered then
@@ -655,7 +659,9 @@ begin
               if pos('#',HRef)=1 then
                 Href:=NameAndExtOf(GetFilename)+Href;
               HRef:=canonicalizeURL(URL,HRef);
-              LinkIndexes[LinkPtr]:=TopicLinks^.AddItem(HRef);
+              Resolve(Href,lfileid,llinkid);
+              LinkIndexes[LinkPtr]:=llinkid;
+              FileIDLinkIndexes[LinkPtr]:=lfileid;
 {$IFDEF WDEBUG}
               DebugMessageS({$i %file%},' Adding Link2 "'+HRef+'"',{$i %line%},'1',0,0);
 {$ENDIF WDEBUG}
@@ -723,6 +729,16 @@ begin
  CanonicalizeURL:=CompleteURL(Base,relative);
 end;
 
+procedure THTMLTopicRenderer.Resolve( href: ansistring; var AFileId,ALinkId : sw_integer); 
+begin
+{$IFDEF WDEBUG}
+              DebugMessageS({$i %file%},' htmlresolve "'+HRef+'"',{$i %line%},'1',0,0);
+{$ENDIF WDEBUG}
+
+  Afileid:=Topic^.FileId;
+  ALinkId:=TopicLinks^.AddItem(HRef);
+end;
+
 procedure THTMLTopicRenderer.DocParagraph(Entered: boolean);
 var Align: string;
 begin
@@ -1302,10 +1318,10 @@ begin
           for I:=0 to Min(Topic^.LinkCount-1,High(LinkIndexes)-1) do
             begin
               {$IFDEF WDEBUG}
-                DebugMessageS({$i %file%},' Indexing links ('+inttostr(i)+')'+topiclinks^.at(linkindexes[i])^,{$i %line%},'1',0,0);
+                DebugMessageS({$i %file%},' Indexing links ('+inttostr(i)+')'+topiclinks^.at(linkindexes[i])^+' '+inttostr(i)+' '+inttostr(linkindexes[i]),{$i %line%},'1',0,0);
               {$endif WDEBUG}
-              Topic^.Links^[I].FileID:=Topic^.FileID;
-              Topic^.Links^[I].Context:=EncodeHTMLCtx(Topic^.FileID,LinkIndexes[I]+1);
+              Topic^.Links^[I].FileID:=FileIDLinkIndexes[i];
+              Topic^.Links^[I].Context:=EncodeHTMLCtx(FileIDLinkIndexes[i],LinkIndexes[I]+1);
             end;
          {$IFDEF WDEBUG}
           if Topic^.Linkcount>High(linkindexes) then
@@ -1330,12 +1346,39 @@ end;
 
 Function  TCHMTopicRenderer.CanonicalizeURL(const Base,Relative:String):string;
 begin
+ if copy(relative,1,6)='http:/' then // external links don't need to be fixed since we can't load them.
+   begin
+     CanonicalizeUrl:=relative;
+     exit;
+   end;
  if copy(relative,1,7)<>'ms-its:' then
    CanonicalizeUrl:=combinepaths(relative,base)
   else
    CanonicalizeUrl:=relative;
 end;
 
+procedure TCHMTopicRenderer.Resolve( href: ansistring; var AFileId,ALinkId : sw_integer); 
+var resolved:boolean;
+begin
+{$IFDEF WDEBUG}
+  DebugMessageS({$i %file%},' chmresolve "'+HRef+'"',{$i %line%},'1',0,0);
+{$ENDIF WDEBUG}
+  resolved:=false; AFileID:=0; ALinkID:=0;	
+  href:=stringreplace(href,'%20',' '); 
+  if copy(href,1,7)='ms-its:' then
+    resolved:=CHMResolve(Href,AFileId,ALinkID);
+  if not resolved then
+    begin
+    {$IFDEF WDEBUG}
+       DebugMessageS({$i %file%},' chmresolve not resolved "'+HRef+'"',{$i %line%},'1',0,0);
+    {$ENDIF WDEBUG}
+
+      Afileid:=Topic^.FileId;
+      ALinkId:=TopicLinks^.AddItem(HRef);
+    end;
+end;
+
+
 constructor TCustomHTMLHelpFile.Init(AID: word);
 begin
   inherited Init(AID);
@@ -1601,7 +1644,7 @@ begin
     Fail;
   end
   else
-    chmw:=TCHMWrapper.Create(DefaultFileName);
+    chmw:=TCHMWrapper.Create(DefaultFileName,AID,TopicLinks);
 end;
 
 function    TChmHelpFile.LoadIndex: boolean;

packages/Makefile

@@ -280,10 +280,10 @@ ifeq ($(FULL_TARGET),i386-freebsd)
 override TARGET_DIRS+=hash pasjpeg paszlib fpmkunit fcl-xml fcl-base fcl-db fcl-image fcl-net fcl-passrc fcl-registry fcl-fpcunit fcl-json  fcl-process unzip regexpr chm fcl-res libgd symbolic  fv fcl-web fastcgi fcl-async ibase mysql ncurses zlib oracle odbc postgres sqlite pthreads imagemagick gdbint libpng x11 gdbm tcl syslog libcurl opengl cairo  bfd aspell svgalib imlib utmp  fpgtk xforms fftw pcap ggi sdl openssl graph gnome1 gtk1 gtk2 librsvg httpd13 httpd20 httpd22 pxlib numlib users iconvenc
 endif
 ifeq ($(FULL_TARGET),i386-beos)
-override TARGET_DIRS+=hash pasjpeg paszlib fpmkunit fcl-xml fcl-base fcl-db fcl-image fcl-net fcl-passrc fcl-registry fcl-fpcunit fcl-json  fcl-process unzip regexpr chm fcl-res libgd symbolic  fv fcl-web fastcgi fcl-async ibase mysql ncurses zlib oracle odbc postgres sqlite pthreads imagemagick gdbint libpng x11 gdbm tcl syslog libcurl opengl bfd aspell svgalib imlib utmp  fpgtk xforms fftw pcap ggi sdl openssl graph gnome1 gtk1 gtk2 librsvg httpd13 httpd20 httpd22 pxlib numlib iconvenc
+override TARGET_DIRS+=hash pasjpeg paszlib fpmkunit fcl-xml fcl-base fcl-db fcl-image fcl-net fcl-passrc fcl-registry fcl-fpcunit fcl-json  fcl-process unzip regexpr chm fcl-res libgd symbolic  fv fcl-web fastcgi fcl-async ibase mysql ncurses zlib oracle odbc postgres sqlite pthreads imagemagick gdbint libpng x11 gdbm tcl syslog libcurl opengl cairo bfd aspell svgalib imlib utmp  fpgtk xforms fftw pcap ggi sdl openssl graph gnome1 gtk1 gtk2 librsvg httpd13 httpd20 httpd22 pxlib numlib iconvenc
 endif
 ifeq ($(FULL_TARGET),i386-haiku)
-override TARGET_DIRS+=hash pasjpeg paszlib fpmkunit fcl-xml fcl-base fcl-db fcl-image fcl-net fcl-passrc fcl-registry fcl-fpcunit fcl-json  fcl-process unzip regexpr chm fcl-res libgd symbolic  fv fcl-web fastcgi fcl-async ibase mysql ncurses zlib oracle odbc postgres sqlite pthreads imagemagick gdbint libpng x11 gdbm tcl syslog libcurl opengl bfd aspell svgalib imlib utmp  fpgtk xforms fftw pcap ggi sdl openssl graph gnome1 gtk1 gtk2 librsvg httpd13 httpd20 httpd22 pxlib numlib iconvenc
+override TARGET_DIRS+=hash pasjpeg paszlib fpmkunit fcl-xml fcl-base fcl-db fcl-image fcl-net fcl-passrc fcl-registry fcl-fpcunit fcl-json  fcl-process unzip regexpr chm fcl-res libgd symbolic  fv fcl-web fastcgi fcl-async ibase mysql ncurses zlib oracle odbc postgres sqlite pthreads imagemagick gdbint libpng x11 gdbm tcl syslog libcurl opengl cairo bfd aspell svgalib imlib utmp  fpgtk xforms fftw pcap ggi sdl openssl graph gnome1 gtk1 gtk2 librsvg httpd13 httpd20 httpd22 pxlib numlib iconvenc
 endif
 ifeq ($(FULL_TARGET),i386-netbsd)
 override TARGET_DIRS+=hash pasjpeg paszlib fpmkunit fcl-xml fcl-base fcl-db fcl-image fcl-net fcl-passrc fcl-registry fcl-fpcunit fcl-json  fcl-process unzip regexpr chm fcl-res libgd symbolic  fv fcl-web fastcgi fcl-async ibase mysql ncurses zlib oracle odbc postgres sqlite pthreads imagemagick gdbint libpng x11 gdbm tcl syslog libcurl opengl cairo gtk1 gtk2 librsvg bfd aspell svgalib imlib utmp  fpgtk xforms fftw pcap ggi sdl openssl gnome1 httpd13 httpd20 httpd22 pxlib numlib
@@ -1856,6 +1856,7 @@ TARGET_DIRS_TCL=1
 TARGET_DIRS_SYSLOG=1
 TARGET_DIRS_LIBCURL=1
 TARGET_DIRS_OPENGL=1
+TARGET_DIRS_CAIRO=1
 TARGET_DIRS_BFD=1
 TARGET_DIRS_ASPELL=1
 TARGET_DIRS_SVGALIB=1
@@ -1923,6 +1924,7 @@ TARGET_DIRS_TCL=1
 TARGET_DIRS_SYSLOG=1
 TARGET_DIRS_LIBCURL=1
 TARGET_DIRS_OPENGL=1
+TARGET_DIRS_CAIRO=1
 TARGET_DIRS_BFD=1
 TARGET_DIRS_ASPELL=1
 TARGET_DIRS_SVGALIB=1
@@ -8553,14 +8555,14 @@ fcl-db_all: fcl-xml_all mysql_all ibase_all oracle_all odbc_all postgres_all sql
 fcl-db_debug: fcl-xml_debug mysql_debug ibase_debug oracle_debug odbc_debug postgres_debug sqlite_debug pxlib_debug
 fcl-db_smart: fcl-xml_smart mysql_smart ibase_smart oracle_smart odbc_smart postgres_smart sqlite_smart pxlib_smart
 fcl-db_release: fcl-xml_release mysql_release ibase_release oracle_release odbc_release postgres_release sqlite_release pxlib_release
-fcl-db_shared: fcl-xml_shared mysql_shared ibase_shared oracle_shared odbc_shared postgres_shared postgres_release pxlib_shared
+fcl-db_shared: fcl-xml_shared mysql_shared ibase_shared oracle_shared odbc_shared postgres_shared sqlite_shared pxlib_shared
 else
 ifneq ($(findstring $(OS_TARGET),win64 wince solaris darwin),)
 fcl-db_all: fcl-xml_all mysql_all ibase_all oracle_all odbc_all postgres_all sqlite_all
 fcl-db_debug: fcl-xml_debug mysql_debug ibase_debug oracle_debug odbc_debug postgres_debug sqlite_debug
 fcl-db_smart: fcl-xml_smart mysql_smart ibase_smart oracle_smart odbc_smart postgres_smart sqlite_smart
 fcl-db_release: fcl-xml_release mysql_release ibase_release oracle_release odbc_release postgres_release sqlite_release
-fcl-db_shared: fcl-xml_shared mysql_shared ibase_shared oracle_shared odbc_shared postgres_shared postgres_release
+fcl-db_shared: fcl-xml_shared mysql_shared ibase_shared oracle_shared odbc_shared postgres_shared sqlite_shared
 else
 fcl-db_all: fcl-xml_all
 fcl-db_debug: fcl-xml_debug

packages/Makefile.fpc

@@ -14,11 +14,11 @@ dirs_sparc_linux=graph
 dirs_arm_linux=graph
 dirs_m68k_linux=graph
 dirs_beos=fv fcl-web fastcgi fcl-async ibase mysql ncurses zlib oracle odbc postgres sqlite pthreads imagemagick \
-               gdbint libpng x11 gdbm tcl syslog libcurl opengl bfd aspell svgalib \
+               gdbint libpng x11 gdbm tcl syslog libcurl opengl cairo bfd aspell svgalib \
                imlib utmp  fpgtk xforms fftw pcap ggi sdl openssl graph gnome1 gtk1 gtk2 librsvg httpd13 httpd20 httpd22 pxlib numlib \
                iconvenc
 dirs_haiku=fv fcl-web fastcgi fcl-async ibase mysql ncurses zlib oracle odbc postgres sqlite pthreads imagemagick \
-               gdbint libpng x11 gdbm tcl syslog libcurl opengl bfd aspell svgalib \
+               gdbint libpng x11 gdbm tcl syslog libcurl opengl cairo bfd aspell svgalib \
                imlib utmp  fpgtk xforms fftw pcap ggi sdl openssl graph gnome1 gtk1 gtk2 librsvg httpd13 httpd20 httpd22 pxlib numlib \
                iconvenc
 dirs_freebsd=fv fcl-web fastcgi fcl-async ibase mysql ncurses zlib oracle odbc postgres sqlite pthreads imagemagick \
@@ -157,14 +157,14 @@ fcl-db_all: fcl-xml_all mysql_all ibase_all oracle_all odbc_all postgres_all sql
 fcl-db_debug: fcl-xml_debug mysql_debug ibase_debug oracle_debug odbc_debug postgres_debug sqlite_debug pxlib_debug
 fcl-db_smart: fcl-xml_smart mysql_smart ibase_smart oracle_smart odbc_smart postgres_smart sqlite_smart pxlib_smart
 fcl-db_release: fcl-xml_release mysql_release ibase_release oracle_release odbc_release postgres_release sqlite_release pxlib_release
-fcl-db_shared: fcl-xml_shared mysql_shared ibase_shared oracle_shared odbc_shared postgres_shared postgres_release pxlib_shared
+fcl-db_shared: fcl-xml_shared mysql_shared ibase_shared oracle_shared odbc_shared postgres_shared sqlite_shared pxlib_shared
 else
 ifneq ($(findstring $(OS_TARGET),win64 wince solaris darwin),)
 fcl-db_all: fcl-xml_all mysql_all ibase_all oracle_all odbc_all postgres_all sqlite_all
 fcl-db_debug: fcl-xml_debug mysql_debug ibase_debug oracle_debug odbc_debug postgres_debug sqlite_debug
 fcl-db_smart: fcl-xml_smart mysql_smart ibase_smart oracle_smart odbc_smart postgres_smart sqlite_smart
 fcl-db_release: fcl-xml_release mysql_release ibase_release oracle_release odbc_release postgres_release sqlite_release
-fcl-db_shared: fcl-xml_shared mysql_shared ibase_shared oracle_shared odbc_shared postgres_shared postgres_release
+fcl-db_shared: fcl-xml_shared mysql_shared ibase_shared oracle_shared odbc_shared postgres_shared sqlite_shared
 else
 fcl-db_all: fcl-xml_all
 fcl-db_debug: fcl-xml_debug

packages/cairo/Makefile

@@ -1,5 +1,5 @@
 #
-# Don't edit, this file is generated by FPCMake Version 2.0.0 [2009/08/02]
+# Don't edit, this file is generated by FPCMake Version 2.0.0 [2009/08/20]
 #
 default: all
 MAKEFILETARGETS=i386-linux i386-go32v2 i386-win32 i386-os2 i386-freebsd i386-beos i386-haiku i386-netbsd i386-solaris i386-qnx i386-netware i386-openbsd i386-wdosx i386-darwin i386-emx i386-watcom i386-netwlibc i386-wince i386-embedded i386-symbian m68k-linux m68k-freebsd m68k-netbsd m68k-amiga m68k-atari m68k-openbsd m68k-palmos m68k-embedded powerpc-linux powerpc-netbsd powerpc-amiga powerpc-macos powerpc-darwin powerpc-morphos powerpc-embedded sparc-linux sparc-netbsd sparc-solaris sparc-embedded x86_64-linux x86_64-freebsd x86_64-darwin x86_64-win64 x86_64-embedded arm-linux arm-palmos arm-darwin arm-wince arm-gba arm-nds arm-embedded arm-symbian powerpc64-linux powerpc64-darwin powerpc64-embedded avr-embedded armeb-linux armeb-embedded
@@ -282,10 +282,10 @@ ifeq ($(FULL_TARGET),i386-freebsd)
 override TARGET_UNITS+=cairo cairoft  cairoxlib
 endif
 ifeq ($(FULL_TARGET),i386-beos)
-override TARGET_UNITS+=cairo cairoft
+override TARGET_UNITS+=cairo cairoft  cairoxlib
 endif
 ifeq ($(FULL_TARGET),i386-haiku)
-override TARGET_UNITS+=cairo cairoft
+override TARGET_UNITS+=cairo cairoft  cairoxlib
 endif
 ifeq ($(FULL_TARGET),i386-netbsd)
 override TARGET_UNITS+=cairo cairoft  cairoxlib
@@ -1638,6 +1638,7 @@ REQUIRE_PACKAGES_HASH=1
 REQUIRE_PACKAGES_PASZLIB=1
 REQUIRE_PACKAGES_FCL-BASE=1
 REQUIRE_PACKAGES_FCL-IMAGE=1
+REQUIRE_PACKAGES_X11=1
 endif
 ifeq ($(FULL_TARGET),i386-haiku)
 REQUIRE_PACKAGES_RTL=1
@@ -1646,6 +1647,7 @@ REQUIRE_PACKAGES_HASH=1
 REQUIRE_PACKAGES_PASZLIB=1
 REQUIRE_PACKAGES_FCL-BASE=1
 REQUIRE_PACKAGES_FCL-IMAGE=1
+REQUIRE_PACKAGES_X11=1
 endif
 ifeq ($(FULL_TARGET),i386-netbsd)
 REQUIRE_PACKAGES_RTL=1

packages/cairo/Makefile.fpc

@@ -4,6 +4,8 @@
 [require]
 packages=fcl-image
 #packages_win32=
+packages_beos=x11
+packages_haiku=x11
 packages_linux=x11
 packages_freebsd=x11
 packages_netbsd=x11
@@ -18,6 +20,8 @@ version=2.5.1
 [target]
 units=cairo cairoft
 units_win32=cairowin32
+units_beos=cairoxlib
+units_haiku=cairoxlib
 units_linux=cairoxlib
 units_freebsd=cairoxlib
 units_netbsd=cairoxlib

packages/cairo/src/cairo.pp

@@ -63,10 +63,15 @@ const
     {$endif}
   {$ENDIF}
 {$else}
-  {$ifdef UseCustomLibs}
-  LIB_CAIRO = '';
+  {$ifdef darwin}
+    LIB_CAIRO = 'cairo';
+    {$linklib cairo}
   {$else}
-  LIB_CAIRO = 'libcairo.so.2';
+    {$ifdef UseCustomLibs}
+    LIB_CAIRO = '';
+    {$else}
+    LIB_CAIRO = 'libcairo.so.2';
+    {$endif}
   {$endif}
 {$endif}
 

packages/chm/src/chmfilewriter.pas

@@ -41,6 +41,7 @@ type
     FDefaultPage: String;
     FFiles: TStrings;
     FIndexFileName: String;
+    FMakeBinaryTOC: Boolean;
     FMakeSearchable: Boolean;
     FFileName: String;
     FOnProgress: TChmProgressCB;
@@ -64,6 +65,7 @@ type
     property Files: TStrings read FFiles write FFiles;
     property AutoFollowLinks: Boolean read FAutoFollowLinks write FAutoFollowLinks;
     property TableOfContentsFileName: String read FTableOfContentsFileName write FTableOfContentsFileName;
+    property MakeBinaryTOC: Boolean read FMakeBinaryTOC write FMakeBinaryTOC;
     property Title: String read FTitle write FTitle;
     property IndexFileName: String read FIndexFileName write FIndexFileName;
     property MakeSearchable: Boolean read FMakeSearchable write FMakeSearchable;
@@ -75,7 +77,7 @@ type
 
 implementation
 
-uses XmlCfg;
+uses XmlCfg, chmsitemap;
 
 { TChmProject }
 
@@ -98,6 +100,7 @@ var
   IndexStream: TFileStream;
   TOCStream: TFileStream;
   Writer: TChmWriter;
+  TOCSitemap: TChmSiteMap;
 begin
   // Assign the TOC and index files
   Writer := TChmWriter(Sender);
@@ -109,6 +112,14 @@ begin
   if (TableOfContentsFileName <> '') and FileExists(TableOfContentsFileName) then begin
     TOCStream := TFileStream.Create(TableOfContentsFileName, fmOpenRead);
     Writer.AppendTOC(TOCStream);
+    if MakeBinaryTOC then
+    begin
+      TOCStream.Position := 0;
+      TOCSitemap := TChmSiteMap.Create(stTOC);
+      TOCSitemap.LoadFromStream(TOCStream);
+      Writer.AppendBinaryTOCFromSiteMap(TOCSitemap);
+      TOCSitemap.Free;
+    end;
     TOCStream.Free;
   end;
 
@@ -142,6 +153,7 @@ begin
   end;
   IndexFileName := Cfg.GetValue('Files/IndexFile/Value','');
   TableOfContentsFileName := Cfg.GetValue('Files/TOCFile/Value','');
+  MakeBinaryTOC := Cfg.GetValue('Files/MakeBinaryTOC/Value', True);
   
   AutoFollowLinks := Cfg.GetValue('Settings/AutoFollowLinks/Value', False);
   MakeSearchable := Cfg.GetValue('Settings/MakeSearchable/Value', False);
@@ -168,6 +180,7 @@ begin
   end;
   Cfg.SetValue('Files/IndexFile/Value', IndexFileName);
   Cfg.SetValue('Files/TOCFile/Value', TableOfContentsFileName);
+  Cfg.SetValue('Files/MakeBinaryTOC/Value',MakeBinaryTOC);
 
   Cfg.SetValue('Settings/AutoFollowLinks/Value', AutoFollowLinks);
   Cfg.SetValue('Settings/MakeSearchable/Value', MakeSearchable);
@@ -189,6 +202,7 @@ var
   Writer: TChmWriter;
   TOCStream,
   IndexStream: TFileStream;
+
 begin
   IndexStream := nil;
   TOCStream := nil;
@@ -207,6 +221,7 @@ begin
   Writer.Title := Title;
   Writer.DefaultFont := DefaultFont;
   Writer.FullTextSearch := MakeSearchable;
+  Writer.HasBinaryTOC := MakeBinaryTOC;
   
   // and write!
   Writer.Execute;

packages/chm/src/chmreader.pas

@@ -28,7 +28,7 @@ unit chmreader;
 interface
 
 uses
-  Classes, SysUtils, chmbase, paslzx, chmFIftiMain;
+  Classes, SysUtils, chmbase, paslzx, chmFIftiMain, chmsitemap;
   
 type
 
@@ -109,12 +109,14 @@ type
     procedure ReadCommonData;
     function  ReadStringsEntry(APosition: DWord): String;
     function  ReadURLSTR(APosition: DWord): String;
+    function  CheckCommonStreams: Boolean;
   public
     constructor Create(AStream: TStream; FreeStreamOnDestroy: Boolean); override;
     destructor Destroy; override;
   public
     function GetContextUrl(Context: THelpContext): String;
     function LookupTopicByID(ATopicID: Integer; out ATitle: String): String; // returns a url
+    function GetTOCSitemap: TChmSiteMap;
     function HasContextList: Boolean;
     property DefaultPage: String read fDefaultPage;
     property IndexFile: String read fIndexFile;
@@ -164,6 +166,7 @@ const
   function ChmErrorToStr(Error: Integer): String;
 
 implementation
+uses ChmTypes;
 
 function ChmErrorToStr(Error: Integer): String;
 begin
@@ -457,22 +460,31 @@ function TChmReader.ReadURLSTR ( APosition: DWord ) : String;
 var
   URLStrURLOffset: DWord;
 begin
+  if not CheckCommonStreams then
+    Exit;
+
+  fURLTBLStream.Position := APosition;
+  fURLTBLStream.ReadDWord; // unknown
+  fURLTBLStream.ReadDWord; // TOPIC index #
+  fURLSTRStream.Position := LEtoN(fURLTBLStream.ReadDWord);
+  fURLSTRStream.ReadDWord;
+  fURLSTRStream.ReadDWord;
+  if fURLSTRStream.Position < fURLSTRStream.Size-1 then
+    Result := '/'+PChar(fURLSTRStream.Memory+fURLSTRStream.Position);
+end;
+
+function TChmReader.CheckCommonStreams: Boolean;
+begin
+  if fTOPICSStream = nil then
+    fTOPICSStream := GetObject('/#TOPICS');
   if fURLSTRStream = nil then
     fURLSTRStream := GetObject('/#URLSTR');
   if fURLTBLStream = nil then
     fURLTBLStream := GetObject('/#URLTBL');
-  if (fURLTBLStream <> nil) and (fURLSTRStream <> nil) then
-  begin
 
-    fURLTBLStream.Position := APosition;
-    fURLTBLStream.ReadDWord; // unknown
-    fURLTBLStream.ReadDWord; // TOPIC index #
-    fURLSTRStream.Position := LEtoN(fURLTBLStream.ReadDWord);
-    fURLSTRStream.ReadDWord;
-    fURLSTRStream.ReadDWord;
-    if fURLSTRStream.Position < fURLSTRStream.Size-1 then
-      Result := '/'+PChar(fURLSTRStream.Memory+fURLSTRStream.Position);
-  end;
+  Result :=     (fTOPICSStream <> nil)
+            and (fURLSTRStream <> nil)
+            and (fURLTBLStream <> nil);
 end;
 
 constructor TChmReader.Create(AStream: TStream; FreeStreamOnDestroy: Boolean);
@@ -848,9 +860,7 @@ begin
   Result := '';
   ATitle := '';
   //WriteLn('Getting topic# ',ATopicID);
-  if fTOPICSStream = nil then
-    fTOPICSStream := GetObject('/#TOPICS');
-  if fTOPICSStream = nil then
+  if not CheckCommonStreams then
     Exit;
   fTOPICSStream.Position := ATopicID * 16;
   if fTOPICSStream.Position = ATopicID * 16 then
@@ -865,6 +875,92 @@ begin
   end;
 end;
 
+function TChmReader.GetTOCSitemap: TChmSiteMap;
+    function AddTOCItem(TOC: TStream; AItemOffset: DWord; SiteMapITems: TChmSiteMapItems): DWord;
+    var
+      Props: DWord;
+      Item: TChmSiteMapItem;
+      NextEntry: DWord;
+      TopicsIndex: DWord;
+      Title: String;
+    begin
+      Toc.Position:= AItemOffset + 4;
+      Item := SiteMapITems.NewItem;
+      Props := LEtoN(TOC.ReadDWord);
+      if (Props and TOC_ENTRY_HAS_LOCAL) = 0 then
+        Item.Text:= ReadStringsEntry(LEtoN(TOC.ReadDWord))
+      else
+      begin
+        TopicsIndex := LEtoN(TOC.ReadDWord);
+        Item.Local := LookupTopicByID(TopicsIndex, Title);
+        Item.Text := Title;
+
+      end;
+      TOC.ReadDWord;
+      Result := LEtoN(TOC.ReadDWord);
+      if Props and TOC_ENTRY_HAS_CHILDREN > 0 then
+      begin
+        NextEntry := LEtoN(TOC.ReadDWord);
+        repeat
+          NextEntry := AddTOCItem(TOC, NextEntry, Item.Children);
+        until NextEntry = 0;
+      end;
+
+    end;
+
+var
+  TOC: TStream;
+  TOPICSOffset: DWord;
+  EntriesOffset: DWord;
+  EntryCount: DWord;
+  EntryInfoOffset: DWord;
+  NextItem: DWord;
+begin
+   Result := nil;
+   // First Try Binary
+   TOC := GetObject('/#TOCIDX');
+   if TOC = nil then
+   begin
+     // Second Try text toc
+     TOC := GetObject(TOCFile);
+     if TOC <> nil then
+     begin
+       Result := TChmSiteMap.Create(stTOC);
+       Result.LoadFromStream(TOC);
+       Toc.Free;
+     end;
+     Exit;
+   end;
+
+   // TOPICS URLSTR URLTBL must all exist to read binary toc
+   // if they don't then try text file
+   if not CheckCommonStreams then
+   begin
+     TOC.Free;
+     TOC := GetObject(TOCFile);
+     if TOC <> nil then
+     begin
+       Result := TChmSiteMap.Create(stTOC);
+       Result.LoadFromStream(TOC);
+       Toc.Free;
+     end;
+     Exit;
+   end;
+
+   // Binary Toc Exists
+   Result := TChmSiteMap.Create(stTOC);
+
+   EntryInfoOffset := NtoLE(TOC.ReadDWord);
+   EntriesOffset   := NtoLE(TOC.ReadDWord);
+   EntryCount      := NtoLE(TOC.ReadDWord);
+   TOPICSOffset    := NtoLE(TOC.ReadDWord);
+
+   NextItem := EntryInfoOffset;
+   repeat
+     NextItem := AddTOCItem(Toc, NextItem, Result.Items);
+   until NextItem = 0;
+end;
+
 function TChmReader.HasContextList: Boolean;
 begin
   Result := fContextList.Count > 0;

packages/chm/src/chmsitemap.pas

@@ -70,6 +70,7 @@ type
 
   TChmSiteMapItems = class(TPersistent)
   private
+    FInternalData: Dword;
     FList: TList;
     FOwner: TChmSiteMap;
     FParentItem: TChmSiteMapItem;
@@ -89,6 +90,7 @@ type
     property Count: Integer read GetCount;
     property ParentItem: TChmSiteMapItem read FParentItem;
     property Owner: TChmSiteMap read FOwner;
+    property InternalData: Dword read FInternalData write FInternalData;
   end;
   
 
@@ -194,14 +196,14 @@ begin
   //WriteLn('TAG:', AActualTag);
   TagName := GetTagName(ACaseInsensitiveTag);
 
-  if not (smtHTML in FSiteMapTags) then begin
-    if TagName = 'HTML' then Include(FSiteMapTags, smtHTML);
+{  if not (smtHTML in FSiteMapTags) then begin
+    if (TagName = 'HTML') or (TagName = '/HTML') then Include(FSiteMapTags, smtHTML);
   end
   else begin // looking for /HTML
     if TagName = '/HTML' then Exclude(FSiteMapTags, smtHTML);
-  end;
+  end;}
   
-  if (smtHTML in FSiteMapTags) then begin
+  //if (smtHTML in FSiteMapTags) then begin
      if not (smtBODY in FSiteMapTags) then begin
        if TagName = 'BODY' then Include(FSiteMapTags, smtBODY);
      end
@@ -263,7 +265,7 @@ begin
          end;
        end;
      end;
-  end
+  //end
 end;
 
 procedure TChmSiteMap.FoundText(AText: string);
@@ -460,6 +462,7 @@ begin
   FList := TList.Create;
   FParentItem := AParentItem;
   FOwner := AOwner;
+  FInternalData := maxLongint;
 end;
 
 destructor TChmSiteMapItems.Destroy;

packages/chm/src/chmtypes.pas

@@ -91,10 +91,63 @@ type
 
   end;
 
+  TTOCIdxHeader = record
+    BlockSize: DWord; // 4096
+    EntriesOffset: DWord;
+    EntriesCount: DWord;
+    TopicsOffset: DWord;
+    EmptyBytes: array[0..4079] of byte;
+  end;
+
+const
+  TOC_ENTRY_HAS_NEW      = 2;
+  TOC_ENTRY_HAS_CHILDREN = 4;
+  TOC_ENTRY_HAS_LOCAL    = 8;
+
+type
+  PTOCEntryPageBookInfo = ^TTOCEntryPageBookInfo;
+  TTOCEntryPageBookInfo = record
+    Unknown1: Word; //  = 0
+    EntryIndex: Word; // multiple entry info's can have this value but the TTocEntry it points to points back to the first item with this number. Wierd.
+    Props: DWord; // BitField. See TOC_ENTRY_*
+    TopicsIndexOrStringsOffset: DWord; // if TOC_ENTRY_HAS_LOCAL is in props it's the Topics Index
+                                       // else it's the Offset In Strings of the Item Text
+    ParentPageBookInfoOffset: DWord;
+    NextPageBookOffset: DWord; // same level of tree only
+
+    // Only if TOC_ENTRY_HAS_CHILDREN is set are these written
+    FirstChildOffset: DWord;
+    Unknown3: DWord; // = 0
+  end;
+
+  TTocEntry = record
+    PageBookInfoOffset: DWord;
+    IncrementedInt: DWord; // first is $29A
+    TopicsIndex: DWord; // Index of Entry in #TOPICS file
+  end;
+
+  TTopicEntry = record
+    TocOffset,
+    StringsOffset,
+    URLTableOffset: DWord;
+    InContents: Word;// 2 = in contents 6 = not in contents
+    Unknown: Word; // 0,2,4,8,10,12,16,32
+  end;
+
+
+  function PageBookInfoRecordSize(ARecord: PTOCEntryPageBookInfo): Integer;
 
 implementation
 uses chmbase;
 
+function PageBookInfoRecordSize(ARecord: PTOCEntryPageBookInfo): Integer;
+begin
+  if (TOC_ENTRY_HAS_CHILDREN and ARecord^.Props) > 0 then
+    Result := 28
+  else
+    Result := 20;
+end;
+
 { TDirectoryChunk }
 
 function TDirectoryChunk.CanHold(ASize: Integer): Boolean;

packages/chm/src/chmwriter.pas

@@ -22,7 +22,7 @@ unit chmwriter;
 {$MODE OBJFPC}{$H+}
 
 interface
-uses Classes, ChmBase, chmtypes, chmspecialfiles, HtmlIndexer;
+uses Classes, ChmBase, chmtypes, chmspecialfiles, HtmlIndexer, chmsitemap;
 
 type
 
@@ -39,6 +39,7 @@ type
   TChmWriter = class(TObject)
     FOnLastFile: TNotifyEvent;
   private
+    FHasBinaryTOC: Boolean;
   
     ForceExit: Boolean;
     
@@ -73,6 +74,7 @@ type
     FWindowSize: LongWord;
     FReadCompressedSize: QWord; // Current Size of Uncompressed data that went in Section1 (compressed)
     FIndexedFiles: TIndexedWordList;
+    FPostStreamActive: Boolean;
     // Linear order of file
     ITSFHeader: TITSFHeader;
     HeaderSection0Table: TITSFHeaderEntry;  // points to HeaderSection0
@@ -107,6 +109,7 @@ type
     function AddString(AString: String): LongWord;
     function AddURL(AURL: String; TopicsIndex: DWord): LongWord;
     procedure CheckFileMakeSearchable(AStream: TStream; AFileEntry: TFileEntryRec);
+    function NextTopicIndex: Integer;
     // callbacks for lzxcomp
     function  AtEndOfData: Longbool;
     function  GetData(Count: LongInt; Buffer: PByte): LongInt;
@@ -118,6 +121,8 @@ type
     destructor Destroy; override;
     procedure Execute;
     procedure AppendTOC(AStream: TStream);
+    procedure AppendBinaryTOCFromSiteMap(ASiteMap: TChmSiteMap);
+    procedure AppendBinaryTOCStream(AStream: TStream);
     procedure AppendIndex(AStream: TStream);
     procedure AppendSearchDB(AName: String; AStream: TStream);
     procedure AddStreamToArchive(AFileName, APath: String; AStream: TStream; Compress: Boolean = True);
@@ -132,6 +137,7 @@ type
     property Title: String read FTitle write FTitle;
     property FullTextSearch: Boolean read FFullTextSearch write FFullTextSearch;
     property SearchTitlesOnly: Boolean read FSearchTitlesOnly write FSearchTitlesOnly;
+    property HasBinaryTOC: Boolean read FHasBinaryTOC write FHasBinaryTOC;
     property DefaultFont: String read FDefaultFont write FDefaultFont;
     property DefaultPage: String read FDefaultPage write FDefaultPage;
     property TempRawStream: TStream read FTempStream write SetTempRawStream;
@@ -517,6 +523,22 @@ begin
 // }
   Entry.DecompressedSize := FSection0.Position - Entry.DecompressedOffset;
   FInternalFiles.AddEntry(Entry);
+
+  {// 7 Binary Index
+  if FHasBinaryIndex then
+  begin
+    FSection0.WriteWord(NToLE(Word(7)));
+    FSection0.WriteWord(NToLE(Word(4)));
+    FSection0.WriteDWord(DWord(0)); // what is this number to be?
+  end;}
+
+  // 11 Binary TOC
+  if FHasBinaryTOC then
+  begin
+    FSection0.WriteWord(NToLE(Word(11)));
+    FSection0.WriteWord(NToLE(Word(4)));
+    FSection0.WriteDWord(DWord(0)); // what is this number to be?
+  end;
 end;
 
 procedure TChmWriter.WriteITBITS;
@@ -815,10 +837,23 @@ begin
 end;
 
 function TChmWriter.AddString(AString: String): LongWord;
+var
+  NextBlock: DWord;
+  Pos: DWord;
 begin
   // #STRINGS starts with a null char
   if FStringsStream.Size = 0 then FStringsStream.WriteByte(0);
   // each entry is a null terminated string
+  Pos := DWord(FStringsStream.Position);
+
+  // Strings are contained in $1000 byte blocks and cannot cross blocks
+  NextBlock := ($0000F000 and Pos) + $00001000;
+  if Length(AString) + 1 > NextBlock then
+  begin
+    FStringsStream.Size:= NextBlock;
+    FStringsStream.Position := NextBlock;
+  end;
+
   Result := FStringsStream.Position;
   FStringsStream.WriteBuffer(AString[1], Length(AString));
   FStringsStream.WriteByte(0);
@@ -911,6 +946,7 @@ begin
     if (AtEndOfData)
     and (FCurrentStream <> FPostStream) then
     begin
+      FPostStreamActive := True;
       if Assigned(FOnLastFile) then
         FOnLastFile(Self);
       FCurrentStream.Free;
@@ -989,31 +1025,19 @@ begin
 end;
 
 procedure TChmWriter.CheckFileMakeSearchable(AStream: TStream; AFileEntry: TFileEntryRec);
-type
-  TTopicEntry = record
-    TocOffset,
-    StringsOffset,
-    URLTableOffset: DWord;
-    InContents: Word;// 2 = in contents 6 = not in contents
-    Unknown: Word; // 0,2,4,8,10,12,16,32
-  end;
 
-  function GetNewTopicsIndex: Integer;
-  begin
-    Result := FTopicsStream.Size div 16;
-  end;
   var
     TopicEntry: TTopicEntry;
     ATitle: String;
 begin
   if Pos('.ht', AFileEntry.Name) > 0 then
   begin
-    ATitle := FIndexedFiles.IndexFile(AStream, GetNewTopicsIndex, FSearchTitlesOnly);
+    ATitle := FIndexedFiles.IndexFile(AStream, NextTopicIndex, FSearchTitlesOnly);
     if ATitle <> '' then
       TopicEntry.StringsOffset := AddString(ATitle)
     else
       TopicEntry.StringsOffset := $FFFFFFFF;
-    TopicEntry.URLTableOffset := AddURL(AFileEntry.Path+AFileEntry.Name, GetNewTopicsIndex);
+    TopicEntry.URLTableOffset := AddURL(AFileEntry.Path+AFileEntry.Name, NextTopicIndex);
     TopicEntry.InContents := 2;
     TopicEntry.Unknown := 0;
     TopicEntry.TocOffset := 0;
@@ -1025,6 +1049,11 @@ begin
   end;
 end;
 
+function TChmWriter.NextTopicIndex: Integer;
+begin
+  Result := FTopicsStream.Size div 16;
+end;
+
 constructor TChmWriter.Create(OutStream: TStream; FreeStreamOnDestroy: Boolean);
 begin
   if OutStream = nil then Raise Exception.Create('TChmWriter.OutStream Cannot be nil!');
@@ -1119,6 +1148,180 @@ begin
   PostAddStreamToArchive('default.hhc', '/', AStream, True);
 end;
 
+procedure TChmWriter.AppendBinaryTOCFromSiteMap(ASiteMap: TChmSiteMap);
+var
+  Header: TTOCIdxHeader;
+  Entry: TTocEntry;
+  EntryInfo: TTOCEntryPageBookInfo;
+
+
+  EntryInfoStream,
+  EntryTopicOffsetStream,
+  EntryStream: TMemoryStream;
+
+  TOCIDXStream: TMemoryStream;
+
+  NextLevelItems,
+  CurrentLevelItems: TFPList;
+  i,j: Integer;
+  MenuItem: TChmSiteMapItem;
+  MenuItems: TChmSiteMapItems;
+  TopicEntry: TTopicEntry;
+  EntryCount: DWord = $29A;
+  procedure FixParentBookFirstChildOffset(AChildOffset: DWord);
+  var
+    ParentEntry: TTOCEntryPageBookInfo;
+  begin
+    // read parent entry
+    EntryInfoStream.Position := MenuItems.InternalData;
+    EntryInfoStream.Read(ParentEntry, SizeOf(ParentEntry));
+    // update child offset
+    ParentEntry.FirstChildOffset:= NtoLE(DWord(4096 + AChildOffset));
+    // write back to stream
+    EntryInfoStream.Position := MenuItems.InternalData;
+    EntryInfoStream.Write(ParentEntry, SizeOf(ParentEntry));
+    // move to end of stream
+    EntryInfoStream.Position := AChildOffset;
+  end;
+
+begin
+  FillChar(Header, 4096, 0);
+  // create streams
+  TOCIDXStream := TMemoryStream.Create;
+  EntryInfoStream := TMemoryStream.Create;
+  EntryTopicOffsetStream := TMemoryStream.Create;
+  EntryStream := TMemoryStream.Create;
+
+  NextLevelItems := TFPList.Create;
+
+  NextLevelItems.Add(ASiteMap.Items);
+
+  if NextLevelItems.Count = 0 then
+      FreeAndNil(NextLevelItems);
+
+  while NextLevelItems <> nil do
+  begin  WriteLn('Loop');
+    CurrentLevelItems := NextLevelItems;
+    NextLevelItems := TFPList.Create;
+
+    for i := 0 to CurrentLevelItems.Count-1 do
+    begin
+      MenuItems := TChmSiteMapItems(CurrentLevelItems.Items[i]);
+
+      for j := 0 to MenuItems.Count-1 do
+      begin
+        MenuItem := MenuItems.Item[j];
+        // first figure out the props
+        EntryInfo.Props := 0;
+        if MenuItem.Children.Count > 0 then
+          EntryInfo.Props := EntryInfo.Props or TOC_ENTRY_HAS_CHILDREN;
+        if Length(MenuItem.Local) > 0 then
+          EntryInfo.Props := EntryInfo.Props or TOC_ENTRY_HAS_LOCAL;
+
+
+      if EntryInfo.Props and TOC_ENTRY_HAS_LOCAL > 0 then
+      begin
+        // Write #TOPICS entry
+        TopicEntry.TocOffset      := NtoLE(DWord(4096 + EntryInfoStream.Position));
+        TopicEntry.StringsOffset  := NtoLE(AddString(MenuItem.Text));
+        TopicEntry.URLTableOffset := NtoLE(AddURL(MenuItem.Local, NextTopicIndex));
+        TopicEntry.InContents     := NtoLE(Word( 2 ));
+        TopicEntry.Unknown        := 0;
+        EntryInfo.TopicsIndexOrStringsOffset := NtoLE(Dword(NextTopicIndex));;
+        FTopicsStream.Write(TopicEntry, SizeOf(TopicEntry));
+        EntryTopicOffsetStream.WriteDWord(EntryInfo.TopicsIndexOrStringsOffset);
+
+        // write TOCEntry
+        Entry.PageBookInfoOffset:= NtoLE(4096 + EntryInfoStream.Position);
+        Entry.IncrementedInt  := NtoLE(EntryCount);
+        EntryStream.Write(Entry, SizeOf(Entry));
+        Inc(EntryCount);
+
+      end
+      else
+      begin
+        EntryInfo.TopicsIndexOrStringsOffset := NtoLE(AddString(MenuItem.Text));
+      end;
+
+
+        // write TOCEntryInfo
+
+        EntryInfo.Unknown1 := 0;
+        EntryInfo.EntryIndex := NtoLE(Word(EntryCount - $29A)); //who knows how useful any of this is
+
+        if MenuItems.InternalData <> maxLongint then
+          EntryInfo.ParentPageBookInfoOffset := MenuItems.InternalData
+        else
+          EntryInfo.ParentPageBookInfoOffset := 0;
+
+        if j = MenuItems.Count-1 then
+          EntryInfo.NextPageBookOffset := 0
+        else if (EntryInfo.Props and TOC_ENTRY_HAS_CHILDREN) > 0 then
+          EntryInfo.NextPageBookOffset := 4096 + EntryInfoStream.Position + 28
+        else
+          EntryInfo.NextPageBookOffset := 4096 + EntryInfoStream.Position + 20;
+
+        // Only if TOC_ENTRY_HAS_CHILDREN is set are these written
+        EntryInfo.FirstChildOffset := 0; // we will update this when the child is written
+        // in fact lets update the *parent* of this item now if needed
+        if (j = 0) and (MenuItems.InternalData <> maxLongint) then
+          FixParentBookFirstChildOffset(EntryInfoStream.Position);
+
+        EntryInfo.Unknown3 := 0;
+
+        // fix endian order
+        EntryInfo.Props := NtoLE(EntryInfo.Props);
+        EntryInfo.ParentPageBookInfoOffset := NtoLE(EntryInfo.ParentPageBookInfoOffset);
+        EntryInfo.NextPageBookOffset := NtoLE(EntryInfo.NextPageBookOffset);
+
+        if MenuItem.Children.Count > 0 then
+        begin
+          NextLevelItems.Add(MenuItem.Children);
+          MenuItem.Children.InternalData := EntryInfoStream.Position;
+        end;
+
+        // write to stream
+        EntryInfoStream.Write(EntryInfo, PageBookInfoRecordSize(@EntryInfo));
+      end;
+    end;
+
+    FreeAndNil(CurrentLevelItems);
+    if NextLevelItems.Count = 0 then
+      FreeAndNil(NextLevelItems);
+  end;
+
+  // write all streams to TOCIdxStream and free everything
+  EntryInfoStream.Position:=0;
+  EntryTopicOffsetStream.Position:=0;
+  EntryStream.Position:=0;
+
+  Header.BlockSize := NtoLE(DWord(4096));
+  Header.EntriesCount := NtoLE(DWord(EntryCount - $29A));
+  Header.EntriesOffset := NtoLE(DWord(4096 + EntryInfoStream.Size + EntryTopicOffsetStream.Size));
+  Header.TopicsOffset := NtoLE(DWord(4096 + EntryInfoStream.Size));
+
+  TOCIDXStream.Write(Header, SizeOf(Header));
+
+  TOCIDXStream.CopyFrom(EntryInfoStream, EntryInfoStream.Size);
+  EntryInfoStream.Free;
+
+  TOCIDXStream.CopyFrom(EntryTopicOffsetStream, EntryTopicOffsetStream.Size);
+  EntryTopicOffsetStream.Free;
+
+  TOCIDXStream.CopyFrom(EntryStream, EntryStream.Size);
+  EntryStream.Free;
+
+  TOCIDXStream.Position := 0;
+  AppendBinaryTOCStream(TOCIDXStream);
+  TOCIDXStream.Free;
+
+end;
+
+procedure TChmWriter.AppendBinaryTOCStream(AStream: TStream);
+begin
+  AddStreamToArchive('#TOCIDX', '/', AStream, True);
+end;
+
 procedure TChmWriter.AppendIndex(AStream: TStream);
 begin
   FHasIndex := True;
@@ -1139,6 +1342,12 @@ var
   TargetStream: TStream;
   Entry: TFileEntryRec;
 begin
+  // in case AddStreamToArchive is used after we should be writing to the post stream
+  if FPostStreamActive then
+  begin
+    PostAddStreamToArchive(AFileName, APath, AStream, Compress);
+    Exit;
+  end;
   if AStream = nil then Exit;
   if Compress then
     TargetStream := FCurrentStream

packages/fcl-image/Makefile

@@ -1,5 +1,5 @@
 #
-# Don't edit, this file is generated by FPCMake Version 2.0.0 [2009/08/02]
+# Don't edit, this file is generated by FPCMake Version 2.0.0 [2009/08/20]
 #
 default: all
 MAKEFILETARGETS=i386-linux i386-go32v2 i386-win32 i386-os2 i386-freebsd i386-beos i386-haiku i386-netbsd i386-solaris i386-qnx i386-netware i386-openbsd i386-wdosx i386-darwin i386-emx i386-watcom i386-netwlibc i386-wince i386-embedded i386-symbian m68k-linux m68k-freebsd m68k-netbsd m68k-amiga m68k-atari m68k-openbsd m68k-palmos m68k-embedded powerpc-linux powerpc-netbsd powerpc-amiga powerpc-macos powerpc-darwin powerpc-morphos powerpc-embedded sparc-linux sparc-netbsd sparc-solaris sparc-embedded x86_64-linux x86_64-freebsd x86_64-darwin x86_64-win64 x86_64-embedded arm-linux arm-palmos arm-darwin arm-wince arm-gba arm-nds arm-embedded arm-symbian powerpc64-linux powerpc64-darwin powerpc64-embedded avr-embedded armeb-linux armeb-embedded
@@ -282,10 +282,10 @@ ifeq ($(FULL_TARGET),i386-freebsd)
 override TARGET_UNITS+=fpimgcmn fpimage pngcomn fpreadpng fpwritepng fpreadxpm fpwritexpm clipping fpcanvas pixtools fppixlcanv fpimgcanv pscanvas fpwritebmp fpreadbmp bmpcomn fpreadpnm fpwritepnm fpreadjpeg fpwritejpeg pcxcomn fpreadpcx fpwritepcx fptiffcmn fpreadtiff fpwritetiff targacmn fpreadtga fpwritetga ellipses fpcolhash fpditherer fpquantizer extinterpolation fpreadgif fpreadpsd xwdfile fpreadxwd  freetypeh freetype ftfont
 endif
 ifeq ($(FULL_TARGET),i386-beos)
-override TARGET_UNITS+=fpimgcmn fpimage pngcomn fpreadpng fpwritepng fpreadxpm fpwritexpm clipping fpcanvas pixtools fppixlcanv fpimgcanv pscanvas fpwritebmp fpreadbmp bmpcomn fpreadpnm fpwritepnm fpreadjpeg fpwritejpeg pcxcomn fpreadpcx fpwritepcx fptiffcmn fpreadtiff fpwritetiff targacmn fpreadtga fpwritetga ellipses fpcolhash fpditherer fpquantizer extinterpolation fpreadgif fpreadpsd xwdfile fpreadxwd
+override TARGET_UNITS+=fpimgcmn fpimage pngcomn fpreadpng fpwritepng fpreadxpm fpwritexpm clipping fpcanvas pixtools fppixlcanv fpimgcanv pscanvas fpwritebmp fpreadbmp bmpcomn fpreadpnm fpwritepnm fpreadjpeg fpwritejpeg pcxcomn fpreadpcx fpwritepcx fptiffcmn fpreadtiff fpwritetiff targacmn fpreadtga fpwritetga ellipses fpcolhash fpditherer fpquantizer extinterpolation fpreadgif fpreadpsd xwdfile fpreadxwd  freetypeh freetype ftfont
 endif
 ifeq ($(FULL_TARGET),i386-haiku)
-override TARGET_UNITS+=fpimgcmn fpimage pngcomn fpreadpng fpwritepng fpreadxpm fpwritexpm clipping fpcanvas pixtools fppixlcanv fpimgcanv pscanvas fpwritebmp fpreadbmp bmpcomn fpreadpnm fpwritepnm fpreadjpeg fpwritejpeg pcxcomn fpreadpcx fpwritepcx fptiffcmn fpreadtiff fpwritetiff targacmn fpreadtga fpwritetga ellipses fpcolhash fpditherer fpquantizer extinterpolation fpreadgif fpreadpsd xwdfile fpreadxwd
+override TARGET_UNITS+=fpimgcmn fpimage pngcomn fpreadpng fpwritepng fpreadxpm fpwritexpm clipping fpcanvas pixtools fppixlcanv fpimgcanv pscanvas fpwritebmp fpreadbmp bmpcomn fpreadpnm fpwritepnm fpreadjpeg fpwritejpeg pcxcomn fpreadpcx fpwritepcx fptiffcmn fpreadtiff fpwritetiff targacmn fpreadtga fpwritetga ellipses fpcolhash fpditherer fpquantizer extinterpolation fpreadgif fpreadpsd xwdfile fpreadxwd  freetypeh freetype ftfont
 endif
 ifeq ($(FULL_TARGET),i386-netbsd)
 override TARGET_UNITS+=fpimgcmn fpimage pngcomn fpreadpng fpwritepng fpreadxpm fpwritexpm clipping fpcanvas pixtools fppixlcanv fpimgcanv pscanvas fpwritebmp fpreadbmp bmpcomn fpreadpnm fpwritepnm fpreadjpeg fpwritejpeg pcxcomn fpreadpcx fpwritepcx fptiffcmn fpreadtiff fpwritetiff targacmn fpreadtga fpwritetga ellipses fpcolhash fpditherer fpquantizer extinterpolation fpreadgif fpreadpsd xwdfile fpreadxwd

packages/fcl-image/Makefile.fpc

@@ -14,6 +14,8 @@ units=fpimgcmn fpimage pngcomn fpreadpng fpwritepng fpreadxpm fpwritexpm \
       targacmn fpreadtga fpwritetga ellipses fpcolhash fpditherer fpquantizer \ 
       extinterpolation fpreadgif fpreadpsd xwdfile fpreadxwd
 units_win32=freetypeh freetype ftfont
+units_beos=freetypeh freetype ftfont
+units_haiku=freetypeh freetype ftfont
 units_linux=freetypeh freetype ftfont
 units_freebsd=freetypeh freetype ftfont
 units_darwin=freetypeh freetype ftfont

packages/fcl-xml/src/dom.pp

@@ -18,8 +18,8 @@
   This unit provides classes which implement the interfaces defined in the
   DOM (Document Object Model) specification.
   The current state is:
-  DOM Level 1  -  Almost completely implemented
-  DOM Level 2  -  Partially implemented
+  DOM Levels 1 and 2 -  Completely implemented
+  DOM Level 3  -  Partially implemented
 
   Specification used for this implementation:
 
@@ -99,9 +99,13 @@ type
   TDOMProcessingInstruction = class;
 
   TDOMAttrDef = class;
-  PNodePool = ^TNodePool;
   TNodePool = class;
+  PNodePoolArray = ^TNodePoolArray;
+  TNodePoolArray = array[0..0] of TNodePool;
 
+{$ifndef fpc}
+  TFPList = TList;
+{$endif}
 
 // -------------------------------------------------------
 //   DOMString
@@ -430,7 +434,7 @@ type
     FEmptyNode: TDOMElement;
     FNodeLists: THashTable;
     FMaxPoolSize: Integer;
-    FPools: PNodePool;
+    FPools: PNodePoolArray;
     FDocumentURI: DOMString;
     function GetDocumentElement: TDOMElement;
     function GetDocType: TDOMDocumentType;
@@ -2081,7 +2085,7 @@ begin
   FEmptyNode.Free;
   inherited Destroy;
   for i := 0 to (FMaxPoolSize div sizeof(TNodePool))-1 do
-    FPools[i].Free;
+    FPools^[i].Free;
   FreeMem(FPools);
   FNames.Free;           // free the nametable after inherited has destroyed the children
                          // (because children reference the nametable)
@@ -2099,11 +2103,11 @@ begin
     Exit;
   end;
 
-  pp := FPools[size div sizeof(TNodePool)];
+  pp := FPools^[size div sizeof(TNodePool)];
   if pp = nil then
   begin
     pp := TNodePool.Create(size);
-    FPools[size div sizeof(TNodePool)] := pp;
+    FPools^[size div sizeof(TNodePool)] := pp;
   end;
   Result := pp.AllocNode(AClass);
 end;
@@ -3163,16 +3167,16 @@ end;
 destructor TNodePool.Destroy;
 var
   ext, next: PExtent;
-  ptr, ptr_end: Pointer;
+  ptr, ptr_end: PAnsiChar;
   sz: Integer;
 begin
   ext := FCurrExtent;
-  ptr := Pointer(FCurrBlock) + FElementSize;
+  ptr := PAnsiChar(FCurrBlock) + FElementSize;
   sz := FCurrExtentSize;
   while Assigned(ext) do
   begin
     // call destructors for everyone still there
-    ptr_end := Pointer(ext) + sizeof(TExtent) + (sz - 1) * FElementSize;
+    ptr_end := PAnsiChar(ext) + sizeof(TExtent) + (sz - 1) * FElementSize;
     while ptr <= ptr_end do
     begin
       if TDOMNode(ptr).FPool = Self then
@@ -3184,7 +3188,7 @@ begin
     FreeMem(ext);
     ext := next;
     sz := sz div 2;
-    ptr := Pointer(ext) + sizeof(TExtent);
+    ptr := PAnsiChar(ext) + sizeof(TExtent);
   end;
   inherited Destroy;
 end;
@@ -3194,13 +3198,13 @@ var
   ext: PExtent;
 begin
   Assert((FCurrExtent = nil) or
-    (Pointer(FCurrBlock) = Pointer(FCurrExtent) + sizeof(TExtent)));
+    (PAnsiChar(FCurrBlock) = PAnsiChar(FCurrExtent) + sizeof(TExtent)));
   Assert(AElemCount > 0);
 
   GetMem(ext, sizeof(TExtent) + AElemCount * FElementSize);
   ext^.Next := FCurrExtent;
   // point to the beginning of the last block of extent
-  FCurrBlock := TDOMNode(Pointer(ext) + sizeof(TExtent) + (AElemCount - 1) * FElementSize);
+  FCurrBlock := TDOMNode(PAnsiChar(ext) + sizeof(TExtent) + (AElemCount - 1) * FElementSize);
   FCurrExtent := ext;
   FCurrExtentSize := AElemCount;
 end;
@@ -3214,7 +3218,7 @@ begin
   end
   else
   begin
-    if Pointer(FCurrBlock) = Pointer(FCurrExtent) + sizeof(TExtent) then
+    if PAnsiChar(FCurrBlock) = PAnsiChar(FCurrExtent) + sizeof(TExtent) then
       AddExtent(FCurrExtentSize * 2);
     Result := FCurrBlock;
     Dec(PAnsiChar(FCurrBlock), FElementSize);

packages/fcl-xml/src/xmlcfg.pp

@@ -18,7 +18,7 @@
   configuration data
 }
 
-{$MODE objfpc}
+{$ifdef fpc}{$MODE objfpc}{$endif}
 {$H+}
 
 unit XMLCfg;
@@ -51,7 +51,7 @@ type
     FStartEmpty: Boolean;
     FUseEscaping: Boolean;
     FRootName: DOMString;
-    procedure SetFilename(const AFilename: String; ForceReload: Boolean);
+    procedure SetFilenameForce(const AFilename: String; ForceReload: Boolean);
     procedure SetFilename(const AFilename: String);
     procedure SetStartEmpty(AValue: Boolean);
     procedure SetRootName(const AValue: DOMString);
@@ -66,15 +66,15 @@ type
     destructor Destroy; override;
     procedure Clear;
     procedure Flush;    // Writes the XML file
-    function  GetValue(const APath, ADefault: String): String;
-    function  GetValue(const APath: String; ADefault: Integer): Integer;
-    function  GetValue(const APath: String; ADefault: Boolean): Boolean;
-    procedure SetValue(const APath, AValue: String);
-    procedure SetDeleteValue(const APath, AValue, DefValue: String);
-    procedure SetValue(const APath: String; AValue: Integer);
-    procedure SetDeleteValue(const APath: String; AValue, DefValue: Integer);
-    procedure SetValue(const APath: String; AValue: Boolean);
-    procedure SetDeleteValue(const APath: String; AValue, DefValue: Boolean);
+    function  GetValue(const APath, ADefault: String): String; overload;
+    function  GetValue(const APath: String; ADefault: Integer): Integer; overload;
+    function  GetValue(const APath: String; ADefault: Boolean): Boolean; overload;
+    procedure SetValue(const APath, AValue: String); overload;
+    procedure SetDeleteValue(const APath, AValue, DefValue: String); overload;
+    procedure SetValue(const APath: String; AValue: Integer); overload;
+    procedure SetDeleteValue(const APath: String; AValue, DefValue: Integer); overload;
+    procedure SetValue(const APath: String; AValue: Boolean); overload;
+    procedure SetDeleteValue(const APath: String; AValue, DefValue: Boolean); overload;
     procedure DeletePath(const APath: string);
     procedure DeleteValue(const APath: string);
     property Modified: Boolean read FModified;
@@ -300,7 +300,7 @@ procedure TXMLConfig.Loaded;
 begin
   inherited Loaded;
   if Length(Filename) > 0 then
-    SetFilename(Filename, true);              // Load the XML config file
+    SetFilenameForce(Filename, true);              // Load the XML config file
 end;
 
 function TXMLConfig.FindNode(const APath: String;
@@ -370,7 +370,7 @@ begin
     Result := s;
 end;
 
-procedure TXMLConfig.SetFilename(const AFilename: String; ForceReload: Boolean);
+procedure TXMLConfig.SetFilenameForce(const AFilename: String; ForceReload: Boolean);
 begin
   {$IFDEF MEM_CHECK}CheckHeapWrtMemCnt('TXMLConfig.SetFilename A '+AFilename);{$ENDIF}
   if (not ForceReload) and (FFilename = AFilename) then
@@ -400,7 +400,7 @@ end;
 
 procedure TXMLConfig.SetFilename(const AFilename: String);
 begin
-  SetFilename(AFilename, False);
+  SetFilenameForce(AFilename, False);
 end;
 
 procedure TXMLConfig.SetRootName(const AValue: DOMString);
@@ -424,7 +424,7 @@ begin
   begin
     FStartEmpty := AValue;
     if (not AValue) and not Modified then
-      SetFilename(Filename, True);
+      SetFilenameForce(Filename, True);
   end;
 end;
 

packages/fcl-xml/src/xmlutils.pp

@@ -14,7 +14,7 @@
  **********************************************************************}
 unit xmlutils;
 
-{$mode objfpc}
+{$ifdef fpc}{$mode objfpc}{$endif}
 {$H+}
 
 interface
@@ -38,6 +38,10 @@ function WStrLIComp(S1, S2: PWideChar; Len: Integer): Integer;
 { a simple hash table with WideString keys }
 
 type
+{$ifndef fpc}
+  PtrInt = LongInt;
+{$endif}  
+
   PPHashItem = ^PHashItem;
   PHashItem = ^THashItem;
   THashItem = record
@@ -46,6 +50,8 @@ type
     Next: PHashItem;
     Data: TObject;
   end;
+  THashItemArray = array[0..0] of PHashItem;
+  PHashItemArray = ^THashItemArray;
 
   THashForEach = function(Entry: PHashItem; arg: Pointer): Boolean;
 
@@ -53,7 +59,7 @@ type
   private
     FCount: LongWord;
     FBucketCount: LongWord;
-    FBucket: PPHashItem;
+    FBucket: PHashItemArray;
     FOwnsObjects: Boolean;
     function Lookup(Key: PWideChar; KeyLength: Integer; out Found: Boolean; CanCreate: Boolean): PHashItem;
     procedure Resize(NewCapacity: LongWord);
@@ -73,7 +79,6 @@ type
 
 { another hash, for detecting duplicate namespaced attributes without memory allocations }
 
-  PExpHashEntry = ^TExpHashEntry;
   TExpHashEntry = record
     rev: LongWord;
     hash: LongWord;
@@ -81,12 +86,14 @@ type
     lname: PWideChar;
     lnameLen: Integer;
   end;
+  TExpHashEntryArray = array[0..0] of TExpHashEntry;
+  PExpHashEntryArray = ^TExpHashEntryArray;
 
   TDblHashArray = class(TObject)
   private
     FSizeLog: Integer;
     FRevision: LongWord;
-    FData: PExpHashEntry;
+    FData: PExpHashEntryArray;
   public  
     procedure Init(NumSlots: Integer);
     function Locate(uri: PWideString; localName: PWideChar; localLength: Integer): Boolean;
@@ -128,7 +135,7 @@ begin
   Result := Xml11Pg;
 end;
 
-function IsXml11Char(Value: PWideChar; var Index: Integer): Boolean;
+function IsXml11Char(Value: PWideChar; var Index: Integer): Boolean; overload;
 begin
   if (Value[Index] >= #$D800) and (Value[Index] <= #$DB7F) then
   begin
@@ -139,7 +146,7 @@ begin
     Result := False;
 end;
 
-function IsXml11Char(const Value: WideString; var Index: Integer): Boolean;
+function IsXml11Char(const Value: WideString; var Index: Integer): Boolean; overload;
 begin
   if (Value[Index] >= #$D800) and (Value[Index] <= #$DB7F) then
   begin
@@ -346,7 +353,11 @@ end;
 
 function KeyCompare(const Key1: WideString; Key2: Pointer; Key2Len: Integer): Boolean;
 begin
+{$IFDEF FPC}
   Result := (Length(Key1)=Key2Len) and (CompareWord(Pointer(Key1)^, Key2^, Key2Len) = 0);
+{$ELSE}
+  Result := (Length(Key1)=Key2Len) and CompareMem(Pointer(Key1), Key2, Key2Len*2);
+{$ENDIF}
 end;
 
 { THashTable }
@@ -377,7 +388,7 @@ var
 begin
   for I := 0 to FBucketCount-1 do
   begin
-    item := FBucket[I];
+    item := FBucket^[I];
     while Assigned(item) do
     begin
       next := item^.Next;
@@ -386,8 +397,8 @@ begin
       Dispose(item);
       item := next;
     end;
+    FBucket^[I] := nil;
   end;
-  FillChar(FBucket^, FBucketCount * sizeof(PHashItem), 0);
 end;
 
 function THashTable.Find(Key: PWideChar; KeyLen: Integer): PHashItem;
@@ -460,14 +471,15 @@ end;
 
 procedure THashTable.Resize(NewCapacity: LongWord);
 var
-  p, chain: PPHashItem;
+  p: PHashItemArray;
+  chain: PPHashItem;
   i: Integer;
   e, n: PHashItem;
 begin
   p := AllocMem(NewCapacity * sizeof(PHashItem));
   for i := 0 to FBucketCount-1 do
   begin
-    e := FBucket[i];
+    e := FBucket^[i];
     while Assigned(e) do
     begin
       chain := @p[e^.HashValue mod NewCapacity];
@@ -538,7 +550,7 @@ var
 begin
   for i := 0 to FBucketCount-1 do
   begin
-    e := FBucket[i];
+    e := FBucket^[i];
     while Assigned(e) do
     begin
       if not proc(e, arg) then
@@ -572,7 +584,7 @@ begin
   begin
     FRevision := $FFFFFFFF;
     for i := (1 shl FSizeLog)-1 downto 0 do
-      FData[i].rev := FRevision;
+      FData^[i].rev := FRevision;
   end;
   Dec(FRevision);
 end;
@@ -591,18 +603,18 @@ begin
   step := (HashValue and (not mask)) shr (FSizeLog-1) and (mask shr 2) or 1;
   idx := HashValue and mask;
   result := True;
-  while FData[idx].rev = FRevision do
+  while FData^[idx].rev = FRevision do
   begin
-    if (HashValue = FData[idx].hash) and (FData[idx].uriPtr^ = uri^) and
-      (FData[idx].lnameLen = localLength) and
-       CompareMem(FData[idx].lname, localName, localLength * sizeof(WideChar)) then
+    if (HashValue = FData^[idx].hash) and (FData^[idx].uriPtr^ = uri^) and
+      (FData^[idx].lnameLen = localLength) and
+       CompareMem(FData^[idx].lname, localName, localLength * sizeof(WideChar)) then
       Exit;
     if idx < step then
       Inc(idx, (1 shl FSizeLog) - step)
     else
       Dec(idx, step);
   end;
-  with FData[idx] do
+  with FData^[idx] do
   begin
     rev := FRevision;
     hash := HashValue;

packages/fcl-xml/src/xmlwrite.pp

@@ -17,7 +17,7 @@
 
 unit XMLWrite;
 
-{$MODE objfpc}
+{$ifdef fpc}{$MODE objfpc}{$endif}
 {$H+}
 
 interface

packages/gdbint/Makefile

@@ -1,5 +1,5 @@
 #
-# Don't edit, this file is generated by FPCMake Version 2.0.0 [2009/08/02]
+# Don't edit, this file is generated by FPCMake Version 2.0.0 [2009/09/05]
 #
 default: all
 MAKEFILETARGETS=i386-linux i386-go32v2 i386-win32 i386-os2 i386-freebsd i386-beos i386-haiku i386-netbsd i386-solaris i386-qnx i386-netware i386-openbsd i386-wdosx i386-darwin i386-emx i386-watcom i386-netwlibc i386-wince i386-embedded i386-symbian m68k-linux m68k-freebsd m68k-netbsd m68k-amiga m68k-atari m68k-openbsd m68k-palmos m68k-embedded powerpc-linux powerpc-netbsd powerpc-amiga powerpc-macos powerpc-darwin powerpc-morphos powerpc-embedded sparc-linux sparc-netbsd sparc-solaris sparc-embedded x86_64-linux x86_64-freebsd x86_64-darwin x86_64-win64 x86_64-embedded arm-linux arm-palmos arm-darwin arm-wince arm-gba arm-nds arm-embedded arm-symbian powerpc64-linux powerpc64-darwin powerpc64-embedded avr-embedded armeb-linux armeb-embedded
@@ -2964,8 +2964,13 @@ GDBVER:=GDB_V$(strip $(shell $(CURRDIR)gdbver$(EXEEXT) -n))
 gdbver.inc: gdbver$(EXEEXT)
 	./gdbver$(EXEEXT) -o gdbver.inc
 gdbint$(PPUEXT): gdbint.pp gdbver.inc
+ifeq ($(wildcard $(GDBLIBDIR)/libmingw32.a),)
 	@$(ECHO) Using GDB $(GDBVER)
 	$(COMPILER) -d$(GDBVER) -Fisrc -Fusrc src/gdbint.pp
+else
+	@$(ECHO) Using GDB $(GDBVER) (MingW)
+	$(COMPILER) -d$(GDBVER) -dUSE_MINGW_GDB -Fisrc -Fusrc src/gdbint.pp
+endif
 	$(DEL) gdbver$(EXEEXT) gdbver$(OEXT)
 endif
 else

packages/gdbint/Makefile.fpc

@@ -88,8 +88,14 @@ GDBVER:=GDB_V$(strip $(shell $(CURRDIR)gdbver$(EXEEXT) -n))
 gdbver.inc: gdbver$(EXEEXT)
         ./gdbver$(EXEEXT) -o gdbver.inc
 gdbint$(PPUEXT): gdbint.pp gdbver.inc
+# MingW?
+ifeq ($(wildcard $(GDBLIBDIR)/libmingw32.a),)
 	@$(ECHO) Using GDB $(GDBVER)
-	$(COMPILER) -d$(GDBVER) -Fisrc -Fusrc src/gdbint.pp
+        $(COMPILER) -d$(GDBVER) -Fisrc -Fusrc src/gdbint.pp
+else
+	@$(ECHO) Using GDB $(GDBVER) (MingW)
+	$(COMPILER) -d$(GDBVER) -dUSE_MINGW_GDB -Fisrc -Fusrc src/gdbint.pp
+endif
 	$(DEL) gdbver$(EXEEXT) gdbver$(OEXT)
 endif
 

packages/gdbint/src/gdbint.pp

@@ -226,6 +226,7 @@ interface
     {$LINKLIB libmingwex.a}
     {$LINKLIB libmingw32.a}
     {$LINKLIB libmsvcrt.a}
+    {$LINKLIB libdecnumber.a}
     {$undef GDB_HAS_DEBUG_FILE_DIRECTORY}
   {$else not USE_MINGW_GDB}
     {$LINKLIB libiconv.a}

packages/gmp/Makefile

@@ -0,0 +1,2803 @@
+#
+# Don't edit, this file is generated by FPCMake Version 2.0.0 [2009/08/28]
+#
+default: all
+MAKEFILETARGETS=i386-linux i386-go32v2 i386-win32 i386-os2 i386-freebsd i386-beos i386-haiku i386-netbsd i386-solaris i386-qnx i386-netware i386-openbsd i386-wdosx i386-darwin i386-emx i386-watcom i386-netwlibc i386-wince i386-embedded i386-symbian m68k-linux m68k-freebsd m68k-netbsd m68k-amiga m68k-atari m68k-openbsd m68k-palmos m68k-embedded powerpc-linux powerpc-netbsd powerpc-amiga powerpc-macos powerpc-darwin powerpc-morphos powerpc-embedded sparc-linux sparc-netbsd sparc-solaris sparc-embedded x86_64-linux x86_64-freebsd x86_64-darwin x86_64-win64 x86_64-embedded arm-linux arm-palmos arm-darwin arm-wince arm-gba arm-nds arm-embedded arm-symbian powerpc64-linux powerpc64-darwin powerpc64-embedded avr-embedded armeb-linux armeb-embedded
+BSDs = freebsd netbsd openbsd darwin
+UNIXs = linux $(BSDs) solaris qnx
+LIMIT83fs = go32v2 os2 emx watcom
+OSNeedsComspecToRunBatch = go32v2 watcom
+FORCE:
+.PHONY: FORCE
+override PATH:=$(patsubst %/,%,$(subst \,/,$(PATH)))
+ifneq ($(findstring darwin,$(OSTYPE)),)
+inUnix=1 #darwin
+SEARCHPATH:=$(filter-out .,$(subst :, ,$(PATH)))
+else
+ifeq ($(findstring ;,$(PATH)),)
+inUnix=1
+SEARCHPATH:=$(filter-out .,$(subst :, ,$(PATH)))
+else
+SEARCHPATH:=$(subst ;, ,$(PATH))
+endif
+endif
+SEARCHPATH+=$(patsubst %/,%,$(subst \,/,$(dir $(MAKE))))
+PWD:=$(strip $(wildcard $(addsuffix /pwd.exe,$(SEARCHPATH))))
+ifeq ($(PWD),)
+PWD:=$(strip $(wildcard $(addsuffix /pwd,$(SEARCHPATH))))
+ifeq ($(PWD),)
+$(error You need the GNU utils package to use this Makefile)
+else
+PWD:=$(firstword $(PWD))
+SRCEXEEXT=
+endif
+else
+PWD:=$(firstword $(PWD))
+SRCEXEEXT=.exe
+endif
+ifndef inUnix
+ifeq ($(OS),Windows_NT)
+inWinNT=1
+else
+ifdef OS2_SHELL
+inOS2=1
+endif
+endif
+else
+ifneq ($(findstring cygdrive,$(PATH)),)
+inCygWin=1
+endif
+endif
+ifdef inUnix
+SRCBATCHEXT=.sh
+else
+ifdef inOS2
+SRCBATCHEXT=.cmd
+else
+SRCBATCHEXT=.bat
+endif
+endif
+ifdef COMSPEC
+ifneq ($(findstring $(OS_SOURCE),$(OSNeedsComspecToRunBatch)),)
+ifndef RUNBATCH
+RUNBATCH=$(COMSPEC) /C
+endif
+endif
+endif
+ifdef inUnix
+PATHSEP=/
+else
+PATHSEP:=$(subst /,\,/)
+ifdef inCygWin
+PATHSEP=/
+endif
+endif
+ifdef PWD
+BASEDIR:=$(subst \,/,$(shell $(PWD)))
+ifdef inCygWin
+ifneq ($(findstring /cygdrive/,$(BASEDIR)),)
+BASENODIR:=$(patsubst /cygdrive%,%,$(BASEDIR))
+BASEDRIVE:=$(firstword $(subst /, ,$(BASENODIR)))
+BASEDIR:=$(subst /cygdrive/$(BASEDRIVE)/,$(BASEDRIVE):/,$(BASEDIR))
+endif
+endif
+else
+BASEDIR=.
+endif
+ifdef inOS2
+ifndef ECHO
+ECHO:=$(strip $(wildcard $(addsuffix /gecho$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO:=$(strip $(wildcard $(addsuffix /echo$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO=echo
+else
+ECHO:=$(firstword $(ECHO))
+endif
+else
+ECHO:=$(firstword $(ECHO))
+endif
+endif
+export ECHO
+endif
+override DEFAULT_FPCDIR=../..
+ifndef FPC
+ifdef PP
+FPC=$(PP)
+endif
+endif
+ifndef FPC
+FPCPROG:=$(strip $(wildcard $(addsuffix /fpc$(SRCEXEEXT),$(SEARCHPATH))))
+ifneq ($(FPCPROG),)
+FPCPROG:=$(firstword $(FPCPROG))
+ifneq ($(CPU_TARGET),)
+FPC:=$(shell $(FPCPROG) -P$(CPU_TARGET) -PB)
+else
+FPC:=$(shell $(FPCPROG) -PB)
+endif
+ifneq ($(findstring Error,$(FPC)),)
+override FPC=$(firstword $(strip $(wildcard $(addsuffix /ppc386$(SRCEXEEXT),$(SEARCHPATH)))))
+else
+ifeq ($(strip $(wildcard $(FPC))),)
+FPC:=$(firstword $(FPCPROG))
+endif
+endif
+else
+override FPC=$(firstword $(strip $(wildcard $(addsuffix /ppc386$(SRCEXEEXT),$(SEARCHPATH)))))
+endif
+endif
+override FPC:=$(subst $(SRCEXEEXT),,$(FPC))
+override FPC:=$(subst \,/,$(FPC))$(SRCEXEEXT)
+FOUNDFPC:=$(strip $(wildcard $(FPC)))
+ifeq ($(FOUNDFPC),)
+FOUNDFPC=$(strip $(wildcard $(addsuffix /$(FPC),$(SEARCHPATH))))
+ifeq ($(FOUNDFPC),)
+$(error Compiler $(FPC) not found)
+endif
+endif
+ifndef FPC_COMPILERINFO
+FPC_COMPILERINFO:=$(shell $(FPC) -iVSPTPSOTO)
+endif
+ifndef FPC_VERSION
+FPC_VERSION:=$(word 1,$(FPC_COMPILERINFO))
+endif
+export FPC FPC_VERSION FPC_COMPILERINFO
+unexport CHECKDEPEND ALLDEPENDENCIES
+ifndef CPU_TARGET
+ifdef CPU_TARGET_DEFAULT
+CPU_TARGET=$(CPU_TARGET_DEFAULT)
+endif
+endif
+ifndef OS_TARGET
+ifdef OS_TARGET_DEFAULT
+OS_TARGET=$(OS_TARGET_DEFAULT)
+endif
+endif
+ifneq ($(words $(FPC_COMPILERINFO)),5)
+FPC_COMPILERINFO+=$(shell $(FPC) -iSP)
+FPC_COMPILERINFO+=$(shell $(FPC) -iTP)
+FPC_COMPILERINFO+=$(shell $(FPC) -iSO)
+FPC_COMPILERINFO+=$(shell $(FPC) -iTO)
+endif
+ifndef CPU_SOURCE
+CPU_SOURCE:=$(word 2,$(FPC_COMPILERINFO))
+endif
+ifndef CPU_TARGET
+CPU_TARGET:=$(word 3,$(FPC_COMPILERINFO))
+endif
+ifndef OS_SOURCE
+OS_SOURCE:=$(word 4,$(FPC_COMPILERINFO))
+endif
+ifndef OS_TARGET
+OS_TARGET:=$(word 5,$(FPC_COMPILERINFO))
+endif
+FULL_TARGET=$(CPU_TARGET)-$(OS_TARGET)
+FULL_SOURCE=$(CPU_SOURCE)-$(OS_SOURCE)
+ifeq ($(CPU_TARGET),armeb)
+ARCH=arm
+override FPCOPT+=-Cb
+else
+ifeq ($(CPU_TARGET),armel)
+ARCH=arm
+override FPCOPT+=-CaEABI
+else
+ARCH=$(CPU_TARGET)
+endif
+endif
+ifneq ($(findstring $(OS_SOURCE),$(LIMIT83fs)),)
+TARGETSUFFIX=$(OS_TARGET)
+SOURCESUFFIX=$(OS_SOURCE)
+else
+TARGETSUFFIX=$(FULL_TARGET)
+SOURCESUFFIX=$(FULL_SOURCE)
+endif
+ifneq ($(FULL_TARGET),$(FULL_SOURCE))
+CROSSCOMPILE=1
+endif
+ifeq ($(findstring makefile,$(MAKECMDGOALS)),)
+ifeq ($(findstring $(FULL_TARGET),$(MAKEFILETARGETS)),)
+$(error The Makefile doesn't support target $(FULL_TARGET), please run fpcmake first)
+endif
+endif
+ifneq ($(findstring $(OS_TARGET),$(BSDs)),)
+BSDhier=1
+endif
+ifeq ($(OS_TARGET),linux)
+linuxHier=1
+endif
+export OS_TARGET OS_SOURCE ARCH CPU_TARGET CPU_SOURCE FULL_TARGET FULL_SOURCE TARGETSUFFIX SOURCESUFFIX CROSSCOMPILE
+ifdef FPCDIR
+override FPCDIR:=$(subst \,/,$(FPCDIR))
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl units)),)
+override FPCDIR=wrong
+endif
+else
+override FPCDIR=wrong
+endif
+ifdef DEFAULT_FPCDIR
+ifeq ($(FPCDIR),wrong)
+override FPCDIR:=$(subst \,/,$(DEFAULT_FPCDIR))
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl units)),)
+override FPCDIR=wrong
+endif
+endif
+endif
+ifeq ($(FPCDIR),wrong)
+ifdef inUnix
+override FPCDIR=/usr/local/lib/fpc/$(FPC_VERSION)
+ifeq ($(wildcard $(FPCDIR)/units),)
+override FPCDIR=/usr/lib/fpc/$(FPC_VERSION)
+endif
+else
+override FPCDIR:=$(subst /$(FPC),,$(firstword $(strip $(wildcard $(addsuffix /$(FPC),$(SEARCHPATH))))))
+override FPCDIR:=$(FPCDIR)/..
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl units)),)
+override FPCDIR:=$(FPCDIR)/..
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl units)),)
+override FPCDIR:=$(BASEDIR)
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl units)),)
+override FPCDIR=c:/pp
+endif
+endif
+endif
+endif
+endif
+ifndef CROSSBINDIR
+CROSSBINDIR:=$(wildcard $(FPCDIR)/bin/$(TARGETSUFFIX))
+endif
+ifeq ($(OS_TARGET),darwin)
+ifeq ($(OS_SOURCE),darwin)
+DARWIN2DARWIN=1
+endif
+endif
+ifndef BINUTILSPREFIX
+ifndef CROSSBINDIR
+ifdef CROSSCOMPILE
+ifndef DARWIN2DARWIN
+BINUTILSPREFIX=$(CPU_TARGET)-$(OS_TARGET)-
+endif
+endif
+endif
+endif
+UNITSDIR:=$(wildcard $(FPCDIR)/units/$(TARGETSUFFIX))
+ifeq ($(UNITSDIR),)
+UNITSDIR:=$(wildcard $(FPCDIR)/units/$(OS_TARGET))
+endif
+PACKAGESDIR:=$(wildcard $(FPCDIR) $(FPCDIR)/packages $(FPCDIR)/packages/base $(FPCDIR)/packages/extra)
+override PACKAGE_NAME=gmp
+override PACKAGE_VERSION=2.5.1
+ifeq ($(FULL_TARGET),i386-linux)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-go32v2)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-win32)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-os2)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-freebsd)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-beos)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-haiku)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-netbsd)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-solaris)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-qnx)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-netware)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-openbsd)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-wdosx)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-darwin)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-emx)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-watcom)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-netwlibc)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-wince)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-embedded)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-symbian)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),m68k-linux)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),m68k-freebsd)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),m68k-netbsd)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),m68k-amiga)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),m68k-atari)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),m68k-openbsd)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),m68k-palmos)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),m68k-embedded)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),powerpc-linux)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),powerpc-netbsd)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),powerpc-amiga)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),powerpc-macos)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),powerpc-darwin)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),powerpc-morphos)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),powerpc-embedded)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),sparc-linux)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),sparc-netbsd)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),sparc-solaris)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),sparc-embedded)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),x86_64-linux)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),x86_64-freebsd)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),x86_64-darwin)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),x86_64-win64)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),x86_64-embedded)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),arm-linux)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),arm-palmos)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),arm-darwin)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),arm-wince)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),arm-gba)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),arm-nds)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),arm-embedded)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),arm-symbian)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),powerpc64-linux)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),powerpc64-darwin)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),powerpc64-embedded)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),avr-embedded)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),armeb-linux)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),armeb-embedded)
+override TARGET_UNITS+=gmp
+endif
+ifeq ($(FULL_TARGET),i386-linux)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-go32v2)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-win32)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-os2)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-freebsd)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-beos)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-haiku)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-netbsd)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-solaris)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-qnx)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-netware)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-openbsd)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-wdosx)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-darwin)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-emx)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-watcom)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-netwlibc)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-wince)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-embedded)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),i386-symbian)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),m68k-linux)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),m68k-freebsd)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),m68k-netbsd)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),m68k-amiga)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),m68k-atari)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),m68k-openbsd)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),m68k-palmos)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),m68k-embedded)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),powerpc-linux)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),powerpc-netbsd)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),powerpc-amiga)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),powerpc-macos)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),powerpc-darwin)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),powerpc-morphos)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),powerpc-embedded)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),sparc-linux)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),sparc-netbsd)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),sparc-solaris)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),sparc-embedded)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),x86_64-linux)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),x86_64-freebsd)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),x86_64-darwin)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),x86_64-win64)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),x86_64-embedded)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),arm-linux)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),arm-palmos)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),arm-darwin)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),arm-wince)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),arm-gba)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),arm-nds)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),arm-embedded)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),arm-symbian)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),powerpc64-linux)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),powerpc64-darwin)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),powerpc64-embedded)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),avr-embedded)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),armeb-linux)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+ifeq ($(FULL_TARGET),armeb-embedded)
+override TARGET_EXAMPLEDIRS+=examples
+endif
+override INSTALL_FPCPACKAGE=y
+override INSTALL_FPCSUBDIR=packages
+ifeq ($(FULL_TARGET),i386-linux)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-go32v2)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-win32)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-os2)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-freebsd)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-beos)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-haiku)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-netbsd)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-solaris)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-qnx)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-netware)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-openbsd)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-wdosx)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-darwin)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-emx)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-watcom)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-netwlibc)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-wince)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-embedded)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-symbian)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-linux)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-freebsd)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-netbsd)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-amiga)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-atari)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-openbsd)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-palmos)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-embedded)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-linux)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-netbsd)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-amiga)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-macos)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-darwin)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-morphos)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-embedded)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),sparc-linux)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),sparc-netbsd)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),sparc-solaris)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),sparc-embedded)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),x86_64-linux)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),x86_64-freebsd)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),x86_64-darwin)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),x86_64-win64)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),x86_64-embedded)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-linux)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-palmos)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-darwin)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-wince)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-gba)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-nds)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-embedded)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-symbian)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc64-linux)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc64-darwin)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc64-embedded)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),avr-embedded)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),armeb-linux)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),armeb-embedded)
+override COMPILER_INCLUDEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-linux)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-go32v2)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-win32)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-os2)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-freebsd)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-beos)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-haiku)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-netbsd)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-solaris)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-qnx)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-netware)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-openbsd)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-wdosx)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-darwin)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-emx)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-watcom)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-netwlibc)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-wince)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-embedded)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),i386-symbian)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-linux)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-freebsd)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-netbsd)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-amiga)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-atari)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-openbsd)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-palmos)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),m68k-embedded)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-linux)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-netbsd)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-amiga)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-macos)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-darwin)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-morphos)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc-embedded)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),sparc-linux)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),sparc-netbsd)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),sparc-solaris)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),sparc-embedded)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),x86_64-linux)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),x86_64-freebsd)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),x86_64-darwin)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),x86_64-win64)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),x86_64-embedded)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-linux)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-palmos)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-darwin)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-wince)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-gba)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-nds)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-embedded)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),arm-symbian)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc64-linux)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc64-darwin)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),powerpc64-embedded)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),avr-embedded)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),armeb-linux)
+override COMPILER_SOURCEDIR+=src
+endif
+ifeq ($(FULL_TARGET),armeb-embedded)
+override COMPILER_SOURCEDIR+=src
+endif
+override SHARED_BUILD=n
+override SHARED_BUILD=n
+ifdef REQUIRE_UNITSDIR
+override UNITSDIR+=$(REQUIRE_UNITSDIR)
+endif
+ifdef REQUIRE_PACKAGESDIR
+override PACKAGESDIR+=$(REQUIRE_PACKAGESDIR)
+endif
+ifdef ZIPINSTALL
+ifneq ($(findstring $(OS_TARGET),$(UNIXs)),)
+UNIXHier=1
+endif
+else
+ifneq ($(findstring $(OS_SOURCE),$(UNIXs)),)
+UNIXHier=1
+endif
+endif
+ifndef INSTALL_PREFIX
+ifdef PREFIX
+INSTALL_PREFIX=$(PREFIX)
+endif
+endif
+ifndef INSTALL_PREFIX
+ifdef UNIXHier
+INSTALL_PREFIX=/usr/local
+else
+ifdef INSTALL_FPCPACKAGE
+INSTALL_BASEDIR:=/pp
+else
+INSTALL_BASEDIR:=/$(PACKAGE_NAME)
+endif
+endif
+endif
+export INSTALL_PREFIX
+ifdef INSTALL_FPCSUBDIR
+export INSTALL_FPCSUBDIR
+endif
+ifndef DIST_DESTDIR
+DIST_DESTDIR:=$(BASEDIR)
+endif
+export DIST_DESTDIR
+ifndef COMPILER_UNITTARGETDIR
+ifdef PACKAGEDIR_MAIN
+COMPILER_UNITTARGETDIR=$(PACKAGEDIR_MAIN)/units/$(TARGETSUFFIX)
+else
+COMPILER_UNITTARGETDIR=units/$(TARGETSUFFIX)
+endif
+endif
+ifndef COMPILER_TARGETDIR
+COMPILER_TARGETDIR=.
+endif
+ifndef INSTALL_BASEDIR
+ifdef UNIXHier
+ifdef INSTALL_FPCPACKAGE
+INSTALL_BASEDIR:=$(INSTALL_PREFIX)/lib/fpc/$(FPC_VERSION)
+else
+INSTALL_BASEDIR:=$(INSTALL_PREFIX)/lib/$(PACKAGE_NAME)
+endif
+else
+INSTALL_BASEDIR:=$(INSTALL_PREFIX)
+endif
+endif
+ifndef INSTALL_BINDIR
+ifdef UNIXHier
+INSTALL_BINDIR:=$(INSTALL_PREFIX)/bin
+else
+INSTALL_BINDIR:=$(INSTALL_BASEDIR)/bin
+ifdef INSTALL_FPCPACKAGE
+ifdef CROSSCOMPILE
+ifdef CROSSINSTALL
+INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(SOURCESUFFIX)
+else
+INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(TARGETSUFFIX)
+endif
+else
+INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(TARGETSUFFIX)
+endif
+endif
+endif
+endif
+ifndef INSTALL_UNITDIR
+INSTALL_UNITDIR:=$(INSTALL_BASEDIR)/units/$(TARGETSUFFIX)
+ifdef INSTALL_FPCPACKAGE
+ifdef PACKAGE_NAME
+INSTALL_UNITDIR:=$(INSTALL_UNITDIR)/$(PACKAGE_NAME)
+endif
+endif
+endif
+ifndef INSTALL_LIBDIR
+ifdef UNIXHier
+INSTALL_LIBDIR:=$(INSTALL_PREFIX)/lib
+else
+INSTALL_LIBDIR:=$(INSTALL_UNITDIR)
+endif
+endif
+ifndef INSTALL_SOURCEDIR
+ifdef UNIXHier
+ifdef BSDhier
+SRCPREFIXDIR=share/src
+else
+ifdef linuxHier
+SRCPREFIXDIR=share/src
+else
+SRCPREFIXDIR=src
+endif
+endif
+ifdef INSTALL_FPCPACKAGE
+ifdef INSTALL_FPCSUBDIR
+INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/fpc-$(FPC_VERSION)/$(INSTALL_FPCSUBDIR)/$(PACKAGE_NAME)
+else
+INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/fpc-$(FPC_VERSION)/$(PACKAGE_NAME)
+endif
+else
+INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+endif
+else
+ifdef INSTALL_FPCPACKAGE
+ifdef INSTALL_FPCSUBDIR
+INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source/$(INSTALL_FPCSUBDIR)/$(PACKAGE_NAME)
+else
+INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source/$(PACKAGE_NAME)
+endif
+else
+INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source
+endif
+endif
+endif
+ifndef INSTALL_DOCDIR
+ifdef UNIXHier
+ifdef BSDhier
+DOCPREFIXDIR=share/doc
+else
+ifdef linuxHier
+DOCPREFIXDIR=share/doc
+else
+DOCPREFIXDIR=doc
+endif
+endif
+ifdef INSTALL_FPCPACKAGE
+INSTALL_DOCDIR:=$(INSTALL_PREFIX)/$(DOCPREFIXDIR)/fpc-$(FPC_VERSION)/$(PACKAGE_NAME)
+else
+INSTALL_DOCDIR:=$(INSTALL_PREFIX)/$(DOCPREFIXDIR)/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+endif
+else
+ifdef INSTALL_FPCPACKAGE
+INSTALL_DOCDIR:=$(INSTALL_BASEDIR)/doc/$(PACKAGE_NAME)
+else
+INSTALL_DOCDIR:=$(INSTALL_BASEDIR)/doc
+endif
+endif
+endif
+ifndef INSTALL_EXAMPLEDIR
+ifdef UNIXHier
+ifdef INSTALL_FPCPACKAGE
+ifdef BSDhier
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/share/examples/fpc-$(FPC_VERSION)/$(PACKAGE_NAME)
+else
+ifdef linuxHier
+INSTALL_EXAMPLEDIR:=$(INSTALL_DOCDIR)/examples
+else
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/doc/fpc-$(FPC_VERSION)/examples/$(PACKAGE_NAME)
+endif
+endif
+else
+ifdef BSDhier
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/share/examples/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+else
+ifdef linuxHier
+INSTALL_EXAMPLEDIR:=$(INSTALL_DOCDIR)/examples/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+else
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/doc/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+endif
+endif
+endif
+else
+ifdef INSTALL_FPCPACKAGE
+INSTALL_EXAMPLEDIR:=$(INSTALL_BASEDIR)/examples/$(PACKAGE_NAME)
+else
+INSTALL_EXAMPLEDIR:=$(INSTALL_BASEDIR)/examples
+endif
+endif
+endif
+ifndef INSTALL_DATADIR
+INSTALL_DATADIR=$(INSTALL_BASEDIR)
+endif
+ifndef INSTALL_SHAREDDIR
+INSTALL_SHAREDDIR=$(INSTALL_PREFIX)/lib
+endif
+ifdef CROSSCOMPILE
+ifndef CROSSBINDIR
+CROSSBINDIR:=$(wildcard $(CROSSTARGETDIR)/bin/$(SOURCESUFFIX))
+ifeq ($(CROSSBINDIR),)
+CROSSBINDIR:=$(wildcard $(INSTALL_BASEDIR)/cross/$(TARGETSUFFIX)/bin/$(FULL_SOURCE))
+endif
+endif
+else
+CROSSBINDIR=
+endif
+ifeq ($(OS_SOURCE),linux)
+ifndef GCCLIBDIR
+ifeq ($(CPU_TARGET),i386)
+ifneq ($(findstring x86_64,$(shell uname -a)),)
+ifeq ($(BINUTILSPREFIX),)
+GCCLIBDIR:=$(shell dirname `gcc -m32 -print-libgcc-file-name`)
+endif
+endif
+endif
+ifeq ($(CPU_TARGET),powerpc64)
+ifeq ($(BINUTILSPREFIX),)
+GCCLIBDIR:=$(shell dirname `gcc -m64 -print-libgcc-file-name`)
+endif
+endif
+endif
+ifndef GCCLIBDIR
+CROSSGCC=$(strip $(wildcard $(addsuffix /$(BINUTILSPREFIX)gcc$(SRCEXEEXT),$(SEARCHPATH))))
+ifneq ($(CROSSGCC),)
+GCCLIBDIR:=$(shell dirname `$(CROSSGCC) -print-libgcc-file-name`)
+endif
+endif
+ifndef OTHERLIBDIR
+OTHERLIBDIR:=$(shell grep -v "^\#" /etc/ld.so.conf | awk '{ ORS=" "; print $1 }')
+endif
+endif
+ifdef inUnix
+ifeq ($(OS_SOURCE),netbsd)
+OTHERLIBDIR+=/usr/pkg/lib
+endif
+export GCCLIBDIR OTHERLIB
+endif
+BATCHEXT=.bat
+LOADEREXT=.as
+EXEEXT=.exe
+PPLEXT=.ppl
+PPUEXT=.ppu
+OEXT=.o
+ASMEXT=.s
+SMARTEXT=.sl
+STATICLIBEXT=.a
+SHAREDLIBEXT=.so
+SHAREDLIBPREFIX=libfp
+STATICLIBPREFIX=libp
+IMPORTLIBPREFIX=libimp
+RSTEXT=.rst
+ifeq ($(findstring 1.0.,$(FPC_VERSION)),)
+ifeq ($(OS_TARGET),go32v1)
+STATICLIBPREFIX=
+SHORTSUFFIX=v1
+endif
+ifeq ($(OS_TARGET),go32v2)
+STATICLIBPREFIX=
+SHORTSUFFIX=dos
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),watcom)
+STATICLIBPREFIX=
+OEXT=.obj
+ASMEXT=.asm
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=wat
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),linux)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=lnx
+endif
+ifeq ($(OS_TARGET),freebsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=fbs
+endif
+ifeq ($(OS_TARGET),netbsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=nbs
+endif
+ifeq ($(OS_TARGET),openbsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=obs
+endif
+ifeq ($(OS_TARGET),win32)
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=w32
+endif
+ifeq ($(OS_TARGET),os2)
+BATCHEXT=.cmd
+AOUTEXT=.out
+STATICLIBPREFIX=
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=os2
+ECHO=echo
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),emx)
+BATCHEXT=.cmd
+AOUTEXT=.out
+STATICLIBPREFIX=
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=emx
+ECHO=echo
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),amiga)
+EXEEXT=
+SHAREDLIBEXT=.library
+SHORTSUFFIX=amg
+endif
+ifeq ($(OS_TARGET),morphos)
+EXEEXT=
+SHAREDLIBEXT=.library
+SHORTSUFFIX=mos
+endif
+ifeq ($(OS_TARGET),atari)
+EXEEXT=.ttp
+SHORTSUFFIX=ata
+endif
+ifeq ($(OS_TARGET),beos)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=be
+endif
+ifeq ($(OS_TARGET),haiku)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=hai
+endif
+ifeq ($(OS_TARGET),solaris)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=sun
+endif
+ifeq ($(OS_TARGET),qnx)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=qnx
+endif
+ifeq ($(OS_TARGET),netware)
+EXEEXT=.nlm
+STATICLIBPREFIX=
+SHORTSUFFIX=nw
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),netwlibc)
+EXEEXT=.nlm
+STATICLIBPREFIX=
+SHORTSUFFIX=nwl
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),macos)
+BATCHEXT=
+EXEEXT=
+DEBUGSYMEXT=.xcoff
+SHORTSUFFIX=mac
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),darwin)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=dwn
+endif
+ifeq ($(OS_TARGET),gba)
+EXEEXT=.gba
+SHAREDLIBEXT=.so
+SHORTSUFFIX=gba
+endif
+ifeq ($(OS_TARGET),symbian)
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=symbian
+endif
+else
+ifeq ($(OS_TARGET),go32v1)
+PPUEXT=.pp1
+OEXT=.o1
+ASMEXT=.s1
+SMARTEXT=.sl1
+STATICLIBEXT=.a1
+SHAREDLIBEXT=.so1
+STATICLIBPREFIX=
+SHORTSUFFIX=v1
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),go32v2)
+STATICLIBPREFIX=
+SHORTSUFFIX=dos
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),watcom)
+STATICLIBPREFIX=
+SHORTSUFFIX=wat
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),linux)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=lnx
+endif
+ifeq ($(OS_TARGET),freebsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=fbs
+endif
+ifeq ($(OS_TARGET),netbsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=nbs
+endif
+ifeq ($(OS_TARGET),openbsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=obs
+endif
+ifeq ($(OS_TARGET),win32)
+PPUEXT=.ppw
+OEXT=.ow
+ASMEXT=.sw
+SMARTEXT=.slw
+STATICLIBEXT=.aw
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=w32
+endif
+ifeq ($(OS_TARGET),os2)
+BATCHEXT=.cmd
+PPUEXT=.ppo
+ASMEXT=.so2
+OEXT=.oo2
+AOUTEXT=.out
+SMARTEXT=.sl2
+STATICLIBPREFIX=
+STATICLIBEXT=.ao2
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=os2
+ECHO=echo
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),amiga)
+EXEEXT=
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+SHAREDLIBEXT=.library
+SHORTSUFFIX=amg
+endif
+ifeq ($(OS_TARGET),atari)
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+EXEEXT=.ttp
+SHORTSUFFIX=ata
+endif
+ifeq ($(OS_TARGET),beos)
+BATCHEXT=.sh
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+EXEEXT=
+SHORTSUFFIX=be
+endif
+ifeq ($(OS_TARGET),solaris)
+BATCHEXT=.sh
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+EXEEXT=
+SHORTSUFFIX=sun
+endif
+ifeq ($(OS_TARGET),qnx)
+BATCHEXT=.sh
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+EXEEXT=
+SHORTSUFFIX=qnx
+endif
+ifeq ($(OS_TARGET),netware)
+STATICLIBPREFIX=
+PPUEXT=.ppu
+OEXT=.o
+ASMEXT=.s
+SMARTEXT=.sl
+STATICLIBEXT=.a
+SHAREDLIBEXT=.nlm
+EXEEXT=.nlm
+SHORTSUFFIX=nw
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),netwlibc)
+STATICLIBPREFIX=
+PPUEXT=.ppu
+OEXT=.o
+ASMEXT=.s
+SMARTEXT=.sl
+STATICLIBEXT=.a
+SHAREDLIBEXT=.nlm
+EXEEXT=.nlm
+SHORTSUFFIX=nwl
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),macos)
+BATCHEXT=
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+EXEEXT=
+DEBUGSYMEXT=.xcoff
+SHORTSUFFIX=mac
+IMPORTLIBPREFIX=imp
+endif
+endif
+ifneq ($(findstring $(OS_SOURCE),$(LIMIT83fs)),)
+FPCMADE=fpcmade.$(SHORTSUFFIX)
+ZIPSUFFIX=$(SHORTSUFFIX)
+ZIPCROSSPREFIX=
+ZIPSOURCESUFFIX=src
+ZIPEXAMPLESUFFIX=exm
+else
+FPCMADE=fpcmade.$(TARGETSUFFIX)
+ZIPSOURCESUFFIX=.source
+ZIPEXAMPLESUFFIX=.examples
+ifdef CROSSCOMPILE
+ZIPSUFFIX=.$(SOURCESUFFIX)
+ZIPCROSSPREFIX=$(TARGETSUFFIX)-
+else
+ZIPSUFFIX=.$(TARGETSUFFIX)
+ZIPCROSSPREFIX=
+endif
+endif
+ifndef ECHO
+ECHO:=$(strip $(wildcard $(addsuffix /gecho$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO:=$(strip $(wildcard $(addsuffix /echo$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO= __missing_command_ECHO
+else
+ECHO:=$(firstword $(ECHO))
+endif
+else
+ECHO:=$(firstword $(ECHO))
+endif
+endif
+export ECHO
+ifndef DATE
+DATE:=$(strip $(wildcard $(addsuffix /gdate$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(DATE),)
+DATE:=$(strip $(wildcard $(addsuffix /date$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(DATE),)
+DATE= __missing_command_DATE
+else
+DATE:=$(firstword $(DATE))
+endif
+else
+DATE:=$(firstword $(DATE))
+endif
+endif
+export DATE
+ifndef GINSTALL
+GINSTALL:=$(strip $(wildcard $(addsuffix /ginstall$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(GINSTALL),)
+GINSTALL:=$(strip $(wildcard $(addsuffix /install$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(GINSTALL),)
+GINSTALL= __missing_command_GINSTALL
+else
+GINSTALL:=$(firstword $(GINSTALL))
+endif
+else
+GINSTALL:=$(firstword $(GINSTALL))
+endif
+endif
+export GINSTALL
+ifndef CPPROG
+CPPROG:=$(strip $(wildcard $(addsuffix /cp$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(CPPROG),)
+CPPROG= __missing_command_CPPROG
+else
+CPPROG:=$(firstword $(CPPROG))
+endif
+endif
+export CPPROG
+ifndef RMPROG
+RMPROG:=$(strip $(wildcard $(addsuffix /rm$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(RMPROG),)
+RMPROG= __missing_command_RMPROG
+else
+RMPROG:=$(firstword $(RMPROG))
+endif
+endif
+export RMPROG
+ifndef MVPROG
+MVPROG:=$(strip $(wildcard $(addsuffix /mv$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(MVPROG),)
+MVPROG= __missing_command_MVPROG
+else
+MVPROG:=$(firstword $(MVPROG))
+endif
+endif
+export MVPROG
+ifndef MKDIRPROG
+MKDIRPROG:=$(strip $(wildcard $(addsuffix /gmkdir$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(MKDIRPROG),)
+MKDIRPROG:=$(strip $(wildcard $(addsuffix /mkdir$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(MKDIRPROG),)
+MKDIRPROG= __missing_command_MKDIRPROG
+else
+MKDIRPROG:=$(firstword $(MKDIRPROG))
+endif
+else
+MKDIRPROG:=$(firstword $(MKDIRPROG))
+endif
+endif
+export MKDIRPROG
+ifndef ECHOREDIR
+ifndef inUnix
+ECHOREDIR=echo
+else
+ECHOREDIR=$(ECHO)
+endif
+endif
+ifndef COPY
+COPY:=$(CPPROG) -fp
+endif
+ifndef COPYTREE
+COPYTREE:=$(CPPROG) -Rfp
+endif
+ifndef MKDIRTREE
+MKDIRTREE:=$(MKDIRPROG) -p
+endif
+ifndef MOVE
+MOVE:=$(MVPROG) -f
+endif
+ifndef DEL
+DEL:=$(RMPROG) -f
+endif
+ifndef DELTREE
+DELTREE:=$(RMPROG) -rf
+endif
+ifndef INSTALL
+ifdef inUnix
+INSTALL:=$(GINSTALL) -c -m 644
+else
+INSTALL:=$(COPY)
+endif
+endif
+ifndef INSTALLEXE
+ifdef inUnix
+INSTALLEXE:=$(GINSTALL) -c -m 755
+else
+INSTALLEXE:=$(COPY)
+endif
+endif
+ifndef MKDIR
+MKDIR:=$(GINSTALL) -m 755 -d
+endif
+export ECHOREDIR COPY COPYTREE MOVE DEL DELTREE INSTALL INSTALLEXE MKDIR
+ifndef PPUMOVE
+PPUMOVE:=$(strip $(wildcard $(addsuffix /ppumove$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(PPUMOVE),)
+PPUMOVE= __missing_command_PPUMOVE
+else
+PPUMOVE:=$(firstword $(PPUMOVE))
+endif
+endif
+export PPUMOVE
+ifndef FPCMAKE
+FPCMAKE:=$(strip $(wildcard $(addsuffix /fpcmake$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(FPCMAKE),)
+FPCMAKE= __missing_command_FPCMAKE
+else
+FPCMAKE:=$(firstword $(FPCMAKE))
+endif
+endif
+export FPCMAKE
+ifndef ZIPPROG
+ZIPPROG:=$(strip $(wildcard $(addsuffix /zip$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ZIPPROG),)
+ZIPPROG= __missing_command_ZIPPROG
+else
+ZIPPROG:=$(firstword $(ZIPPROG))
+endif
+endif
+export ZIPPROG
+ifndef TARPROG
+TARPROG:=$(strip $(wildcard $(addsuffix /gtar$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(TARPROG),)
+TARPROG:=$(strip $(wildcard $(addsuffix /tar$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(TARPROG),)
+TARPROG= __missing_command_TARPROG
+else
+TARPROG:=$(firstword $(TARPROG))
+endif
+else
+TARPROG:=$(firstword $(TARPROG))
+endif
+endif
+export TARPROG
+ASNAME=$(BINUTILSPREFIX)as
+LDNAME=$(BINUTILSPREFIX)ld
+ARNAME=$(BINUTILSPREFIX)ar
+RCNAME=$(BINUTILSPREFIX)rc
+ifneq ($(findstring 1.0.,$(FPC_VERSION)),)
+ifeq ($(OS_TARGET),win32)
+ifeq ($(CROSSBINDIR),)
+ASNAME=asw
+LDNAME=ldw
+ARNAME=arw
+endif
+endif
+endif
+ifndef ASPROG
+ifdef CROSSBINDIR
+ASPROG=$(CROSSBINDIR)/$(ASNAME)$(SRCEXEEXT)
+else
+ASPROG=$(ASNAME)
+endif
+endif
+ifndef LDPROG
+ifdef CROSSBINDIR
+LDPROG=$(CROSSBINDIR)/$(LDNAME)$(SRCEXEEXT)
+else
+LDPROG=$(LDNAME)
+endif
+endif
+ifndef RCPROG
+ifdef CROSSBINDIR
+RCPROG=$(CROSSBINDIR)/$(RCNAME)$(SRCEXEEXT)
+else
+RCPROG=$(RCNAME)
+endif
+endif
+ifndef ARPROG
+ifdef CROSSBINDIR
+ARPROG=$(CROSSBINDIR)/$(ARNAME)$(SRCEXEEXT)
+else
+ARPROG=$(ARNAME)
+endif
+endif
+AS=$(ASPROG)
+LD=$(LDPROG)
+RC=$(RCPROG)
+AR=$(ARPROG)
+PPAS=ppas$(SRCBATCHEXT)
+ifdef inUnix
+LDCONFIG=ldconfig
+else
+LDCONFIG=
+endif
+ifdef DATE
+DATESTR:=$(shell $(DATE) +%Y%m%d)
+else
+DATESTR=
+endif
+ifndef UPXPROG
+ifeq ($(OS_TARGET),go32v2)
+UPXPROG:=1
+endif
+ifeq ($(OS_TARGET),win32)
+UPXPROG:=1
+endif
+ifdef UPXPROG
+UPXPROG:=$(strip $(wildcard $(addsuffix /upx$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(UPXPROG),)
+UPXPROG=
+else
+UPXPROG:=$(firstword $(UPXPROG))
+endif
+else
+UPXPROG=
+endif
+endif
+export UPXPROG
+ZIPOPT=-9
+ZIPEXT=.zip
+ifeq ($(USETAR),bz2)
+TAROPT=vj
+TAREXT=.tar.bz2
+else
+TAROPT=vz
+TAREXT=.tar.gz
+endif
+override REQUIRE_PACKAGES=rtl 
+ifeq ($(FULL_TARGET),i386-linux)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-go32v2)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-win32)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-os2)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-freebsd)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-beos)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-haiku)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-netbsd)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-solaris)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-qnx)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-netware)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-openbsd)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-wdosx)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-darwin)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-emx)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-watcom)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-netwlibc)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-wince)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-embedded)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),i386-symbian)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),m68k-linux)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),m68k-freebsd)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),m68k-netbsd)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),m68k-amiga)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),m68k-atari)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),m68k-openbsd)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),m68k-palmos)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),m68k-embedded)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),powerpc-linux)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),powerpc-netbsd)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),powerpc-amiga)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),powerpc-macos)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),powerpc-darwin)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),powerpc-morphos)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),powerpc-embedded)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),sparc-linux)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),sparc-netbsd)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),sparc-solaris)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),sparc-embedded)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),x86_64-linux)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),x86_64-freebsd)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),x86_64-darwin)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),x86_64-win64)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),x86_64-embedded)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),arm-linux)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),arm-palmos)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),arm-darwin)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),arm-wince)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),arm-gba)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),arm-nds)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),arm-embedded)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),arm-symbian)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),powerpc64-linux)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),powerpc64-darwin)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),powerpc64-embedded)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),avr-embedded)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),armeb-linux)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifeq ($(FULL_TARGET),armeb-embedded)
+REQUIRE_PACKAGES_RTL=1
+endif
+ifdef REQUIRE_PACKAGES_RTL
+PACKAGEDIR_RTL:=$(firstword $(subst /Makefile.fpc,,$(strip $(wildcard $(addsuffix /rtl/Makefile.fpc,$(PACKAGESDIR))))))
+ifneq ($(PACKAGEDIR_RTL),)
+ifneq ($(wildcard $(PACKAGEDIR_RTL)/units/$(TARGETSUFFIX)),)
+UNITDIR_RTL=$(PACKAGEDIR_RTL)/units/$(TARGETSUFFIX)
+else
+UNITDIR_RTL=$(PACKAGEDIR_RTL)
+endif
+ifdef CHECKDEPEND
+$(PACKAGEDIR_RTL)/$(FPCMADE):
+	$(MAKE) -C $(PACKAGEDIR_RTL) $(FPCMADE)
+override ALLDEPENDENCIES+=$(PACKAGEDIR_RTL)/$(FPCMADE)
+endif
+else
+PACKAGEDIR_RTL=
+UNITDIR_RTL:=$(subst /Package.fpc,,$(strip $(wildcard $(addsuffix /rtl/Package.fpc,$(UNITSDIR)))))
+ifneq ($(UNITDIR_RTL),)
+UNITDIR_RTL:=$(firstword $(UNITDIR_RTL))
+else
+UNITDIR_RTL=
+endif
+endif
+ifdef UNITDIR_RTL
+override COMPILER_UNITDIR+=$(UNITDIR_RTL)
+endif
+endif
+ifndef NOCPUDEF
+override FPCOPTDEF=$(ARCH)
+endif
+ifneq ($(OS_TARGET),$(OS_SOURCE))
+override FPCOPT+=-T$(OS_TARGET)
+endif
+ifneq ($(CPU_TARGET),$(CPU_SOURCE))
+override FPCOPT+=-P$(ARCH)
+endif
+ifeq ($(OS_SOURCE),openbsd)
+override FPCOPT+=-FD$(NEW_BINUTILS_PATH)
+endif
+ifndef CROSSBOOTSTRAP
+ifneq ($(BINUTILSPREFIX),)
+override FPCOPT+=-XP$(BINUTILSPREFIX)
+endif
+ifneq ($(BINUTILSPREFIX),)
+override FPCOPT+=-Xr$(RLINKPATH)
+endif
+endif
+ifdef UNITDIR
+override FPCOPT+=$(addprefix -Fu,$(UNITDIR))
+endif
+ifdef LIBDIR
+override FPCOPT+=$(addprefix -Fl,$(LIBDIR))
+endif
+ifdef OBJDIR
+override FPCOPT+=$(addprefix -Fo,$(OBJDIR))
+endif
+ifdef INCDIR
+override FPCOPT+=$(addprefix -Fi,$(INCDIR))
+endif
+ifdef LINKSMART
+override FPCOPT+=-XX
+endif
+ifdef CREATESMART
+override FPCOPT+=-CX
+endif
+ifdef DEBUG
+override FPCOPT+=-gl
+override FPCOPTDEF+=DEBUG
+endif
+ifdef RELEASE
+ifneq ($(findstring 2.0.,$(FPC_VERSION)),)
+ifeq ($(CPU_TARGET),i386)
+FPCCPUOPT:=-OG2p3
+endif
+ifeq ($(CPU_TARGET),powerpc)
+FPCCPUOPT:=-O1r
+endif
+else
+FPCCPUOPT:=-O2
+endif
+override FPCOPT+=-Ur -Xs $(FPCCPUOPT) -n
+override FPCOPTDEF+=RELEASE
+endif
+ifdef STRIP
+override FPCOPT+=-Xs
+endif
+ifdef OPTIMIZE
+override FPCOPT+=-O2
+endif
+ifdef VERBOSE
+override FPCOPT+=-vwni
+endif
+ifdef COMPILER_OPTIONS
+override FPCOPT+=$(COMPILER_OPTIONS)
+endif
+ifdef COMPILER_UNITDIR
+override FPCOPT+=$(addprefix -Fu,$(COMPILER_UNITDIR))
+endif
+ifdef COMPILER_LIBRARYDIR
+override FPCOPT+=$(addprefix -Fl,$(COMPILER_LIBRARYDIR))
+endif
+ifdef COMPILER_OBJECTDIR
+override FPCOPT+=$(addprefix -Fo,$(COMPILER_OBJECTDIR))
+endif
+ifdef COMPILER_INCLUDEDIR
+override FPCOPT+=$(addprefix -Fi,$(COMPILER_INCLUDEDIR))
+endif
+ifdef CROSSBINDIR
+override FPCOPT+=-FD$(CROSSBINDIR)
+endif
+ifdef COMPILER_TARGETDIR
+override FPCOPT+=-FE$(COMPILER_TARGETDIR)
+ifeq ($(COMPILER_TARGETDIR),.)
+override TARGETDIRPREFIX=
+else
+override TARGETDIRPREFIX=$(COMPILER_TARGETDIR)/
+endif
+endif
+ifdef COMPILER_UNITTARGETDIR
+override FPCOPT+=-FU$(COMPILER_UNITTARGETDIR)
+ifeq ($(COMPILER_UNITTARGETDIR),.)
+override UNITTARGETDIRPREFIX=
+else
+override UNITTARGETDIRPREFIX=$(COMPILER_UNITTARGETDIR)/
+endif
+else
+ifdef COMPILER_TARGETDIR
+override COMPILER_UNITTARGETDIR=$(COMPILER_TARGETDIR)
+override UNITTARGETDIRPREFIX=$(TARGETDIRPREFIX)
+endif
+endif
+ifdef CREATESHARED
+override FPCOPT+=-Cg
+ifeq ($(CPU_TARGET),i386)
+override FPCOPT+=-Aas
+endif
+endif
+ifeq ($(findstring 2.0.,$(FPC_VERSION)),)
+ifeq ($(OS_TARGET),linux)
+ifeq ($(CPU_TARGET),x86_64)
+override FPCOPT+=-Cg
+endif
+endif
+endif
+ifdef LINKSHARED
+endif
+ifdef GCCLIBDIR
+override FPCOPT+=-Fl$(GCCLIBDIR)
+endif
+ifdef OTHERLIBDIR
+override FPCOPT+=$(addprefix -Fl,$(OTHERLIBDIR))
+endif
+ifdef OPT
+override FPCOPT+=$(OPT)
+endif
+ifdef FPCOPTDEF
+override FPCOPT+=$(addprefix -d,$(FPCOPTDEF))
+endif
+ifdef CFGFILE
+override FPCOPT+=@$(CFGFILE)
+endif
+ifdef USEENV
+override FPCEXTCMD:=$(FPCOPT)
+override FPCOPT:=!FPCEXTCMD
+export FPCEXTCMD
+endif
+override AFULL_TARGET=$(CPU_TARGET)-$(OS_TARGET)
+override AFULL_SOURCE=$(CPU_SOURCE)-$(OS_SOURCE)
+ifneq ($(AFULL_TARGET),$(AFULL_SOURCE))
+override ACROSSCOMPILE=1
+endif
+ifdef ACROSSCOMPILE
+override FPCOPT+=$(CROSSOPT)
+endif
+override COMPILER:=$(FPC) $(FPCOPT)
+ifeq (,$(findstring -s ,$(COMPILER)))
+EXECPPAS=
+else
+ifeq ($(FULL_SOURCE),$(FULL_TARGET))
+ifdef RUNBATCH
+EXECPPAS:=@$(RUNBATCH) $(PPAS)
+else
+EXECPPAS:=@$(PPAS)
+endif
+endif
+endif
+.PHONY: fpc_units
+ifneq ($(TARGET_UNITS)$(TARGET_IMPLICITUNITS),)
+override ALLTARGET+=fpc_units
+override UNITPPUFILES=$(addsuffix $(PPUEXT),$(TARGET_UNITS))
+override IMPLICITUNITPPUFILES=$(addsuffix $(PPUEXT),$(TARGET_IMPLICITUNITS))
+override INSTALLPPUFILES+=$(UNITPPUFILES) $(IMPLICITUNITPPUFILES)
+override CLEANPPUFILES+=$(UNITPPUFILES) $(IMPLICITUNITPPUFILES)
+endif
+fpc_units: $(COMPILER_UNITTARGETDIR) $(UNITPPUFILES)
+ifdef TARGET_RSTS
+override RSTFILES=$(addsuffix $(RSTEXT),$(TARGET_RSTS))
+override CLEANRSTFILES+=$(RSTFILES)
+endif
+.PHONY: fpc_examples
+ifneq ($(TARGET_EXAMPLES),)
+HASEXAMPLES=1
+override EXAMPLESOURCEFILES:=$(wildcard $(addsuffix .pp,$(TARGET_EXAMPLES)) $(addsuffix .pas,$(TARGET_EXAMPLES)) $(addsuffix .lpr,$(TARGET_EXAMPLES)) $(addsuffix .dpr,$(TARGET_EXAMPLES)))
+override EXAMPLEFILES:=$(addsuffix $(EXEEXT),$(TARGET_EXAMPLES))
+override EXAMPLEOFILES:=$(addsuffix $(OEXT),$(TARGET_EXAMPLES)) $(addprefix $(STATICLIBPREFIX),$(addsuffix $(STATICLIBEXT),$(TARGET_EXAMPLES))) $(addprefix $(IMPORTLIBPREFIX),$(addsuffix $(STATICLIBEXT),$(TARGET_EXAMPLES)))
+override CLEANEXEFILES+=$(EXAMPLEFILES) $(EXAMPLEOFILES)
+ifeq ($(OS_TARGET),os2)
+override CLEANEXEFILES+=$(addsuffix $(AOUTEXT),$(TARGET_EXAMPLES))
+endif
+ifeq ($(OS_TARGET),emx)
+override CLEANEXEFILES+=$(addsuffix $(AOUTEXT),$(TARGET_EXAMPLES))
+endif
+endif
+ifneq ($(TARGET_EXAMPLEDIRS),)
+HASEXAMPLES=1
+endif
+fpc_examples: all $(EXAMPLEFILES) $(addsuffix _all,$(TARGET_EXAMPLEDIRS))
+.PHONY: fpc_all fpc_smart fpc_debug fpc_release fpc_shared
+$(FPCMADE): $(ALLDEPENDENCIES) $(ALLTARGET)
+	@$(ECHOREDIR) Compiled > $(FPCMADE)
+fpc_all: $(FPCMADE)
+fpc_smart:
+	$(MAKE) all LINKSMART=1 CREATESMART=1
+fpc_debug:
+	$(MAKE) all DEBUG=1
+fpc_release:
+	$(MAKE) all RELEASE=1
+.SUFFIXES: $(EXEEXT) $(PPUEXT) $(OEXT) .pas .lpr .dpr .pp .rc .res
+$(COMPILER_UNITTARGETDIR):
+	$(MKDIRTREE) $(COMPILER_UNITTARGETDIR)
+$(COMPILER_TARGETDIR):
+	$(MKDIRTREE) $(COMPILER_TARGETDIR)
+%$(PPUEXT): %.pp
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(PPUEXT): %.pas
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.pp
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.pas
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.lpr
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.dpr
+	$(COMPILER) $<
+	$(EXECPPAS)
+%.res: %.rc
+	windres -i $< -o $@
+vpath %.pp $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.pas $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.lpr $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.dpr $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.inc $(COMPILER_INCLUDEDIR)
+vpath %$(OEXT) $(COMPILER_UNITTARGETDIR)
+vpath %$(PPUEXT) $(COMPILER_UNITTARGETDIR)
+.PHONY: fpc_shared
+override INSTALLTARGET+=fpc_shared_install
+ifndef SHARED_LIBVERSION
+SHARED_LIBVERSION=$(FPC_VERSION)
+endif
+ifndef SHARED_LIBNAME
+SHARED_LIBNAME=$(PACKAGE_NAME)
+endif
+ifndef SHARED_FULLNAME
+SHARED_FULLNAME=$(SHAREDLIBPREFIX)$(SHARED_LIBNAME)-$(SHARED_LIBVERSION)$(SHAREDLIBEXT)
+endif
+ifndef SHARED_LIBUNITS
+SHARED_LIBUNITS:=$(TARGET_UNITS) $(TARGET_IMPLICITUNITS)
+override SHARED_LIBUNITS:=$(filter-out $(INSTALL_BUILDUNIT),$(SHARED_LIBUNITS))
+endif
+fpc_shared:
+ifdef HASSHAREDLIB
+	$(MAKE) all CREATESHARED=1 LINKSHARED=1 CREATESMART=1
+ifneq ($(SHARED_BUILD),n)
+	$(PPUMOVE) -q $(SHARED_LIBUNITS) -i$(COMPILER_UNITTARGETDIR) -o$(SHARED_FULLNAME) -d$(COMPILER_UNITTARGETDIR)
+endif
+else
+	@$(ECHO) Shared Libraries not supported
+endif
+fpc_shared_install:
+ifneq ($(SHARED_BUILD),n)
+ifneq ($(SHARED_LIBUNITS),)
+ifneq ($(wildcard $(COMPILER_UNITTARGETDIR)/$(SHARED_FULLNAME)),)
+	$(INSTALL) $(COMPILER_UNITTARGETDIR)/$(SHARED_FULLNAME) $(INSTALL_SHAREDDIR)
+endif
+endif
+endif
+.PHONY: fpc_install fpc_sourceinstall fpc_exampleinstall
+ifdef INSTALL_UNITS
+override INSTALLPPUFILES+=$(addsuffix $(PPUEXT),$(INSTALL_UNITS))
+endif
+ifdef INSTALL_BUILDUNIT
+override INSTALLPPUFILES:=$(filter-out $(INSTALL_BUILDUNIT)$(PPUEXT),$(INSTALLPPUFILES))
+endif
+ifdef INSTALLPPUFILES
+override INSTALLPPULINKFILES:=$(subst $(PPUEXT),$(OEXT),$(INSTALLPPUFILES)) $(addprefix $(STATICLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(INSTALLPPUFILES))) $(addprefix $(IMPORTLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(INSTALLPPUFILES)))
+ifneq ($(UNITTARGETDIRPREFIX),)
+override INSTALLPPUFILES:=$(addprefix $(UNITTARGETDIRPREFIX),$(notdir $(INSTALLPPUFILES)))
+override INSTALLPPULINKFILES:=$(wildcard $(addprefix $(UNITTARGETDIRPREFIX),$(notdir $(INSTALLPPULINKFILES))))
+endif
+override INSTALL_CREATEPACKAGEFPC=1
+endif
+ifdef INSTALLEXEFILES
+ifneq ($(TARGETDIRPREFIX),)
+override INSTALLEXEFILES:=$(addprefix $(TARGETDIRPREFIX),$(notdir $(INSTALLEXEFILES)))
+endif
+endif
+fpc_install: all $(INSTALLTARGET)
+ifdef INSTALLEXEFILES
+	$(MKDIR) $(INSTALL_BINDIR)
+ifdef UPXPROG
+	-$(UPXPROG) $(INSTALLEXEFILES)
+endif
+	$(INSTALLEXE) $(INSTALLEXEFILES) $(INSTALL_BINDIR)
+endif
+ifdef INSTALL_CREATEPACKAGEFPC
+ifdef FPCMAKE
+ifdef PACKAGE_VERSION
+ifneq ($(wildcard Makefile.fpc),)
+	$(FPCMAKE) -p -T$(CPU_TARGET)-$(OS_TARGET) Makefile.fpc
+	$(MKDIR) $(INSTALL_UNITDIR)
+	$(INSTALL) Package.fpc $(INSTALL_UNITDIR)
+endif
+endif
+endif
+endif
+ifdef INSTALLPPUFILES
+	$(MKDIR) $(INSTALL_UNITDIR)
+	$(INSTALL) $(INSTALLPPUFILES) $(INSTALL_UNITDIR)
+ifneq ($(INSTALLPPULINKFILES),)
+	$(INSTALL) $(INSTALLPPULINKFILES) $(INSTALL_UNITDIR)
+endif
+ifneq ($(wildcard $(LIB_FULLNAME)),)
+	$(MKDIR) $(INSTALL_LIBDIR)
+	$(INSTALL) $(LIB_FULLNAME) $(INSTALL_LIBDIR)
+ifdef inUnix
+	ln -sf $(LIB_FULLNAME) $(INSTALL_LIBDIR)/$(LIB_NAME)
+endif
+endif
+endif
+ifdef INSTALL_FILES
+	$(MKDIR) $(INSTALL_DATADIR)
+	$(INSTALL) $(INSTALL_FILES) $(INSTALL_DATADIR)
+endif
+fpc_sourceinstall: distclean
+	$(MKDIR) $(INSTALL_SOURCEDIR)
+	$(COPYTREE) $(BASEDIR)/* $(INSTALL_SOURCEDIR)
+fpc_exampleinstall: $(addsuffix _distclean,$(TARGET_EXAMPLEDIRS))
+ifdef HASEXAMPLES
+	$(MKDIR) $(INSTALL_EXAMPLEDIR)
+endif
+ifdef EXAMPLESOURCEFILES
+	$(COPY) $(EXAMPLESOURCEFILES) $(INSTALL_EXAMPLEDIR)
+endif
+ifdef TARGET_EXAMPLEDIRS
+	$(COPYTREE) $(addsuffix /*,$(TARGET_EXAMPLEDIRS)) $(INSTALL_EXAMPLEDIR)
+endif
+.PHONY: fpc_distinstall
+fpc_distinstall: install exampleinstall
+.PHONY: fpc_zipinstall fpc_zipsourceinstall fpc_zipexampleinstall
+ifndef PACKDIR
+ifndef inUnix
+PACKDIR=$(BASEDIR)/../fpc-pack
+else
+PACKDIR=/tmp/fpc-pack
+endif
+endif
+ifndef ZIPNAME
+ifdef DIST_ZIPNAME
+ZIPNAME=$(DIST_ZIPNAME)
+else
+ZIPNAME=$(PACKAGE_NAME)
+endif
+endif
+ifndef FULLZIPNAME
+FULLZIPNAME=$(ZIPCROSSPREFIX)$(ZIPPREFIX)$(ZIPNAME)$(ZIPSUFFIX)
+endif
+ifndef ZIPTARGET
+ifdef DIST_ZIPTARGET
+ZIPTARGET=DIST_ZIPTARGET
+else
+ZIPTARGET=install
+endif
+endif
+ifndef USEZIP
+ifdef inUnix
+USETAR=1
+endif
+endif
+ifndef inUnix
+USEZIPWRAPPER=1
+endif
+ifdef USEZIPWRAPPER
+ZIPPATHSEP=$(PATHSEP)
+ZIPWRAPPER=$(subst /,$(PATHSEP),$(DIST_DESTDIR)/fpczip$(SRCBATCHEXT))
+else
+ZIPPATHSEP=/
+endif
+ZIPCMD_CDPACK:=cd $(subst /,$(ZIPPATHSEP),$(PACKDIR))
+ZIPCMD_CDBASE:=cd $(subst /,$(ZIPPATHSEP),$(BASEDIR))
+ifdef USETAR
+ZIPDESTFILE:=$(DIST_DESTDIR)/$(FULLZIPNAME)$(TAREXT)
+ZIPCMD_ZIP:=$(TARPROG) cf$(TAROPT) $(ZIPDESTFILE) *
+else
+ZIPDESTFILE:=$(DIST_DESTDIR)/$(FULLZIPNAME)$(ZIPEXT)
+ZIPCMD_ZIP:=$(subst /,$(ZIPPATHSEP),$(ZIPPROG)) -Dr $(ZIPOPT) $(ZIPDESTFILE) *
+endif
+fpc_zipinstall:
+	$(MAKE) $(ZIPTARGET) INSTALL_PREFIX=$(PACKDIR) ZIPINSTALL=1
+	$(MKDIR) $(DIST_DESTDIR)
+	$(DEL) $(ZIPDESTFILE)
+ifdef USEZIPWRAPPER
+ifneq ($(ECHOREDIR),echo)
+	$(ECHOREDIR) -e "$(subst \,\\,$(ZIPCMD_CDPACK))" > $(ZIPWRAPPER)
+	$(ECHOREDIR) -e "$(subst \,\\,$(ZIPCMD_ZIP))" >> $(ZIPWRAPPER)
+	$(ECHOREDIR) -e "$(subst \,\\,$(ZIPCMD_CDBASE))" >> $(ZIPWRAPPER)
+else
+	echo $(ZIPCMD_CDPACK) > $(ZIPWRAPPER)
+	echo $(ZIPCMD_ZIP) >> $(ZIPWRAPPER)
+	echo $(ZIPCMD_CDBASE) >> $(ZIPWRAPPER)
+endif
+ifdef inUnix
+	/bin/sh $(ZIPWRAPPER)
+else
+ifdef RUNBATCH
+	$(RUNBATCH) $(ZIPWRAPPER)
+else
+	$(ZIPWRAPPER)
+endif
+endif
+	$(DEL) $(ZIPWRAPPER)
+else
+	$(ZIPCMD_CDPACK) ; $(ZIPCMD_ZIP) ; $(ZIPCMD_CDBASE)
+endif
+	$(DELTREE) $(PACKDIR)
+fpc_zipsourceinstall:
+	$(MAKE) fpc_zipinstall ZIPTARGET=sourceinstall ZIPSUFFIX=$(ZIPSOURCESUFFIX)
+fpc_zipexampleinstall:
+ifdef HASEXAMPLES
+	$(MAKE) fpc_zipinstall ZIPTARGET=exampleinstall ZIPSUFFIX=$(ZIPEXAMPLESUFFIX)
+endif
+fpc_zipdistinstall:
+	$(MAKE) fpc_zipinstall ZIPTARGET=distinstall
+.PHONY: fpc_clean fpc_cleanall fpc_distclean
+ifdef EXEFILES
+override CLEANEXEFILES:=$(addprefix $(TARGETDIRPREFIX),$(CLEANEXEFILES))
+endif
+ifdef CLEAN_UNITS
+override CLEANPPUFILES+=$(addsuffix $(PPUEXT),$(CLEAN_UNITS))
+endif
+ifdef CLEANPPUFILES
+override CLEANPPULINKFILES:=$(subst $(PPUEXT),$(OEXT),$(CLEANPPUFILES)) $(addprefix $(STATICLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(CLEANPPUFILES))) $(addprefix $(IMPORTLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(CLEANPPUFILES)))
+ifdef DEBUGSYMEXT
+override CLEANPPULINKFILES+=$(subst $(PPUEXT),$(DEBUGSYMEXT),$(CLEANPPUFILES))
+endif
+override CLEANPPUFILES:=$(addprefix $(UNITTARGETDIRPREFIX),$(CLEANPPUFILES))
+override CLEANPPULINKFILES:=$(wildcard $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANPPULINKFILES)))
+endif
+fpc_clean: $(CLEANTARGET)
+ifdef CLEANEXEFILES
+	-$(DEL) $(CLEANEXEFILES)
+endif
+ifdef CLEANPPUFILES
+	-$(DEL) $(CLEANPPUFILES)
+endif
+ifneq ($(CLEANPPULINKFILES),)
+	-$(DEL) $(CLEANPPULINKFILES)
+endif
+ifdef CLEANRSTFILES
+	-$(DEL) $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANRSTFILES))
+endif
+ifdef CLEAN_FILES
+	-$(DEL) $(CLEAN_FILES)
+endif
+ifdef LIB_NAME
+	-$(DEL) $(LIB_NAME) $(LIB_FULLNAME)
+endif
+	-$(DEL) $(FPCMADE) Package.fpc $(PPAS) script.res link.res $(FPCEXTFILE) $(REDIRFILE)
+	-$(DEL) *$(ASMEXT) *_ppas$(BATCHEXT)
+fpc_cleanall: $(CLEANTARGET)
+ifdef CLEANEXEFILES
+	-$(DEL) $(CLEANEXEFILES)
+endif
+ifdef COMPILER_UNITTARGETDIR
+ifdef CLEANPPUFILES
+	-$(DEL) $(CLEANPPUFILES)
+endif
+ifneq ($(CLEANPPULINKFILES),)
+	-$(DEL) $(CLEANPPULINKFILES)
+endif
+ifdef CLEANRSTFILES
+	-$(DEL) $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANRSTFILES))
+endif
+endif
+	-$(DELTREE) units
+	-$(DEL) *$(OEXT) *$(PPUEXT) *$(RSTEXT) *$(ASMEXT) *$(STATICLIBEXT) *$(SHAREDLIBEXT) *$(PPLEXT)
+ifneq ($(PPUEXT),.ppu)
+	-$(DEL) *.o *.ppu *.a
+endif
+	-$(DELTREE) *$(SMARTEXT)
+	-$(DEL) fpcmade.* Package.fpc $(PPAS) script.res link.res $(FPCEXTFILE) $(REDIRFILE)
+	-$(DEL) *_ppas$(BATCHEXT)
+ifdef AOUTEXT
+	-$(DEL) *$(AOUTEXT)
+endif
+ifdef DEBUGSYMEXT
+	-$(DEL) *$(DEBUGSYMEXT)
+endif
+fpc_distclean: cleanall
+.PHONY: fpc_baseinfo
+override INFORULES+=fpc_baseinfo
+fpc_baseinfo:
+	@$(ECHO)
+	@$(ECHO)  == Package info ==
+	@$(ECHO)  Package Name..... $(PACKAGE_NAME)
+	@$(ECHO)  Package Version.. $(PACKAGE_VERSION)
+	@$(ECHO)
+	@$(ECHO)  == Configuration info ==
+	@$(ECHO)
+	@$(ECHO)  FPC.......... $(FPC)
+	@$(ECHO)  FPC Version.. $(FPC_VERSION)
+	@$(ECHO)  Source CPU... $(CPU_SOURCE)
+	@$(ECHO)  Target CPU... $(CPU_TARGET)
+	@$(ECHO)  Source OS.... $(OS_SOURCE)
+	@$(ECHO)  Target OS.... $(OS_TARGET)
+	@$(ECHO)  Full Source.. $(FULL_SOURCE)
+	@$(ECHO)  Full Target.. $(FULL_TARGET)
+	@$(ECHO)  SourceSuffix. $(SOURCESUFFIX)
+	@$(ECHO)  TargetSuffix. $(TARGETSUFFIX)
+	@$(ECHO)
+	@$(ECHO)  == Directory info ==
+	@$(ECHO)
+	@$(ECHO)  Required pkgs... $(REQUIRE_PACKAGES)
+	@$(ECHO)
+	@$(ECHO)  Basedir......... $(BASEDIR)
+	@$(ECHO)  FPCDir.......... $(FPCDIR)
+	@$(ECHO)  CrossBinDir..... $(CROSSBINDIR)
+	@$(ECHO)  UnitsDir........ $(UNITSDIR)
+	@$(ECHO)  PackagesDir..... $(PACKAGESDIR)
+	@$(ECHO)
+	@$(ECHO)  GCC library..... $(GCCLIBDIR)
+	@$(ECHO)  Other library... $(OTHERLIBDIR)
+	@$(ECHO)
+	@$(ECHO)  == Tools info ==
+	@$(ECHO)
+	@$(ECHO)  As........ $(AS)
+	@$(ECHO)  Ld........ $(LD)
+	@$(ECHO)  Ar........ $(AR)
+	@$(ECHO)  Rc........ $(RC)
+	@$(ECHO)
+	@$(ECHO)  Mv........ $(MVPROG)
+	@$(ECHO)  Cp........ $(CPPROG)
+	@$(ECHO)  Rm........ $(RMPROG)
+	@$(ECHO)  GInstall.. $(GINSTALL)
+	@$(ECHO)  Echo...... $(ECHO)
+	@$(ECHO)  Shell..... $(SHELL)
+	@$(ECHO)  Date...... $(DATE)
+	@$(ECHO)  FPCMake... $(FPCMAKE)
+	@$(ECHO)  PPUMove... $(PPUMOVE)
+	@$(ECHO)  Upx....... $(UPXPROG)
+	@$(ECHO)  Zip....... $(ZIPPROG)
+	@$(ECHO)
+	@$(ECHO)  == Object info ==
+	@$(ECHO)
+	@$(ECHO)  Target Loaders........ $(TARGET_LOADERS)
+	@$(ECHO)  Target Units.......... $(TARGET_UNITS)
+	@$(ECHO)  Target Implicit Units. $(TARGET_IMPLICITUNITS)
+	@$(ECHO)  Target Programs....... $(TARGET_PROGRAMS)
+	@$(ECHO)  Target Dirs........... $(TARGET_DIRS)
+	@$(ECHO)  Target Examples....... $(TARGET_EXAMPLES)
+	@$(ECHO)  Target ExampleDirs.... $(TARGET_EXAMPLEDIRS)
+	@$(ECHO)
+	@$(ECHO)  Clean Units......... $(CLEAN_UNITS)
+	@$(ECHO)  Clean Files......... $(CLEAN_FILES)
+	@$(ECHO)
+	@$(ECHO)  Install Units....... $(INSTALL_UNITS)
+	@$(ECHO)  Install Files....... $(INSTALL_FILES)
+	@$(ECHO)
+	@$(ECHO)  == Install info ==
+	@$(ECHO)
+	@$(ECHO)  DateStr.............. $(DATESTR)
+	@$(ECHO)  ZipName.............. $(ZIPNAME)
+	@$(ECHO)  ZipPrefix............ $(ZIPPREFIX)
+	@$(ECHO)  ZipCrossPrefix....... $(ZIPCROSSPREFIX)
+	@$(ECHO)  ZipSuffix............ $(ZIPSUFFIX)
+	@$(ECHO)  FullZipName.......... $(FULLZIPNAME)
+	@$(ECHO)  Install FPC Package.. $(INSTALL_FPCPACKAGE)
+	@$(ECHO)
+	@$(ECHO)  Install base dir..... $(INSTALL_BASEDIR)
+	@$(ECHO)  Install binary dir... $(INSTALL_BINDIR)
+	@$(ECHO)  Install library dir.. $(INSTALL_LIBDIR)
+	@$(ECHO)  Install units dir.... $(INSTALL_UNITDIR)
+	@$(ECHO)  Install source dir... $(INSTALL_SOURCEDIR)
+	@$(ECHO)  Install doc dir...... $(INSTALL_DOCDIR)
+	@$(ECHO)  Install example dir.. $(INSTALL_EXAMPLEDIR)
+	@$(ECHO)  Install data dir..... $(INSTALL_DATADIR)
+	@$(ECHO)
+	@$(ECHO)  Dist destination dir. $(DIST_DESTDIR)
+	@$(ECHO)  Dist zip name........ $(DIST_ZIPNAME)
+	@$(ECHO)
+.PHONY: fpc_info
+fpc_info: $(INFORULES)
+.PHONY: fpc_makefile fpc_makefiles fpc_makefile_sub1 fpc_makefile_sub2 \
+	fpc_makefile_dirs
+fpc_makefile:
+	$(FPCMAKE) -w -T$(OS_TARGET) Makefile.fpc
+fpc_makefile_sub1:
+ifdef TARGET_DIRS
+	$(FPCMAKE) -w -T$(OS_TARGET) $(addsuffix /Makefile.fpc,$(TARGET_DIRS))
+endif
+ifdef TARGET_EXAMPLEDIRS
+	$(FPCMAKE) -w -T$(OS_TARGET) $(addsuffix /Makefile.fpc,$(TARGET_EXAMPLEDIRS))
+endif
+fpc_makefile_sub2: $(addsuffix _makefile_dirs,$(TARGET_DIRS) $(TARGET_EXAMPLEDIRS))
+fpc_makefile_dirs: fpc_makefile_sub1 fpc_makefile_sub2
+fpc_makefiles: fpc_makefile fpc_makefile_dirs
+ifeq ($(FULL_TARGET),i386-linux)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-go32v2)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-win32)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-os2)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-freebsd)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-beos)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-haiku)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-netbsd)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-solaris)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-qnx)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-netware)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-openbsd)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-wdosx)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-darwin)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-emx)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-watcom)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-netwlibc)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-wince)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-embedded)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),i386-symbian)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),m68k-linux)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),m68k-freebsd)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),m68k-netbsd)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),m68k-amiga)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),m68k-atari)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),m68k-openbsd)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),m68k-palmos)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),m68k-embedded)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),powerpc-linux)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),powerpc-netbsd)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),powerpc-amiga)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),powerpc-macos)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),powerpc-darwin)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),powerpc-morphos)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),powerpc-embedded)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),sparc-linux)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),sparc-netbsd)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),sparc-solaris)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),sparc-embedded)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),x86_64-linux)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),x86_64-freebsd)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),x86_64-darwin)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),x86_64-win64)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),x86_64-embedded)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),arm-linux)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),arm-palmos)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),arm-darwin)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),arm-wince)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),arm-gba)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),arm-nds)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),arm-embedded)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),arm-symbian)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),powerpc64-linux)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),powerpc64-darwin)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),powerpc64-embedded)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),avr-embedded)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),armeb-linux)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifeq ($(FULL_TARGET),armeb-embedded)
+TARGET_EXAMPLEDIRS_EXAMPLES=1
+endif
+ifdef TARGET_EXAMPLEDIRS_EXAMPLES
+examples_all:
+	$(MAKE) -C examples all
+examples_debug:
+	$(MAKE) -C examples debug
+examples_smart:
+	$(MAKE) -C examples smart
+examples_release:
+	$(MAKE) -C examples release
+examples_units:
+	$(MAKE) -C examples units
+examples_examples:
+	$(MAKE) -C examples examples
+examples_shared:
+	$(MAKE) -C examples shared
+examples_install:
+	$(MAKE) -C examples install
+examples_sourceinstall:
+	$(MAKE) -C examples sourceinstall
+examples_exampleinstall:
+	$(MAKE) -C examples exampleinstall
+examples_distinstall:
+	$(MAKE) -C examples distinstall
+examples_zipinstall:
+	$(MAKE) -C examples zipinstall
+examples_zipsourceinstall:
+	$(MAKE) -C examples zipsourceinstall
+examples_zipexampleinstall:
+	$(MAKE) -C examples zipexampleinstall
+examples_zipdistinstall:
+	$(MAKE) -C examples zipdistinstall
+examples_clean:
+	$(MAKE) -C examples clean
+examples_distclean:
+	$(MAKE) -C examples distclean
+examples_cleanall:
+	$(MAKE) -C examples cleanall
+examples_info:
+	$(MAKE) -C examples info
+examples_makefiles:
+	$(MAKE) -C examples makefiles
+examples:
+	$(MAKE) -C examples all
+.PHONY: examples_all examples_debug examples_smart examples_release examples_units examples_examples examples_shared examples_install examples_sourceinstall examples_exampleinstall examples_distinstall examples_zipinstall examples_zipsourceinstall examples_zipexampleinstall examples_zipdistinstall examples_clean examples_distclean examples_cleanall examples_info examples_makefiles examples
+endif
+all: fpc_all
+debug: fpc_debug
+smart: fpc_smart
+release: fpc_release
+units: fpc_units
+examples: fpc_examples
+shared: fpc_shared
+install: fpc_install
+sourceinstall: fpc_sourceinstall
+exampleinstall: fpc_exampleinstall
+distinstall: fpc_distinstall
+zipinstall: fpc_zipinstall
+zipsourceinstall: fpc_zipsourceinstall
+zipexampleinstall: fpc_zipexampleinstall
+zipdistinstall: fpc_zipdistinstall
+clean: fpc_clean $(addsuffix _clean,$(TARGET_EXAMPLEDIRS))
+distclean: fpc_distclean
+cleanall: fpc_cleanall
+info: fpc_info
+makefiles: fpc_makefiles
+.PHONY: all debug smart release units examples shared install sourceinstall exampleinstall distinstall zipinstall zipsourceinstall zipexampleinstall zipdistinstall clean distclean cleanall info makefiles
+ifneq ($(wildcard fpcmake.loc),)
+include fpcmake.loc
+endif
+.NOTPARALLEL:

packages/gmp/Makefile.fpc

@@ -0,0 +1,32 @@
+#
+#   Makefile.fpc for Free Pascal ImLib 1.x Packages
+#
+
+[package]
+name=gmp 
+version=2.5.1
+
+[target]
+units=gmp
+exampledirs=examples
+
+[require]
+libc=y
+
+[compiler]
+includedir=src
+sourcedir=src 
+
+
+[install]
+fpcpackage=y
+fpcsubdir=packages
+
+[default]
+fpcdir=../..
+
+[shared]
+build=n
+
+[rules]
+.NOTPARALLEL:

packages/gmp/examples/Makefile

@@ -0,0 +1,2045 @@
+#
+# Don't edit, this file is generated by FPCMake Version 2.0.0 [2009/08/28]
+#
+default: all
+MAKEFILETARGETS=i386-linux i386-go32v2 i386-win32 i386-os2 i386-freebsd i386-beos i386-haiku i386-netbsd i386-solaris i386-qnx i386-netware i386-openbsd i386-wdosx i386-darwin i386-emx i386-watcom i386-netwlibc i386-wince i386-embedded i386-symbian m68k-linux m68k-freebsd m68k-netbsd m68k-amiga m68k-atari m68k-openbsd m68k-palmos m68k-embedded powerpc-linux powerpc-netbsd powerpc-amiga powerpc-macos powerpc-darwin powerpc-morphos powerpc-embedded sparc-linux sparc-netbsd sparc-solaris sparc-embedded x86_64-linux x86_64-freebsd x86_64-darwin x86_64-win64 x86_64-embedded arm-linux arm-palmos arm-darwin arm-wince arm-gba arm-nds arm-embedded arm-symbian powerpc64-linux powerpc64-darwin powerpc64-embedded avr-embedded armeb-linux armeb-embedded
+BSDs = freebsd netbsd openbsd darwin
+UNIXs = linux $(BSDs) solaris qnx
+LIMIT83fs = go32v2 os2 emx watcom
+OSNeedsComspecToRunBatch = go32v2 watcom
+FORCE:
+.PHONY: FORCE
+override PATH:=$(patsubst %/,%,$(subst \,/,$(PATH)))
+ifneq ($(findstring darwin,$(OSTYPE)),)
+inUnix=1 #darwin
+SEARCHPATH:=$(filter-out .,$(subst :, ,$(PATH)))
+else
+ifeq ($(findstring ;,$(PATH)),)
+inUnix=1
+SEARCHPATH:=$(filter-out .,$(subst :, ,$(PATH)))
+else
+SEARCHPATH:=$(subst ;, ,$(PATH))
+endif
+endif
+SEARCHPATH+=$(patsubst %/,%,$(subst \,/,$(dir $(MAKE))))
+PWD:=$(strip $(wildcard $(addsuffix /pwd.exe,$(SEARCHPATH))))
+ifeq ($(PWD),)
+PWD:=$(strip $(wildcard $(addsuffix /pwd,$(SEARCHPATH))))
+ifeq ($(PWD),)
+$(error You need the GNU utils package to use this Makefile)
+else
+PWD:=$(firstword $(PWD))
+SRCEXEEXT=
+endif
+else
+PWD:=$(firstword $(PWD))
+SRCEXEEXT=.exe
+endif
+ifndef inUnix
+ifeq ($(OS),Windows_NT)
+inWinNT=1
+else
+ifdef OS2_SHELL
+inOS2=1
+endif
+endif
+else
+ifneq ($(findstring cygdrive,$(PATH)),)
+inCygWin=1
+endif
+endif
+ifdef inUnix
+SRCBATCHEXT=.sh
+else
+ifdef inOS2
+SRCBATCHEXT=.cmd
+else
+SRCBATCHEXT=.bat
+endif
+endif
+ifdef COMSPEC
+ifneq ($(findstring $(OS_SOURCE),$(OSNeedsComspecToRunBatch)),)
+ifndef RUNBATCH
+RUNBATCH=$(COMSPEC) /C
+endif
+endif
+endif
+ifdef inUnix
+PATHSEP=/
+else
+PATHSEP:=$(subst /,\,/)
+ifdef inCygWin
+PATHSEP=/
+endif
+endif
+ifdef PWD
+BASEDIR:=$(subst \,/,$(shell $(PWD)))
+ifdef inCygWin
+ifneq ($(findstring /cygdrive/,$(BASEDIR)),)
+BASENODIR:=$(patsubst /cygdrive%,%,$(BASEDIR))
+BASEDRIVE:=$(firstword $(subst /, ,$(BASENODIR)))
+BASEDIR:=$(subst /cygdrive/$(BASEDRIVE)/,$(BASEDRIVE):/,$(BASEDIR))
+endif
+endif
+else
+BASEDIR=.
+endif
+ifdef inOS2
+ifndef ECHO
+ECHO:=$(strip $(wildcard $(addsuffix /gecho$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO:=$(strip $(wildcard $(addsuffix /echo$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO=echo
+else
+ECHO:=$(firstword $(ECHO))
+endif
+else
+ECHO:=$(firstword $(ECHO))
+endif
+endif
+export ECHO
+endif
+override DEFAULT_FPCDIR=../../..
+ifndef FPC
+ifdef PP
+FPC=$(PP)
+endif
+endif
+ifndef FPC
+FPCPROG:=$(strip $(wildcard $(addsuffix /fpc$(SRCEXEEXT),$(SEARCHPATH))))
+ifneq ($(FPCPROG),)
+FPCPROG:=$(firstword $(FPCPROG))
+ifneq ($(CPU_TARGET),)
+FPC:=$(shell $(FPCPROG) -P$(CPU_TARGET) -PB)
+else
+FPC:=$(shell $(FPCPROG) -PB)
+endif
+ifneq ($(findstring Error,$(FPC)),)
+override FPC=$(firstword $(strip $(wildcard $(addsuffix /ppc386$(SRCEXEEXT),$(SEARCHPATH)))))
+else
+ifeq ($(strip $(wildcard $(FPC))),)
+FPC:=$(firstword $(FPCPROG))
+endif
+endif
+else
+override FPC=$(firstword $(strip $(wildcard $(addsuffix /ppc386$(SRCEXEEXT),$(SEARCHPATH)))))
+endif
+endif
+override FPC:=$(subst $(SRCEXEEXT),,$(FPC))
+override FPC:=$(subst \,/,$(FPC))$(SRCEXEEXT)
+FOUNDFPC:=$(strip $(wildcard $(FPC)))
+ifeq ($(FOUNDFPC),)
+FOUNDFPC=$(strip $(wildcard $(addsuffix /$(FPC),$(SEARCHPATH))))
+ifeq ($(FOUNDFPC),)
+$(error Compiler $(FPC) not found)
+endif
+endif
+ifndef FPC_COMPILERINFO
+FPC_COMPILERINFO:=$(shell $(FPC) -iVSPTPSOTO)
+endif
+ifndef FPC_VERSION
+FPC_VERSION:=$(word 1,$(FPC_COMPILERINFO))
+endif
+export FPC FPC_VERSION FPC_COMPILERINFO
+unexport CHECKDEPEND ALLDEPENDENCIES
+ifndef CPU_TARGET
+ifdef CPU_TARGET_DEFAULT
+CPU_TARGET=$(CPU_TARGET_DEFAULT)
+endif
+endif
+ifndef OS_TARGET
+ifdef OS_TARGET_DEFAULT
+OS_TARGET=$(OS_TARGET_DEFAULT)
+endif
+endif
+ifneq ($(words $(FPC_COMPILERINFO)),5)
+FPC_COMPILERINFO+=$(shell $(FPC) -iSP)
+FPC_COMPILERINFO+=$(shell $(FPC) -iTP)
+FPC_COMPILERINFO+=$(shell $(FPC) -iSO)
+FPC_COMPILERINFO+=$(shell $(FPC) -iTO)
+endif
+ifndef CPU_SOURCE
+CPU_SOURCE:=$(word 2,$(FPC_COMPILERINFO))
+endif
+ifndef CPU_TARGET
+CPU_TARGET:=$(word 3,$(FPC_COMPILERINFO))
+endif
+ifndef OS_SOURCE
+OS_SOURCE:=$(word 4,$(FPC_COMPILERINFO))
+endif
+ifndef OS_TARGET
+OS_TARGET:=$(word 5,$(FPC_COMPILERINFO))
+endif
+FULL_TARGET=$(CPU_TARGET)-$(OS_TARGET)
+FULL_SOURCE=$(CPU_SOURCE)-$(OS_SOURCE)
+ifeq ($(CPU_TARGET),armeb)
+ARCH=arm
+override FPCOPT+=-Cb
+else
+ifeq ($(CPU_TARGET),armel)
+ARCH=arm
+override FPCOPT+=-CaEABI
+else
+ARCH=$(CPU_TARGET)
+endif
+endif
+ifneq ($(findstring $(OS_SOURCE),$(LIMIT83fs)),)
+TARGETSUFFIX=$(OS_TARGET)
+SOURCESUFFIX=$(OS_SOURCE)
+else
+TARGETSUFFIX=$(FULL_TARGET)
+SOURCESUFFIX=$(FULL_SOURCE)
+endif
+ifneq ($(FULL_TARGET),$(FULL_SOURCE))
+CROSSCOMPILE=1
+endif
+ifeq ($(findstring makefile,$(MAKECMDGOALS)),)
+ifeq ($(findstring $(FULL_TARGET),$(MAKEFILETARGETS)),)
+$(error The Makefile doesn't support target $(FULL_TARGET), please run fpcmake first)
+endif
+endif
+ifneq ($(findstring $(OS_TARGET),$(BSDs)),)
+BSDhier=1
+endif
+ifeq ($(OS_TARGET),linux)
+linuxHier=1
+endif
+export OS_TARGET OS_SOURCE ARCH CPU_TARGET CPU_SOURCE FULL_TARGET FULL_SOURCE TARGETSUFFIX SOURCESUFFIX CROSSCOMPILE
+ifdef FPCDIR
+override FPCDIR:=$(subst \,/,$(FPCDIR))
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl units)),)
+override FPCDIR=wrong
+endif
+else
+override FPCDIR=wrong
+endif
+ifdef DEFAULT_FPCDIR
+ifeq ($(FPCDIR),wrong)
+override FPCDIR:=$(subst \,/,$(DEFAULT_FPCDIR))
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl units)),)
+override FPCDIR=wrong
+endif
+endif
+endif
+ifeq ($(FPCDIR),wrong)
+ifdef inUnix
+override FPCDIR=/usr/local/lib/fpc/$(FPC_VERSION)
+ifeq ($(wildcard $(FPCDIR)/units),)
+override FPCDIR=/usr/lib/fpc/$(FPC_VERSION)
+endif
+else
+override FPCDIR:=$(subst /$(FPC),,$(firstword $(strip $(wildcard $(addsuffix /$(FPC),$(SEARCHPATH))))))
+override FPCDIR:=$(FPCDIR)/..
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl units)),)
+override FPCDIR:=$(FPCDIR)/..
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl units)),)
+override FPCDIR:=$(BASEDIR)
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl units)),)
+override FPCDIR=c:/pp
+endif
+endif
+endif
+endif
+endif
+ifndef CROSSBINDIR
+CROSSBINDIR:=$(wildcard $(FPCDIR)/bin/$(TARGETSUFFIX))
+endif
+ifeq ($(OS_TARGET),darwin)
+ifeq ($(OS_SOURCE),darwin)
+DARWIN2DARWIN=1
+endif
+endif
+ifndef BINUTILSPREFIX
+ifndef CROSSBINDIR
+ifdef CROSSCOMPILE
+ifndef DARWIN2DARWIN
+BINUTILSPREFIX=$(CPU_TARGET)-$(OS_TARGET)-
+endif
+endif
+endif
+endif
+UNITSDIR:=$(wildcard $(FPCDIR)/units/$(TARGETSUFFIX))
+ifeq ($(UNITSDIR),)
+UNITSDIR:=$(wildcard $(FPCDIR)/units/$(OS_TARGET))
+endif
+PACKAGESDIR:=$(wildcard $(FPCDIR) $(FPCDIR)/packages $(FPCDIR)/packages/base $(FPCDIR)/packages/extra)
+ifeq ($(FULL_TARGET),i386-linux)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-go32v2)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-win32)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-os2)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-freebsd)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-beos)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-haiku)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-netbsd)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-solaris)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-qnx)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-netware)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-openbsd)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-wdosx)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-darwin)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-emx)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-watcom)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-netwlibc)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-wince)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-embedded)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),i386-symbian)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),m68k-linux)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),m68k-freebsd)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),m68k-netbsd)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),m68k-amiga)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),m68k-atari)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),m68k-openbsd)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),m68k-palmos)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),m68k-embedded)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),powerpc-linux)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),powerpc-netbsd)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),powerpc-amiga)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),powerpc-macos)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),powerpc-darwin)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),powerpc-morphos)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),powerpc-embedded)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),sparc-linux)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),sparc-netbsd)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),sparc-solaris)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),sparc-embedded)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),x86_64-linux)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),x86_64-freebsd)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),x86_64-darwin)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),x86_64-win64)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),x86_64-embedded)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),arm-linux)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),arm-palmos)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),arm-darwin)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),arm-wince)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),arm-gba)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),arm-nds)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),arm-embedded)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),arm-symbian)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),powerpc64-linux)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),powerpc64-darwin)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),powerpc64-embedded)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),avr-embedded)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),armeb-linux)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+ifeq ($(FULL_TARGET),armeb-embedded)
+override TARGET_PROGRAMS+=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+endif
+override INSTALL_FPCPACKAGE=y
+ifdef REQUIRE_UNITSDIR
+override UNITSDIR+=$(REQUIRE_UNITSDIR)
+endif
+ifdef REQUIRE_PACKAGESDIR
+override PACKAGESDIR+=$(REQUIRE_PACKAGESDIR)
+endif
+ifdef ZIPINSTALL
+ifneq ($(findstring $(OS_TARGET),$(UNIXs)),)
+UNIXHier=1
+endif
+else
+ifneq ($(findstring $(OS_SOURCE),$(UNIXs)),)
+UNIXHier=1
+endif
+endif
+ifndef INSTALL_PREFIX
+ifdef PREFIX
+INSTALL_PREFIX=$(PREFIX)
+endif
+endif
+ifndef INSTALL_PREFIX
+ifdef UNIXHier
+INSTALL_PREFIX=/usr/local
+else
+ifdef INSTALL_FPCPACKAGE
+INSTALL_BASEDIR:=/pp
+else
+INSTALL_BASEDIR:=/$(PACKAGE_NAME)
+endif
+endif
+endif
+export INSTALL_PREFIX
+ifdef INSTALL_FPCSUBDIR
+export INSTALL_FPCSUBDIR
+endif
+ifndef DIST_DESTDIR
+DIST_DESTDIR:=$(BASEDIR)
+endif
+export DIST_DESTDIR
+ifndef COMPILER_UNITTARGETDIR
+ifdef PACKAGEDIR_MAIN
+COMPILER_UNITTARGETDIR=$(PACKAGEDIR_MAIN)/units/$(TARGETSUFFIX)
+else
+COMPILER_UNITTARGETDIR=units/$(TARGETSUFFIX)
+endif
+endif
+ifndef COMPILER_TARGETDIR
+COMPILER_TARGETDIR=.
+endif
+ifndef INSTALL_BASEDIR
+ifdef UNIXHier
+ifdef INSTALL_FPCPACKAGE
+INSTALL_BASEDIR:=$(INSTALL_PREFIX)/lib/fpc/$(FPC_VERSION)
+else
+INSTALL_BASEDIR:=$(INSTALL_PREFIX)/lib/$(PACKAGE_NAME)
+endif
+else
+INSTALL_BASEDIR:=$(INSTALL_PREFIX)
+endif
+endif
+ifndef INSTALL_BINDIR
+ifdef UNIXHier
+INSTALL_BINDIR:=$(INSTALL_PREFIX)/bin
+else
+INSTALL_BINDIR:=$(INSTALL_BASEDIR)/bin
+ifdef INSTALL_FPCPACKAGE
+ifdef CROSSCOMPILE
+ifdef CROSSINSTALL
+INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(SOURCESUFFIX)
+else
+INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(TARGETSUFFIX)
+endif
+else
+INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(TARGETSUFFIX)
+endif
+endif
+endif
+endif
+ifndef INSTALL_UNITDIR
+INSTALL_UNITDIR:=$(INSTALL_BASEDIR)/units/$(TARGETSUFFIX)
+ifdef INSTALL_FPCPACKAGE
+ifdef PACKAGE_NAME
+INSTALL_UNITDIR:=$(INSTALL_UNITDIR)/$(PACKAGE_NAME)
+endif
+endif
+endif
+ifndef INSTALL_LIBDIR
+ifdef UNIXHier
+INSTALL_LIBDIR:=$(INSTALL_PREFIX)/lib
+else
+INSTALL_LIBDIR:=$(INSTALL_UNITDIR)
+endif
+endif
+ifndef INSTALL_SOURCEDIR
+ifdef UNIXHier
+ifdef BSDhier
+SRCPREFIXDIR=share/src
+else
+ifdef linuxHier
+SRCPREFIXDIR=share/src
+else
+SRCPREFIXDIR=src
+endif
+endif
+ifdef INSTALL_FPCPACKAGE
+ifdef INSTALL_FPCSUBDIR
+INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/fpc-$(FPC_VERSION)/$(INSTALL_FPCSUBDIR)/$(PACKAGE_NAME)
+else
+INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/fpc-$(FPC_VERSION)/$(PACKAGE_NAME)
+endif
+else
+INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+endif
+else
+ifdef INSTALL_FPCPACKAGE
+ifdef INSTALL_FPCSUBDIR
+INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source/$(INSTALL_FPCSUBDIR)/$(PACKAGE_NAME)
+else
+INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source/$(PACKAGE_NAME)
+endif
+else
+INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source
+endif
+endif
+endif
+ifndef INSTALL_DOCDIR
+ifdef UNIXHier
+ifdef BSDhier
+DOCPREFIXDIR=share/doc
+else
+ifdef linuxHier
+DOCPREFIXDIR=share/doc
+else
+DOCPREFIXDIR=doc
+endif
+endif
+ifdef INSTALL_FPCPACKAGE
+INSTALL_DOCDIR:=$(INSTALL_PREFIX)/$(DOCPREFIXDIR)/fpc-$(FPC_VERSION)/$(PACKAGE_NAME)
+else
+INSTALL_DOCDIR:=$(INSTALL_PREFIX)/$(DOCPREFIXDIR)/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+endif
+else
+ifdef INSTALL_FPCPACKAGE
+INSTALL_DOCDIR:=$(INSTALL_BASEDIR)/doc/$(PACKAGE_NAME)
+else
+INSTALL_DOCDIR:=$(INSTALL_BASEDIR)/doc
+endif
+endif
+endif
+ifndef INSTALL_EXAMPLEDIR
+ifdef UNIXHier
+ifdef INSTALL_FPCPACKAGE
+ifdef BSDhier
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/share/examples/fpc-$(FPC_VERSION)/$(PACKAGE_NAME)
+else
+ifdef linuxHier
+INSTALL_EXAMPLEDIR:=$(INSTALL_DOCDIR)/examples
+else
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/doc/fpc-$(FPC_VERSION)/examples/$(PACKAGE_NAME)
+endif
+endif
+else
+ifdef BSDhier
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/share/examples/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+else
+ifdef linuxHier
+INSTALL_EXAMPLEDIR:=$(INSTALL_DOCDIR)/examples/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+else
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/doc/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+endif
+endif
+endif
+else
+ifdef INSTALL_FPCPACKAGE
+INSTALL_EXAMPLEDIR:=$(INSTALL_BASEDIR)/examples/$(PACKAGE_NAME)
+else
+INSTALL_EXAMPLEDIR:=$(INSTALL_BASEDIR)/examples
+endif
+endif
+endif
+ifndef INSTALL_DATADIR
+INSTALL_DATADIR=$(INSTALL_BASEDIR)
+endif
+ifndef INSTALL_SHAREDDIR
+INSTALL_SHAREDDIR=$(INSTALL_PREFIX)/lib
+endif
+ifdef CROSSCOMPILE
+ifndef CROSSBINDIR
+CROSSBINDIR:=$(wildcard $(CROSSTARGETDIR)/bin/$(SOURCESUFFIX))
+ifeq ($(CROSSBINDIR),)
+CROSSBINDIR:=$(wildcard $(INSTALL_BASEDIR)/cross/$(TARGETSUFFIX)/bin/$(FULL_SOURCE))
+endif
+endif
+else
+CROSSBINDIR=
+endif
+ifeq ($(OS_SOURCE),linux)
+ifndef GCCLIBDIR
+ifeq ($(CPU_TARGET),i386)
+ifneq ($(findstring x86_64,$(shell uname -a)),)
+ifeq ($(BINUTILSPREFIX),)
+GCCLIBDIR:=$(shell dirname `gcc -m32 -print-libgcc-file-name`)
+endif
+endif
+endif
+ifeq ($(CPU_TARGET),powerpc64)
+ifeq ($(BINUTILSPREFIX),)
+GCCLIBDIR:=$(shell dirname `gcc -m64 -print-libgcc-file-name`)
+endif
+endif
+endif
+ifndef GCCLIBDIR
+CROSSGCC=$(strip $(wildcard $(addsuffix /$(BINUTILSPREFIX)gcc$(SRCEXEEXT),$(SEARCHPATH))))
+ifneq ($(CROSSGCC),)
+GCCLIBDIR:=$(shell dirname `$(CROSSGCC) -print-libgcc-file-name`)
+endif
+endif
+ifndef OTHERLIBDIR
+OTHERLIBDIR:=$(shell grep -v "^\#" /etc/ld.so.conf | awk '{ ORS=" "; print $1 }')
+endif
+endif
+ifdef inUnix
+ifeq ($(OS_SOURCE),netbsd)
+OTHERLIBDIR+=/usr/pkg/lib
+endif
+export GCCLIBDIR OTHERLIB
+endif
+BATCHEXT=.bat
+LOADEREXT=.as
+EXEEXT=.exe
+PPLEXT=.ppl
+PPUEXT=.ppu
+OEXT=.o
+ASMEXT=.s
+SMARTEXT=.sl
+STATICLIBEXT=.a
+SHAREDLIBEXT=.so
+SHAREDLIBPREFIX=libfp
+STATICLIBPREFIX=libp
+IMPORTLIBPREFIX=libimp
+RSTEXT=.rst
+ifeq ($(findstring 1.0.,$(FPC_VERSION)),)
+ifeq ($(OS_TARGET),go32v1)
+STATICLIBPREFIX=
+SHORTSUFFIX=v1
+endif
+ifeq ($(OS_TARGET),go32v2)
+STATICLIBPREFIX=
+SHORTSUFFIX=dos
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),watcom)
+STATICLIBPREFIX=
+OEXT=.obj
+ASMEXT=.asm
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=wat
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),linux)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=lnx
+endif
+ifeq ($(OS_TARGET),freebsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=fbs
+endif
+ifeq ($(OS_TARGET),netbsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=nbs
+endif
+ifeq ($(OS_TARGET),openbsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=obs
+endif
+ifeq ($(OS_TARGET),win32)
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=w32
+endif
+ifeq ($(OS_TARGET),os2)
+BATCHEXT=.cmd
+AOUTEXT=.out
+STATICLIBPREFIX=
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=os2
+ECHO=echo
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),emx)
+BATCHEXT=.cmd
+AOUTEXT=.out
+STATICLIBPREFIX=
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=emx
+ECHO=echo
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),amiga)
+EXEEXT=
+SHAREDLIBEXT=.library
+SHORTSUFFIX=amg
+endif
+ifeq ($(OS_TARGET),morphos)
+EXEEXT=
+SHAREDLIBEXT=.library
+SHORTSUFFIX=mos
+endif
+ifeq ($(OS_TARGET),atari)
+EXEEXT=.ttp
+SHORTSUFFIX=ata
+endif
+ifeq ($(OS_TARGET),beos)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=be
+endif
+ifeq ($(OS_TARGET),haiku)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=hai
+endif
+ifeq ($(OS_TARGET),solaris)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=sun
+endif
+ifeq ($(OS_TARGET),qnx)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=qnx
+endif
+ifeq ($(OS_TARGET),netware)
+EXEEXT=.nlm
+STATICLIBPREFIX=
+SHORTSUFFIX=nw
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),netwlibc)
+EXEEXT=.nlm
+STATICLIBPREFIX=
+SHORTSUFFIX=nwl
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),macos)
+BATCHEXT=
+EXEEXT=
+DEBUGSYMEXT=.xcoff
+SHORTSUFFIX=mac
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),darwin)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=dwn
+endif
+ifeq ($(OS_TARGET),gba)
+EXEEXT=.gba
+SHAREDLIBEXT=.so
+SHORTSUFFIX=gba
+endif
+ifeq ($(OS_TARGET),symbian)
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=symbian
+endif
+else
+ifeq ($(OS_TARGET),go32v1)
+PPUEXT=.pp1
+OEXT=.o1
+ASMEXT=.s1
+SMARTEXT=.sl1
+STATICLIBEXT=.a1
+SHAREDLIBEXT=.so1
+STATICLIBPREFIX=
+SHORTSUFFIX=v1
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),go32v2)
+STATICLIBPREFIX=
+SHORTSUFFIX=dos
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),watcom)
+STATICLIBPREFIX=
+SHORTSUFFIX=wat
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),linux)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=lnx
+endif
+ifeq ($(OS_TARGET),freebsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=fbs
+endif
+ifeq ($(OS_TARGET),netbsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=nbs
+endif
+ifeq ($(OS_TARGET),openbsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=obs
+endif
+ifeq ($(OS_TARGET),win32)
+PPUEXT=.ppw
+OEXT=.ow
+ASMEXT=.sw
+SMARTEXT=.slw
+STATICLIBEXT=.aw
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=w32
+endif
+ifeq ($(OS_TARGET),os2)
+BATCHEXT=.cmd
+PPUEXT=.ppo
+ASMEXT=.so2
+OEXT=.oo2
+AOUTEXT=.out
+SMARTEXT=.sl2
+STATICLIBPREFIX=
+STATICLIBEXT=.ao2
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=os2
+ECHO=echo
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),amiga)
+EXEEXT=
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+SHAREDLIBEXT=.library
+SHORTSUFFIX=amg
+endif
+ifeq ($(OS_TARGET),atari)
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+EXEEXT=.ttp
+SHORTSUFFIX=ata
+endif
+ifeq ($(OS_TARGET),beos)
+BATCHEXT=.sh
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+EXEEXT=
+SHORTSUFFIX=be
+endif
+ifeq ($(OS_TARGET),solaris)
+BATCHEXT=.sh
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+EXEEXT=
+SHORTSUFFIX=sun
+endif
+ifeq ($(OS_TARGET),qnx)
+BATCHEXT=.sh
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+EXEEXT=
+SHORTSUFFIX=qnx
+endif
+ifeq ($(OS_TARGET),netware)
+STATICLIBPREFIX=
+PPUEXT=.ppu
+OEXT=.o
+ASMEXT=.s
+SMARTEXT=.sl
+STATICLIBEXT=.a
+SHAREDLIBEXT=.nlm
+EXEEXT=.nlm
+SHORTSUFFIX=nw
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),netwlibc)
+STATICLIBPREFIX=
+PPUEXT=.ppu
+OEXT=.o
+ASMEXT=.s
+SMARTEXT=.sl
+STATICLIBEXT=.a
+SHAREDLIBEXT=.nlm
+EXEEXT=.nlm
+SHORTSUFFIX=nwl
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),macos)
+BATCHEXT=
+PPUEXT=.ppu
+ASMEXT=.s
+OEXT=.o
+SMARTEXT=.sl
+STATICLIBEXT=.a
+EXEEXT=
+DEBUGSYMEXT=.xcoff
+SHORTSUFFIX=mac
+IMPORTLIBPREFIX=imp
+endif
+endif
+ifneq ($(findstring $(OS_SOURCE),$(LIMIT83fs)),)
+FPCMADE=fpcmade.$(SHORTSUFFIX)
+ZIPSUFFIX=$(SHORTSUFFIX)
+ZIPCROSSPREFIX=
+ZIPSOURCESUFFIX=src
+ZIPEXAMPLESUFFIX=exm
+else
+FPCMADE=fpcmade.$(TARGETSUFFIX)
+ZIPSOURCESUFFIX=.source
+ZIPEXAMPLESUFFIX=.examples
+ifdef CROSSCOMPILE
+ZIPSUFFIX=.$(SOURCESUFFIX)
+ZIPCROSSPREFIX=$(TARGETSUFFIX)-
+else
+ZIPSUFFIX=.$(TARGETSUFFIX)
+ZIPCROSSPREFIX=
+endif
+endif
+ifndef ECHO
+ECHO:=$(strip $(wildcard $(addsuffix /gecho$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO:=$(strip $(wildcard $(addsuffix /echo$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO= __missing_command_ECHO
+else
+ECHO:=$(firstword $(ECHO))
+endif
+else
+ECHO:=$(firstword $(ECHO))
+endif
+endif
+export ECHO
+ifndef DATE
+DATE:=$(strip $(wildcard $(addsuffix /gdate$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(DATE),)
+DATE:=$(strip $(wildcard $(addsuffix /date$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(DATE),)
+DATE= __missing_command_DATE
+else
+DATE:=$(firstword $(DATE))
+endif
+else
+DATE:=$(firstword $(DATE))
+endif
+endif
+export DATE
+ifndef GINSTALL
+GINSTALL:=$(strip $(wildcard $(addsuffix /ginstall$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(GINSTALL),)
+GINSTALL:=$(strip $(wildcard $(addsuffix /install$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(GINSTALL),)
+GINSTALL= __missing_command_GINSTALL
+else
+GINSTALL:=$(firstword $(GINSTALL))
+endif
+else
+GINSTALL:=$(firstword $(GINSTALL))
+endif
+endif
+export GINSTALL
+ifndef CPPROG
+CPPROG:=$(strip $(wildcard $(addsuffix /cp$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(CPPROG),)
+CPPROG= __missing_command_CPPROG
+else
+CPPROG:=$(firstword $(CPPROG))
+endif
+endif
+export CPPROG
+ifndef RMPROG
+RMPROG:=$(strip $(wildcard $(addsuffix /rm$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(RMPROG),)
+RMPROG= __missing_command_RMPROG
+else
+RMPROG:=$(firstword $(RMPROG))
+endif
+endif
+export RMPROG
+ifndef MVPROG
+MVPROG:=$(strip $(wildcard $(addsuffix /mv$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(MVPROG),)
+MVPROG= __missing_command_MVPROG
+else
+MVPROG:=$(firstword $(MVPROG))
+endif
+endif
+export MVPROG
+ifndef MKDIRPROG
+MKDIRPROG:=$(strip $(wildcard $(addsuffix /gmkdir$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(MKDIRPROG),)
+MKDIRPROG:=$(strip $(wildcard $(addsuffix /mkdir$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(MKDIRPROG),)
+MKDIRPROG= __missing_command_MKDIRPROG
+else
+MKDIRPROG:=$(firstword $(MKDIRPROG))
+endif
+else
+MKDIRPROG:=$(firstword $(MKDIRPROG))
+endif
+endif
+export MKDIRPROG
+ifndef ECHOREDIR
+ifndef inUnix
+ECHOREDIR=echo
+else
+ECHOREDIR=$(ECHO)
+endif
+endif
+ifndef COPY
+COPY:=$(CPPROG) -fp
+endif
+ifndef COPYTREE
+COPYTREE:=$(CPPROG) -Rfp
+endif
+ifndef MKDIRTREE
+MKDIRTREE:=$(MKDIRPROG) -p
+endif
+ifndef MOVE
+MOVE:=$(MVPROG) -f
+endif
+ifndef DEL
+DEL:=$(RMPROG) -f
+endif
+ifndef DELTREE
+DELTREE:=$(RMPROG) -rf
+endif
+ifndef INSTALL
+ifdef inUnix
+INSTALL:=$(GINSTALL) -c -m 644
+else
+INSTALL:=$(COPY)
+endif
+endif
+ifndef INSTALLEXE
+ifdef inUnix
+INSTALLEXE:=$(GINSTALL) -c -m 755
+else
+INSTALLEXE:=$(COPY)
+endif
+endif
+ifndef MKDIR
+MKDIR:=$(GINSTALL) -m 755 -d
+endif
+export ECHOREDIR COPY COPYTREE MOVE DEL DELTREE INSTALL INSTALLEXE MKDIR
+ifndef PPUMOVE
+PPUMOVE:=$(strip $(wildcard $(addsuffix /ppumove$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(PPUMOVE),)
+PPUMOVE= __missing_command_PPUMOVE
+else
+PPUMOVE:=$(firstword $(PPUMOVE))
+endif
+endif
+export PPUMOVE
+ifndef FPCMAKE
+FPCMAKE:=$(strip $(wildcard $(addsuffix /fpcmake$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(FPCMAKE),)
+FPCMAKE= __missing_command_FPCMAKE
+else
+FPCMAKE:=$(firstword $(FPCMAKE))
+endif
+endif
+export FPCMAKE
+ifndef ZIPPROG
+ZIPPROG:=$(strip $(wildcard $(addsuffix /zip$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ZIPPROG),)
+ZIPPROG= __missing_command_ZIPPROG
+else
+ZIPPROG:=$(firstword $(ZIPPROG))
+endif
+endif
+export ZIPPROG
+ifndef TARPROG
+TARPROG:=$(strip $(wildcard $(addsuffix /gtar$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(TARPROG),)
+TARPROG:=$(strip $(wildcard $(addsuffix /tar$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(TARPROG),)
+TARPROG= __missing_command_TARPROG
+else
+TARPROG:=$(firstword $(TARPROG))
+endif
+else
+TARPROG:=$(firstword $(TARPROG))
+endif
+endif
+export TARPROG
+ASNAME=$(BINUTILSPREFIX)as
+LDNAME=$(BINUTILSPREFIX)ld
+ARNAME=$(BINUTILSPREFIX)ar
+RCNAME=$(BINUTILSPREFIX)rc
+ifneq ($(findstring 1.0.,$(FPC_VERSION)),)
+ifeq ($(OS_TARGET),win32)
+ifeq ($(CROSSBINDIR),)
+ASNAME=asw
+LDNAME=ldw
+ARNAME=arw
+endif
+endif
+endif
+ifndef ASPROG
+ifdef CROSSBINDIR
+ASPROG=$(CROSSBINDIR)/$(ASNAME)$(SRCEXEEXT)
+else
+ASPROG=$(ASNAME)
+endif
+endif
+ifndef LDPROG
+ifdef CROSSBINDIR
+LDPROG=$(CROSSBINDIR)/$(LDNAME)$(SRCEXEEXT)
+else
+LDPROG=$(LDNAME)
+endif
+endif
+ifndef RCPROG
+ifdef CROSSBINDIR
+RCPROG=$(CROSSBINDIR)/$(RCNAME)$(SRCEXEEXT)
+else
+RCPROG=$(RCNAME)
+endif
+endif
+ifndef ARPROG
+ifdef CROSSBINDIR
+ARPROG=$(CROSSBINDIR)/$(ARNAME)$(SRCEXEEXT)
+else
+ARPROG=$(ARNAME)
+endif
+endif
+AS=$(ASPROG)
+LD=$(LDPROG)
+RC=$(RCPROG)
+AR=$(ARPROG)
+PPAS=ppas$(SRCBATCHEXT)
+ifdef inUnix
+LDCONFIG=ldconfig
+else
+LDCONFIG=
+endif
+ifdef DATE
+DATESTR:=$(shell $(DATE) +%Y%m%d)
+else
+DATESTR=
+endif
+ifndef UPXPROG
+ifeq ($(OS_TARGET),go32v2)
+UPXPROG:=1
+endif
+ifeq ($(OS_TARGET),win32)
+UPXPROG:=1
+endif
+ifdef UPXPROG
+UPXPROG:=$(strip $(wildcard $(addsuffix /upx$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(UPXPROG),)
+UPXPROG=
+else
+UPXPROG:=$(firstword $(UPXPROG))
+endif
+else
+UPXPROG=
+endif
+endif
+export UPXPROG
+ZIPOPT=-9
+ZIPEXT=.zip
+ifeq ($(USETAR),bz2)
+TAROPT=vj
+TAREXT=.tar.bz2
+else
+TAROPT=vz
+TAREXT=.tar.gz
+endif
+override REQUIRE_PACKAGES=rtl gmp
+ifeq ($(FULL_TARGET),i386-linux)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-go32v2)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-win32)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-os2)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-freebsd)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-beos)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-haiku)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-netbsd)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-solaris)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-qnx)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-netware)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-openbsd)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-wdosx)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-darwin)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-emx)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-watcom)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-netwlibc)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-wince)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-embedded)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),i386-symbian)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),m68k-linux)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),m68k-freebsd)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),m68k-netbsd)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),m68k-amiga)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),m68k-atari)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),m68k-openbsd)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),m68k-palmos)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),m68k-embedded)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),powerpc-linux)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),powerpc-netbsd)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),powerpc-amiga)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),powerpc-macos)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),powerpc-darwin)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),powerpc-morphos)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),powerpc-embedded)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),sparc-linux)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),sparc-netbsd)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),sparc-solaris)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),sparc-embedded)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),x86_64-linux)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),x86_64-freebsd)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),x86_64-darwin)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),x86_64-win64)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),x86_64-embedded)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),arm-linux)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),arm-palmos)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),arm-darwin)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),arm-wince)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),arm-gba)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),arm-nds)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),arm-embedded)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),arm-symbian)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),powerpc64-linux)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),powerpc64-darwin)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),powerpc64-embedded)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),avr-embedded)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),armeb-linux)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifeq ($(FULL_TARGET),armeb-embedded)
+REQUIRE_PACKAGES_RTL=1
+REQUIRE_PACKAGES_GMP=1
+endif
+ifdef REQUIRE_PACKAGES_RTL
+PACKAGEDIR_RTL:=$(firstword $(subst /Makefile.fpc,,$(strip $(wildcard $(addsuffix /rtl/Makefile.fpc,$(PACKAGESDIR))))))
+ifneq ($(PACKAGEDIR_RTL),)
+ifneq ($(wildcard $(PACKAGEDIR_RTL)/units/$(TARGETSUFFIX)),)
+UNITDIR_RTL=$(PACKAGEDIR_RTL)/units/$(TARGETSUFFIX)
+else
+UNITDIR_RTL=$(PACKAGEDIR_RTL)
+endif
+ifdef CHECKDEPEND
+$(PACKAGEDIR_RTL)/$(FPCMADE):
+	$(MAKE) -C $(PACKAGEDIR_RTL) $(FPCMADE)
+override ALLDEPENDENCIES+=$(PACKAGEDIR_RTL)/$(FPCMADE)
+endif
+else
+PACKAGEDIR_RTL=
+UNITDIR_RTL:=$(subst /Package.fpc,,$(strip $(wildcard $(addsuffix /rtl/Package.fpc,$(UNITSDIR)))))
+ifneq ($(UNITDIR_RTL),)
+UNITDIR_RTL:=$(firstword $(UNITDIR_RTL))
+else
+UNITDIR_RTL=
+endif
+endif
+ifdef UNITDIR_RTL
+override COMPILER_UNITDIR+=$(UNITDIR_RTL)
+endif
+endif
+ifdef REQUIRE_PACKAGES_GMP
+PACKAGEDIR_GMP:=$(firstword $(subst /Makefile.fpc,,$(strip $(wildcard $(addsuffix /gmp/Makefile.fpc,$(PACKAGESDIR))))))
+ifneq ($(PACKAGEDIR_GMP),)
+ifneq ($(wildcard $(PACKAGEDIR_GMP)/units/$(TARGETSUFFIX)),)
+UNITDIR_GMP=$(PACKAGEDIR_GMP)/units/$(TARGETSUFFIX)
+else
+UNITDIR_GMP=$(PACKAGEDIR_GMP)
+endif
+ifdef CHECKDEPEND
+$(PACKAGEDIR_GMP)/$(FPCMADE):
+	$(MAKE) -C $(PACKAGEDIR_GMP) $(FPCMADE)
+override ALLDEPENDENCIES+=$(PACKAGEDIR_GMP)/$(FPCMADE)
+endif
+else
+PACKAGEDIR_GMP=
+UNITDIR_GMP:=$(subst /Package.fpc,,$(strip $(wildcard $(addsuffix /gmp/Package.fpc,$(UNITSDIR)))))
+ifneq ($(UNITDIR_GMP),)
+UNITDIR_GMP:=$(firstword $(UNITDIR_GMP))
+else
+UNITDIR_GMP=
+endif
+endif
+ifdef UNITDIR_GMP
+override COMPILER_UNITDIR+=$(UNITDIR_GMP)
+endif
+endif
+ifndef NOCPUDEF
+override FPCOPTDEF=$(ARCH)
+endif
+ifneq ($(OS_TARGET),$(OS_SOURCE))
+override FPCOPT+=-T$(OS_TARGET)
+endif
+ifneq ($(CPU_TARGET),$(CPU_SOURCE))
+override FPCOPT+=-P$(ARCH)
+endif
+ifeq ($(OS_SOURCE),openbsd)
+override FPCOPT+=-FD$(NEW_BINUTILS_PATH)
+endif
+ifndef CROSSBOOTSTRAP
+ifneq ($(BINUTILSPREFIX),)
+override FPCOPT+=-XP$(BINUTILSPREFIX)
+endif
+ifneq ($(BINUTILSPREFIX),)
+override FPCOPT+=-Xr$(RLINKPATH)
+endif
+endif
+ifdef UNITDIR
+override FPCOPT+=$(addprefix -Fu,$(UNITDIR))
+endif
+ifdef LIBDIR
+override FPCOPT+=$(addprefix -Fl,$(LIBDIR))
+endif
+ifdef OBJDIR
+override FPCOPT+=$(addprefix -Fo,$(OBJDIR))
+endif
+ifdef INCDIR
+override FPCOPT+=$(addprefix -Fi,$(INCDIR))
+endif
+ifdef LINKSMART
+override FPCOPT+=-XX
+endif
+ifdef CREATESMART
+override FPCOPT+=-CX
+endif
+ifdef DEBUG
+override FPCOPT+=-gl
+override FPCOPTDEF+=DEBUG
+endif
+ifdef RELEASE
+ifneq ($(findstring 2.0.,$(FPC_VERSION)),)
+ifeq ($(CPU_TARGET),i386)
+FPCCPUOPT:=-OG2p3
+endif
+ifeq ($(CPU_TARGET),powerpc)
+FPCCPUOPT:=-O1r
+endif
+else
+FPCCPUOPT:=-O2
+endif
+override FPCOPT+=-Ur -Xs $(FPCCPUOPT) -n
+override FPCOPTDEF+=RELEASE
+endif
+ifdef STRIP
+override FPCOPT+=-Xs
+endif
+ifdef OPTIMIZE
+override FPCOPT+=-O2
+endif
+ifdef VERBOSE
+override FPCOPT+=-vwni
+endif
+ifdef COMPILER_OPTIONS
+override FPCOPT+=$(COMPILER_OPTIONS)
+endif
+ifdef COMPILER_UNITDIR
+override FPCOPT+=$(addprefix -Fu,$(COMPILER_UNITDIR))
+endif
+ifdef COMPILER_LIBRARYDIR
+override FPCOPT+=$(addprefix -Fl,$(COMPILER_LIBRARYDIR))
+endif
+ifdef COMPILER_OBJECTDIR
+override FPCOPT+=$(addprefix -Fo,$(COMPILER_OBJECTDIR))
+endif
+ifdef COMPILER_INCLUDEDIR
+override FPCOPT+=$(addprefix -Fi,$(COMPILER_INCLUDEDIR))
+endif
+ifdef CROSSBINDIR
+override FPCOPT+=-FD$(CROSSBINDIR)
+endif
+ifdef COMPILER_TARGETDIR
+override FPCOPT+=-FE$(COMPILER_TARGETDIR)
+ifeq ($(COMPILER_TARGETDIR),.)
+override TARGETDIRPREFIX=
+else
+override TARGETDIRPREFIX=$(COMPILER_TARGETDIR)/
+endif
+endif
+ifdef COMPILER_UNITTARGETDIR
+override FPCOPT+=-FU$(COMPILER_UNITTARGETDIR)
+ifeq ($(COMPILER_UNITTARGETDIR),.)
+override UNITTARGETDIRPREFIX=
+else
+override UNITTARGETDIRPREFIX=$(COMPILER_UNITTARGETDIR)/
+endif
+else
+ifdef COMPILER_TARGETDIR
+override COMPILER_UNITTARGETDIR=$(COMPILER_TARGETDIR)
+override UNITTARGETDIRPREFIX=$(TARGETDIRPREFIX)
+endif
+endif
+ifdef CREATESHARED
+override FPCOPT+=-Cg
+ifeq ($(CPU_TARGET),i386)
+override FPCOPT+=-Aas
+endif
+endif
+ifeq ($(findstring 2.0.,$(FPC_VERSION)),)
+ifeq ($(OS_TARGET),linux)
+ifeq ($(CPU_TARGET),x86_64)
+override FPCOPT+=-Cg
+endif
+endif
+endif
+ifdef LINKSHARED
+endif
+ifdef GCCLIBDIR
+override FPCOPT+=-Fl$(GCCLIBDIR)
+endif
+ifdef OTHERLIBDIR
+override FPCOPT+=$(addprefix -Fl,$(OTHERLIBDIR))
+endif
+ifdef OPT
+override FPCOPT+=$(OPT)
+endif
+ifdef FPCOPTDEF
+override FPCOPT+=$(addprefix -d,$(FPCOPTDEF))
+endif
+ifdef CFGFILE
+override FPCOPT+=@$(CFGFILE)
+endif
+ifdef USEENV
+override FPCEXTCMD:=$(FPCOPT)
+override FPCOPT:=!FPCEXTCMD
+export FPCEXTCMD
+endif
+override AFULL_TARGET=$(CPU_TARGET)-$(OS_TARGET)
+override AFULL_SOURCE=$(CPU_SOURCE)-$(OS_SOURCE)
+ifneq ($(AFULL_TARGET),$(AFULL_SOURCE))
+override ACROSSCOMPILE=1
+endif
+ifdef ACROSSCOMPILE
+override FPCOPT+=$(CROSSOPT)
+endif
+override COMPILER:=$(FPC) $(FPCOPT)
+ifeq (,$(findstring -s ,$(COMPILER)))
+EXECPPAS=
+else
+ifeq ($(FULL_SOURCE),$(FULL_TARGET))
+ifdef RUNBATCH
+EXECPPAS:=@$(RUNBATCH) $(PPAS)
+else
+EXECPPAS:=@$(PPAS)
+endif
+endif
+endif
+.PHONY: fpc_exes
+ifndef CROSSINSTALL
+ifneq ($(TARGET_PROGRAMS),)
+override EXEFILES=$(addsuffix $(EXEEXT),$(TARGET_PROGRAMS))
+override EXEOFILES:=$(addsuffix $(OEXT),$(TARGET_PROGRAMS)) $(addprefix $(STATICLIBPREFIX),$(addsuffix $(STATICLIBEXT),$(TARGET_PROGRAMS))) $(addprefix $(IMPORTLIBPREFIX),$(addsuffix $(STATICLIBEXT),$(TARGET_PROGRAMS)))
+override ALLTARGET+=fpc_exes
+override INSTALLEXEFILES+=$(EXEFILES)
+override CLEANEXEFILES+=$(EXEFILES) $(EXEOFILES)
+ifeq ($(OS_TARGET),os2)
+override CLEANEXEFILES+=$(addsuffix $(AOUTEXT),$(TARGET_PROGRAMS))
+endif
+ifeq ($(OS_TARGET),emx)
+override CLEANEXEFILES+=$(addsuffix $(AOUTEXT),$(TARGET_PROGRAMS))
+endif
+endif
+endif
+fpc_exes: $(COMPILER_TARGETDIR) $(COMPILER_UNITTARGETDIR) $(EXEFILES)
+ifdef TARGET_RSTS
+override RSTFILES=$(addsuffix $(RSTEXT),$(TARGET_RSTS))
+override CLEANRSTFILES+=$(RSTFILES)
+endif
+.PHONY: fpc_all fpc_smart fpc_debug fpc_release fpc_shared
+$(FPCMADE): $(ALLDEPENDENCIES) $(ALLTARGET)
+	@$(ECHOREDIR) Compiled > $(FPCMADE)
+fpc_all: $(FPCMADE)
+fpc_smart:
+	$(MAKE) all LINKSMART=1 CREATESMART=1
+fpc_debug:
+	$(MAKE) all DEBUG=1
+fpc_release:
+	$(MAKE) all RELEASE=1
+.SUFFIXES: $(EXEEXT) $(PPUEXT) $(OEXT) .pas .lpr .dpr .pp .rc .res
+$(COMPILER_UNITTARGETDIR):
+	$(MKDIRTREE) $(COMPILER_UNITTARGETDIR)
+$(COMPILER_TARGETDIR):
+	$(MKDIRTREE) $(COMPILER_TARGETDIR)
+%$(PPUEXT): %.pp
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(PPUEXT): %.pas
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.pp
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.pas
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.lpr
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.dpr
+	$(COMPILER) $<
+	$(EXECPPAS)
+%.res: %.rc
+	windres -i $< -o $@
+vpath %.pp $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.pas $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.lpr $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.dpr $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.inc $(COMPILER_INCLUDEDIR)
+vpath %$(OEXT) $(COMPILER_UNITTARGETDIR)
+vpath %$(PPUEXT) $(COMPILER_UNITTARGETDIR)
+.PHONY: fpc_shared
+override INSTALLTARGET+=fpc_shared_install
+ifndef SHARED_LIBVERSION
+SHARED_LIBVERSION=$(FPC_VERSION)
+endif
+ifndef SHARED_LIBNAME
+SHARED_LIBNAME=$(PACKAGE_NAME)
+endif
+ifndef SHARED_FULLNAME
+SHARED_FULLNAME=$(SHAREDLIBPREFIX)$(SHARED_LIBNAME)-$(SHARED_LIBVERSION)$(SHAREDLIBEXT)
+endif
+ifndef SHARED_LIBUNITS
+SHARED_LIBUNITS:=$(TARGET_UNITS) $(TARGET_IMPLICITUNITS)
+override SHARED_LIBUNITS:=$(filter-out $(INSTALL_BUILDUNIT),$(SHARED_LIBUNITS))
+endif
+fpc_shared:
+ifdef HASSHAREDLIB
+	$(MAKE) all CREATESHARED=1 LINKSHARED=1 CREATESMART=1
+ifneq ($(SHARED_BUILD),n)
+	$(PPUMOVE) -q $(SHARED_LIBUNITS) -i$(COMPILER_UNITTARGETDIR) -o$(SHARED_FULLNAME) -d$(COMPILER_UNITTARGETDIR)
+endif
+else
+	@$(ECHO) Shared Libraries not supported
+endif
+fpc_shared_install:
+ifneq ($(SHARED_BUILD),n)
+ifneq ($(SHARED_LIBUNITS),)
+ifneq ($(wildcard $(COMPILER_UNITTARGETDIR)/$(SHARED_FULLNAME)),)
+	$(INSTALL) $(COMPILER_UNITTARGETDIR)/$(SHARED_FULLNAME) $(INSTALL_SHAREDDIR)
+endif
+endif
+endif
+.PHONY: fpc_install fpc_sourceinstall fpc_exampleinstall
+ifdef INSTALL_UNITS
+override INSTALLPPUFILES+=$(addsuffix $(PPUEXT),$(INSTALL_UNITS))
+endif
+ifdef INSTALL_BUILDUNIT
+override INSTALLPPUFILES:=$(filter-out $(INSTALL_BUILDUNIT)$(PPUEXT),$(INSTALLPPUFILES))
+endif
+ifdef INSTALLPPUFILES
+override INSTALLPPULINKFILES:=$(subst $(PPUEXT),$(OEXT),$(INSTALLPPUFILES)) $(addprefix $(STATICLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(INSTALLPPUFILES))) $(addprefix $(IMPORTLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(INSTALLPPUFILES)))
+ifneq ($(UNITTARGETDIRPREFIX),)
+override INSTALLPPUFILES:=$(addprefix $(UNITTARGETDIRPREFIX),$(notdir $(INSTALLPPUFILES)))
+override INSTALLPPULINKFILES:=$(wildcard $(addprefix $(UNITTARGETDIRPREFIX),$(notdir $(INSTALLPPULINKFILES))))
+endif
+override INSTALL_CREATEPACKAGEFPC=1
+endif
+ifdef INSTALLEXEFILES
+ifneq ($(TARGETDIRPREFIX),)
+override INSTALLEXEFILES:=$(addprefix $(TARGETDIRPREFIX),$(notdir $(INSTALLEXEFILES)))
+endif
+endif
+fpc_install: all $(INSTALLTARGET)
+ifdef INSTALLEXEFILES
+	$(MKDIR) $(INSTALL_BINDIR)
+ifdef UPXPROG
+	-$(UPXPROG) $(INSTALLEXEFILES)
+endif
+	$(INSTALLEXE) $(INSTALLEXEFILES) $(INSTALL_BINDIR)
+endif
+ifdef INSTALL_CREATEPACKAGEFPC
+ifdef FPCMAKE
+ifdef PACKAGE_VERSION
+ifneq ($(wildcard Makefile.fpc),)
+	$(FPCMAKE) -p -T$(CPU_TARGET)-$(OS_TARGET) Makefile.fpc
+	$(MKDIR) $(INSTALL_UNITDIR)
+	$(INSTALL) Package.fpc $(INSTALL_UNITDIR)
+endif
+endif
+endif
+endif
+ifdef INSTALLPPUFILES
+	$(MKDIR) $(INSTALL_UNITDIR)
+	$(INSTALL) $(INSTALLPPUFILES) $(INSTALL_UNITDIR)
+ifneq ($(INSTALLPPULINKFILES),)
+	$(INSTALL) $(INSTALLPPULINKFILES) $(INSTALL_UNITDIR)
+endif
+ifneq ($(wildcard $(LIB_FULLNAME)),)
+	$(MKDIR) $(INSTALL_LIBDIR)
+	$(INSTALL) $(LIB_FULLNAME) $(INSTALL_LIBDIR)
+ifdef inUnix
+	ln -sf $(LIB_FULLNAME) $(INSTALL_LIBDIR)/$(LIB_NAME)
+endif
+endif
+endif
+ifdef INSTALL_FILES
+	$(MKDIR) $(INSTALL_DATADIR)
+	$(INSTALL) $(INSTALL_FILES) $(INSTALL_DATADIR)
+endif
+fpc_sourceinstall: distclean
+	$(MKDIR) $(INSTALL_SOURCEDIR)
+	$(COPYTREE) $(BASEDIR)/* $(INSTALL_SOURCEDIR)
+fpc_exampleinstall: $(addsuffix _distclean,$(TARGET_EXAMPLEDIRS))
+ifdef HASEXAMPLES
+	$(MKDIR) $(INSTALL_EXAMPLEDIR)
+endif
+ifdef EXAMPLESOURCEFILES
+	$(COPY) $(EXAMPLESOURCEFILES) $(INSTALL_EXAMPLEDIR)
+endif
+ifdef TARGET_EXAMPLEDIRS
+	$(COPYTREE) $(addsuffix /*,$(TARGET_EXAMPLEDIRS)) $(INSTALL_EXAMPLEDIR)
+endif
+.PHONY: fpc_clean fpc_cleanall fpc_distclean
+ifdef EXEFILES
+override CLEANEXEFILES:=$(addprefix $(TARGETDIRPREFIX),$(CLEANEXEFILES))
+endif
+ifdef CLEAN_UNITS
+override CLEANPPUFILES+=$(addsuffix $(PPUEXT),$(CLEAN_UNITS))
+endif
+ifdef CLEANPPUFILES
+override CLEANPPULINKFILES:=$(subst $(PPUEXT),$(OEXT),$(CLEANPPUFILES)) $(addprefix $(STATICLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(CLEANPPUFILES))) $(addprefix $(IMPORTLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(CLEANPPUFILES)))
+ifdef DEBUGSYMEXT
+override CLEANPPULINKFILES+=$(subst $(PPUEXT),$(DEBUGSYMEXT),$(CLEANPPUFILES))
+endif
+override CLEANPPUFILES:=$(addprefix $(UNITTARGETDIRPREFIX),$(CLEANPPUFILES))
+override CLEANPPULINKFILES:=$(wildcard $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANPPULINKFILES)))
+endif
+fpc_clean: $(CLEANTARGET)
+ifdef CLEANEXEFILES
+	-$(DEL) $(CLEANEXEFILES)
+endif
+ifdef CLEANPPUFILES
+	-$(DEL) $(CLEANPPUFILES)
+endif
+ifneq ($(CLEANPPULINKFILES),)
+	-$(DEL) $(CLEANPPULINKFILES)
+endif
+ifdef CLEANRSTFILES
+	-$(DEL) $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANRSTFILES))
+endif
+ifdef CLEAN_FILES
+	-$(DEL) $(CLEAN_FILES)
+endif
+ifdef LIB_NAME
+	-$(DEL) $(LIB_NAME) $(LIB_FULLNAME)
+endif
+	-$(DEL) $(FPCMADE) Package.fpc $(PPAS) script.res link.res $(FPCEXTFILE) $(REDIRFILE)
+	-$(DEL) *$(ASMEXT) *_ppas$(BATCHEXT)
+fpc_cleanall: $(CLEANTARGET)
+ifdef CLEANEXEFILES
+	-$(DEL) $(CLEANEXEFILES)
+endif
+ifdef COMPILER_UNITTARGETDIR
+ifdef CLEANPPUFILES
+	-$(DEL) $(CLEANPPUFILES)
+endif
+ifneq ($(CLEANPPULINKFILES),)
+	-$(DEL) $(CLEANPPULINKFILES)
+endif
+ifdef CLEANRSTFILES
+	-$(DEL) $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANRSTFILES))
+endif
+endif
+	-$(DELTREE) units
+	-$(DEL) *$(OEXT) *$(PPUEXT) *$(RSTEXT) *$(ASMEXT) *$(STATICLIBEXT) *$(SHAREDLIBEXT) *$(PPLEXT)
+ifneq ($(PPUEXT),.ppu)
+	-$(DEL) *.o *.ppu *.a
+endif
+	-$(DELTREE) *$(SMARTEXT)
+	-$(DEL) fpcmade.* Package.fpc $(PPAS) script.res link.res $(FPCEXTFILE) $(REDIRFILE)
+	-$(DEL) *_ppas$(BATCHEXT)
+ifdef AOUTEXT
+	-$(DEL) *$(AOUTEXT)
+endif
+ifdef DEBUGSYMEXT
+	-$(DEL) *$(DEBUGSYMEXT)
+endif
+fpc_distclean: cleanall
+.PHONY: fpc_baseinfo
+override INFORULES+=fpc_baseinfo
+fpc_baseinfo:
+	@$(ECHO)
+	@$(ECHO)  == Package info ==
+	@$(ECHO)  Package Name..... $(PACKAGE_NAME)
+	@$(ECHO)  Package Version.. $(PACKAGE_VERSION)
+	@$(ECHO)
+	@$(ECHO)  == Configuration info ==
+	@$(ECHO)
+	@$(ECHO)  FPC.......... $(FPC)
+	@$(ECHO)  FPC Version.. $(FPC_VERSION)
+	@$(ECHO)  Source CPU... $(CPU_SOURCE)
+	@$(ECHO)  Target CPU... $(CPU_TARGET)
+	@$(ECHO)  Source OS.... $(OS_SOURCE)
+	@$(ECHO)  Target OS.... $(OS_TARGET)
+	@$(ECHO)  Full Source.. $(FULL_SOURCE)
+	@$(ECHO)  Full Target.. $(FULL_TARGET)
+	@$(ECHO)  SourceSuffix. $(SOURCESUFFIX)
+	@$(ECHO)  TargetSuffix. $(TARGETSUFFIX)
+	@$(ECHO)
+	@$(ECHO)  == Directory info ==
+	@$(ECHO)
+	@$(ECHO)  Required pkgs... $(REQUIRE_PACKAGES)
+	@$(ECHO)
+	@$(ECHO)  Basedir......... $(BASEDIR)
+	@$(ECHO)  FPCDir.......... $(FPCDIR)
+	@$(ECHO)  CrossBinDir..... $(CROSSBINDIR)
+	@$(ECHO)  UnitsDir........ $(UNITSDIR)
+	@$(ECHO)  PackagesDir..... $(PACKAGESDIR)
+	@$(ECHO)
+	@$(ECHO)  GCC library..... $(GCCLIBDIR)
+	@$(ECHO)  Other library... $(OTHERLIBDIR)
+	@$(ECHO)
+	@$(ECHO)  == Tools info ==
+	@$(ECHO)
+	@$(ECHO)  As........ $(AS)
+	@$(ECHO)  Ld........ $(LD)
+	@$(ECHO)  Ar........ $(AR)
+	@$(ECHO)  Rc........ $(RC)
+	@$(ECHO)
+	@$(ECHO)  Mv........ $(MVPROG)
+	@$(ECHO)  Cp........ $(CPPROG)
+	@$(ECHO)  Rm........ $(RMPROG)
+	@$(ECHO)  GInstall.. $(GINSTALL)
+	@$(ECHO)  Echo...... $(ECHO)
+	@$(ECHO)  Shell..... $(SHELL)
+	@$(ECHO)  Date...... $(DATE)
+	@$(ECHO)  FPCMake... $(FPCMAKE)
+	@$(ECHO)  PPUMove... $(PPUMOVE)
+	@$(ECHO)  Upx....... $(UPXPROG)
+	@$(ECHO)  Zip....... $(ZIPPROG)
+	@$(ECHO)
+	@$(ECHO)  == Object info ==
+	@$(ECHO)
+	@$(ECHO)  Target Loaders........ $(TARGET_LOADERS)
+	@$(ECHO)  Target Units.......... $(TARGET_UNITS)
+	@$(ECHO)  Target Implicit Units. $(TARGET_IMPLICITUNITS)
+	@$(ECHO)  Target Programs....... $(TARGET_PROGRAMS)
+	@$(ECHO)  Target Dirs........... $(TARGET_DIRS)
+	@$(ECHO)  Target Examples....... $(TARGET_EXAMPLES)
+	@$(ECHO)  Target ExampleDirs.... $(TARGET_EXAMPLEDIRS)
+	@$(ECHO)
+	@$(ECHO)  Clean Units......... $(CLEAN_UNITS)
+	@$(ECHO)  Clean Files......... $(CLEAN_FILES)
+	@$(ECHO)
+	@$(ECHO)  Install Units....... $(INSTALL_UNITS)
+	@$(ECHO)  Install Files....... $(INSTALL_FILES)
+	@$(ECHO)
+	@$(ECHO)  == Install info ==
+	@$(ECHO)
+	@$(ECHO)  DateStr.............. $(DATESTR)
+	@$(ECHO)  ZipName.............. $(ZIPNAME)
+	@$(ECHO)  ZipPrefix............ $(ZIPPREFIX)
+	@$(ECHO)  ZipCrossPrefix....... $(ZIPCROSSPREFIX)
+	@$(ECHO)  ZipSuffix............ $(ZIPSUFFIX)
+	@$(ECHO)  FullZipName.......... $(FULLZIPNAME)
+	@$(ECHO)  Install FPC Package.. $(INSTALL_FPCPACKAGE)
+	@$(ECHO)
+	@$(ECHO)  Install base dir..... $(INSTALL_BASEDIR)
+	@$(ECHO)  Install binary dir... $(INSTALL_BINDIR)
+	@$(ECHO)  Install library dir.. $(INSTALL_LIBDIR)
+	@$(ECHO)  Install units dir.... $(INSTALL_UNITDIR)
+	@$(ECHO)  Install source dir... $(INSTALL_SOURCEDIR)
+	@$(ECHO)  Install doc dir...... $(INSTALL_DOCDIR)
+	@$(ECHO)  Install example dir.. $(INSTALL_EXAMPLEDIR)
+	@$(ECHO)  Install data dir..... $(INSTALL_DATADIR)
+	@$(ECHO)
+	@$(ECHO)  Dist destination dir. $(DIST_DESTDIR)
+	@$(ECHO)  Dist zip name........ $(DIST_ZIPNAME)
+	@$(ECHO)
+.PHONY: fpc_info
+fpc_info: $(INFORULES)
+.PHONY: fpc_makefile fpc_makefiles fpc_makefile_sub1 fpc_makefile_sub2 \
+	fpc_makefile_dirs
+fpc_makefile:
+	$(FPCMAKE) -w -T$(OS_TARGET) Makefile.fpc
+fpc_makefile_sub1:
+ifdef TARGET_DIRS
+	$(FPCMAKE) -w -T$(OS_TARGET) $(addsuffix /Makefile.fpc,$(TARGET_DIRS))
+endif
+ifdef TARGET_EXAMPLEDIRS
+	$(FPCMAKE) -w -T$(OS_TARGET) $(addsuffix /Makefile.fpc,$(TARGET_EXAMPLEDIRS))
+endif
+fpc_makefile_sub2: $(addsuffix _makefile_dirs,$(TARGET_DIRS) $(TARGET_EXAMPLEDIRS))
+fpc_makefile_dirs: fpc_makefile_sub1 fpc_makefile_sub2
+fpc_makefiles: fpc_makefile fpc_makefile_dirs
+all: fpc_all
+debug: fpc_debug
+smart: fpc_smart
+release: fpc_release
+units: fpc_units
+examples:
+shared: fpc_shared
+install: fpc_install
+sourceinstall: fpc_sourceinstall
+exampleinstall: fpc_exampleinstall
+distinstall:
+zipinstall:
+zipsourceinstall:
+zipexampleinstall:
+zipdistinstall:
+clean: fpc_clean
+distclean: fpc_distclean
+cleanall: fpc_cleanall
+info: fpc_info
+makefiles: fpc_makefiles
+.PHONY: all debug smart release units examples shared install sourceinstall exampleinstall distinstall zipinstall zipsourceinstall zipexampleinstall zipdistinstall clean distclean cleanall info makefiles
+ifneq ($(wildcard fpcmake.loc),)
+include fpcmake.loc
+endif
+.NOTPARALLEL:

packages/gmp/examples/Makefile.fpc

@@ -0,0 +1,21 @@
+#
+#   Makefile.fpc for Free Pascal GTK 2.x.y Examples
+#
+
+[target]
+programs=gmp_accept_test gmp_testcase pidigits_example pidigits_example2 printf_example printf_example2 scanf_example scanf_example2
+
+[require]
+packages=gmp
+
+[install]
+fpcpackage=y
+
+[default]
+fpcdir=../../..
+
+[rules]
+.NOTPARALLEL:
+
+
+

packages/gmp/examples/gmp_accept_test.pas

@@ -0,0 +1,45 @@
+program gmp_accept_test;
+
+{$mode objfpc}{$H+}
+
+uses
+  heaptrc, testutils, strutils, math, sysutils, gmp, classes;
+
+
+type
+  TTestCase = class(TPersistent);
+  TTestCases = class of TTestCase;
+
+{$include gmp_test_intf}
+{$include gmp_test_impl}
+
+procedure Run(Tests: array of TTestCases);
+var
+  TestObj: TTestCase;
+  MethodList: TStringList;
+  TI, MI: integer;
+  Test: procedure of object;
+begin
+  for TI := 0 to Length(Tests) - 1 do begin
+    TestObj := Tests[TI].Create;
+    MethodList := TStringList.Create;
+    try
+      TMethod(Test).Data := TestObj;
+      GetMethodList(TestObj, MethodList);
+      for MI := 0 to MethodList.Count - 1 do begin
+        TMethod(Test).Code := MethodList.Objects[MI];
+        Test;
+      end;
+      WriteLn(Format('%s: Tests executed: %d.', [TestObj.ClassName, MethodList.Count]));
+    finally
+      MethodList.Free;
+      TestObj.Free;
+    end;
+  end;
+end;
+
+begin
+  HaltOnNotReleased := True; // exit code wanted
+  Run([TTestGmpBinding, TTestGmpExtensions, TTestGmpOperators]);
+end.
+

packages/gmp/examples/gmp_test_impl.inc

@@ -0,0 +1,7848 @@
+{$ifopt c-}
+{$error 'Must enable assertions'}
+{$endif}
+
+const
+  BASE10 = 10;
+  BASE16 = 16;
+  Z_FMT = '%Zd';
+  Q_FMT = '%Qd';
+
+function alloc_func(alloc_size: sizeuint): pointer; cdecl;
+begin
+  result := getmem(alloc_size);
+end;
+
+procedure free_proc(p: pointer; size: sizeuint); cdecl;
+begin
+  assert(size = size); // hint off
+  freemem(p);
+end;
+
+function reallocate_func(p: pointer; old_size, new_size: sizeuint): pointer; cdecl;
+begin
+  assert(old_size = old_size); // hint off
+  result := reallocmem(p, new_size);
+end;
+
+function rnd_test(var state: randstate_t): boolean;
+const N = 1000000;
+var r1, r2, r3: valuint;
+begin
+  r1 := mp_urandomm_ui(state, N);
+  r2 := mp_urandomm_ui(state, N);
+  r3 := mp_urandomm_ui(state, N);
+  result := (r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3));
+end;
+
+{ TTestGmpBinding }
+
+procedure TTestGmpBinding.mp_set_memory_functions_test;
+var
+  af0, af: alloc_func_t;
+  rf0, rf: reallocate_func_t;
+  fp0, fp: free_proc_t;
+begin
+  mp_get_memory_functions(@af0, @rf0, @fp0);
+  try
+    mp_set_memory_functions(@alloc_func, @reallocate_func, @free_proc);
+    mp_get_memory_functions(@af, @rf, @fp);
+    assert(af = @alloc_func);
+    assert(rf = @reallocate_func);
+    assert(fp = @free_proc);
+  finally
+    mp_set_memory_functions(af0, rf0, fp0);
+    mp_get_memory_functions(@af, @rf, @fp);
+    assert(af = af0);
+    assert(rf = rf0);
+    assert(fp = fp0);
+  end;
+end;
+
+procedure TTestGmpBinding.mp_get_memory_functions_test;
+var
+  af: alloc_func_t;
+  fp: free_proc_t;
+  rf: reallocate_func_t;
+begin
+  af := nil;
+  fp := nil;
+  rf := nil;
+  mp_get_memory_functions(nil, nil, nil);
+  assert(af = nil);
+  assert(fp = nil);
+  assert(rf = nil);
+
+  mp_get_memory_functions(@af, nil, nil);
+  assert(af <> nil);
+  assert(fp = nil);
+  assert(rf = nil);
+
+  af := nil;
+  mp_get_memory_functions(nil, @rf, nil);
+  assert(af = nil);
+  assert(fp = nil);
+  assert(rf <> nil);
+
+  rf := nil;
+  mp_get_memory_functions(nil, nil, @fp);
+  assert(af = nil);
+  assert(fp <> nil);
+  assert(rf = nil);
+end;
+
+procedure TTestGmpBinding.mp_randinit_default_test;
+var state: randstate_t;
+begin
+  mp_randinit_default(state);
+  assert(rnd_test(state));
+  mp_randclear(state);
+end;
+
+procedure TTestGmpBinding.mp_randinit_mt_test;
+var state: randstate_t;
+begin
+  mp_randinit_mt(state);
+  assert(rnd_test(state));
+  mp_randclear(state);
+end;
+
+procedure TTestGmpBinding.mp_randinit_lc_2exp_test;
+const
+  A_ =  3;
+  C = 5;
+  M2EXP = 8;
+var
+  state: randstate_t;
+  a: mpz_t;
+begin
+  mpz_init_set_ui(a, A_);
+  mp_randinit_lc_2exp(state, a, C, M2EXP);
+  assert(rnd_test(state));
+  mp_randclear(state);
+  mpz_clear(a);
+end;
+
+procedure TTestGmpBinding.mp_randinit_lc_2exp_size_test;
+var state: randstate_t;
+begin
+  assert(longbool(mp_randinit_lc_2exp_size(state, 0)));
+  assert(rnd_test(state));
+  mp_randclear(state);
+end;
+
+procedure TTestGmpBinding.mp_randinit_set_test;
+var rop, op: randstate_t;
+begin
+  mp_randinit_default(op);
+  mp_randinit_set(rop, op);
+  assert(rnd_test(rop));
+  mp_randclear(rop);
+  mp_randclear(op);
+end;
+
+procedure TTestGmpBinding.mp_randclear_test;
+var state: randstate_t;
+begin
+  mp_randinit_default(state);
+  mp_randclear(state);
+end;
+
+procedure TTestGmpBinding.mp_randseed_test;
+var
+  state: randstate_t;
+  seed: mpz_t;
+begin
+  mp_randinit_default(state);
+  mpz_init_set_ui(seed, 0);
+  mp_randseed(state, seed);
+  mp_randclear(state);
+  mpz_clear(seed);
+end;
+
+procedure TTestGmpBinding.mp_randseed_ui_test;
+var state: randstate_t;
+begin
+  mp_randinit_default(state);
+  mp_randseed_ui(state, 0);
+  mp_randclear(state);
+end;
+
+procedure TTestGmpBinding.mp_urandomb_ui_test;
+const
+  B = 8 * (sizeof(valuint) - 1);
+  N = 1 shl B;
+var
+  state: randstate_t;
+  r1, r2, r3: valuint;
+begin
+  mp_randinit_default(state);
+  r1 := mp_urandomb_ui(state, B);
+  r2 := mp_urandomb_ui(state, B);
+  r3 := mp_urandomb_ui(state, B);
+  assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
+  mp_randclear(state);
+end;
+
+procedure TTestGmpBinding.mp_urandomm_ui_test;
+const  N = high(valuint);
+var
+  state: randstate_t;
+  r1, r2, r3: valuint;
+begin
+  mp_randinit_default(state);
+  r1 := mp_urandomm_ui(state, N);
+  r2 := mp_urandomm_ui(state, N);
+  r3 := mp_urandomm_ui(state, N);
+  assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
+  mp_randclear(state);
+end;
+
+procedure TTestGmpBinding.mp_asprintf_test;
+const
+  N = 123456;
+  S = '123456';
+var
+  z: mpz_t;
+  p: pchar;
+begin
+  mpz_init_set_ui(z, N);
+  assert(mp_asprintf(p, Z_FMT, [@z]) = length(S));
+  assert(p = S);
+  freemem(p);
+  mpz_clear(z);
+end;
+
+procedure TTestGmpBinding.mp_asprintf_test2;
+const
+  N = 123456;
+  S = '123456';
+var
+  z: mpz_t;
+  p: pchar;
+begin
+  mpz_init_set_ui(z, N);
+  assert(mp_asprintf(p, Z_FMT, @z) = length(S));
+  assert(p = S);
+  freemem(p);
+  mpz_clear(z);
+end;
+
+procedure TTestGmpBinding.mp_snprintf_test;
+const
+  N = 123456;
+  S = '123456';
+var
+  z: mpz_t;
+  buf: pchar;
+begin
+  mpz_init_set_ui(z, N);
+  getmem(buf, length(S) + 1);
+  assert(mp_snprintf(buf, length(S) + 1, Z_FMT, [@z]) = length(S));
+  assert(buf = S);
+  freemem(buf);
+  mpz_clear(z);
+end;
+
+procedure TTestGmpBinding.mp_snprintf_test2;
+const
+  N = 123456;
+  S = '123456';
+var
+  z: mpz_t;
+  buf: pchar;
+begin
+  mpz_init_set_ui(z, N);
+  getmem(buf, length(S) + 1);
+  assert(mp_snprintf(buf, length(S) + 1, Z_FMT, @z) = length(S));
+  assert(buf = S);
+  freemem(buf);
+  mpz_clear(z);
+end;
+
+procedure TTestGmpBinding.mp_sprintf_test;
+const
+  N = 123456;
+  S = '123456';
+var
+  z: mpz_t;
+  buf: pchar;
+begin
+  mpz_init_set_ui(z, N);
+  getmem(buf, length(S) + 1);
+  assert(mp_sprintf(buf, Z_FMT, [@z]) = length(S));
+  assert(buf = S);
+  freemem(buf);
+  mpz_clear(z);
+end;
+
+procedure TTestGmpBinding.mp_sprintf_test2;
+const
+  N = 123456;
+  S = '123456';
+var
+  z: mpz_t;
+  buf: pchar;
+begin
+  mpz_init_set_ui(z, N);
+  getmem(buf, length(S) + 1);
+  assert(mp_sprintf(buf, Z_FMT, @z) = length(S));
+  assert(buf = S);
+  freemem(buf);
+  mpz_clear(z);
+end;
+
+procedure TTestGmpBinding.mp_sscanf_test;
+const
+  N = 3;
+  D = 2;
+var q: mpq_t;
+begin
+  mpq_init(q);
+  assert(mp_sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, [@q]) = 1);
+  assert(mpq_cmp_ui(q, N, D) = 0);
+  mpq_clear(q);
+end;
+
+procedure TTestGmpBinding.mp_sscanf_test2;
+const
+  N = 3;
+  D = 2;
+var q: mpq_t;
+begin
+  mpq_init(q);
+  assert(mp_sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, @q) = 1);
+  assert(mpq_cmp_ui(q, N, D) = 0);
+  mpq_clear(q);
+end;
+
+procedure TTestGmpBinding.mpz_init_test;
+var integer_: mpz_t;
+begin
+  mpz_init(integer_);
+  assert(mpz_get_si(integer_) = 0);
+  mpz_clear(integer_);
+end;
+
+procedure TTestGmpBinding.mpz_clear_test;
+const N = 1000000;
+var integer_: mpz_t;
+begin
+  mpz_init2(integer_, N);
+  assert(mpz_get_si(integer_) = 0);
+  mpz_clear(integer_);
+end;
+
+procedure TTestGmpBinding.mpz_init2_test;
+const N = 1000000;
+var integer_: mpz_t;
+begin
+  mpz_init2(integer_, N);
+  assert(mpz_get_si(integer_) = 0);
+  mpz_clear(integer_);
+end;
+
+procedure TTestGmpBinding.mpz_init_set_si_test;
+const N = -1000000;
+var rop: mpz_t;
+begin
+  mpz_init_set_si(rop, N);
+  assert(mpz_get_si(rop) = N);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_init_set_ui_test;
+const N = 1000000;
+var rop: mpz_t;
+begin
+  mpz_init_set_ui(rop, N);
+  assert(mpz_get_ui(rop) = N);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_init_set_d_test;
+const N = -1000000;
+var rop: mpz_t;
+begin
+  mpz_init_set_d(rop, N);
+  assert(mpz_get_si(rop) = N);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_init_set_test;
+const N = -1000000;
+var rop, op: mpz_t;
+begin
+  mpz_init_set_si(op, N);
+  mpz_init_set(rop, op);
+  assert(mpz_get_si(rop) = N);
+  mpz_clear(rop);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_init_set_str_test;
+const N = 1000000;
+var rop: mpz_t;
+begin
+  assert(mpz_init_set_str(rop, pchar(inttostr(N)), BASE10) = 0);
+  assert(mpz_get_si(rop) = N);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_realloc_test;
+const N = 1000;
+var integer_: mpz_t;
+begin
+  mpz_init(integer_);
+  mpz_realloc(integer_, N);
+  mpz_clear(integer_)
+end;
+
+procedure TTestGmpBinding.mpz_realloc2_test;
+const N = 1000;
+var integer_: mpz_t;
+begin
+  mpz_init(integer_);
+  mpz_realloc2(integer_, N);
+  mpz_clear(integer_)
+end;
+
+procedure TTestGmpBinding.mpz_getlimbn_test;
+const N = 1234;
+var op: mpz_t;
+begin
+  mpz_init_set_ui(op, N);
+  assert(mpz_getlimbn(op, 0) = N);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_export_test;
+type t = word;
+const
+  N = 1000000;
+  BUF_HIGH = sizeof(N) div sizeof(t);
+var
+  export_op, import_op: mpz_t;
+  buf: array[0..BUF_HIGH] of t;
+  count: sizeuint;
+begin
+  mpz_init_set_si(export_op, N);
+  mpz_init(import_op);
+  mpz_export(buf, count, -1, sizeof(t), 0, 0, export_op);
+  mpz_import(import_op, count, -1, sizeof(t), 0, 0, buf);
+  assert(mpz_get_si(export_op) =mpz_get_si(import_op));
+  mpz_clear(export_op);
+  mpz_clear(import_op);
+end;
+
+procedure TTestGmpBinding.mpz_import_test;
+type t = word;
+const
+  N = 1000000;
+  BUF_HIGH = sizeof(N) div sizeof(t);
+var
+  export_op, import_op: mpz_t;
+  buf: array[0..BUF_HIGH] of t;
+  count: sizeuint;
+begin
+  mpz_init_set_si(export_op, N);
+  mpz_init(import_op);
+  mpz_export(buf, count, -1, sizeof(t), 0, 0, export_op);
+  mpz_import(import_op, count, -1, sizeof(t), 0, 0, buf);
+  assert(mpz_get_si(export_op) =mpz_get_si(import_op));
+  mpz_clear(export_op);
+  mpz_clear(import_op);
+end;
+
+procedure TTestGmpBinding.mpz_swap_test;
+const
+  ROP_1 = -1000;
+  ROP_2 = 1000000;
+var rop1, rop2: mpz_t;
+begin
+  mpz_init_set_si(rop1, ROP_1);
+  mpz_init_set_si(rop2, ROP_2);
+  mpz_swap(rop1, rop2);
+  assert(mpz_get_si(rop1) = ROP_2);
+  assert(mpz_get_si(rop2) = ROP_1);
+  mpz_clear(rop1);
+  mpz_clear(rop2);
+end;
+
+procedure TTestGmpBinding.mpz_set_test;
+const OP_ = 1000000;
+var rop, op: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op, OP_);
+  mpz_set(rop, op);
+  assert(mpz_get_si(rop) = OP_);
+  mpz_clear(rop);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_set_d_test;
+const OP_ = 1000000;
+var rop: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_set_d(rop, OP_);
+  assert(mpz_get_si(rop) = OP_);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_set_f_test;
+const OP_ = -10;
+var
+  op: mpf_t;
+  rop: mpz_t;
+begin
+  mpf_init_set_si(op, OP_);
+  mpz_init(rop);
+  mpz_set_f(rop, op);
+  assert(mpz_get_si(rop) = OP_);
+  mpz_clear(rop);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_set_q_test;
+const OP_ = -10;
+var
+  op: mpq_t;
+  rop: mpz_t;
+begin
+  mpq_init(op);
+  mpz_init(rop);
+  mpq_set_si(op, OP_, 1);
+  mpz_set_q(rop, op);
+  assert(mpz_get_si(rop) = OP_);
+  mpz_clear(rop);
+  mpq_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_set_si_test;
+const OP_ = -1000000;
+var rop: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_set_si(rop, OP_);
+  assert(mpz_get_si(rop) = OP_);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_set_str_test;
+const OP_ = -1000000;
+var rop: mpz_t;
+begin
+  mpz_init(rop);
+  assert(mpz_set_str(rop, pchar(inttostr(OP_)), BASE10) = 0);
+  assert(mpz_get_si(rop) = OP_);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_set_ui_test;
+const OP_ = 1000000;
+var rop: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_set_ui(rop, OP_);
+  assert(mpz_get_si(rop) = OP_);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_get_d_test;
+const N = -1000;
+var op: mpz_t;
+begin
+  mpz_init_set_si(op, N);
+  assert(mpz_get_d(op) = N);
+  mpz_clear(op)
+end;
+
+procedure TTestGmpBinding.mpz_get_d_2exp_test;
+const
+  N_LG2 = 4;
+  N = 1 shl N_LG2;
+var
+  op: mpz_t;
+  exp: mp_exp_t;
+begin
+  mpz_init_set_si(op, N);
+  assert(mpz_get_d_2exp(exp, op) = 1 / 2);
+  assert(exp = N_LG2 + 1);
+  mpz_clear(op)
+end;
+
+procedure TTestGmpBinding.mpz_get_si_test;
+const N = -1000000;
+var op: mpz_t;
+begin
+  mpz_init_set_si(op, N);
+  assert(mpz_get_si(op) = N);
+  mpz_clear(op)
+end;
+
+procedure TTestGmpBinding.mpz_get_str_test;
+const N = -1000000;
+var
+  op: mpz_t;
+  p: pchar;
+  s0, s1: string;
+begin
+  mpz_init_set_si(op, N);
+  s0 := inttostr(N);
+  p :=mpz_get_str(nil, BASE10, op);
+  assert(s0 = p);
+  freemem(p);
+  setlength(s1, length(s0));
+  assert(pointer(mpz_get_str(pchar(s1), BASE10, op)) = pointer(s1));
+  assert(s0 = s1);
+  mpz_clear(op)
+end;
+
+procedure TTestGmpBinding.mpz_get_ui_test;
+const N = 1000000;
+var op: mpz_t;
+begin
+  mpz_init_set_ui(op, N);
+  assert(mpz_get_ui(op) = N);
+  mpz_clear(op)
+end;
+
+procedure TTestGmpBinding.mpz_add_test;
+const
+  OP_1 = -1000;
+  OP_2 = 1000000;
+var rop, op1, op2: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  mpz_add(rop, op1, op2);
+  assert(mpz_get_si(rop) = OP_1 + OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_add_ui_test;
+const
+  OP_1 = -1000;
+  OP_2 = 1000000;
+var rop, op1: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_add_ui(rop, op1, OP_2);
+  assert(mpz_get_si(rop) = OP_1 + OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_sub_test;
+const
+  OP_1 = -1000;
+  OP_2 = 1000000;
+var rop, op1, op2: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  mpz_sub(rop, op1, op2);
+  assert(mpz_get_si(rop) = OP_1 - OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_sub_ui_test;
+const
+  OP_1 = -1000;
+  OP_2 = 1000000;
+var rop, op1: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_sub_ui(rop, op1, OP_2);
+  assert(mpz_get_si(rop) = OP_1 - OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_ui_sub_test;
+const
+  OP_1 = 1000;
+  OP_2 = 1000000;
+var rop, op2: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op2, OP_2);
+  mpz_ui_sub(rop, OP_1, op2);
+  assert(mpz_get_si(rop) = OP_1 - OP_2);
+  mpz_clear(rop);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_mul_test;
+const
+  OP_1 = -10;
+  OP_2 = 1000;
+var rop, op1, op2: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  mpz_mul(rop, op1, op2);
+  assert(mpz_get_si(rop) = OP_1 * OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_mul_si_test;
+const
+  OP_1 = 10;
+  OP_2 = -1000;
+var rop, op1: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_mul_si(rop, op1, OP_2);
+  assert(mpz_get_si(rop) = OP_1 * OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_mul_ui_test;
+const
+  OP_1 = -10;
+  OP_2 = 1000;
+var rop, op1: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_mul_ui(rop, op1, OP_2);
+  assert(mpz_get_si(rop) = OP_1 * OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_addmul_test;
+const
+  ROP_ = 10;
+  OP_1 = -100;
+  OP_2 = 1000;
+var rop, op1, op2: mpz_t;
+begin
+  mpz_init_set_si(rop, ROP_);
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  mpz_addmul(rop, op1, op2);
+  assert(mpz_get_si(rop) = ROP_ + OP_1 * OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_addmul_ui_test;
+const
+  ROP_ = 10;
+  OP_1 = -100;
+  OP_2 = 1000;
+var rop, op1: mpz_t;
+begin
+  mpz_init_set_si(rop, ROP_);
+  mpz_init_set_si(op1, OP_1);
+  mpz_addmul_ui(rop, op1, OP_2);
+  assert(mpz_get_si(rop) = ROP_ + OP_1 * OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_submul_test;
+const
+  ROP_ = 10;
+  OP_1 = -100;
+  OP_2 = 1000;
+var rop, op1, op2: mpz_t;
+begin
+  mpz_init_set_si(rop, ROP_);
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  mpz_submul(rop, op1, op2);
+  assert(mpz_get_si(rop) = ROP_ - OP_1 * OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_submul_ui_test;
+const
+  ROP_ = 10;
+  OP_1 = -100;
+  OP_2 = 1000;
+var rop, op1: mpz_t;
+begin
+  mpz_init_set_si(rop, ROP_);
+  mpz_init_set_si(op1, OP_1);
+  mpz_submul_ui(rop, op1, OP_2);
+  assert(mpz_get_si(rop) = ROP_ - OP_1 * OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_mul_2exp_test;
+const
+  OP_1 = 10;
+  OP_2 = 10;
+var rop, op1: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_mul_2exp(rop, op1, OP_2);
+  assert(mpz_get_si(rop) = OP_1 * (1 shl OP_2));
+  mpz_clear(rop);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_neg_test;
+const OP_ = 1000;
+var rop, op: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op, OP_);
+  mpz_neg(rop, op);
+  assert(mpz_get_si(rop) = -OP_);
+  mpz_clear(rop);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_abs_test;
+const OP_ = -1000;
+var rop, op: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op, OP_);
+  mpz_abs(rop, op);
+  assert(mpz_get_si(rop) = abs(OP_));
+  mpz_clear(rop);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_cdiv_q_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, n, d: mpz_t;
+begin
+  mpz_init(q);
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  mpz_cdiv_q(q, n, d);
+  assert(mpz_get_si(q) = ceil(N_ / D_));
+  mpz_clear(q);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_fdiv_q_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, n, d: mpz_t;
+begin
+  mpz_init(q);
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  mpz_fdiv_q(q, n, d);
+  assert(mpz_get_si(q) = floor(N_ / D_));
+  mpz_clear(q);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_tdiv_q_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, n, d: mpz_t;
+begin
+  mpz_init(q);
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  mpz_tdiv_q(q, n, d);
+  assert(mpz_get_si(q) = trunc(N_ / D_));
+  mpz_clear(q);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_cdiv_q_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var q, n: mpz_t;
+begin
+  mpz_init(q);
+  mpz_init_set_si(n, N_);
+  mpz_cdiv_q_2exp(q, n, B_);
+  assert(mpz_get_si(q) = ceil(N_ / D_));
+  mpz_clear(q);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_fdiv_q_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var q, n: mpz_t;
+begin
+  mpz_init(q);
+  mpz_init_set_si(n, N_);
+  mpz_fdiv_q_2exp(q, n, B_);
+  assert(mpz_get_si(q) = floor(N_ / D_));
+  mpz_clear(q);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_tdiv_q_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var q, n: mpz_t;
+begin
+  mpz_init(q);
+  mpz_init_set_si(n, N_);
+  mpz_tdiv_q_2exp(q, n, B_);
+  assert(mpz_get_si(q) = trunc(N_ / D_));
+  mpz_clear(q);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_cdiv_q_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, n: mpz_t;
+  ur: valuint;
+begin
+  mpz_init(q);
+  mpz_init_set_si(n, N_);
+  ur :=mpz_cdiv_q_ui(q, n, D_);
+  assert(mpz_get_si(q) = ceil(N_ / D_));
+  assert(ur - abs(N_ -mpz_get_si(q) * D_) = 0);
+  mpz_clear(q);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_fdiv_q_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, n: mpz_t;
+  ur: valuint;
+begin
+  mpz_init(q);
+  mpz_init_set_si(n, N_);
+  ur :=mpz_fdiv_q_ui(q, n, D_);
+  assert(mpz_get_si(q) = floor(N_ / D_));
+  assert(ur - abs(N_ -mpz_get_si(q) * D_) = 0);
+  mpz_clear(q);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_tdiv_q_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, n: mpz_t;
+  ur: valuint;
+begin
+  mpz_init(q);
+  mpz_init_set_si(n, N_);
+  ur :=mpz_tdiv_q_ui(q, n, D_);
+  assert(mpz_get_si(q) = trunc(N_ / D_));
+  assert(ur - abs(N_ -mpz_get_si(q) * D_) = 0);
+  mpz_clear(q);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_cdiv_qr_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, r, n, d: mpz_t;
+begin
+  mpz_init(q);
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  mpz_cdiv_qr(q, r, n, d);
+  assert(mpz_get_si(q) = ceil(N_ / D_));
+  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
+  mpz_clear(q);
+  mpz_clear(r);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_fdiv_qr_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, r, n, d: mpz_t;
+begin
+  mpz_init(q);
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  mpz_fdiv_qr(q, r, n, d);
+  assert(mpz_get_si(q) = floor(N_ / D_));
+  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
+  mpz_clear(q);
+  mpz_clear(r);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_tdiv_qr_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, r, n, d: mpz_t;
+begin
+  mpz_init(q);
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  mpz_tdiv_qr(q, r, n, d);
+  assert(mpz_get_si(q) = trunc(N_ / D_));
+  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
+  mpz_clear(q);
+  mpz_clear(r);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_cdiv_qr_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, r, n: mpz_t;
+  ur: valuint;
+begin
+  mpz_init(q);
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  ur :=mpz_cdiv_qr_ui(q, r, n, D_);
+  assert(mpz_get_si(q) = ceil(N_ / D_));
+  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
+  assert(ur - abs(mpz_get_si(r)) = 0);
+  mpz_clear(q);
+  mpz_clear(r);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_fdiv_qr_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, r, n: mpz_t;
+  ur: valuint;
+begin
+  mpz_init(q);
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  ur :=mpz_fdiv_qr_ui(q, r, n, D_);
+  assert(mpz_get_si(q) = floor(N_ / D_));
+  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
+  assert(ur - abs(mpz_get_si(r)) = 0);
+  mpz_clear(q);
+  mpz_clear(r);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_tdiv_qr_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, r, n: mpz_t;
+  ur: valuint;
+begin
+  mpz_init(q);
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  ur :=mpz_tdiv_qr_ui(q, r, n, D_);
+  assert(mpz_get_si(q) = trunc(N_ / D_));
+  assert(mpz_get_si(q) * D_ + mpz_get_si(r) = N_);
+  assert(ur - abs(mpz_get_si(r)) = 0);
+  mpz_clear(q);
+  mpz_clear(r);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_cdiv_r_test;
+const
+  N_ = -17;
+  D_ = 4;
+var r, n, d: mpz_t;
+begin
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  mpz_cdiv_r(r, n, d);
+  assert(ceil(N_ / D_) * D_ + mpz_get_si(r) = N_);
+  mpz_clear(r);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_fdiv_r_test;
+const
+  N_ = -17;
+  D_ = 4;
+var r, n, d: mpz_t;
+begin
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  mpz_fdiv_r(r, n, d);
+  assert(floor(N_ / D_) * D_ + mpz_get_si(r) = N_);
+  mpz_clear(r);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_tdiv_r_test;
+const
+  N_ = -17;
+  D_ = 4;
+var r, n, d: mpz_t;
+begin
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  mpz_tdiv_r(r, n, d);
+  assert(trunc(N_ / D_) * D_ + mpz_get_si(r) = N_);
+  mpz_clear(r);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_cdiv_r_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var r, n: mpz_t;
+begin
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  mpz_cdiv_r_2exp(r, n, B_);
+  assert(ceil(N_ / D_) * D_ + mpz_get_si(r) = N_);
+  mpz_clear(r);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_fdiv_r_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var r, n: mpz_t;
+begin
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  mpz_fdiv_r_2exp(r, n, B_);
+  assert(floor(N_ / D_) * D_ + mpz_get_si(r) = N_);
+  mpz_clear(r);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_tdiv_r_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var r, n: mpz_t;
+begin
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  mpz_tdiv_r_2exp(r, n, B_);
+  assert(trunc(N_ / D_) * D_ + mpz_get_si(r) = N_);
+  mpz_clear(r);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_cdiv_r_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  r, n: mpz_t;
+  ur: valuint;
+begin
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  ur :=mpz_cdiv_r_ui(r, n, D_);
+  assert(ceil(N_ / D_) * D_ + mpz_get_si(r) = N_);
+  assert(ur - abs(mpz_get_si(r)) = 0);
+  mpz_clear(r);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_fdiv_r_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  r, n: mpz_t;
+  ur: valuint;
+begin
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  ur :=mpz_fdiv_r_ui(r, n, D_);
+  assert(floor(N_ / D_) * D_ + mpz_get_si(r) = N_);
+  assert(ur - abs(mpz_get_si(r)) = 0);
+  mpz_clear(r);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_tdiv_r_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  r, n: mpz_t;
+  ur: valuint;
+begin
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  ur :=mpz_tdiv_r_ui(r, n, D_);
+  assert(trunc(N_ / D_) * D_ + mpz_get_si(r) = N_);
+  assert(ur - abs(mpz_get_si(r)) = 0);
+  mpz_clear(r);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_cdiv_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var n: mpz_t;
+begin
+  mpz_init_set_si(n, N_);
+  assert(mpz_cdiv_ui(n, D_) - abs(N_ - ceil(N_ / D_) * D_) = 0);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_fdiv_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var n: mpz_t;
+begin
+  mpz_init_set_si(n, N_);
+  assert(mpz_fdiv_ui(n, D_) - abs(N_ - floor(N_ / D_) * D_) = 0);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_tdiv_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var n: mpz_t;
+begin
+  mpz_init_set_si(n, N_);
+  assert(mpz_tdiv_ui(n, D_) = abs(N_ - trunc(N_ / D_) * D_));
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_mod_test;
+const
+  N_ = 17;
+  D_ = -4;
+var r, n, d: mpz_t;
+begin
+  mpz_init(r);
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  mpz_mod(r, n, d);
+  assert(mpz_get_si(r) = N_ mod abs(D_));
+  mpz_clear(r);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_divexact_test;
+const
+  N_ = -16;
+  D_ = 4;
+var q, n, d: mpz_t;
+begin
+  mpz_init(q);
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  mpz_divexact(q, n, d);
+  assert(mpz_get_si(q) * D_ = N_);
+  mpz_clear(q);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_divexact_ui_test;
+const
+  N_ = -16;
+  D_ = 4;
+var q, n: mpz_t;
+begin
+  mpz_init(q);
+  mpz_init_set_si(n, N_);
+  mpz_divexact_ui(q, n, D_);
+  assert(mpz_get_si(q) * D_ = N_);
+  mpz_clear(q);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_divisible_p_test;
+const
+  N_ = -16;
+  D_ = 4;
+var n, d: mpz_t;
+begin
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(d, D_);
+  assert(mpz_divisible_p(n, d) <> 0);
+  mpz_set_si(n,mpz_get_si(n) + 1);
+  assert(mpz_divisible_p(n, d) = 0);
+  mpz_clear(n);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_divisible_ui_p_test;
+const
+  N_ = -16;
+  D_ = 4;
+var n: mpz_t;
+begin
+  mpz_init_set_si(n, N_);
+  assert(mpz_divisible_ui_p(n, D_) <> 0);
+  mpz_set_si(n,mpz_get_si(n) + 1);
+  assert(mpz_divisible_ui_p(n, D_) = 0);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_divisible_2exp_p_test;
+const
+  N_ = -16;
+  B_ = 2;
+var n: mpz_t;
+begin
+  mpz_init_set_si(n, N_);
+  assert(mpz_divisible_2exp_p(n, B_) <> 0);
+  mpz_set_si(n,mpz_get_si(n) + 1);
+  assert(mpz_divisible_ui_p(n, B_) = 0);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_congruent_p_test;
+const
+  N_ = 23;
+  C_ = 6;
+  D_ = 17;
+var n, c, d: mpz_t;
+begin
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(c, C_);
+  mpz_init_set_si(d, D_);
+  assert(mpz_congruent_p(n, c, d) <> 0);
+  mpz_set_si(n,mpz_get_si(n) + 1);
+  assert(mpz_congruent_p(n, c, d) = 0);
+  mpz_clear(n);
+  mpz_clear(c);
+  mpz_clear(d);
+end;
+
+procedure TTestGmpBinding.mpz_congruent_2exp_p_test;
+const
+  N_ = 23;
+  C_ = 7;
+  B_ = 4;
+var n, c: mpz_t;
+begin
+  mpz_init_set_si(n, N_);
+  mpz_init_set_si(c, C_);
+  assert(mpz_congruent_2exp_p(n, c, B_) <> 0);
+  mpz_set_si(n,mpz_get_si(n) + 1);
+  assert(mpz_congruent_2exp_p(n, c, B_) = 0);
+  mpz_clear(n);
+  mpz_clear(c);
+end;
+
+procedure TTestGmpBinding.mpz_congruent_ui_p_test;
+const
+  N_ = 23;
+  C_ = 6;
+  D_ = 17;
+var n: mpz_t;
+begin
+  mpz_init_set_si(n, N_);
+  assert(mpz_congruent_ui_p(n, C_, D_) <> 0);
+  mpz_set_si(n,mpz_get_si(n) + 1);
+  assert(mpz_congruent_ui_p(n, C_, D_) = 0);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_powm_test;
+const
+  N_EXP = 3;
+  N_MOD = 16;
+  ROP_ = 8;
+var rop, base, exp, mod_: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(base, BASE10);
+  mpz_init_set_si(exp, N_EXP);
+  mpz_init_set_si(mod_, N_MOD);
+  mpz_powm(rop, base, exp, mod_);
+  assert(mpz_get_si(rop) = ROP_);
+  mpz_clear(rop);
+  mpz_clear(base);
+  mpz_clear(exp);
+  mpz_clear(mod_);
+end;
+
+procedure TTestGmpBinding.mpz_powm_ui_test;
+const
+  N_EXP = 3;
+  N_MOD = 16;
+  ROP_ = 8;
+var rop, base, mod_: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(base, BASE10);
+  mpz_init_set_si(mod_, N_MOD);
+  mpz_powm_ui(rop, base, N_EXP, mod_);
+  assert(mpz_get_si(rop) = ROP_);
+  mpz_clear(rop);
+  mpz_clear(base);
+  mpz_clear(mod_);
+end;
+
+procedure TTestGmpBinding.mpz_pow_ui_test;
+const
+  BASE_ = 10;
+  EXP = 3;
+var rop, base: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(base, BASE_);
+  mpz_pow_ui(rop, base, EXP);
+  assert(mpz_get_si(rop) = BASE_ ** EXP);
+  mpz_clear(rop);
+  mpz_clear(base);
+end;
+
+procedure TTestGmpBinding.mpz_ui_pow_ui_test;
+const
+  BASE_ = 10;
+  EXP = 3;
+var rop: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_ui_pow_ui(rop, BASE_, EXP);
+  assert(mpz_get_si(rop) = BASE_ ** EXP);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_root_test;
+const
+  ROOT = 5;
+  N_ = 3;
+var rop, op: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op, ROOT ** N_);
+  assert(mpz_root(rop, op, N_) <> 0);
+  assert(mpz_get_si(rop) = ROOT);
+  mpz_set_si(op, ROOT ** N_ + 1);
+  assert(mpz_root(rop, op, N_) = 0);
+  assert(mpz_get_si(rop) = ROOT);
+  mpz_clear(rop);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_rootrem_test;
+const
+  ROOT_ = 5;
+  N_ = 3;
+  REM_ = 1;
+var root, rem, u: mpz_t;
+begin
+  assert(REM_ < ROOT_);
+  mpz_init(root);
+  mpz_init(rem);
+  mpz_init_set_si(u, ROOT_ ** N_);
+  mpz_rootrem(root, rem, u, N_);
+  assert(mpz_get_si(root) = ROOT_);
+  assert(mpz_get_si(rem) = 0);
+  mpz_set_si(u, ROOT_ ** N_ + REM_);
+  mpz_rootrem(root, rem, u, N_);
+  assert(mpz_get_si(root) = ROOT_);
+  assert(mpz_get_si(rem) = REM_);
+  mpz_clear(root);
+  mpz_clear(rem);
+  mpz_clear(u);
+end;
+
+procedure TTestGmpBinding.mpz_sqrt_test;
+const ROOT = 5;
+var rop, op: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op, ROOT ** 2);
+  mpz_sqrt(rop, op);
+  assert(mpz_get_si(rop) = ROOT);
+  mpz_clear(rop);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_sqrtrem_test;
+const
+  ROOT = 5;
+  REM = 1;
+var rop1, rop2, op: mpz_t;
+begin
+  mpz_init(rop1);
+  mpz_init(rop2);
+  mpz_init_set_si(op, ROOT ** 2 + REM);
+  mpz_sqrtrem(rop1, rop2, op);
+  assert(mpz_get_si(rop1) = ROOT);
+  assert(mpz_get_si(rop2) = REM);
+  mpz_clear(rop1);
+  mpz_clear(rop2);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_perfect_power_p_test;
+const
+  ROOT = 3;
+  EXP = 3;
+var op: mpz_t;
+begin
+  mpz_init_set_si(op, ROOT ** EXP);
+  assert(mpz_perfect_power_p(op) <> 0);
+  mpz_set_si(op, ROOT ** EXP + 1);
+  assert(mpz_perfect_power_p(op) = 0);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_perfect_square_p_test;
+const ROOT = 3;
+var op: mpz_t;
+begin
+  mpz_init_set_si(op, ROOT ** 2);
+  assert(mpz_perfect_square_p(op) <> 0);
+  mpz_set_si(op, ROOT ** 2 or 2);
+  assert(mpz_perfect_square_p(op) = 0);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_probab_prime_p_test;
+const
+  N_ = 127;
+  REPS = 5;
+var n: mpz_t;
+begin
+  mpz_init_set_si(n, N_);
+  assert(mpz_probab_prime_p(n, REPS) = 2);
+  mpz_set_si(n, N_ + 1);
+  assert(mpz_probab_prime_p(n, REPS) = 0);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_nextprime_test;
+const
+  PRIME3 = 5;
+  PRIME4 = 7;
+var rop, op: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op, PRIME3);
+  mpz_nextprime(rop, op);
+  assert(mpz_get_si(rop) = PRIME4);
+  mpz_clear(rop);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_gcd_test;
+const
+  OP_1 = 42;
+  OP_2 = 56;
+  ROP_ = 14;
+var rop, op1, op2: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  mpz_gcd(rop, op1, op2);
+  assert(mpz_get_si(rop) = ROP_);
+  mpz_clear(rop);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_gcd_ui_test;
+const
+  OP_1 = 42;
+  OP_2 = 56;
+  ROP_ = 14;
+var rop, op1: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  assert(mpz_gcd_ui(rop, op1, OP_2) = ROP_);
+  assert(mpz_get_si(rop) = ROP_);
+  mpz_clear(rop);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_gcdext_test;
+const
+  A_ = 42;
+  B_ = 56;
+  G_ = 14;
+var g, s, t, a, b: mpz_t;
+begin
+  mpz_init(g);
+  mpz_init(s);
+  mpz_init(t);
+  mpz_init_set_si(a, A_);
+  mpz_init_set_si(b, B_);
+  mpz_gcdext(g, s, t, a, b);
+  assert(mpz_get_si(g) = G_);
+  assert(A_ *mpz_get_si(s) + B_ *mpz_get_si(t) = G_);
+  mpz_clear(g);
+  mpz_clear(s);
+  mpz_clear(t);
+  mpz_clear(a);
+  mpz_clear(b);
+end;
+
+procedure TTestGmpBinding.mpz_lcm_test;
+const
+  OP_1 = 21;
+  OP_2 = 6;
+  ROP_ = 42;
+var rop, op1, op2: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  mpz_lcm(rop, op1, op2);
+  assert(mpz_get_si(rop) = ROP_);
+  mpz_clear(rop);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_lcm_ui_test;
+const
+  OP_1 = 21;
+  OP_2 = 6;
+  ROP_ = 42;
+var rop, op1: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_lcm_ui(rop, op1, OP_2);
+  assert(mpz_get_si(rop) = ROP_);
+  mpz_clear(rop);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_invert_test;
+const
+  OP_1 = 256;
+  OP_2 = 337;
+  ROP_ = 104;
+var rop, op1, op2: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  assert(mpz_invert(rop, op1, op2) <> 0);
+  assert(mpz_get_si(rop) = ROP_);
+  mpz_clear(rop);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_jacobi_test;
+const
+  B0 = 11;
+  A0 = 13 * B0;
+  AM1 = 1001;
+  BM1 = 9907;
+  A1 = 4;
+  B1 = 7;
+var a, b: mpz_t;
+begin
+  mpz_init_set_si(a, A0);
+  mpz_init_set_si(b, B0);
+  assert(mpz_jacobi(a, b) = 0);
+  mpz_set_si(a, AM1);
+  mpz_set_si(b, BM1);
+  assert(mpz_jacobi(a, b) = -1);
+  mpz_set_si(a, A1);
+  mpz_set_si(b, B1);
+  assert(mpz_jacobi(a, b) = 1);
+  mpz_clear(a);
+  mpz_clear(b);
+end;
+
+procedure TTestGmpBinding.mpz_kronecker_si_test;
+const
+  A_ = 8;
+  B0 = 6;
+  BM1 = 5;
+  B1 = 7;
+var a: mpz_t;
+begin
+  mpz_init_set_si(a, A_);
+  assert(mpz_kronecker_si(a, B1) = 1);
+  assert(mpz_kronecker_si(a, B0) = 0);
+  assert(mpz_kronecker_si(a, BM1) = -1);
+  mpz_clear(a);
+end;
+
+procedure TTestGmpBinding.mpz_kronecker_ui_test;
+const
+  A_ = 8;
+  B0 = 6;
+  BM1 = 5;
+  B1 = 7;
+var a: mpz_t;
+begin
+  mpz_init_set_si(a, A_);
+  assert(mpz_kronecker_ui(a, B1) = 1);
+  assert(mpz_kronecker_ui(a, B0) = 0);
+  assert(mpz_kronecker_ui(a, BM1) = -1);
+  mpz_clear(a);
+end;
+
+procedure TTestGmpBinding.mpz_si_kronecker_test;
+const
+  A_ = 8;
+  B0 = 6;
+  BM1 = 5;
+  B1 = 7;
+var b: mpz_t;
+begin
+  mpz_init_set_si(b, B1);
+  assert(mpz_si_kronecker(A_, b) = 1);
+  mpz_set_si(b, B0);
+  assert(mpz_si_kronecker(A_, b) = 0);
+  mpz_set_si(b, BM1);
+  assert(mpz_si_kronecker(A_, b) = -1);
+  mpz_clear(b);
+end;
+
+procedure TTestGmpBinding.mpz_ui_kronecker_test;
+const
+  A_ = 8;
+  B0 = 6;
+  BM1 = 5;
+  B1 = 7;
+var b: mpz_t;
+begin
+  mpz_init_set_si(b, B1);
+  assert(mpz_ui_kronecker(A_, b) = 1);
+  mpz_set_si(b, B0);
+  assert(mpz_ui_kronecker(A_, b) = 0);
+  mpz_set_si(b, BM1);
+  assert(mpz_ui_kronecker(A_, b) = -1);
+  mpz_clear(b);
+end;
+
+procedure TTestGmpBinding.mpz_remove_test;
+const
+  F_ = 5;
+  OP_ = 3 * F_ * 7;
+  ROP_ = OP_ div F_;
+var rop, op, f: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op, OP_);
+  mpz_init_set_si(f, F_);
+  assert(mpz_remove(rop, op, f) = 1);
+  assert(mpz_get_si(rop) = ROP_);
+  mpz_clear(rop);
+  mpz_clear(op);
+  mpz_clear(f);
+end;
+
+procedure TTestGmpBinding.mpz_fac_ui_test;
+const
+  OP = 4;
+  ROP_ = 2 * 3 * 4;
+var rop: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_fac_ui(rop, OP);
+  assert(mpz_get_si(rop) = ROP_);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_bin_ui_test;
+const
+  N_ = 7;
+  K = 3;
+  ROP_ = 35;
+var rop, n: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(n, N_);
+  mpz_bin_ui(rop, n, K);
+  assert(mpz_get_si(rop) = ROP_);
+  mpz_clear(rop);
+  mpz_clear(n);
+end;
+
+procedure TTestGmpBinding.mpz_bin_uiui_test;
+const
+  N = 7;
+  K = 3;
+  ROP_ = 35;
+var rop: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_bin_uiui(rop, N, K);
+  assert(mpz_get_si(rop) = ROP_);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_fib_ui_test;
+const
+  N = 10;
+  FN_ = 55;
+var fn: mpz_t;
+begin
+  mpz_init(fn);
+  mpz_fib_ui(fn, N);
+  assert(mpz_get_si(fn) = FN_);
+  mpz_clear(fn);
+end;
+
+procedure TTestGmpBinding.mpz_fib2_ui_test;
+const
+  N = 10;
+  FN_ = 55;
+  FNSUB1_ = 34;
+var fn, fnsub1: mpz_t;
+begin
+  mpz_init(fn);
+  mpz_init(fnsub1);
+  mpz_fib2_ui(fn, fnsub1, N);
+  assert(mpz_get_si(fn) = FN_);
+  assert(mpz_get_si(fnsub1) = FNSUB1_);
+  mpz_clear(fn);
+  mpz_clear(fnsub1);
+end;
+
+procedure TTestGmpBinding.mpz_lucnum_ui_test;
+const
+  N = 10;
+  LN_ = 123;
+var ln: mpz_t;
+begin
+  mpz_init(ln);
+  mpz_lucnum_ui(ln, N);
+  assert(mpz_get_si(ln) = LN_);
+  mpz_clear(ln);
+end;
+
+procedure TTestGmpBinding.mpz_lucnum2_ui_test;
+const
+  N = 10;
+  LN_ = 123;
+  LNSUB1_ = 76;
+var ln, lnsub1: mpz_t;
+begin
+  mpz_init(ln);
+  mpz_init(lnsub1);
+  mpz_lucnum2_ui(ln, lnsub1, N);
+  assert(mpz_get_si(ln) = LN_);
+  assert(mpz_get_si(lnsub1) = LNSUB1_);
+  mpz_clear(ln);
+  mpz_clear(lnsub1);
+end;
+
+procedure TTestGmpBinding.mpz_cmp_test;
+const
+  OP_1 = -10;
+  OP_2 = OP_1 - 1;
+var op1, op2: mpz_t;
+begin
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  assert(mpz_cmp(op1, op2) > 0);
+  mpz_set_si(op2, OP_1);
+  assert(mpz_cmp(op1, op2) = 0);
+  mpz_set_si(op2, OP_1 + 1);
+  assert(mpz_cmp(op1, op2) < 0);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_cmp_d_test;
+const
+  OP_1 = -10;
+var op1: mpz_t;
+begin
+  mpz_init_set_si(op1, OP_1);
+  assert(mpz_cmp_d(op1, OP_1 - 1) > 0);
+  assert(mpz_cmp_d(op1, OP_1) = 0);
+  assert(mpz_cmp_d(op1, OP_1 + 1) < 0);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_cmp_si_test;
+const
+  OP_1 = -10;
+var op1: mpz_t;
+begin
+  mpz_init_set_si(op1, OP_1);
+  assert(mpz_cmp_si(op1, OP_1 - 1) > 0);
+  assert(mpz_cmp_si(op1, OP_1) = 0);
+  assert(mpz_cmp_si(op1, OP_1 + 1) < 0);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_cmp_ui_test;
+const
+  OP_1 = 10;
+var op1: mpz_t;
+begin
+  mpz_init_set_si(op1, OP_1);
+  assert(mpz_cmp_ui(op1, OP_1 - 1) > 0);
+  assert(mpz_cmp_ui(op1, OP_1) = 0);
+  assert(mpz_cmp_ui(op1, OP_1 + 1) < 0);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_cmpabs_test;
+const
+  OP_1 = -10;
+  OP_2 = -OP_1 - 1;
+var op1, op2: mpz_t;
+begin
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, -OP_2);
+  assert(mpz_cmpabs(op1, op2) > 0);
+  mpz_set_si(op2, -OP_1);
+  assert(mpz_cmpabs(op1, op2) = 0);
+  mpz_set_si(op2, -OP_1 + 1);
+  assert(mpz_cmpabs(op1, op2) < 0);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_cmpabs_d_test;
+const OP_1 = -10;
+var op1: mpz_t;
+begin
+  mpz_init_set_si(op1, OP_1);
+  assert(mpz_cmpabs_d(op1, -OP_1 - 1) > 0);
+  assert(mpz_cmpabs_d(op1, -OP_1) = 0);
+  assert(mpz_cmpabs_d(op1, -OP_1 + 1) < 0);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_cmpabs_ui_test;
+const OP_1 = -10;
+var op1: mpz_t;
+begin
+  mpz_init_set_si(op1, OP_1);
+  assert(mpz_cmpabs_ui(op1, -OP_1 - 1) > 0);
+  assert(mpz_cmpabs_ui(op1, -OP_1) = 0);
+  assert(mpz_cmpabs_ui(op1, -OP_1 + 1) < 0);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_and_test;
+const
+  OP_1 = $c;
+  OP_2 = $a;
+var rop, op1, op2: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  mpz_and(rop, op1, op2);
+  assert(mpz_get_si(rop) = OP_1 and OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_ior_test;
+const
+  OP_1 = $c;
+  OP_2 = $a;
+var rop, op1, op2: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  mpz_ior(rop, op1, op2);
+  assert(mpz_get_si(rop) = OP_1 or OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_xor_test;
+const
+  OP_1 = $c;
+  OP_2 = $a;
+var rop, op1, op2: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  mpz_xor(rop, op1, op2);
+  assert(mpz_get_si(rop) = OP_1 xor OP_2);
+  mpz_clear(rop);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_com_test;
+const
+  OP_1 = 2;
+var rop, op1: mpz_t;
+begin
+  mpz_init(rop);
+  mpz_init_set_si(op1, OP_1);
+  mpz_com(rop, op1);
+  assert(mpz_get_si(rop) = not OP_1 );
+  mpz_clear(rop);
+  mpz_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpz_popcount_test;
+const
+  OP_ = $55AA;
+  N = 8;
+var op: mpz_t;
+begin
+  mpz_init_set_si(op, OP_);
+  assert(mpz_popcount(op) = N);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_hamdist_test;
+const
+  OP_1 = $55;
+  OP_2 = $7A;
+  N = 5;
+var op1, op2: mpz_t;
+begin
+  mpz_init_set_si(op1, OP_1);
+  mpz_init_set_si(op2, OP_2);
+  assert(mpz_hamdist(op1, op2) = N);
+  mpz_clear(op1);
+  mpz_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpz_scan0_test;
+const
+  OP_ = $F75;
+  STARTING_BIT = 4;
+  N = 7;
+var op: mpz_t;
+begin
+  mpz_init_set_si(op, OP_);
+  assert(mpz_scan0(op, STARTING_BIT) = N);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_scan1_test;
+const
+  OP_ = $85;
+  STARTING_BIT = 4;
+  N = 7;
+var op: mpz_t;
+begin
+  mpz_init_set_si(op, OP_);
+  assert(mpz_scan1(op, STARTING_BIT) = N);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_setbit_test;
+const
+  ROP_ = $F75;
+  BIT_INDEX = 7;
+var rop: mpz_t;
+begin
+  mpz_init_set_ui(rop, ROP_);
+  mpz_setbit(rop, BIT_INDEX);
+  assert(mpz_get_ui(rop) = ROP_ or (1 shl BIT_INDEX));
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_clrbit_test;
+const
+  ROP_ = $F75;
+  BIT_INDEX = 9;
+var rop: mpz_t;
+begin
+  mpz_init_set_ui(rop, ROP_);
+  mpz_clrbit(rop, BIT_INDEX);
+  assert(mpz_get_ui(rop) = ROP_ and not (1 shl BIT_INDEX));
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_combit_test;
+const
+  ROP_ = $F75;
+  BIT_INDEX = 7;
+var rop: mpz_t;
+begin
+  mpz_init_set_ui(rop, ROP_);
+  mpz_combit(rop, BIT_INDEX);
+  assert(mpz_get_ui(rop) = ROP_ xor (1 shl BIT_INDEX));
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_tstbit_test;
+const
+  ROP_ = $F75;
+  BIT_INDEX1 = 7;
+  BIT_INDEX2 = 8;
+var rop: mpz_t;
+begin
+  mpz_init_set_ui(rop, ROP_);
+  assert(longbool(mpz_tstbit(rop, BIT_INDEX1)) = longbool(ROP_ and (1 shl BIT_INDEX1)));
+  assert(longbool(mpz_tstbit(rop, BIT_INDEX2)) = longbool(ROP_ and (1 shl BIT_INDEX2)));
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_urandomb_test;
+const
+  B = 8 * (sizeof(valuint) - 1);
+  N = 1 shl B;
+var
+  rop: mpz_t;
+  state: randstate_t;
+begin
+  mp_randinit_default(state);
+  mpz_init(rop);
+  mpz_urandomb(rop, state, B);
+  assert(mpz_cmp_ui(rop, N) < 0);
+  mpz_clear(rop);
+  mp_randclear(state);
+end;
+
+procedure TTestGmpBinding.mpz_urandomm_test;
+const
+  N_ = 1000000;
+var
+  rop, n: mpz_t;
+  state: randstate_t;
+begin
+  mp_randinit_default(state);
+  mpz_init(rop);
+  mpz_init_set_ui(n, N_);
+  mpz_urandomm(rop, state, n);
+  assert(mpz_cmp_ui(rop, N_) < 0);
+  mpz_clear(rop);
+  mpz_clear(n);
+  mp_randclear(state);
+end;
+
+procedure TTestGmpBinding.mpz_rrandomb_test;
+const
+  B = 8 * sizeof(valuint) - 2;
+  N = 1 shl B;
+var
+  rop: mpz_t;
+  state: randstate_t;
+begin
+  mp_randinit_default(state);
+  mpz_init(rop);
+  mpz_rrandomb(rop, state, B);
+  assert(mpz_cmp_ui(rop, N) < 0);
+  mpz_clear(rop);
+  mp_randclear(state);
+end;
+
+procedure TTestGmpBinding.mpz_fits_ushort_p_test;
+var op: mpz_t;
+begin
+  mpz_init_set_ui(op, high(word));
+  assert(longbool(mpz_fits_ushort_p(op)));
+  mpz_add_ui(op, op, 1);
+  assert(not longbool(mpz_fits_ushort_p(op)));
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_fits_sshort_p_test;
+var op: mpz_t;
+begin
+  mpz_init_set_si(op, high(smallint));
+  assert(longbool(mpz_fits_sshort_p(op)));
+  mpz_add_ui(op, op, 1);
+  assert(not longbool(mpz_fits_sshort_p(op)));
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_fits_uint_p_test;
+var op: mpz_t;
+begin
+  mpz_init_set_ui(op, high(cardinal));
+  assert(longbool(mpz_fits_uint_p(op)));
+  mpz_add_ui(op, op, 1);
+  assert(not longbool(mpz_fits_uint_p(op)));
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_fits_sint_p_test;
+var op: mpz_t;
+begin
+  mpz_init_set_si(op, high(integer));
+  assert(longbool(mpz_fits_sint_p(op)));
+  mpz_add_ui(op, op, 1);
+  assert(not longbool(mpz_fits_sint_p(op)));
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_fits_ulong_p_test;
+var op: mpz_t;
+begin
+  mpz_init_set_ui(op, high(valuint));
+  assert(longbool(mpz_fits_ulong_p(op)));
+  mpz_add_ui(op, op, 1);
+  assert(not longbool(mpz_fits_ulong_p(op)));
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_fits_slong_p_test;
+var op: mpz_t;
+begin
+  mpz_init_set_si(op, high(valsint));
+  assert(longbool(mpz_fits_slong_p(op)));
+  mpz_add_ui(op, op, 1);
+  assert(not longbool(mpz_fits_slong_p(op)));
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpz_sizeinbase_test;
+const
+  OP_ = 1000000;
+var rop: mpz_t;
+begin
+  mpz_init_set_ui(rop, OP_);
+  assert(mpz_sizeinbase(rop, BASE10) - length(inttostr(OP_)) = 0);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpz_size_test;
+var rop: mpz_t;
+begin
+  mpz_init(rop);
+  assert(mpz_size(rop) = 0);
+  mpz_add_ui(rop, rop, 1);
+  assert(mpz_size(rop) = 1);
+  mpz_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpq_init_test;
+var rational: mpq_t;
+begin
+  mpq_init(rational);
+  assert(mpq_cmp_ui(rational, 0, 1) = 0);
+  mpq_clear(rational);
+end;
+
+procedure TTestGmpBinding.mpq_clear_test;
+var rational: mpq_t;
+begin
+  mpq_init(rational);
+  mpq_clear(rational);
+end;
+
+procedure TTestGmpBinding.mpq_set_ui_test;
+const
+  OP_1 = 13;
+  OP_2 = 17;
+var rational: mpq_t;
+begin
+  mpq_init(rational);
+  mpq_set_ui(rational, OP_1, OP_2);
+  assert(mpq_cmp_ui(rational, OP_1, OP_2) = 0);
+  mpq_clear(rational);
+end;
+
+procedure TTestGmpBinding.mpq_set_si_test;
+const
+  OP_1 = -13;
+  OP_2 = 17;
+var rational: mpq_t;
+begin
+  mpq_init(rational);
+  mpq_set_si(rational, OP_1, OP_2);
+  assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
+  mpq_clear(rational);
+end;
+
+procedure TTestGmpBinding.mpq_canonicalize_test;
+const
+  OP_1 = -13;
+  OP_2 = 17;
+  CF = 11;
+var rational: mpq_t;
+begin
+  mpq_init(rational);
+  mpq_set_si(rational, CF * OP_1, CF * OP_2);
+  mpq_canonicalize(rational);
+  assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
+  mpq_clear(rational);
+end;
+
+procedure TTestGmpBinding.mpq_set_test;
+const
+  OP_1 = -13;
+  OP_2 = 17;
+var rational1, rational2: mpq_t;
+begin
+  mpq_init(rational1);
+  mpq_init(rational2);
+  mpq_set_si(rational2, OP_1, OP_2);
+  mpq_set(rational1, rational2);
+  assert(mpq_cmp_si(rational1, OP_1, OP_2) = 0);
+  mpq_clear(rational1);
+  mpq_clear(rational2);
+end;
+
+procedure TTestGmpBinding.mpq_setmpz_test;
+const
+  OP_1 = -13;
+var
+  rational: mpq_t;
+  op: mpz_t;
+begin
+  mpq_init(rational);
+  mpz_init_set_si(op, OP_1);
+  mpq_set_z(rational, op);
+  assert(mpq_cmp_si(rational, OP_1, 1) = 0);
+  mpq_clear(rational);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpq_set_str_test;
+const
+  OP_1 = -13;
+  OP_2 = 17;
+var rational: mpq_t;
+begin
+  mpq_init(rational);
+  assert(mpq_set_str(rational, pchar(inttostr(OP_1) + '/' + inttostr(OP_2)), BASE10) = 0);
+  assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
+  assert(mpq_set_str(rational, pchar(inttostr(OP_1) + '*' + inttostr(OP_2)), BASE10) <> 0);
+  mpq_clear(rational);
+end;
+
+procedure TTestGmpBinding.mpq_swap_test;
+const
+  ROP_1N = -13;
+  ROP_1D = 17;
+  ROP_2N = -23;
+  ROP_2D = 31;
+var rop1, rop2: mpq_t;
+begin
+  mpq_init(rop1);
+  mpq_init(rop2);
+  mpq_set_si(rop1, ROP_1N, ROP_1D);
+  mpq_set_si(rop2, ROP_2N, ROP_2D);
+  mpq_swap(rop1, rop2);
+  assert(mpq_cmp_si(rop1, ROP_2N, ROP_2D) = 0);
+  assert(mpq_cmp_si(rop2, ROP_1N, ROP_1D) = 0);
+  mpq_clear(rop1);
+  mpq_clear(rop2);
+end;
+
+procedure TTestGmpBinding.mpq_get_d_test;
+const
+  OP_1 = -1;
+  OP_2 = 2;
+var op: mpq_t;
+begin
+  mpq_init(op);
+  mpq_set_si(op, OP_1, OP_2);
+  assert(mpq_get_d(op) = OP_1 / OP_2);
+  mpq_clear(op);
+end;
+
+procedure TTestGmpBinding.mpq_set_d_test;
+const
+  OP_1 = -1;
+  OP_2 = 2;
+var rop: mpq_t;
+begin
+  mpq_init(rop);
+  mpq_set_d(rop, OP_1 / OP_2);
+  assert(mpq_cmp_si(rop, OP_1, OP_2) = 0);
+  mpq_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpq_set_f_test;
+const OP_ = -10;
+var
+  op: mpf_t;
+  rop: mpq_t;
+begin
+  mpf_init_set_si(op, OP_);
+  mpq_init(rop);
+  mpq_set_f(rop, op);
+  assert(mpq_get_d(rop) = OP_);
+  mpq_clear(rop);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpq_get_str_test;
+const
+  OP_1 = -1;
+  OP_2 = 2;
+var
+  op: mpq_t;
+  p: pchar;
+begin
+  mpq_init(op);
+  mpq_set_si(op, OP_1, OP_2);
+  p := mpq_get_str(nil, BASE10, op);
+  assert(p = inttostr(OP_1) + '/' + inttostr(OP_2));
+  freemem(p);
+  mpq_clear(op);
+end;
+
+procedure TTestGmpBinding.mpq_add_test;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var sum, addend1, addend2: mpq_t;
+begin
+  mpq_init(sum);
+  mpq_init(addend1);
+  mpq_init(addend2);
+  mpq_set_si(addend1, N1, D1);
+  mpq_set_si(addend2, N2, D2);
+  mpq_add(sum, addend1, addend2);
+  assert(mpq_cmp_si(sum, N1 * D2 + N2 * D1, D1 * D2) = 0);
+  mpq_clear(sum);
+  mpq_clear(addend1);
+  mpq_clear(addend2);
+end;
+
+procedure TTestGmpBinding.mpq_sub_test;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var difference, minuend, subtrahend: mpq_t;
+begin
+  mpq_init(difference);
+  mpq_init(minuend);
+  mpq_init(subtrahend);
+  mpq_set_si(minuend, N1, D1);
+  mpq_set_si(subtrahend, N2, D2);
+  mpq_sub(difference, minuend, subtrahend);
+  assert(mpq_cmp_si(difference, N1 * D2 - N2 * D1, D1 * D2) = 0);
+  mpq_clear(difference);
+  mpq_clear(minuend);
+  mpq_clear(subtrahend);
+end;
+
+procedure TTestGmpBinding.mpq_mul_test;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var product, multiplier, multiplicant: mpq_t;
+begin
+  mpq_init(product);
+  mpq_init(multiplier);
+  mpq_init(multiplicant);
+  mpq_set_si(multiplier, N1, D1);
+  mpq_set_si(multiplicant, N2, D2);
+  mpq_mul(product, multiplier, multiplicant);
+  assert(mpq_cmp_si(product, N1 * N2, D1 * D2) = 0);
+  mpq_clear(product);
+  mpq_clear(multiplier);
+  mpq_clear(multiplicant);
+end;
+
+procedure TTestGmpBinding.mpq_mul_2exp_test;
+const
+  N1 = 5;
+  D1 = 3;
+  OP_2 = 2;
+var rop, op1: mpq_t;
+begin
+  mpq_init(rop);
+  mpq_init(op1);
+  mpq_set_si(op1, N1, D1);
+  mpq_mul_2exp(rop, op1, OP_2);
+  assert(mpq_cmp_si(rop, N1 * (1 shl OP_2), D1) = 0);
+  mpq_clear(rop);
+  mpq_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpq_div_test;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var quotient, dividend, divisor: mpq_t;
+begin
+  mpq_init(quotient);
+  mpq_init(dividend);
+  mpq_init(divisor);
+  mpq_set_si(dividend, N1, D1);
+  mpq_set_si(divisor, N2, D2);
+  mpq_div(quotient, dividend, divisor);
+  assert(mpq_cmp_si(quotient, -N1 * D2, -D1 * N2) = 0);
+  mpq_clear(quotient);
+  mpq_clear(dividend);
+  mpq_clear(divisor);
+end;
+
+procedure TTestGmpBinding.mpq_div_2exp_test;
+const
+  N1 = 5;
+  D1 = 3;
+  OP_2 = 2;
+var rop, op1: mpq_t;
+begin
+  mpq_init(rop);
+  mpq_init(op1);
+  mpq_set_si(op1, N1, D1);
+  mpq_div_2exp(rop, op1, OP_2);
+  assert(mpq_cmp_si(rop, N1, D1 * (1 shl OP_2)) = 0);
+  mpq_clear(rop);
+  mpq_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpq_neg_test;
+const
+  N1 = -5;
+  D1 = 3;
+var negated_operand, operand: mpq_t;
+begin
+  mpq_init(negated_operand);
+  mpq_init(operand);
+  mpq_set_si(operand, N1, D1);
+  mpq_neg(negated_operand, operand);
+  assert(mpq_cmp_si(negated_operand, -N1, D1) = 0);
+  mpq_clear(negated_operand);
+  mpq_clear(operand);
+end;
+
+procedure TTestGmpBinding.mpq_abs_test;
+const
+  N1 = 5;
+  D1 = 3;
+var rop, op: mpq_t;
+begin
+  mpq_init(rop);
+  mpq_init(op);
+  mpq_set_si(op, -N1, D1);
+  mpq_abs(rop, op);
+  assert(mpq_cmp_si(rop, N1, D1) = 0);
+  mpq_clear(rop);
+  mpq_clear(op);
+end;
+
+procedure TTestGmpBinding.mpq_inv_test;
+const
+  N1 = -5;
+  D1 = 3;
+var inverted_number, number: mpq_t;
+begin
+  mpq_init(inverted_number);
+  mpq_init(number);
+  mpq_set_si(number, N1, D1);
+  mpq_inv(inverted_number, number);
+  assert(mpq_cmp_si(inverted_number, -D1, -N1) = 0);
+  mpq_clear(inverted_number);
+  mpq_clear(number);
+end;
+
+procedure TTestGmpBinding.mpq_cmp_test;
+const
+  N1 = -7;
+  D1 = 5;
+var op1, op2: mpq_t;
+begin
+  mpq_init(op1);
+  mpq_init(op2);
+  mpq_set_si(op1, N1, D1);
+  mpq_set_si(op2, N1, D1);
+  assert(mpq_cmp(op1, op2) = 0);
+  mpq_set_si(op1, N1 + 1, D1);
+  assert(mpq_cmp(op1, op2) > 0);
+  mpq_set_si(op1, N1 - 1, D1);
+  assert(mpq_cmp(op1, op2) < 0);
+  mpq_clear(op1);
+  mpq_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpq_cmp_si_test;
+const
+  N1 = -7;
+  D1 = 5;
+var op1: mpq_t;
+begin
+  mpq_init(op1);
+  mpq_set_si(op1, N1, D1);
+  assert(mpq_cmp_si(op1, N1, D1) = 0);
+  assert(mpq_cmp_si(op1, N1 - 1, D1) > 0);
+  assert(mpq_cmp_si(op1, N1 + 1, D1) < 0);
+  mpq_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpq_cmp_ui_test;
+const
+  N1 = 7;
+  D1 = 5;
+var op1: mpq_t;
+begin
+  mpq_init(op1);
+  mpq_set_si(op1, N1, D1);
+  assert(mpq_cmp_ui(op1, N1, D1) = 0);
+  assert(mpq_cmp_ui(op1, N1 - 1, D1) > 0);
+  assert(mpq_cmp_ui(op1, N1 + 1, D1) < 0);
+  mpq_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpq_equal_test;
+const
+  N1 = -7;
+  D1 = 5;
+var op1, op2: mpq_t;
+begin
+  mpq_init(op1);
+  mpq_init(op2);
+  mpq_set_si(op1, N1, D1);
+  mpq_set_si(op2, N1, D1);
+  assert(longbool(mpq_equal(op1, op2)));
+  mpq_set_si(op1, N1 + 1, D1);
+  assert(not longbool(mpq_equal(op1, op2)));
+  mpq_set_si(op1, N1 - 1, D1);
+  assert(not longbool(mpq_equal(op1, op2)));
+  mpq_clear(op1);
+  mpq_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpq_get_num_test;
+const
+  N1 = -7;
+  D1 = 5;
+var
+  rational: mpq_t;
+  numerator: mpz_t;
+begin
+  mpq_init(rational);
+  mpz_init(numerator);
+  mpq_set_si(rational, N1, D1);
+  mpq_get_num(numerator, rational);
+  assert(mpz_get_si(numerator) = N1);
+  mpq_clear(rational);
+  mpz_clear(numerator);
+end;
+
+procedure TTestGmpBinding.mpq_get_den_test;
+const
+  N1 = -7;
+  D1 = 5;
+var
+  rational: mpq_t;
+  denominator: mpz_t;
+begin
+  mpq_init(rational);
+  mpz_init(denominator);
+  mpq_set_si(rational, N1, D1);
+  mpq_get_den(denominator, rational);
+  assert(mpz_get_si(denominator) = D1);
+  mpq_clear(rational);
+  mpz_clear(denominator);
+end;
+
+procedure TTestGmpBinding.mpq_set_num_test;
+const
+  N1 = -7;
+  D1 = 5;
+  N2 = 3;
+var
+  rational: mpq_t;
+  numerator: mpz_t;
+begin
+  mpq_init(rational);
+  mpz_init_set_si(numerator, N2);
+  mpq_set_si(rational, N1, D1);
+  mpq_set_num(rational, numerator);
+  assert(mpq_cmp_si(rational, N2, D1) = 0);
+  mpq_clear(rational);
+  mpz_clear(numerator);
+end;
+
+procedure TTestGmpBinding.mpq_set_den_test;
+const
+  N1 = -7;
+  D1 = 5;
+  D2 = 3;
+var
+  rational: mpq_t;
+  denominator: mpz_t;
+begin
+  mpq_init(rational);
+  mpz_init_set_si(denominator, D2);
+  mpq_set_si(rational, N1, D1);
+  mpq_set_den(rational, denominator);
+  assert(mpq_cmp_si(rational, N1, D2) = 0);
+  mpq_clear(rational);
+  mpz_clear(denominator);
+end;
+
+procedure TTestGmpBinding.mpf_get_default_prec_test;
+begin
+  assert(mpf_get_default_prec > 0);
+end;
+
+procedure TTestGmpBinding.mpf_set_default_prec_test;
+var prec: valuint;
+begin
+  prec := mpf_get_default_prec;
+  mpf_set_default_prec(2 * prec);
+  assert(mpf_get_default_prec  = 2 * prec);
+  mpf_set_default_prec(prec);
+end;
+
+procedure TTestGmpBinding.mpf_init_test;
+var x: mpf_t;
+begin
+  mpf_init(x);
+  assert(mpf_get_prec(x) = mpf_get_default_prec);
+  mpf_clear(x);
+end;
+
+procedure TTestGmpBinding.mpf_init2_test;
+var x: mpf_t;
+begin
+  mpf_init2(x, 2 * mpf_get_default_prec);
+  assert(mpf_get_prec(x) = 2 * mpf_get_default_prec);
+  mpf_clear(x);
+end;
+
+procedure TTestGmpBinding.mpf_clear_test;
+var x: mpf_t;
+begin
+  mpf_init(x);
+  mpf_clear(x);
+end;
+
+procedure TTestGmpBinding.mpf_get_prec_test;
+var x: mpf_t;
+begin
+  mpf_init(x);
+  mpf_set_prec(x, 2 * mpf_get_default_prec);
+  assert(mpf_get_prec(x) = 2 * mpf_get_default_prec);
+  mpf_clear(x);
+end;
+
+procedure TTestGmpBinding.mpf_set_prec_test;
+var x: mpf_t;
+begin
+  mpf_init(x);
+  mpf_set_prec(x, 2 * mpf_get_default_prec);
+  assert(mpf_get_prec(x) = 2 * mpf_get_default_prec);
+  mpf_clear(x);
+end;
+
+procedure TTestGmpBinding.mpf_set_prec_raw_test;
+const N = 10;
+var x: mpf_t;
+begin
+  mpf_init2(x, N * mpf_get_default_prec);
+  mpf_set_prec_raw(x, mpf_get_default_prec);
+  mpf_set_prec_raw(x, N * mpf_get_default_prec);
+  mpf_clear(x);
+end;
+
+procedure TTestGmpBinding.mpf_set_q_test;
+const OP_ = -10;
+var
+  op: mpq_t;
+  rop: mpf_t;
+begin
+  mpq_init(op);
+  mpf_init(rop);
+  mpq_set_si(op, OP_, 1);
+  mpf_set_q(rop, op);
+  assert(mpf_get_si(rop) = OP_);
+  mpf_clear(rop);
+  mpq_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_set_ui_test;
+const OP = 1000000;
+var rop: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_set_ui(rop, OP);
+  assert(mpf_get_ui(rop) = OP);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_get_ui_test;
+const OP = 1000000;
+var rop: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_set_ui(rop, OP);
+  assert(mpf_get_ui(rop) = OP);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_set_si_test;
+const OP = -1000000;
+var rop: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_set_si(rop, OP);
+  assert(mpf_get_si(rop) = OP);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_get_si_test;
+const OP = -1000000;
+var rop: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_set_si(rop, OP);
+  assert(mpf_get_si(rop) = OP);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_set_test;
+const N = -1000000;
+var rop, op: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_si(op, N);
+  mpf_set(rop, op);
+  assert(mpf_get_si(rop) = N);
+  mpf_clear(rop);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_set_str_test;
+const N = -123;
+var rop: mpf_t;
+begin
+  mpf_init(rop);
+  assert(mpf_set_str(rop, pchar(inttostr(N)), BASE10) = 0);
+  assert(mpf_get_si(rop) = N);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_swap_test;
+const
+  ROP_1 = -13;
+  ROP_2 = -23;
+var rop1, rop2: mpf_t;
+begin
+  mpf_init_set_si(rop1, ROP_1);
+  mpf_init_set_si(rop2, ROP_2);
+  mpf_swap(rop1, rop2);
+  assert(mpf_get_si(rop1) =  ROP_2);
+  assert(mpf_get_si(rop2) = ROP_1);
+  mpf_clear(rop1);
+  mpf_clear(rop2);
+end;
+
+procedure TTestGmpBinding.mpf_get_d_test;
+const N = -1.5;
+var rop: mpf_t;
+begin
+  mpf_init_set_d(rop, N);
+  assert(mpf_get_d(rop) = N);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_set_d_test;
+const N = -1.5;
+var rop: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_set_d(rop, N);
+  assert(mpf_get_d(rop) = N);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_setmpz_test;
+const
+  OP_1 = -13;
+var
+  rop: mpf_t;
+  op: mpz_t;
+begin
+  mpf_init(rop);
+  mpz_init_set_si(op, OP_1);
+  mpf_set_z(rop, op);
+  assert(mpf_get_si(rop) = OP_1);
+  mpf_clear(rop);
+  mpz_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_get_d_2exp_test;
+const
+  M = 0.5;
+  E = 4;
+  N = (1 shl E) div 2;
+var
+  rop: mpf_t;
+  exp: valsint;
+begin
+  mpf_init_set_d(rop, N);
+  exp := -1;
+  assert(mpf_get_d_2exp(exp, rop) = M);
+  assert(exp = E);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_get_str_test;
+const
+  N = 3.1416;
+  S = '31416';
+  E = 1;
+var
+  op: mpf_t;
+  p: pchar;
+  exp: mp_exp_t;
+begin
+  mpf_init_set_d(op, N);
+  p := mpf_get_str(nil, exp, BASE10, length(S), op);
+  assert(p = S);
+  assert(exp = E);
+  freemem(p);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_add_test;
+const
+  OP1_ = 1;
+  OP2_ = 2;
+var rop, op1, op2: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_init_set_d(op2, OP2_);
+  mpf_add(rop, op1, op2);
+  assert(mpf_get_d(rop) = OP1_ + OP2_);
+  mpf_clear(rop);
+  mpf_clear(op1);
+  mpf_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpf_add_ui_test;
+const
+  OP1_ = 1;
+  OP2_ = 2;
+var rop, op1: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_add_ui(rop, op1, OP2_);
+  assert(mpf_get_d(rop) = OP1_ + OP2_);
+  mpf_clear(rop);
+  mpf_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpf_sub_test;
+const
+  OP1_ = 3;
+  OP2_ = 1;
+var rop, op1, op2: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_init_set_d(op2, OP2_);
+  mpf_sub(rop, op1, op2);
+  assert(mpf_get_d(rop) = OP1_ - OP2_);
+  mpf_clear(rop);
+  mpf_clear(op1);
+  mpf_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpf_sub_ui_test;
+const
+  OP1_ = 3;
+  OP2_ = 1;
+var rop, op1: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_sub_ui(rop, op1, OP2_);
+  assert(mpf_get_d(rop) = OP1_ - OP2_);
+  mpf_clear(rop);
+  mpf_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpf_ui_sub_test;
+const
+  OP1_ = 3;
+  OP2_ = 1;
+var rop, op2: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op2, OP2_);
+  mpf_ui_sub(rop, OP1_, op2);
+  assert(mpf_get_d(rop) = OP1_ - OP2_);
+  mpf_clear(rop);
+  mpf_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpf_mul_test;
+const
+  OP1_ = 2;
+  OP2_ = 3;
+var rop, op1, op2: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_init_set_d(op2, OP2_);
+  mpf_mul(rop, op1, op2);
+  assert(mpf_get_d(rop) = OP1_ * OP2_);
+  mpf_clear(rop);
+  mpf_clear(op1);
+  mpf_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpf_mul_ui_test;
+const
+  OP1_ = 2;
+  OP2_ = 3;
+var rop, op1: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_mul_ui(rop, op1, OP2_);
+  assert(mpf_get_d(rop) = OP1_ * OP2_);
+  mpf_clear(rop);
+  mpf_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpf_mul_2exp_test;
+const
+  OP1_ = 3;
+  OP2_ = 4;
+var rop, op1: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_mul_2exp(rop, op1, OP2_);
+  assert(mpf_get_d(rop) = OP1_ * (1 shl OP2_));
+  mpf_clear(rop);
+  mpf_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpf_div_test;
+const
+  OP1_ = 6;
+  OP2_ = 2;
+var rop, op1, op2: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_init_set_d(op2, OP2_);
+  mpf_div(rop, op1, op2);
+  assert(mpf_get_d(rop) = OP1_ / OP2_);
+  mpf_clear(rop);
+  mpf_clear(op1);
+  mpf_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpf_div_ui_test;
+const
+  OP1_ = 6;
+  OP2_ = 2;
+var rop, op1: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_div_ui(rop, op1, OP2_);
+  assert(mpf_get_d(rop) = OP1_ / OP2_);
+  mpf_clear(rop);
+  mpf_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpf_ui_div_test;
+const
+  OP1_ = 6;
+  OP2_ = 2;
+var rop, op2: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_si(op2, OP2_);
+  mpf_ui_div(rop, OP1_, op2);
+  assert(mpf_get_d(rop) = OP1_ / OP2_);
+  mpf_clear(rop);
+  mpf_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpf_div_2exp_test;
+const
+  OP1_ = 16;
+  OP2_ = 2;
+var rop, op1: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_div_2exp(rop, op1, OP2_);
+  assert(mpf_get_d(rop) = OP1_ / (1 shl OP2_));
+  mpf_clear(rop);
+  mpf_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpf_sqrt_test;
+const
+  OP_ = 4;
+var rop, op: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op, OP_);
+  mpf_sqrt(rop, op);
+  assert(mpf_get_d(rop) = sqrt(OP_));
+  mpf_clear(rop);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_sqrt_ui_test;
+const
+  OP_ = 4;
+var rop: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_sqrt_ui(rop, OP_);
+  assert(mpf_get_d(rop) = sqrt(OP_));
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_pow_ui_test;
+const
+  OP1_ = 3;
+  OP2_ = 2;
+var rop, op1: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_pow_ui(rop, op1, OP2_);
+  assert(mpf_get_d(rop) = OP1_ ** OP2_);
+  mpf_clear(rop);
+  mpf_clear(op1);
+end;
+
+procedure TTestGmpBinding.mpf_neg_test;
+const
+  OP_ = 4;
+var rop, op: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op, OP_);
+  mpf_neg(rop, op);
+  assert(mpf_get_d(rop) = -OP_);
+  mpf_clear(rop);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_abs_test;
+const OP_ = -4;
+var rop, op: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op, OP_);
+  mpf_abs(rop, op);
+  assert(mpf_get_d(rop) = -OP_);
+  mpf_clear(rop);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_cmp_test;
+const OP_1 = -10;
+var op1, op2: mpf_t;
+begin
+  mpf_init_set_si(op1, OP_1);
+  mpf_init_set_si(op2, OP_1);
+  assert(mpf_cmp(op1, op2) = 0);
+  mpf_set_si(op2, OP_1 + 1);
+  assert(mpf_cmp(op1, op2) < 0);
+  mpf_set_si(op2, OP_1 - 1);
+  assert(mpf_cmp(op1, op2) > 0);
+  mpf_clear(op1);
+  mpf_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpf_cmp_d_test;
+const OP_ = -10;
+var op: mpf_t;
+begin
+  mpf_init_set_si(op, OP_);
+  assert(mpf_cmp_d(op, OP_) = 0);
+  assert(mpf_cmp_d(op, OP_ + 1) < 0);
+  assert(mpf_cmp_d(op, OP_ - 1) > 0);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_cmp_si_test;
+const OP_ = -10;
+var op: mpf_t;
+begin
+  mpf_init_set_si(op, OP_);
+  assert(mpf_cmp_si(op, OP_) = 0);
+  assert(mpf_cmp_si(op, OP_ + 1) < 0);
+  assert(mpf_cmp_si(op, OP_ - 1) > 0);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_cmp_ui_test;
+const OP_ = 10;
+var op: mpf_t;
+begin
+  mpf_init_set_si(op, OP_);
+  assert(mpf_cmp_ui(op, OP_) = 0);
+  assert(mpf_cmp_ui(op, OP_ + 1) < 0);
+  assert(mpf_cmp_ui(op, OP_ - 1) > 0);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_eq_test;
+const
+  OP_1 = 10;
+  OP_3 = 8;
+var op1, op2: mpf_t;
+begin
+  mpf_init_set_si(op1, OP_1);
+  mpf_init_set_si(op2, OP_1);
+  assert(mpf_eq(op1, op2, OP_3) <> 0);
+  mpf_clear(op1);
+  mpf_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpf_reldiff_test;
+const
+  OP1_ = 4;
+  OP2_ = 2;
+var rop, op1, op2: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op1, OP1_);
+  mpf_init_set_d(op2, OP2_);
+  mpf_reldiff(rop, op1, op2);
+  assert(mpf_get_d(rop) = abs(OP1_ - OP2_) / OP1_);
+  mpf_clear(rop);
+  mpf_clear(op1);
+  mpf_clear(op2);
+end;
+
+procedure TTestGmpBinding.mpf_ceil_test;
+const N = 3.1;
+var rop, op: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op, N);
+  mpf_ceil(rop, op);
+  assert(mpf_get_d(rop) = ceil(N));
+  mpf_clear(rop);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_floor_test;
+const N = 3.9;
+var rop, op: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op, N);
+  mpf_floor(rop, op);
+  assert(mpf_get_d(rop) = floor(N));
+  mpf_clear(rop);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_trunc_test;
+const N = -3.9;
+var rop, op: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_init_set_d(op, N);
+  mpf_trunc(rop, op);
+  assert(mpf_get_d(rop) = trunc(N));
+  mpf_clear(rop);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_integer_p_test;
+const
+  N1 = 10;
+  N2 = 10.1;
+var op: mpf_t;
+begin
+  mpf_init_set_si(op, N1);
+  assert(longbool(mpf_integer_p(op)));
+  mpf_set_d(op, N2);
+  assert(not longbool(mpf_integer_p(op)));
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_fits_ushort_p_test;
+var op: mpf_t;
+begin
+  mpf_init_set_ui(op, high(word));
+  assert(longbool(mpf_fits_ushort_p(op)));
+  mpf_add_ui(op, op, 1);
+  assert(not longbool(mpf_fits_ushort_p(op)));
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_fits_sshort_p_test;
+var op: mpf_t;
+begin
+  mpf_init_set_ui(op, high(smallint));
+  assert(longbool(mpf_fits_sshort_p(op)));
+  mpf_add_ui(op, op, 1);
+  assert(not longbool(mpf_fits_sshort_p(op)));
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_fits_uint_p_test;
+var op: mpf_t;
+begin
+  mpf_init_set_ui(op, high(cardinal));
+  assert(longbool(mpf_fits_uint_p(op)));
+  mpf_add_ui(op, op, 1);
+  assert(not longbool(mpf_fits_uint_p(op)));
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_fits_sint_p_test;
+var op: mpf_t;
+begin
+  mpf_init_set_ui(op, high(integer));
+  assert(longbool(mpf_fits_sint_p(op)));
+  mpf_add_ui(op, op, 1);
+  assert(not longbool(mpf_fits_sint_p(op)));
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_fits_ulong_p_test;
+var op: mpf_t;
+begin
+  mpf_init_set_ui(op, high(valuint));
+  assert(longbool(mpf_fits_ulong_p(op)));
+  mpf_add_ui(op, op, 1);
+  assert(not longbool(mpf_fits_ulong_p(op)));
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_fits_slong_p_test;
+var op: mpf_t;
+begin
+  mpf_init_set_ui(op, high(valsint));
+  assert(longbool(mpf_fits_slong_p(op)));
+  mpf_add_ui(op, op, 1);
+  assert(not longbool(mpf_fits_slong_p(op)));
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_urandomb_test;
+const NBITS = 100;
+var
+  rop: mpf_t;
+  state: randstate_t;
+  cmp: longint;
+begin
+  mp_randinit_default(state);
+  mpf_init(rop);
+  mpf_urandomb(rop, state, NBITS);
+  cmp := mpf_cmp_ui(rop, 0);
+  assert(cmp >= 0);
+  assert(mpf_cmp_ui(rop, 1) < 0);
+  mpf_clear(rop);
+  mp_randclear(state);
+end;
+
+procedure TTestGmpBinding.mpf_random2_test;
+var
+  rop: mpf_t;
+begin
+  mpf_init(rop);
+  mpf_random2(rop, 1, 1);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_init_set_test;
+const N = -1000000;
+var rop, op: mpf_t;
+begin
+  mpf_init_set_si(op, N);
+  mpf_init_set(rop, op);
+  assert(mpf_get_si(rop) = N);
+  mpf_clear(rop);
+  mpf_clear(op);
+end;
+
+procedure TTestGmpBinding.mpf_init_set_d_test;
+const N = -1.5;
+var rop: mpf_t;
+begin
+  mpf_init_set_d(rop, N);
+  assert(mpf_get_d(rop) = N);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_init_set_si_test;
+const N = -5;
+var rop: mpf_t;
+begin
+  mpf_init_set_si(rop, N);
+  assert(mpf_get_si(rop) = N);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_init_set_str_test;
+const N = -123;
+var rop: mpf_t;
+begin
+  mpf_init_set_str(rop, pchar(inttostr(N)), BASE10);
+  assert(mpf_get_si(rop) = N);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpf_init_set_ui_test;
+const N = 5;
+var rop: mpf_t;
+begin
+  mpf_init_set_ui(rop, N);
+  assert(mpf_get_ui(rop) = N);
+  mpf_clear(rop);
+end;
+
+procedure TTestGmpBinding.mpn_add_n_test;
+var
+  rop, s1, s2: mp_limb_t;
+begin
+  s1 := high(mp_limb_t);
+  s2 := s1;
+  rop := 2;
+  assert(mpn_add_n(@rop, @s1, @s2, 1) = 1);
+  assert(rop = high(mp_limb_t) - 1);
+end;
+
+procedure TTestGmpBinding.mpn_add_1_test;
+var
+  rop, s1: mp_limb_t;
+begin
+  s1 := high(mp_limb_t);
+  rop := 2;
+  assert(mpn_add_1(@rop, @s1, 1, high(mp_limb_t)) = 1);
+  assert(rop = high(mp_limb_t) - 1);
+end;
+
+procedure TTestGmpBinding.mpn_add_test;
+var
+  rop, s1, s2: mp_limb_t;
+begin
+  s1 := high(mp_limb_t);
+  s2 := s1;
+  rop := 2;
+  assert(mpn_add(@rop, @s1, 1, @s2, 1) = 1);
+  assert(rop = high(mp_limb_t) - 1);
+end;
+
+procedure TTestGmpBinding.mpn_sub_n_test;
+var
+  rop, s1, s2: mp_limb_t;
+begin
+  s1 := 0;
+  s2 := high(mp_limb_t);
+  rop := 2;
+  assert(mpn_sub_n(@rop, @s1, @s2, 1) = 1);
+  assert(rop = 1);
+end;
+
+procedure TTestGmpBinding.mpn_sub_1_test;
+var
+  rop, s1: mp_limb_t;
+begin
+  s1 := 0;
+  rop := 2;
+  assert(mpn_sub_1(@rop, @s1, 1, high(mp_limb_t)) = 1);
+  assert(rop = 1);
+end;
+
+procedure TTestGmpBinding.mpn_sub_test;
+var
+  rop, s1, s2: mp_limb_t;
+begin
+  s1 := 0;
+  s2 := high(mp_limb_t);
+  rop := 2;
+  assert(mpn_sub(@rop, @s1, 1, @s2, 1) = 1);
+  assert(rop = 1);
+end;
+
+procedure TTestGmpBinding.mpn_mul_n_test;
+var
+  rop: array[0..1] of mp_limb_t;
+  s1, s2: mp_limb_t;
+begin
+  s1 := high(mp_limb_t);
+  s2 := s1;
+  mpn_mul_n(@rop, @s1, @s2, 1);
+  assert(rop[0] = 1);
+  assert(rop[1] = high(mp_limb_t) - 1);
+end;
+
+procedure TTestGmpBinding.mpn_mul_1_test;
+var
+  rop: array[0..1] of mp_limb_t;
+  s1: mp_limb_t;
+begin
+  s1 := high(mp_limb_t);
+  assert(mpn_mul_1(@rop, @s1, 1, high(mp_limb_t)) = high(mp_limb_t) - 1);
+  assert(rop[0] = 1);
+end;
+
+procedure TTestGmpBinding.mpn_mul_test;
+var
+  rop: array[0..1] of mp_limb_t;
+  s1, s2: mp_limb_t;
+begin
+  s1 := high(mp_limb_t);
+  s2 := s1;
+  assert(mpn_mul(@rop, @s1, 1, @s2, 1) = high(mp_limb_t) - 1);
+  assert(rop[0] = 1);
+  assert(rop[1] = high(mp_limb_t) - 1);
+end;
+
+procedure TTestGmpBinding.mpn_addmul_1_test;
+var
+  rop: array[0..1] of mp_limb_t;
+  s1: mp_limb_t;
+begin
+  rop[0] := 1;
+  rop[1] := 0;
+  s1 := high(mp_limb_t);
+  assert(mpn_addmul_1(@rop, @s1, 1, high(mp_limb_t)) = high(mp_limb_t) - 1);
+  assert(rop[0] = 2);
+end;
+
+procedure TTestGmpBinding.mpn_submul_1_test;
+var
+  rop: array[0..1] of mp_limb_t;
+  s1: mp_limb_t;
+begin
+  rop[0] := 1;
+  rop[1] := 0;
+  s1 := high(mp_limb_t);
+  assert(mpn_submul_1(@rop, @s1, 1, high(mp_limb_t)) = high(mp_limb_t) - 1);
+  assert(rop[0] = 0);
+end;
+
+procedure TTestGmpBinding.mpn_tdiv_qr_test;
+const
+  N_ = 19;
+  D_ = 4;
+var
+  q, r: array[0..1] of mp_limb_t;
+  n, d: mp_limb_t;
+begin
+  n := N_;
+  d := D_;
+  q[0] := 0;
+  q[1] := 0;
+  r[0] := 0;
+  r[1] := 0;
+  mpn_tdiv_qr(@q, @r, 0, @n, 1, @d, 1);
+  assert(q[0] = N_ div D_);
+  assert(r[0] = N_ mod D_);
+end;
+
+procedure TTestGmpBinding.mpn_divrem_1_test;
+const
+  N_ = 19;
+  D_ = 4;
+var r1, s2: mp_limb_t;
+begin
+  r1 := 0;
+  s2 := N_;
+  assert(mpn_divrem_1(@r1, 0, @s2, 1, D_) = N_ mod D_);
+  assert(r1 = N_ div D_);
+end;
+
+procedure TTestGmpBinding.mpn_divexact_by3c_test;
+const
+  K = 3;
+  N_ = 17;
+var r, s: mp_limb_t;
+begin
+  r := 0;
+  s := K * N_;
+  assert(mpn_divexact_by3c(@r, @s, 1, 0) = 0);
+  assert(r = N_);
+  s := K * N_ + 1;
+  assert(mpn_divexact_by3c(@r, @s, 1, 0) <> 0);
+end;
+
+procedure TTestGmpBinding.mpn_mod_1_test;
+const
+  N_ = 19;
+  D_ = 4;
+var s1: mp_limb_t;
+begin
+  s1 := N_;
+  assert(mpn_mod_1(@s1, 1, D_) = N_ mod D_);
+end;
+
+procedure TTestGmpBinding.mpn_lshift_test;
+var r, s: mp_limb_t;
+begin
+  r := 0;
+  s := high(mp_limb_t);
+  assert(mpn_lshift(@r, @s, 1, 1) = 1);
+  assert(r = high(mp_limb_t) - 1);
+end;
+
+procedure TTestGmpBinding.mpn_rshift_test;
+var r, s: mp_limb_t;
+begin
+  r := 0;
+  s := high(mp_limb_t);
+  assert(mpn_rshift(@r, @s, 1, 1) = valuint(1) shl (bits_per_limb - 1));
+  assert(r = high(mp_limb_t) shr 1);
+end;
+
+procedure TTestGmpBinding.mpn_cmp_test;
+const S1_ = 10;
+var s1, s2: mp_limb_t;
+begin
+  s1 := S1_;
+  S2 := S1_;
+  assert(mpn_cmp(@s1, @s2, 1) = 0);
+  S2 := S1_ - 1;
+  assert(mpn_cmp(@s1, @s2, 1) > 0);
+  S2 := S1_ + 1;
+  assert(mpn_cmp(@s1, @s2, 1) < 0);
+end;
+
+procedure TTestGmpBinding.mpn_gcd_test;
+const
+  S1_ = 30;
+  S2_ = 105;
+  RP_ = 15;
+var r, s1, s2: mp_limb_t;
+begin
+  s1 := S1_;
+  s2 := S2_;
+  r := 0;
+  assert(mpn_gcd(@r, @s1, 1, @s2, 1) = 1);
+  assert(r = RP_);
+end;
+
+procedure TTestGmpBinding.mpn_gcd_1_test;
+const
+  S1_ = 30;
+  S2_ = 105;
+  R_ = 15;
+var s1: mp_limb_t;
+begin
+  s1 := S1_;
+  assert(mpn_gcd_1(@s1, 1, S2_) = R_);
+end;
+
+procedure TTestGmpBinding.mpn_gcdext_test;
+const
+  S1_ = 3 * 5;
+  S2_ = 2 * 3;
+  R1_ = 3;
+var
+  r1, r2, s1, s2: array[0..1] of mp_limb_t;
+  r2n: mp_size_t;
+  k: valsint;
+begin
+  s1[0] := S1_;
+  s1[1] := 0;
+  s2[0] := S2_;
+  s2[1] := 0;
+  assert(mpn_gcdext(@r1, @r2, r2n, @s1, 1, @s2, 1) = 1);
+  assert(r2n = 1);
+  assert(r1[0] = R1_);
+  k := (valsint(r1[0]) - valsint(r2[0]) * valsint(s1[0])) div valsint(s2[0]);
+  assert(valsint(r1[0]) = valsint(r2[0]) * valsint(s1[0]) + k * valsint(s2[0]));
+end;
+
+procedure TTestGmpBinding.mpn_sqrtrem_test;
+const
+  ROOT = 3;
+var r1, r2, s: mp_limb_t;
+begin
+  s := ROOT ** 2 + ROOT - 1;
+  assert(mpn_sqrtrem(@r1, @r2, @s, 1) = 1);
+  assert(r1 = ROOT);
+  assert(r2 = ROOT - 1);
+end;
+
+procedure TTestGmpBinding.mpn_get_str_test;
+const N = uint64($FEDCBA9876543210);
+var
+  str: array[0..2 * sizeof(mp_limb_t)] of byte;
+  s1: mp_limb_t;
+  i: integer;
+begin
+  s1 := N and (high(mp_limb_t) - 1);
+  assert(mpn_get_str(@str, BASE16, @s1, 1) = high(str));
+  for i := 0 to high(str) - 1 do
+    assert(str[i] = high(str) - i - 1);
+end;
+
+procedure TTestGmpBinding.mpn_set_str_test;
+const N = uint64($FEDCBA9876543210);
+var
+  r: mp_limb_t;
+  str: array[0..2 * sizeof(mp_limb_t)] of byte;
+  i: integer;
+begin
+  for i := 0 to high(str) - 1 do
+    str[i] := high(str) - i - 1;
+  assert(mpn_set_str(@r, @str, high(str), BASE16) = 1);
+  assert(r = N and (high(mp_limb_t) - 1));
+end;
+
+procedure TTestGmpBinding.mpn_scan0_test;
+const
+  S1_ = $F75;
+  STARTING_BIT = 4;
+  N = 7;
+var s1: mp_limb_t;
+begin
+  s1 := S1_;
+  assert(mpn_scan0(@s1, STARTING_BIT) = N);
+end;
+
+procedure TTestGmpBinding.mpn_scan1_test;
+const
+  S1_ = $85;
+  STARTING_BIT = 4;
+  N = 7;
+var s1: mp_limb_t;
+begin
+  s1 := S1_;
+  assert(mpn_scan1(@s1, STARTING_BIT) = N);
+end;
+
+procedure TTestGmpBinding.mpn_popcount_test;
+const
+  S1_ = $55AA;
+  N = 8;
+var s1: mp_limb_t;
+begin
+  s1 := S1_;
+  assert(mpn_popcount(@s1, 1) = N);
+end;
+
+procedure TTestGmpBinding.mpn_hamdist_test;
+const
+  S1_ = $55;
+  S2_ = $7A;
+  N = 5;
+var s1, s2: mp_limb_t;
+begin
+  s1 := S1_;
+  s2 := S2_;
+  assert(mpn_hamdist(@s1, @s2, 1) = N);
+end;
+
+procedure TTestGmpBinding.mpn_perfect_square_p_test;
+const ROOT = 3;
+var s1: mp_limb_t;
+begin
+  s1 := ROOT ** 2;
+  assert(mpn_perfect_square_p(@s1, 1) <> 0);
+  s1 := s1 or 2;
+  assert(mpn_perfect_square_p(@s1, 1) = 0);
+end;
+
+procedure TTestGmpBinding.mpn_random_test;
+var r1: array[0..2] of mp_limb_t;
+begin
+  mpn_random(@r1, high(r1) + 1);
+  assert((r1[2] <> 0) and ((r1[0] <> r1[1]) or (r1[0] <> r1[2]) or (r1[1] <> r1[2])));
+end;
+
+procedure TTestGmpBinding.mpn_random2_test;
+var r1: array[0..2] of mp_limb_t;
+begin
+  mpn_random2(@r1, high(r1) + 1);
+  assert((r1[2] <> 0) and ((r1[0] <> r1[1]) or (r1[0] <> r1[2]) or (r1[1] <> r1[2])));
+end;
+
+procedure TTestGmpBinding.bits_per_limb_test;
+begin
+  assert(bits_per_limb = 8 * sizeof(mp_limb_t));
+end;
+
+procedure TTestGmpBinding.version_test;
+
+  function isvernum(s: string; first, last: integer): boolean;
+  var i: integer;
+  begin
+    i := strtointdef(copy(s, first, last - first + 1), -1);
+    result := i >= 0;
+  end;
+
+const DOT = '.';
+var
+  v: string;
+  dot1, dot2: integer;
+begin
+  v := version;
+  dot1 := pos(DOT, v);
+  assert(dot1 <> 0);
+  dot2 := posex(DOT, v, dot1 + 1);
+  assert(dot2 <> 0);
+  assert(isvernum(v, 1, dot1 - 1));
+  assert(isvernum(v, dot1 + 1, dot2 - 1));
+  assert(isvernum(v, dot2 + 1, length(v)));
+end;
+
+{ TTestGmpExtensions }
+
+procedure TTestGmpExtensions.randinit_default_test;
+var state: MPRandState;
+begin
+  randinit_default(state);
+  assert(rnd_test(state.Ptr^));
+end;
+
+procedure TTestGmpExtensions.randinit_mt_test;
+var state: MPRandState;
+begin
+  randinit_mt(state);
+  assert(rnd_test(state.Ptr^));
+end;
+
+procedure TTestGmpExtensions.randinit_lc_2exp_test;
+const
+  A_ =  3;
+  C = 5;
+  M2EXP = 8;
+var
+  state: MPRandState;
+  a: MPInteger;
+begin
+  z_init_set_ui(a, A_);
+  randinit_lc_2exp(state, a, C, M2EXP);
+  assert(rnd_test(state.Ptr^));
+end;
+
+procedure TTestGmpExtensions.randinit_lc_2exp_size_test;
+var state: MPRandState;
+begin
+  assert(randinit_lc_2exp_size(state, 0));
+  assert(rnd_test(state.Ptr^));
+end;
+
+procedure TTestGmpExtensions.randinit_set_test;
+var rop, op: MPRandState;
+begin
+  randinit_default(op);
+  randinit_set(rop, op);
+  assert(rnd_test(rop.Ptr^));
+end;
+
+procedure TTestGmpExtensions.randclear_test;
+var state: MPRandState;
+begin
+  randinit_default(state);
+  randclear(state);
+end;
+
+procedure TTestGmpExtensions.randseed_test;
+var
+  state: MPRandState;
+  seed: MPInteger;
+begin
+  randinit_default(state);
+  z_init_set_ui(seed, 0);
+  randseed(state, seed);
+end;
+
+procedure TTestGmpExtensions.randseed_ui_test;
+var state: MPRandState;
+begin
+  randinit_default(state);
+  randseed_ui(state, 0);
+end;
+
+procedure TTestGmpExtensions.urandomb_ui_test;
+const
+  B = 8 * (sizeof(valuint) - 1);
+  N = 1 shl B;
+var
+  state: MPRandState;
+  r1, r2, r3: valuint;
+begin
+  randinit_default(state);
+  r1 := urandomb_ui(state, B);
+  r2 := urandomb_ui(state, B);
+  r3 := urandomb_ui(state, B);
+  assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
+end;
+
+procedure TTestGmpExtensions.urandomm_ui_test;
+const  N = high(valuint);
+var
+  state: MPRandState;
+  r1, r2, r3: valuint;
+begin
+  randinit_default(state);
+  r1 := urandomm_ui(state, N);
+  r2 := urandomm_ui(state, N);
+  r3 := urandomm_ui(state, N);
+  assert((r1 < N) and (r2 < N) and (r3 < N) and ((r1 <> r2) or (r1 <> r3) or (r2 <> r3)));
+end;
+
+//procedure TTestGmpExtensions.asprintf_test;
+//const
+//  N = 123456;
+//  S = '123456';
+//var
+//  z: MPInteger;
+//  p: pchar;
+//begin
+//  z_init_set_ui(z, N);
+//  assert(asprintf(p, Z_FMT, [@z]) = length(S));
+//  assert(p = S);
+//  freemem(p);
+//  z_clear(z);
+//end;
+//
+//procedure TTestGmpExtensions.asprintf_test2;
+//const
+//  N = 123456;
+//  S = '123456';
+//var
+//  z: MPInteger;
+//  p: pchar;
+//begin
+//  z_init_set_ui(z, N);
+//  assert(asprintf(p, Z_FMT, @z) = length(S));
+//  assert(p = S);
+//  freemem(p);
+//  z_clear(z);
+//end;
+//
+//procedure TTestGmpExtensions.snprintf_test;
+//const
+//  N = 123456;
+//  S = '123456';
+//var
+//  z: MPInteger;
+//  buf: pchar;
+//begin
+//  z_init_set_ui(z, N);
+//  getmem(buf, length(S) + 1);
+//  assert(snprintf(buf, length(S) + 1, Z_FMT, [@z]) = length(S));
+//  assert(buf = S);
+//  freemem(buf);
+//  z_clear(z);
+//end;
+//
+//procedure TTestGmpExtensions.snprintf_test2;
+//const
+//  N = 123456;
+//  S = '123456';
+//var
+//  z: MPInteger;
+//  buf: pchar;
+//begin
+//  z_init_set_ui(z, N);
+//  getmem(buf, length(S) + 1);
+//  assert(snprintf(buf, length(S) + 1, Z_FMT, @z) = length(S));
+//  assert(buf = S);
+//  freemem(buf);
+//  z_clear(z);
+//end;
+//
+//procedure TTestGmpExtensions.sprintf_test;
+//const
+//  N = 123456;
+//  S = '123456';
+//var
+//  z: MPInteger;
+//  buf: pchar;
+//begin
+//  z_init_set_ui(z, N);
+//  getmem(buf, length(S) + 1);
+//  assert(sprintf(buf, Z_FMT, [@z]) = length(S));
+//  assert(buf = S);
+//  freemem(buf);
+//  z_clear(z);
+//end;
+//
+//procedure TTestGmpExtensions.sprintf_test2;
+//const
+//  N = 123456;
+//  S = '123456';
+//var
+//  z: MPInteger;
+//  buf: pchar;
+//begin
+//  z_init_set_ui(z, N);
+//  getmem(buf, length(S) + 1);
+//  assert(sprintf(buf, Z_FMT, @z) = length(S));
+//  assert(buf = S);
+//  freemem(buf);
+//  z_clear(z);
+//end;
+//
+//procedure TTestGmpExtensions.sscanf_test;
+//const
+//  N = 3;
+//  D = 2;
+//var q: mpq_t;
+//begin
+//  q_init(q);
+//  assert(sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, [@q]) = 1);
+//  assert(q_cmp_ui(q, N, D) = 0);
+//  q_clear(q);
+//end;
+//
+//procedure TTestGmpExtensions.sscanf_test2;
+//const
+//  N = 3;
+//  D = 2;
+//var q: mpq_t;
+//begin
+//  q_init(q);
+//  assert(sscanf(pchar(inttostr(N) + '/' + inttostr(D)), Q_FMT, @q) = 1);
+//  assert(q_cmp_ui(q, N, D) = 0);
+//  q_clear(q);
+//end;
+
+procedure TTestGmpExtensions.z_init_test;
+var integer_: MPInteger;
+begin
+  z_init(integer_);
+  assert(z_get_si(integer_) = 0);
+end;
+
+procedure TTestGmpExtensions.z_clear_test;
+const N = 1000000;
+var integer_: MPInteger;
+begin
+  z_init2(integer_, N);
+  z_clear(integer_);
+  assert(z_get_si(integer_) = 0);
+end;
+
+procedure TTestGmpExtensions.z_init2_test;
+const N = 1000000;
+var integer_: MPInteger;
+begin
+  z_init2(integer_, N);
+  assert(z_get_si(integer_) = 0);
+end;
+
+procedure TTestGmpExtensions.z_init_set_si_test;
+const N = -1000000;
+var rop: MPInteger;
+begin
+  z_init_set_si(rop, N);
+  assert(z_get_si(rop) = N);
+end;
+
+procedure TTestGmpExtensions.z_init_set_ui_test;
+const N = 1000000;
+var rop: MPInteger;
+begin
+  z_init_set_ui(rop, N);
+  assert(z_get_ui(rop) = N);
+end;
+
+procedure TTestGmpExtensions.z_init_set_d_test;
+const N = -1000000;
+var rop: MPInteger;
+begin
+  z_init_set_d(rop, N);
+  assert(z_get_si(rop) = N);
+end;
+
+procedure TTestGmpExtensions.z_init_set_test;
+const N = -1000000;
+var rop, op: MPInteger;
+begin
+  z_init_set_si(op, N);
+  z_init_set(rop, op);
+  assert(z_get_si(rop) = N);
+end;
+
+procedure TTestGmpExtensions.z_init_set_str_test;
+const N = 1000000;
+var rop: MPInteger;
+begin
+  assert(z_init_set_str(rop, IntToStr(N), BASE10));
+  assert(z_get_si(rop) = N);
+end;
+
+procedure TTestGmpExtensions.z_realloc_test;
+const N = 1000;
+var integer_: MPInteger;
+begin
+  z_init(integer_);
+  z_realloc(integer_, N);
+end;
+
+procedure TTestGmpExtensions.z_realloc2_test;
+const N = 1000;
+var integer_: MPInteger;
+begin
+  z_init(integer_);
+  z_realloc2(integer_, N);
+end;
+
+procedure TTestGmpExtensions.z_getlimbn_test;
+const N = 1234;
+var op: MPInteger;
+begin
+  z_init_set_ui(op, N);
+  assert(z_getlimbn(op, 0) = N);
+end;
+
+procedure TTestGmpExtensions.z_export_test;
+type t = word;
+const
+  N = 1000000;
+  BUF_HIGH = sizeof(N) div sizeof(t);
+var
+  export_op, import_op: MPInteger;
+  buf: array[0..BUF_HIGH] of t;
+  count: sizeuint;
+begin
+  z_init_set_si(export_op, N);
+  z_init(import_op);
+  z_export(buf, count, -1, sizeof(t), 0, 0, export_op);
+  z_import(import_op, count, -1, sizeof(t), 0, 0, buf);
+  assert(z_get_si(export_op) = z_get_si(import_op));
+end;
+
+procedure TTestGmpExtensions.z_import_test;
+type t = word;
+const
+  N = 1000000;
+  BUF_HIGH = sizeof(N) div sizeof(t);
+var
+  export_op, import_op: MPInteger;
+  buf: array[0..BUF_HIGH] of t;
+  count: sizeuint;
+begin
+  z_init_set_si(export_op, N);
+  z_init(import_op);
+  z_export(buf, count, -1, sizeof(t), 0, 0, export_op);
+  z_import(import_op, count, -1, sizeof(t), 0, 0, buf);
+  assert(z_get_si(export_op) = z_get_si(import_op));
+end;
+
+procedure TTestGmpExtensions.z_swap_test;
+const
+  ROP_1 = -1000;
+  ROP_2 = 1000000;
+var rop1, rop2: MPInteger;
+begin
+  z_init_set_si(rop1, ROP_1);
+  z_init_set_si(rop2, ROP_2);
+  z_swap(rop1, rop2);
+  assert(z_get_si(rop1) = ROP_2);
+  assert(z_get_si(rop2) = ROP_1);
+end;
+
+procedure TTestGmpExtensions.z_set_test;
+const OP_ = 1000000;
+var rop, op: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op, OP_);
+  z_set(rop, op);
+  assert(z_get_si(rop) = OP_);
+end;
+
+procedure TTestGmpExtensions.z_set_d_test;
+const OP_ = 1000000;
+var rop: MPInteger;
+begin
+  z_init(rop);
+  z_set_d(rop, OP_);
+  assert(z_get_si(rop) = OP_);
+end;
+
+procedure TTestGmpExtensions.z_set_f_test;
+const OP_ = -10;
+var
+  op: MPFloat;
+  rop: MPInteger;
+begin
+  f_init_set_si(op, OP_);
+  z_init(rop);
+  z_set_f(rop, op);
+  assert(z_get_si(rop) = OP_);
+end;
+
+procedure TTestGmpExtensions.z_set_q_test;
+const OP_ = -10;
+var
+  op: MPRational;
+  rop: MPInteger;
+begin
+  q_init(op);
+  z_init(rop);
+  q_set_si(op, OP_, 1);
+  z_set_q(rop, op);
+  assert(z_get_si(rop) = OP_);
+end;
+
+procedure TTestGmpExtensions.z_set_si_test;
+const OP_ = -1000000;
+var rop: MPInteger;
+begin
+  z_init(rop);
+  z_set_si(rop, OP_);
+  assert(z_get_si(rop) = OP_);
+end;
+
+procedure TTestGmpExtensions.z_set_str_test;
+const OP_ = -1000000;
+var rop: MPInteger;
+begin
+  z_init(rop);
+  assert(z_set_str(rop, IntToStr(OP_), BASE10));
+  assert(z_get_si(rop) = OP_);
+end;
+
+procedure TTestGmpExtensions.z_set_ui_test;
+const OP_ = 1000000;
+var rop: MPInteger;
+begin
+  z_init(rop);
+  z_set_ui(rop, OP_);
+  assert(z_get_si(rop) = OP_);
+end;
+
+procedure TTestGmpExtensions.z_get_d_test;
+const N = -1000;
+var op: MPInteger;
+begin
+  z_init_set_si(op, N);
+  assert(z_get_d(op) = N);
+end;
+
+procedure TTestGmpExtensions.z_get_d_2exp_test;
+const
+  N_LG2 = 4;
+  N = 1 shl N_LG2;
+var
+  op: MPInteger;
+  exp: mp_exp_t;
+begin
+  z_init_set_si(op, N);
+  assert(z_get_d_2exp(exp, op) = 1 / 2);
+  assert(exp = N_LG2 + 1);
+end;
+
+procedure TTestGmpExtensions.z_get_si_test;
+const N = -1000000;
+var op: MPInteger;
+begin
+  z_init_set_si(op, N);
+  assert(z_get_si(op) = N);
+end;
+
+procedure TTestGmpExtensions.z_get_str_test;
+const N = -1000000;
+var
+  op: MPInteger;
+  p: pchar;
+  s, s0, s1: String;
+begin
+  z_init_set_si(op, N);
+  s0 := inttostr(N);
+  s := z_get_str(BASE10, op);
+  assert(s = s0);
+  p := z_get_str(nil, BASE10, op);
+  assert(p = s0);
+  freemem(p);
+  setlength(s1, length(s0));
+  assert(pointer(z_get_str(pchar(s1), BASE10, op)) = pointer(s1));
+  assert(s1 = s0);
+end;
+
+procedure TTestGmpExtensions.z_get_ui_test;
+const N = 1000000;
+var op: MPInteger;
+begin
+  z_init_set_ui(op, N);
+  assert(z_get_ui(op) = N);
+end;
+
+procedure TTestGmpExtensions.z_add_test;
+const
+  OP_1 = -1000;
+  OP_2 = 1000000;
+var rop, op1, op2, sum: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  z_add(rop, op1, op2);
+  assert(z_get_si(rop) = OP_1 + OP_2);
+  sum := z_add(op1, op2);
+  assert(z_get_si(sum) = OP_1 + OP_2);
+end;
+
+procedure TTestGmpExtensions.z_add_ui_test;
+const
+  OP_1 = -1000;
+  OP_2 = 1000000;
+var rop, op1, sum: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_add_ui(rop, op1, OP_2);
+  assert(z_get_si(rop) = OP_1 + OP_2);
+  sum := z_add_ui(op1, OP_2);
+  assert(z_get_si(sum) = OP_1 + OP_2);
+end;
+
+procedure TTestGmpExtensions.z_sub_test;
+const
+  OP_1 = -1000;
+  OP_2 = 1000000;
+var rop, op1, op2, diff: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  z_sub(rop, op1, op2);
+  assert(z_get_si(rop) = OP_1 - OP_2);
+  diff := z_sub(op1, op2);
+  assert(z_get_si(diff) = OP_1 - OP_2);
+end;
+
+procedure TTestGmpExtensions.z_sub_ui_test;
+const
+  OP_1 = -1000;
+  OP_2 = 1000000;
+var rop, op1, diff: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_sub_ui(rop, op1, OP_2);
+  assert(z_get_si(rop) = OP_1 - OP_2);
+  diff := z_sub_ui(op1, OP_2);
+  assert(z_get_si(diff) = OP_1 - OP_2);
+end;
+
+procedure TTestGmpExtensions.z_ui_sub_test;
+const
+  OP_1 = 1000;
+  OP_2 = 1000000;
+var rop, op2, diff: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op2, OP_2);
+  z_ui_sub(rop, OP_1, op2);
+  assert(z_get_si(rop) = OP_1 - OP_2);
+  diff := z_ui_sub(OP_1, op2);
+  assert(z_get_si(diff) = OP_1 - OP_2);
+end;
+
+procedure TTestGmpExtensions.z_mul_test;
+const
+  OP_1 = -10;
+  OP_2 = 1000;
+var rop, op1, op2, prod: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  z_mul(rop, op1, op2);
+  assert(z_get_si(rop) = OP_1 * OP_2);
+  prod := z_mul(op1, op2);
+  assert(z_get_si(prod) = OP_1 * OP_2);
+end;
+
+procedure TTestGmpExtensions.z_mul_si_test;
+const
+  OP_1 = 10;
+  OP_2 = -1000;
+var rop, op1, prod: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_mul_si(rop, op1, OP_2);
+  assert(z_get_si(rop) = OP_1 * OP_2);
+  prod := z_mul_si(op1, OP_2);
+  assert(z_get_si(prod) = OP_1 * OP_2);
+end;
+
+procedure TTestGmpExtensions.z_mul_ui_test;
+const
+  OP_1 = -10;
+  OP_2 = 1000;
+var rop, op1, prod: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_mul_ui(rop, op1, OP_2);
+  assert(z_get_si(rop) = OP_1 * OP_2);
+  prod := z_mul_ui(op1, OP_2);
+  assert(z_get_si(prod) = OP_1 * OP_2);
+end;
+
+procedure TTestGmpExtensions.z_addmul_test;
+const
+  ROP_ = 10;
+  OP_1 = -100;
+  OP_2 = 1000;
+var rop, op1, op2: MPInteger;
+begin
+  z_init_set_si(rop, ROP_);
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  z_addmul(rop, op1, op2);
+  assert(z_get_si(rop) = ROP_ + OP_1 * OP_2);
+end;
+
+procedure TTestGmpExtensions.z_addmul_ui_test;
+const
+  ROP_ = 10;
+  OP_1 = -100;
+  OP_2 = 1000;
+var rop, op1: MPInteger;
+begin
+  z_init_set_si(rop, ROP_);
+  z_init_set_si(op1, OP_1);
+  z_addmul_ui(rop, op1, OP_2);
+  assert(z_get_si(rop) = ROP_ + OP_1 * OP_2);
+end;
+
+procedure TTestGmpExtensions.z_submul_test;
+const
+  ROP_ = 10;
+  OP_1 = -100;
+  OP_2 = 1000;
+var rop, op1, op2: MPInteger;
+begin
+  z_init_set_si(rop, ROP_);
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  z_submul(rop, op1, op2);
+  assert(z_get_si(rop) = ROP_ - OP_1 * OP_2);
+end;
+
+procedure TTestGmpExtensions.z_submul_ui_test;
+const
+  ROP_ = 10;
+  OP_1 = -100;
+  OP_2 = 1000;
+var rop, op1: MPInteger;
+begin
+  z_init_set_si(rop, ROP_);
+  z_init_set_si(op1, OP_1);
+  z_submul_ui(rop, op1, OP_2);
+  assert(z_get_si(rop) = ROP_ - OP_1 * OP_2);
+end;
+
+procedure TTestGmpExtensions.z_mul_2exp_test;
+const
+  OP_1 = 10;
+  OP_2 = 10;
+var rop, op1, x: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_mul_2exp(rop, op1, OP_2);
+  assert(z_get_si(rop) = OP_1 * (1 shl OP_2));
+  x := z_mul_2exp(op1, OP_2);
+  assert(z_get_si(x) = OP_1 * (1 shl OP_2));
+end;
+
+procedure TTestGmpExtensions.z_neg_test;
+const OP_ = 1000;
+var rop, op, x: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op, OP_);
+  z_neg(rop, op);
+  assert(z_get_si(rop) = -OP_);
+  x := z_neg(op);
+  assert(z_get_si(x) = -OP_);
+end;
+
+procedure TTestGmpExtensions.z_abs_test;
+const OP_ = -1000;
+var rop, op, x: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op, OP_);
+  z_abs(rop, op);
+  assert(z_get_si(rop) = abs(OP_));
+  x := z_abs(op);
+  assert(z_get_si(x) = abs(OP_));
+end;
+
+procedure TTestGmpExtensions.z_cdiv_q_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, n, d, q2: MPInteger;
+begin
+  z_init(q);
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  z_cdiv_q(q, n, d);
+  assert(z_get_si(q) = ceil(N_ / D_));
+  q2 := z_cdiv_q(n, d);
+  assert(z_get_si(q2) = ceil(N_ / D_));
+end;
+
+procedure TTestGmpExtensions.z_fdiv_q_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, n, d, q2: MPInteger;
+begin
+  z_init(q);
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  z_fdiv_q(q, n, d);
+  assert(z_get_si(q) = floor(N_ / D_));
+  q2 := z_fdiv_q(n, d);
+  assert(z_get_si(q2) = floor(N_ / D_));
+end;
+
+procedure TTestGmpExtensions.z_tdiv_q_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, n, d, q2: MPInteger;
+begin
+  z_init(q);
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  z_tdiv_q(q, n, d);
+  assert(z_get_si(q) = trunc(N_ / D_));
+  q2 := z_tdiv_q(n, d);
+  assert(z_get_si(q2) = trunc(N_ / D_));
+end;
+
+procedure TTestGmpExtensions.z_cdiv_q_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var q, n, q2: MPInteger;
+begin
+  z_init(q);
+  z_init_set_si(n, N_);
+  z_cdiv_q_2exp(q, n, B_);
+  assert(z_get_si(q) = ceil(N_ / D_));
+  q2 := z_cdiv_q_2exp(n, B_);
+  assert(z_get_si(q2) = ceil(N_ / D_));
+end;
+
+procedure TTestGmpExtensions.z_fdiv_q_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var q, n, q2: MPInteger;
+begin
+  z_init(q);
+  z_init_set_si(n, N_);
+  z_fdiv_q_2exp(q, n, B_);
+  assert(z_get_si(q) = floor(N_ / D_));
+  q2 := z_fdiv_q_2exp(n, B_);
+  assert(z_get_si(q2) = floor(N_ / D_));
+end;
+
+procedure TTestGmpExtensions.z_tdiv_q_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var q, n, q2: MPInteger;
+begin
+  z_init(q);
+  z_init_set_si(n, N_);
+  z_tdiv_q_2exp(q, n, B_);
+  assert(z_get_si(q) = trunc(N_ / D_));
+  q2 := z_tdiv_q_2exp(n, B_);
+  assert(z_get_si(q2) = trunc(N_ / D_));
+end;
+
+procedure TTestGmpExtensions.z_cdiv_q_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, n: MPInteger;
+  ur: valuint;
+begin
+  z_init(q);
+  z_init_set_si(n, N_);
+  ur := z_cdiv_q_ui(q, n, D_);
+  assert(z_get_si(q) = ceil(N_ / D_));
+  assert(ur - abs(N_ - z_get_si(q) * D_) = 0);
+end;
+
+procedure TTestGmpExtensions.z_fdiv_q_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, n: MPInteger;
+  ur: valuint;
+begin
+  z_init(q);
+  z_init_set_si(n, N_);
+  ur := z_fdiv_q_ui(q, n, D_);
+  assert(z_get_si(q) = floor(N_ / D_));
+  assert(ur - abs(N_ - z_get_si(q) * D_) = 0);
+end;
+
+procedure TTestGmpExtensions.z_tdiv_q_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, n: MPInteger;
+  ur: valuint;
+begin
+  z_init(q);
+  z_init_set_si(n, N_);
+  ur := z_tdiv_q_ui(q, n, D_);
+  assert(z_get_si(q) = trunc(N_ / D_));
+  assert(ur - abs(N_ - z_get_si(q) * D_) = 0);
+end;
+
+procedure TTestGmpExtensions.z_cdiv_qr_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, r, n, d: MPInteger;
+begin
+  z_init(q);
+  z_init(r);
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  z_cdiv_qr(q, r, n, d);
+  assert(z_get_si(q) = ceil(N_ / D_));
+  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
+end;
+
+procedure TTestGmpExtensions.z_fdiv_qr_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, r, n, d: MPInteger;
+begin
+  z_init(q);
+  z_init(r);
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  z_fdiv_qr(q, r, n, d);
+  assert(z_get_si(q) = floor(N_ / D_));
+  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
+end;
+
+procedure TTestGmpExtensions.z_tdiv_qr_test;
+const
+  N_ = -17;
+  D_ = 4;
+var q, r, n, d: MPInteger;
+begin
+  z_init(q);
+  z_init(r);
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  z_tdiv_qr(q, r, n, d);
+  assert(z_get_si(q) = trunc(N_ / D_));
+  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
+end;
+
+procedure TTestGmpExtensions.z_cdiv_qr_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, r, n: MPInteger;
+  ur: valuint;
+begin
+  z_init(q);
+  z_init(r);
+  z_init_set_si(n, N_);
+  ur := z_cdiv_qr_ui(q, r, n, D_);
+  assert(z_get_si(q) = ceil(N_ / D_));
+  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
+  assert(ur - abs(z_get_si(r)) = 0);
+end;
+
+procedure TTestGmpExtensions.z_fdiv_qr_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, r, n: MPInteger;
+  ur: valuint;
+begin
+  z_init(q);
+  z_init(r);
+  z_init_set_si(n, N_);
+  ur := z_fdiv_qr_ui(q, r, n, D_);
+  assert(z_get_si(q) = floor(N_ / D_));
+  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
+  assert(ur - abs(z_get_si(r)) = 0);
+end;
+
+procedure TTestGmpExtensions.z_tdiv_qr_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  q, r, n: MPInteger;
+  ur: valuint;
+begin
+  z_init(q);
+  z_init(r);
+  z_init_set_si(n, N_);
+  ur := z_tdiv_qr_ui(q, r, n, D_);
+  assert(z_get_si(q) = trunc(N_ / D_));
+  assert(z_get_si(q) * D_ + z_get_si(r) = N_);
+  assert(ur - abs(z_get_si(r)) = 0);
+end;
+
+procedure TTestGmpExtensions.z_cdiv_r_test;
+const
+  N_ = -17;
+  D_ = 4;
+var r, n, d, r2: MPInteger;
+begin
+  z_init(r);
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  z_cdiv_r(r, n, d);
+  assert(ceil(N_ / D_) * D_ + z_get_si(r) = N_);
+  r2 := z_cdiv_r(n, d);
+  assert(ceil(N_ / D_) * D_ + z_get_si(r2) = N_);
+end;
+
+procedure TTestGmpExtensions.z_fdiv_r_test;
+const
+  N_ = -17;
+  D_ = 4;
+var r, n, d, r2: MPInteger;
+begin
+  z_init(r);
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  z_fdiv_r(r, n, d);
+  assert(floor(N_ / D_) * D_ + z_get_si(r) = N_);
+  r2 := z_fdiv_r(n, d);
+  assert(floor(N_ / D_) * D_ + z_get_si(r2) = N_);
+end;
+
+procedure TTestGmpExtensions.z_tdiv_r_test;
+const
+  N_ = -17;
+  D_ = 4;
+var r, n, d, r2: MPInteger;
+begin
+  z_init(r);
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  z_tdiv_r(r, n, d);
+  assert(trunc(N_ / D_) * D_ + z_get_si(r) = N_);
+  r2 := z_tdiv_r(n, d);
+  assert(trunc(N_ / D_) * D_ + z_get_si(r2) = N_);
+end;
+
+procedure TTestGmpExtensions.z_cdiv_r_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var r, n, r2: MPInteger;
+begin
+  z_init(r);
+  z_init_set_si(n, N_);
+  z_cdiv_r_2exp(r, n, B_);
+  assert(ceil(N_ / D_) * D_ + z_get_si(r) = N_);
+  r2 := z_cdiv_r_2exp(n, B_);
+  assert(ceil(N_ / D_) * D_ + z_get_si(r2) = N_);
+end;
+
+procedure TTestGmpExtensions.z_fdiv_r_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var r, n, r2: MPInteger;
+begin
+  z_init(r);
+  z_init_set_si(n, N_);
+  z_fdiv_r_2exp(r, n, B_);
+  assert(floor(N_ / D_) * D_ + z_get_si(r) = N_);
+  r2 := z_fdiv_r_2exp(n, B_);
+  assert(floor(N_ / D_) * D_ + z_get_si(r2) = N_);
+end;
+
+procedure TTestGmpExtensions.z_tdiv_r_2exp_test;
+const
+  N_ = -17;
+  B_ = 2;
+  D_ = 1 shl B_;
+var r, n, r2: MPInteger;
+begin
+  z_init(r);
+  z_init_set_si(n, N_);
+  z_tdiv_r_2exp(r, n, B_);
+  assert(trunc(N_ / D_) * D_ + z_get_si(r) = N_);
+  r2 := z_tdiv_r_2exp(n, B_);
+  assert(trunc(N_ / D_) * D_ + z_get_si(r2) = N_);
+end;
+
+procedure TTestGmpExtensions.z_cdiv_r_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  r, n: MPInteger;
+  ur: valuint;
+begin
+  z_init(r);
+  z_init_set_si(n, N_);
+  ur := z_cdiv_r_ui(r, n, D_);
+  assert(ceil(N_ / D_) * D_ + z_get_si(r) = N_);
+  assert(ur - abs(z_get_si(r)) = 0);
+end;
+
+procedure TTestGmpExtensions.z_fdiv_r_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  r, n: MPInteger;
+  ur: valuint;
+begin
+  z_init(r);
+  z_init_set_si(n, N_);
+  ur := z_fdiv_r_ui(r, n, D_);
+  assert(floor(N_ / D_) * D_ + z_get_si(r) = N_);
+  assert(ur - abs(z_get_si(r)) = 0);
+end;
+
+procedure TTestGmpExtensions.z_tdiv_r_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var
+  r, n: MPInteger;
+  ur: valuint;
+begin
+  z_init(r);
+  z_init_set_si(n, N_);
+  ur := z_tdiv_r_ui(r, n, D_);
+  assert(trunc(N_ / D_) * D_ + z_get_si(r) = N_);
+  assert(ur - abs(z_get_si(r)) = 0);
+end;
+
+procedure TTestGmpExtensions.z_cdiv_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var n: MPInteger;
+begin
+  z_init_set_si(n, N_);
+  assert(z_cdiv_ui(n, D_) - abs(N_ - ceil(N_ / D_) * D_) = 0);
+end;
+
+procedure TTestGmpExtensions.z_fdiv_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var n: MPInteger;
+begin
+  z_init_set_si(n, N_);
+  assert(z_fdiv_ui(n, D_) - abs(N_ - floor(N_ / D_) * D_) = 0);
+end;
+
+procedure TTestGmpExtensions.z_tdiv_ui_test;
+const
+  N_ = -17;
+  D_ = 4;
+var n: MPInteger;
+begin
+  z_init_set_si(n, N_);
+  assert(z_tdiv_ui(n, D_) = abs(N_ - trunc(N_ / D_) * D_));
+end;
+
+procedure TTestGmpExtensions.z_mod_test;
+const
+  N_ = 17;
+  D_ = -4;
+var r, n, d, r2: MPInteger;
+begin
+  z_init(r);
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  z_mod(r, n, d);
+  assert(z_get_si(r) = N_ mod abs(D_));
+  r2 := z_mod(n, d);
+  assert(z_get_si(r2) = N_ mod abs(D_));
+end;
+
+procedure TTestGmpExtensions.z_divexact_test;
+const
+  N_ = -16;
+  D_ = 4;
+var q, n, d, q2: MPInteger;
+begin
+  z_init(q);
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  z_divexact(q, n, d);
+  assert(z_get_si(q) * D_ = N_);
+  q2 := z_divexact(n, d);
+  assert(z_get_si(q2) * D_ = N_);
+end;
+
+procedure TTestGmpExtensions.z_divexact_ui_test;
+const
+  N_ = -16;
+  D_ = 4;
+var q, n, q2: MPInteger;
+begin
+  z_init(q);
+  z_init_set_si(n, N_);
+  z_divexact_ui(q, n, D_);
+  assert(z_get_si(q) * D_ = N_);
+  q2 := z_divexact_ui(n, D_);
+  assert(z_get_si(q2) * D_ = N_);
+end;
+
+procedure TTestGmpExtensions.z_divisible_p_test;
+const
+  N_ = -16;
+  D_ = 4;
+var n, d: MPInteger;
+begin
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  assert(z_divisible_p(n, d));
+  z_set_si(n, z_get_si(n) + 1);
+  assert(not z_divisible_p(n, d));
+end;
+
+procedure TTestGmpExtensions.z_divisible_ui_p_test;
+const
+  N_ = -16;
+  D_ = 4;
+var n: MPInteger;
+begin
+  z_init_set_si(n, N_);
+  assert(z_divisible_ui_p(n, D_));
+  z_set_si(n, z_get_si(n) + 1);
+  assert(not z_divisible_ui_p(n, D_));
+end;
+
+procedure TTestGmpExtensions.z_divisible_2exp_p_test;
+const
+  N_ = -16;
+  B_ = 2;
+var n: MPInteger;
+begin
+  z_init_set_si(n, N_);
+  assert(z_divisible_2exp_p(n, B_));
+  z_set_si(n, z_get_si(n) + 1);
+  assert(not z_divisible_ui_p(n, B_));
+end;
+
+procedure TTestGmpExtensions.z_congruent_p_test;
+const
+  N_ = 23;
+  C_ = 6;
+  D_ = 17;
+var n, c, d: MPInteger;
+begin
+  z_init_set_si(n, N_);
+  z_init_set_si(c, C_);
+  z_init_set_si(d, D_);
+  assert(z_congruent_p(n, c, d));
+  z_set_si(n, z_get_si(n) + 1);
+  assert(not z_congruent_p(n, c, d));
+end;
+
+procedure TTestGmpExtensions.z_congruent_2exp_p_test;
+const
+  N_ = 23;
+  C_ = 7;
+  B_ = 4;
+var n, c: MPInteger;
+begin
+  z_init_set_si(n, N_);
+  z_init_set_si(c, C_);
+  assert(z_congruent_2exp_p(n, c, B_));
+  z_set_si(n, z_get_si(n) + 1);
+  assert(not z_congruent_2exp_p(n, c, B_));
+end;
+
+procedure TTestGmpExtensions.z_congruent_ui_p_test;
+const
+  N_ = 23;
+  C_ = 6;
+  D_ = 17;
+var n: MPInteger;
+begin
+  z_init_set_si(n, N_);
+  assert(z_congruent_ui_p(n, C_, D_));
+  z_set_si(n, z_get_si(n) + 1);
+  assert(not z_congruent_ui_p(n, C_, D_));
+end;
+
+procedure TTestGmpExtensions.z_powm_test;
+const
+  N_EXP = 3;
+  N_MOD = 16;
+  ROP_ = 8;
+var rop, base, exp, mod_, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(base, BASE10);
+  z_init_set_si(exp, N_EXP);
+  z_init_set_si(mod_, N_MOD);
+  z_powm(rop, base, exp, mod_);
+  assert(z_get_si(rop) = ROP_);
+  r2 := z_powm(base, exp, mod_);
+  assert(z_get_si(r2) = ROP_);
+end;
+
+procedure TTestGmpExtensions.z_powm_ui_test;
+const
+  N_EXP = 3;
+  N_MOD = 16;
+  ROP_ = 8;
+var rop, base, mod_, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(base, BASE10);
+  z_init_set_si(mod_, N_MOD);
+  z_powm_ui(rop, base, N_EXP, mod_);
+  assert(z_get_si(rop) = ROP_);
+  r2 := z_powm_ui(base, N_EXP, mod_);
+  assert(z_get_si(r2) = ROP_);
+end;
+
+procedure TTestGmpExtensions.z_pow_ui_test;
+const
+  BASE_ = 10;
+  EXP = 3;
+var rop, base, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(base, BASE_);
+  z_pow_ui(rop, base, EXP);
+  assert(z_get_si(rop) = BASE_ ** EXP);
+  r2 := z_pow_ui(base, EXP);
+  assert(z_get_si(r2) = BASE_ ** EXP);
+end;
+
+procedure TTestGmpExtensions.z_ui_pow_ui_test;
+const
+  BASE_ = 10;
+  EXP = 3;
+var rop, r2: MPInteger;
+begin
+  z_init(rop);
+  z_ui_pow_ui(rop, BASE_, EXP);
+  assert(z_get_si(rop) = BASE_ ** EXP);
+  r2 := z_ui_pow_ui(BASE_, EXP);
+  assert(z_get_si(r2) = BASE_ ** EXP);
+end;
+
+procedure TTestGmpExtensions.z_root_test;
+const
+  ROOT = 5;
+  N_ = 3;
+var rop, op: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op, ROOT ** N_);
+  assert(z_root(rop, op, N_));
+  assert(z_get_si(rop) = ROOT);
+  z_set_si(op, ROOT ** N_ + 1);
+  assert(not z_root(rop, op, N_));
+  assert(z_get_si(rop) = ROOT);
+end;
+
+procedure TTestGmpExtensions.z_rootrem_test;
+const
+  ROOT_ = 5;
+  N_ = 3;
+  REM_ = 1;
+var root, rem, u: MPInteger;
+begin
+  assert(REM_ < ROOT_);
+  z_init(root);
+  z_init(rem);
+  z_init_set_si(u, ROOT_ ** N_);
+  z_rootrem(root, rem, u, N_);
+  assert(z_get_si(root) = ROOT_);
+  assert(z_get_si(rem) = 0);
+  z_set_si(u, ROOT_ ** N_ + REM_);
+  z_rootrem(root, rem, u, N_);
+  assert(z_get_si(root) = ROOT_);
+  assert(z_get_si(rem) = REM_);
+end;
+
+procedure TTestGmpExtensions.z_sqrt_test;
+const ROOT = 5;
+var rop, op, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op, ROOT ** 2);
+  z_sqrt(rop, op);
+  assert(z_get_si(rop) = ROOT);
+  r2 := z_sqrt(op);
+  assert(z_get_si(r2) = ROOT);
+end;
+
+procedure TTestGmpExtensions.z_sqrtrem_test;
+const
+  ROOT = 5;
+  REM = 1;
+var rop1, rop2, op: MPInteger;
+begin
+  z_init(rop1);
+  z_init(rop2);
+  z_init_set_si(op, ROOT ** 2 + REM);
+  z_sqrtrem(rop1, rop2, op);
+  assert(z_get_si(rop1) = ROOT);
+  assert(z_get_si(rop2) = REM);
+end;
+
+procedure TTestGmpExtensions.z_perfect_power_p_test;
+const
+  ROOT = 3;
+  EXP = 3;
+var op: MPInteger;
+begin
+  z_init_set_si(op, ROOT ** EXP);
+  assert(z_perfect_power_p(op));
+  z_set_si(op, ROOT ** EXP + 1);
+  assert(not z_perfect_power_p(op));
+end;
+
+procedure TTestGmpExtensions.z_perfect_square_p_test;
+const ROOT = 3;
+var op: MPInteger;
+begin
+  z_init_set_si(op, ROOT ** 2);
+  assert(z_perfect_square_p(op));
+  z_set_si(op, ROOT ** 2 or 2);
+  assert(not z_perfect_square_p(op));
+end;
+
+procedure TTestGmpExtensions.z_probab_prime_p_test;
+const
+  N_ = 127;
+  REPS = 5;
+var n: MPInteger;
+begin
+  z_init_set_si(n, N_);
+  assert(z_probab_prime_p(n, REPS) = 2);
+  z_set_si(n, N_ + 1);
+  assert(z_probab_prime_p(n, REPS) = 0);
+end;
+
+procedure TTestGmpExtensions.z_nextprime_test;
+const
+  PRIME3 = 5;
+  PRIME4 = 7;
+var rop, op, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op, PRIME3);
+  z_nextprime(rop, op);
+  assert(z_get_si(rop) = PRIME4);
+  r2 := z_nextprime(op);
+  assert(z_get_si(r2) = PRIME4);
+end;
+
+procedure TTestGmpExtensions.z_gcd_test;
+const
+  OP_1 = 42;
+  OP_2 = 56;
+  ROP_ = 14;
+var rop, op1, op2, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  z_gcd(rop, op1, op2);
+  assert(z_get_si(rop) = ROP_);
+  r2 := z_gcd(op1, op2);
+  assert(z_get_si(r2) = ROP_);
+end;
+
+procedure TTestGmpExtensions.z_gcd_ui_test;
+const
+  OP_1 = 42;
+  OP_2 = 56;
+  ROP_ = 14;
+var rop, op1: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  assert(z_gcd_ui(rop, op1, OP_2) = ROP_);
+  assert(z_get_si(rop) = ROP_);
+end;
+
+procedure TTestGmpExtensions.z_gcdext_test;
+const
+  A_ = 42;
+  B_ = 56;
+  G_ = 14;
+var g, s, t, a, b: MPInteger;
+begin
+  z_init(g);
+  z_init(s);
+  z_init(t);
+  z_init_set_si(a, A_);
+  z_init_set_si(b, B_);
+  z_gcdext(g, s, t, a, b);
+  assert(z_get_si(g) = G_);
+  assert(A_ * z_get_si(s) + B_ * z_get_si(t) = G_);
+end;
+
+procedure TTestGmpExtensions.z_lcm_test;
+const
+  OP_1 = 21;
+  OP_2 = 6;
+  ROP_ = 42;
+var rop, op1, op2, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  z_lcm(rop, op1, op2);
+  assert(z_get_si(rop) = ROP_);
+  r2 := z_lcm(op1, op2);
+  assert(z_get_si(r2) = ROP_);
+end;
+
+procedure TTestGmpExtensions.z_lcm_ui_test;
+const
+  OP_1 = 21;
+  OP_2 = 6;
+  ROP_ = 42;
+var rop, op1, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_lcm_ui(rop, op1, OP_2);
+  assert(z_get_si(rop) = ROP_);
+  r2 := z_lcm_ui(op1, OP_2);
+  assert(z_get_si(r2) = ROP_);
+end;
+
+procedure TTestGmpExtensions.z_invert_test;
+const
+  OP_1 = 256;
+  OP_2 = 337;
+  ROP_ = 104;
+var rop, op1, op2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  assert(z_invert(rop, op1, op2) <> 0);
+  assert(z_get_si(rop) = ROP_);
+end;
+
+procedure TTestGmpExtensions.z_jacobi_test;
+const
+  B0 = 11;
+  A0 = 13 * B0;
+  AM1 = 1001;
+  BM1 = 9907;
+  A1 = 4;
+  B1 = 7;
+var a, b: MPInteger;
+begin
+  z_init_set_si(a, A0);
+  z_init_set_si(b, B0);
+  assert(z_jacobi(a, b) = 0);
+  z_set_si(a, AM1);
+  z_set_si(b, BM1);
+  assert(z_jacobi(a, b) = -1);
+  z_set_si(a, A1);
+  z_set_si(b, B1);
+  assert(z_jacobi(a, b) = 1);
+end;
+
+procedure TTestGmpExtensions.z_kronecker_si_test;
+const
+  A_ = 8;
+  B0 = 6;
+  BM1 = 5;
+  B1 = 7;
+var a: MPInteger;
+begin
+  z_init_set_si(a, A_);
+  assert(z_kronecker_si(a, B1) = 1);
+  assert(z_kronecker_si(a, B0) = 0);
+  assert(z_kronecker_si(a, BM1) = -1);
+end;
+
+procedure TTestGmpExtensions.z_kronecker_ui_test;
+const
+  A_ = 8;
+  B0 = 6;
+  BM1 = 5;
+  B1 = 7;
+var a: MPInteger;
+begin
+  z_init_set_si(a, A_);
+  assert(z_kronecker_ui(a, B1) = 1);
+  assert(z_kronecker_ui(a, B0) = 0);
+  assert(z_kronecker_ui(a, BM1) = -1);
+end;
+
+procedure TTestGmpExtensions.z_si_kronecker_test;
+const
+  A_ = 8;
+  B0 = 6;
+  BM1 = 5;
+  B1 = 7;
+var b: MPInteger;
+begin
+  z_init_set_si(b, B1);
+  assert(z_si_kronecker(A_, b) = 1);
+  z_set_si(b, B0);
+  assert(z_si_kronecker(A_, b) = 0);
+  z_set_si(b, BM1);
+  assert(z_si_kronecker(A_, b) = -1);
+end;
+
+procedure TTestGmpExtensions.z_ui_kronecker_test;
+const
+  A_ = 8;
+  B0 = 6;
+  BM1 = 5;
+  B1 = 7;
+var b: MPInteger;
+begin
+  z_init_set_si(b, B1);
+  assert(z_ui_kronecker(A_, b) = 1);
+  z_set_si(b, B0);
+  assert(z_ui_kronecker(A_, b) = 0);
+  z_set_si(b, BM1);
+  assert(z_ui_kronecker(A_, b) = -1);
+end;
+
+procedure TTestGmpExtensions.z_remove_test;
+const
+  F_ = 5;
+  OP_ = 3 * F_ * 7;
+  ROP_ = OP_ div F_;
+var rop, op, f: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op, OP_);
+  z_init_set_si(f, F_);
+  assert(z_remove(rop, op, f) = 1);
+  assert(z_get_si(rop) = ROP_);
+end;
+
+procedure TTestGmpExtensions.z_fac_ui_test;
+const
+  OP = 4;
+  ROP_ = 2 * 3 * 4;
+var rop, r2: MPInteger;
+begin
+  z_init(rop);
+  z_fac_ui(rop, OP);
+  assert(z_get_si(rop) = ROP_);
+  r2 := z_fac_ui(OP);
+  assert(z_get_si(r2) = ROP_);
+end;
+
+procedure TTestGmpExtensions.z_bin_ui_test;
+const
+  N_ = 7;
+  K = 3;
+  ROP_ = 35;
+var rop, n, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(n, N_);
+  z_bin_ui(rop, n, K);
+  assert(z_get_si(rop) = ROP_);
+  r2 := z_bin_ui(n, K);
+  assert(z_get_si(r2) = ROP_);
+end;
+
+procedure TTestGmpExtensions.z_bin_uiui_test;
+const
+  N = 7;
+  K = 3;
+  ROP_ = 35;
+var rop, r2: MPInteger;
+begin
+  z_init(rop);
+  z_bin_uiui(rop, N, K);
+  assert(z_get_si(rop) = ROP_);
+  r2 := z_bin_uiui(N, K);
+  assert(z_get_si(r2) = ROP_);
+end;
+
+procedure TTestGmpExtensions.z_fib_ui_test;
+const
+  N = 10;
+  FN_ = 55;
+var fn, ff: MPInteger;
+begin
+  z_init(fn);
+  z_fib_ui(fn, N);
+  assert(z_get_si(fn) = FN_);
+  ff := z_fib_ui(N);
+  assert(z_get_si(ff) = FN_);
+end;
+
+procedure TTestGmpExtensions.z_fib2_ui_test;
+const
+  N = 10;
+  FN_ = 55;
+  FNSUB1_ = 34;
+var fn, fnsub1, ff, ff1: MPInteger;
+begin
+  z_init(fn);
+  z_init(fnsub1);
+  z_fib2_ui(fn, fnsub1, N);
+  assert(z_get_si(fn) = FN_);
+  assert(z_get_si(fnsub1) = FNSUB1_);
+  z_init(ff1);
+  ff := z_fib2_ui(ff1, N);
+  assert(z_get_si(ff) = FN_);
+  assert(z_get_si(ff1) = FNSUB1_);
+end;
+
+procedure TTestGmpExtensions.z_lucnum_ui_test;
+const
+  N = 10;
+  LN_ = 123;
+var ln, l2: MPInteger;
+begin
+  z_init(ln);
+  z_lucnum_ui(ln, N);
+  assert(z_get_si(ln) = LN_);
+  l2 := z_lucnum_ui(N);
+  assert(z_get_si(l2) = LN_);
+end;
+
+procedure TTestGmpExtensions.z_lucnum2_ui_test;
+const
+  N = 10;
+  LN_ = 123;
+  LNSUB1_ = 76;
+var ln, lnsub1, l2, l2s1: MPInteger;
+begin
+  z_init(ln);
+  z_init(lnsub1);
+  z_lucnum2_ui(ln, lnsub1, N);
+  assert(z_get_si(ln) = LN_);
+  assert(z_get_si(lnsub1) = LNSUB1_);
+  z_init(l2s1);
+  l2 := z_lucnum2_ui(l2s1, N);
+  assert(z_get_si(l2) = LN_);
+  assert(z_get_si(l2s1) = LNSUB1_);
+end;
+
+procedure TTestGmpExtensions.z_cmp_test;
+const
+  OP_1 = -10;
+  OP_2 = OP_1 - 1;
+var op1, op2: MPInteger;
+begin
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  assert(z_cmp(op1, op2) > 0);
+  z_set_si(op2, OP_1);
+  assert(z_cmp(op1, op2) = 0);
+  z_set_si(op2, OP_1 + 1);
+  assert(z_cmp(op1, op2) < 0);
+end;
+
+procedure TTestGmpExtensions.z_cmp_d_test;
+const
+  OP_1 = -10;
+var op1: MPInteger;
+begin
+  z_init_set_si(op1, OP_1);
+  assert(z_cmp_d(op1, OP_1 - 1) > 0);
+  assert(z_cmp_d(op1, OP_1) = 0);
+  assert(z_cmp_d(op1, OP_1 + 1) < 0);
+end;
+
+procedure TTestGmpExtensions.z_cmp_si_test;
+const
+  OP_1 = -10;
+var op1: MPInteger;
+begin
+  z_init_set_si(op1, OP_1);
+  assert(z_cmp_si(op1, OP_1 - 1) > 0);
+  assert(z_cmp_si(op1, OP_1) = 0);
+  assert(z_cmp_si(op1, OP_1 + 1) < 0);
+end;
+
+procedure TTestGmpExtensions.z_cmp_ui_test;
+const
+  OP_1 = 10;
+var op1: MPInteger;
+begin
+  z_init_set_si(op1, OP_1);
+  assert(z_cmp_ui(op1, OP_1 - 1) > 0);
+  assert(z_cmp_ui(op1, OP_1) = 0);
+  assert(z_cmp_ui(op1, OP_1 + 1) < 0);
+end;
+
+procedure TTestGmpExtensions.z_cmpabs_test;
+const
+  OP_1 = -10;
+  OP_2 = -OP_1 - 1;
+var op1, op2: MPInteger;
+begin
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, -OP_2);
+  assert(z_cmpabs(op1, op2) > 0);
+  z_set_si(op2, -OP_1);
+  assert(z_cmpabs(op1, op2) = 0);
+  z_set_si(op2, -OP_1 + 1);
+  assert(z_cmpabs(op1, op2) < 0);
+end;
+
+procedure TTestGmpExtensions.z_cmpabs_d_test;
+const OP_1 = -10;
+var op1: MPInteger;
+begin
+  z_init_set_si(op1, OP_1);
+  assert(z_cmpabs_d(op1, -OP_1 - 1) > 0);
+  assert(z_cmpabs_d(op1, -OP_1) = 0);
+  assert(z_cmpabs_d(op1, -OP_1 + 1) < 0);
+end;
+
+procedure TTestGmpExtensions.z_cmpabs_ui_test;
+const OP_1 = -10;
+var op1: MPInteger;
+begin
+  z_init_set_si(op1, OP_1);
+  assert(z_cmpabs_ui(op1, -OP_1 - 1) > 0);
+  assert(z_cmpabs_ui(op1, -OP_1) = 0);
+  assert(z_cmpabs_ui(op1, -OP_1 + 1) < 0);
+end;
+
+procedure TTestGmpExtensions.z_and_test;
+const
+  OP_1 = $c;
+  OP_2 = $a;
+var rop, op1, op2, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  z_and(rop, op1, op2);
+  assert(z_get_si(rop) = OP_1 and OP_2);
+  r2 := z_and(op1, op2);
+  assert(z_get_si(r2) = OP_1 and OP_2);
+end;
+
+procedure TTestGmpExtensions.z_ior_test;
+const
+  OP_1 = $c;
+  OP_2 = $a;
+var rop, op1, op2, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  z_ior(rop, op1, op2);
+  assert(z_get_si(rop) = OP_1 or OP_2);
+  r2 := z_ior(op1, op2);
+  assert(z_get_si(r2) = OP_1 or OP_2);
+end;
+
+procedure TTestGmpExtensions.z_xor_test;
+const
+  OP_1 = $c;
+  OP_2 = $a;
+var rop, op1, op2, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  z_xor(rop, op1, op2);
+  assert(z_get_si(rop) = OP_1 xor OP_2);
+  r2 := z_xor(op1, op2);
+  assert(z_get_si(r2) = OP_1 xor OP_2);
+end;
+
+procedure TTestGmpExtensions.z_com_test;
+const
+  OP_1 = 2;
+var rop, op1, r2: MPInteger;
+begin
+  z_init(rop);
+  z_init_set_si(op1, OP_1);
+  z_com(rop, op1);
+  assert(z_get_si(rop) = not OP_1 );
+  r2 := z_com(op1);
+  assert(z_get_si(r2) = not OP_1 );
+end;
+
+procedure TTestGmpExtensions.z_popcount_test;
+const
+  OP_ = $55AA;
+  N = 8;
+var op: MPInteger;
+begin
+  z_init_set_si(op, OP_);
+  assert(z_popcount(op) = N);
+end;
+
+procedure TTestGmpExtensions.z_hamdist_test;
+const
+  OP_1 = $55;
+  OP_2 = $7A;
+  N = 5;
+var op1, op2: MPInteger;
+begin
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  assert(z_hamdist(op1, op2) = N);
+end;
+
+procedure TTestGmpExtensions.z_scan0_test;
+const
+  OP_ = $F75;
+  STARTING_BIT = 4;
+  N = 7;
+var op: MPInteger;
+begin
+  z_init_set_si(op, OP_);
+  assert(z_scan0(op, STARTING_BIT) = N);
+end;
+
+procedure TTestGmpExtensions.z_scan1_test;
+const
+  OP_ = $85;
+  STARTING_BIT = 4;
+  N = 7;
+var op: MPInteger;
+begin
+  z_init_set_si(op, OP_);
+  assert(z_scan1(op, STARTING_BIT) = N);
+end;
+
+procedure TTestGmpExtensions.z_setbit_test;
+const
+  ROP_ = $F75;
+  BIT_INDEX = 7;
+var rop: MPInteger;
+begin
+  z_init_set_ui(rop, ROP_);
+  z_setbit(rop, BIT_INDEX);
+  assert(z_get_ui(rop) = ROP_ or (1 shl BIT_INDEX));
+end;
+
+procedure TTestGmpExtensions.z_clrbit_test;
+const
+  ROP_ = $F75;
+  BIT_INDEX = 9;
+var rop: MPInteger;
+begin
+  z_init_set_ui(rop, ROP_);
+  z_clrbit(rop, BIT_INDEX);
+  assert(z_get_ui(rop) = ROP_ and not (1 shl BIT_INDEX));
+end;
+
+procedure TTestGmpExtensions.z_combit_test;
+const
+  ROP_ = $F75;
+  BIT_INDEX = 7;
+var rop: MPInteger;
+begin
+  z_init_set_ui(rop, ROP_);
+  z_combit(rop, BIT_INDEX);
+  assert(z_get_ui(rop) = ROP_ xor (1 shl BIT_INDEX));
+end;
+
+procedure TTestGmpExtensions.z_tstbit_test;
+const
+  ROP_ = $F75;
+  BIT_INDEX1 = 7;
+  BIT_INDEX2 = 8;
+var rop: MPInteger;
+begin
+  z_init_set_ui(rop, ROP_);
+  assert(z_tstbit(rop, BIT_INDEX1) = longbool(ROP_ and (1 shl BIT_INDEX1)));
+  assert(z_tstbit(rop, BIT_INDEX2) = longbool(ROP_ and (1 shl BIT_INDEX2)));
+end;
+
+procedure TTestGmpExtensions.z_urandomb_test;
+const
+  B = 8 * (sizeof(valuint) - 1);
+  N = 1 shl B;
+var
+  rop, r2: MPInteger;
+  state: MPRandState;
+begin
+  randinit_default(state);
+  z_init(rop);
+  z_urandomb(rop, state, B);
+  assert(z_cmp_ui(rop, N) < 0);
+  r2 := z_urandomb(state, B);
+  assert(z_cmp_ui(r2, N) < 0);
+end;
+
+procedure TTestGmpExtensions.z_urandomm_test;
+const
+  N_ = 1000000;
+var
+  rop, n, r2: MPInteger;
+  state: MPRandState;
+begin
+  randinit_default(state);
+  z_init(rop);
+  z_init_set_ui(n, N_);
+  z_urandomm(rop, state, n);
+  assert(z_cmp_ui(rop, N_) < 0);
+  r2 := z_urandomm(state, n);
+  assert(z_cmp_ui(r2, N_) < 0);
+end;
+
+procedure TTestGmpExtensions.z_rrandomb_test;
+const
+  B = 8 * sizeof(valuint) - 2;
+  N = 1 shl B;
+var
+  rop, r2: MPInteger;
+  state: MPRandState;
+begin
+  randinit_default(state);
+  z_init(rop);
+  z_rrandomb(rop, state, B);
+  assert(z_cmp_ui(rop, N) < 0);
+  r2 := z_rrandomb(state, B);
+  assert(z_cmp_ui(r2, N) < 0);
+end;
+
+procedure TTestGmpExtensions.z_fits_ushort_p_test;
+var op: MPInteger;
+begin
+  z_init_set_ui(op, high(word));
+  assert(z_fits_ushort_p(op));
+  z_add_ui(op, op, 1);
+  assert(not z_fits_ushort_p(op));
+end;
+
+procedure TTestGmpExtensions.z_fits_sshort_p_test;
+var op: MPInteger;
+begin
+  z_init_set_si(op, high(smallint));
+  assert(z_fits_sshort_p(op));
+  z_add_ui(op, op, 1);
+  assert(not z_fits_sshort_p(op));
+end;
+
+procedure TTestGmpExtensions.z_fits_uint_p_test;
+var op: MPInteger;
+begin
+  z_init_set_ui(op, high(cardinal));
+  assert(z_fits_uint_p(op));
+  z_add_ui(op, op, 1);
+  assert(not z_fits_uint_p(op));
+end;
+
+procedure TTestGmpExtensions.z_fits_sint_p_test;
+var op: MPInteger;
+begin
+  z_init_set_si(op, high(integer));
+  assert(z_fits_sint_p(op));
+  z_add_ui(op, op, 1);
+  assert(not z_fits_sint_p(op));
+end;
+
+procedure TTestGmpExtensions.z_fits_ulong_p_test;
+var op: MPInteger;
+begin
+  z_init_set_ui(op, high(valuint));
+  assert(z_fits_ulong_p(op));
+  z_add_ui(op, op, 1);
+  assert(not z_fits_ulong_p(op));
+end;
+
+procedure TTestGmpExtensions.z_fits_slong_p_test;
+var op: MPInteger;
+begin
+  z_init_set_si(op, high(valsint));
+  assert(z_fits_slong_p(op));
+  z_add_ui(op, op, 1);
+  assert(not z_fits_slong_p(op));
+end;
+
+procedure TTestGmpExtensions.z_sizeinbase_test;
+const
+  OP_ = 1000000;
+var rop: MPInteger;
+begin
+  z_init_set_ui(rop, OP_);
+  assert(z_sizeinbase(rop, BASE10) - length(inttostr(OP_)) = 0);
+end;
+
+procedure TTestGmpExtensions.z_size_test;
+var rop: MPInteger;
+begin
+  z_init(rop);
+  assert(z_size(rop) = 0);
+  z_add_ui(rop, rop, 1);
+  assert(z_size(rop) = 1);
+end;
+
+procedure TTestGmpExtensions.q_init_test;
+var rational: MPRational;
+begin
+  q_init(rational);
+  assert(q_cmp_ui(rational, 0, 1) = 0);
+end;
+
+procedure TTestGmpExtensions.q_clear_test;
+var rational: MPRational;
+begin
+  q_init(rational);
+  q_clear(rational);
+end;
+
+procedure TTestGmpExtensions.q_set_ui_test;
+const
+  OP_1 = 13;
+  OP_2 = 17;
+var rational: MPRational;
+begin
+  q_init(rational);
+  q_set_ui(rational, OP_1, OP_2);
+  assert(q_cmp_ui(rational, OP_1, OP_2) = 0);
+end;
+
+procedure TTestGmpExtensions.q_set_si_test;
+const
+  OP_1 = -13;
+  OP_2 = 17;
+var rational: MPRational;
+begin
+  q_init(rational);
+  q_set_si(rational, OP_1, OP_2);
+  assert(q_cmp_si(rational, OP_1, OP_2) = 0);
+end;
+
+procedure TTestGmpExtensions.q_canonicalize_test;
+const
+  OP_1 = -13;
+  OP_2 = 17;
+  CF = 11;
+var rational: MPRational;
+begin
+  q_init(rational);
+  q_set_si(rational, CF * OP_1, CF * OP_2);
+  q_canonicalize(rational);
+  assert(q_cmp_si(rational, OP_1, OP_2) = 0);
+end;
+
+procedure TTestGmpExtensions.q_set_test;
+const
+  OP_1 = -13;
+  OP_2 = 17;
+var rational1, rational2: MPRational;
+begin
+  q_init(rational1);
+  q_init(rational2);
+  q_set_si(rational2, OP_1, OP_2);
+  q_set(rational1, rational2);
+  assert(q_cmp_si(rational1, OP_1, OP_2) = 0);
+end;
+
+procedure TTestGmpExtensions.q_set_z_test;
+const
+  OP_1 = -13;
+var
+  rational: MPRational;
+  op: MPInteger;
+begin
+  q_init(rational);
+  z_init_set_si(op, OP_1);
+  q_set_z(rational, op);
+  assert(q_cmp_si(rational, OP_1, 1) = 0);
+end;
+
+procedure TTestGmpExtensions.q_set_str_test;
+const
+  OP_1 = -13;
+  OP_2 = 17;
+var rational: MPRational;
+begin
+  q_init(rational);
+  assert(q_set_str(rational, pchar(inttostr(OP_1) + '/' + inttostr(OP_2)), BASE10));
+  assert(q_cmp_si(rational, OP_1, OP_2) = 0);
+  assert(not q_set_str(rational, pchar(inttostr(OP_1) + '*' + inttostr(OP_2)), BASE10));
+end;
+
+procedure TTestGmpExtensions.q_swap_test;
+const
+  ROP_1N = -13;
+  ROP_1D = 17;
+  ROP_2N = -23;
+  ROP_2D = 31;
+var rop1, rop2: MPRational;
+begin
+  q_init(rop1);
+  q_init(rop2);
+  q_set_si(rop1, ROP_1N, ROP_1D);
+  q_set_si(rop2, ROP_2N, ROP_2D);
+  q_swap(rop1, rop2);
+  assert(q_cmp_si(rop1, ROP_2N, ROP_2D) = 0);
+  assert(q_cmp_si(rop2, ROP_1N, ROP_1D) = 0);
+end;
+
+procedure TTestGmpExtensions.q_get_d_test;
+const
+  OP_1 = -1;
+  OP_2 = 2;
+var op: MPRational;
+begin
+  q_init(op);
+  q_set_si(op, OP_1, OP_2);
+  assert(q_get_d(op) = OP_1 / OP_2);
+end;
+
+procedure TTestGmpExtensions.q_set_d_test;
+const
+  OP_1 = -1;
+  OP_2 = 2;
+var rop: MPRational;
+begin
+  q_init(rop);
+  q_set_d(rop, OP_1 / OP_2);
+  assert(q_cmp_si(rop, OP_1, OP_2) = 0);
+end;
+
+procedure TTestGmpExtensions.q_set_f_test;
+const OP_ = -10;
+var
+  op: MPFloat;
+  rop: MPRational;
+begin
+  f_init_set_si(op, OP_);
+  q_init(rop);
+  q_set_f(rop, op);
+  assert(q_get_d(rop) = OP_);
+end;
+
+procedure TTestGmpExtensions.q_get_str_test;
+const
+  OP_1 = -1;
+  OP_2 = 2;
+var
+  op: MPRational;
+  p: pchar;
+  s, s2: string;
+begin
+  q_init(op);
+  q_set_si(op, OP_1, OP_2);
+  s := q_get_str(BASE10, op);
+  assert(s = inttostr(OP_1) + '/' + inttostr(OP_2));
+  p := q_get_str(nil, BASE10, op);
+  assert(p = inttostr(OP_1) + '/' + inttostr(OP_2));
+  freemem(p);
+  setlength(s2, length(inttostr(OP_1) + '/' + inttostr(OP_2)));
+  assert(pointer(q_get_str(pchar(s2), BASE10, op)) = pointer(s2));
+  assert(s2 = inttostr(OP_1) + '/' + inttostr(OP_2));
+end;
+
+procedure TTestGmpExtensions.q_add_test;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var sum, addend1, addend2, s2: MPRational;
+begin
+  q_init(sum);
+  q_init(addend1);
+  q_init(addend2);
+  q_set_si(addend1, N1, D1);
+  q_set_si(addend2, N2, D2);
+  q_add(sum, addend1, addend2);
+  assert(q_cmp_si(sum, N1 * D2 + N2 * D1, D1 * D2) = 0);
+  s2 := q_add(addend1, addend2);
+  assert(q_cmp_si(s2, N1 * D2 + N2 * D1, D1 * D2) = 0);
+end;
+
+procedure TTestGmpExtensions.q_sub_test;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var difference, minuend, subtrahend, diff2: MPRational;
+begin
+  q_init(difference);
+  q_init(minuend);
+  q_init(subtrahend);
+  q_set_si(minuend, N1, D1);
+  q_set_si(subtrahend, N2, D2);
+  q_sub(difference, minuend, subtrahend);
+  assert(q_cmp_si(difference, N1 * D2 - N2 * D1, D1 * D2) = 0);
+  diff2 := q_sub(minuend, subtrahend);
+  assert(q_cmp_si(diff2, N1 * D2 - N2 * D1, D1 * D2) = 0);
+end;
+
+procedure TTestGmpExtensions.q_mul_test;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var product, multiplier, multiplicant, p2: MPRational;
+begin
+  q_init(product);
+  q_init(multiplier);
+  q_init(multiplicant);
+  q_set_si(multiplier, N1, D1);
+  q_set_si(multiplicant, N2, D2);
+  q_mul(product, multiplier, multiplicant);
+  assert(q_cmp_si(product, N1 * N2, D1 * D2) = 0);
+  p2 := q_mul(multiplier, multiplicant);
+  assert(q_cmp_si(p2, N1 * N2, D1 * D2) = 0);
+end;
+
+procedure TTestGmpExtensions.q_mul_2exp_test;
+const
+  N1 = 5;
+  D1 = 3;
+  OP_2 = 2;
+var rop, op1, r2: MPRational;
+begin
+  q_init(rop);
+  q_init(op1);
+  q_set_si(op1, N1, D1);
+  q_mul_2exp(rop, op1, OP_2);
+  assert(q_cmp_si(rop, N1 * (1 shl OP_2), D1) = 0);
+  r2 := q_mul_2exp(op1, OP_2);
+  assert(q_cmp_si(r2, N1 * (1 shl OP_2), D1) = 0);
+end;
+
+procedure TTestGmpExtensions.q_div_test;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var quotient, dividend, divisor, q2: MPRational;
+begin
+  q_init(quotient);
+  q_init(dividend);
+  q_init(divisor);
+  q_set_si(dividend, N1, D1);
+  q_set_si(divisor, N2, D2);
+  q_div(quotient, dividend, divisor);
+  assert(q_cmp_si(quotient, -N1 * D2, -D1 * N2) = 0);
+  q2 := q_div(dividend, divisor);
+  assert(q_cmp_si(q2, -N1 * D2, -D1 * N2) = 0);
+end;
+
+procedure TTestGmpExtensions.q_div_2exp_test;
+const
+  N1 = 5;
+  D1 = 3;
+  OP_2 = 2;
+var rop, op1, r2: MPRational;
+begin
+  q_init(rop);
+  q_init(op1);
+  q_set_si(op1, N1, D1);
+  q_div_2exp(rop, op1, OP_2);
+  assert(q_cmp_si(rop, N1, D1 * (1 shl OP_2)) = 0);
+  r2 := q_div_2exp(op1, OP_2);
+  assert(q_cmp_si(r2, N1, D1 * (1 shl OP_2)) = 0);
+end;
+
+procedure TTestGmpExtensions.q_neg_test;
+const
+  N1 = -5;
+  D1 = 3;
+var negated_operand, operand, n2: MPRational;
+begin
+  q_init(negated_operand);
+  q_init(operand);
+  q_set_si(operand, N1, D1);
+  q_neg(negated_operand, operand);
+  assert(q_cmp_si(negated_operand, -N1, D1) = 0);
+  n2 := q_neg(operand);
+  assert(q_cmp_si(n2, -N1, D1) = 0);
+end;
+
+procedure TTestGmpExtensions.q_abs_test;
+const
+  N1 = 5;
+  D1 = 3;
+var rop, op, r2: MPRational;
+begin
+  q_init(rop);
+  q_init(op);
+  q_set_si(op, -N1, D1);
+  q_abs(rop, op);
+  assert(q_cmp_si(rop, N1, D1) = 0);
+  r2 := q_abs(op);
+  assert(q_cmp_si(r2, N1, D1) = 0);
+end;
+
+procedure TTestGmpExtensions.q_inv_test;
+const
+  N1 = -5;
+  D1 = 3;
+var inverted_number, number, i2: MPRational;
+begin
+  q_init(inverted_number);
+  q_init(number);
+  q_set_si(number, N1, D1);
+  q_inv(inverted_number, number);
+  assert(q_cmp_si(inverted_number, -D1, -N1) = 0);
+  i2 := q_inv(number);
+  assert(q_cmp_si(i2, -D1, -N1) = 0);
+end;
+
+procedure TTestGmpExtensions.q_cmp_test;
+const
+  N1 = -7;
+  D1 = 5;
+var op1, op2: MPRational;
+begin
+  q_init(op1);
+  q_init(op2);
+  q_set_si(op1, N1, D1);
+  q_set_si(op2, N1, D1);
+  assert(q_cmp(op1, op2) = 0);
+  q_set_si(op1, N1 + 1, D1);
+  assert(q_cmp(op1, op2) > 0);
+  q_set_si(op1, N1 - 1, D1);
+  assert(q_cmp(op1, op2) < 0);
+end;
+
+procedure TTestGmpExtensions.q_cmp_si_test;
+const
+  N1 = -7;
+  D1 = 5;
+var op1: MPRational;
+begin
+  q_init(op1);
+  q_set_si(op1, N1, D1);
+  assert(q_cmp_si(op1, N1, D1) = 0);
+  assert(q_cmp_si(op1, N1 - 1, D1) > 0);
+  assert(q_cmp_si(op1, N1 + 1, D1) < 0);
+end;
+
+procedure TTestGmpExtensions.q_cmp_ui_test;
+const
+  N1 = 7;
+  D1 = 5;
+var op1: MPRational;
+begin
+  q_init(op1);
+  q_set_si(op1, N1, D1);
+  assert(q_cmp_ui(op1, N1, D1) = 0);
+  assert(q_cmp_ui(op1, N1 - 1, D1) > 0);
+  assert(q_cmp_ui(op1, N1 + 1, D1) < 0);
+end;
+
+procedure TTestGmpExtensions.q_equal_test;
+const
+  N1 = -7;
+  D1 = 5;
+var op1, op2: MPRational;
+begin
+  q_init(op1);
+  q_init(op2);
+  q_set_si(op1, N1, D1);
+  q_set_si(op2, N1, D1);
+  assert(q_equal(op1, op2));
+  q_set_si(op1, N1 + 1, D1);
+  assert(not q_equal(op1, op2));
+  q_set_si(op1, N1 - 1, D1);
+  assert(not q_equal(op1, op2));
+end;
+
+procedure TTestGmpExtensions.q_get_num_test;
+const
+  N1 = -7;
+  D1 = 5;
+var
+  rational: MPRational;
+  numerator, n2: MPInteger;
+begin
+  q_init(rational);
+  z_init(numerator);
+  q_set_si(rational, N1, D1);
+  q_get_num(numerator, rational);
+  assert(z_get_si(numerator) = N1);
+  n2 := q_get_num(rational);
+  assert(z_get_si(n2) = N1);
+end;
+
+procedure TTestGmpExtensions.q_get_den_test;
+const
+  N1 = -7;
+  D1 = 5;
+var
+  rational: MPRational;
+  denominator, d2: MPInteger;
+begin
+  q_init(rational);
+  z_init(denominator);
+  q_set_si(rational, N1, D1);
+  q_get_den(denominator, rational);
+  assert(z_get_si(denominator) = D1);
+  d2 := q_get_den(rational);
+  assert(z_get_si(d2) = D1);
+end;
+
+procedure TTestGmpExtensions.q_set_num_test;
+const
+  N1 = -7;
+  D1 = 5;
+  N2 = 3;
+var
+  rational: MPRational;
+  numerator: MPInteger;
+begin
+  q_init(rational);
+  z_init_set_si(numerator, N2);
+  q_set_si(rational, N1, D1);
+  q_set_num(rational, numerator);
+  assert(q_cmp_si(rational, N2, D1) = 0);
+end;
+
+procedure TTestGmpExtensions.q_set_den_test;
+const
+  N1 = -7;
+  D1 = 5;
+  D2 = 3;
+var
+  rational: MPRational;
+  denominator: MPInteger;
+begin
+  q_init(rational);
+  z_init_set_si(denominator, D2);
+  q_set_si(rational, N1, D1);
+  q_set_den(rational, denominator);
+  assert(q_cmp_si(rational, N1, D2) = 0);
+end;
+
+procedure TTestGmpExtensions.f_get_default_prec_test;
+begin
+  assert(f_get_default_prec > 0);
+end;
+
+procedure TTestGmpExtensions.f_set_default_prec_test;
+var prec: valuint;
+begin
+  prec := f_get_default_prec;
+  f_set_default_prec(2 * prec);
+  assert(f_get_default_prec  = 2 * prec);
+  f_set_default_prec(prec);
+end;
+
+procedure TTestGmpExtensions.f_init_test;
+var x: MPFloat;
+begin
+  f_init(x);
+  assert(f_get_prec(x) = f_get_default_prec);
+end;
+
+procedure TTestGmpExtensions.f_init2_test;
+var x: MPFloat;
+begin
+  f_init2(x, 2 * f_get_default_prec);
+  assert(f_get_prec(x) = 2 * f_get_default_prec);
+end;
+
+procedure TTestGmpExtensions.f_clear_test;
+var x: MPFloat;
+begin
+  f_init(x);
+  f_clear(x);
+end;
+
+procedure TTestGmpExtensions.f_get_prec_test;
+var x: MPFloat;
+begin
+  f_init(x);
+  f_set_prec(x, 2 * f_get_default_prec);
+  assert(f_get_prec(x) = 2 * f_get_default_prec);
+end;
+
+procedure TTestGmpExtensions.f_set_prec_test;
+var x: MPFloat;
+begin
+  f_init(x);
+  f_set_prec(x, 2 * f_get_default_prec);
+  assert(f_get_prec(x) = 2 * f_get_default_prec);
+end;
+
+procedure TTestGmpExtensions.f_set_prec_raw_test;
+const N = 10;
+var x: MPFloat;
+begin
+  f_init2(x, N * f_get_default_prec);
+  f_set_prec_raw(x, f_get_default_prec);
+  f_set_prec_raw(x, N * f_get_default_prec);
+end;
+
+procedure TTestGmpExtensions.f_set_q_test;
+const OP_ = -10;
+var
+  op: MPRational;
+  rop: MPFloat;
+begin
+  q_init(op);
+  f_init(rop);
+  q_set_si(op, OP_, 1);
+  f_set_q(rop, op);
+  assert(f_get_si(rop) = OP_);
+end;
+
+procedure TTestGmpExtensions.f_set_ui_test;
+const OP = 1000000;
+var rop: MPFloat;
+begin
+  f_init(rop);
+  f_set_ui(rop, OP);
+  assert(f_get_ui(rop) = OP);
+end;
+
+procedure TTestGmpExtensions.f_get_ui_test;
+const OP = 1000000;
+var rop: MPFloat;
+begin
+  f_init(rop);
+  f_set_ui(rop, OP);
+  assert(f_get_ui(rop) = OP);
+end;
+
+procedure TTestGmpExtensions.f_set_si_test;
+const OP = -1000000;
+var rop: MPFloat;
+begin
+  f_init(rop);
+  f_set_si(rop, OP);
+  assert(f_get_si(rop) = OP);
+end;
+
+procedure TTestGmpExtensions.f_get_si_test;
+const OP = -1000000;
+var rop: MPFloat;
+begin
+  f_init(rop);
+  f_set_si(rop, OP);
+  assert(f_get_si(rop) = OP);
+end;
+
+procedure TTestGmpExtensions.f_set_test;
+const N = -1000000;
+var rop, op: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_si(op, N);
+  f_set(rop, op);
+  assert(f_get_si(rop) = N);
+end;
+
+procedure TTestGmpExtensions.f_set_str_test;
+const N = -123;
+var rop: MPFloat;
+begin
+  f_init(rop);
+  assert(f_set_str(rop, inttostr(N), BASE10));
+  assert(f_get_si(rop) = N);
+end;
+
+procedure TTestGmpExtensions.f_swap_test;
+const
+  ROP_1 = -13;
+  ROP_2 = -23;
+var rop1, rop2: MPFloat;
+begin
+  f_init_set_si(rop1, ROP_1);
+  f_init_set_si(rop2, ROP_2);
+  f_swap(rop1, rop2);
+  assert(f_get_si(rop1) =  ROP_2);
+  assert(f_get_si(rop2) = ROP_1);
+end;
+
+procedure TTestGmpExtensions.f_get_d_test;
+const N = -1.5;
+var rop: MPFloat;
+begin
+  f_init_set_d(rop, N);
+  assert(f_get_d(rop) = N);
+end;
+
+procedure TTestGmpExtensions.f_set_d_test;
+const N = -1.5;
+var rop: MPFloat;
+begin
+  f_init(rop);
+  f_set_d(rop, N);
+  assert(f_get_d(rop) = N);
+end;
+
+procedure TTestGmpExtensions.f_set_z_test;
+const
+  OP_1 = -13;
+var
+  rop: MPFloat;
+  op: MPInteger;
+begin
+  f_init(rop);
+  z_init_set_si(op, OP_1);
+  f_set_z(rop, op);
+  assert(f_get_si(rop) = OP_1);
+end;
+
+procedure TTestGmpExtensions.f_get_d_2exp_test;
+const
+  M = 0.5;
+  E = 4;
+  N = (1 shl E) div 2;
+var
+  rop: MPFloat;
+  exp: valsint;
+begin
+  f_init_set_d(rop, N);
+  exp := -1;
+  assert(f_get_d_2exp(exp, rop) = M);
+  assert(exp = E);
+end;
+
+procedure TTestGmpExtensions.f_get_str_test;
+const
+  N = 3.1416;
+  S = '31416';
+  E = 1;
+var
+  op: MPFloat;
+  p: pchar;
+  exp: mp_exp_t;
+  s1: string;
+begin
+  f_init_set_d(op, N);
+  p := f_get_str(nil, exp, BASE10, length(S), op);
+  assert(p = S);
+  assert(exp = E);
+  freemem(p);
+  setlength(s1, length(S));
+  assert(pointer(f_get_str(pchar(s1), exp, BASE10, length(s), op)) = pointer(s1));
+  assert(s1 = S);
+  s1 := f_get_str(exp, BASE10, length(S), op);
+  assert(s1 = S);
+end;
+
+procedure TTestGmpExtensions.f_add_test;
+const
+  OP1_ = 1;
+  OP2_ = 2;
+var rop, op1, op2, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  f_add(rop, op1, op2);
+  assert(f_get_d(rop) = OP1_ + OP2_);
+  r2 := f_add(op1, op2);
+  assert(f_get_d(r2) = OP1_ + OP2_);
+end;
+
+procedure TTestGmpExtensions.f_add_ui_test;
+const
+  OP1_ = 1;
+  OP2_ = 2;
+var rop, op1, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_add_ui(rop, op1, OP2_);
+  assert(f_get_d(rop) = OP1_ + OP2_);
+  r2 := f_add_ui(op1, OP2_);
+  assert(f_get_d(r2) = OP1_ + OP2_);
+end;
+
+procedure TTestGmpExtensions.f_sub_test;
+const
+  OP1_ = 3;
+  OP2_ = 1;
+var rop, op1, op2, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  f_sub(rop, op1, op2);
+  assert(f_get_d(rop) = OP1_ - OP2_);
+  r2 := f_sub(op1, op2);
+  assert(f_get_d(r2) = OP1_ - OP2_);
+end;
+
+procedure TTestGmpExtensions.f_sub_ui_test;
+const
+  OP1_ = 3;
+  OP2_ = 1;
+var rop, op1, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_sub_ui(rop, op1, OP2_);
+  assert(f_get_d(rop) = OP1_ - OP2_);
+  r2 := f_sub_ui(op1, OP2_);
+  assert(f_get_d(r2) = OP1_ - OP2_);
+end;
+
+procedure TTestGmpExtensions.f_ui_sub_test;
+const
+  OP1_ = 3;
+  OP2_ = 1;
+var rop, op2, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op2, OP2_);
+  f_ui_sub(rop, OP1_, op2);
+  assert(f_get_d(rop) = OP1_ - OP2_);
+  r2 := f_ui_sub(OP1_, op2);
+  assert(f_get_d(r2) = OP1_ - OP2_);
+end;
+
+procedure TTestGmpExtensions.f_mul_test;
+const
+  OP1_ = 2;
+  OP2_ = 3;
+var rop, op1, op2, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  f_mul(rop, op1, op2);
+  assert(f_get_d(rop) = OP1_ * OP2_);
+  r2 := f_mul(op1, op2);
+  assert(f_get_d(r2) = OP1_ * OP2_);
+end;
+
+procedure TTestGmpExtensions.f_mul_ui_test;
+const
+  OP1_ = 2;
+  OP2_ = 3;
+var rop, op1, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_mul_ui(rop, op1, OP2_);
+  assert(f_get_d(rop) = OP1_ * OP2_);
+  r2 := f_mul_ui(op1, OP2_);
+  assert(f_get_d(r2) = OP1_ * OP2_);
+end;
+
+procedure TTestGmpExtensions.f_mul_2exp_test;
+const
+  OP1_ = 3;
+  OP2_ = 4;
+var rop, op1, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_mul_2exp(rop, op1, OP2_);
+  assert(f_get_d(rop) = OP1_ * (1 shl OP2_));
+  r2 := f_mul_2exp(op1, OP2_);
+  assert(f_get_d(r2) = OP1_ * (1 shl OP2_));
+end;
+
+procedure TTestGmpExtensions.f_div_test;
+const
+  OP1_ = 6;
+  OP2_ = 2;
+var rop, op1, op2, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  f_div(rop, op1, op2);
+  assert(f_get_d(rop) = OP1_ / OP2_);
+  r2 := f_div(op1, op2);
+  assert(f_get_d(r2) = OP1_ / OP2_);
+end;
+
+procedure TTestGmpExtensions.f_div_ui_test;
+const
+  OP1_ = 6;
+  OP2_ = 2;
+var rop, op1, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_div_ui(rop, op1, OP2_);
+  assert(f_get_d(rop) = OP1_ / OP2_);
+  r2 := f_div_ui(op1, OP2_);
+  assert(f_get_d(r2) = OP1_ / OP2_);
+end;
+
+procedure TTestGmpExtensions.f_ui_div_test;
+const
+  OP1_ = 6;
+  OP2_ = 2;
+var rop, op2, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_si(op2, OP2_);
+  f_ui_div(rop, OP1_, op2);
+  assert(f_get_d(rop) = OP1_ / OP2_);
+  r2 := f_ui_div(OP1_, op2);
+  assert(f_get_d(r2) = OP1_ / OP2_);
+end;
+
+procedure TTestGmpExtensions.f_div_2exp_test;
+const
+  OP1_ = 16;
+  OP2_ = 2;
+var rop, op1, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_div_2exp(rop, op1, OP2_);
+  assert(f_get_d(rop) = OP1_ / (1 shl OP2_));
+  r2 := f_div_2exp(op1, OP2_);
+  assert(f_get_d(r2) = OP1_ / (1 shl OP2_));
+end;
+
+procedure TTestGmpExtensions.f_sqrt_test;
+const
+  OP_ = 4;
+var rop, op, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op, OP_);
+  f_sqrt(rop, op);
+  assert(f_get_d(rop) = sqrt(OP_));
+  r2 := f_sqrt(op);
+  assert(f_get_d(r2) = sqrt(OP_));
+end;
+
+procedure TTestGmpExtensions.f_sqrt_ui_test;
+const
+  OP_ = 4;
+var rop, r2: MPFloat;
+begin
+  f_init(rop);
+  f_sqrt_ui(rop, OP_);
+  assert(f_get_d(rop) = sqrt(OP_));
+  r2 := f_sqrt_ui(OP_);
+  assert(f_get_d(r2) = sqrt(OP_));
+end;
+
+procedure TTestGmpExtensions.f_pow_ui_test;
+const
+  OP1_ = 3;
+  OP2_ = 2;
+var rop, op1, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_pow_ui(rop, op1, OP2_);
+  assert(f_get_d(rop) = OP1_ ** OP2_);
+  r2 := f_pow_ui(op1, OP2_);
+  assert(f_get_d(r2) = OP1_ ** OP2_);
+end;
+
+procedure TTestGmpExtensions.f_neg_test;
+const
+  OP_ = 4;
+var rop, op, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op, OP_);
+  f_neg(rop, op);
+  assert(f_get_d(rop) = -OP_);
+  r2 := f_neg(op);
+  assert(f_get_d(r2) = -OP_);
+end;
+
+procedure TTestGmpExtensions.f_abs_test;
+const OP_ = -4;
+var rop, op, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op, OP_);
+  f_abs(rop, op);
+  assert(f_get_d(rop) = -OP_);
+  r2 := f_abs(op);
+  assert(f_get_d(r2) = -OP_);
+end;
+
+procedure TTestGmpExtensions.f_cmp_test;
+const OP_1 = -10;
+var op1, op2: MPFloat;
+begin
+  f_init_set_si(op1, OP_1);
+  f_init_set_si(op2, OP_1);
+  assert(f_cmp(op1, op2) = 0);
+  f_set_si(op2, OP_1 + 1);
+  assert(f_cmp(op1, op2) < 0);
+  f_set_si(op2, OP_1 - 1);
+  assert(f_cmp(op1, op2) > 0);
+end;
+
+procedure TTestGmpExtensions.f_cmp_d_test;
+const OP_ = -10;
+var op: MPFloat;
+begin
+  f_init_set_si(op, OP_);
+  assert(f_cmp_d(op, OP_) = 0);
+  assert(f_cmp_d(op, OP_ + 1) < 0);
+  assert(f_cmp_d(op, OP_ - 1) > 0);
+end;
+
+procedure TTestGmpExtensions.f_cmp_si_test;
+const OP_ = -10;
+var op: MPFloat;
+begin
+  f_init_set_si(op, OP_);
+  assert(f_cmp_si(op, OP_) = 0);
+  assert(f_cmp_si(op, OP_ + 1) < 0);
+  assert(f_cmp_si(op, OP_ - 1) > 0);
+end;
+
+procedure TTestGmpExtensions.f_cmp_ui_test;
+const OP_ = 10;
+var op: MPFloat;
+begin
+  f_init_set_si(op, OP_);
+  assert(f_cmp_ui(op, OP_) = 0);
+  assert(f_cmp_ui(op, OP_ + 1) < 0);
+  assert(f_cmp_ui(op, OP_ - 1) > 0);
+end;
+
+procedure TTestGmpExtensions.f_eq_test;
+const
+  OP_1 = 10;
+  OP_3 = 8;
+var op1, op2: MPFloat;
+begin
+  f_init_set_si(op1, OP_1);
+  f_init_set_si(op2, OP_1);
+  assert(f_eq(op1, op2, OP_3));
+end;
+
+procedure TTestGmpExtensions.f_reldiff_test;
+const
+  OP1_ = 4;
+  OP2_ = 2;
+var rop, op1, op2, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  f_reldiff(rop, op1, op2);
+  assert(f_get_d(rop) = abs(OP1_ - OP2_) / OP1_);
+  r2 := f_reldiff(op1, op2);
+  assert(f_get_d(r2) = abs(OP1_ - OP2_) / OP1_);
+end;
+
+procedure TTestGmpExtensions.f_ceil_test;
+const N = 3.1;
+var rop, op, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op, N);
+  f_ceil(rop, op);
+  assert(f_get_d(rop) = ceil(N));
+  r2 := f_ceil(op);
+  assert(f_get_d(r2) = ceil(N));
+end;
+
+procedure TTestGmpExtensions.f_floor_test;
+const N = 3.9;
+var rop, op, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op, N);
+  f_floor(rop, op);
+  assert(f_get_d(rop) = floor(N));
+  r2 := f_floor(op);
+  assert(f_get_d(r2) = floor(N));
+end;
+
+procedure TTestGmpExtensions.f_trunc_test;
+const N = -3.9;
+var rop, op, r2: MPFloat;
+begin
+  f_init(rop);
+  f_init_set_d(op, N);
+  f_trunc(rop, op);
+  assert(f_get_d(rop) = trunc(N));
+  r2 := f_trunc(op);
+  assert(f_get_d(r2) = trunc(N));
+end;
+
+procedure TTestGmpExtensions.f_integer_p_test;
+const
+  N1 = 10;
+  N2 = 10.1;
+var op: MPFloat;
+begin
+  f_init_set_si(op, N1);
+  assert(f_integer_p(op));
+  f_set_d(op, N2);
+  assert(not f_integer_p(op));
+end;
+
+procedure TTestGmpExtensions.f_fits_ushort_p_test;
+var op: MPFloat;
+begin
+  f_init_set_ui(op, high(word));
+  assert(f_fits_ushort_p(op));
+  f_add_ui(op, op, 1);
+  assert(not f_fits_ushort_p(op));
+end;
+
+procedure TTestGmpExtensions.f_fits_sshort_p_test;
+var op: MPFloat;
+begin
+  f_init_set_ui(op, high(smallint));
+  assert(f_fits_sshort_p(op));
+  f_add_ui(op, op, 1);
+  assert(not f_fits_sshort_p(op));
+  f_clear(op);
+end;
+
+procedure TTestGmpExtensions.f_fits_uint_p_test;
+var op: MPFloat;
+begin
+  f_init_set_ui(op, high(cardinal));
+  assert(f_fits_uint_p(op));
+  f_add_ui(op, op, 1);
+  assert(not f_fits_uint_p(op));
+  f_clear(op);
+end;
+
+procedure TTestGmpExtensions.f_fits_sint_p_test;
+var op: MPFloat;
+begin
+  f_init_set_ui(op, high(integer));
+  assert(f_fits_sint_p(op));
+  f_add_ui(op, op, 1);
+  assert(not f_fits_sint_p(op));
+  f_clear(op);
+end;
+
+procedure TTestGmpExtensions.f_fits_ulong_p_test;
+var op: MPFloat;
+begin
+  f_init_set_ui(op, high(valuint));
+  assert(f_fits_ulong_p(op));
+  f_add_ui(op, op, 1);
+  assert(not f_fits_ulong_p(op));
+  f_clear(op);
+end;
+
+procedure TTestGmpExtensions.f_fits_slong_p_test;
+var op: MPFloat;
+begin
+  f_init_set_ui(op, high(valsint));
+  assert(f_fits_slong_p(op));
+  f_add_ui(op, op, 1);
+  assert(not f_fits_slong_p(op));
+  f_clear(op);
+end;
+
+procedure TTestGmpExtensions.f_urandomb_test;
+const NBITS = 100;
+var
+  rop, r2: MPFloat;
+  state: MPRandState;
+  cmp: longint;
+begin
+  randinit_default(state);
+  f_init(rop);
+  f_urandomb(rop, state, NBITS);
+  cmp := f_cmp_ui(rop, 0);
+  assert(cmp >= 0);
+  assert(f_cmp_ui(rop, 1) < 0);
+  r2 := f_urandomb(state, NBITS);
+  cmp := f_cmp_ui(r2, 0);
+  assert(cmp >= 0);
+  assert(f_cmp_ui(r2, 1) < 0);
+end;
+
+procedure TTestGmpExtensions.f_random2_test;
+var
+  rop, r2: MPFloat;
+begin
+  f_init(rop);
+  f_random2(rop, 1, 1);
+  r2 := f_random2(1, 1);
+  assert(assigned(r2))
+end;
+
+procedure TTestGmpExtensions.f_init_set_test;
+const N = -1000000;
+var rop, op: MPFloat;
+begin
+  f_init_set_si(op, N);
+  f_init_set(rop, op);
+  assert(f_get_si(rop) = N);
+end;
+
+procedure TTestGmpExtensions.f_init_set_d_test;
+const N = -1.5;
+var rop: MPFloat;
+begin
+  f_init_set_d(rop, N);
+  assert(f_get_d(rop) = N);
+end;
+
+procedure TTestGmpExtensions.f_init_set_si_test;
+const N = -5;
+var rop: MPFloat;
+begin
+  f_init_set_si(rop, N);
+  assert(f_get_si(rop) = N);
+end;
+
+procedure TTestGmpExtensions.f_init_set_str_test;
+const N = -123;
+var rop: MPFloat;
+begin
+  f_init_set_str(rop, inttostr(N), BASE10);
+  assert(f_get_si(rop) = N);
+end;
+
+procedure TTestGmpExtensions.f_init_set_ui_test;
+const N = 5;
+var rop: MPFloat;
+begin
+  f_init_set_ui(rop, N);
+  assert(f_get_ui(rop) = N);
+end;
+
+{ TTestGmpOperators }
+
+// operator * (op1: MPFloat; op2: MPFloat): MPFloat;
+procedure TTestGmpOperators.star__MPFloat__MPFloat__MPFloat_;
+const
+  OP1_ = 2;
+  OP2_ = 3;
+var rop, op1, op2: MPFloat;
+begin
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  rop := op1 * op2;
+  assert(f_get_d(rop) = OP1_ * OP2_);
+end;
+
+// operator * (op1: MPInteger; op2: MPInteger): MPInteger;
+procedure TTestGmpOperators.star__MPInteger__MPInteger__MPInteger_;
+const
+  OP_1 = -10;
+  OP_2 = 1000;
+var rop, op1, op2: MPInteger;
+begin
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  rop := op1 * op2;
+  assert(z_get_si(rop) = OP_1 * OP_2);
+end;
+
+// operator * (op1: MPRational; op2: MPRational): MPRational;
+procedure TTestGmpOperators.star__MPRational__MPRational__MPRational_;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var product, multiplier, multiplicant: MPRational;
+begin
+  q_init(multiplier);
+  q_init(multiplicant);
+  q_set_si(multiplier, N1, D1);
+  q_set_si(multiplicant, N2, D2);
+  product := multiplier * multiplicant;
+  assert(q_cmp_si(product, N1 * N2, D1 * D2) = 0);
+end;
+
+// operator ** (op1: MPFloat; op2: valuint): MPFloat;
+procedure TTestGmpOperators.pow__MPFloat_valuint_MPFloat_;
+const
+  OP1_ = 3;
+  OP2_ = 2;
+var rop, op1: MPFloat;
+begin
+  f_init_set_d(op1, OP1_);
+  rop := op1 ** OP2_;
+  assert(f_get_d(rop) = OP1_ ** OP2_);
+end;
+
+// operator ** (op1: MPInteger; op2: valuint): MPInteger;
+procedure TTestGmpOperators.pow__MPInteger_valuint_MPInteger_;
+const
+  BASE_ = 10;
+  EXP = 3;
+var rop, base: MPInteger;
+begin
+  z_init_set_si(base, BASE_);
+  rop := base ** EXP;
+  assert(z_get_si(rop) = BASE_ ** EXP);
+end;
+
+// operator + (op1: MPFloat; op2: MPFloat): MPFloat;
+procedure TTestGmpOperators.plus__MPFloat__MPFloat__MPFloat_;
+const
+  OP1_ = 1;
+  OP2_ = 2;
+var rop, op1, op2: MPFloat;
+begin
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  rop := op1 + op2;
+  assert(f_get_d(rop) = OP1_ + OP2_);
+end;
+
+// operator + (op1: MPInteger; op2: MPInteger): MPInteger;
+procedure TTestGmpOperators.plus__MPInteger__MPInteger__MPInteger_;
+const
+  OP_1 = -1000;
+  OP_2 = 1000000;
+var rop, op1, op2: MPInteger;
+begin
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  rop := op1 + op2;
+  assert(z_get_si(rop) = OP_1 + OP_2);
+end;
+
+// operator + (op1: MPRational; op2: MPRational): MPRational;
+procedure TTestGmpOperators.plus__MPRational__MPRational__MPRational_;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var sum, addend1, addend2: MPRational;
+begin
+  q_init(addend1);
+  q_init(addend2);
+  q_set_si(addend1, N1, D1);
+  q_set_si(addend2, N2, D2);
+  sum := addend1 + addend2;
+  assert(q_cmp_si(sum, N1 * D2 + N2 * D1, D1 * D2) = 0);
+end;
+
+// operator - (op: MPFloat): MPFloat;
+procedure TTestGmpOperators.minus__MPFloat__MPFloat_;
+const
+  OP_ = 4;
+var rop, op: MPFloat;
+begin
+  f_init_set_d(op, OP_);
+  rop := -op;
+  assert(f_get_d(rop) = -OP_);
+end;
+
+// operator - (op: MPInteger): MPInteger;
+procedure TTestGmpOperators.minus__MPInteger__MPInteger_;
+const OP_ = 1000;
+var rop, op: MPInteger;
+begin
+  z_init_set_si(op, OP_);
+  rop := -op;
+  assert(z_get_si(rop) = -OP_);
+end;
+
+// operator - (op: MPRational): MPRational;
+procedure TTestGmpOperators.minus__MPRational__MPRational_;
+const
+  N1 = -5;
+  D1 = 3;
+var negated_operand, operand: MPRational;
+begin
+  q_init(negated_operand);
+  q_init(operand);
+  q_set_si(operand, N1, D1);
+  negated_operand := - operand;
+  assert(q_cmp_si(negated_operand, -N1, D1) = 0);
+end;
+
+// operator - (op1: MPFloat; op2: MPFloat): MPFloat;
+procedure TTestGmpOperators.minus__MPFloat__MPFloat__MPFloat_;
+const
+  OP1_ = 3;
+  OP2_ = 1;
+var rop, op1, op2: MPFloat;
+begin
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  rop := op1 - op2;
+  assert(f_get_d(rop) = OP1_ - OP2_);
+end;
+
+// operator - (op1: MPInteger; op2: MPInteger): MPInteger;
+procedure TTestGmpOperators.minus__MPInteger__MPInteger__MPInteger_;
+const
+  OP_1 = -1000;
+  OP_2 = 1000000;
+var rop, op1, op2: MPInteger;
+begin
+  z_init_set_si(op1, OP_1);
+  z_init_set_si(op2, OP_2);
+  rop := op1 - op2;
+  assert(z_get_si(rop) = OP_1 - OP_2);
+end;
+
+// operator - (op1: MPRational; op2: MPRational): MPRational;
+procedure TTestGmpOperators.minus__MPRational__MPRational__MPRational_;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var difference, minuend, subtrahend: MPRational;
+begin
+  q_init(minuend);
+  q_init(subtrahend);
+  q_set_si(minuend, N1, D1);
+  q_set_si(subtrahend, N2, D2);
+  difference := minuend - subtrahend;
+  assert(q_cmp_si(difference, N1 * D2 - N2 * D1, D1 * D2) = 0);
+end;
+
+// operator / (op1: MPFloat; op2: MPFloat): MPFloat;
+procedure TTestGmpOperators.slash__MPFloat__MPFloat__MPFloat_;
+const
+  OP1_ = 6;
+  OP2_ = 2;
+var rop, op1, op2: MPFloat;
+begin
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  rop := op1 / op2;
+  assert(f_get_d(rop) = OP1_ / OP2_);
+end;
+
+// operator / (op1: MPInteger; op2: MPInteger): MPInteger;
+procedure TTestGmpOperators.slash__MPInteger__MPInteger__MPInteger_;
+const
+  N_ = -17;
+  D_ = 4;
+var q, n, d: MPInteger;
+begin
+  z_init_set_si(n, N_);
+  z_init_set_si(d, D_);
+  q := n / d;
+  assert(z_get_si(q) = trunc(N_ / D_));
+end;
+
+// operator / (op1: MPRational; op2: MPRational): MPRational;
+procedure TTestGmpOperators.slash__MPRational__MPRational__MPRational_;
+const
+  N1 = 5;
+  D1 = 2;
+  N2 = -7;
+  D2 = 3;
+var quotient, dividend, divisor: MPRational;
+begin
+  q_init(dividend);
+  q_init(divisor);
+  q_set_si(dividend, N1, D1);
+  q_set_si(divisor, N2, D2);
+  quotient := dividend / divisor;
+  assert(q_cmp_si(quotient, -N1 * D2, -D1 * N2) = 0);
+end;
+
+// operator := (op: double): MPFloat;
+procedure TTestGmpOperators.assign_double_MPFloat_;
+const N = -1.5;
+var rop: MPFloat;
+begin
+  rop := N;
+  assert(f_get_d(rop) = N);
+end;
+
+// operator := (op: double): MPInteger;
+procedure TTestGmpOperators.assign_double_MPInteger_;
+const OP_ = 1000000;
+var rop: MPInteger;
+begin
+  rop := OP_;
+  assert(z_get_si(rop) = OP_);
+end;
+
+// operator := (op: double): MPRational;
+procedure TTestGmpOperators.assign_double_MPRational_;
+const
+  OP_1 = -1;
+  OP_2 = 2;
+var rop: MPRational;
+begin
+  rop := OP_1 / OP_2;
+  assert(q_cmp_si(rop, OP_1, OP_2) = 0);
+end;
+
+// operator := (op: MPFloat): cardinal;
+procedure TTestGmpOperators.assign__MPFloat_Cardinal;
+const OP = 1000000;
+var rop: MPFloat;
+begin
+  rop := OP;
+  assert(f_get_ui(rop) = OP);
+end;
+
+// operator := (op: MPFloat): double;
+procedure TTestGmpOperators.assign__MPFloat_double;
+const N = -1.5;
+var rop: MPFloat;
+begin
+  rop := N;
+  assert(f_get_d(rop) = N);
+end;
+
+// operator := (op: MPFloat): integer;
+procedure TTestGmpOperators.assign__MPFloat_integer;
+const OP = -1000000;
+var rop: MPFloat;
+begin
+  rop := OP;
+  assert(f_get_si(rop) = OP);
+end;
+
+// operator := (op: MPFloat): mpf_t;
+procedure TTestGmpOperators.assign__MPFloat_mpf_t;
+const N = -1000000;
+var
+  rop: mpf_t;
+  op: MPFloat;
+begin
+  f_init_set_si(op, N);
+  rop := op;
+  assert(mpf_get_si(rop) = N);
+  mpf_clear(rop);
+end;
+
+// operator := (op: MPFloat): MPInteger;
+procedure TTestGmpOperators.assign__MPFloat__MPInteger_;
+const OP_ = -10;
+var
+  op: MPFloat;
+  rop: MPInteger;
+begin
+  f_init_set_si(op, OP_);
+  rop := op;
+  assert(z_get_si(rop) = OP_);
+end;
+
+// operator := (op: MPFloat): MPRational;
+procedure TTestGmpOperators.assign__MPFloat__MPRational_;
+const OP_ = -10;
+var
+  op: MPFloat;
+  rop: MPRational;
+begin
+  f_init_set_si(op, OP_);
+  rop :=  op;
+  assert(q_get_d(rop) = OP_);
+end;
+
+// operator := (op: MPFloat): string;
+procedure TTestGmpOperators.assign__MPFloat_string;
+const
+  N = 123456;
+  S = '123456';
+var
+  op: MPFloat;
+  r: string;
+begin
+  f_init_set_d(op, N);
+  r := op;
+  assert(r = S);
+end;
+
+// operator := (op: MPFloat): valsint;
+procedure TTestGmpOperators.assign__MPFloat_valsint;
+const OP_ = -1000000;
+var
+  op: MPFloat;
+  r: valsint;
+begin
+  f_init_set_si(op, OP_);
+  r := op;
+  assert(r = OP_);
+end;
+
+// operator := (op: MPFloat): valuint;
+procedure TTestGmpOperators.assign__MPFloat_valuint;
+const OP_ = 1000000;
+var
+  op: MPFloat;
+  r: valuint;
+begin
+  f_init_set_si(op, OP_);
+  r := op;
+  assert(r = OP_);
+end;
+
+// operator := (var op: mpf_t): MPFloat;
+procedure TTestGmpOperators.assign_mpf_t_MPFloat_;
+const N = -1000000;
+var
+  op: mpf_t;
+  rop: MPFloat;
+begin
+  mpf_init_set_si(op, N);
+  rop := op;
+  assert(f_get_si(rop) = N);
+  mpf_clear(op);
+end;
+
+// operator := (op: MPInteger): cardinal;
+procedure TTestGmpOperators.assign__MPInteger_cardinal;
+const N = 1000000;
+var
+  op: MPInteger;
+  r: cardinal;
+begin
+  z_init_set_ui(op, N);
+  r := op;
+  assert(r = N);
+end;
+
+// operator := (op: MPInteger): double;
+procedure TTestGmpOperators.assign__MPInteger_double;
+const N = -1000;
+var
+  op: MPInteger;
+  r: double;
+begin
+  z_init_set_si(op, N);
+  r := op;
+  assert(r = N);
+end;
+
+// operator := (op: MPInteger): integer;
+procedure TTestGmpOperators.assign__MPInteger_integer;
+const N = -1000000;
+var
+  op: MPInteger;
+  r: integer;
+begin
+  z_init_set_si(op, N);
+  r := op;
+  assert(r = N);
+end;
+
+// operator := (op: MPInteger): MPFloat;
+procedure TTestGmpOperators.assign__MPInteger__MPFloat_;
+const
+  OP_1 = -13;
+var
+  rop: MPFloat;
+  op: MPInteger;
+begin
+  z_init_set_si(op, OP_1);
+  rop := op;
+  assert(f_get_si(rop) = OP_1);
+end;
+
+// operator := (op: MPInteger): MPRational;
+procedure TTestGmpOperators.assign__MPInteger__MPRational_;
+const
+  OP_1 = -13;
+var
+  rational: MPRational;
+  op: MPInteger;
+begin
+  z_init_set_si(op, OP_1);
+  rational := op;
+  assert(q_cmp_si(rational, OP_1, 1) = 0);
+end;
+
+// operator := (op: MPInteger): mpz_t;
+procedure TTestGmpOperators.assign__MPInteger_mpz_t;
+const N = -1000000;
+var
+  rop: mpz_t;
+  op: MPInteger;
+begin
+  z_init_set_si(op, N);
+  rop := op;
+  assert(mpz_get_si(rop) = N);
+  mpz_clear(rop);
+end;
+
+// operator := (op: MPInteger): string;
+procedure TTestGmpOperators.assign__MPInteger_string;
+const
+  N = 123456;
+  S = '123456';
+var
+  op: MPInteger;
+  r: string;
+begin
+  z_init_set_ui(op, N);
+  r := op;
+  assert(r = S);
+end;
+
+// operator := (op: MPInteger): valsint;
+procedure TTestGmpOperators.assign__MPInteger_valsint;
+const N = -1000000;
+var
+  op: MPInteger;
+  r: valsint;
+begin
+  z_init_set_si(op, N);
+  r := op;
+  assert(r = N);
+end;
+
+// operator := (op: MPInteger): valuint;
+procedure TTestGmpOperators.assign__MPInteger_valuint;
+const N = 1000000;
+var
+  op: MPInteger;
+  r: valuint;
+begin
+  z_init_set_ui(op, N);
+  r := op;
+  assert(r = N);
+end;
+
+// operator := (var op: mpq_t): MPRational;
+procedure TTestGmpOperators.assign_mpq_t_MPRational_;
+const
+  N = -17;
+  D = 3;
+var
+  op: mpq_t;
+  rop: MPRational;
+begin
+  mpq_init(op);
+  mpq_set_si(op, N, D);
+  rop := op;
+  assert(q_cmp_si(rop, N, D) = 0);
+  mpq_clear(op);
+end;
+
+// operator := (op: MPRandState): randstate_t;
+procedure TTestGmpOperators.assign__MPRandState_randstate_t;
+var
+  op: MPRandState;
+  rop: randstate_t;
+begin
+  randinit_default(op);
+  rop := op;
+  assert(rnd_test(rop));
+  mp_randclear(rop);
+end;
+
+// operator := (op: MPRational): double;
+procedure TTestGmpOperators.assign__MPRational_double;
+const
+  OP_1 = -1;
+  OP_2 = 2;
+var
+  op: MPRational;
+  r: double;
+begin
+  q_init(op);
+  q_set_si(op, OP_1, OP_2);
+  r := op;
+  assert(r = OP_1 / OP_2);
+end;
+
+// operator := (op: MPRational): MPFloat;
+procedure TTestGmpOperators.assign__MPRational__MPFloat_;
+const OP_ = -10;
+var
+  op: MPRational;
+  rop: MPFloat;
+begin
+  q_init(op);
+  q_set_si(op, OP_, 1);
+  rop :=  op;
+  assert(f_get_si(rop) = OP_);
+end;
+
+// operator := (op: MPRational): MPInteger;
+procedure TTestGmpOperators.assign__MPRational__MPInteger_;
+const OP_ = -10;
+var
+  op: MPRational;
+  rop: MPInteger;
+begin
+  q_init(op);
+  q_set_si(op, OP_, 1);
+  rop := op;
+  assert(z_get_si(rop) = OP_);
+end;
+
+// operator := (op: MPRational): mpq_t;
+procedure TTestGmpOperators.assign__MPRational_mpq_t;
+const
+  OP_1 = -13;
+  OP_2 = 17;
+var
+  rational: mpq_t;
+  op: MPRational;
+begin
+  q_init(op);
+  q_set_si(op, OP_1, OP_2);
+  rational := op;
+  assert(mpq_cmp_si(rational, OP_1, OP_2) = 0);
+  mpq_clear(rational);
+end;
+
+// operator := (op: MPRational): string;
+procedure TTestGmpOperators.assign__MPRational_string;
+const
+  N = 5;
+  D = 3;
+  S = '5/3';
+var
+  op: MPRational;
+  r: string;
+begin
+  q_init(op);
+  q_set_si(op, N, D);
+  r := op;
+  assert(r = S);
+end;
+
+// operator := (var op: mpz_t): MPInteger;
+procedure TTestGmpOperators.assign_mpz_t_MPInteger_;
+const N = -1000000;
+var
+  op: mpz_t;
+  rop: MPInteger;
+begin
+  mpz_init_set_si(op, N);
+  rop := op;
+  assert(z_get_si(rop) = N);
+  mpz_clear(op);
+end;
+
+// operator := (var op: randstate_t): MPRandState;
+procedure TTestGmpOperators.assign_randstate_t_MPRandState_;
+var
+  op: randstate_t;
+  rop: MPRandState;
+begin
+  mp_randinit_default(op);
+  rop := op;
+  assert(rnd_test(rop.ptr^));
+  mp_randclear(op);
+end;
+
+// operator := (op: string): MPFloat;
+procedure TTestGmpOperators.assign_string_MPFloat_;
+const N = -123;
+var rop: MPFloat;
+begin
+  rop := inttostr(N);
+  assert(f_get_si(rop) = N);
+end;
+
+// operator := (op: string): MPInteger;
+procedure TTestGmpOperators.assign_string_MPInteger_;
+const N = -123;
+var rop: MPInteger;
+begin
+  rop := inttostr(N);
+  assert(z_get_si(rop) = N);
+end;
+
+// operator := (op: string): MPRational;
+procedure TTestGmpOperators.assign_string_MPRational_;
+const
+  N = 5;
+  D = 3;
+  S = '5/3';
+var rop: MPRational;
+begin
+  rop := S;
+  assert(q_cmp_si(rop, N, D) = 0);
+end;
+
+// operator := (op: valsint): MPFloat;
+procedure TTestGmpOperators.assign_valsint_MPFloat_;
+const OP = -1000000;
+var rop: MPFloat;
+begin
+  rop := OP;
+  assert(f_get_si(rop) = OP);
+end;
+
+// operator := (op: valsint): MPInteger;
+procedure TTestGmpOperators.assign_valsint_MPInteger_;
+const OP = -1000000;
+var rop: MPInteger;
+begin
+  rop := OP;
+  assert(z_get_si(rop) = OP);
+end;
+
+// operator := (op: valsint): MPRational;
+procedure TTestGmpOperators.assign_valsint_MPRational_;
+const OP = -1000000;
+var rop: MPRational;
+begin
+  rop := OP;
+  assert(q_cmp_si(rop, OP, 1) = 0);
+end;
+
+// operator := (op: valuint): MPFloat;
+procedure TTestGmpOperators.assign_valuint_MPFloat_;
+const OP = 1000000;
+var rop: MPFloat;
+begin
+  rop := OP;
+  assert(f_get_ui(rop) = OP);
+end;
+
+// operator := (op: valuint): MPInteger;
+procedure TTestGmpOperators.assign_valuint_MPInteger_;
+const OP = 1000000;
+var rop: MPInteger;
+begin
+  rop := OP;
+  assert(z_get_ui(rop) = OP);
+end;
+
+// operator := (op: valuint): MPRational;
+procedure TTestGmpOperators.assign_valuint_MPRational_;
+const OP = 1000000;
+var rop: MPRational;
+begin
+  rop := OP;
+  assert(q_cmp_ui(rop, OP, 1) = 0);
+end;
+
+// operator < (op1: MPFloat; op2: MPFloat): boolean;
+procedure TTestGmpOperators.lt__MPFloat__MPFloat_boolean;
+const
+  OP1_ = 1.2;
+  OP2_ = OP1_ + 1;
+var op1, op2: MPFloat;
+begin
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  assert(op1 < op2);
+end;
+
+// operator < (op1: MPInteger; op2: MPInteger): boolean;
+procedure TTestGmpOperators.lt__MPInteger__MPInteger_boolean;
+const
+  OP1_ = 12;
+  OP2_ = OP1_ + 1;
+var op1, op2: MPInteger;
+begin
+  z_init_set_d(op1, OP1_);
+  z_init_set_d(op2, OP2_);
+  assert(op1 < op2);
+end;
+
+// operator < (op1: MPRational; op2: MPRational): boolean;
+procedure TTestGmpOperators.lt__MPRational__MPRational_boolean;
+const
+  OP1_ = 12;
+  OP2_ = OP1_ + 1;
+var op1, op2: MPRational;
+begin
+  q_init(op1);
+  q_init(op2);
+  q_set_si(op1, OP1_, 1);
+  q_set_si(op2, OP2_, 1);
+  assert(op1 < op2);
+end;
+
+// operator <= (op1: MPFloat; op2: MPFloat): boolean;
+procedure TTestGmpOperators.le__MPFloat__MPFloat_boolean;
+const
+  OP1_ = 1.2;
+  OP2_ = OP1_ + 1;
+var op1, op2: MPFloat;
+begin
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  assert(op1 <= op2);
+  f_set_d(op2, OP1_);
+  assert(op1 <= op2);
+end;
+
+// operator <= (op1: MPInteger; op2: MPInteger): boolean;
+procedure TTestGmpOperators.le__MPInteger__MPInteger_boolean;
+const
+  OP1_ = 12;
+  OP2_ = OP1_ + 1;
+var op1, op2: MPInteger;
+begin
+  z_init_set_ui(op1, OP1_);
+  z_init_set_ui(op2, OP2_);
+  assert(op1 <= op2);
+  z_set_ui(op2, OP1_);
+  assert(op1 <= op2);
+end;
+
+// operator <= (op1: MPRational; op2: MPRational): boolean;
+procedure TTestGmpOperators.le__MPRational__MPRational_boolean;
+const
+  OP1_ = 12;
+  OP2_ = OP1_ + 1;
+var op1, op2: MPRational;
+begin
+  q_init(op1);
+  q_init(op2);
+  q_set_si(op1, OP1_, 1);
+  q_set_si(op2, OP2_, 1);
+  assert(op1 <= op2);
+  q_set_si(op2, OP1_, 1);
+  assert(op1 <= op2);
+end;
+
+// operator > (op1: MPFloat; op2: MPFloat): boolean;
+procedure TTestGmpOperators.gt__MPFloat__MPFloat_boolean;
+const
+  OP1_ = 1.2;
+  OP2_ = OP1_ - 1;
+var op1, op2: MPFloat;
+begin
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  assert(op1 > op2);
+end;
+
+// operator > (op1: MPInteger; op2: MPInteger): boolean;
+procedure TTestGmpOperators.gt__MPInteger__MPInteger_boolean;
+const
+  OP1_ = 12;
+  OP2_ = OP1_ - 1;
+var op1, op2: MPInteger;
+begin
+  z_init_set_d(op1, OP1_);
+  z_init_set_d(op2, OP2_);
+  assert(op1 > op2);
+end;
+
+// operator > (op1: MPRational; op2: MPRational): boolean;
+procedure TTestGmpOperators.gt__MPRational__MPRational_boolean;
+const
+  OP1_ = 12;
+  OP2_ = OP1_ - 1;
+var op1, op2: MPRational;
+begin
+  q_init(op1);
+  q_init(op2);
+  q_set_si(op1, OP1_, 1);
+  q_set_si(op2, OP2_, 1);
+  assert(op1 > op2);
+end;
+
+// operator >= (op1: MPFloat; op2: MPFloat): boolean;
+procedure TTestGmpOperators.ge__MPFloat__MPFloat_boolean;
+const
+  OP1_ = 1.2;
+  OP2_ = OP1_ - 1;
+var op1, op2: MPFloat;
+begin
+  f_init_set_d(op1, OP1_);
+  f_init_set_d(op2, OP2_);
+  assert(op1 >= op2);
+  f_set_d(op2, OP1_);
+  assert(op1 >= op2);
+end;
+
+// operator >= (op1: MPInteger; op2: MPInteger): boolean;
+procedure TTestGmpOperators.ge__MPInteger__MPInteger_boolean;
+const
+  OP1_ = 12;
+  OP2_ = OP1_ - 1;
+var op1, op2: MPInteger;
+begin
+  z_init_set_ui(op1, OP1_);
+  z_init_set_ui(op2, OP2_);
+  assert(op1 >= op2);
+  z_set_ui(op2, OP1_);
+  assert(op1 >= op2);
+end;
+
+// operator >= (op1: MPRational; op2: MPRational): boolean;
+procedure TTestGmpOperators.ge__MPRational__MPRational_boolean;
+const
+  OP1_ = 12;
+  OP2_ = OP1_ - 1;
+var op1, op2: MPRational;
+begin
+  q_init(op1);
+  q_init(op2);
+  q_set_si(op1, OP1_, 1);
+  q_set_si(op2, OP2_, 1);
+  assert(op1 >= op2);
+  q_set_si(op2, OP1_, 1);
+  assert(op1 >= op2);
+end;
+

packages/gmp/examples/gmp_test_intf.inc

@@ -0,0 +1,674 @@
+{ Note: This doesn't test GMP per se.
+
+  Not covered:
+    mp_printf
+    mp_scanf
+    mpz_array_init
+    errno
+}
+
+{$assertions on - keep this}
+
+type
+
+  { TTestGmpBinding }
+
+  TTestGmpBinding = class(TTestCase)
+  published
+    procedure mp_get_memory_functions_test;
+    procedure mp_set_memory_functions_test;
+
+    procedure mp_randinit_default_test;
+    procedure mp_randinit_mt_test;
+    procedure mp_randinit_lc_2exp_test;
+    procedure mp_randinit_lc_2exp_size_test;
+    procedure mp_randinit_set_test;
+    procedure mp_randclear_test;
+    procedure mp_randseed_test;
+    procedure mp_randseed_ui_test;
+    procedure mp_urandomb_ui_test;
+    procedure mp_urandomm_ui_test;
+
+    procedure mp_asprintf_test;
+    procedure mp_asprintf_test2;
+    procedure mp_snprintf_test;
+    procedure mp_snprintf_test2;
+    procedure mp_sprintf_test;
+    procedure mp_sprintf_test2;
+    procedure mp_sscanf_test;
+    procedure mp_sscanf_test2;
+
+    procedure mpz_init_test;
+    procedure mpz_clear_test;
+    procedure mpz_init2_test;
+    procedure mpz_init_set_si_test;
+    procedure mpz_init_set_ui_test;
+    procedure mpz_init_set_d_test;
+    procedure mpz_init_set_test;
+    procedure mpz_init_set_str_test;
+    procedure mpz_realloc_test;
+    procedure mpz_realloc2_test;
+    procedure mpz_getlimbn_test;
+    procedure mpz_export_test;
+    procedure mpz_import_test;
+    procedure mpz_swap_test;
+    procedure mpz_set_test;
+    procedure mpz_set_d_test;
+    procedure mpz_set_f_test;
+    procedure mpz_set_q_test;
+    procedure mpz_set_si_test;
+    procedure mpz_set_str_test;
+    procedure mpz_set_ui_test;
+    procedure mpz_get_d_test;
+    procedure mpz_get_d_2exp_test;
+    procedure mpz_get_si_test;
+    procedure mpz_get_str_test;
+    procedure mpz_get_ui_test;
+    procedure mpz_add_test;
+    procedure mpz_add_ui_test;
+    procedure mpz_sub_test;
+    procedure mpz_sub_ui_test;
+    procedure mpz_ui_sub_test;
+    procedure mpz_mul_test;
+    procedure mpz_mul_si_test;
+    procedure mpz_mul_ui_test;
+    procedure mpz_addmul_test;
+    procedure mpz_addmul_ui_test;
+    procedure mpz_submul_test;
+    procedure mpz_submul_ui_test;
+    procedure mpz_mul_2exp_test;
+    procedure mpz_neg_test;
+    procedure mpz_abs_test;
+
+    procedure mpz_cdiv_q_test;
+    procedure mpz_fdiv_q_test;
+    procedure mpz_tdiv_q_test;
+    procedure mpz_cdiv_q_2exp_test;
+    procedure mpz_fdiv_q_2exp_test;
+    procedure mpz_tdiv_q_2exp_test;
+    procedure mpz_cdiv_q_ui_test;
+    procedure mpz_fdiv_q_ui_test;
+    procedure mpz_tdiv_q_ui_test;
+    procedure mpz_cdiv_qr_test;
+    procedure mpz_fdiv_qr_test;
+    procedure mpz_tdiv_qr_test;
+    procedure mpz_cdiv_qr_ui_test;
+    procedure mpz_fdiv_qr_ui_test;
+    procedure mpz_tdiv_qr_ui_test;
+    procedure mpz_cdiv_r_test;
+    procedure mpz_fdiv_r_test;
+    procedure mpz_tdiv_r_test;
+    procedure mpz_cdiv_r_2exp_test;
+    procedure mpz_fdiv_r_2exp_test;
+    procedure mpz_tdiv_r_2exp_test;
+    procedure mpz_cdiv_r_ui_test;
+    procedure mpz_fdiv_r_ui_test;
+    procedure mpz_tdiv_r_ui_test;
+    procedure mpz_cdiv_ui_test;
+    procedure mpz_fdiv_ui_test;
+    procedure mpz_tdiv_ui_test;
+
+    procedure mpz_mod_test;
+    procedure mpz_divexact_test;
+    procedure mpz_divexact_ui_test;
+    procedure mpz_divisible_p_test;
+    procedure mpz_divisible_ui_p_test;
+    procedure mpz_divisible_2exp_p_test;
+    procedure mpz_congruent_p_test;
+    procedure mpz_congruent_2exp_p_test;
+    procedure mpz_congruent_ui_p_test;
+    procedure mpz_powm_test;
+    procedure mpz_powm_ui_test;
+    procedure mpz_pow_ui_test;
+    procedure mpz_ui_pow_ui_test;
+    procedure mpz_root_test;
+    procedure mpz_rootrem_test;
+    procedure mpz_sqrt_test;
+    procedure mpz_sqrtrem_test;
+    procedure mpz_perfect_power_p_test;
+    procedure mpz_perfect_square_p_test;
+
+    procedure mpz_probab_prime_p_test;
+    procedure mpz_nextprime_test;
+    procedure mpz_gcd_test;
+    procedure mpz_gcd_ui_test;
+    procedure mpz_gcdext_test;
+    procedure mpz_lcm_test;
+    procedure mpz_lcm_ui_test;
+    procedure mpz_invert_test;
+    procedure mpz_jacobi_test;
+    procedure mpz_kronecker_si_test;
+    procedure mpz_kronecker_ui_test;
+    procedure mpz_si_kronecker_test;
+    procedure mpz_ui_kronecker_test;
+    procedure mpz_remove_test;
+    procedure mpz_fac_ui_test;
+    procedure mpz_bin_ui_test;
+    procedure mpz_bin_uiui_test;
+    procedure mpz_fib_ui_test;
+    procedure mpz_fib2_ui_test;
+    procedure mpz_lucnum_ui_test;
+    procedure mpz_lucnum2_ui_test;
+
+    procedure mpz_cmp_test;
+    procedure mpz_cmp_d_test;
+    procedure mpz_cmp_si_test;
+    procedure mpz_cmp_ui_test;
+    procedure mpz_cmpabs_test;
+    procedure mpz_cmpabs_d_test;
+    procedure mpz_cmpabs_ui_test;
+
+    procedure mpz_and_test;
+    procedure mpz_ior_test;
+    procedure mpz_xor_test;
+    procedure mpz_com_test;
+    procedure mpz_popcount_test;
+    procedure mpz_hamdist_test;
+    procedure mpz_scan0_test;
+    procedure mpz_scan1_test;
+    procedure mpz_setbit_test;
+    procedure mpz_clrbit_test;
+    procedure mpz_combit_test;
+    procedure mpz_tstbit_test;
+
+    procedure mpz_urandomb_test;
+    procedure mpz_urandomm_test;
+    procedure mpz_rrandomb_test;
+
+    procedure mpz_fits_ushort_p_test;
+    procedure mpz_fits_sshort_p_test;
+    procedure mpz_fits_uint_p_test;
+    procedure mpz_fits_sint_p_test;
+    procedure mpz_fits_ulong_p_test;
+    procedure mpz_fits_slong_p_test;
+    procedure mpz_sizeinbase_test;
+    procedure mpz_size_test;
+
+    procedure mpq_init_test;
+    procedure mpq_clear_test;
+    procedure mpq_set_ui_test;
+    procedure mpq_set_si_test;
+    procedure mpq_canonicalize_test;
+    procedure mpq_set_test;
+    procedure mpq_setmpz_test;
+    procedure mpq_set_str_test;
+    procedure mpq_swap_test;
+
+    procedure mpq_get_d_test;
+    procedure mpq_set_d_test;
+    procedure mpq_set_f_test;
+    procedure mpq_get_str_test;
+
+    procedure mpq_add_test;
+    procedure mpq_sub_test;
+    procedure mpq_mul_test;
+    procedure mpq_mul_2exp_test;
+    procedure mpq_div_test;
+    procedure mpq_div_2exp_test;
+    procedure mpq_neg_test;
+    procedure mpq_abs_test;
+    procedure mpq_inv_test;
+
+    procedure mpq_cmp_test;
+    procedure mpq_cmp_si_test;
+    procedure mpq_cmp_ui_test;
+    procedure mpq_equal_test;
+
+    procedure mpq_get_num_test;
+    procedure mpq_get_den_test;
+    procedure mpq_set_num_test;
+    procedure mpq_set_den_test;
+
+    procedure mpf_get_default_prec_test;
+    procedure mpf_set_default_prec_test;
+
+    procedure mpf_init_test;
+    procedure mpf_init2_test;
+    procedure mpf_clear_test;
+    procedure mpf_get_prec_test;
+    procedure mpf_set_prec_test;
+    procedure mpf_set_prec_raw_test;
+
+    procedure mpf_set_q_test;
+    procedure mpf_set_ui_test;
+    procedure mpf_get_ui_test;
+    procedure mpf_set_si_test;
+    procedure mpf_get_si_test;
+    procedure mpf_set_test;
+    procedure mpf_set_str_test;
+    procedure mpf_swap_test;
+
+    procedure mpf_get_d_test;
+    procedure mpf_set_d_test;
+    procedure mpf_setmpz_test;
+    procedure mpf_get_d_2exp_test;
+    procedure mpf_get_str_test;
+
+    procedure mpf_add_test;
+    procedure mpf_add_ui_test;
+    procedure mpf_sub_test;
+    procedure mpf_sub_ui_test;
+    procedure mpf_ui_sub_test;
+    procedure mpf_mul_test;
+    procedure mpf_mul_ui_test;
+    procedure mpf_mul_2exp_test;
+    procedure mpf_div_test;
+    procedure mpf_div_ui_test;
+    procedure mpf_ui_div_test;
+    procedure mpf_div_2exp_test;
+    procedure mpf_sqrt_test;
+    procedure mpf_sqrt_ui_test;
+    procedure mpf_pow_ui_test;
+    procedure mpf_neg_test;
+    procedure mpf_abs_test;
+
+    procedure mpf_cmp_test;
+    procedure mpf_cmp_d_test;
+    procedure mpf_cmp_si_test;
+    procedure mpf_cmp_ui_test;
+    procedure mpf_eq_test;
+    procedure mpf_reldiff_test;
+
+    procedure mpf_ceil_test;
+    procedure mpf_floor_test;
+    procedure mpf_trunc_test;
+    procedure mpf_integer_p_test;
+
+    procedure mpf_fits_ushort_p_test;
+    procedure mpf_fits_sshort_p_test;
+    procedure mpf_fits_uint_p_test;
+    procedure mpf_fits_sint_p_test;
+    procedure mpf_fits_ulong_p_test;
+    procedure mpf_fits_slong_p_test;
+
+    procedure mpf_urandomb_test;
+    procedure mpf_random2_test;
+
+    procedure mpf_init_set_test;
+    procedure mpf_init_set_d_test;
+    procedure mpf_init_set_si_test;
+    procedure mpf_init_set_str_test;
+    procedure mpf_init_set_ui_test;
+
+    procedure mpn_add_n_test;
+    procedure mpn_add_1_test;
+    procedure mpn_add_test;
+    procedure mpn_sub_n_test;
+    procedure mpn_sub_1_test;
+    procedure mpn_sub_test;
+    procedure mpn_mul_n_test;
+    procedure mpn_mul_1_test;
+    procedure mpn_mul_test;
+    procedure mpn_addmul_1_test;
+    procedure mpn_submul_1_test;
+    procedure mpn_tdiv_qr_test;
+    procedure mpn_divrem_1_test;
+    procedure mpn_divexact_by3c_test;
+    procedure mpn_mod_1_test;
+    procedure mpn_lshift_test;
+    procedure mpn_rshift_test;
+    procedure mpn_cmp_test;
+    procedure mpn_gcd_test;
+    procedure mpn_gcd_1_test;
+    procedure mpn_gcdext_test;
+    procedure mpn_sqrtrem_test;
+    procedure mpn_get_str_test;
+    procedure mpn_set_str_test;
+    procedure mpn_scan0_test;
+    procedure mpn_scan1_test;
+    procedure mpn_popcount_test;
+    procedure mpn_hamdist_test;
+    procedure mpn_perfect_square_p_test;
+
+    procedure mpn_random_test;
+    procedure mpn_random2_test;
+
+    procedure bits_per_limb_test;
+    procedure version_test;
+
+  end;
+
+  { TTestGmpExtensions }
+
+  TTestGmpExtensions = class(TTestCase)
+  published
+
+    procedure randinit_default_test;
+    procedure randinit_mt_test;
+    procedure randinit_lc_2exp_test;
+    procedure randinit_lc_2exp_size_test;
+    procedure randinit_set_test;
+    procedure randclear_test;
+    procedure randseed_test;
+    procedure randseed_ui_test;
+    procedure urandomb_ui_test;
+    procedure urandomm_ui_test;
+
+    procedure z_init_test;
+    procedure z_clear_test;
+    procedure z_init2_test;
+    procedure z_init_set_si_test;
+    procedure z_init_set_ui_test;
+    procedure z_init_set_d_test;
+    procedure z_init_set_test;
+    procedure z_init_set_str_test;
+    procedure z_realloc_test;
+    procedure z_realloc2_test;
+    procedure z_getlimbn_test;
+    procedure z_export_test;
+    procedure z_import_test;
+    procedure z_swap_test;
+    procedure z_set_test;
+    procedure z_set_d_test;
+    procedure z_set_f_test;
+    procedure z_set_q_test;
+    procedure z_set_si_test;
+    procedure z_set_str_test;
+    procedure z_set_ui_test;
+    procedure z_get_d_test;
+    procedure z_get_d_2exp_test;
+    procedure z_get_si_test;
+    procedure z_get_str_test;
+    procedure z_get_ui_test;
+    procedure z_add_test;
+    procedure z_add_ui_test;
+    procedure z_sub_test;
+    procedure z_sub_ui_test;
+    procedure z_ui_sub_test;
+    procedure z_mul_test;
+    procedure z_mul_si_test;
+    procedure z_mul_ui_test;
+    procedure z_addmul_test;
+    procedure z_addmul_ui_test;
+    procedure z_submul_test;
+    procedure z_submul_ui_test;
+    procedure z_mul_2exp_test;
+    procedure z_neg_test;
+    procedure z_abs_test;
+
+    procedure z_cdiv_q_test;
+    procedure z_fdiv_q_test;
+    procedure z_tdiv_q_test;
+    procedure z_cdiv_q_2exp_test;
+    procedure z_fdiv_q_2exp_test;
+    procedure z_tdiv_q_2exp_test;
+    procedure z_cdiv_q_ui_test;
+    procedure z_fdiv_q_ui_test;
+    procedure z_tdiv_q_ui_test;
+    procedure z_cdiv_qr_test;
+    procedure z_fdiv_qr_test;
+    procedure z_tdiv_qr_test;
+    procedure z_cdiv_qr_ui_test;
+    procedure z_fdiv_qr_ui_test;
+    procedure z_tdiv_qr_ui_test;
+    procedure z_cdiv_r_test;
+    procedure z_fdiv_r_test;
+    procedure z_tdiv_r_test;
+    procedure z_cdiv_r_2exp_test;
+    procedure z_fdiv_r_2exp_test;
+    procedure z_tdiv_r_2exp_test;
+    procedure z_cdiv_r_ui_test;
+    procedure z_fdiv_r_ui_test;
+    procedure z_tdiv_r_ui_test;
+    procedure z_cdiv_ui_test;
+    procedure z_fdiv_ui_test;
+    procedure z_tdiv_ui_test;
+
+    procedure z_mod_test;
+    procedure z_divexact_test;
+    procedure z_divexact_ui_test;
+    procedure z_divisible_p_test;
+    procedure z_divisible_ui_p_test;
+    procedure z_divisible_2exp_p_test;
+    procedure z_congruent_p_test;
+    procedure z_congruent_2exp_p_test;
+    procedure z_congruent_ui_p_test;
+    procedure z_powm_test;
+    procedure z_powm_ui_test;
+    procedure z_pow_ui_test;
+    procedure z_ui_pow_ui_test;
+    procedure z_root_test;
+    procedure z_rootrem_test;
+    procedure z_sqrt_test;
+    procedure z_sqrtrem_test;
+    procedure z_perfect_power_p_test;
+    procedure z_perfect_square_p_test;
+
+    procedure z_probab_prime_p_test;
+    procedure z_nextprime_test;
+    procedure z_gcd_test;
+    procedure z_gcd_ui_test;
+    procedure z_gcdext_test;
+    procedure z_lcm_test;
+    procedure z_lcm_ui_test;
+    procedure z_invert_test;
+    procedure z_jacobi_test;
+    procedure z_kronecker_si_test;
+    procedure z_kronecker_ui_test;
+    procedure z_si_kronecker_test;
+    procedure z_ui_kronecker_test;
+    procedure z_remove_test;
+    procedure z_fac_ui_test;
+    procedure z_bin_ui_test;
+    procedure z_bin_uiui_test;
+    procedure z_fib_ui_test;
+    procedure z_fib2_ui_test;
+    procedure z_lucnum_ui_test;
+    procedure z_lucnum2_ui_test;
+
+    procedure z_cmp_test;
+    procedure z_cmp_d_test;
+    procedure z_cmp_si_test;
+    procedure z_cmp_ui_test;
+    procedure z_cmpabs_test;
+    procedure z_cmpabs_d_test;
+    procedure z_cmpabs_ui_test;
+
+    procedure z_and_test;
+    procedure z_ior_test;
+    procedure z_xor_test;
+    procedure z_com_test;
+    procedure z_popcount_test;
+    procedure z_hamdist_test;
+    procedure z_scan0_test;
+    procedure z_scan1_test;
+    procedure z_setbit_test;
+    procedure z_clrbit_test;
+    procedure z_combit_test;
+    procedure z_tstbit_test;
+
+    procedure z_urandomb_test;
+    procedure z_urandomm_test;
+    procedure z_rrandomb_test;
+
+    procedure z_fits_ushort_p_test;
+    procedure z_fits_sshort_p_test;
+    procedure z_fits_uint_p_test;
+    procedure z_fits_sint_p_test;
+    procedure z_fits_ulong_p_test;
+    procedure z_fits_slong_p_test;
+    procedure z_sizeinbase_test;
+    procedure z_size_test;
+
+    procedure q_init_test;
+    procedure q_clear_test;
+    procedure q_set_ui_test;
+    procedure q_set_si_test;
+    procedure q_canonicalize_test;
+    procedure q_set_test;
+    procedure q_set_z_test;
+    procedure q_set_str_test;
+    procedure q_swap_test;
+
+    procedure q_get_d_test;
+    procedure q_set_d_test;
+    procedure q_set_f_test;
+    procedure q_get_str_test;
+
+    procedure q_add_test;
+    procedure q_sub_test;
+    procedure q_mul_test;
+    procedure q_mul_2exp_test;
+    procedure q_div_test;
+    procedure q_div_2exp_test;
+    procedure q_neg_test;
+    procedure q_abs_test;
+    procedure q_inv_test;
+
+    procedure q_cmp_test;
+    procedure q_cmp_si_test;
+    procedure q_cmp_ui_test;
+    procedure q_equal_test;
+
+    procedure q_get_num_test;
+    procedure q_get_den_test;
+    procedure q_set_num_test;
+    procedure q_set_den_test;
+
+    procedure f_get_default_prec_test;
+    procedure f_set_default_prec_test;
+
+    procedure f_init_test;
+    procedure f_init2_test;
+    procedure f_clear_test;
+    procedure f_get_prec_test;
+    procedure f_set_prec_test;
+    procedure f_set_prec_raw_test;
+
+    procedure f_set_q_test;
+    procedure f_set_ui_test;
+    procedure f_get_ui_test;
+    procedure f_set_si_test;
+    procedure f_get_si_test;
+    procedure f_set_test;
+    procedure f_set_str_test;
+    procedure f_swap_test;
+
+    procedure f_get_d_test;
+    procedure f_set_d_test;
+    procedure f_set_z_test;
+    procedure f_get_d_2exp_test;
+    procedure f_get_str_test;
+
+    procedure f_add_test;
+    procedure f_add_ui_test;
+    procedure f_sub_test;
+    procedure f_sub_ui_test;
+    procedure f_ui_sub_test;
+    procedure f_mul_test;
+    procedure f_mul_ui_test;
+    procedure f_mul_2exp_test;
+    procedure f_div_test;
+    procedure f_div_ui_test;
+    procedure f_ui_div_test;
+    procedure f_div_2exp_test;
+    procedure f_sqrt_test;
+    procedure f_sqrt_ui_test;
+    procedure f_pow_ui_test;
+    procedure f_neg_test;
+    procedure f_abs_test;
+
+    procedure f_cmp_test;
+    procedure f_cmp_d_test;
+    procedure f_cmp_si_test;
+    procedure f_cmp_ui_test;
+    procedure f_eq_test;
+    procedure f_reldiff_test;
+
+    procedure f_ceil_test;
+    procedure f_floor_test;
+    procedure f_trunc_test;
+    procedure f_integer_p_test;
+
+    procedure f_fits_ushort_p_test;
+    procedure f_fits_sshort_p_test;
+    procedure f_fits_uint_p_test;
+    procedure f_fits_sint_p_test;
+    procedure f_fits_ulong_p_test;
+    procedure f_fits_slong_p_test;
+
+    procedure f_urandomb_test;
+    procedure f_random2_test;
+
+    procedure f_init_set_test;
+    procedure f_init_set_d_test;
+    procedure f_init_set_si_test;
+    procedure f_init_set_str_test;
+    procedure f_init_set_ui_test;
+
+  end;
+
+  { TTestGmpOperators }
+
+  TTestGmpOperators = class(TTestCase)
+    procedure star__MPFloat__MPFloat__MPFloat_;
+    procedure star__MPInteger__MPInteger__MPInteger_;
+    procedure star__MPRational__MPRational__MPRational_;
+    procedure pow__MPFloat_valuint_MPFloat_;
+    procedure pow__MPInteger_valuint_MPInteger_;
+    procedure plus__MPFloat__MPFloat__MPFloat_;
+    procedure plus__MPInteger__MPInteger__MPInteger_;
+    procedure plus__MPRational__MPRational__MPRational_;
+    procedure minus__MPFloat__MPFloat_;
+    procedure minus__MPInteger__MPInteger_;
+    procedure minus__MPRational__MPRational_;
+    procedure minus__MPFloat__MPFloat__MPFloat_;
+    procedure minus__MPInteger__MPInteger__MPInteger_;
+    procedure minus__MPRational__MPRational__MPRational_;
+    procedure slash__MPFloat__MPFloat__MPFloat_;
+    procedure slash__MPInteger__MPInteger__MPInteger_;
+    procedure slash__MPRational__MPRational__MPRational_;
+    procedure assign_double_MPFloat_;
+    procedure assign_double_MPInteger_;
+    procedure assign_double_MPRational_;
+    procedure assign__MPFloat_Cardinal;
+    procedure assign__MPFloat_double;
+    procedure assign__MPFloat_integer;
+    procedure assign__MPFloat_mpf_t;
+    procedure assign__MPFloat__MPInteger_;
+    procedure assign__MPFloat__MPRational_;
+    procedure assign__MPFloat_string;
+    procedure assign__MPFloat_valsint;
+    procedure assign__MPFloat_valuint;
+    procedure assign_mpf_t_MPFloat_;
+    procedure assign__MPInteger_cardinal;
+    procedure assign__MPInteger_double;
+    procedure assign__MPInteger_integer;
+    procedure assign__MPInteger__MPFloat_;
+    procedure assign__MPInteger__MPRational_;
+    procedure assign__MPInteger_mpz_t;
+    procedure assign__MPInteger_string;
+    procedure assign__MPInteger_valsint;
+    procedure assign__MPInteger_valuint;
+    procedure assign_mpq_t_MPRational_;
+    procedure assign__MPRandState_randstate_t;
+    procedure assign__MPRational_double;
+    procedure assign__MPRational__MPFloat_;
+    procedure assign__MPRational__MPInteger_;
+    procedure assign__MPRational_mpq_t;
+    procedure assign__MPRational_string;
+    procedure assign_mpz_t_MPInteger_;
+    procedure assign_randstate_t_MPRandState_;
+    procedure assign_string_MPFloat_;
+    procedure assign_string_MPInteger_;
+    procedure assign_string_MPRational_;
+    procedure assign_valsint_MPFloat_;
+    procedure assign_valsint_MPInteger_;
+    procedure assign_valsint_MPRational_;
+    procedure assign_valuint_MPFloat_;
+    procedure assign_valuint_MPInteger_;
+    procedure assign_valuint_MPRational_;
+    procedure lt__MPFloat__MPFloat_boolean;
+    procedure lt__MPInteger__MPInteger_boolean;
+    procedure lt__MPRational__MPRational_boolean;
+    procedure le__MPFloat__MPFloat_boolean;
+    procedure le__MPInteger__MPInteger_boolean;
+    procedure le__MPRational__MPRational_boolean;
+    procedure gt__MPFloat__MPFloat_boolean;
+    procedure gt__MPInteger__MPInteger_boolean;
+    procedure gt__MPRational__MPRational_boolean;
+    procedure ge__MPFloat__MPFloat_boolean;
+    procedure ge__MPInteger__MPInteger_boolean;
+    procedure ge__MPRational__MPRational_boolean;
+  end;
+

packages/gmp/examples/gmp_testcase.pas

@@ -0,0 +1,23 @@
+unit gmp_testcase;
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  Classes, SysUtils, fpcunit, testregistry;
+
+{$include gmp_test_intf}
+
+implementation
+
+uses
+  math, strutils, gmp;
+
+{$include gmp_test_impl}
+
+initialization
+  RegisterTests([TTestGmpBinding, TTestGmpExtensions, TTestGmpOperators]);
+
+end.
+

packages/gmp/examples/pidigits_example.pas

@@ -0,0 +1,106 @@
+{ The Computer Language Benchmarks Game
+  http://shootout.alioth.debian.org
+
+  contributed by Vincent Snijders
+  gmp headers by Karl-Michael Schindler
+}
+
+{$mode objfpc}
+
+program pidigits_example;
+
+uses
+  gmp;
+
+procedure PrintPiDigits(NumDigits: integer);
+var
+  q, r, s, t: mpz_t; // Transformation matrix components.
+  u, v, w: mpz_t; // Temporary variables
+  i, k, digit, c: integer;
+  line: string[10];
+
+  function Extract(x:cardinal): integer;
+  begin
+    mpz_mul_ui(u, q, x);
+    mpz_add(u, u, r);
+    mpz_mul_ui(v, s, x);
+    mpz_add(v, v, t);
+    mpz_tdiv_q(w, u, v);
+    result := mpz_get_ui(w);
+  end;
+
+  function IsSafe: boolean;
+  begin
+    result := digit = Extract(4);
+  end;
+
+  procedure Produce;
+  begin
+    mpz_mul_si(r, r, 10);
+    mpz_mul_si(v, t, -10 * digit);
+    mpz_add(r, r, v);
+    mpz_mul_si(q, q, 10);
+  end;
+
+  procedure Consume;
+  begin
+    inc(k);
+    mpz_mul_si(r, r, 2*k+1);
+    mpz_mul_si(u, q, 4*k+2);
+    mpz_add(r, r, u);
+    mpz_mul_si(t, t, 2*k+1);
+    mpz_mul_si(v, s, 4*k+2);
+    mpz_add(t, t, v);
+    mpz_mul_si(s, s, k);
+    mpz_mul_si(q, q, k);
+  end;
+
+begin
+  k := 0;
+  i := 0;
+  c := 0;
+  setlength(line, 10);
+  mpz_init_set_ui(q, 1);
+  mpz_init_set_ui(r, 0);
+  mpz_init_set_ui(s, 0);
+  mpz_init_set_ui(t, 1);
+  mpz_init(u);
+  mpz_init(v);
+  mpz_init(w);
+  while (i < NumDigits) do begin
+    digit := Extract(3);
+    while not IsSafe do begin
+      Consume;
+      digit:= Extract(3);
+    end;
+    Produce;
+    inc(c);
+    line[c] := chr(ord('0') + digit);
+    inc(i);
+    if c = 10 then begin
+      writeln(line, #9':', i);
+      c := 0;
+    end;
+  end;
+  if c <> 0 then begin
+    SetLength(line, c);
+    writeln(line);
+  end;
+  mpz_clear(q);
+  mpz_clear(r);
+  mpz_clear(s);
+  mpz_clear(t);
+  mpz_clear(u);
+  mpz_clear(v);
+  mpz_clear(w);
+end;
+
+var
+  n: integer = 27;
+
+begin
+  if (ParamCount = 1) then
+    val(ParamStr(1), n);
+  PrintPiDigits(n);
+end.
+

packages/gmp/examples/pidigits_example2.pas

@@ -0,0 +1,84 @@
+{ The Computer Language Benchmarks Game
+  http://shootout.alioth.debian.org
+
+  contributed by Vincent Snijders
+  gmp headers by Karl-Michael Schindler
+}
+
+{$mode objfpc}
+
+program pidigits_example2;
+
+uses
+  gmp;
+
+procedure PrintPiDigits(NumDigits: integer);
+var
+  q, r, s, t: MPInteger;  // Transformation matrix components.
+  i, k, digit, c: integer;
+  line: string[10];
+
+  function Extract(x: cardinal): integer;
+  begin
+    result := (q * x + r) / (s * x + t);
+  end;
+
+  function IsSafe: boolean;
+  begin
+    result := digit = Extract(4);
+  end;
+
+  procedure Produce;
+  begin
+    r := 10 * (r - t * digit);
+    q *= 10;
+  end;
+
+  procedure Consume;
+  begin
+    inc(k);
+    r := r * (2 * k + 1) + q * (4 * k + 2);
+    t := t * (2 * k + 1) + s * (4 * k + 2);
+    s *= k;
+    q *= k;
+  end;
+
+begin
+  k := 0;
+  i := 0;
+  c := 0;
+  setlength(line, 10);
+  q := 1;
+  r := 0;
+  s := 0;
+  t := 1;
+  while (i < NumDigits) do begin
+    digit := Extract(3);
+    while not IsSafe do begin
+      Consume;
+      digit := Extract(3);
+    end;
+    Produce;
+    inc(c);
+    line[c] := chr(ord('0') + digit);
+    inc(i);
+    if c = 10 then begin
+      writeln(line, #9':', i);
+      c := 0;
+    end;
+  end;
+  if c <> 0 then begin
+    SetLength(line, c);
+    writeln(line);
+  end;
+end;
+
+var
+  n: integer = 27;
+
+begin
+  if (ParamCount = 1) then
+    val(ParamStr(1), n);
+  PrintPiDigits(n);
+end.
+

packages/gmp/examples/printf_example.pas

@@ -0,0 +1,27 @@
+program printf_example;
+
+{$mode objfpc}{$H+}
+
+uses
+  math, gmp;
+
+const
+  N = 2;
+  NBITS = 100;
+
+var
+  f: mpf_t;
+  bits, digits: integer;
+begin
+  mpf_init2(f, NBITS);
+  bits := mpf_get_prec(f);
+  digits := floor(bits * LOG_10_2);
+  mpf_sqrt_ui(f, N);
+  mp_printf('Sqrt(%d) to %d digits (%d bits) = %.*Fg'#10, N, digits, bits, digits, @f);
+  mpf_pow_ui(f, f, 2);
+  mp_printf('Squared back = %.*Fg'#10, digits, @f);
+  mpf_sub_ui(f, f, N);
+  mp_printf('Minus %d = %.*Fg'#10, N, digits, @f);
+  mpf_clear(f);
+end.
+

packages/gmp/examples/printf_example2.pas

@@ -0,0 +1,26 @@
+program printf_example2;
+
+{$mode objfpc}{$H+}
+
+uses
+  sysutils, math, gmp;
+
+const
+  N = 2;
+  NBITS = 100;
+
+var
+  f: mpfloat;
+  bits, digits: integer;
+begin
+  f_set_default_prec(NBITS);
+  bits := f_get_default_prec;
+  digits := floor(bits * LOG_10_2);
+  f := f_sqrt_ui(N);
+  writeln(format('Sqrt(%d) to %d digits (%d bits) = %s', [N, digits, bits, string(f)]));
+  f := f ** 2;
+  writeln(format('Squared back = %s', [string(f)]));
+  f -= N;
+  writeln(format('Minus %d = %s', [N, string(f)]));
+end.
+

packages/gmp/examples/scanf_example.pas

@@ -0,0 +1,22 @@
+program scanf_example;
+
+{$mode objfpc}{$H+}
+
+uses
+  gmp;
+
+var n, sqr: mpz_t;
+
+begin
+  mpz_init(n);
+  mpz_init(sqr);
+  write('Please enter an integer of any length: ');
+  if mp_scanf('%Zd', @n) = 1 then begin
+    mpz_pow_ui(sqr, n, 2);
+    mp_printf('%Zd^2 = %Zd'#10, @n, @sqr);
+  end else
+    writeln('Failed to parse an integer from your input');
+  mpz_clear(sqr);
+  mpz_clear(n);
+end.
+

packages/gmp/examples/scanf_example2.pas

@@ -0,0 +1,21 @@
+program scanf_example2;
+
+{$mode objfpc}{$H+}
+
+uses
+  sysutils, gmp;
+
+var
+  n, sqr: MPInteger;
+  s: string;
+begin
+  write('Please enter an integer of any length: ');
+  readln(s);
+  z_init(n);
+  if mp_sscanf(pchar(s), '%Zd', n.ptr) = 1 then begin
+    sqr := n ** 2;
+    writeln(format('%s^2 = %s', [string(n), string(sqr)]));
+  end else
+    writeln('Failed to parse an integer from your input');
+end.
+

packages/gmp/readme

@@ -0,0 +1,83 @@
+Readme for libgmp.tar.bz2 2009-09-06
+
+= What
+
+  Free Pascal interface for the GNU Multiple Precision Arithmetic Library.
+
+= Why
+
+  Numeric computing outside the built in types range. AFAIK there is no complete
+  binding for Free Pascal available yet.
+
+= Files
+
+  - gmp_accept_test.pas
+    "Go/no go" test of the gmp unit against the GMP library on your system.
+
+  - gmp.pas
+    The interface unit.
+
+  - gmp_testcase.pas
+    Put this unit in your uses clause of a fpcunit project.
+
+  - gmp_test_impl.inc
+  - gmp_test_intf.inc
+    Test classes declarations and implementations. Included by:
+    * gmp_accept_test.pas
+    * gmp_testcase
+
+  - pidigits_example.pas
+    Original source from:
+    shootout.alioth.debian.org/u64/benchmark.php?test=pidigits&lang=fpascal&id=2
+    Adapted for using the gmp unit.
+
+  - pidigits_example2.pas
+    Modified pidigits_example.pas to demonstrate usage of the gmp extensions.
+
+  - printf_example.pas
+    Demo using the GMP printf
+
+  - printf_example2.pas
+    Dtto with gmp extensions.
+
+  - scanf_example.pas
+    Demo using the GMP scanf.
+
+  - scanf_example2.pas
+    Dtto with gmp extensions.
+
+= Status
+  - Tested on 64 and 32 bit Linux and on 32 bit Windows.
+  - Known issues
+    * There is a link error on Windows with the GMP global variables.
+      Probably could be solved with someone's better knowledge of the Windows
+      environment.
+
+= Bindings
+  - Standard
+    * Almost full (see comments in gmp.pas) binding of the types and functions
+      exported from libgmp.
+
+  - Extensions
+    * Based on pseudo value types (in fact interface types) with an automatic
+      memory management in the spirit of Object Pascal strings - compiler takes
+      care of initialization/finalization. Copy on write semantics. Can intermix
+      the standard binding/types with the extended ones. The extended types have
+      access to a same set of numeric functions as in the standard binding.
+
+  - Operators
+    * Overloaded operators for the extensions value types. Can make programs
+      significantly more readable/maintainable. See and compare for yourself
+      in the pidigits examples. BTW, the overhead in this example with
+      the extended types and operators is less than 10%. Unusable for shootout,
+      but is probably acceptable in many other areas.
+
+= Tips
+  - range checks
+    You should probably want to put asserts with *_fits before conversion to
+    FPC ordinal types - applies to the assignment operator too.
+
+= License
+  - FPC developers, you can do anything you see appropriate with the sources.
+    Review, refactor and/or reject :-)
+

packages/gmp/src/gmp.pas

@@ -0,0 +1,3819 @@
+{
+    This file is part of the Free Pascal packages
+    Copyright (c) 2009 by the Free Pascal development team
+
+    An header for the GMP library
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright. (LGPL)
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+}
+
+unit gmp;
+
+{$mode objfpc}{$h+}
+{$packrecords c}
+
+//todo:windows link error on GMP global vars, reason not yet known
+{$ifdef windows}
+{$define NO_GMP_GLOBVARS}
+{$endif}
+
+{ Unused symbols exported from GMP:
+
+  Marked preliminary in GMP manual
+    __gmpn_bdivmod
+
+  Marked obsolete in GMP manual
+    __gmpn_divrem
+    __gmpz_random
+    __gmpz_random2
+    __gmp_randinit
+
+  Not documented in GMP manual
+    __gmpf_size
+    __gmpn_divrem_2
+    __gmpn_pow_1
+    __gmpn_preinv_mod_1
+    __gmpz_millerrabin
+
+  Marked for use only within GDB
+    __gmpf_dump
+    __gmpz_dump
+}
+
+interface
+
+uses
+  sysutils;
+
+const
+  BASE10 = 10;
+  LIB = 'gmp';
+  LOG_10_2 = 0.3010299956639812;
+  ERROR_NONE = 0;
+  ERROR_UNSUPPORTED_ARGUMENT = 1;
+  ERROR_DIVISION_BY_ZERO = 2;
+  ERROR_SQRT_OF_NEGATIVE = 4;
+  ERROR_INVALID_ARGUMENT = 8;
+  RAND_ALG_DEFAULT = 0;
+  RAND_ALG_LC = RAND_ALG_DEFAULT;
+
+type
+
+  // ---- GMP types ----
+
+  { low level multi precision integer atom = machine size uint }
+  mp_limb_t = valuint;
+  { ^array of mp_limb_t}
+  mpn_ptr = ^mp_limb_t;
+  mp_size_t = sizeint;
+  mp_exp_t = valsint;
+  randalg_t = longint;
+
+  { multi precision integer number record }
+  mpz_t = record
+    alloc: longint;
+    size: longint;
+    data: mpn_ptr;
+  end;
+  mpz_ptr = ^mpz_t;
+
+  { multi precision rational number record }
+  mpq_t = record
+    num: mpz_t;
+    den: mpz_t;
+  end;
+  mpq_ptr = ^mpq_t;
+
+  { multi precision real number record }
+  mpf_t = record
+    prec: longint;
+    size: longint;
+    exp: mp_exp_t;
+    data: mpn_ptr;
+  end;
+  mpf_ptr = ^mpf_t;
+
+  randstate_t = record
+    seed: mpz_t;
+    alg: randalg_t;
+    algdata: record
+      case longint of
+        0 : (lc : pointer);
+    end;
+  end;
+  randstate_ptr = ^randstate_t;
+
+  { Return a pointer to newly allocated space with at least alloc size bytes }
+  alloc_func_t = function(alloc_size: sizeuint): pointer; cdecl;
+  { Resize a previously allocated block ptr of old size bytes to be new size bytes }
+  reallocate_func_t = function(p: pointer; old_size, new_size: sizeuint): pointer; cdecl;
+  { De-allocate the space pointed to by ptr }
+  free_proc_t = procedure(p: pointer; size: sizeuint); cdecl;
+  palloc_func = ^alloc_func_t;
+  preallocate_func = ^reallocate_func_t;
+  pfree_proc = ^free_proc_t;
+
+  // ---- ext types with automatic mem mngmt & cow, ~ fpc string type style -----
+
+  IMPBase = interface
+    function refs: longint;
+  end;
+
+  MPInteger = interface(IMPBase)
+    function ptr: mpz_ptr;
+  end;
+
+  MPFloat = interface(IMPBase)
+    function ptr: mpf_ptr;
+  end;
+
+  MPRational = interface(IMPBase)
+    function ptr: mpq_ptr;
+  end;
+
+  MPRandState = interface(IMPBase)
+    function ptr: randstate_ptr;
+  end;
+
+  { TMPBase }
+
+  TMPBase = class(TInterfacedObject, IMPBase)
+  private
+    function refs: longint;  inline;
+  end;
+
+  { TMPInteger }
+
+  TMPInteger = class(TMPBase, MPInteger)
+  private
+    fmpz: mpz_t;
+    function ptr: mpz_ptr;  inline;
+  public
+    destructor destroy; override;
+  end;
+
+  { TMPFloat }
+
+  TMPFloat = class(TMPBase, MPFloat)
+  private
+    fmpf: mpf_t;
+    function ptr: mpf_ptr;  inline;
+  public
+    destructor destroy; override;
+  end;
+
+  { TMPRational }
+
+  TMPRational = class(TMPBase, MPRational)
+  private
+    fmpq: mpq_t;
+    function ptr: mpq_ptr;  inline;
+  public
+    destructor destroy; override;
+  end;
+
+  { TMPRandState }
+
+  TMPRandState = class(TMPBase, MPRandState)
+  private
+    frandstate: randstate_t;
+    function ptr: randstate_ptr;  inline;
+  public
+    destructor destroy; override;
+  end;
+
+// ==== GMP bindings ====
+
+// ---- Custom Allocation ----
+
+{ Replace the current allocation functions from the arguments }
+procedure mp_set_memory_functions(alloc_func_ptr: alloc_func_t; realloc_func_ptr: reallocate_func_t; free_func_ptr: free_proc_t); cdecl; external LIB name '__gmp_set_memory_functions';
+{ Get the current allocation functions, storing function pointers to the locations given by the arguments }
+procedure mp_get_memory_functions(alloc_func_ptr: palloc_func; realloc_func_ptr: preallocate_func; free_func_ptr: pfree_proc); cdecl; external LIB name '__gmp_get_memory_functions';
+
+// ---- Random Number Functions ----
+
+{ Obsolete: Initialize state with an algorithm selected by alg }
+// procedure randinit(var state: randstate_t; alg: randalg_t; args: array of const); cdecl; external LIB name '__gmp_randinit';
+
+{ Initialize state with a default algorithm }
+procedure mp_randinit_default(out state: randstate_t); cdecl; external LIB name '__gmp_randinit_default';
+{ Initialize state with a linear congruential algorithm X = (aX + c) mod 2^m2exp }
+procedure mp_randinit_lc_2exp(out state: randstate_t; var a: mpz_t; c, m2exp: valuint); cdecl; external LIB name '__gmp_randinit_lc_2exp';
+{ Initialize state for a linear congruential algorithm as per gmp_randinit_lc_2exp }
+function mp_randinit_lc_2exp_size(out state: randstate_t; size: sizeuint): longint; cdecl; external LIB name '__gmp_randinit_lc_2exp_size';
+{ Initialize state for a Mersenne Twister algorithm }
+procedure mp_randinit_mt(out state: randstate_t); cdecl; external LIB name '__gmp_randinit_mt';
+{ Initialize rop with a copy of the algorithm and state from op }
+procedure mp_randinit_set(out rop: randstate_t; var op: randstate_t); cdecl; external LIB name '__gmp_randinit_set';
+{ Set an initial seed value into state }
+procedure mp_randseed(var state: randstate_t; var seed: mpz_t); cdecl; external LIB name '__gmp_randseed';
+{ Set an initial seed value into state }
+procedure mp_randseed_ui(var state: randstate_t; seed: valuint); cdecl; external LIB name '__gmp_randseed_ui';
+{ Free all memory occupied by state }
+procedure mp_randclear(var state: randstate_t); cdecl; external LIB name '__gmp_randclear';
+{ Return an uniformly distributed random number of n bits, ie. in the range 0 to 2^n−1 inclusive }
+function mp_urandomb_ui(var state: randstate_t; n: valuint): valuint; cdecl; external LIB name '__gmp_urandomb_ui';
+{ Return an uniformly distributed random number in the range 0 to n − 1, inclusive }
+function mp_urandomm_ui(var state: randstate_t; n: valuint): valuint; cdecl; external LIB name '__gmp_urandomm_ui';
+
+// ---- Formatted Input/Output ----
+
+{ Form a null-terminated string in a block of memory obtained from the current memory allocation function }
+function mp_asprintf(out pp: pchar; fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_asprintf';
+{ Form a null-terminated string in a block of memory obtained from the current memory allocation function }
+function mp_asprintf(out pp: pchar; fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_asprintf';
+{ Print to the standard output stdout. Return the number of characters written, or −1 if an error occurred. }
+function mp_printf(fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_printf';
+{ Print to the standard output stdout. Return the number of characters written, or −1 if an error occurred. }
+function mp_printf(fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_printf';
+{ Form a null-terminated string in buf. No more than size bytes will be written. }
+function mp_snprintf(buf: pchar; size: sizeuint; fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_snprintf';
+{ Form a null-terminated string in buf. No more than size bytes will be written. }
+function mp_snprintf(buf: pchar; size: sizeuint; fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_snprintf';
+{ Form a null-terminated string in buf. Return the number of characters written, excluding the terminating null. }
+function mp_sprintf(buf, fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_sprintf';
+{ Form a null-terminated string in buf. Return the number of characters written, excluding the terminating null. }
+function mp_sprintf(buf, fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_sprintf';
+{ Read from the standard input stdin }
+function mp_scanf(fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_scanf';
+{ Read from the standard input stdin }
+function mp_scanf(fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_scanf';
+{ Read from a null-terminated string s }
+function mp_sscanf(s, fmt: pchar; args: array of const): longint; cdecl; external LIB name '__gmp_sscanf';
+{ Read from a null-terminated string s }
+function mp_sscanf(s, fmt: pchar): longint; cdecl; varargs; external LIB name '__gmp_sscanf';
+
+// ---- integer Functions ----
+
+{ Change the space for integer to new_alloc limbs }
+function mpz_realloc(var integer_: mpz_t; new_alloc: mp_size_t): pointer; cdecl; external LIB name '__gmpz_realloc';
+{ Set rop to the absolute value of op }
+procedure mpz_abs(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_abs';
+{ Set rop to op1 + op2 }
+procedure mpz_add(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_add';
+{ Set rop to op1 + op2 }
+procedure mpz_add_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_add_ui';
+{ Set rop to rop + op1 × op2 }
+procedure mpz_addmul(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_addmul';
+{ Set rop to rop + op1 × op2 }
+procedure mpz_addmul_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_addmul_ui';
+{ Set rop to op1 bitwise-and op2 }
+procedure mpz_and(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_and';
+{ _Fixed_ space of fixed_num_bits is allocated to each of the array size integers in integer array }
+procedure mpz_array_init(var integer_array: mpz_t; array_size, fixed_num_bits: mp_size_t); cdecl; external LIB name '__gmpz_array_init';
+{ Compute the binomial coefficient (n over k) and store the result in rop }
+procedure mpz_bin_ui(var rop, n: mpz_t; k: valuint); cdecl; external LIB name '__gmpz_bin_ui';
+{ Compute the binomial coefficient (n over k) and store the result in rop }
+procedure mpz_bin_uiui(var rop: mpz_t; n, k: valuint); cdecl; external LIB name '__gmpz_bin_uiui';
+{ Divide n by d, forming a quotient q. Round mode ceil. }
+procedure mpz_cdiv_q(var q, n, d: mpz_t); cdecl; external LIB name '__gmpz_cdiv_q';
+{ Divide n by d, forming a quotient q. d = 2^b. Round mode ceil. }
+procedure mpz_cdiv_q_2exp(var q, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_cdiv_q_2exp';
+{ Divide n by d, forming a quotient q. Round mode ceil. }
+function mpz_cdiv_q_ui(var q, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_cdiv_q_ui';
+{ Divide n by d, forming a quotient q and remainder r. Round mode ceil. }
+procedure mpz_cdiv_qr(var q, r, n, d: mpz_t); cdecl; external LIB name '__gmpz_cdiv_qr';
+{ Divide n by d, forming a quotient q and remainder r. Round mode ceil. }
+function mpz_cdiv_qr_ui(var q, r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_cdiv_qr_ui';
+{ Divide n by d, forming a remainder r. Round mode ceil. }
+procedure mpz_cdiv_r(var r, n, d: mpz_t); cdecl; external LIB name '__gmpz_cdiv_r';
+{ Divide n by d, forming a remainder r. d = 2^b. Round mode ceil. }
+procedure mpz_cdiv_r_2exp(var r, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_cdiv_r_2exp';
+{ Divide n by d, forming a remainder r. Round mode ceil. }
+function mpz_cdiv_r_ui(var r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_cdiv_r_ui';
+{ Divide n by d. Round mode ceil. }
+function mpz_cdiv_ui(var n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_cdiv_ui';
+{ Free the space occupied by integer. Call this function for all mpz_t variables when you are done with them. }
+procedure mpz_clear(var integer_: mpz_t); cdecl; external LIB name '__gmpz_clear';
+{ Clear bit bit_index in rop }
+procedure mpz_clrbit(var rop: mpz_t; bit_index: valuint); cdecl; external LIB name '__gmpz_clrbit';
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
+function mpz_cmp(var op1, op2: mpz_t): longint; cdecl; external LIB name '__gmpz_cmp';
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
+function mpz_cmp_d(var op1: mpz_t; op2: double): longint; cdecl; external LIB name '__gmpz_cmp_d';
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
+function mpz_cmp_si(var op1: mpz_t; op2: valsint): longint; cdecl; external LIB name '__gmpz_cmp_si';
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
+function mpz_cmp_ui(var op1: mpz_t; op2: valuint): longint; cdecl; external LIB name '__gmpz_cmp_ui';
+{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
+function mpz_cmpabs(var op1, op2: mpz_t): longint; cdecl; external LIB name '__gmpz_cmpabs';
+{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
+function mpz_cmpabs_d(var op1: mpz_t; op2: double): longint; cdecl; external LIB name '__gmpz_cmpabs_d';
+{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
+function mpz_cmpabs_ui(var op1: mpz_t; op2: valuint): longint; cdecl; external LIB name '__gmpz_cmpabs_ui';
+{ Set rop to the one’s complement of op }
+procedure mpz_com(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_com';
+{ Complement bit bit_index in rop }
+procedure mpz_combit(var rop: mpz_t; bit_index: valuint); cdecl; external LIB name '__gmpz_combit';
+{ Return non-zero if n is congruent to c modulo d }
+function mpz_congruent_p(var n, c, d: mpz_t): longint; cdecl; external LIB name '__gmpz_congruent_p';
+{ Return non-zero if n is congruent to c modulo 2^b }
+function mpz_congruent_2exp_p(var n, c: mpz_t; b: valuint): longint; cdecl; external LIB name '__gmpz_congruent_2exp_p';
+{ Return non-zero if n is congruent to c modulo d }
+function mpz_congruent_ui_p(var n: mpz_t; c, d: valuint): longint; cdecl; external LIB name '__gmpz_congruent_ui_p';
+{ Set q to n/d }
+procedure mpz_divexact(var q, n, d: mpz_t); cdecl; external LIB name '__gmpz_divexact';
+{ Set q to n/d }
+procedure mpz_divexact_ui(var q, n: mpz_t; d: valuint); cdecl; external LIB name '__gmpz_divexact_ui';
+{ Return non-zero if n is exactly divisible by d }
+function mpz_divisible_p(var n, d: mpz_t): longint; cdecl; external LIB name '__gmpz_divisible_p';
+{ Return non-zero if n is exactly divisible by d }
+function mpz_divisible_ui_p(var n: mpz_t; d: valuint): longint; cdecl; external LIB name '__gmpz_divisible_ui_p';
+{ Return non-zero if n is exactly divisible by by 2^b }
+function mpz_divisible_2exp_p(var n: mpz_t; b: valuint): longint; cdecl; external LIB name '__gmpz_divisible_2exp_p';
+
+// GDB only: procedure mpz_dump(var _para1: mpz_t); cdecl; external LIB name '__gmpz_dump';
+
+{ Fill buf with word data from op }
+function mpz_export(out buf; out countp: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; var op: mpz_t): pointer; cdecl; external LIB name '__gmpz_export';
+{ Set rop to op!, the factorial of op }
+procedure mpz_fac_ui(var rop: mpz_t; op: valuint); cdecl; external LIB name '__gmpz_fac_ui';
+{ Divide n by d, forming a quotient q. Round mode floor. }
+procedure mpz_fdiv_q(var q, n, d: mpz_t); cdecl; external LIB name '__gmpz_fdiv_q';
+{ Divide n by d, forming a quotient q. d = 2^b. Round mode floor. }
+procedure mpz_fdiv_q_2exp(var q, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_fdiv_q_2exp';
+{ Divide n by d, forming a quotient q. Round mode floor. }
+function mpz_fdiv_q_ui(var q, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_fdiv_q_ui';
+{ Divide n by d, forming a quotient q and remainder r. Round mode floor. }
+procedure mpz_fdiv_qr(var q, r, n, d: mpz_t); cdecl; external LIB name '__gmpz_fdiv_qr';
+{ Divide n by d, forming a quotient q and remainder r. Round mode floor. }
+function mpz_fdiv_qr_ui(var q, r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_fdiv_qr_ui';
+{ Divide n by d, forming a remainder r. Round mode floor. }
+procedure mpz_fdiv_r(var r, n, d: mpz_t); cdecl; external LIB name '__gmpz_fdiv_r';
+{ Divide n by d, forming a remainder r. d = 2^b. Round mode floor. }
+procedure mpz_fdiv_r_2exp(var r, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_fdiv_r_2exp';
+{ Divide n by d, forming a remainder r. Round mode floor. }
+function mpz_fdiv_r_ui(var r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_fdiv_r_ui';
+{ Divide n by d. Round mode floor. }
+function mpz_fdiv_ui(var n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_fdiv_ui';
+{ Set fn to to Fn, the n’th Fibonacci number }
+procedure mpz_fib_ui(var fn: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_fib_ui';
+{ Set fn to Fn, and fnsub1 to Fn−1 }
+procedure mpz_fib2_ui(var fn, fnsub1: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_fib2_ui';
+{ Return non-zero iff the value of op fits in an signed int. Otherwise, return zero. }
+function mpz_fits_sint_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_sint_p';
+{ Return non-zero iff the value of op fits in an signed long int. Otherwise, return zero. }
+function mpz_fits_slong_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_slong_p';
+{ Return non-zero iff the value of op fits in an signed short int. Otherwise, return zero. }
+function mpz_fits_sshort_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_sshort_p';
+{ Return non-zero iff the value of op fits in an unsigned int. Otherwise, return zero. }
+function mpz_fits_uint_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_uint_p';
+{ Return non-zero iff the value of op fits in an unsigned long int. Otherwise, return zero. }
+function mpz_fits_ulong_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_ulong_p';
+{ Return non-zero iff the value of op fits in an unsigned short int. Otherwise, return zero. }
+function mpz_fits_ushort_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_fits_ushort_p';
+{ Set rop to the greatest common divisor of op1 and op2 }
+procedure mpz_gcd(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_gcd';
+{ Compute the greatest common divisor of op1 and op2. If rop is not NULL, store the result there. }
+function mpz_gcd_ui(var rop, op1: mpz_t; op2: valuint): valuint; cdecl; external LIB name '__gmpz_gcd_ui';
+{ Set g to the greatest common divisor of a and b, and in addition set s and t to coefficients satisfying as + bt = g }
+procedure mpz_gcdext(var g, s, t, a, b: mpz_t); cdecl; external LIB name '__gmpz_gcdext';
+{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
+function mpz_get_d(var op: mpz_t): double; cdecl; external LIB name '__gmpz_get_d';
+{ Convert op to a double, truncating if necessary (ie. rounding towards zero), and returning the exponent separately }
+function mpz_get_d_2exp(out exp: valsint; var op: mpz_t): double; cdecl; external LIB name '__gmpz_get_d_2exp';
+{ Return the value of op as a signed long }
+function mpz_get_si(var op: mpz_t): valsint; cdecl; external LIB name '__gmpz_get_si';
+{ Convert op to a string of digits in base base. The base argument may vary from 2 to 62 or from −2 to −36. If str is NULL, the result string is allocated using the current allocation function }
+function mpz_get_str(str: pchar; base: longint; var op: mpz_t): pchar; cdecl; external LIB name '__gmpz_get_str';
+{ Return the value of op as an unsigned long }
+function mpz_get_ui(var op: mpz_t): valuint; cdecl; external LIB name '__gmpz_get_ui';
+{ Return limb number n from op }
+function mpz_getlimbn(var op: mpz_t; n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpz_getlimbn';
+{ If op1 and op2 are both >= 0 or both < 0, return the hamming distance between the two operands, which is the number of bit positions where op1 and op2 have different bit values }
+function mpz_hamdist(var op1, op2: mpz_t): valuint; cdecl; external LIB name '__gmpz_hamdist';
+{ Set rop from an array of word data at op }
+procedure mpz_import(var rop: mpz_t; count: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; const op); cdecl; external LIB name '__gmpz_import';
+{ Initialize integer, and set its value to 0 }
+procedure mpz_init(out integer_: mpz_t); cdecl; external LIB name '__gmpz_init';
+{ Initialize integer, with space for n bits, and set its value to 0 }
+procedure mpz_init2(out integer_: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_init2';
+{ Initialize rop with limb space and set the initial numeric value from op }
+procedure mpz_init_set(out rop: mpz_t; var op: mpz_t); cdecl; external LIB name '__gmpz_init_set';
+{ Initialize rop with limb space and set the initial numeric value from op }
+procedure mpz_init_set_d(out rop: mpz_t; op: double); cdecl; external LIB name '__gmpz_init_set_d';
+{ Initialize rop with limb space and set the initial numeric value from op }
+procedure mpz_init_set_si(out rop: mpz_t; op: valsint); cdecl; external LIB name '__gmpz_init_set_si';
+{ Initialize rop and set its value like mpz_set_str }
+function mpz_init_set_str(out rop: mpz_t; str: pchar; base: longint): longint; cdecl; external LIB name '__gmpz_init_set_str';
+{ Initialize rop with limb space and set the initial numeric value from op }
+procedure mpz_init_set_ui(out rop: mpz_t; op: valuint); cdecl; external LIB name '__gmpz_init_set_ui';
+{ Compute the inverse of op1 modulo op2 and put the result in rop }
+function mpz_invert(var rop, op1, op2: mpz_t): longint; cdecl; external LIB name '__gmpz_invert';
+{ Set rop to op1 bitwise inclusive-or op2 }
+procedure mpz_ior(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_ior';
+{ Calculate the Jacobi symbol. This is defined only for b odd }
+function mpz_jacobi(var a, b: mpz_t): longint; cdecl; external LIB name '__gmpz_jacobi';
+{ Calculate the Jacobi symbol with the Kronecker extension }
+function mpz_kronecker_si(var a: mpz_t; b: valsint): longint; cdecl; external LIB name '__gmpz_kronecker_si';
+{ Calculate the Jacobi symbol with the Kronecker extension }
+function mpz_kronecker_ui(var a: mpz_t; b: valuint): longint; cdecl; external LIB name '__gmpz_kronecker_ui';
+{ Calculate the Jacobi symbol with the Kronecker extension }
+function mpz_si_kronecker(a: valsint; var b: mpz_t): longint; cdecl; external LIB name '__gmpz_si_kronecker';
+{ Calculate the Jacobi symbol with the Kronecker extension }
+function mpz_ui_kronecker(a: valuint; var b: mpz_t): longint; cdecl; external LIB name '__gmpz_ui_kronecker';
+{ Set rop to the least common multiple of op1 and op2 }
+procedure mpz_lcm(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_lcm';
+{ Set rop to the least common multiple of op1 and op2 }
+procedure mpz_lcm_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_lcm_ui';
+{ Set ln to to Ln, the n’th Lucas number }
+procedure mpz_lucnum_ui(var ln: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_lucnum_ui';
+{ Set ln to Ln, and lnsub1 to Ln−1 }
+procedure mpz_lucnum2_ui(var ln, lnsub1: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_lucnum2_ui';
+
+// No docs: function mpz_millerrabin(var _para1: mpz_t; _para2: longint): longint; cdecl; external LIB name '__gmpz_millerrabin';
+
+{ Set r to n mod d. The sign of the divisor is ignored; the result is always non-negative. }
+procedure mpz_mod(var r, n, d: mpz_t); cdecl; external LIB name '__gmpz_mod';
+{ Set rop to op1 × op2 }
+procedure mpz_mul(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_mul';
+{ Set rop to op1 × 2^op2. This operation can also be defined as a left shift by op2 bits. }
+procedure mpz_mul_2exp(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_mul_2exp';
+{ Set rop to op1 × op2 }
+procedure mpz_mul_si(var rop, op1: mpz_t; op2: valsint); cdecl; external LIB name '__gmpz_mul_si';
+{ Set rop to op1 × op2 }
+procedure mpz_mul_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_mul_ui';
+{ Set rop to −op }
+procedure mpz_neg(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_neg';
+{ Set rop to the next prime greater than op }
+procedure mpz_nextprime(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_nextprime';
+{ Return non-zero if op is a perfect power, i.e., if there exist integers a and b, with b > 1, such that op = a^b }
+function mpz_perfect_power_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_perfect_power_p';
+{ Return non-zero if op is a perfect square, i.e., if the square root of op is an integer }
+function mpz_perfect_square_p(var op: mpz_t): longint; cdecl; external LIB name '__gmpz_perfect_square_p';
+{ If op >= 0, return the population count of op, which is the number of 1 bits in the binary representation }
+function mpz_popcount(var op: mpz_t): valuint; cdecl; external LIB name '__gmpz_popcount';
+{ Set rop to base^exp. The case 0^0 yields 1. }
+procedure mpz_pow_ui(var rop, base: mpz_t; exp: valuint); cdecl; external LIB name '__gmpz_pow_ui';
+{ Set rop to base^exp mod mod_ }
+procedure mpz_powm(var rop, base, exp, mod_: mpz_t); cdecl; external LIB name '__gmpz_powm';
+{ Set rop to base^exp mod mod_ }
+procedure mpz_powm_ui(var rop, base: mpz_t; exp: valuint; var mod_: mpz_t); cdecl; external LIB name '__gmpz_powm_ui';
+{ Determine whether n is prime. Return 2 if n is definitely prime, return 1 if n is probably prime (without being certain), or return 0 if n is definitely composite. }
+function mpz_probab_prime_p(var n: mpz_t; reps: longint): longint; cdecl; external LIB name '__gmpz_probab_prime_p';
+
+{ Obsolete: Generate a random integer of at most max_size limbs }
+// procedure mpz_random(var rop: mpz_t; max_size: mp_size_t); cdecl; external LIB name '__gmpz_random';
+{ Obsolete: Generate a random integer of at most max_size limbs, with long strings of zeros and ones in the binary representation }
+// procedure mpz_random2(var rop: mpz_t; max_size: mp_size_t); cdecl; external LIB name '__gmpz_random2';
+
+{ Change the space allocated for integer to n bits. The value in integer is preserved if it fits, or is set to 0 if not. }
+procedure mpz_realloc2(var integer_: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_realloc2';
+{ Remove all occurrences of the factor f from op and store the result in rop }
+function mpz_remove(var rop, op, f: mpz_t): valuint; cdecl; external LIB name '__gmpz_remove';
+{ Set rop to trunc(op^(1/n)), the truncated integer part of the nth root of op. Return non-zero if the computation was exact, i.e., if op is rop to the nth power. }
+function mpz_root(var rop, op: mpz_t; n: valuint): longint; cdecl; external LIB name '__gmpz_root';
+{ Set root to trunc(u^(1/n)), the truncated integer part of the nth root of u. Set rem to the remainder, (u − root^n). }
+procedure mpz_rootrem(var root, rem, u: mpz_t; n: valuint); cdecl; external LIB name '__gmpz_rootrem';
+{ Generate a random integer with long strings of zeros and ones in the binary representation }
+procedure mpz_rrandomb(var rop: mpz_t; var state: randstate_t; n: valuint); cdecl; external LIB name '__gmpz_rrandomb';
+{ Scan op, starting from bit starting_bit, towards more significant bits, until the first 0 bit is found }
+function mpz_scan0(var op: mpz_t; starting_bit: valuint): valuint; cdecl; external LIB name '__gmpz_scan0';
+{ Scan op, starting from bit starting_bit, towards more significant bits, until the first 1 bit is found }
+function mpz_scan1(var op: mpz_t; starting_bit: valuint): valuint; cdecl; external LIB name '__gmpz_scan1';
+{ Set the value of rop from op }
+procedure mpz_set(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_set';
+{ Set the value of rop from op }
+procedure mpz_set_d(var rop: mpz_t; op: double); cdecl; external LIB name '__gmpz_set_d';
+{ Set the value of rop from op }
+procedure mpz_set_f(var rop: mpz_t; var op: mpf_t); cdecl; external LIB name '__gmpz_set_f';
+{ Set the value of rop from op }
+procedure mpz_set_q(var rop: mpz_t; var op: mpq_t); cdecl; external LIB name '__gmpz_set_q';
+{ Set the value of rop from op }
+procedure mpz_set_si(var rop: mpz_t; op: valsint); cdecl; external LIB name '__gmpz_set_si';
+{ Set the value of rop from str, a null-terminated C string in base base. White space is allowed in the string, and is simply ignored. }
+function mpz_set_str(var rop: mpz_t; str: pchar; base: longint): longint; cdecl; external LIB name '__gmpz_set_str';
+{ Set the value of rop from op }
+procedure mpz_set_ui(var rop: mpz_t; op: valuint); cdecl; external LIB name '__gmpz_set_ui';
+{ Set bit bit_index in rop }
+procedure mpz_setbit(var rop: mpz_t; bit_index: valuint); cdecl; external LIB name '__gmpz_setbit';
+{ Return the size of op measured in number of limbs }
+function mpz_size(var op: mpz_t): sizeuint; cdecl; external LIB name '__gmpz_size';
+{ Return the size of op measured in number of digits in the given base }
+function mpz_sizeinbase(var op: mpz_t; base: longint): sizeuint; cdecl; external LIB name '__gmpz_sizeinbase';
+{ Set rop to trunc(sqrt(op)), the truncated integer part of the square root of op }
+procedure mpz_sqrt(var rop, op: mpz_t); cdecl; external LIB name '__gmpz_sqrt';
+{ Set rop1 to trunc(sqrt(op)), likempz_sqrt. Set rop2 to the remainder (op − rop1^2), which will be zero if op is a perfect square. }
+procedure mpz_sqrtrem(var rop1, rop2, op: mpz_t); cdecl; external LIB name '__gmpz_sqrtrem';
+{ Set rop to op1 − op2 }
+procedure mpz_sub(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_sub';
+{ Set rop to op1 − op2 }
+procedure mpz_sub_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_sub_ui';
+{ Set rop to op1 − op2 }
+procedure mpz_ui_sub(var rop: mpz_t; op1: valuint; var op2: mpz_t); cdecl; external LIB name '__gmpz_ui_sub';
+{ Set rop to rop − op1 × op2 }
+procedure mpz_submul(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_submul';
+{ Set rop to rop − op1 × op2 }
+procedure mpz_submul_ui(var rop, op1: mpz_t; op2: valuint); cdecl; external LIB name '__gmpz_submul_ui';
+{ Swap the values rop1 and rop2 efficiently }
+procedure mpz_swap(var rop1, rop2: mpz_t); cdecl; external LIB name '__gmpz_swap';
+{ Divide n by d, forming a quotient q. Round mode trunc. }
+procedure mpz_tdiv_q(var q, n, d: mpz_t); cdecl; external LIB name '__gmpz_tdiv_q';
+{ Divide n by d, forming a quotient q. d = 2^b. Round mode trunc. }
+procedure mpz_tdiv_q_2exp(var q, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_tdiv_q_2exp';
+{ Divide n by d, forming a quotient q. Round mode trunc. }
+function mpz_tdiv_q_ui(var q, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_tdiv_q_ui';
+{ Divide n by d, forming a quotient q and remainder r. Round mode trunc. }
+procedure mpz_tdiv_qr(var q, r, n, d: mpz_t); cdecl; external LIB name '__gmpz_tdiv_qr';
+{ Divide n by d, forming a quotient q and remainder r. Round mode trunc. }
+function mpz_tdiv_qr_ui(var q, r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_tdiv_qr_ui';
+{ Divide n by d, forming a remainder r. Round mode trunc. }
+procedure mpz_tdiv_r(var r, n, d: mpz_t); cdecl; external LIB name '__gmpz_tdiv_r';
+{ Divide n by d, forming a remainder r. d = 2^b. Round mode trunc. }
+procedure mpz_tdiv_r_2exp(var r, n: mpz_t; b: valuint); cdecl; external LIB name '__gmpz_tdiv_r_2exp';
+{ Divide n by d, forming a remainder r. Round mode trunc. }
+function mpz_tdiv_r_ui(var r, n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_tdiv_r_ui';
+{ Divide n by d. Round mode trunc. }
+function mpz_tdiv_ui(var n: mpz_t; d: valuint): valuint; cdecl; external LIB name '__gmpz_tdiv_ui';
+{ Test bit bit_index in op and return 0 or 1 accordingly }
+function mpz_tstbit(var rop: mpz_t; bit_index: valuint): longint; cdecl; external LIB name '__gmpz_tstbit';
+{ Set rop to base^exp. The case 0^0 yields 1 }
+procedure mpz_ui_pow_ui(var rop: mpz_t; base, exp: valuint); cdecl; external LIB name '__gmpz_ui_pow_ui';
+{ Generate a uniformly distributed random integer in the range 0 to 2^n − 1, inclusive }
+procedure mpz_urandomb(var rop: mpz_t; var state: randstate_t; n: valuint); cdecl; external LIB name '__gmpz_urandomb';
+{ Generate a uniform random integer in the range 0 to n − 1, inclusive }
+procedure mpz_urandomm(var rop: mpz_t; var state: randstate_t; var n: mpz_t); cdecl; external LIB name '__gmpz_urandomm';
+{ Set rop to op1 bitwise exclusive-or op2 }
+procedure mpz_xor(var rop, op1, op2: mpz_t); cdecl; external LIB name '__gmpz_xor';
+
+// ---- Rational Number Functions ----
+
+{ Set rop to the absolute value of op }
+procedure mpq_abs(var rop, op: mpq_t); cdecl; external LIB name '__gmpq_abs';
+{ Set sum to addend1 + addend2 }
+procedure mpq_add(var sum, addend1, addend2: mpq_t); cdecl; external LIB name '__gmpq_add';
+{ Remove any factors that are common to the numerator and denominator of op, and make the denominator positive }
+procedure mpq_canonicalize(var op: mpq_t); cdecl; external LIB name '__gmpq_canonicalize';
+{ Free the space occupied by rational number }
+procedure mpq_clear(var rational_number: mpq_t); cdecl; external LIB name '__gmpq_clear';
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2 }
+function mpq_cmp(var op1, op2: mpq_t): longint; cdecl; external LIB name '__gmpq_cmp';
+{ Compare op1 and num2/den2. Return a positive value if op1 > num2/den2, zero if op1 = num2/den2, and a negative value if op1 < num2/den2 }
+function mpq_cmp_si(var op1: mpq_t; num2: valsint; den2: valuint): longint; cdecl; external LIB name '__gmpq_cmp_si';
+{ Compare op1 and num2/den2. Return a positive value if op1 > num2/den2, zero if op1 = num2/den2, and a negative value if op1 < num2/den2 }
+function mpq_cmp_ui(var op1: mpq_t; num2, den2: valuint): longint; cdecl; external LIB name '__gmpq_cmp_ui';
+{ Set quotient to dividend/divisor }
+procedure mpq_div(var quotient, dividend, divisor: mpq_t); cdecl; external LIB name '__gmpq_div';
+{ Set rop to op1/(2^op2) }
+procedure mpq_div_2exp(var rop, op1: mpq_t; op2: valuint); cdecl; external LIB name '__gmpq_div_2exp';
+{ Return non-zero if op1 and op2 are equal, zero if they are non-equal }
+function mpq_equal(var op1, op2: mpq_t): longint; cdecl; external LIB name '__gmpq_equal';
+{ Get the numerator of a rational }
+procedure mpq_get_num(var numerator: mpz_t; var rational: mpq_t); cdecl; external LIB name '__gmpq_get_num';
+{ Get the denominator of a rational }
+procedure mpq_get_den(var denominator: mpz_t; var rational: mpq_t); cdecl; external LIB name '__gmpq_get_den';
+{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
+function mpq_get_d(var op: mpq_t): double; cdecl; external LIB name '__gmpq_get_d';
+{ Convert op to a string of digits in base base }
+function mpq_get_str(str: pchar; base: longint; var op: mpq_t): pchar; cdecl; external LIB name '__gmpq_get_str';
+{ Initialize dest rational and set it to 0/1 }
+procedure mpq_init(out dest_rational: mpq_t); cdecl; external LIB name '__gmpq_init';
+{ Set inverted_number to 1/number }
+procedure mpq_inv(var inverted_number, number: mpq_t); cdecl; external LIB name '__gmpq_inv';
+{ Set product to multiplier × multiplicand }
+procedure mpq_mul(var product, multiplier, multiplicand: mpq_t); cdecl; external LIB name '__gmpq_mul';
+{ Set rop to op1 × (2^op2) }
+procedure mpq_mul_2exp(var rop, op1: mpq_t; op2: valuint); cdecl; external LIB name '__gmpq_mul_2exp';
+{ Set negated_operand to −operand }
+procedure mpq_neg(var negated_operand, operand: mpq_t); cdecl; external LIB name '__gmpq_neg';
+{ Assign rop from op }
+procedure mpq_set(var rop, op: mpq_t); cdecl; external LIB name '__gmpq_set';
+{ Set rop to the value of op. There is no rounding, this conversion is exact. }
+procedure mpq_set_d(var rop: mpq_t; op: double); cdecl; external LIB name '__gmpq_set_d';
+{ Set the denominator of a rational }
+procedure mpq_set_den(var rational: mpq_t; var denominator: mpz_t); cdecl; external LIB name '__gmpq_set_den';
+{ Set rop to the value of op. There is no rounding, this conversion is exact. }
+procedure mpq_set_f(var rop: mpq_t; var op: mpf_t); cdecl; external LIB name '__gmpq_set_f';
+{ Set the numerator of a rational }
+procedure mpq_set_num(var rational: mpq_t; var numerator: mpz_t); cdecl; external LIB name '__gmpq_set_num';
+{ Set the value of rop to op1/op2 }
+procedure mpq_set_si(var rop: mpq_t; op1: valsint; op2: valuint); cdecl; external LIB name '__gmpq_set_si';
+{ Set rop from a null-terminated string str in the given base }
+function mpq_set_str(var rop: mpq_t; str: pchar; base: longint): longint; cdecl; external LIB name '__gmpq_set_str';
+{ Set the value of rop to op1/op2 }
+procedure mpq_set_ui(var rop: mpq_t; op1, op2: valuint); cdecl; external LIB name '__gmpq_set_ui';
+{ Assign rop from op }
+procedure mpq_set_z(var rop: mpq_t; var op: mpz_t); cdecl; external LIB name '__gmpq_set_z';
+{ Set difference to minuend − subtrahend }
+procedure mpq_sub(var difference, minuend, subtrahend: mpq_t); cdecl; external LIB name '__gmpq_sub';
+{ Swap the values rop1 and rop2 efficiently }
+procedure mpq_swap(var rop1, rop2: mpq_t); cdecl; external LIB name '__gmpq_swap';
+
+// ---- Floating-point Functions ----
+
+{ Set rop to the absolute value of op }
+procedure mpf_abs(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_abs';
+{ Set rop to op1 + op2 }
+procedure mpf_add(var rop, op1, op2: mpf_t); cdecl; external LIB name '__gmpf_add';
+{ Set rop to op1 + op2 }
+procedure mpf_add_ui(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_add_ui';
+{ Set rop to op rounded to the next higher integer }
+procedure mpf_ceil(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_ceil';
+{ Free the space occupied by x }
+procedure mpf_clear(var x: mpf_t); cdecl; external LIB name '__gmpf_clear';
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
+function mpf_cmp(var op1, op2: mpf_t): longint; cdecl; external LIB name '__gmpf_cmp';
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
+function mpf_cmp_d(var op1: mpf_t; op2: double): longint; cdecl; external LIB name '__gmpf_cmp_d';
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
+function mpf_cmp_si(var op1: mpf_t; op2: valsint): longint; cdecl; external LIB name '__gmpf_cmp_si';
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
+function mpf_cmp_ui(var op1: mpf_t; op2: valuint): longint; cdecl; external LIB name '__gmpf_cmp_ui';
+{ Set rop to op1/op2 }
+procedure mpf_div(var rop, op1, op2: mpf_t); cdecl; external LIB name '__gmpf_div';
+{ Set rop to op1/(2^op2) }
+procedure mpf_div_2exp(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_div_2exp';
+{ Set rop to op1/op2 }
+procedure mpf_div_ui(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_div_ui';
+
+// GDB only: procedure mpf_dump(var _para1: mpf_t); cdecl; external LIB name '__gmpf_dump';
+
+{ Return non-zero if the first op3 bits of op1 and op2 are equal, zero otherwise }
+function mpf_eq(var op1, op2: mpf_t; op3: valuint): longint; cdecl; external LIB name '__gmpf_eq';
+{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
+function mpf_fits_sint_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_sint_p';
+{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
+function mpf_fits_slong_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_slong_p';
+{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
+function mpf_fits_sshort_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_sshort_p';
+{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
+function mpf_fits_uint_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_uint_p';
+{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
+function mpf_fits_ulong_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_ulong_p';
+{ Return non-zero if op would fit in the respective C data type, when truncated to an integer }
+function mpf_fits_ushort_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_fits_ushort_p';
+{ Set rop to op rounded to the next lower }
+procedure mpf_floor(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_floor';
+{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
+function mpf_get_d(var op: mpf_t): double; cdecl; external LIB name '__gmpf_get_d';
+{ Convert op to a double, truncating if necessary (ie. rounding towards zero), and with an exponent returned separately }
+function mpf_get_d_2exp(out exp: valsint; var op: mpf_t): double; cdecl; external LIB name '__gmpf_get_d_2exp';
+{ Return the default precision actually used }
+function mpf_get_default_prec: valuint; cdecl; external LIB name '__gmpf_get_default_prec';
+{ Return the current precision of op, in bits }
+function mpf_get_prec(var op: mpf_t): valuint; cdecl; external LIB name '__gmpf_get_prec';
+{ Convert op to a long, truncating any fraction part }
+function mpf_get_si(var op: mpf_t): valsint; cdecl; external LIB name '__gmpf_get_si';
+{ Convert op to a string of digits in base base }
+function mpf_get_str(str: pchar; out exp: mp_exp_t; base: longint; ndigits: sizeuint; var op: mpf_t): pchar; cdecl; external LIB name '__gmpf_get_str';
+{ Convert op to a unsigned long, truncating any fraction part }
+function mpf_get_ui(var op: mpf_t): valuint; cdecl; external LIB name '__gmpf_get_ui';
+{ Initialize x to 0 }
+procedure mpf_init(out x: mpf_t); cdecl; external LIB name '__gmpf_init';
+{ Initialize x to 0 and set its precision to be at least prec bits }
+procedure mpf_init2(out x: mpf_t; prec: valuint); cdecl; external LIB name '__gmpf_init2';
+{ Initialize rop and set its value from op }
+procedure mpf_init_set(out rop: mpf_t; var op: mpf_t); cdecl; external LIB name '__gmpf_init_set';
+{ Initialize rop and set its value from op }
+procedure mpf_init_set_d(out rop: mpf_t; op: double); cdecl; external LIB name '__gmpf_init_set_d';
+{ Initialize rop and set its value from op }
+procedure mpf_init_set_si(out rop: mpf_t; op: valsint); cdecl; external LIB name '__gmpf_init_set_si';
+{ Initialize rop and set its value from the string in str }
+function mpf_init_set_str(out rop: mpf_t; str: pchar; base: longint): longint; cdecl; external LIB name '__gmpf_init_set_str';
+{ Initialize rop and set its value from op }
+procedure mpf_init_set_ui(out rop: mpf_t; op: valuint); cdecl; external LIB name '__gmpf_init_set_ui';
+{ Return non-zero if op is an integer }
+function mpf_integer_p(var op: mpf_t): longint; cdecl; external LIB name '__gmpf_integer_p';
+{ Set rop to op1 × op2 }
+procedure mpf_mul(var rop, op1, op2: mpf_t); cdecl; external LIB name '__gmpf_mul';
+{ Set rop to op1 × (2^op2) }
+procedure mpf_mul_2exp(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_mul_2exp';
+{ Set rop to op1 × op2 }
+procedure mpf_mul_ui(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_mul_ui';
+{ Set rop to −op }
+procedure mpf_neg(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_neg';
+{ Set rop to op1^op2 }
+procedure mpf_pow_ui(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_pow_ui';
+{ Generate a random float of at most max_size limbs, with long strings of zeros and ones in the binary representation }
+procedure mpf_random2(var rop: mpf_t; max_size: mp_size_t; exp: mp_exp_t); cdecl; external LIB name '__gmpf_random2';
+{ Compute the relative difference between op1 and op2 and store the result in rop }
+procedure mpf_reldiff(var rop, op1, op2: mpf_t); cdecl; external LIB name '__gmpf_reldiff';
+{ Set the value of rop from op }
+procedure mpf_set(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_set';
+{ Set the value of rop from op }
+procedure mpf_set_d(var rop: mpf_t; op: double); cdecl; external LIB name '__gmpf_set_d';
+{ Set the default precision to be at least prec bits }
+procedure mpf_set_default_prec(prec: valuint); cdecl; external LIB name '__gmpf_set_default_prec';
+{ Set the precision of rop to be at least prec bits }
+procedure mpf_set_prec(var rop: mpf_t; prec: valuint); cdecl; external LIB name '__gmpf_set_prec';
+{ Set the precision of rop to be at least prec bits, without changing the memory allocated }
+procedure mpf_set_prec_raw(var rop: mpf_t; prec: valuint); cdecl; external LIB name '__gmpf_set_prec_raw';
+{ Set the value of rop from op }
+procedure mpf_set_q(var rop: mpf_t; var op: mpq_t); cdecl; external LIB name '__gmpf_set_q';
+{ Set the value of rop from op }
+procedure mpf_set_si(var rop: mpf_t; op: valsint); cdecl; external LIB name '__gmpf_set_si';
+{ Set the value of rop from the string in str }
+function mpf_set_str(var rop: mpf_t; str: pchar; base: longint): longint; cdecl; external LIB name '__gmpf_set_str';
+{ Set the value of rop from op }
+procedure mpf_set_ui(var rop: mpf_t; op: valuint); cdecl; external LIB name '__gmpf_set_ui';
+{ Set the value of rop from op }
+procedure mpf_set_z(var rop: mpf_t; var op: mpz_t); cdecl; external LIB name '__gmpf_set_z';
+
+// No docs: function mpf_size(var _para1: mpf_t): size_t; cdecl; external LIB name '__gmpf_size';
+
+{ Set rop to op^(1/2) }
+procedure mpf_sqrt(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_sqrt';
+{ Set rop to op^(1/2) }
+procedure mpf_sqrt_ui(var rop: mpf_t; op: valuint); cdecl; external LIB name '__gmpf_sqrt_ui';
+{ Set rop to op1 − op2 }
+procedure mpf_sub(var rop, op1, op2: mpf_t); cdecl; external LIB name '__gmpf_sub';
+{ Set rop to op1 − op2 }
+procedure mpf_sub_ui(var rop, op1: mpf_t; op2: valuint); cdecl; external LIB name '__gmpf_sub_ui';
+{ Swap rop1 and rop2 efficiently }
+procedure mpf_swap(var rop1, rop2: mpf_t); cdecl; external LIB name '__gmpf_swap';
+{ Set rop to op rounded to the integer towards zero }
+procedure mpf_trunc(var rop, op: mpf_t); cdecl; external LIB name '__gmpf_trunc';
+{ Set rop to op1/op2 }
+procedure mpf_ui_div(var rop: mpf_t; op1: valuint; var op2: mpf_t); cdecl; external LIB name '__gmpf_ui_div';
+{ Set rop to op1 − op2 }
+procedure mpf_ui_sub(var rop: mpf_t; op1: valuint; var op2: mpf_t); cdecl; external LIB name '__gmpf_ui_sub';
+{ Generate a uniformly distributed random float in rop, such that 0 <= rop < 1, with nbits significant bits in the mantissa }
+procedure mpf_urandomb(var rop: mpf_t; var state: randstate_t; nbits: valuint); cdecl; external LIB name '__gmpf_urandomb';
+
+// ---- Low-level Functions ----
+
+{ Add [s1p, s1n] and [s2p, s2n], and write the s1n least significant limbs of the result to rp. Return carry, either 0 or 1. }
+function mpn_add(rop, s1p: mpn_ptr; s1n: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_add';
+{ Add [s1p, n] and s2limb, and write the n least significant limbs of the result to rp. Return carry, either 0 or 1. }
+function mpn_add_1(rp, s1p: mpn_ptr; n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_add_1';
+{ Add [s1p, n] and [s2p, n], and write the n least significant limbs of the result to rp. Return carry, either 0 or 1. }
+function mpn_add_n(rop, s1p, s2p: mpn_ptr; n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_add_n';
+{ Multiply [s1p, n] and s2limb, and add the n least significant limbs of the product to [rp, n] and write the result to rp. Return the most significant limb of the product, plus carry-out from the addition. }
+function mpn_addmul_1(rp, s1p: mpn_ptr; n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_addmul_1';
+
+{ Preliminary: This function puts the low floor(d/mp_bits_per_limb) limbs of q = [s1p, s1n]/[s2p, s2n] mod 2^d at rp, and returns the high d mod mp_bits_per_limb bits of q }
+// function mpn_bdivmod(rp, s1p: mpn_t; s1n: mp_size_t; s2p: mpn_t; s2n: mp_size_t; d: valuint): mp_limb_t; cdecl; external LIB name '__gmpn_bdivmod';
+
+{ Compare [s1p, n] and [s2p, n] and return a positive value if s1 > s2, 0 if they are equal, or a negative value if s1 < s2 }
+function mpn_cmp(s1p, s2p: mpn_ptr; n: mp_size_t): longint; cdecl; external LIB name '__gmpn_cmp';
+{ Divide [sp, n] by 3, expecting it to divide exactly, and writing the result to [rp, n] }
+function mpn_divexact_by3c(rp, sp: mpn_ptr; n: mp_size_t; carry: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_divexact_by3c';
+
+{ Obsolete: Divide [rs2p, rs2n] by [s3p, s3n], and write the quotient at r1p, with the exception of the most significant limb, which is returned }
+// function mpn_divrem(r1p: mpn_t; qxn: mp_size_t; rs2p: mpn_t; rs2n: mp_size_t; s3p: mpn_t; s3n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_divrem';
+
+{ Divide [s2p, s2n] by s3limb, and write the quotient at r1p. Return the remainder }
+function mpn_divrem_1(r1p: mpn_ptr; qxn: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_divrem_1';
+
+// No docs: function mpn_divrem_2(_para1: mpn_t; _para2: mp_size_t; _para3: mpn_t; _para4: mp_size_t; _para5: mpn_t): mp_limb_t; cdecl; external LIB name '__gmpn_divrem_2';
+
+{ Set [rp, retval] to the greatest common divisor of [s1p, s1n] and [s2p, s2n] }
+function mpn_gcd(rp, s1p: mpn_ptr; s1n: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t): mp_size_t; cdecl; external LIB name '__gmpn_gcd';
+{ Return the greatest common divisor of [s1p, s1n] and s2limb }
+function mpn_gcd_1(s1p: mpn_ptr; s1n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_gcd_1';
+{ Calculate the greatest common divisor of [s1p, s1n] and [s2p, s2n] }
+function mpn_gcdext(r1p, r2p: mpn_ptr; out r2n: mp_size_t; s1p: mpn_ptr; s1n: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t): mp_size_t; cdecl; external LIB name '__gmpn_gcdext';
+{ Convert [s1p, s1n] to a raw unsigned char array at str in base base, and return the number of characters produced }
+function mpn_get_str(str: pbyte; base: longint; s1p: mpn_ptr; s1n: mp_size_t):sizeuint; cdecl; external LIB name '__gmpn_get_str';
+{ Compute the hamming distance between [s1p, n] and [s2p, n], which is the number of bit positions where the two operands have different bit values }
+function mpn_hamdist(s1p, s2p: mpn_ptr; n: mp_size_t): valuint; cdecl; external LIB name '__gmpn_hamdist';
+{ Shift [sp, n] left by count bits, and write the result to [rp, n] }
+function mpn_lshift(rp, sp: mpn_ptr; n: mp_size_t; count: dword): mp_limb_t; cdecl; external LIB name '__gmpn_lshift';
+{ Divide [s1p, s1n] by s2limb, and return the remainder. s1n can be zero. }
+function mpn_mod_1(s1p: mpn_ptr; s1n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_mod_1';
+{ Multiply [s1p, s1n] and [s2p, s2n], and write the result to rp. Return the most significant limb of the result. }
+function mpn_mul(rp, s1p: mpn_ptr; s1n: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_mul';
+{ Multiply [s1p, n] by s2limb, and write the n least significant limbs of the product to rp. Return the most significant limb of the product. }
+function mpn_mul_1(rp, s1p: mpn_ptr; n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_mul_1';
+{ Multiply [s1p, n] and [s2p, n], and write the 2*n-limb result to rp }
+procedure mpn_mul_n(rp, s1p, s2p: mpn_ptr; n: mp_size_t); cdecl; external LIB name '__gmpn_mul_n';
+{ Return non-zero iff [s1p, n] is a perfect square }
+function mpn_perfect_square_p(s1p: mpn_ptr; n: mp_size_t): longint; cdecl; external LIB name '__gmpn_perfect_square_p';
+{ Count the number of set bits in [s1p, n] }
+function mpn_popcount(s1p: mpn_ptr; n: mp_size_t): valuint; cdecl; external LIB name '__gmpn_popcount';
+
+// No docs: function mpn_pow_1(_para1, _para2: mpn_t; _para3: mp_size_t; _para4, _para5: mpn_t): mp_size_t; cdecl; external LIB name '__gmpn_pow_1';
+// No docs: function mpn_preinv_mod_1(_para1: mpn_t; _para2: mp_size_t; _para3, _para4: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_preinv_mod_1';
+
+{ Generate a random number of length r1n and store it at r1p }
+procedure mpn_random(r1p: mpn_ptr; r1n: mp_size_t); cdecl; external LIB name '__gmpn_random';
+{ Generate a random number of length r1n and store it at r1p }
+procedure mpn_random2(r1p: mpn_ptr; r1n: mp_size_t); cdecl; external LIB name '__gmpn_random2';
+{ Shift [sp, n] right by count bits, and write the result to [rp, n] }
+function mpn_rshift(rp, sp: mpn_ptr; n: mp_size_t; count: dword): mp_limb_t; cdecl; external LIB name '__gmpn_rshift';
+{ Scan s1p from bit position bit for the next clear bit }
+function mpn_scan0(s1p: mpn_ptr; bit: valuint): valuint; cdecl; external LIB name '__gmpn_scan0';
+{ Scan s1p from bit position bit for the next set bit }
+function mpn_scan1(s1p: mpn_ptr; bit: valuint): valuint; cdecl; external LIB name '__gmpn_scan1';
+{ Convert bytes [str,strsize] in the given base to limbs at rp }
+function mpn_set_str(rp: mpn_ptr; str: pbyte; strsize: sizeuint; base:longint): mp_size_t; cdecl; external LIB name '__gmpn_set_str';
+{ Compute the square root of [sp, n] and put the result at [r1p, dn/2e] and the remainder at [r2p, retval] }
+function mpn_sqrtrem(r1p, r2p, sp: mpn_ptr; n: mp_size_t): mp_size_t; cdecl; external LIB name '__gmpn_sqrtrem';
+{ Subtract [s2p, s2n] from [s1p, s1n], and write the s1n least significant limbs of the result to rp. Return borrow, either 0 or 1. }
+function mpn_sub(rp, s1p: mpn_ptr; s1n: mp_size_t; s2p: mpn_ptr; s2n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_sub';
+{ Subtract s2limb from [s1p, n], and write the n least significant limbs of the result to rp. Return borrow, either 0 or 1. }
+function mpn_sub_1(rp, s1p: mpn_ptr; n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_sub_1';
+{ Subtract [s2p, n] from [s1p, n], and write the n least significant limbs of the result to rp. Return borrow, either 0 or 1. }
+function mpn_sub_n(rp, s1p, s2p: mpn_ptr; n: mp_size_t): mp_limb_t; cdecl; external LIB name '__gmpn_sub_n';
+{ Multiply [s1p, n] and s2limb, and subtract the n least significant limbs of the product from [rp, n] and write the result to rp. Return the most significant limb of the product, plus borrow-out from the subtraction. }
+function mpn_submul_1(rp, s1p: mpn_ptr; n: mp_size_t; s2limb: mp_limb_t): mp_limb_t; cdecl; external LIB name '__gmpn_submul_1';
+{ Divide [np, nn] by [dp, dn] and put the quotient at [qp, nn−dn+1] and the remainder at [rp, dn] }
+procedure mpn_tdiv_qr(qp, rp: mpn_ptr; qxn: mp_size_t; np: mpn_ptr; nn: mp_size_t; dp: mpn_ptr; dn: mp_size_t); cdecl; external LIB name '__gmpn_tdiv_qr';
+
+// ---- GMP properties ----
+
+{ Size of a limb on this machine }
+function bits_per_limb: longint;
+{ Some GMP functions may set this thread unsafe variable. Better avoid using it. }
+function errno: longint;
+{ GMP version string a.b.c }
+function version: string;
+
+// ==== ext bindings =====
+
+// ---- Random Number Functions ----
+
+{ Initialize state with a default algorithm }
+procedure randinit_default(out state: MPRandState);
+{ Initialize state with a linear congruential algorithm X = (aX + c) mod 2^m2exp }
+procedure randinit_lc_2exp(out state: MPRandState; var a: MPInteger; c, m2exp: valuint);
+{ Initialize state for a linear congruential algorithm as per gmp_randinit_lc_2exp }
+function randinit_lc_2exp_size(out state: MPRandState; size: sizeuint): boolean;
+{ Initialize state for a Mersenne Twister algorithm }
+procedure randinit_mt(out state: MPRandState);
+{ Initialize rop with a copy of the algorithm and state from op }
+procedure randinit_set(out rop: MPRandState; var op: MPRandState);
+{ Set an initial seed value into state }
+procedure randseed(var state: MPRandState; var seed: MPInteger);
+{ Set an initial seed value into state }
+procedure randseed_ui(var state: MPRandState; seed: valuint);
+{ Free all memory occupied by state }
+procedure randclear(var state: MPRandState);
+{ Return an uniformly distributed random number of n bits, ie. in the range 0 to 2^n−1 inclusive }
+function urandomb_ui(var state: MPRandState; n: valuint): valuint;
+{ Return an uniformly distributed random number in the range 0 to n − 1, inclusive }
+function urandomm_ui(var state: MPRandState; n: valuint): valuint;
+
+// ---- integer Functions ----
+
+{ Change the space for integer to new_alloc limbs }
+function z_realloc(var integer_: MPInteger; new_alloc: mp_size_t): pointer;
+{ Set rop to the absolute value of op }
+procedure z_abs(var rop, op: MPInteger);
+{ Return the absolute value of op }
+function z_abs(var op: MPInteger): MPInteger;
+{ Set rop to op1 + op2 }
+procedure z_add(var rop, op1, op2: MPInteger);
+{ Return op1 + op2 }
+function z_add(var op1, op2: MPInteger): MPInteger;
+{ Set rop to op1 + op2 }
+procedure z_add_ui(var rop, op1: MPInteger; op2: valuint);
+{ Return op1 + op2 }
+function z_add_ui(var op1: MPInteger; op2: valuint): MPInteger;
+{ Set rop to rop + op1 × op2 }
+procedure z_addmul(var rop, op1, op2: MPInteger);
+{ Set rop to rop + op1 × op2 }
+procedure z_addmul_ui(var rop, op1: MPInteger; op2: valuint);
+{ Set rop to op1 bitwise-and op2 }
+procedure z_and(var rop, op1, op2: MPInteger);
+{ Return op1 bitwise-and op2 }
+function z_and(var op1, op2: MPInteger): MPInteger;
+//{ _Fixed_ space of fixed_num_bits is allocated to each of the array size integers in integer array }
+//procedure z_array_init(var integer_array: MPInteger; array_size, fixed_num_bits: mp_size_t);
+{ Compute the binomial coefficient (n over k) and store the result in rop }
+procedure z_bin_ui(var rop, n: MPInteger; k: valuint);
+{ Return the binomial coefficient (n over k) }
+function z_bin_ui(var n: MPInteger; k: valuint): MPInteger;
+{ Compute the binomial coefficient (n over k) and store the result in rop }
+procedure z_bin_uiui(var rop: MPInteger; n, k: valuint);
+{ Return the binomial coefficient (n over k) }
+function z_bin_uiui(n, k: valuint): MPInteger;
+{ Divide n by d, forming a quotient q. Round mode ceil. }
+procedure z_cdiv_q(var q, n, d: MPInteger);
+{ Divide n by d, forming a return quotient. Round mode ceil. }
+function z_cdiv_q(var n, d: MPInteger): MPInteger;
+{ Divide n by d, forming a quotient q. d = 2^b. Round mode ceil. }
+procedure z_cdiv_q_2exp(var q, n: MPInteger; b: valuint);
+{ Divide n by d, forming a return quotient. d = 2^b. Round mode ceil. }
+function z_cdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
+{ Divide n by d, forming a quotient q. Round mode ceil. }
+function z_cdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
+{ Divide n by d, forming a quotient q and remainder r. Round mode ceil. }
+procedure z_cdiv_qr(var q, r, n, d: MPInteger);
+{ Divide n by d, forming a quotient q and remainder r. Round mode ceil. }
+function z_cdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
+{ Divide n by d, forming a remainder r. Round mode ceil. }
+procedure z_cdiv_r(var r, n, d: MPInteger);
+{ Divide n by d, forming a return remainder. Round mode ceil. }
+function z_cdiv_r(var n, d: MPInteger): MPInteger;
+{ Divide n by d, forming a remainder r. d = 2^b. Round mode ceil. }
+procedure z_cdiv_r_2exp(var r, n: MPInteger; b: valuint);
+{ Divide n by d, forming a return remainder. d = 2^b. Round mode ceil. }
+function z_cdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
+{ Divide n by d, forming a remainder r. Round mode ceil. }
+function z_cdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
+{ Divide n by d. Round mode ceil. }
+function z_cdiv_ui(var n: MPInteger; d: valuint): valuint;
+{ Free the space occupied by integer. Call this function for all MPInteger variables when you are done with them. }
+procedure z_clear(var integer_: MPInteger);
+{ Clear bit bit_index in rop }
+procedure z_clrbit(var rop: MPInteger; bit_index: valuint);
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
+function z_cmp(var op1, op2: MPInteger): longint;
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
+function z_cmp_d(var op1: MPInteger; op2: double): longint;
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
+function z_cmp_si(var op1: MPInteger; op2: valsint): longint;
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, or a negative value if op1 < op2. }
+function z_cmp_ui(var op1: MPInteger; op2: valuint): longint;
+{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
+function z_cmpabs(var op1, op2: MPInteger): longint;
+{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
+function z_cmpabs_d(var op1: MPInteger; op2: double): longint;
+{ Compare the absolute values of op1 and op2. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, or a negative value if |op1| < |op2|. }
+function z_cmpabs_ui(var op1: MPInteger; op2: valuint): longint;
+{ Set rop to the one’s complement of op }
+procedure z_com(var rop, op: MPInteger);
+{ Return the one’s complement of op }
+function z_com(var op: MPInteger): MPInteger;
+{ Complement bit bit_index in rop }
+procedure z_combit(var rop: MPInteger; bit_index: valuint);
+{ Return true if n is congruent to c modulo d }
+function z_congruent_p(var n, c, d: MPInteger): boolean;
+{ Return true if n is congruent to c modulo 2^b }
+function z_congruent_2exp_p(var n, c: MPInteger; b: valuint): boolean;
+{ Return true if n is congruent to c modulo d }
+function z_congruent_ui_p(var n: MPInteger; c, d: valuint): boolean;
+{ Set q to n/d }
+procedure z_divexact(var q, n, d: MPInteger);
+{ Return n/d }
+function z_divexact(var n, d: MPInteger): MPInteger;
+{ Set q to n/d }
+procedure z_divexact_ui(var q, n: MPInteger; d: valuint);
+{ Return n/d }
+function z_divexact_ui(var n: MPInteger; d: valuint): MPInteger;
+{ Return true if n is exactly divisible by d }
+function z_divisible_p(var n, d: MPInteger): boolean;
+{ Return true if n is exactly divisible by d }
+function z_divisible_ui_p(var n: MPInteger; d: valuint): boolean;
+{ Return true if n is exactly divisible by by 2^b }
+function z_divisible_2exp_p(var n: MPInteger; b: valuint): boolean;
+{ Fill buf with word data from op }
+function z_export(out buf; out countp: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; var op: MPInteger): pointer;
+{ Set rop to op!, the factorial of op }
+procedure z_fac_ui(var rop: MPInteger; op: valuint);
+{ Return op!, the factorial of op }
+function z_fac_ui(op: valuint): MPInteger;
+{ Divide n by d, forming a quotient q. Round mode floor. }
+procedure z_fdiv_q(var q, n, d: MPInteger);
+{ Divide n by d, forming a return quotient. Round mode floor. }
+function z_fdiv_q(var n, d: MPInteger): MPInteger;
+{ Divide n by d, forming a quotient q. d = 2^b. Round mode floor. }
+procedure z_fdiv_q_2exp(var q, n: MPInteger; b: valuint);
+{ Divide n by d, forming a return quotient. d = 2^b. Round mode floor. }
+function z_fdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
+{ Divide n by d, forming a quotient q. Round mode floor. }
+function z_fdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
+{ Divide n by d, forming a quotient q and remainder r. Round mode floor. }
+procedure z_fdiv_qr(var q, r, n, d: MPInteger);
+{ Divide n by d, forming a quotient q and remainder r. Round mode floor. }
+function z_fdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
+{ Divide n by d, forming a remainder r. Round mode floor. }
+procedure z_fdiv_r(var r, n, d: MPInteger);
+{ Divide n by d, forming a return remainder. Round mode floor. }
+function z_fdiv_r(var n, d: MPInteger): MPInteger;
+{ Divide n by d, forming a remainder r. d = 2^b. Round mode floor. }
+procedure z_fdiv_r_2exp(var r, n: MPInteger; b: valuint);
+{ Divide n by d, forming a return remainder. d = 2^b. Round mode floor. }
+function z_fdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
+{ Divide n by d, forming a remainder r. Round mode floor. }
+function z_fdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
+{ Divide n by d. Round mode floor. }
+function z_fdiv_ui(var n: MPInteger; d: valuint): valuint;
+{ Set fn to to Fn, the n’th Fibonacci number }
+procedure z_fib_ui(var fn: MPInteger; n: valuint);
+{ Return Fn, the n’th Fibonacci number }
+function z_fib_ui(n: valuint): MPInteger;
+{ Set fn to Fn, and fnsub1 to Fn−1 }
+procedure z_fib2_ui(var fn, fnsub1: MPInteger; n: valuint);
+{ Return Fn, and fnsub1 = Fn−1 }
+function z_fib2_ui(var fnsub1: MPInteger; n: valuint): MPInteger;
+{ Return true iff the value of op fits in an signed int }
+function z_fits_sint_p(var op: MPInteger): boolean;
+{ Return true iff the value of op fits in an signed long int }
+function z_fits_slong_p(var op: MPInteger): boolean;
+{ Return true iff the value of op fits in an signed short int }
+function z_fits_sshort_p(var op: MPInteger): boolean;
+{ Return true iff the value of op fits in an unsigned int }
+function z_fits_uint_p(var op: MPInteger): boolean;
+{ Return true iff the value of op fits in an unsigned long int }
+function z_fits_ulong_p(var op: MPInteger): boolean;
+{ Return true iff the value of op fits in an unsigned short int }
+function z_fits_ushort_p(var op: MPInteger): boolean;
+{ Set rop to the greatest common divisor of op1 and op2 }
+procedure z_gcd(var rop, op1, op2: MPInteger);
+{ Return the greatest common divisor of op1 and op2 }
+function z_gcd(var op1, op2: MPInteger): MPInteger;
+{ Compute the greatest common divisor of op1 and op2 }
+function z_gcd_ui(var rop, op1: MPInteger; op2: valuint): valuint;
+{ Set g to the greatest common divisor of a and b, and in addition set s and t to coefficients satisfying as + bt = g }
+procedure z_gcdext(var g, s, t, a, b: MPInteger);
+{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
+function z_get_d(var op: MPInteger): double;
+{ Convert op to a double, truncating if necessary (ie. rounding towards zero), and returning the exponent separately }
+function z_get_d_2exp(out exp: valsint; var op: MPInteger): double;
+{ Return the value of op as a signed long }
+function z_get_si(op: MPInteger): valsint;
+{ Convert op to a string of digits in base base. The base argument may vary from 2 to 62 or from −2 to −36. }
+function z_get_str(base: longint; var op: MPInteger): string;
+{ Convert op to a string of digits in base base. The base argument may vary from 2 to 62 or from −2 to −36. If str is NULL, the result string is allocated using the current allocation function }
+function z_get_str(str: pchar; base: longint; var op: MPInteger): pchar;
+{ Return the value of op as an unsigned long }
+function z_get_ui(op: MPInteger): valuint;
+{ Return limb number n from op }
+function z_getlimbn(var op: MPInteger; n: mp_size_t): mp_limb_t;
+{ If op1 and op2 are both >= 0 or both < 0, return the hamming distance between the two operands, which is the number of bit positions where op1 and op2 have different bit values }
+function z_hamdist(var op1, op2: MPInteger): valuint;
+{ Set rop from an array of word data at op }
+procedure z_import(var rop: MPInteger; count: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; const op);
+{ Initialize integer, and set its value to 0 }
+procedure z_init(out integer_: MPInteger);
+{ Initialize integer, with space for n bits, and set its value to 0 }
+procedure z_init2(out integer_: MPInteger; n: valuint);
+{ Initialize rop with limb space and set the initial numeric value from op }
+procedure z_init_set(out rop: MPInteger; var op: MPInteger);
+{ Initialize rop with limb space and set the initial numeric value from op }
+procedure z_init_set_d(out rop: MPInteger; op: double);
+{ Initialize rop with limb space and set the initial numeric value from op }
+procedure z_init_set_si(out rop: MPInteger; op: valsint);
+{ Initialize rop and set its value like z_set_str. If the string is a correct base base number, the function returns true. }
+function z_init_set_str(out rop: MPInteger; str: string; base: longint): boolean;
+{ Initialize rop with limb space and set the initial numeric value from op }
+procedure z_init_set_ui(out rop: MPInteger; op: valuint);
+{ Compute the inverse of op1 modulo op2 and put the result in rop }
+function z_invert(var rop, op1, op2: MPInteger): longint;
+{ Set rop to op1 bitwise inclusive-or op2 }
+procedure z_ior(var rop, op1, op2: MPInteger);
+{ Return bitwise inclusive-or op2 }
+function z_ior(var op1, op2: MPInteger): MPInteger;
+{ Calculate the Jacobi symbol. This is defined only for b odd }
+function z_jacobi(var a, b: MPInteger): longint;
+{ Calculate the Jacobi symbol with the Kronecker extension }
+function z_kronecker_si(var a: MPInteger; b: valsint): longint;
+{ Calculate the Jacobi symbol with the Kronecker extension }
+function z_kronecker_ui(var a: MPInteger; b: valuint): longint;
+{ Calculate the Jacobi symbol with the Kronecker extension }
+function z_si_kronecker(a: valsint; var b: MPInteger): longint;
+{ Calculate the Jacobi symbol with the Kronecker extension }
+function z_ui_kronecker(a: valuint; var b: MPInteger): longint;
+{ Set rop to the least common multiple of op1 and op2 }
+procedure z_lcm(var rop, op1, op2: MPInteger);
+{ Return the least common multiple of op1 and op2 }
+function z_lcm(var op1, op2: MPInteger): MPInteger;
+{ Set rop to the least common multiple of op1 and op2 }
+procedure z_lcm_ui(var rop, op1: MPInteger; op2: valuint);
+{ Return the least common multiple of op1 and op2 }
+function z_lcm_ui(var op1: MPInteger; op2: valuint): MPInteger;
+{ Set ln to to Ln, the n’th Lucas number }
+procedure z_lucnum_ui(var ln: MPInteger; n: valuint);
+{ Return Ln, the n’th Lucas number }
+function z_lucnum_ui(n: valuint): MPInteger;
+{ Set ln to Ln, and lnsub1 to Ln−1 }
+procedure z_lucnum2_ui(var ln, lnsub1: MPInteger; n: valuint);
+{ Return Ln, and lnsub1 to Ln−1 }
+function z_lucnum2_ui(var lnsub1: MPInteger; n: valuint): MPInteger;
+{ Set r to n mod d. The sign of the divisor is ignored; the result is always non-negative. }
+procedure z_mod(var r, n, d: MPInteger);
+{ Return n mod d. The sign of the divisor is ignored; the result is always non-negative. }
+function z_mod(var n, d: MPInteger): MPInteger;
+{ Set rop to op1 × op2 }
+procedure z_mul(var rop, op1, op2: MPInteger);
+{ Return op1 × op2 }
+function z_mul(var op1, op2: MPInteger): MPInteger;
+{ Set rop to op1 × 2^op2. This operation can also be defined as a left shift by op2 bits. }
+procedure z_mul_2exp(var rop, op1: MPInteger; op2: valuint);
+{ Return op1 × 2^op2. This operation can also be defined as a left shift by op2 bits. }
+function z_mul_2exp(var op1: MPInteger; op2: valuint): MPInteger;
+{ Set rop to op1 × op2 }
+procedure z_mul_si(var rop, op1: MPInteger; op2: valsint);
+{ Return op1 × op2 }
+function z_mul_si(var op1: MPInteger; op2: valsint): MPInteger;
+{ Set rop to op1 × op2 }
+procedure z_mul_ui(var rop, op1: MPInteger; op2: valuint);
+{ Return op1 × op2 }
+function z_mul_ui(var op1: MPInteger; op2: valuint): MPInteger;
+{ Set rop to −op }
+procedure z_neg(var rop, op: MPInteger);
+{ Return −op }
+function z_neg(var op: MPInteger): MPInteger;
+{ Set rop to the next prime greater than op }
+procedure z_nextprime(var rop, op: MPInteger);
+{ Return the next prime greater than op }
+function z_nextprime(var op: MPInteger): MPInteger;
+{ Return true if op is a perfect power, i.e., if there exist integers a and b, with b > 1, such that op = a^b }
+function z_perfect_power_p(var op: MPInteger): boolean;
+{ Return true if op is a perfect square, i.e., if the square root of op is an integer }
+function z_perfect_square_p(var op: MPInteger): boolean;
+{ If op >= 0, return the population count of op, which is the number of 1 bits in the binary representation }
+function z_popcount(var op: MPInteger): valuint;
+{ Set rop to base^exp. The case 0^0 yields 1. }
+procedure z_pow_ui(var rop, base: MPInteger; exp: valuint);
+{ Return base^exp. The case 0^0 yields 1. }
+function z_pow_ui(var base: MPInteger; exp: valuint): MPInteger;
+{ Set rop to base^exp mod mod_ }
+procedure z_powm(var rop, base, exp, mod_: MPInteger);
+{ Return base^exp mod mod_ }
+function z_powm(var base, exp, mod_: MPInteger): MPInteger;
+{ Set rop to base^exp mod mod_ }
+procedure z_powm_ui(var rop, base: MPInteger; exp: valuint; var mod_: MPInteger);
+{ Return base^exp mod mod_ }
+function z_powm_ui(var base: MPInteger; exp: valuint; var mod_: MPInteger): MPInteger;
+{ Determine whether n is prime. Return 2 if n is definitely prime, return 1 if n is probably prime (without being certain), or return 0 if n is definitely composite. }
+function z_probab_prime_p(var n: MPInteger; reps: longint): longint;
+{ Change the space allocated for integer to n bits. The value in integer is preserved if it fits, or is set to 0 if not. }
+procedure z_realloc2(var integer_: MPInteger; n: valuint);
+{ Remove all occurrences of the factor f from op and store the result in rop }
+function z_remove(var rop, op, f: MPInteger): valuint;
+{ Set rop to trunc(op^(1/n)), the truncated integer part of the nth root of op. Return true if the computation was exact, i.e., if op is rop to the nth power. }
+function z_root(var rop, op: MPInteger; n: valuint): boolean;
+{ Set root to trunc(u^(1/n)), the truncated integer part of the nth root of u. Set rem to the remainder, (u − root^n). }
+procedure z_rootrem(var root, rem, u: MPInteger; n: valuint);
+{ Generate a random integer with long strings of zeros and ones in the binary representation }
+procedure z_rrandomb(var rop: MPInteger; var state: MPRandState; n: valuint);
+{ Return a random integer with long strings of zeros and ones in the binary representation }
+function z_rrandomb(var state: MPRandState; n: valuint): MPInteger;
+{ Scan op, starting from bit starting_bit, towards more significant bits, until the first 0 bit is found }
+function z_scan0(var op: MPInteger; starting_bit: valuint): valuint;
+{ Scan op, starting from bit starting_bit, towards more significant bits, until the first 1 bit is found }
+function z_scan1(var op: MPInteger; starting_bit: valuint): valuint;
+{ Set the value of rop from op }
+procedure z_set(var rop, op: MPInteger);
+{ Set the value of rop from op }
+procedure z_set_d(var rop: MPInteger; op: double);
+{ Set the value of rop from op }
+procedure z_set_f(var rop: MPInteger; var op: MPFloat);
+{ Set the value of rop from op }
+procedure z_set_q(var rop: MPInteger; var op: MPRational);
+{ Set the value of rop from op }
+procedure z_set_si(var rop: MPInteger; op: valsint);
+{ Set the value of rop from str, a null-terminated C string in base base. If the string is a correct base base number, the function returns true. }
+function z_set_str(var rop: MPInteger; str: string; base: longint): boolean;
+{ Set the value of rop from op }
+procedure z_set_ui(var rop: MPInteger; op: valuint);
+{ Set bit bit_index in rop }
+procedure z_setbit(var rop: MPInteger; bit_index: valuint);
+{ Return the size of op measured in number of limbs }
+function z_size(var op: MPInteger): sizeuint;
+{ Return the size of op measured in number of digits in the given base }
+function z_sizeinbase(var op: MPInteger; base: longint): sizeuint;
+{ Set rop to trunc(sqrt(op)), the truncated integer part of the square root of op }
+procedure z_sqrt(var rop, op: MPInteger);
+{ Return trunc(sqrt(op)), the truncated integer part of the square root of op }
+function z_sqrt(var op: MPInteger): MPInteger;
+{ Set rop1 to trunc(sqrt(op)), like z_sqrt. Set rop2 to the remainder (op − rop1^2), which will be zero if op is a perfect square. }
+procedure z_sqrtrem(var rop1, rop2, op: MPInteger);
+{ Set rop to op1 − op2 }
+procedure z_sub(var rop, op1, op2: MPInteger);
+{ Return op1 − op2 }
+function z_sub(var op1, op2: MPInteger): MPInteger;
+{ Set rop to op1 − op2 }
+procedure z_sub_ui(var rop, op1: MPInteger; op2: valuint);
+{ Return op1 − op2 }
+function z_sub_ui(var op1: MPInteger; op2: valuint): MPInteger;
+{ Set rop to op1 − op2 }
+procedure z_ui_sub(var rop: MPInteger; op1: valuint; var op2: MPInteger);
+{ Return op1 − op2 }
+function z_ui_sub(op1: valuint; var op2: MPInteger): MPInteger;
+{ Set rop to rop − op1 × op2 }
+procedure z_submul(var rop, op1, op2: MPInteger);
+{ Set rop to rop − op1 × op2 }
+procedure z_submul_ui(var rop, op1: MPInteger; op2: valuint);
+{ Swap the values rop1 and rop2 efficiently }
+procedure z_swap(var rop1, rop2: MPInteger);
+{ Divide n by d, forming a quotient q. Round mode trunc. }
+procedure z_tdiv_q(var q, n, d: MPInteger);
+{ Divide n by d, forming a return quotient. Round mode trunc. }
+function z_tdiv_q(var n, d: MPInteger): MPInteger;
+{ Divide n by d, forming a quotient q. d = 2^b. Round mode trunc. }
+procedure z_tdiv_q_2exp(var q, n: MPInteger; b: valuint);
+{ Divide n by d, forming a return quotient. d = 2^b. Round mode trunc. }
+function z_tdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
+{ Divide n by d, forming a quotient q. Round mode trunc. }
+function z_tdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
+{ Divide n by d, forming a quotient q and remainder r. Round mode trunc. }
+procedure z_tdiv_qr(var q, r, n, d: MPInteger);
+{ Divide n by d, forming a quotient q and remainder r. Round mode trunc. }
+function z_tdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
+{ Divide n by d, forming a remainder r. Round mode trunc. }
+procedure z_tdiv_r(var r, n, d: MPInteger);
+{ Divide n by d, forming a return remainder. Round mode trunc. }
+function z_tdiv_r(var n, d: MPInteger): MPInteger;
+{ Divide n by d, forming a remainder r. d = 2^b. Round mode trunc. }
+procedure z_tdiv_r_2exp(var r, n: MPInteger; b: valuint);
+{ Divide n by d, forming a return remainder. d = 2^b. Round mode trunc. }
+function z_tdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
+{ Divide n by d, forming a remainder r. Round mode trunc. }
+function z_tdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
+{ Divide n by d. Round mode trunc. }
+function z_tdiv_ui(var n: MPInteger; d: valuint): valuint;
+{ Test bit bit_index in op and return true or false accordingly }
+function z_tstbit(var rop: MPInteger; bit_index: valuint): boolean;
+{ Set rop to base^exp. The case 0^0 yields 1 }
+procedure z_ui_pow_ui(var rop: MPInteger; base, exp: valuint);
+{ Return base^exp. The case 0^0 yields 1 }
+function z_ui_pow_ui(base, exp: valuint): MPInteger;
+{ Generate a uniformly distributed random integer in the range 0 to 2^n − 1, inclusive }
+procedure z_urandomb(var rop: MPInteger; var state: MPRandState; n: valuint);
+{ Return a uniformly distributed random integer in the range 0 to 2^n − 1, inclusive }
+function z_urandomb(var state: MPRandState; n: valuint): MPInteger;
+{ Generate a uniform random integer in the range 0 to n − 1, inclusive }
+procedure z_urandomm(var rop: MPInteger; var state: MPRandState; var n: MPInteger);
+{ Return a uniform random integer in the range 0 to n − 1, inclusive }
+function z_urandomm(var state: MPRandState; var n: MPInteger): MPInteger;
+{ Set rop to op1 bitwise exclusive-or op2 }
+procedure z_xor(var rop, op1, op2: MPInteger);
+{ Retuen op1 bitwise exclusive-or op2 }
+function z_xor(var op1, op2: MPInteger): MPInteger;
+
+// ---- Rational Number Functions ----
+
+{ Set rop to the absolute value of op }
+procedure q_abs(var rop, op: MPRational);
+{ Return absolute value of op }
+function q_abs(var op: MPRational): MPRational;
+{ Set sum to addend1 + addend2 }
+procedure q_add(var sum, addend1, addend2: MPRational);
+{ Return addend1 + addend2 }
+function q_add(var addend1, addend2: MPRational): MPRational;
+{ Remove any factors that are common to the numerator and denominator of op, and make the denominator positive }
+procedure q_canonicalize(var op: MPRational);
+{ Free the space occupied by rational number }
+procedure q_clear(var rational_number: MPRational);
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2 }
+function q_cmp(var op1, op2: MPRational): longint;
+{ Compare op1 and num2/den2. Return a positive value if op1 > num2/den2, zero if op1 = num2/den2, and a negative value if op1 < num2/den2 }
+function q_cmp_si(var op1: MPRational; num2: valsint; den2: valuint): longint;
+{ Compare op1 and num2/den2. Return a positive value if op1 > num2/den2, zero if op1 = num2/den2, and a negative value if op1 < num2/den2 }
+function q_cmp_ui(var op1: MPRational; num2, den2: valuint): longint;
+{ Set quotient to dividend/divisor }
+procedure q_div(var quotient, dividend, divisor: MPRational);
+{ Return dividend/divisor }
+function q_div(var dividend, divisor: MPRational): MPRational;
+{ Set rop to op1/(2^op2) }
+procedure q_div_2exp(var rop, op1: MPRational; op2: valuint);
+{ Return op1/(2^op2) }
+function q_div_2exp(var op1: MPRational; op2: valuint): MPRational;
+{ Return true if op1 and op2 are equal, false if they are non-equal }
+function q_equal(var op1, op2: MPRational): boolean;
+{ Get the numerator of a rational }
+procedure q_get_num(var numerator: MPInteger; var rational: MPRational);
+{ Return the numerator of a rational }
+function q_get_num(var rational: MPRational): MPInteger;
+{ Get the denominator of a rational }
+procedure q_get_den(var denominator: MPInteger; var rational: MPRational);
+{ Return the denominator of a rational }
+function q_get_den(var rational: MPRational): MPInteger;
+{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
+function q_get_d(var op: MPRational): double;
+{ Convert op to a string of digits in base base }
+function q_get_str(base: longint; var op: MPRational): string;
+{ Convert op to a string of digits in base base. If str is NULL, the result string is allocated using the current allocation function. }
+function q_get_str(str: pchar; base: longint; var op: MPRational): pchar;
+{ Initialize dest rational and set it to 0/1 }
+procedure q_init(out dest_rational: MPRational);
+{ Set inverted_number to 1/number }
+procedure q_inv(var inverted_number, number: MPRational);
+{ Return 1/number }
+function q_inv(var number: MPRational): MPRational;
+{ Set product to multiplier × multiplicand }
+procedure q_mul(var product, multiplier, multiplicand: MPRational);
+{ Return multiplier × multiplicand }
+function q_mul(var multiplier, multiplicand: MPRational): MPRational;
+{ Set rop to op1 × (2^op2) }
+procedure q_mul_2exp(var rop, op1: MPRational; op2: valuint);
+{ Return op1 × (2^op2) }
+function q_mul_2exp(var op1: MPRational; op2: valuint): MPRational;
+{ Set negated_operand to −operand }
+procedure q_neg(var negated_operand, operand: MPRational);
+{ Return −operand }
+function q_neg(var operand: MPRational): MPRational;
+{ Assign rop from op }
+procedure q_set(var rop, op: MPRational);
+{ Set rop to the value of op. There is no rounding, this conversion is exact. }
+procedure q_set_d(var rop: MPRational; op: double);
+{ Set the denominator of a rational }
+procedure q_set_den(var rational: MPRational; var denominator: MPInteger);
+{ Set rop to the value of op. There is no rounding, this conversion is exact. }
+procedure q_set_f(var rop: MPRational; var op: MPFloat);
+{ Set the numerator of a rational }
+procedure q_set_num(var rational: MPRational; var numerator: MPInteger);
+{ Set the value of rop to op1/op2 }
+procedure q_set_si(var rop: MPRational; op1: valsint; op2: valuint);
+{ Set rop from a null-terminated string str in the given base. The return value is true if the entire string is a valid number. }
+function q_set_str(var rop: MPRational; str: string; base: longint): boolean;
+{ Set the value of rop to op1/op2 }
+procedure q_set_ui(var rop: MPRational; op1, op2: valuint);
+{ Assign rop from op }
+procedure q_set_z(var rop: MPRational; var op: MPInteger);
+{ Set difference to minuend − subtrahend }
+procedure q_sub(var difference, minuend, subtrahend: MPRational);
+{ Return minuend − subtrahend }
+function q_sub(var minuend, subtrahend: MPRational): MPRational;
+{ Swap the values rop1 and rop2 efficiently }
+procedure q_swap(var rop1, rop2: MPRational);
+
+// ---- Floating-point Functions ----
+
+{ Set rop to the absolute value of op }
+procedure f_abs(var rop, op: MPFloat);
+{ Return the absolute value of op }
+function f_abs(var op: MPFloat): MPFloat;
+{ Set rop to op1 + op2 }
+procedure f_add(var rop, op1, op2: MPFloat);
+{ Return op1 + op2 }
+function f_add(var op1, op2: MPFloat): MPFloat;
+{ Set rop to op1 + op2 }
+procedure f_add_ui(var rop, op1: MPFloat; op2: valuint);
+{ Return op1 + op2 }
+function f_add_ui(var op1: MPFloat; op2: valuint): MPFloat;
+{ Set rop to op rounded to the next higher integer }
+procedure f_ceil(var rop, op: MPFloat);
+{ Return op rounded to the next higher integer }
+function f_ceil(var op: MPFloat): MPFloat;
+{ Free the space occupied by x }
+procedure f_clear(var x: MPFloat);
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
+function f_cmp(var op1, op2: MPFloat): longint;
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
+function f_cmp_d(var op1: MPFloat; op2: double): longint;
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
+function f_cmp_si(var op1: MPFloat; op2: valsint): longint;
+{ Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. }
+function f_cmp_ui(var op1: MPFloat; op2: valuint): longint;
+{ Set rop to op1/op2 }
+procedure f_div(var rop, op1, op2: MPFloat);
+{ Return op1/op2 }
+function f_div(var op1, op2: MPFloat): MPFloat;
+{ Set rop to op1/(2^op2) }
+procedure f_div_2exp(var rop, op1: MPFloat; op2: valuint);
+{ Return op1/(2^op2) }
+function f_div_2exp(var op1: MPFloat; op2: valuint): MPFloat;
+{ Set rop to op1/op2 }
+procedure f_div_ui(var rop, op1: MPFloat; op2: valuint);
+{ Return op1/op2 }
+function f_div_ui(var op1: MPFloat; op2: valuint): MPFloat;
+{ Return true if the first op3 bits of op1 and op2 are equal, false otherwise }
+function f_eq(var op1, op2: MPFloat; op3: valuint): boolean;
+{ Return true if op would fit in the respective C data type, when truncated to an integer }
+function f_fits_sint_p(var op: MPFloat): boolean;
+{ Return true if op would fit in the respective C data type, when truncated to an integer }
+function f_fits_slong_p(var op: MPFloat): boolean;
+{ Return true if op would fit in the respective C data type, when truncated to an integer }
+function f_fits_sshort_p(var op: MPFloat): boolean;
+{ Return true if op would fit in the respective C data type, when truncated to an integer }
+function f_fits_uint_p(var op: MPFloat): boolean;
+{ Return true if op would fit in the respective C data type, when truncated to an integer }
+function f_fits_ulong_p(var op: MPFloat): boolean;
+{ Return true if op would fit in the respective C data type, when truncated to an integer }
+function f_fits_ushort_p(var op: MPFloat): boolean;
+{ Set rop to op rounded to the next lower }
+procedure f_floor(var rop, op: MPFloat);
+{ Return op rounded to the next lower }
+function f_floor(var op: MPFloat): MPFloat;
+{ Convert op to a double, truncating if necessary (ie. rounding towards zero) }
+function f_get_d(var op: MPFloat): double;
+{ Convert op to a double, truncating if necessary (ie. rounding towards zero), and with an exponent returned separately }
+function f_get_d_2exp(out exp: valsint; var op: MPFloat): double;
+{ Return the default precision actually used }
+function f_get_default_prec: valuint;
+{ Return the current precision of op, in bits }
+function f_get_prec(var op: MPFloat): valuint;
+{ Convert op to a long, truncating any fraction part }
+function f_get_si(var op: MPFloat): valsint;
+{ Convert op to a string of digits in base base }
+function f_get_str(out exp: mp_exp_t; base: longint; ndigits: sizeuint; var op: MPFloat): string;
+{ Convert op to a string of digits in base base. If str is NULL, the result string is allocated using the current allocation function. }
+function f_get_str(str: pchar; out exp: mp_exp_t; base: longint; ndigits: sizeuint; var op: MPFloat): pchar;
+{ Convert op to a unsigned long, truncating any fraction part }
+function f_get_ui(var op: MPFloat): valuint;
+{ Initialize x to 0 }
+procedure f_init(out x: MPFloat);
+{ Initialize x to 0 and set its precision to be at least prec bits }
+procedure f_init2(out x: MPFloat; prec: valuint);
+{ Initialize rop and set its value from op }
+procedure f_init_set(out rop: MPFloat; var op: MPFloat);
+{ Initialize rop and set its value from op }
+procedure f_init_set_d(out rop: MPFloat; op: double);
+{ Initialize rop and set its value from op }
+procedure f_init_set_si(out rop: MPFloat; op: valsint);
+{ Initialize rop and set its value from the string in str. Returns true if the entire string is a valid number in base base. }
+function f_init_set_str(out rop: MPFloat; str: string; base: longint): boolean;
+{ Initialize rop and set its value from op }
+procedure f_init_set_ui(out rop: MPFloat; op: valuint);
+{ Return true if op is an integer }
+function f_integer_p(var op: MPFloat): boolean;
+{ Set rop to op1 × op2 }
+procedure f_mul(var rop, op1, op2: MPFloat);
+{ Return op1 × op2 }
+function f_mul(var op1, op2: MPFloat): MPFloat;
+{ Set rop to op1 × (2^op2) }
+procedure f_mul_2exp(var rop, op1: MPFloat; op2: valuint);
+{ Return op1 × (2^op2) }
+function f_mul_2exp(var op1: MPFloat; op2: valuint): MPFloat;
+{ Set rop to op1 × op2 }
+procedure f_mul_ui(var rop, op1: MPFloat; op2: valuint);
+{ Return op1 × op2 }
+function f_mul_ui(var op1: MPFloat; op2: valuint): MPFloat;
+{ Set rop to −op }
+procedure f_neg(var rop, op: MPFloat);
+{ Return −op }
+function f_neg(var op: MPFloat): MPFloat;
+{ Set rop to op1^op2 }
+procedure f_pow_ui(var rop, op1: MPFloat; op2: valuint);
+{ Return op1^op2 }
+function f_pow_ui(var op1: MPFloat; op2: valuint): MPFloat;
+{ Generate a random float of at most max_size limbs, with long strings of zeros and ones in the binary representation }
+procedure f_random2(var rop: MPFloat; max_size: mp_size_t; exp: mp_exp_t);
+{ Return a random float of at most max_size limbs, with long strings of zeros and ones in the binary representation }
+function f_random2(max_size: mp_size_t; exp: mp_exp_t): MPFloat;
+{ Compute the relative difference between op1 and op2 and store the result in rop }
+procedure f_reldiff(var rop, op1, op2: MPFloat);
+{ Return the relative difference between op1 and op2 }
+function f_reldiff(var op1, op2: MPFloat): MPFloat;
+{ Set the value of rop from op }
+procedure f_set(var rop, op: MPFloat);
+{ Set the value of rop from op }
+procedure f_set_d(var rop: MPFloat; op: double);
+{ Set the default precision to be at least prec bits }
+procedure f_set_default_prec(prec: valuint);
+{ Set the precision of rop to be at least prec bits }
+procedure f_set_prec(var rop: MPFloat; prec: valuint);
+{ Set the precision of rop to be at least prec bits, without changing the memory allocated }
+procedure f_set_prec_raw(var rop: MPFloat; prec: valuint);
+{ Set the value of rop from op }
+procedure f_set_q(var rop: MPFloat; var op: MPRational);
+{ Set the value of rop from op }
+procedure f_set_si(var rop: MPFloat; op: valsint);
+{ Set the value of rop from the string in str. Returns true if the entire string is a valid number in base base. }
+function f_set_str(var rop: MPFloat; str: string; base: longint): boolean;
+{ Set the value of rop from op }
+procedure f_set_ui(var rop: MPFloat; op: valuint);
+{ Set the value of rop from op }
+procedure f_set_z(var rop: MPFloat; var op: MPInteger);
+{ Set rop to op^(1/2) }
+procedure f_sqrt(var rop, op: MPFloat);
+{ Return op^(1/2) }
+function f_sqrt(var op: MPFloat): MPFloat;
+{ Set rop to op^(1/2) }
+procedure f_sqrt_ui(var rop: MPFloat; op: valuint);
+{ Return op^(1/2) }
+function f_sqrt_ui(op: valuint): MPFloat;
+{ Set rop to op1 − op2 }
+procedure f_sub(var rop, op1, op2: MPFloat);
+{ Return op1 − op2 }
+function f_sub(var op1, op2: MPFloat): MPFloat;
+{ Set rop to op1 − op2 }
+procedure f_sub_ui(var rop, op1: MPFloat; op2: valuint);
+{ Return op1 − op2 }
+function f_sub_ui(var op1: MPFloat; op2: valuint): MPFloat;
+{ Swap rop1 and rop2 efficiently }
+procedure f_swap(var rop1, rop2: MPFloat);
+{ Set rop to op rounded to the integer towards zero }
+procedure f_trunc(var rop, op: MPFloat);
+{ Return op rounded to the integer towards zero }
+function f_trunc(var op: MPFloat): MPFloat;
+{ Set rop to op1/op2 }
+procedure f_ui_div(var rop: MPFloat; op1: valuint; var op2: MPFloat);
+{ Return op1/op2 }
+function f_ui_div(op1: valuint; var op2: MPFloat): MPFloat;
+{ Set rop to op1 − op2 }
+procedure f_ui_sub(var rop: MPFloat; op1: valuint; var op2: MPFloat);
+{ Return op1 − op2 }
+function f_ui_sub(op1: valuint; var op2: MPFloat): MPFloat;
+{ Generate a uniformly distributed random float in rop, such that 0 <= rop < 1, with nbits significant bits in the mantissa }
+procedure f_urandomb(var rop: MPFloat; var state: MPRandState; nbits: valuint);
+{ Return a uniformly distributed random float, such that 0 <= result < 1, with nbits significant bits in the mantissa }
+function f_urandomb(var state: MPRandState; nbits: valuint): MPFloat;
+
+// ---- operators ----
+
+operator * (op1: MPFloat; op2: MPFloat): MPFloat; inline;
+operator * (op1: MPInteger; op2: MPInteger): MPInteger; inline;
+operator * (op1: MPRational; op2: MPRational): MPRational; inline;
+operator ** (op1: MPFloat; op2: valuint): MPFloat; inline;
+operator ** (op1: MPInteger; op2: valuint): MPInteger; inline;
+operator + (op1: MPFloat; op2: MPFloat): MPFloat; inline;
+operator + (op1: MPInteger; op2: MPInteger): MPInteger; inline;
+operator + (op1: MPRational; op2: MPRational): MPRational; inline;
+operator - (op: MPFloat): MPFloat; inline;
+operator - (op: MPInteger): MPInteger; inline;
+operator - (op: MPRational): MPRational; inline;
+operator - (op1: MPFloat; op2: MPFloat): MPFloat; inline;
+operator - (op1: MPInteger; op2: MPInteger): MPInteger; inline;
+operator - (op1: MPRational; op2: MPRational): MPRational; inline;
+operator / (op1: MPFloat; op2: MPFloat): MPFloat; inline;
+operator / (op1: MPInteger; op2: MPInteger): MPInteger; inline;
+operator / (op1: MPRational; op2: MPRational): MPRational; inline;
+operator := (op: double): MPFloat; inline;
+operator := (op: double): MPInteger; inline;
+operator := (op: double): MPRational; inline;
+operator := (op: MPFloat): Cardinal; inline;
+operator := (op: MPFloat): double; inline;
+operator := (op: MPFloat): integer; inline;
+operator := (op: MPFloat): mpf_t; inline;
+operator := (op: MPFloat): MPInteger; inline;
+operator := (op: MPFloat): MPRational; inline;
+operator := (op: MPFloat): string; inline;
+{$ifdef CPU64}
+operator := (op: MPFloat): valsint; inline;
+operator := (op: MPFloat): valuint; inline;
+{$endif}
+operator := (var op: mpf_t): MPFloat; inline;
+operator := (op: MPInteger): cardinal; inline;
+operator := (op: MPInteger): double; inline;
+operator := (op: MPInteger): integer; inline;
+operator := (op: MPInteger): MPFloat; inline;
+operator := (op: MPInteger): MPRational; inline;
+operator := (op: MPInteger): mpz_t; inline;
+operator := (op: MPInteger): string; inline;
+{$ifdef CPU64}
+operator := (op: MPInteger): valsint; inline;
+operator := (op: MPInteger): valuint; inline;
+{$endif}
+operator := (var op: mpq_t): MPRational; inline;
+operator := (op: MPRandState): randstate_t; inline;
+operator := (op: MPRational): double; inline;
+operator := (op: MPRational): MPFloat; inline;
+operator := (op: MPRational): MPInteger; inline;
+operator := (op: MPRational): mpq_t; inline;
+operator := (op: MPRational): string; inline;
+operator := (var op: mpz_t): MPInteger; inline;
+operator := (var op: randstate_t): MPRandState; inline;
+operator := (op: string): MPFloat; inline;
+operator := (op: string): MPInteger; inline;
+operator := (op: string): MPRational; inline;
+operator := (op: valsint): MPFloat; inline;
+operator := (op: valsint): MPInteger; inline;
+operator := (op: valsint): MPRational; inline;
+operator := (op: valuint): MPFloat; inline;
+operator := (op: valuint): MPInteger; inline;
+operator := (op: valuint): MPRational; inline;
+operator < (op1: MPFloat; op2: MPFloat): boolean; inline;
+operator < (op1: MPInteger; op2: MPInteger): boolean; inline;
+operator < (op1: MPRational; op2: MPRational): boolean; inline;
+operator <= (op1: MPFloat; op2: MPFloat): boolean; inline;
+operator <= (op1: MPInteger; op2: MPInteger): boolean; inline;
+operator <= (op1: MPRational; op2: MPRational): boolean; inline;
+operator > (op1: MPFloat; op2: MPFloat): boolean; inline;
+operator > (op1: MPInteger; op2: MPInteger): boolean; inline;
+operator > (op1: MPRational; op2: MPRational): boolean; inline;
+operator >= (op1: MPFloat; op2: MPFloat): boolean; inline;
+operator >= (op1: MPInteger; op2: MPInteger): boolean; inline;
+operator >= (op1: MPRational; op2: MPRational): boolean; inline;
+// compiler doesn't like theese
+// operator = (op1: MPFloat; op2: MPFloat): boolean; inline;
+// operator = (op1: MPInteger; op2: MPInteger): boolean; inline;
+// operator = (op1: MPRational; op2: MPRational): boolean; inline;
+
+implementation
+
+uses
+  math;
+
+{$ifndef NO_GMP_GLOBVARS}
+var
+  __gmp_bits_per_limb: longint; cvar; external;
+  __gmp_errno: longint; cvar; external;
+  __gmp_version: pchar; cvar; external;
+
+function bits_per_limb: longint;
+begin
+  result := __gmp_bits_per_limb;
+end;
+
+function errno: longint;
+begin
+  result := __gmp_errno;
+end;
+
+function version: string;
+begin
+  result := __gmp_version;
+end;
+
+{$else NO_GMP_GLOBVARS}
+function bits_per_limb: longint;
+const BITS_PER_BYTE = 8;
+begin
+  result := sizeof(mp_limb_t) * BITS_PER_BYTE;
+end;
+
+function errno: longint;
+begin
+  result := 0;
+end;
+
+function version: string;
+const NO_VER = '0.0.0';
+begin
+  result := NO_VER;
+end;
+{$endif NO_GMP_GLOBVARS}
+
+// ---- ext types ----
+
+{ TMPBase }
+
+function TMPBase.refs: longint;
+begin
+  result := frefcount;
+end;
+
+{ TMPInteger }
+
+function TMPInteger.ptr: mpz_ptr;
+begin
+  result := @fmpz
+end;
+
+destructor TMPInteger.destroy;
+begin
+  mpz_clear(fmpz);
+  inherited destroy;
+end;
+
+{ TMPFloat }
+
+function TMPFloat.ptr: mpf_ptr;
+begin
+  result := @fmpf;
+end;
+
+destructor TMPFloat.destroy;
+begin
+  mpf_clear(fmpf);
+  inherited destroy;
+end;
+
+{ TMPRational }
+
+function TMPRational.ptr: mpq_ptr;
+begin
+  result := @fmpq;
+end;
+
+destructor TMPRational.destroy;
+begin
+  mpq_clear(fmpq);
+  inherited destroy;
+end;
+
+{ TMPRandState }
+
+function TMPRandState.ptr: randstate_ptr;
+begin
+  result := @frandstate;
+end;
+
+destructor TMPRandState.destroy;
+begin
+  mp_randclear(frandstate);
+  inherited destroy;
+end;
+
+// --- helpers ----
+
+function dest(var rop: MPInteger): mpz_ptr;
+begin
+  if (not assigned(rop)) or (rop.refs > 1) then
+    z_init(rop);
+  result := rop.ptr;
+end;
+
+function dest(var rop: MPFloat): mpf_ptr;
+begin
+  if (not assigned(rop)) or (rop.refs > 1) then
+    f_init(rop);
+  result := rop.ptr;
+end;
+
+function dest(var rop: MPRational): mpq_ptr;
+begin
+  if (not assigned(rop)) or (rop.refs > 1) then
+    q_init(rop);
+  result := rop.ptr;
+end;
+
+function dest(var rop: MPRandState): randstate_ptr;
+begin
+  if (not assigned(rop)) or (rop.refs > 1) then
+    randinit_default(rop);
+  result := rop.ptr;
+end;
+
+function src(var rop: MPInteger): mpz_ptr;
+begin
+  if not assigned(rop) then
+    z_init(rop);
+  result := rop.ptr;
+end;
+
+function src(var rop: MPFloat): mpf_ptr;
+begin
+  if not assigned(rop) then
+    f_init(rop);
+  result := rop.ptr;
+end;
+
+function src(var rop: MPRational): mpq_ptr;
+begin
+  if not assigned(rop) then
+    q_init(rop);
+  result := rop.ptr;
+end;
+
+function src(var rop: MPRandState): randstate_ptr;
+begin
+  if not assigned(rop) then
+    randinit_default(rop);
+  result := rop.ptr;
+end;
+
+procedure propagate_prec(var result, op: MPFloat);
+begin
+  f_set_prec(result, f_get_prec(op));
+end;
+
+procedure propagate_prec(var result, op1, op2: MPFloat);
+begin
+  f_set_prec(result, max(valsint(f_get_prec(op1)), f_get_prec(op2)));
+end;
+
+// --- ext bindings ----
+
+procedure randinit_default(out state: MPRandState);
+begin
+  state := TMPRandState.Create;
+  mp_randinit_default(state.ptr^);
+end;
+
+procedure randinit_lc_2exp(out state: MPRandState; var a: MPInteger; c, m2exp: valuint);
+begin
+  state := TMPRandState.Create;
+  mp_randinit_lc_2exp(state.ptr^, src(a)^, c, m2exp);
+end;
+
+function randinit_lc_2exp_size(out state: MPRandState; size: sizeuint): boolean;
+begin
+  state := TMPRandState.Create;
+  result := mp_randinit_lc_2exp_size(state.ptr^, size) <> 0;
+end;
+
+procedure randinit_mt(out state: MPRandState);
+begin
+  state := TMPRandState.Create;
+  mp_randinit_mt(state.ptr^);
+end;
+
+procedure randinit_set(out rop: MPRandState; var op: MPRandState);
+begin
+  rop := TMPRandState.Create;
+  mp_randinit_set(rop.ptr^, src(op)^);
+end;
+
+procedure randseed(var state: MPRandState; var seed: MPInteger);
+begin
+  mp_randseed(dest(state)^, src(seed)^);
+end;
+
+procedure randseed_ui(var state: MPRandState; seed: valuint);
+begin
+  mp_randseed_ui(dest(state)^, seed);
+end;
+
+procedure randclear(var state: MPRandState);
+begin
+  state := nil;
+end;
+
+function urandomb_ui(var state: MPRandState; n: valuint): valuint;
+begin
+  result := mp_urandomb_ui(dest(state)^, n);
+end;
+
+function urandomm_ui(var state: MPRandState; n: valuint): valuint;
+begin
+  result := mp_urandomb_ui(dest(state)^, n);
+end;
+
+function z_realloc(var integer_: MPInteger; new_alloc: mp_size_t): pointer;
+begin
+  result := mpz_realloc(dest(integer_)^, new_alloc);
+end;
+
+procedure z_abs(var rop, op: MPInteger);
+begin
+  mpz_abs(dest(rop)^, src(op)^);
+end;
+
+function z_abs(var op: MPInteger): MPInteger;
+begin
+  mpz_abs(dest(result)^, src(op)^);
+end;
+
+procedure z_add(var rop, op1, op2: MPInteger);
+begin
+  mpz_add(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function z_add(var op1, op2: MPInteger): MPInteger;
+begin
+  mpz_add(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+procedure z_add_ui(var rop, op1: MPInteger; op2: valuint);
+begin
+  mpz_add_ui(dest(rop)^, src(op1)^, op2);
+end;
+
+function z_add_ui(var op1: MPInteger; op2: valuint): MPInteger;
+begin
+  mpz_add_ui(dest(result)^, src(op1)^, op2);
+end;
+
+procedure z_addmul(var rop, op1, op2: MPInteger);
+begin
+  mpz_addmul(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+procedure z_addmul_ui(var rop, op1: MPInteger; op2: valuint);
+begin
+  mpz_addmul_ui(dest(rop)^, src(op1)^, op2);
+end;
+
+procedure z_and(var rop, op1, op2: MPInteger);
+begin
+  mpz_and(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function z_and(var op1, op2: MPInteger): MPInteger;
+begin
+  mpz_and(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+procedure z_bin_ui(var rop, n: MPInteger; k: valuint);
+begin
+  mpz_bin_ui(dest(rop)^, src(n)^, k);
+end;
+
+function z_bin_ui(var n: MPInteger; k: valuint): MPInteger;
+begin
+  mpz_bin_ui(dest(result)^, src(n)^, k);
+end;
+
+procedure z_bin_uiui(var rop: MPInteger; n, k: valuint);
+begin
+  mpz_bin_uiui(dest(rop)^, n, k);
+end;
+
+function z_bin_uiui(n, k: valuint): MPInteger;
+begin
+  mpz_bin_uiui(dest(result)^, n, k);
+end;
+
+procedure z_cdiv_q(var q, n, d: MPInteger);
+begin
+  mpz_cdiv_q(dest(q)^, src(n)^, src(d)^);
+end;
+
+function z_cdiv_q(var n, d: MPInteger): MPInteger;
+begin
+  mpz_cdiv_q(dest(result)^, src(n)^, src(d)^);
+end;
+
+procedure z_cdiv_q_2exp(var q, n: MPInteger; b: valuint);
+begin
+  mpz_cdiv_q_2exp(dest(q)^, src(n)^, b);
+end;
+
+function z_cdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
+begin
+  mpz_cdiv_q_2exp(dest(result)^, src(n)^, b);
+end;
+
+function z_cdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_cdiv_q_ui(dest(q)^, src(n)^, d);
+end;
+
+procedure z_cdiv_qr(var q, r, n, d: MPInteger);
+begin
+  mpz_cdiv_qr(dest(q)^, dest(r)^, src(n)^, src(d)^);
+end;
+
+function z_cdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_cdiv_qr_ui(dest(q)^, dest(r)^, src(n)^, d);
+end;
+
+procedure z_cdiv_r(var r, n, d: MPInteger);
+begin
+  mpz_cdiv_r(dest(r)^, src(n)^, src(d)^);
+end;
+
+function z_cdiv_r(var n, d: MPInteger): MPInteger;
+begin
+  mpz_cdiv_r(dest(result)^, src(n)^, src(d)^);
+end;
+
+procedure z_cdiv_r_2exp(var r, n: MPInteger; b: valuint);
+begin
+  mpz_cdiv_r_2exp(dest(r)^, src(n)^, b);
+end;
+
+function z_cdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
+begin
+  mpz_cdiv_r_2exp(dest(result)^, src(n)^, b);
+end;
+
+function z_cdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_cdiv_r_ui(dest(r)^, src(n)^, d);
+end;
+
+function z_cdiv_ui(var n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_cdiv_ui(src(n)^, d);
+end;
+
+procedure z_clear(var integer_: MPInteger);
+begin
+  integer_ := nil;
+end;
+
+procedure z_clrbit(var rop: MPInteger; bit_index: valuint);
+begin
+  mpz_clrbit(dest(rop)^, bit_index);
+end;
+
+function z_cmp(var op1, op2: MPInteger): longint;
+begin
+  result := mpz_cmp(src(op1)^, src(op2)^);
+end;
+
+function z_cmp_d(var op1: MPInteger; op2: double): longint;
+begin
+  result := mpz_cmp_d(src(op1)^, op2);
+end;
+
+function z_cmp_si(var op1: MPInteger; op2: valsint): longint;
+begin
+  result := mpz_cmp_si(src(op1)^, op2);
+end;
+
+function z_cmp_ui(var op1: MPInteger; op2: valuint): longint;
+begin
+  result := mpz_cmp_ui(src(op1)^, op2);
+end;
+
+function z_cmpabs(var op1, op2: MPInteger): longint;
+begin
+  result := mpz_cmpabs(src(op1)^, src(op2)^);
+end;
+
+function z_cmpabs_d(var op1: MPInteger; op2: double): longint;
+begin
+  result := mpz_cmpabs_d(src(op1)^, op2);
+end;
+
+function z_cmpabs_ui(var op1: MPInteger; op2: valuint): longint;
+begin
+  result := mpz_cmpabs_ui(src(op1)^, op2);
+end;
+
+procedure z_com(var rop, op: MPInteger);
+begin
+  mpz_com(dest(rop)^, src(op)^);
+end;
+
+function z_com(var op: MPInteger): MPInteger;
+begin
+  mpz_com(dest(result)^, src(op)^);
+end;
+
+procedure z_combit(var rop: MPInteger; bit_index: valuint);
+begin
+  mpz_combit(dest(rop)^, bit_index);
+end;
+
+function z_congruent_p(var n, c, d: MPInteger): boolean;
+begin
+  result := mpz_congruent_p(src(n)^, src(c)^, src(d)^) <> 0;
+end;
+
+function z_congruent_2exp_p(var n, c: MPInteger; b: valuint): boolean;
+begin
+  result := mpz_congruent_2exp_p(src(n)^, src(c)^, b) <> 0;
+end;
+
+function z_congruent_ui_p(var n: MPInteger; c, d: valuint): boolean;
+begin
+  result := mpz_congruent_ui_p(src(n)^, c, d) <> 0;
+end;
+
+procedure z_divexact(var q, n, d: MPInteger);
+begin
+  mpz_divexact(dest(q)^, src(n)^, src(d)^);
+end;
+
+function z_divexact(var n, d: MPInteger): MPInteger;
+begin
+  mpz_divexact(dest(result)^, src(n)^, src(d)^);
+end;
+
+procedure z_divexact_ui(var q, n: MPInteger; d: valuint);
+begin
+  mpz_divexact_ui(dest(q)^, src(n)^, d);
+end;
+
+function z_divexact_ui(var n: MPInteger; d: valuint): MPInteger;
+begin
+  mpz_divexact_ui(dest(result)^, src(n)^, d);
+end;
+
+function z_divisible_p(var n, d: MPInteger): boolean;
+begin
+  result := mpz_divisible_p(src(n)^, src(d)^) <> 0;
+end;
+
+function z_divisible_ui_p(var n: MPInteger; d: valuint): boolean;
+begin
+  result := mpz_divisible_ui_p(src(n)^, d) <> 0;
+end;
+
+function z_divisible_2exp_p(var n: MPInteger; b: valuint): boolean;
+begin
+  result := mpz_divisible_2exp_p(src(n)^, b) <> 0;
+end;
+
+function z_export(out buf; out countp: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; var op: MPInteger): pointer;
+begin
+  result := mpz_export(buf, countp, order, size, endian, nails, src(op)^);
+end;
+
+procedure z_fac_ui(var rop: MPInteger; op: valuint);
+begin
+  mpz_fac_ui(dest(rop)^, op);
+end;
+
+function z_fac_ui(op: valuint): MPInteger;
+begin
+  mpz_fac_ui(dest(result)^, op);
+end;
+
+procedure z_fdiv_q(var q, n, d: MPInteger);
+begin
+  mpz_fdiv_q(dest(q)^, src(n)^, src(d)^);
+end;
+
+function z_fdiv_q(var n, d: MPInteger): MPInteger;
+begin
+  mpz_fdiv_q(dest(result)^, src(n)^, src(d)^);
+end;
+
+procedure z_fdiv_q_2exp(var q, n: MPInteger; b: valuint);
+begin
+  mpz_fdiv_q_2exp(dest(q)^, src(n)^, b);
+end;
+
+function z_fdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
+begin
+  mpz_fdiv_q_2exp(dest(result)^, src(n)^, b);
+end;
+
+function z_fdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_fdiv_q_ui(dest(q)^, src(n)^, d);
+end;
+
+procedure z_fdiv_qr(var q, r, n, d: MPInteger);
+begin
+  mpz_fdiv_qr(dest(q)^, dest(r)^, src(n)^, src(d)^);
+end;
+
+function z_fdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_fdiv_qr_ui(dest(q)^, dest(r)^, src(n)^, d);
+end;
+
+procedure z_fdiv_r(var r, n, d: MPInteger);
+begin
+  mpz_fdiv_r(dest(r)^, src(n)^, src(d)^);
+end;
+
+function z_fdiv_r(var n, d: MPInteger): MPInteger;
+begin
+  mpz_fdiv_r(dest(result)^, src(n)^, src(d)^);
+end;
+
+procedure z_fdiv_r_2exp(var r, n: MPInteger; b: valuint);
+begin
+  mpz_fdiv_r_2exp(dest(r)^, src(n)^, b);
+end;
+
+function z_fdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
+begin
+  mpz_fdiv_r_2exp(dest(result)^, src(n)^, b);
+end;
+
+function z_fdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_fdiv_r_ui(dest(r)^, src(n)^, d);
+end;
+
+function z_fdiv_ui(var n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_fdiv_ui(src(n)^, d);
+end;
+
+procedure z_fib_ui(var fn: MPInteger; n: valuint);
+begin
+  mpz_fib_ui(dest(fn)^, n);
+end;
+
+function z_fib_ui(n: valuint): MPInteger;
+begin
+  mpz_fib_ui(dest(result)^, n);
+end;
+
+procedure z_fib2_ui(var fn, fnsub1: MPInteger; n: valuint);
+begin
+  mpz_fib2_ui(dest(fn)^, dest(fnsub1)^, n);
+end;
+
+function z_fib2_ui(var fnsub1: MPInteger; n: valuint): MPInteger;
+begin
+  mpz_fib2_ui(dest(result)^, dest(fnsub1)^, n);
+end;
+
+function z_fits_sint_p(var op: MPInteger): boolean;
+begin
+  result := mpz_fits_sint_p(src(op)^) <> 0;
+end;
+
+function z_fits_slong_p(var op: MPInteger): boolean;
+begin
+  result := mpz_fits_slong_p(src(op)^) <> 0;
+end;
+
+function z_fits_sshort_p(var op: MPInteger): boolean;
+begin
+  result := mpz_fits_sshort_p(src(op)^) <> 0;
+end;
+
+function z_fits_uint_p(var op: MPInteger): boolean;
+begin
+  result := mpz_fits_uint_p(src(op)^) <> 0;
+end;
+
+function z_fits_ulong_p(var op: MPInteger): boolean;
+begin
+  result := mpz_fits_ulong_p(src(op)^) <> 0;
+end;
+
+function z_fits_ushort_p(var op: MPInteger): boolean;
+begin
+  result := mpz_fits_ushort_p(src(op)^) <> 0;
+end;
+
+procedure z_gcd(var rop, op1, op2: MPInteger);
+begin
+  mpz_gcd(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function z_gcd(var op1, op2: MPInteger): MPInteger;
+begin
+  mpz_gcd(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+function z_gcd_ui(var rop, op1: MPInteger; op2: valuint): valuint;
+begin
+  result := mpz_gcd_ui(dest(rop)^, src(op1)^, op2)
+end;
+
+procedure z_gcdext(var g, s, t, a, b: MPInteger);
+begin
+  mpz_gcdext(dest(g)^, dest(s)^, dest(t)^, src(a)^, src(b)^);
+end;
+
+function z_get_d(var op: MPInteger): double;
+begin
+  result := mpz_get_d(src(op)^);
+end;
+
+function z_get_d_2exp(out exp: valsint; var op: MPInteger): double;
+begin
+  result := mpz_get_d_2exp(exp, src(op)^);
+end;
+
+function z_get_si(op: MPInteger): valsint;
+begin
+  result := mpz_get_si(src(op)^);
+end;
+
+function z_get_str(base: longint; var op: MPInteger): string;
+var p: pchar;
+begin
+  p := mpz_get_str(nil, base, src(op)^);
+  result := p;
+  freemem(p);
+end;
+
+function z_get_str(str: pchar; base: longint; var op: MPInteger): pchar;
+begin
+  result := mpz_get_str(str, base, src(op)^);
+end;
+
+function z_get_ui(op: MPInteger): valuint;
+begin
+  result := mpz_get_ui(src(op)^);
+end;
+
+function z_getlimbn(var op: MPInteger; n: mp_size_t): mp_limb_t;
+begin
+  result := mpz_getlimbn(src(op)^, n);
+end;
+
+function z_hamdist(var op1, op2: MPInteger): valuint;
+begin
+  result := mpz_hamdist(src(op1)^, src(op2)^);
+end;
+
+procedure z_import(var rop: MPInteger; count: sizeuint; order: longint; size: sizeuint; endian: longint; nails: sizeuint; const op);
+begin
+  mpz_import(dest(rop)^, count, order, size, endian, nails, op);
+end;
+
+procedure z_init(out integer_: MPInteger);
+begin
+  integer_ := TMPInteger.Create;
+  mpz_init(integer_.ptr^);
+end;
+
+procedure z_init2(out integer_: MPInteger; n: valuint);
+begin
+  integer_ := TMPInteger.Create;
+  mpz_init2(integer_.ptr^, n);
+end;
+
+procedure z_init_set(out rop: MPInteger; var op: MPInteger);
+begin
+  rop := TMPInteger.Create;
+  mpz_init_set(rop.ptr^, src(op)^);
+end;
+
+procedure z_init_set_d(out rop: MPInteger; op: double);
+begin
+  rop := TMPInteger.Create;
+  mpz_init_set_d(rop.ptr^, op);
+end;
+
+procedure z_init_set_si(out rop: MPInteger; op: valsint);
+begin
+  rop := TMPInteger.Create;
+  mpz_init_set_si(rop.ptr^, op);
+end;
+
+function z_init_set_str(out rop: MPInteger; str: string; base: longint): boolean;
+begin
+  rop := TMPInteger.Create;
+  result := mpz_set_str(rop.ptr^, pchar(str), base) = 0;
+end;
+
+procedure z_init_set_ui(out rop: MPInteger; op: valuint);
+begin
+  rop := TMPInteger.Create;
+  mpz_init_set_ui(rop.ptr^, op);
+end;
+
+function z_invert(var rop, op1, op2: MPInteger): longint;
+begin
+  result := mpz_invert(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+procedure z_ior(var rop, op1, op2: MPInteger);
+begin
+  mpz_ior(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function z_ior(var op1, op2: MPInteger): MPInteger;
+begin
+  mpz_ior(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+function z_jacobi(var a, b: MPInteger): longint;
+begin
+  result := mpz_jacobi(src(a)^, src(b)^);
+end;
+
+function z_kronecker_si(var a: MPInteger; b: valsint): longint;
+begin
+  result := mpz_kronecker_si(src(a)^, b);
+end;
+
+function z_kronecker_ui(var a: MPInteger; b: valuint): longint;
+begin
+  result := mpz_kronecker_ui(src(a)^, b);
+end;
+
+function z_si_kronecker(a: valsint; var b: MPInteger): longint;
+begin
+  result := mpz_si_kronecker(a, src(b)^);
+end;
+
+function z_ui_kronecker(a: valuint; var b: MPInteger): longint;
+begin
+  result := mpz_ui_kronecker(a, src(b)^);
+end;
+
+procedure z_lcm(var rop, op1, op2: MPInteger);
+begin
+  mpz_lcm(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function z_lcm(var op1, op2: MPInteger): MPInteger;
+begin
+  mpz_lcm(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+procedure z_lcm_ui(var rop, op1: MPInteger; op2: valuint);
+begin
+  mpz_lcm_ui(dest(rop)^, src(op1)^, op2);
+end;
+
+function z_lcm_ui(var op1: MPInteger; op2: valuint): MPInteger;
+begin
+  mpz_lcm_ui(dest(result)^, src(op1)^, op2);
+end;
+
+procedure z_lucnum_ui(var ln: MPInteger; n: valuint);
+begin
+  mpz_lucnum_ui(dest(ln)^, n);
+end;
+
+function z_lucnum_ui(n: valuint): MPInteger;
+begin
+  mpz_lucnum_ui(dest(result)^, n);
+end;
+
+procedure z_lucnum2_ui(var ln, lnsub1: MPInteger; n: valuint);
+begin
+  mpz_lucnum2_ui(dest(ln)^, dest(lnsub1)^, n);
+end;
+
+function z_lucnum2_ui(var lnsub1: MPInteger; n: valuint): MPInteger;
+begin
+  mpz_lucnum2_ui(dest(result)^, dest(lnsub1)^, n);
+end;
+
+procedure z_mod(var r, n, d: MPInteger);
+begin
+  mpz_mod(dest(r)^, src(n)^, src(d)^);
+end;
+
+function z_mod(var n, d: MPInteger): MPInteger;
+begin
+  mpz_mod(dest(result)^, src(n)^, src(d)^);
+end;
+
+procedure z_mul(var rop, op1, op2: MPInteger);
+begin
+  mpz_mul(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function z_mul(var op1, op2: MPInteger): MPInteger;
+begin
+  mpz_mul(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+procedure z_mul_2exp(var rop, op1: MPInteger; op2: valuint);
+begin
+  mpz_mul_2exp(dest(rop)^, src(op1)^, op2);
+end;
+
+function z_mul_2exp(var op1: MPInteger; op2: valuint): MPInteger;
+begin
+  mpz_mul_2exp(dest(result)^, src(op1)^, op2);
+end;
+
+procedure z_mul_si(var rop, op1: MPInteger; op2: valsint);
+begin
+  mpz_mul_si(dest(rop)^, src(op1)^, op2);
+end;
+
+function z_mul_si(var op1: MPInteger; op2: valsint): MPInteger;
+begin
+  mpz_mul_si(dest(result)^, src(op1)^, op2);
+end;
+
+procedure z_mul_ui(var rop, op1: MPInteger; op2: valuint);
+begin
+  mpz_mul_ui(dest(rop)^, src(op1)^, op2);
+end;
+
+function z_mul_ui(var op1: MPInteger; op2: valuint): MPInteger;
+begin
+  mpz_mul_ui(dest(result)^, src(op1)^, op2);
+end;
+
+procedure z_neg(var rop, op: MPInteger);
+begin
+  mpz_neg(dest(rop)^, src(op)^);
+end;
+
+function z_neg(var op: MPInteger): MPInteger;
+begin
+  mpz_neg(dest(result)^, src(op)^);
+end;
+
+procedure z_nextprime(var rop, op: MPInteger);
+begin
+  mpz_nextprime(dest(rop)^, src(op)^);
+end;
+
+function z_nextprime(var op: MPInteger): MPInteger;
+begin
+  mpz_nextprime(dest(result)^, src(op)^);
+end;
+
+function z_perfect_power_p(var op: MPInteger): boolean;
+begin
+  result := mpz_perfect_power_p(src(op)^) <> 0;
+end;
+
+function z_perfect_square_p(var op: MPInteger): boolean;
+begin
+  result := mpz_perfect_square_p(src(op)^) <> 0;
+end;
+
+function z_popcount(var op: MPInteger): valuint;
+begin
+  result := mpz_popcount(src(op)^);
+end;
+
+procedure z_pow_ui(var rop, base: MPInteger; exp: valuint);
+begin
+  mpz_pow_ui(dest(rop)^, src(base)^, exp);
+end;
+
+function z_pow_ui(var base: MPInteger; exp: valuint): MPInteger;
+begin
+  mpz_pow_ui(dest(result)^, src(base)^, exp);
+end;
+
+procedure z_powm(var rop, base, exp, mod_: MPInteger);
+begin
+  mpz_powm(dest(rop)^, src(base)^, src(exp)^, src(mod_)^);
+end;
+
+function z_powm(var base, exp, mod_: MPInteger): MPInteger;
+begin
+  mpz_powm(dest(result)^, src(base)^, src(exp)^, src(mod_)^);
+end;
+
+procedure z_powm_ui(var rop, base: MPInteger; exp: valuint; var mod_: MPInteger);
+begin
+  mpz_powm_ui(dest(rop)^, src(base)^, exp, src(mod_)^);
+end;
+
+function z_powm_ui(var base: MPInteger; exp: valuint; var mod_: MPInteger): MPInteger;
+begin
+  mpz_powm_ui(dest(result)^, src(base)^, exp, src(mod_)^);
+end;
+
+function z_probab_prime_p(var n: MPInteger; reps: longint): longint;
+begin
+  result := mpz_probab_prime_p(src(n)^, reps);
+end;
+
+procedure z_realloc2(var integer_: MPInteger; n: valuint);
+begin
+  mpz_realloc2(dest(integer_)^, n);
+end;
+
+function z_remove(var rop, op, f: MPInteger): valuint;
+begin
+  result := mpz_remove(dest(rop)^, src(op)^, src(f)^);
+end;
+
+function z_root(var rop, op: MPInteger; n: valuint): boolean;
+begin
+  result := mpz_root(dest(rop)^, src(op)^, n) <> 0;
+end;
+
+procedure z_rootrem(var root, rem, u: MPInteger; n: valuint);
+begin
+  mpz_rootrem(dest(root)^, dest(rem)^, src(u)^, n);
+end;
+
+procedure z_rrandomb(var rop: MPInteger; var state: MPRandState; n: valuint);
+begin
+  mpz_rrandomb(dest(rop)^, src(state)^, n);
+end;
+
+function z_rrandomb(var state: MPRandState; n: valuint): MPInteger;
+begin
+  mpz_rrandomb(dest(result)^, src(state)^, n);
+end;
+
+function z_scan0(var op: MPInteger; starting_bit: valuint): valuint;
+begin
+  result := mpz_scan0(src(op)^, starting_bit);
+end;
+
+function z_scan1(var op: MPInteger; starting_bit: valuint): valuint;
+begin
+  result := mpz_scan1(src(op)^, starting_bit);
+end;
+
+procedure z_set(var rop, op: MPInteger);
+begin
+  mpz_set(dest(rop)^, src(op)^);
+end;
+
+procedure z_set_d(var rop: MPInteger; op: double);
+begin
+  mpz_set_d(dest(rop)^, op);
+end;
+
+procedure z_set_f(var rop: MPInteger; var op: MPFloat);
+begin
+  mpz_set_f(dest(rop)^, src(op)^);
+end;
+
+procedure z_set_q(var rop: MPInteger; var op: MPRational);
+begin
+  mpz_set_q(dest(rop)^, src(op)^);
+end;
+
+procedure z_set_si(var rop: MPInteger; op: valsint);
+begin
+  mpz_set_si(dest(rop)^, op);
+end;
+
+function z_set_str(var rop: MPInteger; str: string; base: longint): boolean;
+begin
+  result := mpz_set_str(dest(rop)^, pchar(str), base) = 0;
+end;
+
+procedure z_set_ui(var rop: MPInteger; op: valuint);
+begin
+  mpz_set_ui(dest(rop)^, op);
+end;
+
+procedure z_setbit(var rop: MPInteger; bit_index: valuint);
+begin
+  mpz_setbit(dest(rop)^, bit_index);
+end;
+
+function z_size(var op: MPInteger): sizeuint;
+begin
+  result := mpz_size(src(op)^);
+end;
+
+function z_sizeinbase(var op: MPInteger; base: longint): sizeuint;
+begin
+  result := mpz_sizeinbase(src(op)^, base);
+end;
+
+procedure z_sqrt(var rop, op: MPInteger);
+begin
+  mpz_sqrt(dest(rop)^, src(op)^);
+end;
+
+function z_sqrt(var op: MPInteger): MPInteger;
+begin
+  mpz_sqrt(dest(result)^, src(op)^);
+end;
+
+procedure z_sqrtrem(var rop1, rop2, op: MPInteger);
+begin
+  mpz_sqrtrem(dest(rop1)^, dest(rop2)^, src(op)^);
+end;
+
+procedure z_sub(var rop, op1, op2: MPInteger);
+begin
+  mpz_sub(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function z_sub(var op1, op2: MPInteger): MPInteger;
+begin
+  mpz_sub(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+procedure z_sub_ui(var rop, op1: MPInteger; op2: valuint);
+begin
+  mpz_sub_ui(dest(rop)^, src(op1)^, op2);
+end;
+
+function z_sub_ui(var op1: MPInteger; op2: valuint): MPInteger;
+begin
+  mpz_sub_ui(dest(result)^, src(op1)^, op2);
+end;
+
+procedure z_ui_sub(var rop: MPInteger; op1: valuint; var op2: MPInteger);
+begin
+  mpz_ui_sub(dest(rop)^, op1, src(op2)^);
+end;
+
+function z_ui_sub(op1: valuint; var op2: MPInteger): MPInteger;
+begin
+  mpz_ui_sub(dest(result)^, op1, src(op2)^);
+end;
+
+procedure z_submul(var rop, op1, op2: MPInteger);
+begin
+  mpz_submul(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+procedure z_submul_ui(var rop, op1: MPInteger; op2: valuint);
+begin
+  mpz_submul_ui(dest(rop)^, src(op1)^, op2);
+end;
+
+procedure z_swap(var rop1, rop2: MPInteger);
+begin
+  mpz_swap(dest(rop1)^, dest(rop2)^);
+end;
+
+procedure z_tdiv_q(var q, n, d: MPInteger);
+begin
+  mpz_tdiv_q(dest(q)^, src(n)^, src(d)^);
+end;
+
+function z_tdiv_q(var n, d: MPInteger): MPInteger;
+begin
+  mpz_tdiv_q(dest(result)^, src(n)^, src(d)^);
+end;
+
+procedure z_tdiv_q_2exp(var q, n: MPInteger; b: valuint);
+begin
+  mpz_tdiv_q_2exp(dest(q)^, src(n)^, b);
+end;
+
+function z_tdiv_q_2exp(var n: MPInteger; b: valuint): MPInteger;
+begin
+  mpz_tdiv_q_2exp(dest(result)^, src(n)^, b);
+end;
+
+function z_tdiv_q_ui(var q, n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_tdiv_q_ui(dest(q)^, src(n)^, d);
+end;
+
+procedure z_tdiv_qr(var q, r, n, d: MPInteger);
+begin
+  mpz_tdiv_qr(dest(q)^, dest(r)^, src(n)^, src(d)^);
+end;
+
+function z_tdiv_qr_ui(var q, r, n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_tdiv_qr_ui(dest(q)^, dest(r)^, src(n)^, d);
+end;
+
+procedure z_tdiv_r(var r, n, d: MPInteger);
+begin
+  mpz_tdiv_r(dest(r)^, src(n)^, src(d)^);
+end;
+
+function z_tdiv_r(var n, d: MPInteger): MPInteger;
+begin
+  mpz_tdiv_r(dest(result)^, src(n)^, src(d)^);
+end;
+
+procedure z_tdiv_r_2exp(var r, n: MPInteger; b: valuint);
+begin
+  mpz_tdiv_r_2exp(dest(r)^, src(n)^, b);
+end;
+
+function z_tdiv_r_2exp(var n: MPInteger; b: valuint): MPInteger;
+begin
+  mpz_tdiv_r_2exp(dest(result)^, src(n)^, b);
+end;
+
+function z_tdiv_r_ui(var r, n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_tdiv_r_ui(dest(r)^, src(n)^, d);
+end;
+
+function z_tdiv_ui(var n: MPInteger; d: valuint): valuint;
+begin
+  result := mpz_tdiv_ui(src(n)^, d);
+end;
+
+function z_tstbit(var rop: MPInteger; bit_index: valuint): boolean;
+begin
+  result := mpz_tstbit(src(rop)^, bit_index) <> 0;
+end;
+
+procedure z_ui_pow_ui(var rop: MPInteger; base, exp: valuint);
+begin
+  mpz_ui_pow_ui(dest(rop)^, base, exp);
+end;
+
+function z_ui_pow_ui(base, exp: valuint): MPInteger;
+begin
+  mpz_ui_pow_ui(dest(result)^, base, exp);
+end;
+
+procedure z_urandomb(var rop: MPInteger; var state: MPRandState; n: valuint);
+begin
+  mpz_urandomb(dest(rop)^, src(state)^, n);
+end;
+
+function z_urandomb(var state: MPRandState; n: valuint): MPInteger;
+begin
+  mpz_urandomb(dest(result)^, src(state)^, n);
+end;
+
+procedure z_urandomm(var rop: MPInteger; var state: MPRandState; var n: MPInteger);
+begin
+  mpz_urandomm(dest(rop)^, src(state)^, src(n)^);
+end;
+
+function z_urandomm(var state: MPRandState; var n: MPInteger): MPInteger;
+begin
+  mpz_urandomm(dest(result)^, src(state)^, src(n)^);
+end;
+
+procedure z_xor(var rop, op1, op2: MPInteger);
+begin
+  mpz_xor(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function z_xor(var op1, op2: MPInteger): MPInteger;
+begin
+  mpz_xor(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+procedure q_abs(var rop, op: MPRational);
+begin
+  mpq_abs(dest(rop)^, src(op)^);
+end;
+
+function q_abs(var op: MPRational): MPRational;
+begin
+  mpq_abs(dest(result)^, src(op)^);
+end;
+
+procedure q_add(var sum, addend1, addend2: MPRational);
+begin
+  mpq_add(dest(sum)^, src(addend1)^, src(addend2)^);
+end;
+
+function q_add(var addend1, addend2: MPRational): MPRational;
+begin
+  mpq_add(dest(result)^, src(addend1)^, src(addend2)^);
+end;
+
+procedure q_canonicalize(var op: MPRational);
+begin
+  mpq_canonicalize(dest(op)^);
+end;
+
+procedure q_clear(var rational_number: MPRational);
+begin
+  rational_number := nil;
+end;
+
+function q_cmp(var op1, op2: MPRational): longint;
+begin
+  result := mpq_cmp(src(op1)^, src(op2)^);
+end;
+
+function q_cmp_si(var op1: MPRational; num2: valsint; den2: valuint): longint;
+begin
+  result := mpq_cmp_si(src(op1)^, num2, den2);
+end;
+
+function q_cmp_ui(var op1: MPRational; num2, den2: valuint): longint;
+begin
+  result := mpq_cmp_ui(src(op1)^, num2, den2);
+end;
+
+procedure q_div(var quotient, dividend, divisor: MPRational);
+begin
+  mpq_div(dest(quotient)^, src(dividend)^, src(divisor)^);
+end;
+
+function q_div(var dividend, divisor: MPRational): MPRational;
+begin
+  mpq_div(dest(result)^, src(dividend)^, src(divisor)^);
+end;
+
+procedure q_div_2exp(var rop, op1: MPRational; op2: valuint);
+begin
+  mpq_div_2exp(dest(rop)^, src(op1)^, op2);
+end;
+
+function q_div_2exp(var op1: MPRational; op2: valuint): MPRational;
+begin
+  mpq_div_2exp(dest(result)^, src(op1)^, op2);
+end;
+
+function q_equal(var op1, op2: MPRational): boolean;
+begin
+  result := mpq_equal(src(op1)^, src(op2)^) <> 0;
+end;
+
+procedure q_get_num(var numerator: MPInteger; var rational: MPRational);
+begin
+  mpq_get_num(dest(numerator)^, src(rational)^);
+end;
+
+function q_get_num(var rational: MPRational): MPInteger;
+begin
+  mpq_get_num(dest(result)^, src(rational)^);
+end;
+
+procedure q_get_den(var denominator: MPInteger; var rational: MPRational);
+begin
+  mpq_get_den(dest(denominator)^, src(rational)^);
+end;
+
+function q_get_den(var rational: MPRational): MPInteger;
+begin
+  mpq_get_den(dest(result)^, src(rational)^);
+end;
+
+function q_get_d(var op: MPRational): double;
+begin
+  result := mpq_get_d(src(op)^);
+end;
+
+function q_get_str(base: longint; var op: MPRational): string;
+var p: pchar;
+begin
+  p := mpq_get_str(nil, base, src(op)^);
+  result := p;
+  freemem(p);
+end;
+
+function q_get_str(str: pchar; base: longint; var op: MPRational): pchar;
+begin
+  result := mpq_get_str(str, base, src(op)^);
+end;
+
+procedure q_init(out dest_rational: MPRational);
+begin
+  dest_rational := TMPRational.Create;
+  mpq_init(dest_rational.ptr^);
+end;
+
+procedure q_inv(var inverted_number, number: MPRational);
+begin
+  mpq_inv(dest(inverted_number)^, src(number)^);
+end;
+
+function q_inv(var number: MPRational): MPRational;
+begin
+  mpq_inv(dest(result)^, src(number)^);
+end;
+
+procedure q_mul(var product, multiplier, multiplicand: MPRational);
+begin
+  mpq_mul(dest(product)^, src(multiplier)^, src(multiplicand)^);
+end;
+
+function q_mul(var multiplier, multiplicand: MPRational): MPRational;
+begin
+  mpq_mul(dest(result)^, src(multiplier)^, src(multiplicand)^);
+end;
+
+procedure q_mul_2exp(var rop, op1: MPRational; op2: valuint);
+begin
+  mpq_mul_2exp(dest(rop)^, src(op1)^, op2);
+end;
+
+function q_mul_2exp(var op1: MPRational; op2: valuint): MPRational;
+begin
+  mpq_mul_2exp(dest(result)^, src(op1)^, op2);
+end;
+
+procedure q_neg(var negated_operand, operand: MPRational);
+begin
+  mpq_neg(dest(negated_operand)^, src(operand)^);
+end;
+
+function q_neg(var operand: MPRational): MPRational;
+begin
+  mpq_neg(dest(result)^, src(operand)^);
+end;
+
+procedure q_set(var rop, op: MPRational);
+begin
+  mpq_set(dest(rop)^, src(op)^);
+end;
+
+procedure q_set_d(var rop: MPRational; op: double);
+begin
+  mpq_set_d(dest(rop)^, op);
+end;
+
+procedure q_set_den(var rational: MPRational; var denominator: MPInteger);
+begin
+  mpq_set_den(dest(rational)^, src(denominator)^);
+end;
+
+procedure q_set_f(var rop: MPRational; var op: MPFloat);
+begin
+  mpq_set_f(dest(rop)^, src(op)^);
+end;
+
+procedure q_set_num(var rational: MPRational; var numerator: MPInteger);
+begin
+  mpq_set_num(dest(rational)^, src(numerator)^);
+end;
+
+procedure q_set_si(var rop: MPRational; op1: valsint; op2: valuint);
+begin
+  mpq_set_si(dest(rop)^, op1, op2);
+end;
+
+function q_set_str(var rop: MPRational; str: string; base: longint): boolean;
+begin
+  result := mpq_set_str(dest(rop)^, pchar(str), base) = 0;
+end;
+
+procedure q_set_ui(var rop: MPRational; op1, op2: valuint);
+begin
+  mpq_set_ui(dest(rop)^, op1, op2);
+end;
+
+procedure q_set_z(var rop: MPRational; var op: MPInteger);
+begin
+  mpq_set_z(dest(rop)^, src(op)^);
+end;
+
+procedure q_sub(var difference, minuend, subtrahend: MPRational);
+begin
+  mpq_sub(dest(difference)^, src(minuend)^, src(subtrahend)^);
+end;
+
+function q_sub(var minuend, subtrahend: MPRational): MPRational;
+begin
+  mpq_sub(dest(result)^, src(minuend)^, src(subtrahend)^);
+end;
+
+procedure q_swap(var rop1, rop2: MPRational);
+begin
+  mpq_swap(dest(rop1)^, dest(rop2)^);
+end;
+
+procedure f_abs(var rop, op: MPFloat);
+begin
+  mpf_abs(dest(rop)^, src(op)^);
+end;
+
+function f_abs(var op: MPFloat): MPFloat;
+begin
+  mpf_abs(dest(result)^, src(op)^);
+end;
+
+procedure f_add(var rop, op1, op2: MPFloat);
+begin
+  mpf_add(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function f_add(var op1, op2: MPFloat): MPFloat;
+begin
+  mpf_add(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+procedure f_add_ui(var rop, op1: MPFloat; op2: valuint);
+begin
+  mpf_add_ui(dest(rop)^, src(op1)^, op2);
+end;
+
+function f_add_ui(var op1: MPFloat; op2: valuint): MPFloat;
+begin
+  mpf_add_ui(dest(result)^, src(op1)^, op2);
+end;
+
+procedure f_ceil(var rop, op: MPFloat);
+begin
+  mpf_ceil(dest(rop)^, src(op)^);
+end;
+
+function f_ceil(var op: MPFloat): MPFloat;
+begin
+  mpf_ceil(dest(result)^, src(op)^);
+end;
+
+procedure f_clear(var x: MPFloat);
+begin
+  x := nil;
+end;
+
+function f_cmp(var op1, op2: MPFloat): longint;
+begin
+  result := mpf_cmp(src(op1)^, src(op2)^);
+end;
+
+function f_cmp_d(var op1: MPFloat; op2: double): longint;
+begin
+  result := mpf_cmp_d(src(op1)^, op2);
+end;
+
+function f_cmp_si(var op1: MPFloat; op2: valsint): longint;
+begin
+  result := mpf_cmp_si(src(op1)^, op2);
+end;
+
+function f_cmp_ui(var op1: MPFloat; op2: valuint): longint;
+begin
+  result := mpf_cmp_ui(src(op1)^, op2);
+end;
+
+procedure f_div(var rop, op1, op2: MPFloat);
+begin
+  mpf_div(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function f_div(var op1, op2: MPFloat): MPFloat;
+begin
+  mpf_div(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+procedure f_div_2exp(var rop, op1: MPFloat; op2: valuint);
+begin
+  mpf_div_2exp(dest(rop)^, src(op1)^, op2);
+end;
+
+function f_div_2exp(var op1: MPFloat; op2: valuint): MPFloat;
+begin
+  mpf_div_2exp(dest(result)^, src(op1)^, op2);
+end;
+
+procedure f_div_ui(var rop, op1: MPFloat; op2: valuint);
+begin
+  mpf_div_ui(dest(rop)^, src(op1)^, op2);
+end;
+
+function f_div_ui(var op1: MPFloat; op2: valuint): MPFloat;
+begin
+  mpf_div_ui(dest(result)^, src(op1)^, op2);
+end;
+
+function f_eq(var op1, op2: MPFloat; op3: valuint): boolean;
+begin
+  result := mpf_eq(src(op1)^, src(op2)^, op3) <> 0;
+end;
+
+function f_fits_sint_p(var op: MPFloat): boolean;
+begin
+  result := mpf_fits_sint_p(src(op)^) <> 0;
+end;
+
+function f_fits_slong_p(var op: MPFloat): boolean;
+begin
+  result := mpf_fits_slong_p(src(op)^) <> 0;
+end;
+
+function f_fits_sshort_p(var op: MPFloat): boolean;
+begin
+  result := mpf_fits_sshort_p(src(op)^) <> 0;
+end;
+
+function f_fits_uint_p(var op: MPFloat): boolean;
+begin
+  result := mpf_fits_uint_p(src(op)^) <> 0;
+end;
+
+function f_fits_ulong_p(var op: MPFloat): boolean;
+begin
+  result := mpf_fits_ulong_p(src(op)^) <> 0;
+end;
+
+function f_fits_ushort_p(var op: MPFloat): boolean;
+begin
+  result := mpf_fits_ushort_p(src(op)^) <> 0;
+end;
+
+procedure f_floor(var rop, op: MPFloat);
+begin
+  mpf_floor(dest(rop)^, src(op)^);
+end;
+
+function f_floor(var op: MPFloat): MPFloat;
+begin
+  mpf_floor(dest(result)^, src(op)^);
+end;
+
+function f_get_d(var op: MPFloat): double;
+begin
+  result := mpf_get_d(src(op)^);
+end;
+
+function f_get_d_2exp(out exp: valsint; var op: MPFloat): double;
+begin
+  result := mpf_get_d_2exp(exp, src(op)^);
+end;
+
+function f_get_default_prec: valuint;
+begin
+  result := mpf_get_default_prec;
+end;
+
+function f_get_prec(var op: MPFloat): valuint;
+begin
+  result := mpf_get_prec(src(op)^);
+end;
+
+function f_get_si(var op: MPFloat): valsint;
+begin
+  result := mpf_get_si(src(op)^);
+end;
+
+function f_get_str(out exp: mp_exp_t; base: longint; ndigits: sizeuint; var op: MPFloat): string;
+var p: pchar;
+begin
+  p := mpf_get_str(nil, exp, base, ndigits, src(op)^);
+  result := p;
+  freemem(p);
+end;
+
+function f_get_str(str: pchar; out exp: mp_exp_t; base: longint; ndigits: sizeuint; var op: MPFloat): pchar;
+begin
+  result := mpf_get_str(str, exp, base, ndigits, src(op)^);
+end;
+
+function f_get_ui(var op: MPFloat): valuint;
+begin
+  result := mpf_get_ui(src(op)^);
+end;
+
+procedure f_init(out x: MPFloat);
+begin
+  x := TMPFloat.Create;
+  mpf_init(x.ptr^);
+end;
+
+procedure f_init2(out x: MPFloat; prec: valuint);
+begin
+  x := TMPFloat.Create;
+  mpf_init2(x.ptr^, prec);
+end;
+
+procedure f_init_set(out rop: MPFloat; var op: MPFloat);
+begin
+  rop := TMPFloat.Create;
+  mpf_init_set(rop.ptr^, src(op)^);
+end;
+
+procedure f_init_set_d(out rop: MPFloat; op: double);
+begin
+  rop := TMPFloat.Create;
+  mpf_init_set_d(rop.ptr^, op);
+end;
+
+procedure f_init_set_si(out rop: MPFloat; op: valsint);
+begin
+  rop := TMPFloat.Create;
+  mpf_init_set_si(rop.ptr^, op);
+end;
+
+function f_init_set_str(out rop: MPFloat; str: string; base: longint): boolean;
+begin
+  rop := TMPFloat.Create;
+  result := mpf_init_set_str(rop.ptr^, pchar(str), base) = 0;
+end;
+
+procedure f_init_set_ui(out rop: MPFloat; op: valuint);
+begin
+  rop := TMPFloat.Create;
+  mpf_init_set_ui(rop.ptr^, op);
+end;
+
+function f_integer_p(var op: MPFloat): boolean;
+begin
+  result := mpf_integer_p(src(op)^) <> 0;
+end;
+
+procedure f_mul(var rop, op1, op2: MPFloat);
+begin
+  mpf_mul(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function f_mul(var op1, op2: MPFloat): MPFloat;
+begin
+  mpf_mul(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+procedure f_mul_2exp(var rop, op1: MPFloat; op2: valuint);
+begin
+  mpf_mul_2exp(dest(rop)^, src(op1)^, op2);
+end;
+
+function f_mul_2exp(var op1: MPFloat; op2: valuint): MPFloat;
+begin
+  mpf_mul_2exp(dest(result)^, src(op1)^, op2);
+end;
+
+procedure f_mul_ui(var rop, op1: MPFloat; op2: valuint);
+begin
+  mpf_mul_ui(dest(rop)^, src(op1)^, op2);
+end;
+
+function f_mul_ui(var op1: MPFloat; op2: valuint): MPFloat;
+begin
+  mpf_mul_ui(dest(result)^, src(op1)^, op2);
+end;
+
+procedure f_neg(var rop, op: MPFloat);
+begin
+  mpf_neg(dest(rop)^, src(op)^);
+end;
+
+function f_neg(var op: MPFloat): MPFloat;
+begin
+  mpf_neg(dest(result)^, src(op)^);
+end;
+
+procedure f_pow_ui(var rop, op1: MPFloat; op2: valuint);
+begin
+  mpf_pow_ui(dest(rop)^, src(op1)^, op2);
+end;
+
+function f_pow_ui(var op1: MPFloat; op2: valuint): MPFloat;
+begin
+  mpf_pow_ui(dest(result)^, src(op1)^, op2);
+end;
+
+procedure f_random2(var rop: MPFloat; max_size: mp_size_t; exp: mp_exp_t);
+begin
+  mpf_random2(dest(rop)^, max_size, exp);
+end;
+
+function f_random2(max_size: mp_size_t; exp: mp_exp_t): MPFloat;
+begin
+  mpf_random2(dest(result)^, max_size, exp);
+end;
+
+procedure f_reldiff(var rop, op1, op2: MPFloat);
+begin
+  mpf_reldiff(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function f_reldiff(var op1, op2: MPFloat): MPFloat;
+begin
+  mpf_reldiff(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+procedure f_set(var rop, op: MPFloat);
+begin
+  mpf_set(dest(rop)^, src(op)^);
+end;
+
+procedure f_set_d(var rop: MPFloat; op: double);
+begin
+  mpf_set_d(dest(rop)^, op);
+end;
+
+procedure f_set_default_prec(prec: valuint);
+begin
+  mpf_set_default_prec(prec);
+end;
+
+procedure f_set_prec(var rop: MPFloat; prec: valuint);
+begin
+  mpf_set_prec(dest(rop)^, prec);
+end;
+
+procedure f_set_prec_raw(var rop: MPFloat; prec: valuint);
+begin
+  mpf_set_prec_raw(dest(rop)^, prec);
+end;
+
+procedure f_set_q(var rop: MPFloat; var op: MPRational);
+begin
+  mpf_set_q(dest(rop)^, src(op)^);
+end;
+
+procedure f_set_si(var rop: MPFloat; op: valsint);
+begin
+  mpf_set_si(dest(rop)^, op);
+end;
+
+function f_set_str(var rop: MPFloat; str: string; base: longint): boolean;
+begin
+  result := mpf_set_str(dest(rop)^, pchar(str), base) = 0;
+end;
+
+procedure f_set_ui(var rop: MPFloat; op: valuint);
+begin
+  mpf_set_ui(dest(rop)^, op);
+end;
+
+procedure f_set_z(var rop: MPFloat; var op: MPInteger);
+begin
+  mpf_set_z(dest(rop)^, src(op)^);
+end;
+
+procedure f_sqrt(var rop, op: MPFloat);
+begin
+  mpf_sqrt(dest(rop)^, src(op)^);
+end;
+
+function f_sqrt(var op: MPFloat): MPFloat;
+begin
+  mpf_sqrt(dest(result)^, src(op)^);
+end;
+
+procedure f_sqrt_ui(var rop: MPFloat; op: valuint);
+begin
+  mpf_sqrt_ui(dest(rop)^, op);
+end;
+
+function f_sqrt_ui(op: valuint): MPFloat;
+begin
+  mpf_sqrt_ui(dest(result)^, op);
+end;
+
+procedure f_sub(var rop, op1, op2: MPFloat);
+begin
+  mpf_sub(dest(rop)^, src(op1)^, src(op2)^);
+end;
+
+function f_sub(var op1, op2: MPFloat): MPFloat;
+begin
+  mpf_sub(dest(result)^, src(op1)^, src(op2)^);
+end;
+
+procedure f_sub_ui(var rop, op1: MPFloat; op2: valuint);
+begin
+  mpf_sub_ui(dest(rop)^, src(op1)^, op2);
+end;
+
+function f_sub_ui(var op1: MPFloat; op2: valuint): MPFloat;
+begin
+  mpf_sub_ui(dest(result)^, src(op1)^, op2);
+end;
+
+procedure f_swap(var rop1, rop2: MPFloat);
+begin
+  mpf_swap(dest(rop1)^, dest(rop2)^);
+end;
+
+procedure f_trunc(var rop, op: MPFloat);
+begin
+  mpf_trunc(dest(rop)^, src(op)^);
+end;
+
+function f_trunc(var op: MPFloat): MPFloat;
+begin
+  mpf_trunc(dest(result)^, src(op)^);
+end;
+
+procedure f_ui_div(var rop: MPFloat; op1: valuint; var op2: MPFloat);
+begin
+  mpf_ui_div(dest(rop)^, op1, src(op2)^);
+end;
+
+function f_ui_div(op1: valuint; var op2: MPFloat): MPFloat;
+begin
+  mpf_ui_div(dest(result)^, op1, src(op2)^);
+end;
+
+procedure f_ui_sub(var rop: MPFloat; op1: valuint; var op2: MPFloat);
+begin
+  mpf_ui_sub(dest(rop)^, op1, src(op2)^);
+end;
+
+function f_ui_sub(op1: valuint; var op2: MPFloat): MPFloat;
+begin
+  mpf_ui_sub(dest(result)^, op1, src(op2)^);
+end;
+
+procedure f_urandomb(var rop: MPFloat; var state: MPRandState; nbits: valuint);
+begin
+  mpf_urandomb(dest(rop)^, src(state)^, nbits);
+end;
+
+function f_urandomb(var state: MPRandState; nbits: valuint): MPFloat;
+begin
+  mpf_urandomb(dest(result)^, src(state)^, nbits);
+end;
+
+// ---- operators ----
+
+operator * (op1: MPFloat; op2: MPFloat): MPFloat;
+begin
+  propagate_prec(result, op1, op2);
+  f_mul(result, op1, op2);
+end;
+
+operator * (op1: MPInteger; op2: MPInteger): MPInteger;
+begin
+  z_mul(result, op1, op2);
+end;
+
+operator * (op1: MPRational; op2: MPRational): MPRational;
+begin
+  q_mul(result, op1, op2);
+end;
+
+operator ** (op1: MPFloat; op2: valuint): MPFloat;
+begin
+  propagate_prec(result, op1);
+  f_pow_ui(result, op1, op2);
+end;
+
+operator ** (op1: MPInteger; op2: valuint): MPInteger;
+begin
+  z_pow_ui(result, op1, op2);
+end;
+
+operator + (op1: MPFloat; op2: MPFloat): MPFloat;
+begin
+  propagate_prec(result, op1, op2);
+  f_add(result, op1, op2);
+end;
+
+operator + (op1: MPInteger; op2: MPInteger): MPInteger;
+begin
+  z_add(result, op1, op2);
+end;
+
+operator + (op1: MPRational; op2: MPRational): MPRational;
+begin
+  q_add(result, op1, op2);
+end;
+
+operator - (op: MPFloat): MPFloat;
+begin
+  propagate_prec(result, op);
+  f_neg(result, op);
+end;
+
+operator - (op: MPInteger): MPInteger;
+begin
+  z_neg(result, op);
+end;
+
+operator - (op: MPRational): MPRational;
+begin
+  q_neg(result, op);
+end;
+
+operator - (op1: MPFloat; op2: MPFloat): MPFloat;
+begin
+  propagate_prec(result, op1, op2);
+  f_sub(result, op1, op2);
+end;
+
+operator - (op1: MPInteger; op2: MPInteger): MPInteger;
+begin
+  z_sub(result, op1, op2);
+end;
+
+operator - (op1: MPRational; op2: MPRational): MPRational;
+begin
+  q_sub(result, op1, op2);
+end;
+
+operator / (op1: MPFloat; op2: MPFloat): MPFloat;
+begin
+  propagate_prec(result, op1, op2);
+  f_div(result, op1, op2);
+end;
+
+operator / (op1: MPInteger; op2: MPInteger): MPInteger;
+begin
+  z_tdiv_q(result, op1, op2);
+end;
+
+operator / (op1: MPRational; op2: MPRational): MPRational;
+begin
+  q_div(result, op1, op2);
+end;
+
+operator := (op: double): MPFloat;
+begin
+  f_set_d(result, op);
+end;
+
+operator := (op: double): MPInteger;
+begin
+  z_set_d(result, op);
+end;
+
+operator := (op: double): MPRational;
+begin
+  q_set_d(result, op);
+end;
+
+operator := (op: MPFloat): cardinal;
+begin
+  result := f_get_ui(op);
+end;
+
+operator := (op: MPFloat): double;
+begin
+  result := f_get_d(op);
+end;
+
+operator := (op: MPFloat): integer;
+begin
+  result := f_get_si(op);
+end;
+
+operator := (op: MPFloat): mpf_t;
+begin
+  mpf_init_set(result, src(op)^);
+end;
+
+operator := (op: MPFloat): MPInteger;
+begin
+  z_set_f(result, op);
+end;
+
+operator := (op: MPFloat): MPRational;
+begin
+  q_set_f(result, op);
+end;
+
+operator := (op: MPFloat): string;
+const FMT = '%.*Fg';
+var p: pchar;
+begin
+  mp_asprintf(p, FMT, floor(f_get_prec(op) * LOG_10_2), src(op));
+  result := p;
+  freemem(p);
+end;
+
+{$ifdef CPU64}
+operator := (op: MPFloat): valsint;
+begin
+  result := f_get_si(op);
+end;
+
+operator := (op: MPFloat): valuint;
+begin
+  result := f_get_ui(op);
+end;
+{$endif}
+
+operator := (var op: mpf_t): MPFloat;
+begin
+  mpf_set(dest(result)^, op);
+end;
+
+operator := (op: MPInteger): cardinal;
+begin
+  result := z_get_ui(op);
+end;
+
+operator := (op: MPInteger): double;
+begin
+  result := z_get_d(op);
+end;
+
+operator := (op: MPInteger): integer;
+begin
+  result := z_get_si(op);
+end;
+
+operator := (op: MPInteger): MPFloat;
+begin
+  f_set_z(result, op);
+end;
+
+operator := (op: MPInteger): MPRational;
+begin
+  q_set_z(result, op);
+end;
+
+operator := (op: MPInteger): mpz_t;
+begin
+  mpz_init_set(result, src(op)^);
+end;
+
+operator := (op: MPInteger): string;
+const FMT = '%Zd';
+var p: pchar;
+begin
+  mp_asprintf(p, FMT, src(op));
+  result := p;
+  freemem(p);
+end;
+
+{$ifdef CPU64}
+operator := (op: MPInteger): valsint;
+begin
+  result := z_get_si(op);
+end;
+
+operator := (op: MPInteger): valuint;
+begin
+  result := z_get_ui(op);
+end;
+{$endif}
+
+operator := (var op: mpq_t): MPRational;
+begin
+  mpq_set(dest(result)^, op);
+end;
+
+operator := (op: MPRandState): randstate_t;
+begin
+  mp_randinit_set(result, src(op)^);
+end;
+
+operator := (op: MPRational): double;
+begin
+  result := q_get_d(op);
+end;
+
+operator := (op: MPRational): MPFloat;
+begin
+  f_set_q(result, op);
+end;
+
+operator := (op: MPRational): MPInteger;
+begin
+  z_set_q(result, op);
+end;
+
+operator := (op: MPRational): mpq_t;
+begin
+  mpq_init(result);
+  mpq_set(result, src(op)^);
+end;
+
+operator := (op: MPRational): string;
+const FMT = '%Qd';
+var p: pchar;
+begin
+  mp_asprintf(p, FMT, src(op));
+  result := p;
+  freemem(p);
+end;
+
+operator := (var op: mpz_t): MPInteger;
+begin
+  mpz_set(dest(result)^, op);
+end;
+
+operator := (var op: randstate_t): MPRandState;
+begin
+  result := TMPRandState.Create;
+  mp_randinit_set(result.ptr^, op);
+end;
+
+operator := (op: string): MPFloat;
+begin
+  f_set_prec(result, ceil(length(op) / LOG_10_2));
+  f_set_str(result, op, BASE10);
+end;
+
+operator := (op: string): MPInteger;
+begin
+  z_set_str(result, op, BASE10);
+end;
+
+operator := (op: string): MPRational;
+begin
+  q_set_str(result, op, BASE10);
+end;
+
+operator := (op: valsint): MPFloat;
+begin
+  f_set_si(result, op);
+end;
+
+operator := (op: valsint): MPInteger;
+begin
+  z_set_si(result, op);
+end;
+
+operator := (op: valsint): MPRational;
+begin
+  q_set_si(result, op, 1);
+end;
+
+operator := (op: valuint): MPFloat;
+begin
+  f_set_ui(result, op);
+end;
+
+operator := (op: valuint): MPInteger;
+begin
+  z_set_ui(result, op);
+end;
+
+operator := (op: valuint): MPRational;
+begin
+  q_set_ui(result, op, 1);
+end;
+
+operator < (op1: MPFloat; op2: MPFloat): boolean;
+begin
+  result := f_cmp(op1, op2) < 0;
+end;
+
+operator < (op1: MPInteger; op2: MPInteger): boolean;
+begin
+  result := z_cmp(op1, op2) < 0;
+end;
+
+operator < (op1: MPRational; op2: MPRational): boolean;
+begin
+  result := q_cmp(op1, op2) < 0;
+end;
+
+operator <= (op1: MPFloat; op2: MPFloat): boolean;
+begin
+  result := f_cmp(op1, op2) <= 0;
+end;
+
+operator <= (op1: MPInteger; op2: MPInteger): boolean;
+begin
+  result := z_cmp(op1, op2) <= 0;
+end;
+
+operator <= (op1: MPRational; op2: MPRational): boolean;
+begin
+  result := q_cmp(op1, op2) <= 0;
+end;
+
+//operator = (op1: MPFloat; op2: MPFloat): boolean;
+//begin
+//  result := f_cmp(op1, op2) = 0;
+//end;
+
+//operator = (op1: MPInteger; op2: MPInteger): boolean;
+//begin
+//  result := z_cmp(op1, op2) = 0;
+//end;
+
+//operator = (op1: MPRational; op2: MPRational): boolean;
+//begin
+//  result := q_cmp(op1, op2) = 0;
+//end;
+
+operator > (op1: MPFloat; op2: MPFloat): boolean;
+begin
+  result := f_cmp(op1, op2) > 0;
+end;
+
+operator > (op1: MPInteger; op2: MPInteger): boolean;
+begin
+  result := z_cmp(op1, op2) > 0;
+end;
+
+operator > (op1: MPRational; op2: MPRational): boolean;
+begin
+  result := q_cmp(op1, op2) > 0;
+end;
+
+operator >= (op1: MPFloat; op2: MPFloat): boolean;
+begin
+  result := f_cmp(op1, op2) >= 0;
+end;
+
+operator >= (op1: MPInteger; op2: MPInteger): boolean;
+begin
+  result := z_cmp(op1, op2) >= 0;
+end;
+
+operator >= (op1: MPRational; op2: MPRational): boolean;
+begin
+  result := q_cmp(op1, op2) >= 0;
+end;
+
+// ==== init stuff ====
+
+function alloc_func(alloc_size: sizeuint): pointer; cdecl;
+begin
+  result := getmem(alloc_size);
+end;
+
+procedure free_proc(p: pointer; size: sizeuint); cdecl;
+begin
+  assert(size = size); // hint off
+  freemem(p);
+end;
+
+function reallocate_func(p: pointer; old_size, new_size: sizeuint): pointer; cdecl;
+begin
+  assert(old_size = old_size); // hint off
+  result := reallocmem(p, new_size);
+end;
+
+var r1: mp_limb_t;
+
+initialization
+  // prealloc the GMP's global PRNG state, get rid of the (pseudo) mem leak report
+  mpn_random(@r1, 1);
+  mp_set_memory_functions(@alloc_func, @reallocate_func, @free_proc);
+
+end.
+

packages/gtk2/src/gtk+/gtk/gtk2.pas

@@ -93,6 +93,7 @@ const
       {$linklib gobject-2.0.0}
       {$linklib gdk_pixbuf-2.0.0}
       {$linklib atk-1.0.0}
+      {$linklib gthread-2.0}
     {$else}
       {$ifdef UseCustomLibs}
       gtklib = '';

packages/libndsfpc/src/fat/filesystem.pp

@@ -14,6 +14,7 @@ uses
   ctypes, nds9;
 
 {$linklib filesystem}
+{$linklib fat}
 {$linklib nds9}
 
 {$linklib c}

packages/lua/src/lauxlib.pas

@@ -66,7 +66,7 @@ function luaL_newmetatable(L: Plua_State; const tname: PChar): Integer; cdecl;
 function luaL_checkudata(L: Plua_State; ud: Integer; const tname: PChar): Pointer; cdecl;
 
 procedure luaL_where(L: Plua_State; lvl: Integer); cdecl;
-function luaL_error(L: Plua_State; const fmt: PChar; args: array of const): Integer; cdecl; // note: C's ... to array of const conversion is not portable to Delphi
+function luaL_error(L: Plua_State; const fmt: PChar; args: array of const): Integer; cdecl; external LUA_LIB_NAME; // note: C's ... to array of const conversion is not portable to Delphi
 
 function luaL_checkoption(L: Plua_State; narg: Integer; def: PChar; lst: PPChar): Integer; cdecl;
 
@@ -206,7 +206,7 @@ function luaL_newmetatable(L: Plua_State; const tname: PChar): Integer; cdecl; e
 function luaL_checkudata(L: Plua_State; ud: Integer; const tname: PChar): Pointer; cdecl; external LUA_LIB_NAME;
 
 procedure luaL_where(L: Plua_State; lvl: Integer); cdecl; external LUA_LIB_NAME;
-function luaL_error(L: Plua_State; const fmt: PChar; args: array of const): Integer; cdecl; external LUA_LIB_NAME;
+// function luaL_error(L: Plua_State; const fmt: PChar; args: array of const): Integer; cdecl; external LUA_LIB_NAME;
 
 function luaL_checkoption(L: Plua_State; narg: Integer; def: PChar; lst: PPChar): Integer; cdecl; external LUA_LIB_NAME;
 

packages/winunits-base/tests/hhex.pp

@@ -0,0 +1,43 @@
+Program Hhex;
+{
+   Small example/test of the html help OCX.
+   Marco van de Voort (C) 2009
+
+   Copy ref.chm from the CHM distribution to this dir.
+}
+{$mode objfpc}{$H+}
+uses htmlhelp;
+
+
+var 
+   HelpfileName : AnsiString;
+   htmltopic    : AnsiString;
+   res 		: Integer;
+ 
+Begin
+  Helpfilename:='ref.chm';
+  htmltopic   := 'ref/refli3.html';
+
+  Writeln('Html example 1');
+  Writeln('note:    Copy ref.chm from the CHM distribution to this dir');
+  
+  // HH_DISPLAY_INDEX  or HH_DISPLAY_SEARCH work too. 
+  Writeln('calling TOC');
+  Res:=HtmlHelpA(0,pchar(helpfilename) ,HH_DISPLAY_TOC,0);	
+  Writeln('program now blocked on readln, press enter (in console window) to continue');
+  
+  readln;
+  writeln('Showing a topic that is probably about dialog.');
+  // probably because due to automatic generation filenames and exact contact can drift.
+  Res:=HtmlHelpA(0,pchar(helpfilename) ,HH_DISPLAY_TOPIC,ptruint(pchar(htmltopic)));	 
+  Writeln('program now blocked on readln, press enter (in console window) to continue');
+  readln;
+  Writeln('ready. Note that the windows die automatically on exit of the program');
+
+{
+   Not demoed yet : HH_HELPCONTEXT. Load on ID, because we have no files that do that yet
+}
+
+
+end.
+  

packages/winunits-base/tests/hhex2.pp

@@ -0,0 +1,46 @@
+Program hhex2;
+{
+   Small example/test of the html help OCX.
+   Marco van de Voort (C) 2009
+
+   Copy rtl.chm from the CHM distribution to this dir. Test keyword/alink search.
+}
+
+Uses HTMLHelp;
+
+var
+   keyword      : ansistring; 
+   HelpfileName : AnsiString;
+   htmltopic    : AnsiString;
+   res 		: Integer;
+   ah           : PHH_AKLINK ;
+   
+Begin
+  Helpfilename:='rtl.chm';
+  keyword:='Sysutils' ;
+ 
+  New(ah);
+  fillchar(ah^,sizeof(ah^),#0); 
+  ah.cbstruct:=sizeof(tagHH_AKLINK);
+  ah.fReserved   := FALSE ;
+  ah.pszKeywords :=pansichar(keyword);  
+  ah.pszUrl      := NIL ;
+  ah.pszMsgText  :='Text succes' ;
+  ah.pszMsgTitle :='Text fail';
+  ah.pszWindow   := NIL ;
+  ah.fIndexOnFail:= false;
+
+ 
+  Res:=HtmlHelpA(0,pchar(helpfilename) ,HH_DISPLAY_INDEX,PTRUINT(PAnsiChar(Keyword)));	
+
+  // keyword search seems to have same effect.
+  Res:=HtmlHelpA(0,pchar(helpfilename) ,HH_ALINK_LOOKUP,PTRUINT(AH));	
+  writeln(ah.pszkeywords);
+  writeln(ah.pszurl);
+  writeln(ah.pszmsgtext);
+  writeln(ah.pszmsgtitle);
+  writeln(ah.pszwindow);
+  writeln(res);
+
+ readln;
+end.

rtl/objpas/cvarutil.inc

@@ -15,15 +15,8 @@
 
 Resourcestring
 
-  SNoWidestrings = 'No widestrings supported';
   SNoInterfaces  = 'No interfaces supported';
 
-Procedure NoWidestrings;
-
-begin
-  Raise Exception.Create(SNoWideStrings);
-end;
-
 Procedure NoInterfaces;
 
 begin
@@ -106,7 +99,7 @@ begin
       else
         VariantTypeMismatch(vType, varSmallInt);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := PSmallInt(vPointer)^;
         varShortInt : Result := PShortInt(vPointer)^;
         varInteger  : Result := smallint(PInteger(vPointer)^);
@@ -189,7 +182,7 @@ begin
       else
         VariantTypeMismatch(vType, varShortInt);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := shortint(PSmallInt(vPointer)^);
         varShortInt : Result := PShortInt(vPointer)^;
         varInteger  : Result := shortint(PInteger(vPointer)^);
@@ -272,7 +265,7 @@ begin
       else
         VariantTypeMismatch(vType, varInteger);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := PSmallInt(vPointer)^;
         varShortInt : Result := PShortInt(vPointer)^;
         varInteger  : Result := PInteger(vPointer)^;
@@ -355,7 +348,7 @@ begin
       else
         VariantTypeMismatch(vType, varLongWord);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := cardinal(PSmallInt(vPointer)^);
         varShortInt : Result := cardinal(PShortInt(vPointer)^);
         varInteger  : Result := cardinal(PInteger(vPointer)^);
@@ -468,7 +461,7 @@ begin
       else
         VariantTypeMismatch(vType, varSingle);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := PSmallInt(vPointer)^;
         varShortInt : Result := PShortInt(vPointer)^;
         varInteger  : Result := PInteger(vPointer)^;
@@ -561,7 +554,7 @@ begin
       else
         VariantTypeMismatch(vType, varDouble);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := PSmallInt(vPointer)^;
         varShortInt : Result := PShortInt(vPointer)^;
         varInteger  : Result := PInteger(vPointer)^;
@@ -688,7 +681,7 @@ begin
       else
         VariantTypeMismatch(vType, varCurrency);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := PSmallInt(vPointer)^;
         varShortInt : Result := PShortInt(vPointer)^;
         varInteger  : Result := PInteger(vPointer)^;
@@ -785,7 +778,7 @@ begin
       else
         VariantTypeMismatch(vType, varDate);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := PSmallInt(vPointer)^;
         varShortInt : Result := PShortInt(vPointer)^;
         varInteger  : Result := PInteger(vPointer)^;
@@ -864,7 +857,7 @@ begin
       else
         VariantTypeMismatch(vType, varBoolean);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := PSmallInt(vPointer)^ <> 0;
         varShortInt : Result := PShortInt(vPointer)^ <> 0;
         varInteger  : Result := PInteger(vPointer)^ <> 0;
@@ -947,7 +940,7 @@ begin
       else
         VariantTypeMismatch(vType, varByte);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := byte(PSmallInt(vPointer)^);
         varShortInt : Result := byte(PShortInt(vPointer)^);
         varInteger  : Result := byte(PInteger(vPointer)^);
@@ -1030,7 +1023,7 @@ begin
       else
         VariantTypeMismatch(vType, varInt64);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := PSmallInt(vPointer)^;
         varShortInt : Result := PShortInt(vPointer)^;
         varInteger  : Result := PInteger(vPointer)^;
@@ -1113,7 +1106,7 @@ begin
       else
         VariantTypeMismatch(vType, varQWord);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := qword(PSmallInt(vPointer)^);
         varShortInt : Result := qword(PShortInt(vPointer)^);
         varInteger  : Result := qword(PInteger(vPointer)^);
@@ -1178,7 +1171,7 @@ begin
       else
         VariantTypeMismatch(vType, varOleStr);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := IntToStr(PSmallInt(vPointer)^);
         varShortInt : Result := IntToStr(PShortInt(vPointer)^);
         varInteger  : Result := IntToStr(PInteger(vPointer)^);
@@ -1243,7 +1236,7 @@ begin
       else
         VariantTypeMismatch(vType, varString);
       end;
-      varByRef: if Assigned(vPointer) then case vType of
+      varByRef: if Assigned(vPointer) then case vType and varTypeMask of
         varSmallInt : Result := IntToStr(PSmallInt(vPointer)^);
         varShortInt : Result := IntToStr(PShortInt(vPointer)^);
         varInteger  : Result := IntToStr(PInteger(vPointer)^);

rtl/unix/bunxovl.inc

@@ -13,10 +13,6 @@
 
  **********************************************************************}
 
-{$if defined(CPUARM) or defined(CPUX86_64) or defined(CPUSPARC)}
-  {$define RTSIGACTION}
-{$endif}
-
 {$I textrec.inc}
 {$I filerec.inc}
 
@@ -161,13 +157,6 @@ begin
  {restart behaviour needs libc}
       sa.sa_flags :=sa.sa_flags or SA_RESTART;
 }
-{$ifdef RTSIGACTION}
-      sa.sa_flags:=SA_SIGINFO
-{$ifdef cpux86_64}
-         or $4000000
-{$endif cpux86_64}
-      ;
-{$endif RTSIGACTION}
      FPSigaction(signum,@sa,@osa);
      if fpgetErrNo<>0 then
        fpsignal:=NIL

rtl/unix/convert.inc

@@ -47,12 +47,13 @@ const convert_linuxlowascii_to_vga:array[#0..#31] of word=(
         $00b0,$00a8,$00b7,$00b9,$00b3,$00b2,$002a,$00a0  { $f8..$ff }
       );
       convert_lowascii_to_UTF8:array[#0..#31] of WideChar=(
-        #0000,#9786,#9787,#9829,#9830,#9827,#9824,#8226,
+        #8199,#9786,#9787,#9829,#9830,#9827,#9824,#8226,
         #9688,#9675,#9689,#9794,#9792,#9834,#9835,#9788,
         #9658,#9668,#8597,#8252,#0182,#0167,#9644,#8616,
         #8593,#8595,#8594,#8592,#8735,#8596,#9650,#9660
       );
-      convert_cp437_to_UTF8:array[#128..#255] of WideChar=(
+      convert_cp437_to_UTF8:array[#127..#255] of WideChar=(
+                                                  #8962, { $7f }
         #0199,#0252,#0233,#0226,#0228,#0224,#0229,#0231, { $80..$87 }
         #0234,#0235,#0232,#0239,#0238,#0236,#0196,#0197, { $88..$8f }
         #0201,#0230,#0198,#0244,#0246,#0242,#0251,#0249, { $90..$97 }

rtl/unix/keyboard.pp

@@ -1013,9 +1013,15 @@ const key_sequences:array[0..276] of key_sequence=(
        (char:0;scan:kbAltDown;st:#27#27'[B'),    {rxvt}
        (char:0;scan:kbAltLeft;st:#27#27'[D'),    {rxvt}
        (char:0;scan:kbAltRight;st:#27#27'[C'),   {rxvt}
+{$ifdef HAIKU}
+       (char:0;scan:kbAltUp;st:#27#27'OA'),
+       (char:0;scan:kbAltDown;st:#27#27'OB'),
+       (char:0;scan:kbAltRight;st:#27#27'OC'),
+{$else}
        (char:0;scan:kbAltUp;st:#27'OA'),
        (char:0;scan:kbAltDown;st:#27'OB'),
        (char:0;scan:kbAltRight;st:#27'OC'),
+{$endif}
        (char:0;scan:kbAltLeft;st:#27#27'OD'),
        (char:0;scan:kbAltPgUp;st:#27#27'[5~'),   {rxvt}
        (char:0;scan:kbAltPgDn;st:#27#27'[6~'),   {rxvt}

rtl/unix/video.pp

@@ -41,7 +41,8 @@ type  Tencoding=(cp437,         {Codepage 437}
                  iso10,         {ISO 8859-10}
                  iso13,         {ISO 8859-13}
                  iso14,         {ISO 8859-14}
-                 iso15);        {ISO 8859-15}
+                 iso15,         {ISO 8859-15}
+                 utf8);         {UTF-8}
 
 const  {Contains all code pages that can be considered a normal vga font.
         Note: KOI8-R has line drawing characters in wrong place. Support
@@ -245,6 +246,9 @@ const
   ACSOut : string = '';
   in_ACS : boolean =false;
 
+  TerminalSupportsHighIntensityColors: boolean = false;
+  TerminalSupportsBold: boolean = true;
+
 function convert_vga_to_acs(ch:char):word;
 
 {Ch contains a character in the VGA character set (i.e. codepage 437).
@@ -453,16 +457,17 @@ begin
   OFg:=OAttr and $f;
   OBg:=OAttr shr 4;
   attr2ansi:=#27'[';
-  if fg and 8<>0 then
-    begin
-      {Enable bold if not yet on.}
-      if ofg and 8=0 then
-        attr2ansi:=attr2ansi+'1;';
-    end
-  else
-    {Disable bold if on.}
-    if ofg and 8<>0 then
-      attr2ansi:=attr2ansi+'22;';
+  if TerminalSupportsBold then
+    if fg and 8<>0 then
+      begin
+        {Enable bold if not yet on.}
+        if ofg and 8=0 then
+          attr2ansi:=attr2ansi+'1;';
+      end
+    else
+      {Disable bold if on.}
+      if ofg and 8<>0 then
+        attr2ansi:=attr2ansi+'22;';
   if bg and 8<>0 then
     begin
       {Enable bold if not yet on.}
@@ -474,8 +479,19 @@ begin
     if obg and 8<>0 then
       attr2ansi:=attr2ansi+'25;';
 
-  if fg and 7<>ofg and 7 then
-     attr2ansi:=attr2ansi+'3'+ansitbl[fg and 7]+';';
+  if TerminalSupportsHighIntensityColors then
+  begin
+    if fg and 15<>ofg and 15 then
+      if fg and 8<>0 then
+        attr2ansi:=attr2ansi+'9'+ansitbl[fg and 7]+';'
+      else
+        attr2ansi:=attr2ansi+'3'+ansitbl[fg and 7]+';';
+  end
+  else
+  begin
+    if fg and 7<>ofg and 7 then
+      attr2ansi:=attr2ansi+'3'+ansitbl[fg and 7]+';';
+  end;
   if bg and 7<>obg and 7 then
      attr2ansi:=attr2ansi+'4'+ansitbl[bg and 7]+';';
 
@@ -624,7 +640,7 @@ var
         case c of
           #0..#31:
             converted:=convert_lowascii_to_UTF8[c];
-          #128..#255:
+          #127..#255:
             converted:=convert_cp437_to_UTF8[c];
           else
           begin
@@ -942,6 +958,18 @@ begin
   TCSetAttr(1,TCSANOW,tio);
 end;
 
+function UTF8Enabled: Boolean;
+var
+  lang:string;
+begin
+  {$ifdef BEOS}
+  UTF8Enabled := true;
+  exit;
+  {$endif}
+  lang:=upcase(fpgetenv('LANG'));
+  UTF8Enabled := (Pos('.UTF-8', lang) > 0) or (Pos('.UTF8', lang) > 0);
+end;
+
 procedure decide_codepages;
 
 var s:string;
@@ -970,6 +998,11 @@ begin
       internal_codepage:=cp852;
     iso05:               {Cyrillic}
       internal_codepage:=cp866;
+    utf8:
+      begin
+        internal_codepage:=cp437;
+        convert:=cv_cp437_to_UTF8;
+      end;
     else
       if internal_codepage in vga_codepages then
         internal_codepage:=external_codepage
@@ -978,9 +1011,6 @@ begin
          437 in the hope that the actual font has similarity to codepage 437.}
         internal_codepage:=cp437;
   end;
-  {$ifdef BEOS}
-  convert := cv_cp437_to_UTF8;  
-  {$endif}
 end;
 
 
@@ -1045,6 +1075,8 @@ begin
      Console:=TTyNetwork;                 {Default: Network or other vtxxx tty}
      cur_term_strings:=@term_codes_vt100; {Default: vt100}
      external_codepage:=iso01;            {Default: ISO-8859-1}
+     if UTF8Enabled then
+       external_codepage:=utf8;
    {$ifdef linux}
      if vcs_device>=0 then
        begin
@@ -1082,6 +1114,16 @@ begin
      for i:=low(terminal_names) to high(terminal_names) do
        if copy(term,1,length(terminal_names[i]))=terminal_names[i] then
          cur_term_strings:=terminal_data[i];
+    if cur_term_strings=@term_codes_xterm then
+    begin
+      TerminalSupportsBold := false;
+      TerminalSupportsHighIntensityColors := true;
+    end
+    else
+    begin
+      TerminalSupportsBold := true;
+      TerminalSupportsHighIntensityColors := false;
+    end;
     if cur_term_strings=@term_codes_freebsd then
       console:=ttyFreeBSD;
 {$ifdef linux}
@@ -1090,16 +1132,22 @@ begin
 {$endif}
         if cur_term_strings=@term_codes_linux then
           begin
-            {Executed in case ttylinux is false (i.e. no vcsa), but
-             TERM=linux.}
-            {Enable the VGA character set (codepage 437,850,....)}
-            fpwrite(stdoutputhandle,font_vga,sizeof(font_vga));
-            external_codepage:=cp437;  {Now default to codepage 437.}
+            if external_codepage<>utf8 then
+              begin
+                {Enable the VGA character set (codepage 437,850,....)}
+                fpwrite(stdoutputhandle,font_vga,sizeof(font_vga));
+                external_codepage:=cp437;  {Now default to codepage 437.}
+              end;
           end
         else
-          {No VGA font :( }
-          fpwrite(stdoutputhandle,font_lat1,sizeof(font_lat1));
-        { running on a remote terminal, no error with /dev/vcsa }
+          begin
+            if external_codepage<>utf8 then
+              begin
+                {No VGA font  :(  }
+                fpwrite(stdoutputhandle,font_lat1,sizeof(font_lat1));
+              end;
+            { running on a remote terminal, no error with /dev/vcsa }
+          end;
    {$ifdef linux}
       end;
    {$endif}

rtl/win/systhrd.inc

@@ -187,6 +187,8 @@ CONST
     procedure SysInitMultithreading;
       begin
         { do not check IsMultiThread, as program could have altered it, out of Delphi habit }
+        
+        { the thread attach/detach code uses locks to avoid multiple calls of this }
         if TLSKey=$ffffffff then
          begin
            { We're still running in single thread mode, setup the TLS }
@@ -200,10 +202,10 @@ CONST
     procedure SysFiniMultithreading;
       begin
         if IsMultiThread then
-         begin
-           TlsFree(TLSKey);
-           TLSKey:=$ffffffff;
-         end;
+          begin
+            TlsFree(TLSKey);
+            TLSKey:=$ffffffff;
+          end;
       end;
 
     function SysBeginThread(sa : Pointer;stacksize : ptruint;
@@ -342,10 +344,10 @@ end;
 
 
 Const
-        wrSignaled = 0;
-        wrTimeout  = 1;
-        wrAbandoned= 2;
-        wrError    = 3;
+  wrSignaled = 0;
+  wrTimeout  = 1;
+  wrAbandoned= 2;
+  wrError    = 3;
 
 type Tbasiceventstate=record
                         fhandle    : THandle;

rtl/win/syswin.inc

@@ -24,6 +24,8 @@ Const
 Var
   DLLBuf : Jmp_buf;
   MainThreadIdWin32 : DWORD;
+  AttachingThread : TRTLCriticalSection;
+
 
 function Dll_entry{$ifdef FPC_HAS_INDIRECT_MAIN_INFORMATION}(const info : TEntryInformation){$endif FPC_HAS_INDIRECT_MAIN_INFORMATION} : longbool; [public,alias:'_FPC_DLL_Entry'];
   var
@@ -37,6 +39,7 @@ function Dll_entry{$ifdef FPC_HAS_INDIRECT_MAIN_INFORMATION}(const info : TEntry
      case DLLreason of
        DLL_PROCESS_ATTACH :
          begin
+           WinInitCriticalSection(AttachingThread);
            MainThreadIdWin32 := Win32GetCurrentThreadId;
            If SetJmp(DLLBuf) = 0 then
              begin
@@ -59,7 +62,8 @@ function Dll_entry{$ifdef FPC_HAS_INDIRECT_MAIN_INFORMATION}(const info : TEntry
        DLL_THREAD_ATTACH :
          begin
            inclocked(Thread_count);
-
+           
+           WinEnterCriticalSection(AttachingThread);
            if (Win32GetCurrentThreadId <> MainThreadIdWin32) then
            begin
              { Set up TLS slot for the DLL }
@@ -73,14 +77,15 @@ function Dll_entry{$ifdef FPC_HAS_INDIRECT_MAIN_INFORMATION}(const info : TEntry
            if assigned(Dll_Thread_Attach_Hook) then
              Dll_Thread_Attach_Hook(DllParam);
            Dll_entry:=true; { return value is ignored }
-         end;
+           WinLeaveCriticalSection(AttachingThread);
+        end;
        DLL_THREAD_DETACH :
          begin
            declocked(Thread_count);
            if assigned(Dll_Thread_Detach_Hook) then
              Dll_Thread_Detach_Hook(DllParam);
            { Release Threadvars }
-           if (Win32GetCurrentThreadId <> MainThreadIdWin32) then
+           if (Win32GetCurrentThreadId<>MainThreadIdWin32) then
              DoneThread; { Assume everything is idempotent there }
            Dll_entry:=true; { return value is ignored }
          end;
@@ -94,6 +99,7 @@ function Dll_entry{$ifdef FPC_HAS_INDIRECT_MAIN_INFORMATION}(const info : TEntry
 
            { Free TLS resources used by ThreadVars }
            SysFiniMultiThreading;
+           WinDoneCriticalSection(AttachingThread);
          end;
      end;
   end;

tests/test/cg/cdecl/taoc4.pp

@@ -1,7 +1,11 @@
+{ %fail }
 { %cpu=i386 }
 
 { This test expects values on the stack, which is i386 only }
 
+{ This test should fail, because it can indeed only ever work on i386,
+  and even there the default typing by the compiler is wrong.  }
+
 { fourth simple array of const test }
 
 {$mode objfpc}

tests/test/cg/cdecl/taoc5.pp

@@ -1,7 +1,11 @@
+{ %fail }
 { %cpu=i386 }
 
 { This test expects values on the stack, which is i386 only }
 
+{ This test should fail, because it can indeed only ever work on i386,
+  and even there the default typing by the compiler is wrong.  }
+
 { fifth simple array of const test }
 
 {$mode objfpc}

tests/test/cg/cdecl/taoc6.pp

@@ -1,7 +1,11 @@
+{ %fail }
 { %cpu=i386 }
 
 { This test expects values on the stack, which is i386 only }
 
+{ This test should fail, because it can indeed only ever work on i386,
+  and even there the default typing by the compiler is wrong.  }
+
 { sixth simple array of const test
   for int64 values }
 

tests/test/tcase10.pp

@@ -0,0 +1,25 @@
+{%FAIL}
+
+{ duplicate labels in different cases }
+
+{$H+}
+var
+  my_str: string;
+  i: integer;
+
+begin
+  my_str := 'cab';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase11.pp

@@ -0,0 +1,25 @@
+{%FAIL}
+
+{ duplicate labels in different cases, one of them is range }
+
+{$H+}
+var
+  my_str: string;
+  i: integer;
+
+begin
+  my_str := 'cab';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c'..'d': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase12.pp

@@ -0,0 +1,89 @@
+{ test for simple comparsion }
+
+{$H+}
+
+var
+  my_str: string;
+  my_str_wide: widestring;
+  my_str_ansi: ansistring;
+  my_str_uni: unicodestring;
+  i: integer;
+
+begin
+  my_str := 'ababaca';
+  my_str_wide := 'ababaca';
+  my_str_ansi := 'ababaca';
+  my_str_uni := 'ababaca';
+  i := -1;
+
+  case my_str of
+    'abba': i := 1;
+    'ababac': i := 2;
+    'ababacaa': i := 3;
+    'ababaca ': i := 4;
+    ' ababaca': i := 5;
+    ' ababac': i := 6;
+    'ababaca': i := 7;
+    else i := 0;
+  end;
+
+  writeln(i);
+  if (i <> 7) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'abba': i := 1;
+    'ababac': i := 2;
+    'ababacaa': i := 3;
+    'ababaca ': i := 4;
+    ' ababaca': i := 5;
+    ' ababac': i := 6;
+    'ababaca': i := 7;
+    else i := 0;
+  end;
+
+  writeln(i);
+  if (i <> 7) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'abba': i := 1;
+    'ababac': i := 2;
+    'ababacaa': i := 3;
+    'ababaca ': i := 4;
+    ' ababaca': i := 5;
+    ' ababac': i := 6;
+    'ababaca': i := 7;
+    else i := 0;
+  end;
+
+  writeln(i);
+  if (i <> 7) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'abba': i := 1;
+    'ababac': i := 2;
+    'ababacaa': i := 3;
+    'ababaca ': i := 4;
+    ' ababaca': i := 5;
+    ' ababac': i := 6;
+    'ababaca': i := 7;
+    else i := 0;
+  end;
+
+  writeln(i);
+  if (i <> 7) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase13.pp

@@ -0,0 +1,68 @@
+{ the last range should be converted to single case and give 'expected' value }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: widestring;
+  my_str_ansi: ansistring;
+  my_str_uni: unicodestring;
+  i: integer;
+
+begin
+  my_str := 'cab';
+  my_str_wide := 'cab';
+  my_str_ansi := 'cab';
+  my_str_uni := 'cab';
+  i := -1;
+  
+  case my_str of
+    'a'..'b': i := 1;
+    'c'..'caa': i := 2;
+    'cab'..'cab': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+  
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c'..'caa': i := 2;
+    'cab'..'cab': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error_wide ', i);
+    Halt(1);
+  end;
+  
+  
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c'..'caa': i := 2;
+    'cab'..'cab': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error_ansi');
+    Halt(1);
+  end;
+  
+
+  case my_str_uni of
+    'aa': i := 1;
+    'ca'..'caa': i := 2;
+    'cab': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase14.pp

@@ -0,0 +1,60 @@
+{ comparsion with empty string as bound of 'needed' range }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: widestring;
+  my_str_ansi: ansistring;
+  my_str_uni: unicodestring;
+  i: integer;
+
+begin
+  my_str := 'ababaca';
+  my_str_wide := 'ababaca';
+  my_str_ansi := 'ababaca';
+  my_str_uni := 'ababaca';
+  i := -1;
+
+  case my_str of
+    ''..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    ''..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    ''..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    ''..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase15.pp

@@ -0,0 +1,68 @@
+{ comparsion of one-symbol strings as ranges and single cases }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'c';
+  my_str_wide := 'c';
+  my_str_ansi := 'c';
+  my_str_uni := 'c';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase16.pp

@@ -0,0 +1,68 @@
+{ comparsion of one-symbol strings as ranges and single cases }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'b';
+  my_str_wide := 'b';
+  my_str_ansi := 'b';
+  my_str_uni := 'b';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase17.pp

@@ -0,0 +1,72 @@
+{ comparsion of empty string }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := '';
+  my_str_wide := '';
+  my_str_ansi := '';
+  my_str_uni := '';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase18.pp

@@ -0,0 +1,69 @@
+{ comparsion of empty string }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: widestring;
+  my_str_ansi: ansistring;
+  my_str_uni: unicodestring;
+  i: integer;
+
+begin
+  my_str := '';
+  my_str_wide := '';
+  my_str_ansi := '';
+  my_str_uni := '';
+  i := -1;
+
+  case my_str of
+    'b'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'a': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+  case my_str_wide of
+    'b'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'a': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+  case my_str_ansi of
+    'b'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'a': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+  case my_str_uni of
+    'b'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'a': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase19.pp

@@ -0,0 +1,70 @@
+{%FAIL}
+
+{ duplicate labels in different cases, one of them is range }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'cab';
+  my_str_wide := 'cab';
+  my_str_ansi := 'cab';
+  my_str_uni := 'cab';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c'..'d': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c'..'d': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c'..'d': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c'..'d': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase20.pp

@@ -0,0 +1,39 @@
+{%FAIL}
+
+{ left bound is greater; fails }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'ababaca';
+  my_str_wide := 'ababaca';
+  my_str_ansi := 'ababaca';
+  my_str_uni := 'ababaca';
+  i := -1;
+
+  case my_str of
+    'abba'..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_wide of
+    'abba'..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_ansi of
+    'abba'..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_uni of
+    'abba'..'ababaca': i := 1;
+    else i := 0;
+  end;
+end.

tests/test/tcase21.pp

@@ -0,0 +1,39 @@
+{%FAIL}
+
+{ left bound is greater; comparsion with empty string. Fails }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'ababaca';
+  my_str_wide := 'ababaca';
+  my_str_ansi := 'ababaca';
+  my_str_uni := 'ababaca';
+  i := -1;
+
+  case my_str of
+    'aba'..'': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_wide of
+    'aba'..'': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_ansi of
+    'aba'..'': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_uni of
+    'aba'..'': i := 1;
+    else i := 0;
+  end;
+end.

tests/test/tcase22.pp

@@ -0,0 +1,64 @@
+{ comparsion of one-symbol strings in ranges }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'c';
+  my_str_wide := 'c';
+  my_str_ansi := 'c';
+  my_str_uni := 'c';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c'..'d': i := 2;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c'..'d': i := 2;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c'..'d': i := 2;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'b': i := 1;
+    'c'..'d': i := 2;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase23.pp

@@ -0,0 +1,70 @@
+{%FAIL}
+
+{ duplicate labels in different case ranges }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'cab';
+  my_str_wide := 'cab';
+  my_str_ansi := 'cab';
+  my_str_uni := 'cab';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c'..'caa': i := 2;
+    'caa'..'cabaa': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c'..'caa': i := 2;
+    'caa'..'cabaa': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c'..'caa': i := 2;
+    'caa'..'cabaa': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'b': i := 1;
+    'c'..'caa': i := 2;
+    'caa'..'cabaa': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase24.pp

@@ -0,0 +1,60 @@
+{ simple test for range }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'cab';
+  my_str_wide := 'cab';
+  my_str_ansi := 'cab';
+  my_str_uni := 'cab';
+  i := -1;
+
+  case my_str of
+    'aba'..'daa': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'aba'..'daa': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'aba'..'daa': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'aba'..'daa': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase25.pp

@@ -0,0 +1,60 @@
+{ test for range with one-symbol string as left bound }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'cab';
+  my_str_wide := 'cab';
+  my_str_ansi := 'cab';
+  my_str_uni := 'cab';
+  i := -1;
+
+  case my_str of
+    'a'..'daa': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'daa': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'daa': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'daa': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase26.pp

@@ -0,0 +1,62 @@
+{ test for range with one-symbol string as right bound, which is smaller than left. Fail }
+
+{%FAIL}
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'cab';
+  my_str_wide := 'cab';
+  my_str_ansi := 'cab';
+  my_str_uni := 'cab';
+  i := -1;
+
+  case my_str of
+    'cab'..'a': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'cab'..'a': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'cab'..'a': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'cab'..'a': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase27.pp

@@ -0,0 +1,70 @@
+{%FAIL}
+
+{ duplicate labels in different cases }
+
+{$H+}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'cab';
+  my_str_wide := 'cab';
+  my_str_ansi := 'cab';
+  my_str_uni := 'cab';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase28.pp

@@ -0,0 +1,89 @@
+{ test for simple comparsion }
+
+{$H-}
+
+var
+  my_str: string;
+  my_str_wide: widestring;
+  my_str_ansi: ansistring;
+  my_str_uni: unicodestring;
+  i: integer;
+
+begin
+  my_str := 'ababaca';
+  my_str_wide := 'ababaca';
+  my_str_ansi := 'ababaca';
+  my_str_uni := 'ababaca';
+  i := -1;
+
+  case my_str of
+    'abba': i := 1;
+    'ababac': i := 2;
+    'ababacaa': i := 3;
+    'ababaca ': i := 4;
+    ' ababaca': i := 5;
+    ' ababac': i := 6;
+    'ababaca': i := 7;
+    else i := 0;
+  end;
+
+  writeln(i);
+  if (i <> 7) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'abba': i := 1;
+    'ababac': i := 2;
+    'ababacaa': i := 3;
+    'ababaca ': i := 4;
+    ' ababaca': i := 5;
+    ' ababac': i := 6;
+    'ababaca': i := 7;
+    else i := 0;
+  end;
+
+  writeln(i);
+  if (i <> 7) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'abba': i := 1;
+    'ababac': i := 2;
+    'ababacaa': i := 3;
+    'ababaca ': i := 4;
+    ' ababaca': i := 5;
+    ' ababac': i := 6;
+    'ababaca': i := 7;
+    else i := 0;
+  end;
+
+  writeln(i);
+  if (i <> 7) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'abba': i := 1;
+    'ababac': i := 2;
+    'ababacaa': i := 3;
+    'ababaca ': i := 4;
+    ' ababaca': i := 5;
+    ' ababac': i := 6;
+    'ababaca': i := 7;
+    else i := 0;
+  end;
+
+  writeln(i);
+  if (i <> 7) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase29.pp

@@ -0,0 +1,68 @@
+{ the last range should be converted to single case and give 'expected' value }
+
+{$H-}
+var
+  my_str: string;
+  my_str_wide: widestring;
+  my_str_ansi: ansistring;
+  my_str_uni: unicodestring;
+  i: integer;
+
+begin
+  my_str := 'cab';
+  my_str_wide := 'cab';
+  my_str_ansi := 'cab';
+  my_str_uni := 'cab';
+  i := -1;
+  
+  case my_str of
+    'a'..'b': i := 1;
+    'c'..'caa': i := 2;
+    'cab'..'cab': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+  
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c'..'caa': i := 2;
+    'cab'..'cab': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error_wide ', i);
+    Halt(1);
+  end;
+  
+  
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c'..'caa': i := 2;
+    'cab'..'cab': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error_ansi');
+    Halt(1);
+  end;
+  
+
+  case my_str_uni of
+    'aa': i := 1;
+    'ca'..'caa': i := 2;
+    'cab': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase3.pp

@@ -0,0 +1,18 @@
+{%FAIL}
+
+{ left bound is greater; fails }
+
+{$H+}
+var
+  my_str: string;
+  i: integer;
+
+begin
+  my_str := 'ababaca';
+  i := -1;
+
+  case my_str of
+    'abba'..'ababaca': i := 1;
+    else i := 0;
+  end;
+end.

tests/test/tcase30.pp

@@ -0,0 +1,60 @@
+{ comparsion with empty string as bound of 'needed' range }
+
+{$H-}
+var
+  my_str: string;
+  my_str_wide: widestring;
+  my_str_ansi: ansistring;
+  my_str_uni: unicodestring;
+  i: integer;
+
+begin
+  my_str := 'ababaca';
+  my_str_wide := 'ababaca';
+  my_str_ansi := 'ababaca';
+  my_str_uni := 'ababaca';
+  i := -1;
+
+  case my_str of
+    ''..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    ''..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    ''..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    ''..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase31.pp

@@ -0,0 +1,68 @@
+{ comparsion of one-symbol strings as ranges and single cases }
+
+{$H-}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'c';
+  my_str_wide := 'c';
+  my_str_ansi := 'c';
+  my_str_uni := 'c';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 2) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase32.pp

@@ -0,0 +1,68 @@
+{ comparsion of one-symbol strings as ranges and single cases }
+
+{$H-}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'b';
+  my_str_wide := 'b';
+  my_str_ansi := 'b';
+  my_str_uni := 'b';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 1) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase33.pp

@@ -0,0 +1,72 @@
+{ comparsion of empty string }
+
+{$H-}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := '';
+  my_str_wide := '';
+  my_str_ansi := '';
+  my_str_uni := '';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase34.pp

@@ -0,0 +1,69 @@
+{ comparsion of empty string }
+
+{$H-}
+var
+  my_str: string;
+  my_str_wide: widestring;
+  my_str_ansi: ansistring;
+  my_str_uni: unicodestring;
+  i: integer;
+
+begin
+  my_str := '';
+  my_str_wide := '';
+  my_str_ansi := '';
+  my_str_uni := '';
+  i := -1;
+
+  case my_str of
+    'b'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'a': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error1');
+    Halt(1);
+  end;
+
+  case my_str_wide of
+    'b'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'a': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+  case my_str_ansi of
+    'b'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'a': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+  case my_str_uni of
+    'b'..'b': i := 1;
+    'c': i := 2;
+    'd'..'eee': i := 3;
+    ''..'a': i := 4;
+    else i := 0;
+  end;
+
+  if (i <> 4) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase35.pp

@@ -0,0 +1,70 @@
+{%FAIL}
+
+{ duplicate labels in different cases, one of them is range }
+
+{$H-}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'cab';
+  my_str_wide := 'cab';
+  my_str_ansi := 'cab';
+  my_str_uni := 'cab';
+  i := -1;
+
+  case my_str of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c'..'d': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_wide of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c'..'d': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_ansi of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c'..'d': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+
+
+  case my_str_uni of
+    'a'..'b': i := 1;
+    'c': i := 2;
+    'c'..'d': i := 3;
+    else i := 0;
+  end;
+
+  if (i <> 3) then begin
+    writeln('Error');
+    Halt(1);
+  end;
+end.

tests/test/tcase36.pp

@@ -0,0 +1,39 @@
+{%FAIL}
+
+{ left bound is greater; fails }
+
+{$H-}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'ababaca';
+  my_str_wide := 'ababaca';
+  my_str_ansi := 'ababaca';
+  my_str_uni := 'ababaca';
+  i := -1;
+
+  case my_str of
+    'abba'..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_wide of
+    'abba'..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_ansi of
+    'abba'..'ababaca': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_uni of
+    'abba'..'ababaca': i := 1;
+    else i := 0;
+  end;
+end.

tests/test/tcase37.pp

@@ -0,0 +1,39 @@
+{%FAIL}
+
+{ left bound is greater; comparsion with empty string. Fails }
+
+{$H-}
+var
+  my_str: string;
+  my_str_wide: string;
+  my_str_ansi: string;
+  my_str_uni: string;
+  i: integer;
+
+begin
+  my_str := 'ababaca';
+  my_str_wide := 'ababaca';
+  my_str_ansi := 'ababaca';
+  my_str_uni := 'ababaca';
+  i := -1;
+
+  case my_str of
+    'aba'..'': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_wide of
+    'aba'..'': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_ansi of
+    'aba'..'': i := 1;
+    else i := 0;
+  end;
+
+  case my_str_uni of
+    'aba'..'': i := 1;
+    else i := 0;
+  end;
+end.