home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / icon / dos / src / common / dlrgint.c < prev    next >
C/C++ Source or Header  |  1992-02-10  |  4KB  |  252 lines
  1. /*
  2.  * dlrgint.c - versions of "large integer" routines for compiled programs
  3.  *   that do not support large integers.
  4.  */
  5. #include "../h/rt.h"
  6.  
  7. /*
  8.  *****************************************************************
  9.  *
  10.  * Routines in the first set are only called when large integers
  11.  *  exist and thus these versions will never be called. They need
  12.  *  only have the correct signature and compile without error.
  13.  */
  14.  
  15. /*
  16.  *  bignum -> file 
  17.  */
  18. novalue bigprint(f, da)
  19. FILE *f;
  20. dptr da;
  21. {
  22. }
  23.  
  24. /*
  25.  *  bignum -> real
  26.  */
  27. double bigtoreal(da)
  28. dptr da;
  29.    {
  30.    return 0.0;
  31.    }
  32.  
  33. /*
  34.  *  bignum -> string
  35.  */
  36. int bigtos(da, dx)
  37. dptr da, dx;
  38.    {
  39.    return 0;
  40.    }
  41.  
  42. /*
  43.  *  da -> dx
  44.  */
  45. int cpbignum(da, dx)
  46. dptr da, dx;
  47.    {
  48.    return 0;
  49.    }
  50.  
  51. /*
  52.  *  da / db -> dx
  53.  */
  54. int bigdiv(da, db, dx)
  55. dptr da, db, dx;
  56.    {
  57.    return 0;
  58.    }
  59.  
  60. /*
  61.  *  da % db -> dx
  62.  */
  63. int bigmod(da, db, dx)
  64. dptr da, db, dx;
  65.    {
  66.    return 0;
  67.    }
  68.  
  69. /*
  70.  *  iand(da, db) -> dx
  71.  */
  72. int bigand(da, db, dx)
  73. dptr da, db, dx;
  74.    {
  75.    return 0;
  76.    }
  77.  
  78. /*
  79.  *  ior(da, db) -> dx
  80.  */
  81. int bigor(da, db, dx)
  82. dptr da, db, dx;
  83.    {
  84.    return 0;
  85.    }
  86.  
  87. /*
  88.  *  xor(da, db) -> dx
  89.  */
  90. int bigxor(da, db, dx)
  91. dptr da, db, dx;
  92.    {
  93.    return 0;
  94.    }
  95.  
  96. /*
  97.  *  negative if da < db
  98.  *  zero if da == db
  99.  *  positive if da > db
  100.  */
  101. word bigcmp(da, db)
  102. dptr da, db;
  103.    {
  104.    return (word)0;
  105.    }
  106.  
  107. /*
  108.  *  ?da -> dx
  109.  */  
  110. int bigrand(da, dx)
  111. dptr da, dx;
  112.    {
  113.    return 0;
  114.    }
  115.  
  116. /*
  117.  *************************************************************
  118.  *
  119.  * The following routines are called when overflow has occurred
  120.  *   during ordinary arithmentic.
  121.  */
  122.  
  123. /*
  124.  *  da + db -> dx
  125.  */
  126. int bigadd(da, db, dx)
  127. dptr da, db;
  128. dptr dx;
  129.    {
  130.    t_errornumber = 203;
  131.    t_errorvalue = nulldesc;
  132.    t_have_val = 0;
  133.    return Error;
  134.    }
  135.  
  136. /*
  137.  *  da * db -> dx
  138.  */
  139. int bigmul(da, db, dx)
  140. dptr da, db, dx;
  141.    {
  142.    t_errornumber = 203;
  143.    t_errorvalue = nulldesc;
  144.    t_have_val = 0;
  145.    return Error;
  146.    }
  147.  
  148. /*
  149.  *  -i -> dx
  150.  */
  151. int bigneg(da, dx)
  152. dptr da, dx;
  153.    {
  154.    t_errornumber = 203;
  155.    t_errorvalue = nulldesc;
  156.    t_have_val = 0;
  157.    return Error;
  158.    }
  159.  
  160. /*
  161.  *  da - db -> dx
  162.  */ 
  163. int bigsub(da, db, dx)
  164. dptr da, db, dx;
  165.    {
  166.    t_errornumber = 203;
  167.    t_errorvalue = nulldesc;
  168.    t_have_val = 0;
  169.    return Error;
  170.    }
  171.  
  172. /*
  173.  * ********************************************************
  174.  *
  175.  * The remaining routines each requires different handling.
  176.  */
  177.  
  178. /*
  179.  *  real -> bignum
  180.  */
  181. int realtobig(da, dx)
  182. dptr da, dx;
  183.    {
  184.    return Failed;  /* conversion cannot be done */
  185.    }
  186.  
  187. /*
  188.  *  da ^ db -> dx
  189.  */
  190. int bigpow(da, db, dx)
  191. dptr da, db, dx;
  192.    {
  193.    C_integer r;
  194.    extern int over_flow;
  195.  
  196.    /*
  197.     * Just do ordinary interger exponentiation and check for overflow.
  198.     */
  199.    r = iipow(IntVal(*da), IntVal(*db));
  200.    if (over_flow) {
  201.       k_errornumber = 203;
  202.       k_errortext = "";
  203.       k_errorvalue = nulldesc;
  204.       have_errval = 0;
  205.       return Error;
  206.       }
  207.    MakeInt(r, dx)
  208.    return Succeeded;
  209.    }
  210.  
  211. /*
  212.  *  string -> bignum 
  213.  */
  214. word bigradix(sign, r, s, end_s, result)
  215. int sign;                      /* '-' or not */
  216. int r;                          /* radix 2 .. 36 */
  217. char *s, *end_s;                        /* input string */
  218. union numeric *result;          /* output T_Integer or T_Lrgint */
  219.    {
  220.    /*
  221.     * Just do string to ordinary integer.
  222.     */
  223.    return radix(sign, r, s, end_s, result);
  224.    }
  225.  
  226. /*
  227.  *  bigshift(da, db) -> dx
  228.  */
  229. int bigshift(da, db, dx)
  230. dptr da, db, dx;
  231.    {
  232.    uword ci;                  /* shift in 0s, even if negative */
  233.    C_integer cj;
  234.  
  235.    /*
  236.     * Do an ordinary shift - note that db is always positive when this
  237.     *   routine is called.
  238.     */
  239.    ci = (uword)IntVal(*da);
  240.    cj = IntVal(*db);
  241.    /*
  242.     * Check for a shift of WordSize or greater; return an explicit 0 because
  243.     *  this is beyond C's defined behavior.  Otherwise shift as requested.
  244.     */
  245.    if (cj >= WordBits)
  246.       ci = 0;
  247.    else
  248.       ci <<= cj;
  249.    MakeInt(ci, dx)
  250.    return Succeeded;
  251.    }
  252.