home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1134 < prev    next >
Internet Message Format  |  1990-12-28  |  37KB
  1. From: howard@hasse.ericsson.se (Howard Gayle)
  2. Newsgroups: alt.sources
  3. Subject: GNU Emacs 8-bit mods part 07 of 12
  4. Message-ID: <1990Apr5.133859.8993@ericsson.se>
  5. Date: 5 Apr 90 13:38:59 GMT
  6.  
  7. *** ../18.55/src/regex.c    Thu Aug 18 20:24:38 1988
  8. --- src/regex.c    Thu Apr  5 09:15:22 1990
  9. ***************
  10. *** 1,5 ****
  11.   /* Extended regular expression matching and search.
  12. !    Copyright (C) 1985 Free Software Foundation, Inc.
  13.   
  14.                  NO WARRANTY
  15.   
  16. --- 1,5 ----
  17.   /* Extended regular expression matching and search.
  18. !    Copyright (C) 1985, 1990 Free Software Foundation, Inc.
  19.   
  20.                  NO WARRANTY
  21.   
  22. ***************
  23. *** 103,108 ****
  24. --- 103,112 ----
  25.   what you give them.   Help stamp out software-hoarding!  */
  26.   
  27.   
  28. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  29. +  *  See chartab.c for details. */
  30. + 
  31. + 
  32.   /* To test, compile with -Dtest.
  33.    This Dtestable feature turns this into a self-contained program
  34.    which reads a pattern, describes how it compiles,
  35. ***************
  36. *** 117,122 ****
  37. --- 121,127 ----
  38.   #include "config.h"
  39.   #include "lisp.h"
  40.   #include "buffer.h"
  41. + #include "sorttab.h"
  42.   #include "syntax.h"
  43.   
  44.   #else  /* not emacs */
  45. ***************
  46. *** 218,242 ****
  47.     after re_compile_pattern returns.
  48.   */
  49.   
  50. ! #define PATPUSH(ch) (*b++ = (char) (ch))
  51.   
  52.   #define PATFETCH(c) \
  53.    {if (p == pend) goto end_of_pattern; \
  54. !   c = * (unsigned char *) p++; \
  55. !   if (translate) c = translate[c]; }
  56. ! 
  57. ! #define PATFETCH_RAW(c) \
  58. !  {if (p == pend) goto end_of_pattern; \
  59. !   c = * (unsigned char *) p++; }
  60.   
  61.   #define PATUNFETCH p--
  62.   
  63.   #define EXTEND_BUFFER \
  64. !   { char *old_buffer = bufp->buffer; \
  65.       if (bufp->allocated == (1<<16)) goto too_big; \
  66.       bufp->allocated *= 2; \
  67.       if (bufp->allocated > (1<<16)) bufp->allocated = (1<<16); \
  68. !     if (!(bufp->buffer = (char *) realloc (bufp->buffer, bufp->allocated))) \
  69.         goto memory_exhausted; \
  70.       c = bufp->buffer - old_buffer; \
  71.       b += c; \
  72. --- 223,242 ----
  73.     after re_compile_pattern returns.
  74.   */
  75.   
  76. ! #define PATPUSH(ch) (*b++ = (unsigned char) (ch))
  77.   
  78.   #define PATFETCH(c) \
  79.    {if (p == pend) goto end_of_pattern; \
  80. !   c = *p++; }
  81.   
  82.   #define PATUNFETCH p--
  83.   
  84.   #define EXTEND_BUFFER \
  85. !   { unsigned char *old_buffer = bufp->buffer; \
  86.       if (bufp->allocated == (1<<16)) goto too_big; \
  87.       bufp->allocated *= 2; \
  88.       if (bufp->allocated > (1<<16)) bufp->allocated = (1<<16); \
  89. !     if (!(bufp->buffer = (unsigned char *) realloc (bufp->buffer, bufp->allocated))) \
  90.         goto memory_exhausted; \
  91.       c = bufp->buffer - old_buffer; \
  92.       b += c; \
  93. ***************
  94. *** 251,274 ****
  95.   
  96.   static int store_jump (), insert_jump ();
  97.   
  98.   char *
  99.   re_compile_pattern (pattern, size, bufp)
  100. !      char *pattern;
  101.        int size;
  102.        struct re_pattern_buffer *bufp;
  103.   {
  104. !   register char *b = bufp->buffer;
  105. !   register char *p = pattern;
  106. !   char *pend = pattern + size;
  107.     register unsigned c, c1;
  108. !   char *p1;
  109. !   unsigned char *translate = (unsigned char *) bufp->translate;
  110.   
  111.     /* address of the count-byte of the most recently inserted "exactn" command.
  112.       This makes it possible to tell whether a new exact-match character
  113.       can be added to that command or requires a new "exactn" command. */
  114.        
  115. !   char *pending_exact = 0;
  116.   
  117.     /* address of the place where a forward-jump should go
  118.       to the end of the containing expression.
  119. --- 251,691 ----
  120.   
  121.   static int store_jump (), insert_jump ();
  122.   
  123. + #ifdef emacs
  124. + 
  125. + void
  126. + set_bits (b, c, st)
  127. + register unsigned char *b;
  128. + register int c;
  129. + register struct Lisp_Sorttab *st;
  130. + {
  131. + register int i;
  132. + register int hi;
  133. + register int ec;
  134. + 
  135. + if (st == NULL_SORT_TABLE)
  136. +    b[c / BYTEWIDTH] |= 1 << (c % BYTEWIDTH);
  137. + else
  138. +    {
  139. +    ec = st->srt_ec[c];
  140. +    hi = st->srt_dope[ec].ec_hi;
  141. +    for (i = st->srt_dope[ec].ec_lo; i <= hi; ++i)
  142. +       {
  143. +       c = st->srt_chars[i];
  144. +       b[c / BYTEWIDTH] |= 1 << (c % BYTEWIDTH);
  145. +       }
  146. +    }
  147. + }
  148. + 
  149. + char *
  150. + re_compile_pattern_sort (pattern, size, bufp, sorttab)
  151. +      unsigned char *pattern;
  152. +      int size;
  153. +      struct re_pattern_buffer *bufp;
  154. +      struct Lisp_Sorttab *sorttab;
  155. + {
  156. +   register unsigned char *b = bufp->buffer;
  157. +   register unsigned char *p = pattern;
  158. +   unsigned char *pend = pattern + size;
  159. +   register unsigned c, c1;
  160. +   unsigned char *p1;
  161. + 
  162. +   /* address of the count-byte of the most recently inserted "exactn" command.
  163. +     This makes it possible to tell whether a new exact-match character
  164. +     can be added to that command or requires a new "exactn" command. */
  165. +      
  166. +   unsigned char *pending_exact = 0;
  167. + 
  168. +   /* address of the place where a forward-jump should go
  169. +     to the end of the containing expression.
  170. +     Each alternative of an "or", except the last, ends with a forward-jump
  171. +     of this sort. */
  172. + 
  173. +   unsigned char *fixup_jump = 0;
  174. + 
  175. +   /* address of start of the most recently finished expression.
  176. +     This tells postfix * where to find the start of its operand. */
  177. + 
  178. +   unsigned char *laststart = 0;
  179. + 
  180. +   /* In processing a repeat, 1 means zero matches is allowed */
  181. + 
  182. +   unsigned char zero_times_ok;
  183. + 
  184. +   /* In processing a repeat, 1 means many matches is allowed */
  185. + 
  186. +   unsigned char many_times_ok;
  187. + 
  188. +   /* address of beginning of regexp, or inside of last \( */
  189. + 
  190. +   unsigned char *begalt = b;
  191. + 
  192. +   /* Stack of information saved by \( and restored by \).
  193. +      Four stack elements are pushed by each \(:
  194. +        First, the value of b.
  195. +        Second, the value of fixup_jump.
  196. +        Third, the value of regnum.
  197. +        Fourth, the value of begalt.  */
  198. + 
  199. +   int stackb[40];
  200. +   int *stackp = stackb;
  201. +   int *stacke = stackb + 40;
  202. +   int *stackt;
  203. + 
  204. +   /* Counts \('s as they are encountered.  Remembered for the matching \),
  205. +      where it becomes the "register number" to put in the stop_memory command */
  206. + 
  207. +   int regnum = 1;
  208. + 
  209. +   bufp->fastmap_accurate = 0;
  210. + 
  211. +   if (bufp->allocated == 0)
  212. +     {
  213. +       bufp->allocated = 28;
  214. +       if (bufp->buffer)
  215. +     /* EXTEND_BUFFER loses when bufp->allocated is 0 */
  216. +     bufp->buffer = (unsigned char *) realloc (bufp->buffer, 28);
  217. +       else
  218. +     /* Caller did not allocate a buffer.  Do it for him */
  219. +     bufp->buffer = (unsigned char *) malloc (28);
  220. +       if (!bufp->buffer) goto memory_exhausted;
  221. +       begalt = b = bufp->buffer;
  222. +     }
  223. + 
  224. +   while (p != pend)
  225. +     {
  226. +       if (b - bufp->buffer > bufp->allocated - 10)
  227. +     /* Note that EXTEND_BUFFER clobbers c */
  228. +     EXTEND_BUFFER;
  229. + 
  230. +       PATFETCH (c);
  231. + 
  232. +       switch (c)
  233. +     {
  234. +     case '$':
  235. +       /* $ means succeed if at end of line, but only in special contexts.
  236. +         If randonly in the middle of a pattern, it is a normal character. */
  237. +       if (p == pend || (*p == '\\' && (p[1] == ')' || p[1] == '|')))
  238. +         {
  239. +           PATPUSH (endline);
  240. +           break;
  241. +         }
  242. +       goto normal_char;
  243. + 
  244. +     case '^':
  245. +       /* ^ means succeed if at beg of line, but only if no preceding pattern. */
  246. +       if (laststart) goto normal_char;
  247. +       PATPUSH (begline);
  248. +       break;
  249. + 
  250. +     case '*':
  251. +     case '+':
  252. +     case '?':
  253. +       /* If there is no previous pattern, char not special. */
  254. +       if (!laststart)
  255. +         goto normal_char;
  256. +       /* If there is a sequence of repetition chars,
  257. +          collapse it down to equivalent to just one.  */
  258. +       zero_times_ok = 0;
  259. +       many_times_ok = 0;
  260. +       while (1)
  261. +         {
  262. +           zero_times_ok |= c != '+';
  263. +           many_times_ok |= c != '?';
  264. +           if (p == pend)
  265. +         break;
  266. +           PATFETCH (c);
  267. +           if (!(c == '*' || c == '+' || c == '?'))
  268. +         {
  269. +           PATUNFETCH;
  270. +           break;
  271. +         }
  272. +         }
  273. + 
  274. +       /* Now we know whether 0 matches is allowed,
  275. +          and whether 2 or more matches is allowed.  */
  276. +       if (many_times_ok)
  277. +         {
  278. +           /* If more than one repetition is allowed,
  279. +          put in a backward jump at the end.  */
  280. +           store_jump (b, maybe_finalize_jump, laststart - 3);
  281. +           b += 3;
  282. +         }
  283. +       insert_jump (on_failure_jump, laststart, b + 3, b);
  284. +       pending_exact = 0;
  285. +       b += 3;
  286. +       if (!zero_times_ok)
  287. +         {
  288. +           /* At least one repetition required: insert before the loop
  289. +          a skip over the initial on-failure-jump instruction */
  290. +           insert_jump (dummy_failure_jump, laststart, laststart + 6, b);
  291. +           b += 3;
  292. +         }
  293. +       break;
  294. + 
  295. +     case '.':
  296. +       laststart = b;
  297. +       PATPUSH (anychar);
  298. +       break;
  299. + 
  300. +     case '[':
  301. +       if (b - bufp->buffer
  302. +           > bufp->allocated - 3 - (1 << BYTEWIDTH) / BYTEWIDTH)
  303. +         /* Note that EXTEND_BUFFER clobbers c */
  304. +         EXTEND_BUFFER;
  305. + 
  306. +       laststart = b;
  307. +       if (*p == '^')
  308. +         PATPUSH (charset_not), p++;
  309. +       else
  310. +         PATPUSH (charset);
  311. +       p1 = p;
  312. + 
  313. +       PATPUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
  314. +       /* Clear the whole map */
  315. +       bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH);
  316. +       /* Read in characters and ranges, setting map bits */
  317. +       while (1)
  318. +         {
  319. +           PATFETCH (c);
  320. +           if (c == ']' && p != p1 + 1) break;
  321. +           if (*p == '-')
  322. +         {
  323. +           PATFETCH (c1);
  324. +           PATFETCH (c1);
  325. +           while (c <= c1)
  326. +             set_bits (b, c++, sorttab);
  327. +         }
  328. +           else
  329. +         set_bits (b, c, sorttab);
  330. +         }
  331. +       /* Discard any bitmap bytes that are all 0 at the end of the map.
  332. +          Decrement the map-length byte too. */
  333. +       while (b[-1] > 0 && b[b[-1] - 1] == 0)
  334. +         b[-1]--;
  335. +       b += b[-1];
  336. +       break;
  337. + 
  338. +         case '\\':
  339. +       if (p == pend) goto invalid_pattern;
  340. +       PATFETCH (c);
  341. +       switch (c)
  342. +         {
  343. +         case '(':
  344. +           if (stackp == stacke) goto nesting_too_deep;
  345. +           if (regnum < RE_NREGS)
  346. +             {
  347. +           PATPUSH (start_memory);
  348. +           PATPUSH (regnum);
  349. +             }
  350. +           *stackp++ = b - bufp->buffer;
  351. +           *stackp++ = fixup_jump ? fixup_jump - bufp->buffer + 1 : 0;
  352. +           *stackp++ = regnum++;
  353. +           *stackp++ = begalt - bufp->buffer;
  354. +           fixup_jump = 0;
  355. +           laststart = 0;
  356. +           begalt = b;
  357. +           break;
  358. + 
  359. +         case ')':
  360. +           if (stackp == stackb) goto unmatched_close;
  361. +           begalt = *--stackp + bufp->buffer;
  362. +           if (fixup_jump)
  363. +         store_jump (fixup_jump, jump, b);
  364. +           if (stackp[-1] < RE_NREGS)
  365. +         {
  366. +           PATPUSH (stop_memory);
  367. +           PATPUSH (stackp[-1]);
  368. +         }
  369. +           stackp -= 2;
  370. +           fixup_jump = 0;
  371. +           if (*stackp)
  372. +         fixup_jump = *stackp + bufp->buffer - 1;
  373. +           laststart = *--stackp + bufp->buffer;
  374. +           break;
  375. + 
  376. +         case '|':
  377. +           insert_jump (on_failure_jump, begalt, b + 6, b);
  378. +           pending_exact = 0;
  379. +           b += 3;
  380. +           if (fixup_jump)
  381. +         store_jump (fixup_jump, jump, b);
  382. +           fixup_jump = b;
  383. +           b += 3;
  384. +           laststart = 0;
  385. +           begalt = b;
  386. +           break;
  387. + 
  388. +         case '=':
  389. +           PATPUSH (at_dot);
  390. +           break;
  391. + 
  392. +         case 's':    
  393. +           laststart = b;
  394. +           PATPUSH (syntaxspec);
  395. +           PATFETCH (c);
  396. +           PATPUSH (syntax_spec_code[c]);
  397. +           break;
  398. + 
  399. +         case 'S':
  400. +           laststart = b;
  401. +           PATPUSH (notsyntaxspec);
  402. +           PATFETCH (c);
  403. +           PATPUSH (syntax_spec_code[c]);
  404. +           break;
  405. + 
  406. +         case 'w':
  407. +           laststart = b;
  408. +           PATPUSH (wordchar);
  409. +           break;
  410. + 
  411. +         case 'W':
  412. +           laststart = b;
  413. +           PATPUSH (notwordchar);
  414. +           break;
  415. + 
  416. +         case '<':
  417. +           PATPUSH (wordbeg);
  418. +           break;
  419. + 
  420. +         case '>':
  421. +           PATPUSH (wordend);
  422. +           break;
  423. + 
  424. +         case 'b':
  425. +           PATPUSH (wordbound);
  426. +           break;
  427. + 
  428. +         case 'B':
  429. +           PATPUSH (notwordbound);
  430. +           break;
  431. + 
  432. +         case '`':
  433. +           PATPUSH (begbuf);
  434. +           break;
  435. + 
  436. +         case '\'':
  437. +           PATPUSH (endbuf);
  438. +           break;
  439. + 
  440. +         case '1':
  441. +         case '2':
  442. +         case '3':
  443. +         case '4':
  444. +         case '5':
  445. +         case '6':
  446. +         case '7':
  447. +         case '8':
  448. +         case '9':
  449. +           c1 = c - '0';
  450. +           if (c1 >= regnum)
  451. +         goto normal_char;
  452. +           for (stackt = stackp - 2;  stackt > stackb;  stackt -= 4)
  453. +          if (*stackt == c1)
  454. +           goto normal_char;
  455. +           laststart = b;
  456. +           PATPUSH (duplicate);
  457. +           PATPUSH (c1);
  458. +           break;
  459. +         default:
  460. +           goto normal_char;
  461. +         }
  462. +       break;
  463. + 
  464. +     default:
  465. +     normal_char:
  466. +       if ((sorttab == NULL_SORT_TABLE) ||
  467. +           (sorttab->srt_dope[sorttab->srt_ec[c]].ec_lo ==
  468. +           sorttab->srt_dope[sorttab->srt_ec[c]].ec_hi))
  469. +         {
  470. +           if (!pending_exact || pending_exact + *pending_exact + 1 != b
  471. +               || *pending_exact == 0177 || *p == '*' || *p == '^'
  472. +               || *p == '+' || *p == '?')
  473. +             {
  474. +               laststart = b;
  475. +               PATPUSH (exactn);
  476. +               pending_exact = b;
  477. +               PATPUSH (0);
  478. +             }
  479. +           PATPUSH (c);
  480. +           (*pending_exact)++;
  481. +         }
  482. +       else
  483. +         {
  484. +           if (b - bufp->buffer
  485. +               > bufp->allocated - 3 - (1 << BYTEWIDTH) / BYTEWIDTH)
  486. +             /* Note that EXTEND_BUFFER clobbers c */
  487. +         {
  488. +           c1 = c;
  489. +               EXTEND_BUFFER;
  490. +           c = c1;
  491. +         }
  492. + 
  493. +           laststart = b;
  494. +           PATPUSH (charset);
  495. + 
  496. +           PATPUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
  497. +           /* Clear the whole map */
  498. +           bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH);
  499. +           set_bits (b, c, sorttab);
  500. +           /* Discard any bitmap bytes that are all 0 at the end of the map.
  501. +              Decrement the map-length byte too. */
  502. +           while (b[-1] > 0 && b[b[-1] - 1] == 0)
  503. +             b[-1]--;
  504. +           b += b[-1];
  505. +         }
  506. +     }
  507. +     }
  508. + 
  509. +   if (fixup_jump)
  510. +     store_jump (fixup_jump, jump, b);
  511. + 
  512. +   if (stackp != stackb) goto unmatched_open;
  513. + 
  514. +   bufp->used = b - bufp->buffer;
  515. +   return 0;
  516. + 
  517. +  invalid_pattern:
  518. +   return "Invalid regular expression";
  519. + 
  520. +  unmatched_open:
  521. +   return "Unmatched \\(";
  522. + 
  523. +  unmatched_close:
  524. +   return "Unmatched \\)";
  525. + 
  526. +  end_of_pattern:
  527. +   return "Premature end of regular expression";
  528. + 
  529. +  nesting_too_deep:
  530. +   return "Nesting too deep";
  531. + 
  532. +  too_big:
  533. +   return "Regular expression too big";
  534. + 
  535. +  memory_exhausted:
  536. +   return "Memory exhausted";
  537. + }
  538. + 
  539. + #else /* not emacs */
  540. + 
  541.   char *
  542.   re_compile_pattern (pattern, size, bufp)
  543. !      unsigned char *pattern;
  544.        int size;
  545.        struct re_pattern_buffer *bufp;
  546.   {
  547. !   register unsigned char *b = bufp->buffer;
  548. !   register unsigned char *p = pattern;
  549. !   unsigned char *pend = pattern + size;
  550.     register unsigned c, c1;
  551. !   unsigned char *p1;
  552.   
  553.     /* address of the count-byte of the most recently inserted "exactn" command.
  554.       This makes it possible to tell whether a new exact-match character
  555.       can be added to that command or requires a new "exactn" command. */
  556.        
  557. !   unsigned char *pending_exact = 0;
  558.   
  559.     /* address of the place where a forward-jump should go
  560.       to the end of the containing expression.
  561. ***************
  562. *** 275,298 ****
  563.       Each alternative of an "or", except the last, ends with a forward-jump
  564.       of this sort. */
  565.   
  566. !   char *fixup_jump = 0;
  567.   
  568.     /* address of start of the most recently finished expression.
  569.       This tells postfix * where to find the start of its operand. */
  570.   
  571. !   char *laststart = 0;
  572.   
  573.     /* In processing a repeat, 1 means zero matches is allowed */
  574.   
  575. !   char zero_times_ok;
  576.   
  577.     /* In processing a repeat, 1 means many matches is allowed */
  578.   
  579. !   char many_times_ok;
  580.   
  581.     /* address of beginning of regexp, or inside of last \( */
  582.   
  583. !   char *begalt = b;
  584.   
  585.     /* Stack of information saved by \( and restored by \).
  586.        Four stack elements are pushed by each \(:
  587. --- 692,715 ----
  588.       Each alternative of an "or", except the last, ends with a forward-jump
  589.       of this sort. */
  590.   
  591. !   unsigned char *fixup_jump = 0;
  592.   
  593.     /* address of start of the most recently finished expression.
  594.       This tells postfix * where to find the start of its operand. */
  595.   
  596. !   unsigned char *laststart = 0;
  597.   
  598.     /* In processing a repeat, 1 means zero matches is allowed */
  599.   
  600. !   unsigned char zero_times_ok;
  601.   
  602.     /* In processing a repeat, 1 means many matches is allowed */
  603.   
  604. !   unsigned char many_times_ok;
  605.   
  606.     /* address of beginning of regexp, or inside of last \( */
  607.   
  608. !   unsigned char *begalt = b;
  609.   
  610.     /* Stack of information saved by \( and restored by \).
  611.        Four stack elements are pushed by each \(:
  612. ***************
  613. *** 313,319 ****
  614.   
  615.     bufp->fastmap_accurate = 0;
  616.   
  617. - #ifndef emacs
  618.   #ifndef SYNTAX_TABLE
  619.     /*
  620.      * Initialize the syntax table.
  621. --- 730,735 ----
  622. ***************
  623. *** 320,326 ****
  624.      */
  625.      init_syntax_once();
  626.   #endif
  627. - #endif
  628.   
  629.     if (bufp->allocated == 0)
  630.       {
  631. --- 736,741 ----
  632. ***************
  633. *** 327,336 ****
  634.         bufp->allocated = 28;
  635.         if (bufp->buffer)
  636.       /* EXTEND_BUFFER loses when bufp->allocated is 0 */
  637. !     bufp->buffer = (char *) realloc (bufp->buffer, 28);
  638.         else
  639.       /* Caller did not allocate a buffer.  Do it for him */
  640. !     bufp->buffer = (char *) malloc (28);
  641.         if (!bufp->buffer) goto memory_exhausted;
  642.         begalt = b = bufp->buffer;
  643.       }
  644. --- 742,751 ----
  645.         bufp->allocated = 28;
  646.         if (bufp->buffer)
  647.       /* EXTEND_BUFFER loses when bufp->allocated is 0 */
  648. !     bufp->buffer = (unsigned char *) realloc (bufp->buffer, 28);
  649.         else
  650.       /* Caller did not allocate a buffer.  Do it for him */
  651. !     bufp->buffer = (unsigned char *) malloc (28);
  652.         if (!bufp->buffer) goto memory_exhausted;
  653.         begalt = b = bufp->buffer;
  654.       }
  655. ***************
  656. *** 534,540 ****
  657.   
  658.           case '\\':
  659.         if (p == pend) goto invalid_pattern;
  660. !       PATFETCH_RAW (c);
  661.         switch (c)
  662.           {
  663.           case '(':
  664. --- 949,955 ----
  665.   
  666.           case '\\':
  667.         if (p == pend) goto invalid_pattern;
  668. !       PATFETCH (c);
  669.         switch (c)
  670.           {
  671.           case '(':
  672. ***************
  673. *** 672,681 ****
  674.   
  675.           default:
  676.           normal_backsl:
  677. -           /* You might think it would be useful for \ to mean
  678. -          not to translate; but if we don't translate it
  679. -          it will never match anything.  */
  680. -           if (translate) c = translate[c];
  681.             goto normal_char;
  682.           }
  683.         break;
  684. --- 1087,1092 ----
  685. ***************
  686. *** 728,733 ****
  687. --- 1139,1146 ----
  688.     return "Memory exhausted";
  689.   }
  690.   
  691. + #endif /* emacs */
  692. + 
  693.   /* Store where `from' points a jump operation to jump to where `to' points.
  694.     `opcode' is the opcode to store. */
  695.   
  696. ***************
  697. *** 750,760 ****
  698.   
  699.   static int
  700.   insert_jump (op, from, to, current_end)
  701. !      char op;
  702. !      char *from, *to, *current_end;
  703.   {
  704. !   register char *pto = current_end + 3;
  705. !   register char *pfrom = current_end;
  706.     while (pfrom != from)
  707.       *--pto = *--pfrom;
  708.     store_jump (from, op, to);
  709. --- 1163,1173 ----
  710.   
  711.   static int
  712.   insert_jump (op, from, to, current_end)
  713. !      unsigned char op;
  714. !      unsigned char *from, *to, *current_end;
  715.   {
  716. !   register unsigned char *pto = current_end + 3;
  717. !   register unsigned char *pfrom = current_end;
  718.     while (pfrom != from)
  719.       *--pto = *--pfrom;
  720.     store_jump (from, op, to);
  721. ***************
  722. *** 773,785 ****
  723.   re_compile_fastmap (bufp)
  724.        struct re_pattern_buffer *bufp;
  725.   {
  726. !   unsigned char *pattern = (unsigned char *) bufp->buffer;
  727.     int size = bufp->used;
  728. !   register char *fastmap = bufp->fastmap;
  729.     register unsigned char *p = pattern;
  730.     register unsigned char *pend = pattern + size;
  731.     register int j, k;
  732. -   unsigned char *translate = (unsigned char *) bufp->translate;
  733.   
  734.     unsigned char *stackb[NFAILURES];
  735.     unsigned char **stackp = stackb;
  736. --- 1186,1197 ----
  737.   re_compile_fastmap (bufp)
  738.        struct re_pattern_buffer *bufp;
  739.   {
  740. !   unsigned char *pattern = bufp->buffer;
  741.     int size = bufp->used;
  742. !   register unsigned char *fastmap = bufp->fastmap;
  743.     register unsigned char *p = pattern;
  744.     register unsigned char *pend = pattern + size;
  745.     register int j, k;
  746.   
  747.     unsigned char *stackb[NFAILURES];
  748.     unsigned char **stackp = stackb;
  749. ***************
  750. *** 802,811 ****
  751.   #endif
  752.       {
  753.       case exactn:
  754. !       if (translate)
  755. !         fastmap[translate[p[1]]] = 1;
  756. !       else
  757. !         fastmap[p[1]] = 1;
  758.         break;
  759.   
  760.           case begline:
  761. --- 1214,1220 ----
  762.   #endif
  763.       {
  764.       case exactn:
  765. !       fastmap[p[1]] = 1;
  766.         break;
  767.   
  768.           case begline:
  769. ***************
  770. *** 821,830 ****
  771.         continue;
  772.   
  773.       case endline:
  774. !       if (translate)
  775. !         fastmap[translate['\n']] = 1;
  776. !       else
  777. !         fastmap['\n'] = 1;
  778.         if (bufp->can_be_null != 1)
  779.           bufp->can_be_null = 2;
  780.         break;
  781. --- 1230,1236 ----
  782.         continue;
  783.   
  784.       case endline:
  785. !       fastmap['\n'] = 1;
  786.         if (bufp->can_be_null != 1)
  787.           bufp->can_be_null = 2;
  788.         break;
  789. ***************
  790. *** 911,940 ****
  791.       case charset:
  792.         for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
  793.           if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))
  794. !           {
  795. !         if (translate)
  796. !           fastmap[translate[j]] = 1;
  797. !         else
  798. !           fastmap[j] = 1;
  799. !           }
  800.         break;
  801.   
  802.       case charset_not:
  803.         /* Chars beyond end of map must be allowed */
  804.         for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++)
  805. !         if (translate)
  806. !           fastmap[translate[j]] = 1;
  807. !         else
  808. !           fastmap[j] = 1;
  809.   
  810.         for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
  811.           if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))))
  812. !           {
  813. !         if (translate)
  814. !           fastmap[translate[j]] = 1;
  815. !         else
  816. !           fastmap[j] = 1;
  817. !           }
  818.         break;
  819.       }
  820.   
  821. --- 1317,1333 ----
  822.       case charset:
  823.         for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
  824.           if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))
  825. !           fastmap[j] = 1;
  826.         break;
  827.   
  828.       case charset_not:
  829.         /* Chars beyond end of map must be allowed */
  830.         for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++)
  831. !         fastmap[j] = 1;
  832.   
  833.         for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
  834.           if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))))
  835. !           fastmap[j] = 1;
  836.         break;
  837.       }
  838.   
  839. ***************
  840. *** 953,959 ****
  841.   int
  842.   re_search (pbufp, string, size, startpos, range, regs)
  843.        struct re_pattern_buffer *pbufp;
  844. !      char *string;
  845.        int size, startpos, range;
  846.        struct re_registers *regs;
  847.   {
  848. --- 1346,1352 ----
  849.   int
  850.   re_search (pbufp, string, size, startpos, range, regs)
  851.        struct re_pattern_buffer *pbufp;
  852. !      unsigned char *string;
  853.        int size, startpos, range;
  854.        struct re_registers *regs;
  855.   {
  856. ***************
  857. *** 975,981 ****
  858.   int
  859.   re_search_2 (pbufp, string1, size1, string2, size2, startpos, range, regs, mstop)
  860.        struct re_pattern_buffer *pbufp;
  861. !      char *string1, *string2;
  862.        int size1, size2;
  863.        int startpos;
  864.        register int range;
  865. --- 1368,1374 ----
  866.   int
  867.   re_search_2 (pbufp, string1, size1, string2, size2, startpos, range, regs, mstop)
  868.        struct re_pattern_buffer *pbufp;
  869. !      unsigned char *string1, *string2;
  870.        int size1, size2;
  871.        int startpos;
  872.        register int range;
  873. ***************
  874. *** 982,989 ****
  875.        struct re_registers *regs;
  876.        int mstop;
  877.   {
  878. !   register char *fastmap = pbufp->fastmap;
  879. !   register unsigned char *translate = (unsigned char *) pbufp->translate;
  880.     int total = size1 + size2;
  881.     int val;
  882.   
  883. --- 1375,1381 ----
  884.        struct re_registers *regs;
  885.        int mstop;
  886.   {
  887. !   register unsigned char *fastmap = pbufp->fastmap;
  888.     int total = size1 + size2;
  889.     int val;
  890.   
  891. ***************
  892. *** 1023,1049 ****
  893.             p = ((unsigned char *)
  894.              &(startpos >= size1 ? string2 - size1 : string1)[startpos]);
  895.   
  896. !           if (translate)
  897. !         {
  898. !           while (range > lim && !fastmap[translate[*p++]])
  899. !             range--;
  900. !         }
  901. !           else
  902. !         {
  903. !           while (range > lim && !fastmap[*p++])
  904. !             range--;
  905. !         }
  906.             startpos += irange - range;
  907.           }
  908.         else
  909.           {
  910.             register unsigned char c;
  911. !           if (startpos >= size1)
  912. !         c = string2[startpos - size1];
  913. !           else
  914. !         c = string1[startpos];
  915. !           c &= 0xff;
  916. !           if (translate ? !fastmap[translate[c]] : !fastmap[c])
  917.           goto advance;
  918.           }
  919.       }
  920. --- 1415,1430 ----
  921.             p = ((unsigned char *)
  922.              &(startpos >= size1 ? string2 - size1 : string1)[startpos]);
  923.   
  924. !           while (range > lim && !fastmap[*p++])
  925. !         range--;
  926.             startpos += irange - range;
  927.           }
  928.         else
  929.           {
  930.             register unsigned char c;
  931. !           if (startpos >= size1) c = string2[startpos - size1];
  932. !           else c = string1[startpos];
  933. !           if (!fastmap[c])
  934.           goto advance;
  935.           }
  936.       }
  937. ***************
  938. *** 1075,1081 ****
  939.   int
  940.   re_match (pbufp, string, size, pos, regs)
  941.        struct re_pattern_buffer *pbufp;
  942. !      char *string;
  943.        int size, pos;
  944.        struct re_registers *regs;
  945.   {
  946. --- 1456,1462 ----
  947.   int
  948.   re_match (pbufp, string, size, pos, regs)
  949.        struct re_pattern_buffer *pbufp;
  950. !      unsigned char *string;
  951.        int size, pos;
  952.        struct re_registers *regs;
  953.   {
  954. ***************
  955. *** 1087,1093 ****
  956.   
  957.   int re_max_failures = 2000;
  958.   
  959. - static int bcmp_translate();
  960.   /* Match the pattern described by PBUFP
  961.      against data which is the virtual concatenation of STRING1 and STRING2.
  962.      SIZE1 and SIZE2 are the sizes of the two data strings.
  963. --- 1468,1473 ----
  964. ***************
  965. *** 1123,1129 ****
  966.     unsigned char *end_match_1, *end_match_2;
  967.     register unsigned char *d, *dend;
  968.     register int mcnt;
  969. -   unsigned char *translate = (unsigned char *) pbufp->translate;
  970.   
  971.    /* Failure point stack.  Each place that can handle a failure further down the line
  972.       pushes a failure point on this stack.  It consists of two char *'s.
  973. --- 1503,1508 ----
  974. ***************
  975. *** 1295,1301 ****
  976.           if (mcnt > dend2 - d2)
  977.             mcnt = dend2 - d2;
  978.           /* Compare that many; failure if mismatch, else skip them. */
  979. !         if (translate ? bcmp_translate (d, d2, mcnt, translate) : bcmp (d, d2, mcnt))
  980.             goto fail;
  981.           d += mcnt, d2 += mcnt;
  982.             }
  983. --- 1674,1680 ----
  984.           if (mcnt > dend2 - d2)
  985.             mcnt = dend2 - d2;
  986.           /* Compare that many; failure if mismatch, else skip them. */
  987. !         if (bcmp (d, d2, mcnt))
  988.             goto fail;
  989.           d += mcnt, d2 += mcnt;
  990.             }
  991. ***************
  992. *** 1306,1312 ****
  993.         /* fetch a data character */
  994.         PREFETCH;
  995.         /* Match anything but a newline.  */
  996. !       if ((translate ? translate[*d++] : *d++) == '\n')
  997.           goto fail;
  998.         break;
  999.   
  1000. --- 1685,1691 ----
  1001.         /* fetch a data character */
  1002.         PREFETCH;
  1003.         /* Match anything but a newline.  */
  1004. !       if (*d++ == '\n')
  1005.           goto fail;
  1006.         break;
  1007.   
  1008. ***************
  1009. *** 1322,1331 ****
  1010.           /* fetch a data character */
  1011.           PREFETCH;
  1012.   
  1013. !         if (translate)
  1014. !           c = translate [*d];
  1015. !         else
  1016. !           c = *d;
  1017.   
  1018.           if (c < *p * BYTEWIDTH
  1019.           && p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
  1020. --- 1701,1707 ----
  1021.           /* fetch a data character */
  1022.           PREFETCH;
  1023.   
  1024. !             c = *d;
  1025.   
  1026.           if (c < *p * BYTEWIDTH
  1027.           && p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
  1028. ***************
  1029. *** 1371,1378 ****
  1030.             if (stacke - stackb > re_max_failures)
  1031.           return -2;
  1032.             stackx = (unsigned char **) alloca (2 * (stacke - stackb)
  1033. !                      * sizeof (char *));
  1034. !           bcopy (stackb, stackx, (stacke - stackb) * sizeof (char *));
  1035.             stackp = stackx + (stackp - stackb);
  1036.             stacke = stackx + 2 * (stacke - stackb);
  1037.             stackb = stackx;
  1038. --- 1747,1754 ----
  1039.             if (stacke - stackb > re_max_failures)
  1040.           return -2;
  1041.             stackx = (unsigned char **) alloca (2 * (stacke - stackb)
  1042. !                      * sizeof (unsigned char *));
  1043. !           bcopy (stackb, stackx, (stacke - stackb) * sizeof (unsigned char *));
  1044.             stackp = stackx + (stackp - stackb);
  1045.             stacke = stackx + 2 * (stacke - stackb);
  1046.             stackb = stackx;
  1047. ***************
  1048. *** 1444,1451 ****
  1049.           {
  1050.             unsigned char **stackx
  1051.           = (unsigned char **) alloca (2 * (stacke - stackb)
  1052. !                          * sizeof (char *));
  1053. !           bcopy (stackb, stackx, (stacke - stackb) * sizeof (char *));
  1054.             stackp = stackx + (stackp - stackb);
  1055.             stacke = stackx + 2 * (stacke - stackb);
  1056.             stackb = stackx;
  1057. --- 1820,1827 ----
  1058.           {
  1059.             unsigned char **stackx
  1060.           = (unsigned char **) alloca (2 * (stacke - stackb)
  1061. !                          * sizeof (unsigned char *));
  1062. !           bcopy (stackb, stackx, (stacke - stackb) * sizeof (unsigned char *));
  1063.             stackp = stackx + (stackp - stackb);
  1064.             stacke = stackx + 2 * (stacke - stackb);
  1065.             stackb = stackx;
  1066. ***************
  1067. *** 1563,1586 ****
  1068.         /* Match the next few pattern characters exactly.
  1069.            mcnt is how many characters to match. */
  1070.         mcnt = *p++;
  1071. !       if (translate)
  1072.           {
  1073. !           do
  1074. !         {
  1075. !           PREFETCH;
  1076. !           if (translate[*d++] != *p++) goto fail;
  1077. !         }
  1078. !           while (--mcnt);
  1079. !         }
  1080. !       else
  1081. !         {
  1082. !           do
  1083. !         {
  1084. !           PREFETCH;
  1085. !           if (*d++ != *p++) goto fail;
  1086. !         }
  1087. !           while (--mcnt);
  1088.           }
  1089.         break;
  1090.       }
  1091.         continue;    /* Successfully matched one pattern command; keep matching */
  1092. --- 1939,1950 ----
  1093.         /* Match the next few pattern characters exactly.
  1094.            mcnt is how many characters to match. */
  1095.         mcnt = *p++;
  1096. !       do
  1097.           {
  1098. !           PREFETCH;
  1099. !           if (*d++ != *p++) goto fail;
  1100.           }
  1101. +       while (--mcnt);
  1102.         break;
  1103.       }
  1104.         continue;    /* Successfully matched one pattern command; keep matching */
  1105. ***************
  1106. *** 1604,1624 ****
  1107.       }
  1108.     return -1;         /* Failure to match */
  1109.   }
  1110. - 
  1111. - static int
  1112. - bcmp_translate (s1, s2, len, translate)
  1113. -      unsigned char *s1, *s2;
  1114. -      register int len;
  1115. -      unsigned char *translate;
  1116. - {
  1117. -   register unsigned char *p1 = s1, *p2 = s2;
  1118. -   while (len)
  1119. -     {
  1120. -       if (translate [*p1++] != translate [*p2++]) return 1;
  1121. -       len--;
  1122. -     }
  1123. -   return 0;
  1124. - }
  1125.   
  1126.   /* Entry points compatible with bsd4.2 regex library */
  1127.   
  1128. --- 1968,1973 ----
  1129. ***************
  1130. *** 1628,1634 ****
  1131.   
  1132.   char *
  1133.   re_comp (s)
  1134. !      char *s;
  1135.   {
  1136.     if (!s)
  1137.       {
  1138. --- 1977,1983 ----
  1139.   
  1140.   char *
  1141.   re_comp (s)
  1142. !      unsigned char *s;
  1143.   {
  1144.     if (!s)
  1145.       {
  1146. ***************
  1147. *** 1639,1648 ****
  1148.   
  1149.     if (!re_comp_buf.buffer)
  1150.       {
  1151. !       if (!(re_comp_buf.buffer = (char *) malloc (200)))
  1152.       return "Memory exhausted";
  1153.         re_comp_buf.allocated = 200;
  1154. !       if (!(re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH)))
  1155.       return "Memory exhausted";
  1156.       }
  1157.     return re_compile_pattern (s, strlen (s), &re_comp_buf);
  1158. --- 1988,1997 ----
  1159.   
  1160.     if (!re_comp_buf.buffer)
  1161.       {
  1162. !       if (!(re_comp_buf.buffer = (unsigned char *) malloc (200)))
  1163.       return "Memory exhausted";
  1164.         re_comp_buf.allocated = 200;
  1165. !       if (!(re_comp_buf.fastmap = (unsigned char *) malloc (1 << BYTEWIDTH)))
  1166.       return "Memory exhausted";
  1167.       }
  1168.     return re_compile_pattern (s, strlen (s), &re_comp_buf);
  1169. ***************
  1170. *** 1650,1656 ****
  1171.   
  1172.   int
  1173.   re_exec (s)
  1174. !      char *s;
  1175.   {
  1176.     int len = strlen (s);
  1177.     return 0 <= re_search (&re_comp_buf, s, len, 0, len, 0);
  1178. --- 1999,2005 ----
  1179.   
  1180.   int
  1181.   re_exec (s)
  1182. !      unsigned char *s;
  1183.   {
  1184.     int len = strlen (s);
  1185.     return 0 <= re_search (&re_comp_buf, s, len, 0, len, 0);
  1186. ***************
  1187. *** 1664,1670 ****
  1188.   
  1189.   /* Indexed by a character, gives the upper case equivalent of the character */
  1190.   
  1191. ! static char upcase[0400] = 
  1192.     { 000, 001, 002, 003, 004, 005, 006, 007,
  1193.       010, 011, 012, 013, 014, 015, 016, 017,
  1194.       020, 021, 022, 023, 024, 025, 026, 027,
  1195. --- 2013,2019 ----
  1196.   
  1197.   /* Indexed by a character, gives the upper case equivalent of the character */
  1198.   
  1199. ! static unsigned char upcase[0400] = 
  1200.     { 000, 001, 002, 003, 004, 005, 006, 007,
  1201.       010, 011, 012, 013, 014, 015, 016, 017,
  1202.       020, 021, 022, 023, 024, 025, 026, 027,
  1203. ***************
  1204. *** 1703,1713 ****
  1205.        int argc;
  1206.        char **argv;
  1207.   {
  1208. !   char pat[80];
  1209.     struct re_pattern_buffer buf;
  1210.     int i;
  1211. !   char c;
  1212. !   char fastmap[(1 << BYTEWIDTH)];
  1213.   
  1214.     /* Allow a command argument to specify the style of syntax.  */
  1215.     if (argc > 1)
  1216. --- 2052,2062 ----
  1217.        int argc;
  1218.        char **argv;
  1219.   {
  1220. !   unsigned char pat[80];
  1221.     struct re_pattern_buffer buf;
  1222.     int i;
  1223. !   unsigned char c;
  1224. !   unsigned char fastmap[(1 << BYTEWIDTH)];
  1225.   
  1226.     /* Allow a command argument to specify the style of syntax.  */
  1227.     if (argc > 1)
  1228. ***************
  1229. *** 1714,1722 ****
  1230.       obscure_syntax = atoi (argv[1]);
  1231.   
  1232.     buf.allocated = 40;
  1233. !   buf.buffer = (char *) malloc (buf.allocated);
  1234.     buf.fastmap = fastmap;
  1235. -   buf.translate = upcase;
  1236.   
  1237.     while (1)
  1238.       {
  1239. --- 2063,2070 ----
  1240.       obscure_syntax = atoi (argv[1]);
  1241.   
  1242.     buf.allocated = 40;
  1243. !   buf.buffer = (unsigned char *) malloc (buf.allocated);
  1244.     buf.fastmap = fastmap;
  1245.   
  1246.     while (1)
  1247.       {
  1248. ***************
  1249. *** 1763,1773 ****
  1250.     for (i = 0; i < (1 << BYTEWIDTH); i++)
  1251.       if (bufp->fastmap[i])
  1252.         printchar (i);
  1253. -   printf ("\nAllowed by translate: ");
  1254. -   if (bufp->translate)
  1255. -     for (i = 0; i < (1 << BYTEWIDTH); i++)
  1256. -       if (bufp->translate[i])
  1257. -     printchar (i);
  1258.     printf ("\nfastmap is%s accurate\n", bufp->fastmap_accurate ? "" : "n't");
  1259.     printf ("can %s be null\n----------", bufp->can_be_null ? "" : "not");
  1260.   }
  1261. --- 2111,2116 ----
  1262. ***************
  1263. *** 1774,1780 ****
  1264.   #endif
  1265.   
  1266.   printchar (c)
  1267. !      char c;
  1268.   {
  1269.     if (c < 041 || c >= 0177)
  1270.       {
  1271. --- 2117,2123 ----
  1272.   #endif
  1273.   
  1274.   printchar (c)
  1275. !      unsigned char c;
  1276.   {
  1277.     if (c < 041 || c >= 0177)
  1278.       {
  1279. ***************
  1280. *** 1788,1794 ****
  1281.   }
  1282.   
  1283.   error (string)
  1284. !      char *string;
  1285.   {
  1286.     puts (string);
  1287.     exit (1);
  1288. --- 2131,2137 ----
  1289.   }
  1290.   
  1291.   error (string)
  1292. !      unsigned char *string;
  1293.   {
  1294.     puts (string);
  1295.     exit (1);
  1296. *** ../18.55/src/regex.h    Sat Aug 13 20:15:10 1988
  1297. --- src/regex.h    Thu Apr  5 09:15:46 1990
  1298. ***************
  1299. *** 1,5 ****
  1300.   /* Definitions for data structures callers pass the regex library.
  1301. !    Copyright (C) 1985 Free Software Foundation, Inc.
  1302.   
  1303.                  NO WARRANTY
  1304.   
  1305. --- 1,5 ----
  1306.   /* Definitions for data structures callers pass the regex library.
  1307. !    Copyright (C) 1985, 1990 Free Software Foundation, Inc.
  1308.   
  1309.                  NO WARRANTY
  1310.   
  1311. ***************
  1312. *** 103,108 ****
  1313. --- 103,112 ----
  1314.   what you give them.   Help stamp out software-hoarding!  */
  1315.   
  1316.   
  1317. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  1318. +  *  See chartab.c for details. */
  1319. + 
  1320. + 
  1321.   /* Define number of parens for which we record the beginnings and ends.
  1322.      This affects how much space the `struct re_registers' type takes up.  */
  1323.   #ifndef RE_NREGS
  1324. ***************
  1325. *** 149,168 ****
  1326.   #define RE_SYNTAX_GREP (RE_BK_PLUS_QM | RE_NEWLINE_OR)
  1327.   #define RE_SYNTAX_EMACS 0
  1328.   
  1329.   /* This data structure is used to represent a compiled pattern. */
  1330.   
  1331.   struct re_pattern_buffer
  1332.     {
  1333. !     char *buffer;    /* Space holding the compiled pattern commands. */
  1334.       int allocated;    /* Size of space that  buffer  points to */
  1335.       int used;        /* Length of portion of buffer actually occupied */
  1336. !     char *fastmap;    /* Pointer to fastmap, if any, or zero if none. */
  1337.               /* re_search uses the fastmap, if there is one,
  1338.                  to skip quickly over totally implausible characters */
  1339. -     char *translate;    /* Translate table to apply to all characters before comparing.
  1340. -                Or zero for no translation.
  1341. -                The translation is applied to a pattern when it is compiled
  1342. -                and to data when it is matched. */
  1343.       char fastmap_accurate;
  1344.               /* Set to zero when a new pattern is stored,
  1345.                  set to one when the fastmap is updated from it. */
  1346. --- 153,172 ----
  1347.   #define RE_SYNTAX_GREP (RE_BK_PLUS_QM | RE_NEWLINE_OR)
  1348.   #define RE_SYNTAX_EMACS 0
  1349.   
  1350. + #ifndef emacs
  1351. + typedef unsigned char char_t;
  1352. + #endif
  1353. + 
  1354.   /* This data structure is used to represent a compiled pattern. */
  1355.   
  1356.   struct re_pattern_buffer
  1357.     {
  1358. !     char_t *buffer;    /* Space holding the compiled pattern commands. */
  1359.       int allocated;    /* Size of space that  buffer  points to */
  1360.       int used;        /* Length of portion of buffer actually occupied */
  1361. !     char_t *fastmap;    /* Pointer to fastmap, if any, or zero if none. */
  1362.               /* re_search uses the fastmap, if there is one,
  1363.                  to skip quickly over totally implausible characters */
  1364.       char fastmap_accurate;
  1365.               /* Set to zero when a new pattern is stored,
  1366.                  set to one when the fastmap is updated from it. */
  1367. ***************
  1368. *** 252,258 ****
  1369. --- 256,267 ----
  1370.       notsyntaxspec /* Matches any character whose syntax differs from the specified. */
  1371.     };
  1372.   
  1373. + #ifdef emacs
  1374. + extern char *re_compile_pattern_sort ();
  1375. + #else
  1376.   extern char *re_compile_pattern ();
  1377. + #endif
  1378. + 
  1379.   /* Is this really advertised? */
  1380.   extern void re_compile_fastmap ();
  1381.   extern int re_search (), re_search_2 ();
  1382. *** ../18.55/src/scroll.c    Sat Mar 19 08:55:25 1988
  1383. --- src/scroll.c    Thu Apr  5 09:16:04 1990
  1384. ***************
  1385. *** 1,5 ****
  1386.   /* Calculate what ins/del line to do, and do it, for Emacs redisplay.
  1387. !    Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  1388.   
  1389.   This file is part of GNU Emacs.
  1390.   
  1391. --- 1,5 ----
  1392.   /* Calculate what ins/del line to do, and do it, for Emacs redisplay.
  1393. !    Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
  1394.   
  1395.   This file is part of GNU Emacs.
  1396.   
  1397. ***************
  1398. *** 19,25 ****
  1399. --- 19,30 ----
  1400.   and this notice must be preserved on all copies.  */
  1401.   
  1402.   
  1403. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  1404. +  *  See chartab.c for details. */
  1405. + 
  1406. + 
  1407.   #include "config.h"
  1408. + #include "lisp.h"
  1409.   #include "termchar.h"
  1410.   #include "dispextern.h"
  1411.   
  1412.