home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume3 / g-format / part3 / gfloat / f77 / src / f77pass1 / conv.c.diff < prev    next >
Encoding:
Text File  |  1986-11-30  |  23.8 KB  |  1,070 lines
  1. *** ../f77/src/f77pass1/conv.c.orig    Tue Oct 29 15:15:46 1985
  2. --- ../f77/src/f77pass1/conv.c    Tue Oct 29 15:22:23 1985
  3. ***************
  4. *** 53,59
  5.   
  6.   
  7.   /*  The following constants are used to check the limits of  */
  8. ! /*  conversions.  Dmaxword is the largest double precision   */
  9.   /*  number which can be converted to a two-byte integer      */
  10.   /*  without overflow.  Dminword is the smallest double       */
  11.   /*  precision value which can be converted to a two-byte     */
  12.  
  13. --- 53,61 -----
  14.   
  15.   
  16.   /*  The following constants are used to check the limits of  */
  17. ! /*  conversions.                                 */
  18. ! 
  19. ! /*  Dmaxword is the largest double precision                    */
  20.   /*  number which can be converted to a two-byte integer      */
  21.   /*  without overflow.  Dminword is the smallest double       */
  22.   /*  precision value which can be converted to a two-byte     */
  23. ***************
  24. *** 57,66
  25.   /*  number which can be converted to a two-byte integer      */
  26.   /*  without overflow.  Dminword is the smallest double       */
  27.   /*  precision value which can be converted to a two-byte     */
  28. ! /*  integer without overflow.  Dmaxint and dminint are the   */
  29. ! /*  analogous values for four-byte integers.                 */
  30. ! 
  31. ! 
  32.   LOCAL long dmaxword[] = { 0xfeff47ff, 0xffffffff };
  33.   LOCAL long dminword[] = { 0x00ffc800, 0xffffffff };
  34.   
  35.  
  36. --- 59,66 -----
  37.   /*  number which can be converted to a two-byte integer      */
  38.   /*  without overflow.  Dminword is the smallest double       */
  39.   /*  precision value which can be converted to a two-byte     */
  40. ! /*  integer without overflow.                                */
  41. ! #ifndef GFLOAT
  42.   LOCAL long dmaxword[] = { 0xfeff47ff, 0xffffffff };
  43.   LOCAL long dminword[] = { 0x00ffc800, 0xffffffff };
  44.   #else GFLOAT
  45. ***************
  46. *** 63,68
  47.   
  48.   LOCAL long dmaxword[] = { 0xfeff47ff, 0xffffffff };
  49.   LOCAL long dminword[] = { 0x00ffc800, 0xffffffff };
  50.   
  51.   LOCAL long dmaxint[]  = { 0xffff4fff, 0xfffffeff };
  52.   LOCAL long dminint[]  = { 0x0000d000, 0xffff00ff };
  53.  
  54. --- 63,72 -----
  55.   #ifndef GFLOAT
  56.   LOCAL long dmaxword[] = { 0xfeff47ff, 0xffffffff };
  57.   LOCAL long dminword[] = { 0x00ffc800, 0xffffffff };
  58. + #else GFLOAT
  59. + LOCAL long dmaxword[] = { 0xffdf40ff, 0xffffffff };
  60. + LOCAL long dminword[] = { 0x0010c100, 0x00000000 };
  61. + #endif GFLOAT
  62.   
  63.   /*  Dmaxint and dminint are the limits for double values     */
  64.   /*  converted to four-byte integers.                         */
  65. ***************
  66. *** 64,69
  67.   LOCAL long dmaxword[] = { 0xfeff47ff, 0xffffffff };
  68.   LOCAL long dminword[] = { 0x00ffc800, 0xffffffff };
  69.   
  70.   LOCAL long dmaxint[]  = { 0xffff4fff, 0xfffffeff };
  71.   LOCAL long dminint[]  = { 0x0000d000, 0xffff00ff };
  72.   
  73.  
  74. --- 68,79 -----
  75.   LOCAL long dminword[] = { 0x0010c100, 0x00000000 };
  76.   #endif GFLOAT
  77.   
  78. + /*  Dmaxint and dminint are the limits for double values     */
  79. + /*  converted to four-byte integers.                         */
  80. + #ifdef GFLOAT
  81. + LOCAL long dmaxint[]  = { 0xffff41ff, 0xffffffdf };
  82. + LOCAL long dminint[]  = { 0x0000c200, 0xffff0010 };
  83. + #else GFLOAT
  84.   LOCAL long dmaxint[]  = { 0xffff4fff, 0xfffffeff };
  85.   LOCAL long dminint[]  = { 0x0000d000, 0xffff00ff };
  86.   #endif GFLOAT
  87. ***************
  88. *** 66,71
  89.   
  90.   LOCAL long dmaxint[]  = { 0xffff4fff, 0xfffffeff };
  91.   LOCAL long dminint[]  = { 0x0000d000, 0xffff00ff };
  92.   
  93.   LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff };
  94.   LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff };
  95.  
  96. --- 76,82 -----
  97.   #else GFLOAT
  98.   LOCAL long dmaxint[]  = { 0xffff4fff, 0xfffffeff };
  99.   LOCAL long dminint[]  = { 0x0000d000, 0xffff00ff };
  100. + #endif GFLOAT
  101.   
  102.   #ifndef GFLOAT
  103.   LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff };
  104. ***************
  105. *** 67,72
  106.   LOCAL long dmaxint[]  = { 0xffff4fff, 0xfffffeff };
  107.   LOCAL long dminint[]  = { 0x0000d000, 0xffff00ff };
  108.   
  109.   LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff };
  110.   LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff };
  111.   
  112.  
  113. --- 78,84 -----
  114.   LOCAL long dminint[]  = { 0x0000d000, 0xffff00ff };
  115.   #endif GFLOAT
  116.   
  117. + #ifndef GFLOAT
  118.   LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff };
  119.   LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff };
  120.   #else GFLOAT
  121. ***************
  122. *** 69,74
  123.   
  124.   LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff };
  125.   LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff };
  126.   
  127.   
  128.   
  129.  
  130. --- 81,89 -----
  131.   #ifndef GFLOAT
  132.   LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff };
  133.   LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff };
  134. + #else GFLOAT
  135. + LOCAL long dmaxreal[] = { 0xffff47f7, 0xffffffff };
  136. + LOCAL long dminreal[] = { 0xffffc7f7, 0xffffffff };
  137.   
  138.   /*  Fmaxword and fminword are limits for float to short.     */
  139.   LOCAL long fmaxword[] = { 0xff7f47ff };
  140. ***************
  141. *** 70,75
  142.   LOCAL long dmaxreal[] = { 0xffff7fff, 0xffff7fff };
  143.   LOCAL long dminreal[] = { 0xffffffff, 0xffff7fff };
  144.   
  145.   
  146.   
  147.   /*  The routines which follow are used to convert  */
  148.  
  149. --- 85,98 -----
  150.   LOCAL long dmaxreal[] = { 0xffff47f7, 0xffffffff };
  151.   LOCAL long dminreal[] = { 0xffffc7f7, 0xffffffff };
  152.   
  153. + /*  Fmaxword and fminword are limits for float to short.     */
  154. + LOCAL long fmaxword[] = { 0xff7f47ff };
  155. + LOCAL long fminword[] = { 0x00ffc800 };
  156. + 
  157. + /*  Fmaxint and fminint are the limits for float to int.     */
  158. + LOCAL long fmaxint[]  = { 0xffff4fff };
  159. + LOCAL long fminint[]  = { 0x0000d000 };
  160. + #endif GFLOAT
  161.   
  162.   
  163.   /*  The routines which follow are used to convert  */
  164. ***************
  165. *** 188,193
  166.     register long *rp;
  167.     register double *minp;
  168.     register double *maxp;
  169.     realvalue x;
  170.   
  171.     switch (cp->vtype)
  172.  
  173. --- 211,220 -----
  174.     register long *rp;
  175.     register double *minp;
  176.     register double *maxp;
  177. + #ifdef GFLOAT
  178. +   register float *minpf;
  179. +   register float *maxpf;
  180. + #endif GFLOAT
  181.     realvalue x;
  182.   
  183.     switch (cp->vtype)
  184. ***************
  185. *** 222,227
  186.         break;
  187.   
  188.       case TYREAL:
  189.       case TYDREAL:
  190.       case TYCOMPLEX:
  191.       case TYDCOMPLEX:
  192.  
  193. --- 249,255 -----
  194.         break;
  195.   
  196.       case TYREAL:
  197. + #ifndef GFLOAT
  198.       case TYDREAL:
  199.   #endif GFLOAT
  200.       case TYCOMPLEX:
  201. ***************
  202. *** 223,228
  203.   
  204.       case TYREAL:
  205.       case TYDREAL:
  206.       case TYCOMPLEX:
  207.       case TYDCOMPLEX:
  208.         minp = (double *) dminword;
  209.  
  210. --- 251,257 -----
  211.       case TYREAL:
  212.   #ifndef GFLOAT
  213.       case TYDREAL:
  214. + #endif GFLOAT
  215.       case TYCOMPLEX:
  216.   #ifdef GFLOAT
  217.         minpf = (float *) fminword;
  218. ***************
  219. *** 224,229
  220.       case TYREAL:
  221.       case TYDREAL:
  222.       case TYCOMPLEX:
  223.       case TYDCOMPLEX:
  224.         minp = (double *) dminword;
  225.         maxp = (double *) dmaxword;
  226.  
  227. --- 253,290 -----
  228.       case TYDREAL:
  229.   #endif GFLOAT
  230.       case TYCOMPLEX:
  231. + #ifdef GFLOAT
  232. +       minpf = (float *) fminword;
  233. +       maxpf = (float *) fmaxword;
  234. +       rp = (long *) &(cp->const.cr[0]);
  235. +       x.q.word1 = rp[0];
  236. +       if (x.f.sign == 1 && x.f.exp == 0)
  237. +     {
  238. +       if (badvalue <= 1)
  239. +         {
  240. +           badvalue = 2;
  241. +           err(reserved);
  242. +         }
  243. +       p = errnode();
  244. +     }
  245. +       else if ((float) x.q.word1 >= *minpf && (float) x.q.word1 <= *maxpf)
  246. +     {
  247. +       p = (expptr) mkconst(TYSHORT);
  248. +       p->constblock.const.ci = x.q.word1;
  249. +     }
  250. +       else
  251. +     {
  252. +       if (badvalue <= 1)
  253. +         {
  254. +           badvalue = 2;
  255. +           err(toobig);
  256. +         }
  257. +       p = errnode();
  258. +     }
  259. +       break;
  260. + 
  261. +     case TYDREAL:
  262. + #endif GFLOAT
  263.       case TYDCOMPLEX:
  264.         minp = (double *) dminword;
  265.         maxp = (double *) dmaxword;
  266. ***************
  267. *** 230,235
  268.         rp = (long *) &(cp->const.cd[0]);
  269.         x.q.word1 = rp[0];
  270.         x.q.word2 = rp[1];
  271.         if (x.f.sign == 1 && x.f.exp == 0)
  272.       {
  273.         if (badvalue <= 1)
  274.  
  275. --- 291,297 -----
  276.         rp = (long *) &(cp->const.cd[0]);
  277.         x.q.word1 = rp[0];
  278.         x.q.word2 = rp[1];
  279. + #ifndef GFLOAT
  280.         if (x.f.sign == 1 && x.f.exp == 0)
  281.   #else GFLOAT
  282.         if (x.g.sign == 1 && x.g.exp == 0)
  283. ***************
  284. *** 231,236
  285.         x.q.word1 = rp[0];
  286.         x.q.word2 = rp[1];
  287.         if (x.f.sign == 1 && x.f.exp == 0)
  288.       {
  289.         if (badvalue <= 1)
  290.           {
  291.  
  292. --- 293,301 -----
  293.         x.q.word2 = rp[1];
  294.   #ifndef GFLOAT
  295.         if (x.f.sign == 1 && x.f.exp == 0)
  296. + #else GFLOAT
  297. +       if (x.g.sign == 1 && x.g.exp == 0)
  298. + #endif GFLOAT
  299.       {
  300.         if (badvalue <= 1)
  301.           {
  302. ***************
  303. *** 302,307
  304.     register long *rp;
  305.     register double *minp;
  306.     register double *maxp;
  307.     realvalue x;
  308.   
  309.     switch (cp->vtype)
  310.  
  311. --- 367,376 -----
  312.     register long *rp;
  313.     register double *minp;
  314.     register double *maxp;
  315. + #ifdef GFLOAT
  316. +   register float *minpf;
  317. +   register float *maxpf;
  318. + #endif GFLOAT
  319.     realvalue x;
  320.   
  321.     switch (cp->vtype)
  322. ***************
  323. *** 323,328
  324.         break;
  325.   
  326.       case TYREAL:
  327.       case TYDREAL:
  328.       case TYCOMPLEX:
  329.       case TYDCOMPLEX:
  330.  
  331. --- 392,398 -----
  332.         break;
  333.   
  334.       case TYREAL:
  335. + #ifndef GFLOAT
  336.       case TYDREAL:
  337.   #endif GFLOAT
  338.       case TYCOMPLEX:
  339. ***************
  340. *** 324,329
  341.   
  342.       case TYREAL:
  343.       case TYDREAL:
  344.       case TYCOMPLEX:
  345.       case TYDCOMPLEX:
  346.         minp = (double *) dminint;
  347.  
  348. --- 394,400 -----
  349.       case TYREAL:
  350.   #ifndef GFLOAT
  351.       case TYDREAL:
  352. + #endif GFLOAT
  353.       case TYCOMPLEX:
  354.   #ifdef GFLOAT
  355.         minpf = (float *) fminint;
  356. ***************
  357. *** 325,330
  358.       case TYREAL:
  359.       case TYDREAL:
  360.       case TYCOMPLEX:
  361.       case TYDCOMPLEX:
  362.         minp = (double *) dminint;
  363.         maxp = (double *) dmaxint;
  364.  
  365. --- 396,432 -----
  366.       case TYDREAL:
  367.   #endif GFLOAT
  368.       case TYCOMPLEX:
  369. + #ifdef GFLOAT
  370. +       minpf = (float *) fminint;
  371. +       maxpf = (float *) fmaxint;
  372. +       x.q.word1 = *((long *) &cp->const.cr[0]);
  373. +       if (x.f.sign == 1 && x.f.exp == 0)
  374. +     {
  375. +       if (badvalue <= 1)
  376. +         {
  377. +           badvalue = 2;
  378. +           err(reserved);
  379. +         }
  380. +       p = errnode();
  381. +     }
  382. +       else if (cp->const.cr[0] >= *minpf && cp->const.cr[0] <= *maxpf)
  383. +     {
  384. +       p = (expptr) mkconst(TYLONG);
  385. +       p->constblock.const.ci = cp->const.cr[0];
  386. +     }
  387. +       else
  388. +     {
  389. +       if (badvalue <= 1)
  390. +         {
  391. +           badvalue = 2;
  392. +           err(toobig);
  393. +         }
  394. +       p = errnode();
  395. +     }
  396. +       break;
  397. + 
  398. +     case TYDREAL:
  399. + #endif GFLOAT
  400.       case TYDCOMPLEX:
  401.         minp = (double *) dminint;
  402.         maxp = (double *) dmaxint;
  403. ***************
  404. *** 331,336
  405.         rp = (long *) &(cp->const.cd[0]);
  406.         x.q.word1 = rp[0];
  407.         x.q.word2 = rp[1];
  408.         if (x.f.sign == 1 && x.f.exp == 0)
  409.       {
  410.         if (badvalue <= 1)
  411.  
  412. --- 433,439 -----
  413.         rp = (long *) &(cp->const.cd[0]);
  414.         x.q.word1 = rp[0];
  415.         x.q.word2 = rp[1];
  416. + #ifndef GFLOAT
  417.         if (x.f.sign == 1 && x.f.exp == 0)
  418.   #else GFLOAT
  419.         if (x.g.sign == 1 && x.g.exp == 0)
  420. ***************
  421. *** 332,337
  422.         x.q.word1 = rp[0];
  423.         x.q.word2 = rp[1];
  424.         if (x.f.sign == 1 && x.f.exp == 0)
  425.       {
  426.         if (badvalue <= 1)
  427.           {
  428.  
  429. --- 435,443 -----
  430.         x.q.word2 = rp[1];
  431.   #ifndef GFLOAT
  432.         if (x.f.sign == 1 && x.f.exp == 0)
  433. + #else GFLOAT
  434. +       if (x.g.sign == 1 && x.g.exp == 0)
  435. + #endif GFLOAT
  436.       {
  437.         if (badvalue <= 1)
  438.           {
  439. ***************
  440. *** 403,408
  441.     register double *minp;
  442.     register double *maxp;
  443.     realvalue x;
  444.     float y;
  445.   
  446.     switch (cp->vtype)
  447.  
  448. --- 509,515 -----
  449.     register double *minp;
  450.     register double *maxp;
  451.     realvalue x;
  452. + #ifndef GFLOAT
  453.     float y;
  454.   #endif GFLOAT
  455.   
  456. ***************
  457. *** 404,409
  458.     register double *maxp;
  459.     realvalue x;
  460.     float y;
  461.   
  462.     switch (cp->vtype)
  463.       {
  464.  
  465. --- 511,517 -----
  466.     realvalue x;
  467.   #ifndef GFLOAT
  468.     float y;
  469. + #endif GFLOAT
  470.   
  471.     switch (cp->vtype)
  472.       {
  473. ***************
  474. *** 418,423
  475.       case TYSHORT:
  476.       case TYLONG:
  477.         p = (expptr) mkconst(TYREAL);
  478.         p->constblock.const.cd[0] = cp->const.ci;
  479.         break;
  480.   
  481.  
  482. --- 526,532 -----
  483.       case TYSHORT:
  484.       case TYLONG:
  485.         p = (expptr) mkconst(TYREAL);
  486. + #ifndef GFLOAT
  487.         p->constblock.const.cd[0] = cp->const.ci;
  488.   #else GFLOAT
  489.         p->constblock.const.cr[0] = cp->const.ci;
  490. ***************
  491. *** 419,424
  492.       case TYLONG:
  493.         p = (expptr) mkconst(TYREAL);
  494.         p->constblock.const.cd[0] = cp->const.ci;
  495.         break;
  496.   
  497.       case TYREAL:
  498.  
  499. --- 528,536 -----
  500.         p = (expptr) mkconst(TYREAL);
  501.   #ifndef GFLOAT
  502.         p->constblock.const.cd[0] = cp->const.ci;
  503. + #else GFLOAT
  504. +       p->constblock.const.cr[0] = cp->const.ci;
  505. + #endif GFLOAT
  506.         break;
  507.   
  508.       case TYREAL:
  509. ***************
  510. *** 422,427
  511.         break;
  512.   
  513.       case TYREAL:
  514.       case TYDREAL:
  515.       case TYCOMPLEX:
  516.       case TYDCOMPLEX:
  517.  
  518. --- 534,540 -----
  519.         break;
  520.   
  521.       case TYREAL:
  522. + #ifndef GFLOAT
  523.       case TYDREAL:
  524.   #endif GFLOAT
  525.       case TYCOMPLEX:
  526. ***************
  527. *** 423,428
  528.   
  529.       case TYREAL:
  530.       case TYDREAL:
  531.       case TYCOMPLEX:
  532.       case TYDCOMPLEX:
  533.         minp = (double *) dminreal;
  534.  
  535. --- 536,542 -----
  536.       case TYREAL:
  537.   #ifndef GFLOAT
  538.       case TYDREAL:
  539. + #endif GFLOAT
  540.       case TYCOMPLEX:
  541.   #ifdef GFLOAT
  542.         p = (expptr) mkconst(TYREAL);
  543. ***************
  544. *** 424,429
  545.       case TYREAL:
  546.       case TYDREAL:
  547.       case TYCOMPLEX:
  548.       case TYDCOMPLEX:
  549.         minp = (double *) dminreal;
  550.         maxp = (double *) dmaxreal;
  551.  
  552. --- 538,550 -----
  553.       case TYDREAL:
  554.   #endif GFLOAT
  555.       case TYCOMPLEX:
  556. + #ifdef GFLOAT
  557. +       p = (expptr) mkconst(TYREAL);
  558. +       p->constblock.const.cr[0] = cp->const.cr[0];
  559. +       break;
  560. + 
  561. +     case TYDREAL:
  562. + #endif GFLOAT
  563.       case TYDCOMPLEX:
  564.         minp = (double *) dminreal;
  565.         maxp = (double *) dmaxreal;
  566. ***************
  567. *** 430,435
  568.         rp = (long *) &(cp->const.cd[0]);
  569.         x.q.word1 = rp[0];
  570.         x.q.word2 = rp[1];
  571.         if (x.f.sign == 1 && x.f.exp == 0)
  572.       {
  573.         p = (expptr) mkconst(TYREAL);
  574.  
  575. --- 551,557 -----
  576.         rp = (long *) &(cp->const.cd[0]);
  577.         x.q.word1 = rp[0];
  578.         x.q.word2 = rp[1];
  579. + #ifndef GFLOAT
  580.         if (x.f.sign == 1 && x.f.exp == 0)
  581.   #else GFLOAT
  582.         if (x.g.sign == 1 && x.g.exp == 0)
  583. ***************
  584. *** 431,436
  585.         x.q.word1 = rp[0];
  586.         x.q.word2 = rp[1];
  587.         if (x.f.sign == 1 && x.f.exp == 0)
  588.       {
  589.         p = (expptr) mkconst(TYREAL);
  590.         rp = (long *) &(p->constblock.const.cd[0]);
  591.  
  592. --- 553,561 -----
  593.         x.q.word2 = rp[1];
  594.   #ifndef GFLOAT
  595.         if (x.f.sign == 1 && x.f.exp == 0)
  596. + #else GFLOAT
  597. +       if (x.g.sign == 1 && x.g.exp == 0)
  598. + #endif GFLOAT
  599.       {
  600.         p = (expptr) mkconst(TYREAL);
  601.   #ifndef GFLOAT
  602. ***************
  603. *** 433,438
  604.         if (x.f.sign == 1 && x.f.exp == 0)
  605.       {
  606.         p = (expptr) mkconst(TYREAL);
  607.         rp = (long *) &(p->constblock.const.cd[0]);
  608.         rp[0] = x.q.word1;
  609.       }
  610.  
  611. --- 558,564 -----
  612.   #endif GFLOAT
  613.       {
  614.         p = (expptr) mkconst(TYREAL);
  615. + #ifndef GFLOAT
  616.         rp = (long *) &(p->constblock.const.cd[0]);
  617.         rp[0] = x.q.word1;
  618.   #else GFLOAT
  619. ***************
  620. *** 435,440
  621.         p = (expptr) mkconst(TYREAL);
  622.         rp = (long *) &(p->constblock.const.cd[0]);
  623.         rp[0] = x.q.word1;
  624.       }
  625.         else if (x.d >= *minp && x.d <= *maxp)
  626.       {
  627.  
  628. --- 561,570 -----
  629.   #ifndef GFLOAT
  630.         rp = (long *) &(p->constblock.const.cd[0]);
  631.         rp[0] = x.q.word1;
  632. + #else GFLOAT
  633. + /* Gfloat: Assume that IEEE standard hardware handles exceptions */
  634. +       p->constblock.const.cr[0] = x.d;
  635. + #endif GFLOAT
  636.       }
  637.         else if (x.d >= *minp && x.d <= *maxp)
  638.       {
  639. ***************
  640. *** 439,444
  641.         else if (x.d >= *minp && x.d <= *maxp)
  642.       {
  643.         p = (expptr) mkconst(TYREAL);
  644.         y = x.d;
  645.         p->constblock.const.cd[0] = y;
  646.       }
  647.  
  648. --- 569,575 -----
  649.         else if (x.d >= *minp && x.d <= *maxp)
  650.       {
  651.         p = (expptr) mkconst(TYREAL);
  652. + #ifndef GFLOAT
  653.         y = x.d;
  654.         p->constblock.const.cd[0] = y;
  655.   #else GFLOAT
  656. ***************
  657. *** 441,446
  658.         p = (expptr) mkconst(TYREAL);
  659.         y = x.d;
  660.         p->constblock.const.cd[0] = y;
  661.       }
  662.         else
  663.       {
  664.  
  665. --- 572,580 -----
  666.   #ifndef GFLOAT
  667.         y = x.d;
  668.         p->constblock.const.cd[0] = y;
  669. + #else GFLOAT
  670. +       p->constblock.const.cr[0] = x.d;
  671. + #endif GFLOAT
  672.       }
  673.         else
  674.       {
  675. ***************
  676. *** 517,522
  677.         p->constblock.const.cd[0] = cp->const.ci;
  678.         break;
  679.   
  680.       case TYREAL:
  681.       case TYDREAL:
  682.       case TYCOMPLEX:
  683.  
  684. --- 651,657 -----
  685.         p->constblock.const.cd[0] = cp->const.ci;
  686.         break;
  687.   
  688. + #ifndef GFLOAT
  689.       case TYREAL:
  690.       case TYCOMPLEX:
  691.   #endif GFLOAT
  692. ***************
  693. *** 518,524
  694.         break;
  695.   
  696.       case TYREAL:
  697. -     case TYDREAL:
  698.       case TYCOMPLEX:
  699.       case TYDCOMPLEX:
  700.         p = (expptr) mkconst(TYDREAL);
  701.  
  702. --- 653,658 -----
  703.   
  704.   #ifndef GFLOAT
  705.       case TYREAL:
  706.       case TYCOMPLEX:
  707.   #endif GFLOAT
  708.       case TYDREAL:
  709. ***************
  710. *** 520,525
  711.       case TYREAL:
  712.       case TYDREAL:
  713.       case TYCOMPLEX:
  714.       case TYDCOMPLEX:
  715.         p = (expptr) mkconst(TYDREAL);
  716.         longp = (long *) &(cp->const.cd[0]);
  717.  
  718. --- 654,661 -----
  719.   #ifndef GFLOAT
  720.       case TYREAL:
  721.       case TYCOMPLEX:
  722. + #endif GFLOAT
  723. +     case TYDREAL:
  724.       case TYDCOMPLEX:
  725.         p = (expptr) mkconst(TYDREAL);
  726.   #ifndef GFLOAT
  727. ***************
  728. *** 522,527
  729.       case TYCOMPLEX:
  730.       case TYDCOMPLEX:
  731.         p = (expptr) mkconst(TYDREAL);
  732.         longp = (long *) &(cp->const.cd[0]);
  733.         rp = (long *) &(p->constblock.const.cd[0]);
  734.         rp[0] = longp[0];
  735.  
  736. --- 658,664 -----
  737.       case TYDREAL:
  738.       case TYDCOMPLEX:
  739.         p = (expptr) mkconst(TYDREAL);
  740. + #ifndef GFLOAT
  741.         longp = (long *) &(cp->const.cd[0]);
  742.         rp = (long *) &(p->constblock.const.cd[0]);
  743.         rp[0] = longp[0];
  744. ***************
  745. *** 526,531
  746.         rp = (long *) &(p->constblock.const.cd[0]);
  747.         rp[0] = longp[0];
  748.         rp[1] = longp[1];
  749.         break;
  750.   
  751.       case TYLOGICAL:
  752.  
  753. --- 663,671 -----
  754.         rp = (long *) &(p->constblock.const.cd[0]);
  755.         rp[0] = longp[0];
  756.         rp[1] = longp[1];
  757. + #else GFLOAT
  758. +       p->constblock.const.cd[0] = cp->const.cd[0];
  759. + #endif GFLOAT
  760.         break;
  761.   
  762.   #ifdef GFLOAT
  763. ***************
  764. *** 528,533
  765.         rp[1] = longp[1];
  766.         break;
  767.   
  768.       case TYLOGICAL:
  769.         if (badvalue <= 1)
  770.       {
  771.  
  772. --- 668,681 -----
  773.   #endif GFLOAT
  774.         break;
  775.   
  776. + #ifdef GFLOAT
  777. +     case TYREAL:
  778. +     case TYCOMPLEX:
  779. +       p = (expptr) mkconst(TYDREAL);
  780. +       p->constblock.const.cd[0] = cp->const.cr[0];
  781. +       break;
  782. + 
  783. + #endif GFLOAT
  784.       case TYLOGICAL:
  785.         if (badvalue <= 1)
  786.       {
  787. ***************
  788. *** 576,581
  789.     register long *rp;
  790.     register double *minp;
  791.     register double *maxp;
  792.     realvalue re, im;
  793.     int overflow;
  794.     float x;
  795.  
  796. --- 724,733 -----
  797.     register long *rp;
  798.     register double *minp;
  799.     register double *maxp;
  800. + #ifdef GFLOAT
  801. +   register float *minpf;
  802. +   register float *maxpf;
  803. + #endif GFLOAT
  804.     realvalue re, im;
  805.     int overflow;
  806.     float x;
  807. ***************
  808. *** 598,603
  809.         break;
  810.   
  811.       case TYREAL:
  812.       case TYDREAL:
  813.       case TYCOMPLEX:
  814.       case TYDCOMPLEX:
  815.  
  816. --- 750,756 -----
  817.         break;
  818.   
  819.       case TYREAL:
  820. + #ifndef GFLOAT
  821.       case TYDREAL:
  822.   #endif GFLOAT
  823.       case TYCOMPLEX:
  824. ***************
  825. *** 599,604
  826.   
  827.       case TYREAL:
  828.       case TYDREAL:
  829.       case TYCOMPLEX:
  830.       case TYDCOMPLEX:
  831.         overflow = 0;
  832.  
  833. --- 752,758 -----
  834.       case TYREAL:
  835.   #ifndef GFLOAT
  836.       case TYDREAL:
  837. + #endif GFLOAT
  838.       case TYCOMPLEX:
  839.   #ifdef GFLOAT
  840.         overflow = 0;
  841. ***************
  842. *** 600,605
  843.       case TYREAL:
  844.       case TYDREAL:
  845.       case TYCOMPLEX:
  846.       case TYDCOMPLEX:
  847.         overflow = 0;
  848.         minp = (double *) dminreal;
  849.  
  850. --- 754,768 -----
  851.       case TYDREAL:
  852.   #endif GFLOAT
  853.       case TYCOMPLEX:
  854. + #ifdef GFLOAT
  855. +       overflow = 0;
  856. +       p = (expptr) mkconst(TYCOMPLEX);
  857. +       p->constblock.const.cr[0] = cp->const.cr[0];
  858. +       p->constblock.const.cr[1] = cp->const.cr[1];
  859. +       break;
  860. + 
  861. +     case TYDREAL:
  862. + #endif GFLOAT
  863.       case TYDCOMPLEX:
  864.         overflow = 0;
  865.         minp = (double *) dminreal;
  866. ***************
  867. *** 609,614
  868.         re.q.word2 = rp[1];
  869.         im.q.word1 = rp[2];
  870.         im.q.word2 = rp[3];
  871.         if (((re.f.sign == 0 || re.f.exp != 0) &&
  872.          (re.d < *minp || re.d > *maxp))       ||
  873.         ((im.f.sign == 0 || re.f.exp != 0) &&
  874.  
  875. --- 772,778 -----
  876.         re.q.word2 = rp[1];
  877.         im.q.word1 = rp[2];
  878.         im.q.word2 = rp[3];
  879. + #ifndef GFLOAT
  880.         if (((re.f.sign == 0 || re.f.exp != 0) &&
  881.   #else GFLOAT
  882.         if (((re.g.sign == 0 || re.g.exp != 0) &&
  883. ***************
  884. *** 610,615
  885.         im.q.word1 = rp[2];
  886.         im.q.word2 = rp[3];
  887.         if (((re.f.sign == 0 || re.f.exp != 0) &&
  888.          (re.d < *minp || re.d > *maxp))       ||
  889.         ((im.f.sign == 0 || re.f.exp != 0) &&
  890.          (im.d < *minp || re.d > *maxp)))
  891.  
  892. --- 774,782 -----
  893.         im.q.word2 = rp[3];
  894.   #ifndef GFLOAT
  895.         if (((re.f.sign == 0 || re.f.exp != 0) &&
  896. + #else GFLOAT
  897. +       if (((re.g.sign == 0 || re.g.exp != 0) &&
  898. + #endif GFLOAT
  899.          (re.d < *minp || re.d > *maxp))       ||
  900.   #ifndef GFLOAT
  901.         ((im.f.sign == 0 || re.f.exp != 0) &&
  902. ***************
  903. *** 611,616
  904.         im.q.word2 = rp[3];
  905.         if (((re.f.sign == 0 || re.f.exp != 0) &&
  906.          (re.d < *minp || re.d > *maxp))       ||
  907.         ((im.f.sign == 0 || re.f.exp != 0) &&
  908.          (im.d < *minp || re.d > *maxp)))
  909.       {
  910.  
  911. --- 778,784 -----
  912.         if (((re.g.sign == 0 || re.g.exp != 0) &&
  913.   #endif GFLOAT
  914.          (re.d < *minp || re.d > *maxp))       ||
  915. + #ifndef GFLOAT
  916.         ((im.f.sign == 0 || re.f.exp != 0) &&
  917.   #else GFLOAT
  918.         ((im.g.sign == 0 || re.g.exp != 0) &&
  919. ***************
  920. *** 612,617
  921.         if (((re.f.sign == 0 || re.f.exp != 0) &&
  922.          (re.d < *minp || re.d > *maxp))       ||
  923.         ((im.f.sign == 0 || re.f.exp != 0) &&
  924.          (im.d < *minp || re.d > *maxp)))
  925.       {
  926.         if (badvalue <= 1)
  927.  
  928. --- 780,788 -----
  929.          (re.d < *minp || re.d > *maxp))       ||
  930.   #ifndef GFLOAT
  931.         ((im.f.sign == 0 || re.f.exp != 0) &&
  932. + #else GFLOAT
  933. +       ((im.g.sign == 0 || re.g.exp != 0) &&
  934. + #endif GFLOAT
  935.          (im.d < *minp || re.d > *maxp)))
  936.       {
  937.         if (badvalue <= 1)
  938. ***************
  939. *** 624,629
  940.         else
  941.       {
  942.         p = (expptr) mkconst(TYCOMPLEX);
  943.         if (re.f.sign == 1 && re.f.exp == 0)
  944.           re.q.word2 = 0;
  945.         else
  946.  
  947. --- 795,801 -----
  948.         else
  949.       {
  950.         p = (expptr) mkconst(TYCOMPLEX);
  951. + #ifndef GFLOAT
  952.         if (re.f.sign == 1 && re.f.exp == 0)
  953.           re.q.word2 = 0;
  954.         else
  955. ***************
  956. *** 643,648
  957.         rp[1] = re.q.word2;
  958.         rp[2] = im.q.word1;
  959.         rp[3] = im.q.word2;
  960.       }
  961.         break;
  962.   
  963.  
  964. --- 815,824 -----
  965.         rp[1] = re.q.word2;
  966.         rp[2] = im.q.word1;
  967.         rp[3] = im.q.word2;
  968. + #else GFLOAT
  969. +           p->constblock.const.cr[0] = cp->const.cd[0];
  970. +           p->constblock.const.cr[0] = cp->const.cd[1];
  971. + #endif GFLOAT
  972.       }
  973.         break;
  974.   
  975. ***************
  976. *** 711,716
  977.         break;
  978.   
  979.       case TYREAL:
  980.       case TYDREAL:
  981.       case TYCOMPLEX:
  982.       case TYDCOMPLEX:
  983.  
  984. --- 887,893 -----
  985.         break;
  986.   
  987.       case TYREAL:
  988. + #ifndef GFLOAT
  989.       case TYDREAL:
  990.   #endif GFLOAT
  991.       case TYCOMPLEX:
  992. ***************
  993. *** 712,717
  994.   
  995.       case TYREAL:
  996.       case TYDREAL:
  997.       case TYCOMPLEX:
  998.       case TYDCOMPLEX:
  999.         p = (expptr) mkconst(TYDCOMPLEX);
  1000.  
  1001. --- 889,895 -----
  1002.       case TYREAL:
  1003.   #ifndef GFLOAT
  1004.       case TYDREAL:
  1005. + #endif GFLOAT
  1006.       case TYCOMPLEX:
  1007.   #ifdef GFLOAT
  1008.         p = (expptr) mkconst(TYDCOMPLEX);
  1009. ***************
  1010. *** 713,718
  1011.       case TYREAL:
  1012.       case TYDREAL:
  1013.       case TYCOMPLEX:
  1014.       case TYDCOMPLEX:
  1015.         p = (expptr) mkconst(TYDCOMPLEX);
  1016.         longp = (long *) &(cp->const.cd[0]);
  1017.  
  1018. --- 891,904 -----
  1019.       case TYDREAL:
  1020.   #endif GFLOAT
  1021.       case TYCOMPLEX:
  1022. + #ifdef GFLOAT
  1023. +       p = (expptr) mkconst(TYDCOMPLEX);
  1024. +       p->constblock.const.cd[0] = cp->const.cr[0];
  1025. +       p->constblock.const.cd[1] = cp->const.cr[1];
  1026. +       break;
  1027. + 
  1028. +     case TYDREAL:
  1029. + #endif GFLOAT
  1030.       case TYDCOMPLEX:
  1031.         p = (expptr) mkconst(TYDCOMPLEX);
  1032.   #ifndef GFLOAT
  1033. ***************
  1034. *** 715,720
  1035.       case TYCOMPLEX:
  1036.       case TYDCOMPLEX:
  1037.         p = (expptr) mkconst(TYDCOMPLEX);
  1038.         longp = (long *) &(cp->const.cd[0]);
  1039.         rp = (long *) &(p->constblock.const.cd[0]);
  1040.         rp[0] = longp[0];
  1041.  
  1042. --- 901,907 -----
  1043.   #endif GFLOAT
  1044.       case TYDCOMPLEX:
  1045.         p = (expptr) mkconst(TYDCOMPLEX);
  1046. + #ifndef GFLOAT
  1047.         longp = (long *) &(cp->const.cd[0]);
  1048.         rp = (long *) &(p->constblock.const.cd[0]);
  1049.         rp[0] = longp[0];
  1050. ***************
  1051. *** 721,726
  1052.         rp[1] = longp[1];
  1053.         rp[2] = longp[2];
  1054.         rp[3] = longp[3];
  1055.         break;
  1056.   
  1057.       case TYLOGICAL:
  1058.  
  1059. --- 908,917 -----
  1060.         rp[1] = longp[1];
  1061.         rp[2] = longp[2];
  1062.         rp[3] = longp[3];
  1063. + #else GFLOAT
  1064. +       p->constblock.const.cd[0] = cp->const.cd[0];
  1065. +       p->constblock.const.cd[1] = cp->const.cd[1];
  1066. + #endif GFLOAT
  1067.         break;
  1068.   
  1069.       case TYLOGICAL:
  1070.