home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update27.zoo / libg++ / src / diffs next >
Encoding:
Text File  |  1992-12-28  |  27.5 KB  |  1,120 lines
  1. *** 1.8    1992/11/08 00:19:13
  2. --- Changelo    1992/12/28 07:41:07
  3. ***************
  4. *** 276,278 ****
  5. --- 276,293 ----
  6.       dont pass a zero size request to malloc.
  7.   
  8.   ---------------------------- Patchlevel 15 -----------------------------------
  9. + 
  10. + xobstack.cc:: ++jrb
  11. +     must use delete [] form, because was alloced with new [] form.
  12. + 
  13. + filebuf.cc::  ++jrb
  14. +     fix from net
  15. + 
  16. + iostream.cc:: ++jrb
  17. +     line 696 cast this as appro. gcc 2.3.2 barfs otherwise.
  18. + 
  19. + *.cc, *.h:: ++jrb
  20. +     half way thru syncing up with changes in libg++ 2.3 distribution.
  21. +     i have done allthe non-io classes. still working on those.
  22. + 
  23. + ---------------------------- Patchlevel 16 -----------------------------------
  24. *** 1.10    1992/11/08 00:19:13
  25. --- PatchLev.h    1992/12/28 07:41:08
  26. ***************
  27. *** 1,5 ****
  28.   
  29. ! #define    PatchLevel "15"
  30.   
  31.   /*
  32.    *    the Patch Level above is to identify the version
  33. --- 1,5 ----
  34.   
  35. ! #define    PatchLevel "16"
  36.   
  37.   /*
  38.    *    the Patch Level above is to identify the version
  39. *** 1.7    1992/07/17 18:24:43
  40. --- filebuf.cc    1992/12/28 07:41:12
  41. ***************
  42. *** 305,310 ****
  43. --- 305,312 ----
  44.       if (do_flush()) return EOF;
  45.   #endif
  46.   
  47. +     switch_to_get_mode();
  48. + 
  49.       _G_ssize_t count = sys_read(base(), ebuf() - base());
  50.       if (count <= 0) {
  51.       if (count == 0)
  52. *** 1.7    1992/07/17 18:24:43
  53. --- iostream.cc    1992/12/28 07:41:15
  54. ***************
  55. *** 693,699 ****
  56.       _strbuf->vscan(format, ap, &_state);
  57.       va_end(ap);
  58.       }
  59. !     return *this;
  60.   }
  61.   
  62.   // NOTE: extension for compatibility with old libg++.
  63. --- 693,699 ----
  64.       _strbuf->vscan(format, ap, &_state);
  65.       va_end(ap);
  66.       }
  67. !     return *(istream *)this;
  68.   }
  69.   
  70.   // NOTE: extension for compatibility with old libg++.
  71. *** 1.8    1992/11/08 00:19:13
  72. --- mincl    1992/12/28 07:41:17
  73. ***************
  74. *** 13,19 ****
  75.   xgeom.cc xgetopt.cc xhypgeom.cc xinteger.cc  xlognorm.cc xmlcg.cc \
  76.   xnegexp.cc xnormal.cc xobstack.cc xpoisson.cc xrandom.cc xrationa.cc \
  77.   xregex.cc xrndint.cc xrng.cc xsmplhis.cc xsmplsta.cc \
  78. ! xstring.cc xuniform.cc xweibull.cc xeh.cc
  79.   
  80.   IOSRC = editbuf.cc filebuf.cc fstream.cc igetline.cc indstrea.cc iostream.cc \
  81.   makebuf.cc parsestr.cc sbufvfor.cc sbufvsca.cc sgetline.cc stdstrbu.cc \
  82. --- 13,19 ----
  83.   xgeom.cc xgetopt.cc xhypgeom.cc xinteger.cc  xlognorm.cc xmlcg.cc \
  84.   xnegexp.cc xnormal.cc xobstack.cc xpoisson.cc xrandom.cc xrationa.cc \
  85.   xregex.cc xrndint.cc xrng.cc xsmplhis.cc xsmplsta.cc \
  86. ! xstring.cc xuniform.cc xweibull.cc xeh.cc xdllist.cc xsllist.cc
  87.   
  88.   IOSRC = editbuf.cc filebuf.cc fstream.cc igetline.cc indstrea.cc iostream.cc \
  89.   makebuf.cc parsestr.cc sbufvfor.cc sbufvsca.cc sgetline.cc stdstrbu.cc \
  90. ***************
  91. *** 63,68 ****
  92. --- 63,73 ----
  93.   
  94.   _bin_del.o: gnuaux.c
  95.       $(CC) -c $(CFLAGS) -DL_builtin_del $^ -o $@
  96. + 
  97. + # dont ask me why, but with gcc 2.3.1 and 2.3.2 -fomit-frame-pointer
  98. + # breaks xbitset
  99. + xbitset.o: xbitset.cc
  100. +     $(GXX) $(GXXFFLAGS) -c xbitset.cc
  101.   
  102.   # DO NOT DELETE THIS LINE -- g++dep uses it.
  103.   # DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
  104. *** 1.7    1992/07/20 22:21:08
  105. --- regex.cc    1992/12/28 07:41:18
  106. ***************
  107. *** 52,68 ****
  108.   
  109.   #else  /* not emacs */
  110.   
  111. - #include <string.h>
  112.   #include <g_config.h>
  113. ! 
  114. ! #if defined (_G_SYSV) || defined (STDC_HEADERS)
  115. ! #if !(defined(BSTRING) || defined(atarist))
  116. ! #define bcopy(s,d,n)    memcpy((d),(s),(n))
  117. ! #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  118. ! #define bzero(s,n)    memset((s),0,(n))
  119. ! #endif
  120. ! #endif
  121. ! 
  122.   #include <stdlib.h>
  123.   
  124.   /* Define the syntax stuff, so we can do the \<, \>, etc.  */
  125. --- 52,59 ----
  126.   
  127.   #else  /* not emacs */
  128.   
  129.   #include <g_config.h>
  130. ! #include <string.h>
  131.   #include <stdlib.h>
  132.   
  133.   /* Define the syntax stuff, so we can do the \<, \>, etc.  */
  134. ***************
  135. *** 94,100 ****
  136.      if (done)
  137.        return;
  138.   
  139. !    bzero (re_syntax_table, sizeof re_syntax_table);
  140.   
  141.      for (c = 'a'; c <= 'z'; c++)
  142.        re_syntax_table[c] = Sword;
  143. --- 85,91 ----
  144.      if (done)
  145.        return;
  146.   
  147. !    memset (re_syntax_table, 0, sizeof re_syntax_table);
  148.   
  149.      for (c = 'a'; c <= 'z'; c++)
  150.        re_syntax_table[c] = Sword;
  151. ***************
  152. *** 657,663 ****
  153.   
  154.         BUFPUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
  155.         /* Clear the whole map */
  156. !       bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH);
  157.             
  158.         if ((obscure_syntax & RE_HAT_NOT_NEWLINE) && b[-2] == charset_not)
  159.               SET_LIST_BIT ('\n');
  160. --- 648,654 ----
  161.   
  162.         BUFPUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
  163.         /* Clear the whole map */
  164. !       memset (b, 0, (1 << BYTEWIDTH) / BYTEWIDTH);
  165.             
  166.         if ((obscure_syntax & RE_HAT_NOT_NEWLINE) && b[-2] == charset_not)
  167.               SET_LIST_BIT ('\n');
  168. ***************
  169. *** 1318,1324 ****
  170.   
  171.     unsigned is_a_succeed_n;
  172.   
  173. !   bzero (fastmap, (1 << BYTEWIDTH));
  174.     bufp->fastmap_accurate = 1;
  175.     bufp->can_be_null = 0;
  176.         
  177. --- 1309,1315 ----
  178.   
  179.     unsigned is_a_succeed_n;
  180.   
  181. !   memset (fastmap, 0, (1 << BYTEWIDTH));
  182.     bufp->fastmap_accurate = 1;
  183.     bufp->can_be_null = 0;
  184.         
  185. ***************
  186. *** 1735,1741 ****
  187.           stackx = (unsigned char **) alloca (2 * len            \
  188.                                               * sizeof (unsigned char *));\
  189.       /* Only copy what is in use.  */                \
  190. !         bcopy (stackb, stackx, len * sizeof (char *));            \
  191.       stackp = stackx + (stackp - stackb);                \
  192.       stackb = stackx;                        \
  193.       stacke = stackb + 2 * len;                    \
  194. --- 1726,1732 ----
  195.           stackx = (unsigned char **) alloca (2 * len            \
  196.                                               * sizeof (unsigned char *));\
  197.       /* Only copy what is in use.  */                \
  198. !         memcpy (stackx, stackb, len * sizeof (char *));            \
  199.       stackp = stackx + (stackp - stackb);                \
  200.       stackb = stackx;                        \
  201.       stacke = stackb + 2 * len;                    \
  202. ***************
  203. *** 2162,2168 ****
  204.                      past them.  */
  205.           if (translate 
  206.                       ? bcmp_translate ((char*)d, (char*)d2, mcnt, translate) 
  207. !                     : bcmp (d, d2, mcnt))
  208.             goto fail;
  209.           d += mcnt, d2 += mcnt;
  210.             }
  211. --- 2153,2159 ----
  212.                      past them.  */
  213.           if (translate 
  214.                       ? bcmp_translate ((char*)d, (char*)d2, mcnt, translate) 
  215. !                     : memcmp (d, d2, mcnt))
  216.             goto fail;
  217.           d += mcnt, d2 += mcnt;
  218.             }
  219. *** 1.6    1992/07/17 18:24:43
  220. --- xbitset.cc    1992/12/28 07:41:22
  221. ***************
  222. *** 78,92 ****
  223.       (*lib_error_handler)("BitSet", "Requested length out of range");
  224.       
  225.     BitSetRep* rep = (BitSetRep *) new char[allocsiz];
  226. !   bzero(rep, allocsiz);
  227.     rep->sz = (allocsiz - sizeof(BitSetRep) + sizeof(short)) / sizeof(short);
  228.     return rep;
  229.   }
  230.   
  231. ! BitSetRep* BitSetalloc(BitSetRep* old, const unsigned short* src, int srclen, 
  232.                   int newvirt, int newlen)
  233.   {
  234. !   if (old == &_nilBitSetRep) old = 0; 
  235.     BitSetRep* rep;
  236.     if (old == 0 || newlen >= old->sz)
  237.       rep = BSnew(newlen);
  238. --- 78,92 ----
  239.       (*lib_error_handler)("BitSet", "Requested length out of range");
  240.       
  241.     BitSetRep* rep = (BitSetRep *) new char[allocsiz];
  242. !   memset(rep, 0, allocsiz);
  243.     rep->sz = (allocsiz - sizeof(BitSetRep) + sizeof(short)) / sizeof(short);
  244.     return rep;
  245.   }
  246.   
  247. ! BitSetRep* BitSetalloc(BitSetRep* old, const unsigned short* src, int srclen,
  248.                   int newvirt, int newlen)
  249.   {
  250. !   if (old == &_nilBitSetRep) old = 0;
  251.     BitSetRep* rep;
  252.     if (old == 0 || newlen >= old->sz)
  253.       rep = BSnew(newlen);
  254. ***************
  255. *** 97,104 ****
  256.     rep->virt = newvirt;
  257.   
  258.     if (srclen != 0 && src != rep->s)
  259. !     bcopy(src, rep->s, srclen * sizeof(short));
  260. ! 
  261.     if (old != rep && old != 0) delete old;
  262.     return rep;
  263.   }
  264. --- 97,106 ----
  265.     rep->virt = newvirt;
  266.   
  267.     if (srclen != 0 && src != rep->s)
  268. !     memcpy(rep->s, src, srclen * sizeof(short));
  269. !   // BUG fix: extend virtual bit! 20 Oct 1992 Kevin Karplus
  270. !   if (rep->virt)
  271. !       memset(&rep->s[srclen], ONES, (newlen - srclen) * sizeof(short));
  272.     if (old != rep && old != 0) delete old;
  273.     return rep;
  274.   }
  275. ***************
  276. *** 114,121 ****
  277.     else if (newlen >= old->sz)
  278.     {
  279.       rep = BSnew(newlen);
  280. !     bcopy(old->s, rep->s, old->len * sizeof(short));
  281.       rep->virt = old->virt;
  282.       delete old;
  283.     }
  284.     else
  285. --- 116,126 ----
  286.     else if (newlen >= old->sz)
  287.     {
  288.       rep = BSnew(newlen);
  289. !     memcpy(rep->s, old->s, old->len * sizeof(short));
  290.       rep->virt = old->virt;
  291. +     // BUG fix: extend virtual bit!  20 Oct 1992 Kevin Karplus
  292. +     if (rep->virt)
  293. +     memset(&rep->s[old->len], ONES, (newlen - old->len) * sizeof(short));
  294.       delete old;
  295.     }
  296.     else
  297. ***************
  298. *** 154,160 ****
  299.       else
  300.         rep = old;
  301.   
  302. !     bcopy(src->s, rep->s, newlen * sizeof(short));
  303.       rep->len = newlen;
  304.       rep->virt = src->virt;
  305.     }
  306. --- 159,165 ----
  307.       else
  308.         rep = old;
  309.   
  310. !     memcpy(rep->s, src->s, newlen * sizeof(short));
  311.       rep->len = newlen;
  312.       rep->virt = src->virt;
  313.     }
  314. ***************
  315. *** 178,188 ****
  316.   
  317.   int operator == (const BitSet& x, const BitSet& y)
  318.   {
  319. !   return x.rep->len == y.rep->len && x.rep->virt == y.rep->virt &&
  320. !     bcmp((void*)x.rep->s, (void*)y.rep->s, 
  321. !          x.rep->len * sizeof(short)) == 0;
  322. ! }
  323.   
  324.   
  325.   int operator <= (const BitSet& x, const BitSet& y)
  326.   {
  327. --- 183,214 ----
  328.   
  329.   int operator == (const BitSet& x, const BitSet& y)
  330.   {
  331. !   if (x.rep->virt != y.rep->virt)
  332. !     return 0;
  333. !   int xl = x.rep->len;
  334. !   int yl = y.rep->len;
  335.   
  336. +   unsigned short* xs = x.rep->s;
  337. +   unsigned short* ys = y.rep->s;
  338. +   if (xl<=yl)
  339. +     {
  340. +       if (memcmp((void*)xs, (void*)ys, xl * sizeof(short)))
  341. +       return 0;
  342. +       for (register int i=xl; i<yl; i++)
  343. +         if (ys[i])
  344. +       return 0;
  345. +       return 1;
  346. +     }
  347. +   else
  348. +     {
  349. +       if (memcmp((void*)xs, (void*)ys, yl * sizeof(short)))
  350. +       return 0;
  351. +       for (register int i=yl; i<xl; i++)
  352. +         if (xs[i]) 
  353. +       return 0;
  354. +       return 1;
  355. +     }
  356. + }
  357.   
  358.   int operator <= (const BitSet& x, const BitSet& y)
  359.   {
  360. ***************
  361. *** 427,433 ****
  362.   
  363.   void BitSet::clear()
  364.   {
  365. !   if (rep->len > 0) bzero(rep->s, rep->sz * sizeof(short));
  366.     rep->len = rep->virt = 0;
  367.   }
  368.   
  369. --- 453,459 ----
  370.   
  371.   void BitSet::clear()
  372.   {
  373. !   if (rep->len > 0) memset(rep->s, 0, rep->sz * sizeof(short));
  374.     rep->len = rep->virt = 0;
  375.   }
  376.   
  377. *** 1.6    1992/07/20 22:21:08
  378. --- xbitstri.cc    1992/12/28 07:41:23
  379. ***************
  380. *** 159,165 ****
  381.   static inline void bit_clear(unsigned short* ds, int nbits)
  382.   {
  383.     int n = (unsigned)(nbits) / BITSTRBITS;
  384. !   if (n > 0) bzero((void*)ds, n * sizeof(short));
  385.     ds[n] &= ONES << (nbits & (BITSTRBITS - 1));
  386.   }
  387.   
  388. --- 159,165 ----
  389.   static inline void bit_clear(unsigned short* ds, int nbits)
  390.   {
  391.     int n = (unsigned)(nbits) / BITSTRBITS;
  392. !   if (n > 0) memset((void*)ds, 0, n * sizeof(short));
  393.     ds[n] &= ONES << (nbits & (BITSTRBITS - 1));
  394.   }
  395.   
  396. ***************
  397. *** 296,302 ****
  398.       (*lib_error_handler)("BitString", "Requested length out of range");
  399.       
  400.     BitStrRep* rep = (BitStrRep *) new char[allocsiz];
  401. !   bzero(rep, allocsiz);
  402.     rep->sz = (allocsiz - sizeof(BitStrRep) + sizeof(short)) / sizeof(short);
  403.     return rep;
  404.   }
  405. --- 296,302 ----
  406.       (*lib_error_handler)("BitString", "Requested length out of range");
  407.       
  408.     BitStrRep* rep = (BitStrRep *) new char[allocsiz];
  409. !   memset(rep, 0, allocsiz);
  410.     rep->sz = (allocsiz - sizeof(BitStrRep) + sizeof(short)) / sizeof(short);
  411.     return rep;
  412.   }
  413. ***************
  414. *** 336,342 ****
  415.     else if (news > old->sz)
  416.     {
  417.       rep = BSnew(newlen);
  418. !     bcopy(old->s, rep->s, BitStr_len(old->len) * sizeof(short));
  419.       delete old;
  420.     }
  421.     else
  422. --- 336,342 ----
  423.     else if (news > old->sz)
  424.     {
  425.       rep = BSnew(newlen);
  426. !     memcpy(rep->s, old->s, BitStr_len(old->len) * sizeof(short));
  427.       delete old;
  428.     }
  429.     else
  430. ***************
  431. *** 373,379 ****
  432.       else
  433.         rep = old;
  434.       
  435. !     bcopy(src->s, rep->s, news * sizeof(short));
  436.       rep->len = newlen;
  437.     }
  438.     check_last(rep);
  439. --- 373,379 ----
  440.       else
  441.         rep = old;
  442.       
  443. !     memcpy(rep->s, src->s, news * sizeof(short));
  444.       rep->len = newlen;
  445.     }
  446.     check_last(rep);
  447. ***************
  448. *** 384,390 ****
  449.   int operator == (const BitString& x, const BitString& y)
  450.   {
  451.     return x.rep->len == y.rep->len && 
  452. !     bcmp((void*)x.rep->s, (void*)y.rep->s, 
  453.            BitStr_len(x.rep->len) * sizeof(short)) == 0;
  454.   }
  455.   
  456. --- 384,390 ----
  457.   int operator == (const BitString& x, const BitString& y)
  458.   {
  459.     return x.rep->len == y.rep->len && 
  460. !     memcmp((void*)x.rep->s, (void*)y.rep->s, 
  461.            BitStr_len(x.rep->len) * sizeof(short)) == 0;
  462.   }
  463.   
  464. *** 1.4    1992/06/03 02:12:17
  465. --- xcursesw.cc    1992/12/28 07:41:23
  466. ***************
  467. *** 29,34 ****
  468. --- 29,36 ----
  469.   // because curses.h defines a clear macro that conflicts with iostream. Sigh.
  470.   #include <xcursesw.h>
  471.   
  472. + #if _G_HAVE_CURSES
  473. + 
  474.   int CursesWindow::count = 0;
  475.   
  476.   /*
  477. ***************
  478. *** 278,280 ****
  479. --- 280,284 ----
  480.       (*lib_error_handler)("CursesWindow", "Too many windows destroyed");
  481.     }
  482.   }
  483. + 
  484. + #endif /* _G_HAVE_CURSES */
  485. *** 1.5    1992/06/08 20:42:41
  486. --- xfix.cc    1992/12/28 07:41:24
  487. ***************
  488. *** 89,95 ****
  489.     if (siz <= 0) siz = 1;
  490.     size_t allocsiz = (sizeof(_Frep) + (siz - 1) * sizeof(uint16));
  491.     _Fix z = (_Fix)(new char[allocsiz]);
  492. !   bzero(z, allocsiz);
  493.     z->len = len;
  494.     z->siz = siz;
  495.     z->ref = 1;
  496. --- 89,95 ----
  497.     if (siz <= 0) siz = 1;
  498.     size_t allocsiz = (sizeof(_Frep) + (siz - 1) * sizeof(uint16));
  499.     _Fix z = (_Fix)(new char[allocsiz]);
  500. !   memset(z, 0, allocsiz);
  501.     z->len = len;
  502.     z->siz = siz;
  503.     z->ref = 1;
  504. *** 1.2    1992/07/17 18:24:43
  505. --- xgetopt.cc    1992/12/28 07:41:25
  506. ***************
  507. *** 34,44 ****
  508.   char* GetOpt::nextchar = 0;
  509.   int GetOpt::first_nonopt = 0;
  510.   int GetOpt::last_nonopt = 0;
  511. - #if (__GNUG__ == 1) 
  512. - OrderingEnum GetOpt::ordering = GetOpt::REQUIRE_ORDER;
  513. - #else
  514. - GetOpt::OrderingEnum GetOpt::ordering = GetOpt::REQUIRE_ORDER;
  515. - #endif /* (__GNUG__ == 1)  */
  516.   
  517.   GetOpt::GetOpt (int argc, char **argv, const char *optstring)
  518.    :opterr (1), nargc (argc), nargv (argv), noptstring (optstring)
  519. --- 34,39 ----
  520. ***************
  521. *** 70,79 ****
  522.   
  523.     /* Interchange the two blocks of data in argv.  */
  524.   
  525. !   bcopy (&argv[first_nonopt], temp, nonopts_size);
  526. !   bcopy (&argv[last_nonopt], &argv[first_nonopt],
  527.            (optind - last_nonopt) * sizeof (char *));
  528. !   bcopy (temp, &argv[first_nonopt + optind - last_nonopt],
  529.            nonopts_size);
  530.   
  531.     /* Update records for the slots the non-options now occupy.  */
  532. --- 65,74 ----
  533.   
  534.     /* Interchange the two blocks of data in argv.  */
  535.   
  536. !   memcpy (temp, &argv[first_nonopt], nonopts_size);
  537. !   memcpy (&argv[first_nonopt], &argv[last_nonopt],
  538.            (optind - last_nonopt) * sizeof (char *));
  539. !   memcpy (&argv[first_nonopt + optind - last_nonopt], temp,
  540.            nonopts_size);
  541.   
  542.     /* Update records for the slots the non-options now occupy.  */
  543. ***************
  544. *** 195,201 ****
  545.   
  546.     {
  547.       char c = *nextchar++;
  548. !     char *temp = (char *) index (noptstring, c);
  549.   
  550.       /* Increment `optind' when we start to process its last character.  */
  551.       if (*nextchar == 0)
  552. --- 190,196 ----
  553.   
  554.     {
  555.       char c = *nextchar++;
  556. !     char *temp = (char *) strchr (noptstring, c);
  557.   
  558.       /* Increment `optind' when we start to process its last character.  */
  559.       if (*nextchar == 0)
  560. *** 1.7    1992/07/20 22:21:08
  561. --- xinteger.cc    1992/12/28 07:41:26
  562. ***************
  563. *** 32,37 ****
  564. --- 32,38 ----
  565.   #include <std.h>
  566.   #include <ctype.h>
  567.   #include <math.h>
  568. + #include <float.h>
  569.   #include <limits.h>
  570.   #include <xobstack.h>
  571.   #include <xallocri.h>
  572. ***************
  573. *** 38,43 ****
  574. --- 39,52 ----
  575.   #include <new.h>
  576.   #include <builtin.h>
  577.   
  578. + #ifndef HUGE_VAL
  579. + #ifdef HUGE
  580. + #define HUGE_VAL HUGE
  581. + #else
  582. + #define HUGE_VAL DBL_MAX
  583. + #endif
  584. + #endif
  585. + 
  586.   /*
  587.    Sizes of shifts for multiple-precision arithmetic.
  588.    These should not be changed unless Integer representation
  589. ***************
  590. *** 280,298 ****
  591.   
  592.   IntRep* Icopy_long(IntRep* old, long x)
  593.   {
  594.     unsigned short src[SHORT_PER_LONG];
  595. -   unsigned long u;
  596. -   int newsgn;
  597. -   if (newsgn = (x >= 0))
  598. -     u = x;
  599. -   else
  600. -     u = -x;
  601.     
  602.     unsigned short srclen = 0;
  603. !   while (u != 0)
  604.     {
  605. !     src[srclen++] = extract(u);
  606. !     u = down(u);
  607.     }
  608.   
  609.     IntRep* rep;
  610. --- 289,309 ----
  611.   
  612.   IntRep* Icopy_long(IntRep* old, long x)
  613.   {
  614. +   int newsgn = (x >= 0);
  615. +   IntRep* rep = Icopy_ulong(old, newsgn ? x : -x);
  616. +   rep->sgn = newsgn;
  617. +   return rep;
  618. + }
  619. + 
  620. + IntRep* Icopy_ulong(IntRep* old, unsigned long x)
  621. + {
  622.     unsigned short src[SHORT_PER_LONG];
  623.     
  624.     unsigned short srclen = 0;
  625. !   while (x != 0)
  626.     {
  627. !     src[srclen++] = extract(x);
  628. !     x = down(x);
  629.     }
  630.   
  631.     IntRep* rep;
  632. ***************
  633. *** 305,316 ****
  634.       rep = old;
  635.   
  636.     rep->len = srclen;
  637. !   rep->sgn = newsgn;
  638.   
  639.     scpy(src, rep->s, srclen);
  640.   
  641.     return rep;
  642. - 
  643.   }
  644.   
  645.   // special case for zero -- it's worth it!
  646. --- 316,326 ----
  647.       rep = old;
  648.   
  649.     rep->len = srclen;
  650. !   rep->sgn = I_POSITIVE;
  651.   
  652.     scpy(src, rep->s, srclen);
  653.   
  654.     return rep;
  655.   }
  656.   
  657.   // special case for zero -- it's worth it!
  658. ***************
  659. *** 408,414 ****
  660.   double Itodouble(const IntRep* rep)
  661.   { 
  662.     double d = 0.0;
  663. !   double bound = HUGE / 2.0;
  664.     for (int i = rep->len - 1; i >= 0; --i)
  665.     {
  666.       unsigned short a = I_RADIX >> 1;
  667. --- 418,424 ----
  668.   double Itodouble(const IntRep* rep)
  669.   { 
  670.     double d = 0.0;
  671. !   double bound = DBL_MAX / 2.0;
  672.     for (int i = rep->len - 1; i >= 0; --i)
  673.     {
  674.       unsigned short a = I_RADIX >> 1;
  675. ***************
  676. *** 415,421 ****
  677.       while (a != 0)
  678.       {
  679.         if (d >= bound)
  680. !         return (rep->sgn == I_NEGATIVE) ? -HUGE : HUGE;
  681.         d *= 2.0;
  682.         if (rep->s[i] & a)
  683.           d += 1.0;
  684. --- 425,431 ----
  685.       while (a != 0)
  686.       {
  687.         if (d >= bound)
  688. !         return (rep->sgn == I_NEGATIVE) ? -HUGE_VAL : HUGE_VAL;
  689.         d *= 2.0;
  690.         if (rep->s[i] & a)
  691.           d += 1.0;
  692. ***************
  693. *** 435,441 ****
  694.   int Iisdouble(const IntRep* rep)
  695.   {
  696.     double d = 0.0;
  697. !   double bound = HUGE / 2.0;
  698.     for (int i = rep->len - 1; i >= 0; --i)
  699.     {
  700.       unsigned short a = I_RADIX >> 1;
  701. --- 445,451 ----
  702.   int Iisdouble(const IntRep* rep)
  703.   {
  704.     double d = 0.0;
  705. !   double bound = DBL_MAX / 2.0;
  706.     for (int i = rep->len - 1; i >= 0; --i)
  707.     {
  708.       unsigned short a = I_RADIX >> 1;
  709. ***************
  710. *** 460,466 ****
  711.     divide(num, den, q, r);
  712.     double d1 = double(q);
  713.    
  714. !   if (d1 == HUGE || d1 == -HUGE || sign(r) == 0)
  715.       return d1;
  716.     else      // use as much precision as available for fractional part
  717.     {
  718. --- 470,476 ----
  719.     divide(num, den, q, r);
  720.     double d1 = double(q);
  721.    
  722. !   if (d1 >= DBL_MAX || d1 <= -DBL_MAX || sign(r) == 0)
  723.       return d1;
  724.     else      // use as much precision as available for fractional part
  725.     {
  726. ***************
  727. *** 562,570 ****
  728.           if (diff == 0)
  729.             diff = docmp(x->s, tmp, xl);
  730.         }
  731.       }
  732. -     if (xsgn == I_NEGATIVE)
  733. -       diff = -diff;
  734.       return diff;
  735.     }
  736.   }
  737. --- 572,580 ----
  738.           if (diff == 0)
  739.             diff = docmp(x->s, tmp, xl);
  740.         }
  741. +       if (xsgn == I_NEGATIVE)
  742. +     diff = -diff;
  743.       }
  744.       return diff;
  745.     }
  746.   }
  747. ***************
  748. *** 2332,2338 ****
  749.           break;
  750.       }
  751.       else if (!know_base & !got_one && ch == '0')
  752. !       base = 8;
  753.       else if (!know_base & !got_one && base == 8 && (ch == 'X' || ch == 'x'))
  754.         base = 16;
  755.       else if (base == 8)
  756. --- 2342,2348 ----
  757.           break;
  758.       }
  759.       else if (!know_base & !got_one && ch == '0')
  760. !       base = 8, got_one = 1;
  761.       else if (!know_base & !got_one && base == 8 && (ch == 'X' || ch == 'x'))
  762.         base = 16;
  763.       else if (base == 8)
  764. *** 1.2    1992/05/31 04:14:02
  765. --- xobstack.cc    1992/12/28 07:41:27
  766. ***************
  767. *** 40,46 ****
  768.     while (lp != 0 && ((void*)lp > obj || (void*)(lp)->limit < obj))
  769.     {
  770.       plp = lp -> prev;
  771. !     delete(lp);
  772.       lp = plp;
  773.     }
  774.     if (lp)
  775. --- 40,46 ----
  776.     while (lp != 0 && ((void*)lp > obj || (void*)(lp)->limit < obj))
  777.     {
  778.       plp = lp -> prev;
  779. !     delete [] (char*)lp;
  780.       lp = plp;
  781.     }
  782.     if (lp)
  783. ***************
  784. *** 68,74 ****
  785.     new_chunk->prev = old_chunk;
  786.     new_chunk->limit = chunklimit = (char *) new_chunk + new_size;
  787.   
  788. !   bcopy((void*)objectbase, (void*)new_chunk->contents, obj_size);
  789.     objectbase = new_chunk->contents;
  790.     nextfree = objectbase + obj_size;
  791.   }
  792. --- 68,74 ----
  793.     new_chunk->prev = old_chunk;
  794.     new_chunk->limit = chunklimit = (char *) new_chunk + new_size;
  795.   
  796. !   memcpy((void*)new_chunk->contents, (void*)objectbase, obj_size);
  797.     objectbase = new_chunk->contents;
  798.     nextfree = objectbase + obj_size;
  799.   }
  800. *** 1.2    1992/06/08 20:42:41
  801. --- xregex.cc    1992/12/28 07:41:28
  802. ***************
  803. *** 49,55 ****
  804.     buf = new re_pattern_buffer;
  805.     reg = new re_registers;
  806.     if (fast)
  807. !     buf->fastmap = malloc(256);
  808.     else
  809.       buf->fastmap = 0;
  810.     buf->translate = (char*)transtable;
  811. --- 49,55 ----
  812.     buf = new re_pattern_buffer;
  813.     reg = new re_registers;
  814.     if (fast)
  815. !     buf->fastmap = (char*)malloc(256);
  816.     else
  817.       buf->fastmap = 0;
  818.     buf->translate = (char*)transtable;
  819. ***************
  820. *** 56,62 ****
  821.     if (tlen > bufsize)
  822.       bufsize = tlen;
  823.     buf->allocated = bufsize;
  824. !   buf->buffer = malloc(buf->allocated);
  825.     char* msg = re_compile_pattern((const char*)t, tlen, buf);
  826.     if (msg != 0)
  827.       (*lib_error_handler)("Regex", msg);
  828. --- 56,62 ----
  829.     if (tlen > bufsize)
  830.       bufsize = tlen;
  831.     buf->allocated = bufsize;
  832. !   buf->buffer = (char *)malloc(buf->allocated);
  833.     char* msg = re_compile_pattern((const char*)t, tlen, buf);
  834.     if (msg != 0)
  835.       (*lib_error_handler)("Regex", msg);
  836. *** 1.1    1992/03/22 07:42:32
  837. --- xsample.cc    1992/12/28 07:41:29
  838. ***************
  839. *** 21,27 ****
  840. --- 21,36 ----
  841.   #include <stream.h>
  842.   #include <xsmplsta.h>
  843.   #include <math.h>
  844. + #include <float.h>
  845.   
  846. + #ifndef HUGE_VAL
  847. + #ifdef HUGE
  848. + #define HUGE_VAL HUGE
  849. + #else
  850. + #define HUGE_VAL DBL_MAX
  851. + #endif
  852. + #endif
  853. + 
  854.   // error handling
  855.   
  856.   void default_SampleStatistic_error_handler(const char* msg)
  857. ***************
  858. *** 53,59 ****
  859.     int positive = p >= 0.5;
  860.     p = (positive)? 1.0 - p : p;
  861.     if (p <= 0.0 || df <= 0)
  862. !     t = HUGE;
  863.     else if (p == 0.5)
  864.       t = 0.0;
  865.     else if (df == 1)
  866. --- 62,68 ----
  867.     int positive = p >= 0.5;
  868.     p = (positive)? 1.0 - p : p;
  869.     if (p <= 0.0 || df <= 0)
  870. !     t = HUGE_VAL;
  871.     else if (p == 0.5)
  872.       t = 0.0;
  873.     else if (df == 1)
  874. ***************
  875. *** 78,85 ****
  876.   SampleStatistic::reset()
  877.   {
  878.       n = 0; x = x2 = 0.0;
  879. !     maxValue = -HUGE;
  880. !     minValue = HUGE;
  881.   }
  882.   
  883.   void
  884. --- 87,94 ----
  885.   SampleStatistic::reset()
  886.   {
  887.       n = 0; x = x2 = 0.0;
  888. !     maxValue = -HUGE_VAL;
  889. !     minValue = HUGE_VAL;
  890.   }
  891.   
  892.   void
  893. ***************
  894. *** 128,136 ****
  895.   SampleStatistic::confidence(int interval)
  896.   {
  897.     int df = n - 1;
  898. !   if (df <= 0) return HUGE;
  899.     double t = tval(double(100 + interval) * 0.005, df);
  900. !   if (t == HUGE)
  901.       return t;
  902.     else
  903.       return (t * stdDev()) / sqrt(double(n));
  904. --- 137,145 ----
  905.   SampleStatistic::confidence(int interval)
  906.   {
  907.     int df = n - 1;
  908. !   if (df <= 0) return HUGE_VAL;
  909.     double t = tval(double(100 + interval) * 0.005, df);
  910. !   if (t == HUGE_VAL)
  911.       return t;
  912.     else
  913.       return (t * stdDev()) / sqrt(double(n));
  914. ***************
  915. *** 140,148 ****
  916.   SampleStatistic::confidence(double p_value)
  917.   {
  918.     int df = n - 1;
  919. !   if (df <= 0) return HUGE;
  920.     double t = tval((1.0 + p_value) * 0.5, df);
  921. !   if (t == HUGE)
  922.       return t;
  923.     else
  924.       return (t * stdDev()) / sqrt(double(n));
  925. --- 149,157 ----
  926.   SampleStatistic::confidence(double p_value)
  927.   {
  928.     int df = n - 1;
  929. !   if (df <= 0) return HUGE_VAL;
  930.     double t = tval((1.0 + p_value) * 0.5, df);
  931. !   if (t == HUGE_VAL)
  932.       return t;
  933.     else
  934.       return (t * stdDev()) / sqrt(double(n));
  935. ***************
  936. *** 175,181 ****
  937.       bucketLimit[i] = lim;
  938.       lim += width;
  939.       }
  940. !     bucketLimit[howManyBuckets-1] = HUGE;    /* from math.h */
  941.   }
  942.   
  943.   SampleHistogram::~SampleHistogram()
  944. --- 184,190 ----
  945.       bucketLimit[i] = lim;
  946.       lim += width;
  947.       }
  948. !     bucketLimit[howManyBuckets-1] = HUGE_VAL;    /* from math.h */
  949.   }
  950.   
  951.   SampleHistogram::~SampleHistogram()
  952. ***************
  953. *** 211,217 ****
  954.   SampleHistogram::printBuckets(ostream& s)
  955.   {
  956.       for(int i = 0; i < howManyBuckets; i++) {
  957. !     if (bucketLimit[i] >= HUGE) {
  958.           s << "< max : " << bucketCount[i] << "\n";
  959.       } else {
  960.           s << "< " << bucketLimit[i] << " : " << bucketCount[i] << "\n";
  961. --- 220,226 ----
  962.   SampleHistogram::printBuckets(ostream& s)
  963.   {
  964.       for(int i = 0; i < howManyBuckets; i++) {
  965. !     if (bucketLimit[i] >= HUGE_VAL) {
  966.           s << "< max : " << bucketCount[i] << "\n";
  967.       } else {
  968.           s << "< " << bucketLimit[i] << " : " << bucketCount[i] << "\n";
  969. *** 1.1    1992/03/22 07:42:32
  970. --- xsmplhis.cc    1992/12/28 07:41:30
  971. ***************
  972. *** 22,27 ****
  973. --- 22,35 ----
  974.   #include <xsmplhis.h>
  975.   #include <math.h>
  976.   
  977. + #ifndef HUGE_VAL
  978. + #ifdef HUGE
  979. + #define HUGE_VAL HUGE
  980. + #else
  981. + #include <float.h>
  982. + #define HUGE_VAL DBL_MAX
  983. + #endif
  984. + #endif
  985.   
  986.   const int SampleHistogramMinimum = -2;
  987.   const int SampleHistogramMaximum = -1;
  988. ***************
  989. *** 47,53 ****
  990.       bucketLimit[i] = lim;
  991.       lim += width;
  992.       }
  993. !     bucketLimit[howManyBuckets-1] = HUGE;    /* from math.h */
  994.   }
  995.   
  996.   SampleHistogram::~SampleHistogram()
  997. --- 55,61 ----
  998.       bucketLimit[i] = lim;
  999.       lim += width;
  1000.       }
  1001. !     bucketLimit[howManyBuckets-1] = HUGE_VAL;    /* from math.h */
  1002.   }
  1003.   
  1004.   SampleHistogram::~SampleHistogram()
  1005. ***************
  1006. *** 83,89 ****
  1007.   SampleHistogram::printBuckets(ostream& s)
  1008.   {
  1009.       for(int i = 0; i < howManyBuckets; i++) {
  1010. !     if (bucketLimit[i] >= HUGE) {
  1011.           s << "< max : " << bucketCount[i] << "\n";
  1012.       } else {
  1013.           s << "< " << bucketLimit[i] << " : " << bucketCount[i] << "\n";
  1014. --- 91,97 ----
  1015.   SampleHistogram::printBuckets(ostream& s)
  1016.   {
  1017.       for(int i = 0; i < howManyBuckets; i++) {
  1018. !     if (bucketLimit[i] >= HUGE_VAL) {
  1019.           s << "< max : " << bucketCount[i] << "\n";
  1020.       } else {
  1021.           s << "< " << bucketLimit[i] << " : " << bucketCount[i] << "\n";
  1022. *** 1.1    1992/03/22 07:42:32
  1023. --- xsmplsta.cc    1992/12/28 07:41:30
  1024. ***************
  1025. *** 22,27 ****
  1026. --- 22,36 ----
  1027.   #include <xsmplsta.h>
  1028.   #include <math.h>
  1029.   
  1030. + #ifndef HUGE_VAL
  1031. + #ifdef HUGE
  1032. + #define HUGE_VAL HUGE
  1033. + #else
  1034. + #include <float.h>
  1035. + #define HUGE_VAL DBL_MAX
  1036. + #endif
  1037. + #endif
  1038. + 
  1039.   // error handling
  1040.   
  1041.   void default_SampleStatistic_error_handler(const char* msg)
  1042. ***************
  1043. *** 53,59 ****
  1044.     int positive = p >= 0.5;
  1045.     p = (positive)? 1.0 - p : p;
  1046.     if (p <= 0.0 || df <= 0)
  1047. !     t = HUGE;
  1048.     else if (p == 0.5)
  1049.       t = 0.0;
  1050.     else if (df == 1)
  1051. --- 62,68 ----
  1052.     int positive = p >= 0.5;
  1053.     p = (positive)? 1.0 - p : p;
  1054.     if (p <= 0.0 || df <= 0)
  1055. !     t = HUGE_VAL;
  1056.     else if (p == 0.5)
  1057.       t = 0.0;
  1058.     else if (df == 1)
  1059. ***************
  1060. *** 78,85 ****
  1061.   SampleStatistic::reset()
  1062.   {
  1063.       n = 0; x = x2 = 0.0;
  1064. !     maxValue = -HUGE;
  1065. !     minValue = HUGE;
  1066.   }
  1067.   
  1068.   void
  1069. --- 87,94 ----
  1070.   SampleStatistic::reset()
  1071.   {
  1072.       n = 0; x = x2 = 0.0;
  1073. !     maxValue = -HUGE_VAL;
  1074. !     minValue = HUGE_VAL;
  1075.   }
  1076.   
  1077.   void
  1078. ***************
  1079. *** 128,136 ****
  1080.   SampleStatistic::confidence(int interval)
  1081.   {
  1082.     int df = n - 1;
  1083. !   if (df <= 0) return HUGE;
  1084.     double t = tval(double(100 + interval) * 0.005, df);
  1085. !   if (t == HUGE)
  1086.       return t;
  1087.     else
  1088.       return (t * stdDev()) / sqrt(double(n));
  1089. --- 137,145 ----
  1090.   SampleStatistic::confidence(int interval)
  1091.   {
  1092.     int df = n - 1;
  1093. !   if (df <= 0) return HUGE_VAL;
  1094.     double t = tval(double(100 + interval) * 0.005, df);
  1095. !   if (t == HUGE_VAL)
  1096.       return t;
  1097.     else
  1098.       return (t * stdDev()) / sqrt(double(n));
  1099. ***************
  1100. *** 140,148 ****
  1101.   SampleStatistic::confidence(double p_value)
  1102.   {
  1103.     int df = n - 1;
  1104. !   if (df <= 0) return HUGE;
  1105.     double t = tval((1.0 + p_value) * 0.5, df);
  1106. !   if (t == HUGE)
  1107.       return t;
  1108.     else
  1109.       return (t * stdDev()) / sqrt(double(n));
  1110. --- 149,157 ----
  1111.   SampleStatistic::confidence(double p_value)
  1112.   {
  1113.     int df = n - 1;
  1114. !   if (df <= 0) return HUGE_VAL;
  1115.     double t = tval((1.0 + p_value) * 0.5, df);
  1116. !   if (t == HUGE_VAL)
  1117.       return t;
  1118.     else
  1119.       return (t * stdDev()) / sqrt(double(n));
  1120.