home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 June / SIMTEL_0692.cdr / msdos / gnuish / gptx01.arc / patches < prev    next >
Text File  |  1990-09-24  |  29KB  |  974 lines
  1. *** e:\tmp/RCSt1006052    Sat Sep 22 00:28:24 1990
  2. --- gptx.c    Sat Sep 22 00:20:50 1990
  3. ***************
  4. *** 2,8 ****
  5.      Copyright (C) 1990 Free Software Foundation, Inc.
  6.      Francois Pinard <pinard@iro.umontreal.ca>, 1988.
  7.   
  8. !    $Id: gptx.c 0.1 90/08/11 09:18:50 tho Exp $
  9.   
  10.      This program is free software; you can redistribute it and/or modify
  11.      it under the terms of the GNU General Public License as published by
  12. --- 2,8 ----
  13.      Copyright (C) 1990 Free Software Foundation, Inc.
  14.      Francois Pinard <pinard@iro.umontreal.ca>, 1988.
  15.   
  16. !    $Id: gptx.c 0.1.0.4 90/09/22 00:18:19 tho Exp $
  17.   
  18.      This program is free software; you can redistribute it and/or modify
  19.      it under the terms of the GNU General Public License as published by
  20. ***************
  21. *** 117,124 ****
  22.   
  23.   typedef struct
  24.     {
  25. !     char *start;        /* pointer to beginning of region */
  26. !     char *end;            /* pointer to end + 1 of region */
  27.     }
  28.   BLOCK;
  29.   
  30. --- 117,124 ----
  31.   
  32.   typedef struct
  33.     {
  34. !     char HUGE *start;        /* pointer to beginning of region */
  35. !     char HUGE *end;            /* pointer to end + 1 of region */
  36.     }
  37.   BLOCK;
  38.   
  39. ***************
  40. *** 186,192 ****
  41.   int *file_line_count;        /* array of `total_line_count' values at end */
  42.   
  43.   BLOCK text_buffer;        /* file to study */
  44. ! char *text_buffer_maxend;    /* allocated end of text_buffer */
  45.   
  46.   /* SKIP_NON_WHITE used only for getting or skipping the reference.  */
  47.   
  48. --- 186,192 ----
  49.   int *file_line_count;        /* array of `total_line_count' values at end */
  50.   
  51.   BLOCK text_buffer;        /* file to study */
  52. ! char HUGE *text_buffer_maxend;    /* allocated end of text_buffer */
  53.   
  54.   /* SKIP_NON_WHITE used only for getting or skipping the reference.  */
  55.   
  56. ***************
  57. *** 207,213 ****
  58.       if (word_regex_string)                        \
  59.         {                                    \
  60.       int count;                            \
  61. !     count = re_match (word_regex, cursor, limit - cursor, 0, NULL);    \
  62.       cursor += count <= 0 ? 1 : count;                \
  63.         }                                    \
  64.       else if (word_fastmap[(unsigned char) *cursor])            \
  65. --- 207,214 ----
  66.       if (word_regex_string)                        \
  67.         {                                    \
  68.       int count;                            \
  69. !     count = re_match (word_regex, cursor,                \
  70. !               L_PDIFF(limit, cursor), ZERO, NULL);        \
  71.       cursor += count <= 0 ? 1 : count;                \
  72.         }                                    \
  73.       else if (word_fastmap[(unsigned char) *cursor])            \
  74. ***************
  75. *** 368,374 ****
  76. --- 369,380 ----
  77.   
  78.     if (pattern->allocated > pattern->used)
  79.       {
  80. + #ifdef MSDOS
  81. +       pattern->buffer
  82. +     = (char *) xrealloc (pattern->buffer, (size_t) pattern->used);
  83. + #else /* not MSDOS */
  84.         pattern->buffer = (char *) xrealloc (pattern->buffer, pattern->used);
  85. + #endif /* not MSDOS */
  86.         pattern->allocated = pattern->used;
  87.       }
  88.   
  89. ***************
  90. *** 469,477 ****
  91.   {
  92.     int file_handle;        /* file descriptor number */
  93.     struct stat stat_block;    /* stat block for file */
  94. !   int allocated_length;        /* allocated length of memory buffer */
  95. !   int used_length;        /* used length in memory buffer */
  96. !   int read_length;        /* number of character gotten on last read */
  97.   
  98.     /* As special cases, a file name which is NULL or "-" indicates standard
  99.        input, which is already opened.  In all other cases, open the file from
  100. --- 475,483 ----
  101.   {
  102.     int file_handle;        /* file descriptor number */
  103.     struct stat stat_block;    /* stat block for file */
  104. !   LONG allocated_length;        /* allocated length of memory buffer */
  105. !   LONG used_length;        /* used length in memory buffer */
  106. !   LONG read_length;        /* number of character gotten on last read */
  107.   
  108.     /* As special cases, a file name which is NULL or "-" indicates standard
  109.        input, which is already opened.  In all other cases, open the file from
  110. ***************
  111. *** 493,498 ****
  112. --- 499,513 ----
  113.   
  114.     if ((stat_block.st_mode & S_IFMT) == S_IFREG)
  115.       {
  116. + #ifdef MSDOS
  117. +       block->start = (char HUGE *) xhalloc (stat_block.st_size);
  118. + 
  119. +       read_length = hread (file_handle, block->start, stat_block.st_size);
  120. +       if (read_length <= 0L)
  121. +     perror_and_exit (file_name);
  122. + 
  123. +       block->end = block->start + read_length;
  124. + #else /* not MSDOS */
  125.         block->start = (char *) xmalloc ((int) stat_block.st_size);
  126.   
  127.         if (read (file_handle, block->start, (int) stat_block.st_size)
  128. ***************
  129. *** 500,508 ****
  130. --- 515,533 ----
  131.       perror_and_exit (file_name);
  132.   
  133.         block->end = block->start + stat_block.st_size;
  134. + #endif /* not MSDOS */
  135.       }
  136.     else
  137.       {
  138. + #ifdef MSDOS
  139. +       block->start = (char HUGE *) xhalloc (1L << SWALLOW_REALLOC_LOG);
  140. +       used_length = 0;
  141. +       allocated_length = (1 << SWALLOW_REALLOC_LOG);
  142. + 
  143. +       while ((read_length = hread (file_handle,
  144. +                    block->start + used_length,
  145. +                    allocated_length - used_length)) > 0L)
  146. + #else /* not MSDOS */
  147.         block->start = (char *) xmalloc (1 << SWALLOW_REALLOC_LOG);
  148.         used_length = 0;
  149.         allocated_length = (1 << SWALLOW_REALLOC_LOG);
  150. ***************
  151. *** 510,522 ****
  152. --- 535,556 ----
  153.         while ((read_length = read (file_handle,
  154.                     block->start + used_length,
  155.                     allocated_length - used_length)) > 0)
  156. + #endif /* not MSDOS */
  157.       {
  158.         used_length += read_length;
  159.         if (used_length == allocated_length)
  160.           {
  161. + #ifdef MSDOS
  162. +           block->start
  163. +         = (char HUGE *) xhrealloc (block->start, allocated_length,
  164. +                        allocated_length
  165. +                        + (1L << SWALLOW_REALLOC_LOG));
  166. +           allocated_length += (1L << SWALLOW_REALLOC_LOG);
  167. + #else /* not MSDOS */
  168.             allocated_length += (1 << SWALLOW_REALLOC_LOG);
  169.             block->start
  170.           = (char *) xrealloc (block->start, allocated_length);
  171. + #endif /* not MSDOS */
  172.           }
  173.       }
  174.   
  175. ***************
  176. *** 594,600 ****
  177. --- 628,642 ----
  178.     int value;
  179.   
  180.     value = compare_words (&first->key, &second->key);
  181. + 
  182. + #ifdef MSDOS
  183. +   return
  184. +     value == 0
  185. +     ? (L_PDIFF (first->key.start, second->key.start) >= 0L ? 1 : -1)
  186. +     : value;
  187. + #else /* not MSDOS */
  188.     return value == 0 ? first->key.start - second->key.start : value;
  189. + #endif /* not MSDOS */
  190.   }
  191.   
  192.   
  193. ***************
  194. *** 645,650 ****
  195. --- 687,696 ----
  196.   
  197.     /* Only one language for the time being.  */
  198.   
  199. + #ifdef MSDOS
  200. +   assert ((long) number_of_occurs[0] * (long) sizeof_occurs < 0x10000L);
  201. + #endif
  202. + 
  203.     qsort (occurs_table[0], number_of_occurs[0],
  204.        sizeof_occurs, compare_occurs);
  205.   }
  206. ***************
  207. *** 734,740 ****
  208.       {
  209.         ALLOC_NEW_WORD (table);
  210.         table->start[table->length].start = word_start;
  211. !       table->start[table->length].size = cursor - word_start;
  212.         table->length++;
  213.       }
  214.   
  215. --- 780,786 ----
  216.       {
  217.         ALLOC_NEW_WORD (table);
  218.         table->start[table->length].start = word_start;
  219. !       table->start[table->length].size = I_PDIFF (cursor, word_start);
  220.         table->length++;
  221.       }
  222.   
  223. ***************
  224. *** 746,751 ****
  225. --- 792,801 ----
  226.   
  227.     /* Finally, sort all the words read.  */
  228.   
  229. + #ifdef MSDOS
  230. +   assert ((long) table->length * (long) sizeof (WORD) < 0x10000L);
  231. + #endif
  232. + 
  233.     qsort (table->start, table->length, sizeof (WORD), compare_words);
  234.   }
  235.   
  236. ***************
  237. *** 762,778 ****
  238.   find_occurs_in_text ()
  239.   #endif
  240.   {
  241. !   char *cursor;            /* for scanning the source text */
  242. !   char *scan;            /* for scanning the source text also */
  243. !   char *line_start;        /* start of the current input line */
  244. !   char *line_scan;        /* newlines scanned until this point */
  245.     int reference_length;        /* length of reference in input mode */
  246.     WORD possible_key;        /* possible key, to ease searches */
  247.     OCCURS *occurs_cursor;    /* current OCCURS under construction */
  248.   
  249. !   char *context_start;        /* start of left context */
  250. !   char *context_end;        /* end of right context */
  251. !   char *next_context_start;    /* next start of left context */
  252.   
  253.     /* Tracking where lines start is helpful for reference processing.  In
  254.        auto reference mode, this allows counting lines.  In input reference
  255. --- 812,828 ----
  256.   find_occurs_in_text ()
  257.   #endif
  258.   {
  259. !   char HUGE *cursor;        /* for scanning the source text */
  260. !   char HUGE *scan;        /* for scanning the source text also */
  261. !   char HUGE *line_start;    /* start of the current input line */
  262. !   char HUGE *line_scan;        /* newlines scanned until this point */
  263.     int reference_length;        /* length of reference in input mode */
  264.     WORD possible_key;        /* possible key, to ease searches */
  265.     OCCURS *occurs_cursor;    /* current OCCURS under construction */
  266.   
  267. !   char HUGE *context_start;    /* start of left context */
  268. !   char HUGE *context_end;    /* end of right context */
  269. !   char HUGE *next_context_start;/* next start of left context */
  270.   
  271.     /* Tracking where lines start is helpful for reference processing.  In
  272.        auto reference mode, this allows counting lines.  In input reference
  273. ***************
  274. *** 788,794 ****
  275.     if (input_reference)
  276.       {
  277.         SKIP_NON_WHITE (line_scan, text_buffer.end);
  278. !       reference_length = line_scan - line_start;
  279.         SKIP_WHITE (line_scan, text_buffer.end);
  280.       }
  281.   
  282. --- 838,844 ----
  283.     if (input_reference)
  284.       {
  285.         SKIP_NON_WHITE (line_scan, text_buffer.end);
  286. !       reference_length = I_PDIFF (line_scan, line_start);
  287.         SKIP_WHITE (line_scan, text_buffer.end);
  288.       }
  289.   
  290. ***************
  291. *** 814,821 ****
  292.        sentence at the end of the buffer.  */
  293.   
  294.         if (context_regex_string
  295. !       && (re_search (context_regex, cursor, text_buffer.end - cursor,
  296. !              0, text_buffer.end - cursor, &context_regs)
  297.             >= 0))
  298.       next_context_start = cursor + context_regs.end[0];
  299.   
  300. --- 864,872 ----
  301.        sentence at the end of the buffer.  */
  302.   
  303.         if (context_regex_string
  304. !       && (re_search (context_regex, cursor,
  305. !              L_PDIFF (text_buffer.end, cursor),
  306. !              ZERO, L_PDIFF (text_buffer.end, cursor), &context_regs)
  307.             >= 0))
  308.       next_context_start = cursor + context_regs.end[0];
  309.   
  310. ***************
  311. *** 841,848 ****
  312.              the loop.  */
  313.   
  314.           {
  315. !           if (re_search (word_regex, cursor, context_end - cursor,
  316. !                  0, context_end - cursor, &word_regs)
  317.             < 0)
  318.           break;
  319.           }
  320. --- 892,900 ----
  321.              the loop.  */
  322.   
  323.           {
  324. !           if (re_search (word_regex, cursor,
  325. !                  L_PDIFF (context_end, cursor),
  326. !                  ZERO, L_PDIFF (context_end, cursor), &word_regs)
  327.             < 0)
  328.           break;
  329.           }
  330. ***************
  331. *** 862,874 ****
  332.             if (scan == context_end)
  333.           break;
  334.   
  335. !           word_regs.start[0] = scan - cursor;
  336.   
  337.             while (scan < context_end
  338.                && word_fastmap[(unsigned char) *scan])
  339.           scan++;
  340.   
  341. !           word_regs.end[0] = scan - cursor;
  342.           }
  343.   
  344.         /* Skip right to the beginning of the found word.  */
  345. --- 914,926 ----
  346.             if (scan == context_end)
  347.           break;
  348.   
  349. !           word_regs.start[0] = I_PDIFF (scan, cursor);
  350.   
  351.             while (scan < context_end
  352.                && word_fastmap[(unsigned char) *scan])
  353.           scan++;
  354.   
  355. !           word_regs.end[0] = I_PDIFF (scan, cursor);
  356.           }
  357.   
  358.         /* Skip right to the beginning of the found word.  */
  359. ***************
  360. *** 912,918 ****
  361.               line_scan++;
  362.               line_start = line_scan;
  363.               SKIP_NON_WHITE (line_scan, text_buffer.end);
  364. !             reference_length = line_scan - line_start;
  365.             }
  366.           else
  367.             line_scan++;
  368. --- 964,971 ----
  369.               line_scan++;
  370.               line_start = line_scan;
  371.               SKIP_NON_WHITE (line_scan, text_buffer.end);
  372. ! 
  373. !             reference_length = I_PDIFF (line_scan, line_start);
  374.             }
  375.           else
  376.             line_scan++;
  377. ***************
  378. *** 976,982 ****
  379.            value of `line_start'.  */
  380.   
  381.             occurs_cursor->reference
  382. !         = (DELTA) (line_start - possible_key.start);
  383.             if (reference_length > reference_max_width)
  384.           reference_max_width = reference_length;
  385.           }
  386. --- 1029,1035 ----
  387.            value of `line_start'.  */
  388.   
  389.             occurs_cursor->reference
  390. !         = (DELTA) I_PDIFF (line_start, possible_key.start);
  391.             if (reference_length > reference_max_width)
  392.           reference_max_width = reference_length;
  393.           }
  394. ***************
  395. *** 992,1000 ****
  396.         /* Completes the OCCURS structure.  */
  397.   
  398.         occurs_cursor->key = possible_key;
  399. !       occurs_cursor->left = context_start - possible_key.start;
  400. !       occurs_cursor->right = context_end - possible_key.start;
  401.   
  402.         number_of_occurs[0]++;
  403.       }
  404.       }
  405. --- 1045,1056 ----
  406.         /* Completes the OCCURS structure.  */
  407.   
  408.         occurs_cursor->key = possible_key;
  409. !       occurs_cursor->left = I_PDIFF (context_start, possible_key.start);
  410. !       occurs_cursor->right = I_PDIFF (context_end, possible_key.start);
  411.   
  412. + #ifdef MSDOS
  413. +       assert (number_of_occurs[0] < 32767);
  414. + #endif /* MSDOS */
  415.         number_of_occurs[0]++;
  416.       }
  417.       }
  418. ***************
  419. *** 1030,1036 ****
  420.        BLOCK field;
  421.   #endif
  422.   {
  423. !   char *cursor;            /* Cursor in field to print */
  424.     int character;        /* Current character */
  425.     int base;            /* Base character, without diacritic */
  426.     int diacritic;        /* Diacritic code for the character */
  427. --- 1086,1092 ----
  428.        BLOCK field;
  429.   #endif
  430.   {
  431. !   char HUGE *cursor;        /* Cursor in field to print */
  432.     int character;        /* Current character */
  433.     int base;            /* Base character, without diacritic */
  434.     int diacritic;        /* Diacritic code for the character */
  435. ***************
  436. *** 1356,1365 ****
  437.   {
  438.     int tail_max_width;        /* allowable width of tail field */
  439.     int head_max_width;        /* allowable width of head field */
  440. !   char *cursor;            /* running cursor in source text */
  441. !   char *left_context_start;    /* start of left context */
  442. !   char *right_context_end;    /* end of right context */
  443. !   char *left_field_start;    /* conservative start for `head'/`before' */
  444.     int file_index;        /* index in text input file arrays */
  445.     STRING *file_name;        /* file name for reference */
  446.     int line_ordinal;        /* line ordinal for reference */
  447. --- 1412,1421 ----
  448.   {
  449.     int tail_max_width;        /* allowable width of tail field */
  450.     int head_max_width;        /* allowable width of head field */
  451. !   char HUGE *cursor;        /* running cursor in source text */
  452. !   char HUGE *left_context_start;/* start of left context */
  453. !   char HUGE *right_context_end;    /* end of right context */
  454. !   char HUGE *left_field_start;    /* conservative start for `head'/`before' */
  455.     int file_index;        /* index in text input file arrays */
  456.     STRING *file_name;        /* file name for reference */
  457.     int line_ordinal;        /* line ordinal for reference */
  458. ***************
  459. *** 1442,1448 ****
  460.        has no suffixed spaces.  */
  461.   
  462.     tail_max_width
  463. !     = before_max_width - (before.end - before.start) - gap_size;
  464.   
  465.     if (tail_max_width > 0)
  466.       {
  467. --- 1498,1504 ----
  468.        has no suffixed spaces.  */
  469.   
  470.     tail_max_width
  471. !     = before_max_width - I_PDIFF (before.end, before.start) - gap_size;
  472.   
  473.     if (tail_max_width > 0)
  474.       {
  475. ***************
  476. *** 1488,1494 ****
  477.        contain only part of a word, and has no suffixed spaces.  */
  478.   
  479.     head_max_width
  480. !     = keyafter_max_width - (keyafter.end - keyafter.start) - gap_size;
  481.   
  482.     if (head_max_width > 0)
  483.       {
  484. --- 1544,1550 ----
  485.        contain only part of a word, and has no suffixed spaces.  */
  486.   
  487.     head_max_width
  488. !     = keyafter_max_width - I_PDIFF (keyafter.end, keyafter.start) - gap_size;
  489.   
  490.     if (head_max_width > 0)
  491.       {
  492. ***************
  493. *** 1624,1630 ****
  494.   {
  495.     BLOCK key;            /* key field, isolated */
  496.     BLOCK after;            /* after field, isolated */
  497. !   char *cursor;            /* running cursor in source text */
  498.   
  499.     printf ("\\xx ");
  500.     printf ("{");
  501. --- 1680,1686 ----
  502.   {
  503.     BLOCK key;            /* key field, isolated */
  504.     BLOCK after;            /* after field, isolated */
  505. !   char HUGE *cursor;        /* running cursor in source text */
  506.   
  507.     printf ("\\xx ");
  508.     printf ("{");
  509. ***************
  510. *** 1675,1681 ****
  511.       putchar (':');
  512.       print_spaces (reference_max_width
  513.                 + gap_size
  514. !               - (reference.end - reference.start)
  515.                 - 1);
  516.         }
  517.       else
  518. --- 1731,1737 ----
  519.       putchar (':');
  520.       print_spaces (reference_max_width
  521.                 + gap_size
  522. !               - I_PDIFF (reference.end, reference.start)
  523.                 - 1);
  524.         }
  525.       else
  526. ***************
  527. *** 1686,1692 ****
  528.       print_field (reference);
  529.       print_spaces (reference_max_width
  530.               + gap_size
  531. !             - (reference.end - reference.start));
  532.         }
  533.   
  534.     if (tail.start < tail.end)
  535. --- 1742,1748 ----
  536.       print_field (reference);
  537.       print_spaces (reference_max_width
  538.               + gap_size
  539. !             - I_PDIFF (reference.end, reference.start));
  540.         }
  541.   
  542.     if (tail.start < tail.end)
  543. ***************
  544. *** 1698,1711 ****
  545.       printf ("%s", truncation_string);
  546.   
  547.         print_spaces (half_line_width - gap_size
  548. !             - (before.end - before.start)
  549.               - (before_truncation ? truncation_string_length : 0)
  550. !             - (tail.end - tail.start)
  551.               - (tail_truncation ? truncation_string_length : 0));
  552.       }
  553.     else
  554.       print_spaces (half_line_width - gap_size
  555. !           - (before.end - before.start)
  556.             - (before_truncation ? truncation_string_length : 0));
  557.   
  558.     /* Output the `before' field.  */
  559. --- 1754,1767 ----
  560.       printf ("%s", truncation_string);
  561.   
  562.         print_spaces (half_line_width - gap_size
  563. !             - I_PDIFF (before.end, before.start)
  564.               - (before_truncation ? truncation_string_length : 0)
  565. !             - I_PDIFF (tail.end, tail.start)
  566.               - (tail_truncation ? truncation_string_length : 0));
  567.       }
  568.     else
  569.       print_spaces (half_line_width - gap_size
  570. !           - I_PDIFF (before.end, before.start)
  571.             - (before_truncation ? truncation_string_length : 0));
  572.   
  573.     /* Output the `before' field.  */
  574. ***************
  575. *** 1727,1735 ****
  576.         /* Output the `head' field.  */
  577.   
  578.         print_spaces (half_line_width
  579. !             - (keyafter.end - keyafter.start)
  580.               - (keyafter_truncation ? truncation_string_length : 0)
  581. !             - (head.end - head.start)
  582.               - (head_truncation ? truncation_string_length : 0));
  583.         if (head_truncation)
  584.       printf ("%s", truncation_string);
  585. --- 1783,1791 ----
  586.         /* Output the `head' field.  */
  587.   
  588.         print_spaces (half_line_width
  589. !             - I_PDIFF (keyafter.end, keyafter.start)
  590.               - (keyafter_truncation ? truncation_string_length : 0)
  591. !             - I_PDIFF (head.end, head.start)
  592.               - (head_truncation ? truncation_string_length : 0));
  593.         if (head_truncation)
  594.       printf ("%s", truncation_string);
  595. ***************
  596. *** 1739,1745 ****
  597.   
  598.       if ((auto_reference || input_reference) && right_reference)
  599.         print_spaces (half_line_width
  600. !             - (keyafter.end - keyafter.start)
  601.               - (keyafter_truncation ? truncation_string_length : 0));
  602.   
  603.     if ((auto_reference || input_reference) && right_reference)
  604. --- 1795,1801 ----
  605.   
  606.       if ((auto_reference || input_reference) && right_reference)
  607.         print_spaces (half_line_width
  608. !             - I_PDIFF (keyafter.end, keyafter.start)
  609.               - (keyafter_truncation ? truncation_string_length : 0));
  610.   
  611.     if ((auto_reference || input_reference) && right_reference)
  612. *** e:\tmp/RCSt1006052    Sat Sep 22 00:28:28 1990
  613. --- xmalloc.c    Fri Sep 21 23:39:02 1990
  614. ***************
  615. *** 2,8 ****
  616.      Copyright (C) 1990 Free Software Foundation, Inc.
  617.      Francois Pinard <pinard@iro.umontreal.ca>, September 1989.
  618.   
  619. !    $Id: xmalloc.c 0.1 90/08/11 09:18:57 tho Exp $
  620.   */
  621.   
  622.   #include <stdio.h>
  623. --- 2,8 ----
  624.      Copyright (C) 1990 Free Software Foundation, Inc.
  625.      Francois Pinard <pinard@iro.umontreal.ca>, September 1989.
  626.   
  627. !    $Id: xmalloc.c 0.1.0.1 90/08/12 00:53:35 tho Exp $
  628.   */
  629.   
  630.   #include <stdio.h>
  631. ***************
  632. *** 66,68 ****
  633. --- 66,163 ----
  634.       }
  635.     return result_pointer;
  636.   }
  637. + 
  638. + #ifdef MSDOS
  639. + 
  640. + #include <stdlib.h>
  641. + #include <string.h>
  642. + #include <io.h>
  643. + 
  644. + #if defined (_MSC_VER) && (_MSC_VER >= 600)
  645. + #define HUGE _huge
  646. + #else
  647. + #define HUGE huge
  648. + #endif
  649. + 
  650. + 
  651. + /* malloc a block of memory, with fatal error message if we can't do it. */
  652. + 
  653. + #include <malloc.h>
  654. + #include <dos.h>
  655. + 
  656. + void HUGE *
  657. + xhalloc (long size)
  658. + {
  659. +   void HUGE *value = (void HUGE *) halloc (size, (size_t)1 );
  660. + 
  661. +   if (!value)
  662. +     {
  663. +       fprintf (stderr, "Out of memory!\n");
  664. +       abort ();
  665. +     }
  666. + 
  667. +   return value;
  668. + }
  669. + 
  670. + /* Here we do a HUGE "realloc" by allocating a new block and
  671. +    moving the old block afterwards.  This is *slow*, but should
  672. +    be reliable.  */
  673. + 
  674. + void HUGE *
  675. + xhrealloc (void HUGE *ptr, long new_size, long old_size)
  676. + {
  677. +   void HUGE *value = (void HUGE *) halloc (new_size, (size_t)1 );
  678. + 
  679. +   if (!value)
  680. +     {
  681. +       fprintf (stderr, "Out of memory!\n");
  682. +       abort ();
  683. +     }
  684. +   else
  685. +     {
  686. +       char HUGE *dest = value;
  687. +       char HUGE *src = ptr;
  688. + 
  689. +       while (old_size > 0L)
  690. +     {
  691. +       unsigned int bytes = (unsigned int) min (0x8000L, old_size);
  692. +       memcpy (dest, src, bytes);
  693. +       old_size -= (long) bytes;
  694. +       dest += (long) bytes;
  695. +       src += (long) bytes;
  696. +     }
  697. +     }
  698. +   hfree (ptr);
  699. +   return value;
  700. + }
  701. + 
  702. + long
  703. + hread (int fd, void HUGE *buffer, long bytes)
  704. + {
  705. +   long bytes_read = 0L;
  706. + 
  707. +   while (1)
  708. +     {
  709. +       int n = read (fd, buffer, (unsigned int) min (0x4000L, bytes));
  710. + 
  711. +       if (n > 0)
  712. +     {
  713. +       bytes_read += (long) n;
  714. +       bytes -= (long) n;
  715. +       /* we can't say buffer += n here, because we have to make
  716. +          sure that the offset of BUFFER doesn't overflow during
  717. +          the read() system call.  Therefore we add what we read
  718. +          to the segment of BUFFER.  */
  719. +       FP_SEG(buffer) += (n >> 4);
  720. +       FP_OFF(buffer) += (n & 0x0F);
  721. +     }
  722. +       else if (n == 0)
  723. +     return bytes_read;    /* done */
  724. +       else
  725. +     {
  726. +       perror ("Out of memory");
  727. +       abort ();
  728. +     }
  729. +     }
  730. + }
  731. + #endif /* MSDOS */
  732. *** e:\tmp/RCSt1006052    Sat Sep 22 00:28:30 1990
  733. --- hregex.c    Sat Sep 22 00:25:50 1990
  734. ***************
  735. *** 0 ****
  736. --- 1,119 ----
  737. + /*  hregex.c - use re_search () and re_match () on huge buffers
  738. +     Copyright (C) 1990 Free Software Foundation, Inc.
  739. +     Francois Pinard <pinard@iro.umontreal.ca>, 1988.
  740. +     Thorsten Ohl <td12@ddagsi3.bitnet>, 1990.
  741. + 
  742. +     This program is free software; you can redistribute it and/or modify
  743. +     it under the terms of the GNU General Public License as published by
  744. +     the Free Software Foundation; either version 1, or (at your option)
  745. +     any later version.
  746. + 
  747. +     This program is distributed in the hope that it will be useful,
  748. +     but WITHOUT ANY WARRANTY; without even the implied warranty of
  749. +     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  750. +     GNU General Public License for more details.
  751. + 
  752. +     You should have received a copy of the GNU General Public License
  753. +     along with this program; if not, write to the Free Software
  754. +     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  755. + 
  756. +     $Header: e:/gnu/gptx/RCS/hregex.c 0.1.0.1 90/09/22 00:23:03 tho Exp $
  757. +  */
  758. + 
  759. + #if defined (_MSC_VER) && (_MSC_VER >= 600)
  760. + #define HUGE _huge
  761. + #else
  762. + #define HUGE huge
  763. + #endif
  764. + 
  765. + #define LONG long
  766. + #define IMAX 0x7fffL
  767. + 
  768. + #include <stdio.h>
  769. + #include <stdlib.h>
  770. + #include <dos.h>
  771. + #include <regex.h>
  772. + 
  773. + extern char *program_name;
  774. + 
  775. + /* Normalize a "huge" ix86 pointer by moving part of the offset into
  776. +    the segment.  (We do it only if the offset is sufficiently large.)
  777. +    Note:  Don't do this with pointers to memory blocks owned by malloc,
  778. +       as a subsequent free () or realloc () will fail!  */
  779. + 
  780. + #define FP_NORM(fp)                \
  781. +   if (FP_OFF (fp) & 0xf000)            \
  782. +     {                        \
  783. +       FP_SEG (fp) += (FP_OFF(fp) >> 4);        \
  784. +       FP_OFF (fp) &= 0x0f;            \
  785. +     }
  786. + 
  787. + /* This is a kludge for using the GNU regex library on huge (>32k)
  788. +    buffers.  This "implementation" assumes that a match will be found in
  789. +    the first 32k and will simply abort with a diagnostic message if not.
  790. +    While this is certainly not a clean solution, it is appropriate in
  791. +    cases where a failure is extremely unlikely, since it avoids the
  792. +    enormous computational overhead of using huge pointers for regexp
  793. +    matching, which is furthermore very error-prone.
  794. +    Note: once these functions are real implementation, they should return
  795. +    a long, but for the moment ints are more convenient.  */
  796. + 
  797. + int
  798. + re_hsearch (struct re_pattern_buffer *pbufp, char HUGE *string, long size,
  799. +         long startpos, long range, struct re_registers *regs)
  800. + {
  801. +   int match;
  802. +   int isize = (int) min (size, IMAX);
  803. +   int istartpos = (int) min (startpos, IMAX);
  804. +   int irange = (int) min (range, IMAX);
  805. + 
  806. +   FP_NORM (string);
  807. + 
  808. +   match = re_search (pbufp, string, isize, istartpos, irange, regs);
  809. + 
  810. +   if (match == -1 && size > IMAX)
  811. +     {
  812. +       fprintf (stderr, "%s: re_search() failed in truncated buffer\n"
  813. +                "        buffer: `%.30s...'\n"
  814. +                "        length: %ld\n",
  815. +                program_name, string, size);
  816. +       abort ();
  817. +     }
  818. + 
  819. +   return match;
  820. + }
  821. + 
  822. + int
  823. + re_hmatch (struct re_pattern_buffer *pbufp, char HUGE *string, long size,
  824. +        long pos, struct re_registers *regs)
  825. + {
  826. +   int match;
  827. +   int isize = (int) min (size, IMAX);
  828. +   int ipos = (int) min (pos, IMAX);
  829. + 
  830. +   FP_NORM (string);
  831. + 
  832. +   match = re_match (pbufp, string, isize, ipos, regs);
  833. + 
  834. +   if (match == -1 && size > IMAX)
  835. +     {
  836. +       fprintf (stderr, "%s: re_match() failed against truncated buffer\n"
  837. +                "        buffer: `%.30s...'\n"
  838. +                "        length: %ld\n",
  839. +                program_name, string, size);
  840. +       abort ();
  841. +     }
  842. + 
  843. +   return match;
  844. + }
  845. + 
  846. + 
  847. + /*
  848. +    Local Variables:
  849. +    mode:C
  850. +    ChangeLog:ChangeLog
  851. +    compile-command:make
  852. +    End:
  853. +  */
  854. + 
  855. + 
  856. *** e:\tmp/RCSt1006052    Sat Sep 22 00:28:34 1990
  857. --- gptx.h    Sat Sep 22 00:23:24 1990
  858. ***************
  859. *** 2,8 ****
  860.      Copyright (C) 1990 Free Software Foundation, Inc.
  861.      Francois Pinard <pinard@iro.umontreal.ca>, 1988.
  862.   
  863. !    $Id: gptx.h 0.1 90/08/11 09:18:59 tho Exp $
  864.   */
  865.   
  866.   
  867. --- 2,8 ----
  868.      Copyright (C) 1990 Free Software Foundation, Inc.
  869.      Francois Pinard <pinard@iro.umontreal.ca>, 1988.
  870.   
  871. !    $Id: gptx.h 0.1.0.4 90/09/22 00:22:40 tho Exp $
  872.   */
  873.   
  874.   
  875. ***************
  876. *** 38,43 ****
  877. --- 38,53 ----
  878.   
  879.   #ifndef STDLIB_PROTO_ALREADY
  880.   
  881. + #include <assert.h>
  882. + 
  883. + #ifdef MSDOS
  884. + 
  885. + #include <stdlib.h>
  886. + #include <io.h>
  887. + int getopt (int, char **, const char *);
  888. + 
  889. + #else /* not MSDOS */
  890. + 
  891.   #ifdef BUFSIZ            /* stdio dependant -- how ugly! */
  892.   int        _filbuf PROTO ((FILE *));
  893.   int        _flsbuf PROTO ((unsigned char, FILE *));
  894. ***************
  895. *** 54,59 ****
  896. --- 64,71 ----
  897.   void        qsort PROTO ((void *, int, int, int ()));
  898.   int        read PROTO ((int, void *, unsigned));
  899.   
  900. + #endif /* not MSDOS */
  901. + 
  902.   #endif /* not STDLIB_PROTO_ALREADY */
  903.   
  904.   
  905. ***************
  906. *** 66,68 ****
  907. --- 78,143 ----
  908.   
  909.   void        print_copyright PROTO ((void));
  910.   void        print_version PROTO ((void));
  911. + 
  912. + /* Teach MS-DOS to handel long files */
  913. + 
  914. + #ifdef MSDOS
  915. + 
  916. + #if defined (_MSC_VER) && (_MSC_VER >= 600)
  917. + #define HUGE _huge
  918. + #else
  919. + #define HUGE huge
  920. + #endif
  921. + #define LONG long
  922. + 
  923. + void HUGE *xhalloc (long size);
  924. + void HUGE *xhrealloc (void HUGE *ptr, long new_size, long old_size);
  925. + long hread (int fd, void HUGE *buffer, long bytes);
  926. + 
  927. + #if defined (M_I86CM) || defined (M_I86LM)
  928. + 
  929. + #define L_PDIFF(ptr1,ptr2) \
  930. +   ((long)((char HUGE *)(ptr1) - (char HUGE *)(ptr2)))
  931. + 
  932. + #define I_PDIFF(ptr1,ptr2) \
  933. +   (assert ((long)((char HUGE *)(ptr1) - (char HUGE *)(ptr2)) < (1L << 15)), \
  934. +    ((int)(long)((char HUGE *)(ptr1) - (char HUGE *)(ptr2))))
  935. + 
  936. + extern int re_hsearch (struct re_pattern_buffer *pbufp, char HUGE *string,
  937. +                long size, long startpos, long range,
  938. +                struct re_registers *regs);
  939. + extern int re_hmatch (struct re_pattern_buffer *pbufp, char HUGE *string,
  940. +               long size, long pos, struct re_registers *regs);
  941. + 
  942. + /* We must mask re_search () and re_match () *after* the prototypes
  943. +    in regex.h!  */
  944. + 
  945. + #include <regex.h>
  946. + 
  947. + #define re_search re_hsearch
  948. + #define re_match re_hmatch
  949. + 
  950. + #define ZERO 0L
  951. + 
  952. + #else /* not M_I86CM and not M_I86LM */
  953. + 
  954. + #define L_PDIFF(ptr1,ptr2)    ((ptr1) - (ptr2))
  955. + #define I_PDIFF(ptr1,ptr2)    ((ptr1) - (ptr2))
  956. + 
  957. + #define ZERO 0
  958. + 
  959. + #endif /* not M_I86CM and not M_I86LM */
  960. + 
  961. + #else /* not MSDOS */
  962. + 
  963. + #define HUGE
  964. + #define LONG int
  965. + 
  966. + #define L_PDIFF(ptr1,ptr2)    ((ptr1) - (ptr2))
  967. + #define I_PDIFF(ptr1,ptr2)    ((ptr1) - (ptr2))
  968. + 
  969. + #define ZERO 0
  970. + 
  971. + #endif /* not MSDOS */
  972. + 
  973. + 
  974.