home *** CD-ROM | disk | FTP | other *** search
/ Mega CD-ROM 1 / megacd_rom_1.zip / megacd_rom_1 / GNUISH / SED106.ZIP / PATCHES < prev    next >
Text File  |  1990-09-22  |  13KB  |  523 lines
  1. *** e:\tmp/RCSt1006323    Sat Sep 22 18:15:06 1990
  2. --- sed.c    Sat Sep 22 18:11:00 1990
  3. ***************
  4. *** 1,4 ****
  5. - 
  6.   /*  GNU SED, a batch stream editor.
  7.       Copyright (C) 1989, Free Software Foundation, Inc.
  8.   
  9. --- 1,3 ----
  10. ***************
  11. *** 16,23 ****
  12. --- 15,37 ----
  13.       along with this program; if not, write to the Free Software
  14.       Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  15.   
  16. + /*  MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  17. +     This port is also distributed under the terms of the
  18. +     GNU General Public License as published by the
  19. +     Free Software Foundation.
  20. + 
  21. +     Please note that this file is not identical to the
  22. +     original GNU release, you should have received this
  23. +     code as patch to the official release.  */
  24. + 
  25. + #ifdef MSDOS
  26. + static char RCS_Id[] =
  27. +   "$Header: e:/gnu/sed/RCS/sed.c 1.6.1.2 90/09/22 17:14:48 tho Exp $";
  28. + #endif
  29. + 
  30.   #include <stdio.h>
  31.   #include <ctype.h>
  32. + 
  33.   #include <regex.h>
  34.   
  35.   /* Compile with 'gcc [-g] [-DHAS_UTILS] [-O] -o sed sed.c [-lutils]' */
  36. ***************
  37. *** 25,31 ****
  38. --- 39,63 ----
  39.   /* Add '-I. regex.c' if regex is not in the system include dir/library */
  40.   
  41.   /* This is a good idea */
  42. + 
  43. + #ifdef MSDOS
  44. + 
  45. + static char Program_Id[] = "sed";
  46. + static char RCS_Revision[] = "$Revision: 1.6.1.2 $";
  47. + 
  48. + #define VERSION \
  49. +   "GNU %s, Version %.*s (compiled %s %s for MS-DOS)\n", Program_Id, \
  50. +   (sizeof RCS_Revision - 14), (RCS_Revision + 11), __DATE__, __TIME__
  51. + 
  52. + #define COPYING \
  53. +   "This is free software, distributed under the terms of the\n" \
  54. +   "GNU General Public License.  For details, see the file COPYING.\n"
  55. + 
  56. + #else /* not MSDOS */
  57. + 
  58.   char *version_string = "GNU sed version 1.06 (or so)";
  59. + 
  60. + #endif /* not MSDOS */
  61.   /*
  62.       1.00    Began (thinking about) distributing this file
  63.       1.01    Added s/re/rep/[digits]
  64. ***************
  65. *** 43,49 ****
  66.    */
  67.   
  68.   #ifdef USG
  69. ! #define bcopy(s, d, n) ((void)memcpy((d),(s), (n)))
  70.   #endif
  71.   
  72.   /* Struct vector is used to describe a chunk of a sed program.  There is one
  73. --- 75,81 ----
  74.    */
  75.   
  76.   #ifdef USG
  77. ! #define bcopy( s, d, n) ((void)memmove((d), (s), (n)))
  78.   #endif
  79.   
  80.   /* Struct vector is used to describe a chunk of a sed program.  There is one
  81. ***************
  82. *** 175,190 ****
  83.   
  84.   
  85.   /* This for all you losing compilers out there that can't handle void * */
  86. ! #ifdef __GNU__
  87.   #define VOID void
  88.   #else
  89.   #define VOID char
  90.   #endif
  91.   
  92. ! extern int optind;
  93. ! extern char *optarg;
  94. ! extern int getopt();
  95.   
  96.   extern char *memchr();
  97.   extern VOID *memmove();
  98.   
  99. --- 207,268 ----
  100.   
  101.   
  102.   /* This for all you losing compilers out there that can't handle void * */
  103. ! #if defined( __GNU__ ) || defined( MSDOS )
  104.   #define VOID void
  105.   #else
  106.   #define VOID char
  107.   #endif
  108.   
  109. ! #include "getopt.h"
  110. ! 
  111. ! #ifdef MSDOS
  112. ! 
  113. ! #include <stdlib.h>
  114. ! #include <string.h>
  115. ! 
  116. ! #include <gnulib.h>
  117. ! 
  118. ! #ifndef STDIO_BUFSIZE
  119. ! #define STDIO_BUFSIZE    0x4000
  120. ! #endif
  121. ! 
  122. ! extern  void main (int argc, char **argv);
  123. ! 
  124. ! static  char *get_buffer (VOID *);
  125. ! static  char *__fp_name (FILE *);
  126. ! static  FILE *ck_fopen (char *, char *);
  127. ! static  FILE *compile_filename (int);
  128. ! static  int compile_address (struct addr *);
  129. ! static  int inchar (void);
  130. ! static  int match_address (struct addr *);
  131. ! static  int read_pattern_space (void);
  132. ! static  int size_buffer (VOID *);
  133. ! static  struct sed_label *setup_jump(struct sed_label *, struct sed_cmd *,
  134. !                      struct vector *);
  135. ! static  struct vector *compile_program (struct vector *);
  136. ! static  VOID *ck_malloc (int);
  137. ! static  VOID *ck_realloc (VOID *, int);
  138. ! static  VOID *init_buffer (void);
  139. ! static  void add1_buffer (VOID *, int);
  140. ! static  void add_buffer (VOID *, VOID *, int);
  141. ! static  void append_pattern_space (void);
  142. ! static  void bad_prog (char *);
  143. ! static  void ck_fclose (FILE *);
  144. ! static  void ck_fwrite (char *, int, int, FILE *);
  145. ! static  void compile_file (char *);
  146. ! static  void compile_string (char *);
  147. ! static  void compile_regex (int);
  148. ! static  void execute_program (struct vector *);
  149. ! static  void flush_buffer (VOID *);
  150. ! static  void line_append (struct line *, struct line *);
  151. ! static  void line_copy (struct line *, struct line *);
  152. ! static  void panic (char *,...);
  153. ! static  void read_file (char *);
  154. ! static  void savchar (int);
  155. ! static  void str_append (struct line *, char *, int);
  156.   
  157. + #else /* not MSDOS */
  158. + 
  159.   extern char *memchr();
  160.   extern VOID *memmove();
  161.   
  162. ***************
  163. *** 209,214 ****
  164. --- 287,294 ----
  165.   void execute_program();
  166.   void compile_regex ();
  167.   
  168. + #endif /* not MSDOS */
  169. + 
  170.   #ifndef HAS_UTILS
  171.   char *myname;
  172.   #else
  173. ***************
  174. *** 297,309 ****
  175.   static char NO_ADDR[] = "Command doesn't take any addresses";
  176.   static char LINE_JUNK[] ="Extra characters after command";
  177.   static char BAD_EOF[] =  "Unexpected End-of-file";
  178.   static char USAGE[] =   "Usage: %s [-n] [-e script...] [-f sfile...] [file...]\n";
  179.   static char NO_REGEX[] = "No previous regular expression";
  180.   
  181.   /* Yes, the main program, which parses arguments, and does the right thing with them,
  182.      It also inits the temporary storage, etc. */
  183. ! main(argc,argv)
  184. ! char **argv;
  185.   {
  186.       int opt;
  187.       int compiled = 0;
  188. --- 377,396 ----
  189.   static char NO_ADDR[] = "Command doesn't take any addresses";
  190.   static char LINE_JUNK[] ="Extra characters after command";
  191.   static char BAD_EOF[] =  "Unexpected End-of-file";
  192. + #ifdef MSDOS
  193. + static char USAGE[] =
  194. +   "Usage: %s [-CV] [-n] [-e script...] [-f sfile...] [file...]\n";
  195. + #else
  196.   static char USAGE[] =   "Usage: %s [-n] [-e script...] [-f sfile...] [file...]\n";
  197. + #endif
  198.   static char NO_REGEX[] = "No previous regular expression";
  199.   
  200.   /* Yes, the main program, which parses arguments, and does the right thing with them,
  201.      It also inits the temporary storage, etc. */
  202. ! void
  203. ! main (argc, argv)
  204. !   int argc;
  205. !   char **argv;
  206.   {
  207.       int opt;
  208.       int compiled = 0;
  209. ***************
  210. *** 310,316 ****
  211. --- 397,408 ----
  212.       struct sed_label *go,*lbl;
  213.   
  214.       myname=argv[0];
  215. + 
  216. + #ifdef MSDOS
  217. +     while((opt=getopt(argc,argv,"ne:f:CV"))!=EOF) {
  218. + #else
  219.       while((opt=getopt(argc,argv,"ne:f:"))!=EOF) {
  220. + #endif
  221.           switch(opt) {
  222.           case 'n':
  223.               if(no_default_output)
  224. ***************
  225. *** 325,332 ****
  226. --- 417,442 ----
  227.               compile_file(optarg);
  228.               compiled++;
  229.               break;
  230. + #ifdef MSDOS
  231. +         case 'C':
  232. +             fprintf (stderr, COPYING);
  233. +             exit (0);
  234. +             break;
  235. +         case 'V':
  236. +             fprintf (stderr, VERSION);
  237. +             exit (0);
  238. +             break;
  239. +         default:
  240. +             fprintf (stderr, USAGE, myname);
  241. +             exit (4);
  242. +             break;
  243. + #endif /* MSDOS */
  244.           }
  245.       }
  246. + #ifdef MSDOS
  247. +     if (setvbuf (stdout, NULL, _IOFBF, STDIO_BUFSIZE) != 0)
  248. +       panic ("can't adjust buffering for /dev/stdout");
  249. + #endif
  250.       if(!compiled) {
  251.           if(argc<=optind)
  252.               panic("No program to run\n");
  253. ***************
  254. *** 373,378 ****
  255. --- 483,489 ----
  256.   
  257.   /* 'str' is a string (from the command line) that contains a sed command.
  258.      Compile the command, and add it to the end of 'the_program' */
  259. + void
  260.   compile_string(str)
  261.   char *str;
  262.   {
  263. ***************
  264. *** 385,390 ****
  265. --- 496,502 ----
  266.   
  267.   /* 'str' is the name of a file containing sed commands.  Read them in
  268.      and add them to the end of 'the_program' */
  269. + void
  270.   compile_file(str)
  271.   char *str;
  272.   {
  273. ***************
  274. *** 685,690 ****
  275. --- 797,803 ----
  276.   }
  277.   
  278.   /* Complain about a programming error and exit. */
  279. + void
  280.   bad_prog(why)
  281.   char *why;
  282.   {
  283. ***************
  284. *** 748,754 ****
  285. --- 861,871 ----
  286.   {
  287.       int    ch;
  288.       int    num;
  289. + #ifdef MSDOS
  290. +     char    *b;
  291. + #else
  292.       char    *b,*init_buffer();
  293. + #endif
  294.   
  295.       ch=inchar();
  296.   
  297. ***************
  298. *** 783,788 ****
  299. --- 900,906 ----
  300.   
  301.   void
  302.   compile_regex (slash)
  303. +   int slash;
  304.   {
  305.       VOID *b;
  306.       int ch;
  307. ***************
  308. *** 839,846 ****
  309. --- 957,973 ----
  310.       if(size_buffer(b)) {
  311.           last_regex=(struct re_pattern_buffer *)ck_malloc(sizeof(struct re_pattern_buffer));
  312.           last_regex->allocated=size_buffer(b);
  313. + #ifdef MSDOS
  314. +         last_regex->buffer
  315. +           = ck_malloc ((size_t) last_regex->allocated);
  316. + #else
  317.           last_regex->buffer=ck_malloc(last_regex->allocated);
  318. + #endif
  319. + #ifdef __LOOSE_WITHOUT_FASTMAP__    /* who would want to ??? */
  320.           last_regex->fastmap=0;
  321. + #else
  322. +         last_regex->fastmap = ck_malloc (1 << BYTEWIDTH);
  323. + #endif
  324.           last_regex->translate=0;
  325.           re_compile_pattern(get_buffer(b),size_buffer(b),last_regex);
  326.       } else if(!last_regex)
  327. ***************
  328. *** 881,886 ****
  329. --- 1008,1014 ----
  330.      opened if it isn't already open. */
  331.   FILE *
  332.   compile_filename(readit)
  333. +   int readit;
  334.   {
  335.       char *file_name;
  336.       int n;
  337. ***************
  338. *** 935,943 ****
  339. --- 1063,1073 ----
  340.       else {
  341.           input_file=fopen(name,"r");
  342.           if(input_file==0) {
  343. + #ifndef MSDOS
  344.               extern int errno;
  345.               extern char *sys_errlist[];
  346.               extern int sys_nerr;
  347. + #endif
  348.   
  349.               char *ptr;
  350.   
  351. ***************
  352. *** 948,953 ****
  353. --- 1078,1088 ----
  354.               return;
  355.           }
  356.       }
  357. + #ifdef MSDOS
  358. +     if (setvbuf (input_file, NULL, _IOFBF, STDIO_BUFSIZE) != 0)
  359. +       panic ("can't adjust buffering for %s",
  360. +          (*name=='-' && name[1]=='\0') ? "/dev/stdin" : name);
  361. + #endif
  362.       while(read_pattern_space()) {
  363.           execute_program(the_program);
  364.           if(!no_default_output)
  365. ***************
  366. *** 1162,1168 ****
  367. --- 1297,1309 ----
  368.                   char *tmp;
  369.   
  370.                   tmp=memchr(line.text,'\n',line.length);
  371. + #ifdef __BUG__
  372. +                 /* this can't be true! obviously copied from 'D'
  373. +                    (where it is correct). [tho] */
  374.                   ck_fwrite(line.text,1,line.length-(tmp-line.text),stdout);
  375. + #else /* FIXED */
  376. +                 ck_fwrite(line.text,1,tmp-line.text,stdout);
  377. + #endif /* FIXED */
  378.               }
  379.               break;
  380.   
  381. ***************
  382. *** 1259,1265 ****
  383. --- 1400,1413 ----
  384.               if(!count)
  385.                   break;
  386.               replaced=1;
  387. + #ifdef __BUG__
  388. +             /* This is wrong (at least with the new regex library)
  389. +                after the last (failed!) re_search() the registers
  390. +                will be set to -1!  [tho] */
  391.               str_append(&tmp,line.text+regs.end[0],line.length-regs.end[0]);
  392. + #else /* FIXED */
  393. +             str_append(&tmp,line.text+start,line.length-start);
  394. + #endif /* FIXED */
  395.               t.text=line.text;
  396.               t.length=line.length;
  397.               t.alloc=line.alloc;
  398. ***************
  399. *** 1503,1510 ****
  400. --- 1651,1664 ----
  401.   #include "stdarg.h"
  402.   
  403.   /* Print an error message and exit */
  404. + #ifdef MSDOS
  405. + void
  406. + panic (char *str, ...)
  407. + #else /* not MSDOS */
  408. + void
  409.   panic(str)
  410.   char *str;
  411. + #endif /* not MSDOS */
  412.   {
  413.       va_list iggy;
  414.   
  415. ***************
  416. *** 1520,1526 ****
  417.       exit(4);
  418.   }
  419.   
  420. ! #else
  421.   #include "varargs.h"
  422.   
  423.   panic(str,va_alist)
  424. --- 1674,1680 ----
  425.       exit(4);
  426.   }
  427.   
  428. ! #else /* not __STDC__ */
  429.   #include "varargs.h"
  430.   
  431.   panic(str,va_alist)
  432. ***************
  433. *** 1541,1547 ****
  434.       exit(4);
  435.   }
  436.   
  437. ! #endif
  438.   
  439.   /* Store information about files opened with ck_fopen
  440.      so that error messages from ck_fread, etc can print the
  441. --- 1695,1701 ----
  442.       exit(4);
  443.   }
  444.   
  445. ! #endif /* not __STDC__ */
  446.   
  447.   /* Store information about files opened with ck_fopen
  448.      so that error messages from ck_fread, etc can print the
  449. ***************
  450. *** 1599,1604 ****
  451. --- 1753,1762 ----
  452.           __id_s[n].name=(char *)ck_malloc(strlen(name)+1);
  453.           strcpy(__id_s[n].name,name);
  454.       }
  455. + #ifdef MSDOS
  456. +     if (setvbuf (ret, NULL, _IOFBF, STDIO_BUFSIZE) != 0)
  457. +       panic ("can't adjust buffering for %s", name);
  458. + #endif
  459.       return ret;
  460.   }
  461.   
  462. ***************
  463. *** 1628,1634 ****
  464. --- 1786,1794 ----
  465.   int size;
  466.   {
  467.       VOID *ret;
  468. + #ifndef MSDOS
  469.       VOID *malloc();
  470. + #endif
  471.   
  472.       ret=malloc(size);
  473.       if(ret==(VOID *)0)
  474. ***************
  475. *** 1643,1649 ****
  476. --- 1803,1811 ----
  477.   int size;
  478.   {
  479.       VOID *ret;
  480. + #ifndef MSDOS
  481.       VOID *realloc();
  482. + #endif
  483.   
  484.       ret=realloc(ptr,size);
  485.       if(ret==(VOID *)0)
  486. ***************
  487. *** 1651,1656 ****
  488. --- 1813,1820 ----
  489.       return ret;
  490.   }
  491.   
  492. + #ifndef MSDOS
  493. + 
  494.   /* Return a malloc()'d copy of a string */
  495.   char *
  496.   strdup(str)
  497. ***************
  498. *** 1682,1688 ****
  499. --- 1846,1857 ----
  500.       scan = (char *)s;
  501.       uc = (ucharwanted&0xFF);
  502.       for (n = size; n > 0; n--)
  503. + #ifdef __BUG__
  504. +         /* Nope, '==' has higher precedence than '&' ... [tho]  */
  505.           if ((*scan)&0xFF == uc)
  506. + #else /* FIXED */
  507. +         if ( ((*scan)&0xFF) == uc)
  508. + #endif /* FIXED */
  509.               return((VOID *)scan);
  510.           else
  511.               scan++;
  512. ***************
  513. *** 1721,1726 ****
  514. --- 1890,1897 ----
  515.   
  516.       return(dst);
  517.   }
  518. + 
  519. + #endif /* not MSDOS */
  520.   
  521.   /* Implement a variable sized buffer of 'stuff'.  We don't know what it is,
  522.      nor do we care, as long as it doesn't mind being aligned by malloc. */
  523.