OpenScop 0.8.1

int.c

Go to the documentation of this file.
00001 
00002     /*+-----------------------------------------------------------------**
00003      **                       OpenScop Library                          **
00004      **-----------------------------------------------------------------**
00005      **                             int.c                               **
00006      **-----------------------------------------------------------------**
00007      **                   First version: 18/07/2011                     **
00008      **-----------------------------------------------------------------**
00009 
00010  
00011  *****************************************************************************
00012  * OpenScop: Structures and formats for polyhedral tools to talk together    *
00013  *****************************************************************************
00014  *    ,___,,_,__,,__,,__,,__,,_,__,,_,__,,__,,___,_,__,,_,__,                *
00015  *    /   / /  //  //  //  // /   / /  //  //   / /  // /  /|,_,             *
00016  *   /   / /  //  //  //  // /   / /  //  //   / /  // /  / / /\             *
00017  *  |~~~|~|~~~|~~~|~~~|~~~|~|~~~|~|~~~|~~~|~~~|~|~~~|~|~~~|/_/  \            *
00018  *  | G |C| P | = | L | P |=| = |C| = | = | = |=| = |=| C |\  \ /\           *
00019  *  | R |l| o | = | e | l |=| = |a| = | = | = |=| = |=| L | \# \ /\          *
00020  *  | A |a| l | = | t | u |=| = |n| = | = | = |=| = |=| o | |\# \  \         *
00021  *  | P |n| l | = | s | t |=| = |d| = | = | = | |   |=| o | | \# \  \        *
00022  *  | H | | y |   | e | o | | = |l|   |   | = | |   | | G | |  \  \  \       *
00023  *  | I | |   |   | e |   | |   | |   |   |   | |   | |   | |   \  \  \      *
00024  *  | T | |   |   |   |   | |   | |   |   |   | |   | |   | |    \  \  \     *
00025  *  | E | |   |   |   |   | |   | |   |   |   | |   | |   | |     \  \  \    *
00026  *  | * |*| * | * | * | * |*| * |*| * | * | * |*| * |*| * | /      \* \  \   *
00027  *  | O |p| e | n | S | c |o| p |-| L | i | b |r| a |r| y |/        \  \ /   *
00028  *  '---'-'---'---'---'---'-'---'-'---'---'---'-'---'-'---'          '--'    *
00029  *                                                                           *
00030  * Copyright (C) 2008 University Paris-Sud 11 and INRIA                      *
00031  *                                                                           *
00032  * (3-clause BSD license)                                                    *
00033  * Redistribution and use in source  and binary forms, with or without       *
00034  * modification, are permitted provided that the following conditions        *
00035  * are met:                                                                  *
00036  *                                                                           *
00037  * 1. Redistributions of source code must retain the above copyright notice, *
00038  *    this list of conditions and the following disclaimer.                  *
00039  * 2. Redistributions in binary form must reproduce the above copyright      *
00040  *    notice, this list of conditions and the following disclaimer in the    *
00041  *    documentation and/or other materials provided with the distribution.   *
00042  * 3. The name of the author may not be used to endorse or promote products  *
00043  *    derived from this software without specific prior written permission.  *
00044  *                                                                           *
00045  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR      *
00046  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES *
00047  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.   *
00048  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,          *
00049  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT  *
00050  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, *
00051  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY     *
00052  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT       *
00053  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF  *
00054  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.         *
00055  *                                                                           *
00056  * OpenScop Library, a library to manipulate OpenScop formats and data       *
00057  * structures. Written by:                                                   *
00058  * Cedric Bastoul     <Cedric.Bastoul@u-psud.fr> and                         *
00059  * Louis-Noel Pouchet <Louis-Noel.pouchet@inria.fr>                          *
00060  *                                                                           *
00061  *****************************************************************************/
00062 
00063 #include <stdlib.h>
00064 #include <stdio.h>
00065 #ifdef OSL_GMP_IS_HERE
00066 # include <gmp.h>
00067 #endif
00068 
00069 #include <osl/macros.h>
00070 #include <osl/int.h>
00071 
00072 
00073 
00074 /*+***************************************************************************
00075  *                                Basic Functions                            *
00076  *****************************************************************************/
00077 
00078 
00086 void osl_int_dump_precision(FILE * file, int precision) {
00087 
00088   switch (precision) {
00089     case OSL_PRECISION_SP:
00090       fprintf(file, "32 bits");
00091       break;
00092     case OSL_PRECISION_DP:
00093       fprintf(file, "64 bits");
00094       break;
00095 #ifdef OSL_GMP_IS_HERE
00096     case OSL_PRECISION_MP:
00097       fprintf(file, "GMP");
00098       break;
00099 #endif
00100     default:
00101       fprintf(file, "unknown precision %d", precision);
00102   }
00103 }
00104 
00105 
00106 int osl_int_sizeof(int precision) {
00107   switch (precision) {
00108     case OSL_PRECISION_SP:
00109       return sizeof(long int);
00110 
00111     case OSL_PRECISION_DP:
00112       return sizeof(long long int);
00113 
00114 #ifdef OSL_GMP_IS_HERE
00115     case OSL_PRECISION_MP:
00116       return sizeof(mpz_t);
00117 #endif
00118 
00119     default:
00120       OSL_error("unknown precision");
00121   }
00122 }
00123 
00124 
00125 void * osl_int_address(int precision, void * base, int offset) {
00126   switch (precision) {
00127     case OSL_PRECISION_SP:
00128       return (long int *)base + offset;
00129 
00130     case OSL_PRECISION_DP:
00131       return (long long int *)base + offset;
00132 
00133 #ifdef OSL_GMP_IS_HERE
00134     case OSL_PRECISION_MP:
00135       return (mpz_t *)base + offset;
00136 #endif
00137 
00138     default:
00139       OSL_error("unknown precision");
00140   }
00141 }
00142 
00143 
00144 void osl_int_init(int precision, void * value_base, int value_offset) {
00145   void * value = osl_int_address(precision, value_base, value_offset);
00146 
00147   switch (precision) {
00148     case OSL_PRECISION_SP:
00149       *(long int *)value = 0;
00150       break;
00151 
00152     case OSL_PRECISION_DP:
00153       *(long long int *)value = 0;
00154       break;
00155 
00156 #ifdef OSL_GMP_IS_HERE
00157     case OSL_PRECISION_MP:
00158       mpz_init(*(mpz_t *)value);
00159       break;
00160 #endif
00161 
00162     default:
00163       OSL_error("unknown precision");
00164   }
00165 }
00166 
00167 
00168 void * osl_int_malloc(int precision) {
00169   void * value;
00170 
00171   switch (precision) {
00172     case OSL_PRECISION_SP:
00173       value = malloc(sizeof(long int));
00174       break;
00175 
00176     case OSL_PRECISION_DP:
00177       value = malloc(sizeof(long long int));
00178       *(long long int *)value = 0;
00179       break;
00180 
00181 #ifdef OSL_GMP_IS_HERE
00182     case OSL_PRECISION_MP:
00183       value = malloc(sizeof(mpz_t));
00184       break;
00185 #endif
00186 
00187     default:
00188       OSL_error("unknown precision");
00189   }
00190 
00191   osl_int_init(precision, value, 0);
00192   return value;
00193 }
00194 
00195 
00199 void osl_int_assign(int precision,
00200                     void * val1_base, int val1_offset,
00201                     void * val2_base, int val2_offset) {
00202   void * val1 = osl_int_address(precision, val1_base, val1_offset);
00203   void * val2 = osl_int_address(precision, val2_base, val2_offset);
00204 
00205   switch (precision) {
00206     case OSL_PRECISION_SP:
00207       *(long int *)val1 = *(long int *)val2;
00208       break;
00209 
00210     case OSL_PRECISION_DP:
00211       *(long long int *)val1 = *(long long int *)val2;
00212       break;
00213 
00214 #ifdef OSL_GMP_IS_HERE
00215     case OSL_PRECISION_MP:
00216       mpz_set(*(mpz_t *)val1, *(mpz_t *)val2);
00217       break;
00218 #endif
00219 
00220     default:
00221       OSL_error("unknown precision");
00222   }
00223 }
00224 
00225 
00229 void osl_int_set_si(int precision, void * value_base, int value_offset,
00230                     int i) {
00231   void * value = osl_int_address(precision, value_base, value_offset);
00232 
00233   switch (precision) {
00234     case OSL_PRECISION_SP:
00235       *(long int *)value = (long int)i;
00236       break;
00237 
00238     case OSL_PRECISION_DP:
00239       *(long long int *)value = (long long int)i;
00240       break;
00241 
00242 #ifdef OSL_GMP_IS_HERE
00243     case OSL_PRECISION_MP:
00244       mpz_set_si(*(mpz_t *)value, i);
00245       break;
00246 #endif
00247 
00248     default:
00249       OSL_error("unknown precision");
00250   }
00251 }
00252 
00253 
00257 int osl_int_get_si(int precision, void * value_base, int value_offset) {
00258   void * value = osl_int_address(precision, value_base, value_offset);
00259 
00260   switch (precision) {
00261     case OSL_PRECISION_SP:
00262       return *(int *)value;
00263 
00264     case OSL_PRECISION_DP:
00265       return *(int *)value;
00266 
00267 #ifdef OSL_GMP_IS_HERE
00268     case OSL_PRECISION_MP:
00269       return mpz_get_si(*(mpz_t *)value);
00270 #endif
00271 
00272     default:
00273       OSL_error("unknown precision");
00274   }
00275 }
00276 
00277 
00281 void osl_int_init_set_si(int precision,
00282                          void * value_base, int value_offset, int i) {
00283   void * value = osl_int_address(precision, value_base, value_offset);
00284 
00285   switch (precision) {
00286     case OSL_PRECISION_SP:
00287       *(long int *)value = (long int)i;
00288       break;
00289 
00290     case OSL_PRECISION_DP:
00291       *(long long int *)value = (long long int)i;
00292       break;
00293 
00294 #ifdef OSL_GMP_IS_HERE
00295     case OSL_PRECISION_MP:
00296       mpz_init_set_si(*(mpz_t *)value, i);
00297       break;
00298 #endif
00299 
00300     default:
00301       OSL_error("unknown precision");
00302   }
00303 }
00304 
00305 
00309 void osl_int_clear(int precision, void * value_base, int value_offset) {
00310   void * value = osl_int_address(precision, value_base, value_offset);
00311   
00312   switch (precision) {
00313     case OSL_PRECISION_SP:
00314       *(long int *)value = 0;
00315       break;
00316 
00317     case OSL_PRECISION_DP:
00318       *(long long int *)value = 0;
00319       break;
00320 
00321 #ifdef OSL_GMP_IS_HERE
00322     case OSL_PRECISION_MP:
00323       mpz_clear(*(mpz_t *)value);
00324       break;
00325 #endif
00326 
00327     default:
00328       OSL_error("unknown precision");
00329   }
00330 }
00331 
00332 
00333 void osl_int_free(int precision, void * value_base, int value_offset) {
00334   void * value = osl_int_address(precision, value_base, value_offset);
00335 
00336   osl_int_clear(precision, value_base, value_offset);
00337   free(value);
00338 }
00339 
00340 
00349 void osl_int_print(FILE * file, int precision,
00350                    void * value_base, int value_offset) {
00351   char string[OSL_MAX_STRING];
00352   
00353   osl_int_sprint(string, precision, value_base, value_offset);
00354   fprintf(file, "%s", string);
00355 }
00356 
00357 
00367 void osl_int_sprint(char * string, int precision,
00368                     void * value_base, int value_offset) {
00369   void * value = osl_int_address(precision, value_base, value_offset);
00370             
00371   switch (precision) {
00372     case OSL_PRECISION_SP:
00373       sprintf(string, OSL_FMT_SP, *(long int *)value);
00374       break;
00375 
00376     case OSL_PRECISION_DP:
00377       sprintf(string, OSL_FMT_DP, *(long long int *)value);
00378       break;
00379 
00380 #ifdef OSL_GMP_IS_HERE
00381     case OSL_PRECISION_MP: {
00382       char * str;
00383       str = mpz_get_str(0, 10, *(mpz_t *)value); //TODO: 10 -> #define
00384       sprintf(string, OSL_FMT_MP, str);
00385       free(str);
00386       break;
00387     }
00388 #endif
00389 
00390     default:
00391       OSL_error("unknown precision");
00392   }
00393 }
00394 
00395 
00402 void osl_int_sprint_txt(char * string, int precision,
00403                         void * value_base, int value_offset) {
00404   void * value = osl_int_address(precision, value_base, value_offset);
00405             
00406   switch (precision) {
00407     case OSL_PRECISION_SP:
00408       sprintf(string, OSL_FMT_TXT_SP, *(long int *)value);
00409       break;
00410 
00411     case OSL_PRECISION_DP:
00412       sprintf(string, OSL_FMT_TXT_DP, *(long long int *)value);
00413       break;
00414 
00415 #ifdef OSL_GMP_IS_HERE
00416     case OSL_PRECISION_MP: {
00417       char * str;
00418       str = mpz_get_str(0, 10, *(mpz_t *)value); //TODO: 10 -> #define
00419       sprintf(string, OSL_FMT_TXT_MP, str);
00420       free(str);
00421       break;
00422     }
00423 #endif
00424 
00425     default:
00426       OSL_error("unknown precision");
00427   }
00428 }
00429 
00430 
00431 void osl_int_sread(char ** string, int precision,
00432                    void * value_base, int value_offset) {
00433   void * value = osl_int_address(precision, value_base, value_offset);
00434   int nb_read = 0;
00435 
00436   switch (precision) {
00437     case OSL_PRECISION_SP:
00438       nb_read = sscanf(*string, OSL_FMT_TXT_SP, (long int *)value);
00439       if (nb_read == 0)
00440         OSL_error("failed to read an integer");
00441       break;
00442 
00443     case OSL_PRECISION_DP:
00444       nb_read = sscanf(*string, OSL_FMT_TXT_DP, (long long int *)value);
00445       if (nb_read == 0)
00446         OSL_error("failed to read an integer");
00447       break;
00448 
00449 #ifdef OSL_GMP_IS_HERE
00450     case OSL_PRECISION_MP: {
00451       long long int tmp;
00452       nb_read = sscanf(*string, OSL_FMT_TXT_DP, &tmp);
00453       if (nb_read == 0)
00454         OSL_error("failed to read an integer");
00455       mpz_set_si(*(mpz_t *)value, tmp);
00456       break;
00457     }
00458 #endif
00459 
00460     default:
00461       OSL_error("unknown precision");
00462   }
00463 
00464   // Update the position in the input string.
00465   *string = *string + nb_read;
00466 }
00467 
00468 
00469 /*+***************************************************************************
00470  *                            Arithmetic Operations                          *
00471  *****************************************************************************/
00472 
00473 
00477 void osl_int_increment(int precision,
00478                        void * result_base, int result_offset,
00479                        void * value_base,  int value_offset) {
00480   void * result = osl_int_address(precision, result_base, result_offset);
00481   void * value  = osl_int_address(precision, value_base, value_offset);
00482 
00483   switch (precision) {
00484     case OSL_PRECISION_SP:
00485       *(long int *)result = *(long int *)value + (long int)1;
00486       break;
00487 
00488     case OSL_PRECISION_DP:
00489       *(long long int *)result = *(long long int *)value + (long long int)1;
00490       break;
00491 
00492 #ifdef OSL_GMP_IS_HERE
00493     case OSL_PRECISION_MP:
00494       mpz_add_ui(*(mpz_t *)result, *(mpz_t *)value, 1);
00495       break;
00496 #endif
00497 
00498     default:
00499       OSL_error("unknown precision");
00500   }
00501 }
00502 
00503 
00507 void osl_int_decrement(int precision,
00508                        void * result_base, int result_offset,
00509                        void * value_base,  int value_offset) {
00510   void * result = osl_int_address(precision, result_base, result_offset);
00511   void * value  = osl_int_address(precision, value_base, value_offset);
00512 
00513   switch (precision) {
00514     case OSL_PRECISION_SP:
00515       *(long int *)result = *(long int *)value - (long int)1;
00516       break;
00517 
00518     case OSL_PRECISION_DP:
00519       *(long long int *)result = *(long long int *)value - (long long int)1;
00520       break;
00521 
00522 #ifdef OSL_GMP_IS_HERE
00523     case OSL_PRECISION_MP: {
00524       mpz_t one;
00525       mpz_init_set_si(one, 1);
00526       mpz_sub(*(mpz_t *)result, *(mpz_t *)value, one);
00527       mpz_clear(one);
00528       break;
00529     }
00530 #endif
00531 
00532     default:
00533       OSL_error("unknown precision");
00534   }
00535 }
00536 
00537 
00541 void osl_int_add(int precision,
00542                  void * result_base, int result_offset,
00543                  void * val1_base,   int val1_offset,
00544                  void * val2_base,   int val2_offset) {
00545   void * result = osl_int_address(precision, result_base, result_offset);
00546   void * val1   = osl_int_address(precision, val1_base, val1_offset);
00547   void * val2   = osl_int_address(precision, val2_base, val2_offset);
00548 
00549   switch (precision) {
00550     case OSL_PRECISION_SP:
00551       *(long int *)result = *(long int *)val1 + *(long int *)val2;
00552       break;
00553 
00554     case OSL_PRECISION_DP:
00555       *(long long int *)result = *(long long int *)val1 +
00556                                  *(long long int *)val2;
00557       break;
00558 
00559 #ifdef OSL_GMP_IS_HERE
00560     case OSL_PRECISION_MP:
00561       mpz_add(*(mpz_t *)result, *(mpz_t *)val1, *(mpz_t *)val2);
00562       break;
00563 #endif
00564 
00565     default:
00566       OSL_error("unknown precision");
00567   }
00568 }
00569 
00570 
00574 void osl_int_add_si(int precision,
00575                     void * result_base, int result_offset,
00576                     void * value_base,  int value_offset, int i) {
00577   void * result = osl_int_address(precision, result_base, result_offset);
00578   void * value  = osl_int_address(precision, value_base, value_offset);
00579 
00580   switch (precision) {
00581     case OSL_PRECISION_SP:
00582       *(long int *)result = *(long int *)value + (long int)i;
00583       break;
00584 
00585     case OSL_PRECISION_DP:
00586       *(long long int *)result = *(long long int *)value + (long long int)i;
00587       break;
00588 
00589 #ifdef OSL_GMP_IS_HERE
00590     case OSL_PRECISION_MP: {
00591       mpz_t si;
00592       mpz_init_set_si(si, i);
00593       mpz_add(*(mpz_t *)result, *(mpz_t *)value, si);
00594       mpz_clear(si);
00595       break;
00596     }
00597 #endif
00598 
00599     default:
00600       OSL_error("unknown precision");
00601   }
00602 }
00603 
00604 
00608 void osl_int_mul(int precision,
00609                  void * result_base, int result_offset,
00610                  void * val1_base,   int val1_offset,
00611                  void * val2_base,   int val2_offset) {
00612   void * result = osl_int_address(precision, result_base, result_offset);
00613   void * val1   = osl_int_address(precision, val1_base, val1_offset);
00614   void * val2   = osl_int_address(precision, val2_base, val2_offset);
00615 
00616   switch (precision) {
00617     case OSL_PRECISION_SP:
00618       *(long int *)result = *(long int *)val1 * *(long int *)val2;
00619       break;
00620 
00621     case OSL_PRECISION_DP:
00622       *(long long int *)result = *(long long int *)val1 *
00623                                  *(long long int *)val2;
00624       break;
00625 
00626 #ifdef OSL_GMP_IS_HERE
00627     case OSL_PRECISION_MP:
00628       mpz_mul(*(mpz_t *)result, *(mpz_t *)val1, *(mpz_t *)val2);
00629       break;
00630 #endif
00631 
00632     default:
00633       OSL_error("unknown precision");
00634   }
00635 }
00636 
00637 
00641 void osl_int_mul_si(int precision,
00642                     void * result_base, int result_offset,
00643                     void * value_base,  int value_offset, int i) {
00644   void * result = osl_int_address(precision, result_base, result_offset);
00645   void * value  = osl_int_address(precision, value_base, value_offset);
00646 
00647   switch (precision) {
00648     case OSL_PRECISION_SP:
00649       *(long int *)result = *(long int *)value * (long int)i;
00650       break;
00651 
00652     case OSL_PRECISION_DP:
00653       *(long long int *)result = *(long long int *)value * (long long int)i;
00654       break;
00655 
00656 #ifdef OSL_GMP_IS_HERE
00657     case OSL_PRECISION_MP:
00658       mpz_mul_si(*(mpz_t *)result, *(mpz_t *)value, i);
00659       break;
00660 #endif
00661 
00662     default:
00663       OSL_error("unknown precision");
00664   }
00665 }
00666 
00667 
00671 void osl_int_sub(int precision,
00672                  void * result_base, int result_offset,
00673                  void * val1_base,   int val1_offset,
00674                  void * val2_base,   int val2_offset) {
00675   void * result = osl_int_address(precision, result_base, result_offset);
00676   void * val1   = osl_int_address(precision, val1_base, val1_offset);
00677   void * val2   = osl_int_address(precision, val2_base, val2_offset);
00678 
00679   switch (precision) {
00680     case OSL_PRECISION_SP:
00681       *(long int *)result = *(long int *)val1 - *(long int *)val2;
00682       break;
00683 
00684     case OSL_PRECISION_DP:
00685       *(long long int *)result = *(long long int *)val1 -
00686                                  *(long long int *)val2;
00687       break;
00688 
00689 #ifdef OSL_GMP_IS_HERE
00690     case OSL_PRECISION_MP:
00691       mpz_sub(*(mpz_t *)result, *(mpz_t *)val1, *(mpz_t *)val2);
00692       break;
00693 #endif
00694 
00695     default:
00696       OSL_error("unknown precision");
00697   }
00698 }
00699 
00700 
00704 void osl_int_oppose(int precision,
00705                     void * result_base, int result_offset,
00706                     void * value_base,  int value_offset) {
00707   void * result = osl_int_address(precision, result_base, result_offset);
00708   void * value  = osl_int_address(precision, value_base, value_offset);
00709 
00710   switch (precision) {
00711     case OSL_PRECISION_SP:
00712       *(long int *)result = -*(long int *)value;
00713       break;
00714 
00715     case OSL_PRECISION_DP:
00716       *(long long int *)result = -*(long long int *)value;
00717       break;
00718 
00719 #ifdef OSL_GMP_IS_HERE
00720     case OSL_PRECISION_MP:
00721       mpz_neg(*(mpz_t *)result, *(mpz_t *)value);
00722       break;
00723 #endif
00724 
00725     default:
00726       OSL_error("unknown precision");
00727   }
00728 }
00729 
00730 
00731 /*+***************************************************************************
00732  *                            Conditional Operations                         *
00733  *****************************************************************************/
00734 
00735 
00739 int osl_int_eq(int precision,
00740                void * val1_base, int val1_offset,
00741                void * val2_base, int val2_offset) {
00742   void * val1 = osl_int_address(precision, val1_base, val1_offset);
00743   void * val2 = osl_int_address(precision, val2_base, val2_offset);
00744 
00745   switch (precision) {
00746     case OSL_PRECISION_SP:
00747       return (*(long int *)val1 == *(long int *)val2);
00748 
00749     case OSL_PRECISION_DP:
00750       return (*(long long int *)val1 == *(long long int *)val2);
00751 
00752 #ifdef OSL_GMP_IS_HERE
00753     case OSL_PRECISION_MP:
00754       return (mpz_cmp(*(mpz_t *)val1, *(mpz_t *)val2) == 0);
00755 #endif
00756 
00757     default:
00758       OSL_error("unknown precision");
00759   }
00760 }
00761 
00762 
00766 int osl_int_ne(int precision,
00767                void * val1_base, int val1_offset,
00768                void * val2_base, int val2_offset) {
00769   return !osl_int_eq(precision,
00770                           val1_base, val1_offset,
00771                           val2_base, val2_offset);
00772 }
00773 
00774 
00778 int osl_int_pos(int precision, void * value_base, int value_offset) {
00779   void * value = osl_int_address(precision, value_base, value_offset);
00780 
00781   switch (precision) {
00782     case OSL_PRECISION_SP:
00783       return (*(long int *)value > 0);
00784 
00785     case OSL_PRECISION_DP:
00786       return (*(long long int *)value > 0);
00787 
00788 #ifdef OSL_GMP_IS_HERE
00789     case OSL_PRECISION_MP:
00790       return (mpz_sgn(*(mpz_t *)value) > 0);
00791 #endif
00792 
00793     default:
00794       OSL_error("unknown precision");
00795   }
00796 }
00797 
00798 
00802 int osl_int_neg(int precision, void * value_base, int value_offset) {
00803   void * value = osl_int_address(precision, value_base, value_offset);
00804 
00805   switch (precision) {
00806     case OSL_PRECISION_SP:
00807       return (*(long int *)value < 0);
00808 
00809     case OSL_PRECISION_DP:
00810       return (*(long long int *)value < 0);
00811 
00812 #ifdef OSL_GMP_IS_HERE
00813     case OSL_PRECISION_MP:
00814       return (mpz_sgn(*(mpz_t *)value) < 0);
00815 #endif
00816 
00817     default:
00818       OSL_error("unknown precision");
00819   }
00820 }
00821 
00822 
00826 int osl_int_zero(int precision, void * value_base, int value_offset) {
00827   void * value = osl_int_address(precision, value_base, value_offset);
00828 
00829   switch (precision) {
00830     case OSL_PRECISION_SP:
00831       return (*(long int *)value == 0);
00832 
00833     case OSL_PRECISION_DP:
00834       return (*(long long int *)value == 0);
00835 
00836 #ifdef OSL_GMP_IS_HERE
00837     case OSL_PRECISION_MP:
00838       return (mpz_sgn(*(mpz_t *)value) == 0);
00839 #endif
00840 
00841     default:
00842       OSL_error("unknown precision");
00843   }
00844 }
00845 
00846 
00850 int osl_int_one(int precision, void * value_base, int value_offset) {
00851   void * value = osl_int_address(precision, value_base, value_offset);
00852 
00853   switch (precision) {
00854     case OSL_PRECISION_SP:
00855       return (*(long int *)value == (long int)1);
00856 
00857     case OSL_PRECISION_DP:
00858       return (*(long long int *)value == (long long int)1);
00859 
00860 #ifdef OSL_GMP_IS_HERE
00861     case OSL_PRECISION_MP:
00862       return (mpz_cmp_si(*(mpz_t *)value, 1) == 0);
00863 #endif
00864 
00865     default:
00866       OSL_error("unknown precision");
00867   }
00868 }
00869 
00870 
00874 int osl_int_mone(int precision, void * value_base, int value_offset) {
00875   void * value = osl_int_address(precision, value_base, value_offset);
00876 
00877   switch (precision) {
00878     case OSL_PRECISION_SP:
00879       return (*(long int *)value == (long int)-1);
00880 
00881     case OSL_PRECISION_DP:
00882       return (*(long long int *)value == (long long int)-1);
00883 
00884 #ifdef OSL_GMP_IS_HERE
00885     case OSL_PRECISION_MP:
00886       return (mpz_cmp_si(*(mpz_t *)value, -1) == 0);
00887 #endif
00888 
00889     default:
00890       OSL_error("unknown precision");
00891   }
00892 }
00893 
00894 
00898 int osl_int_divisible(int precision,
00899                       void * val1_base, int val1_offset,
00900                       void * val2_base, int val2_offset) {
00901   void * val1 = osl_int_address(precision, val1_base, val1_offset);
00902   void * val2 = osl_int_address(precision, val2_base, val2_offset);
00903 
00904   switch (precision) {
00905     case OSL_PRECISION_SP:
00906       return ((*(long int *)val1 % *(long int *)val2) == 0);
00907 
00908     case OSL_PRECISION_DP:
00909       return ((*(long long int *)val1 % *(long long int *)val2) == 0);
00910 
00911 #ifdef OSL_GMP_IS_HERE
00912     case OSL_PRECISION_MP:
00913       return mpz_divisible_p(*(mpz_t *)val1, *(mpz_t *)val2);
00914 #endif
00915 
00916     default:
00917       OSL_error("unknown precision");
00918   }
00919 }