home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / editor / sed / patches.os2 < prev    next >
Encoding:
Text File  |  1994-01-31  |  12.5 KB  |  520 lines
  1. diff -cb orig/glob.c ./glob.c
  2. *** orig/glob.c    Tue Mar 20 19:08:38 1990
  3. --- ./glob.c    Fri Dec 22 21:43:52 1989
  4. ***************
  5. *** 27,37 ****
  6. --- 27,41 ----
  7.   #define    D_NAMLEN(d) strlen((d)->d_name)
  8.   #else    /* not USGr3    */
  9.   #define D_NAMLEN(d) ((d)->d_namlen)
  10. + #ifdef MSDOS
  11. + #include "dir.h"
  12. + #else
  13.   #ifdef    USG
  14.   #include "ndir.h"   /* Get ndir.h from the Emacs distribution.  */
  15.   #else    /* not USG    */
  16.   #include <sys/dir.h>
  17.   #endif    /* USG        */
  18. + #endif
  19.   #endif    /* USGr3    */
  20.   
  21.   #ifdef USG
  22. ***************
  23. *** 40,47 ****
  24.   #define bcopy(s, d, n) ((void) memcpy ((d), (s), (n)))
  25.   #define rindex strrchr
  26.   struct passwd *getpwent(), *getpwuid(), *getpwnam();
  27. ! 
  28.   extern char *memcpy ();
  29.   #else /* not USG */
  30.   #include <strings.h>
  31.   
  32. --- 44,52 ----
  33.   #define bcopy(s, d, n) ((void) memcpy ((d), (s), (n)))
  34.   #define rindex strrchr
  35.   struct passwd *getpwent(), *getpwuid(), *getpwnam();
  36. ! #ifndef MSDOS
  37.   extern char *memcpy ();
  38. + #endif
  39.   #else /* not USG */
  40.   #include <strings.h>
  41.   
  42. ***************
  43. *** 58,64 ****
  44. --- 63,71 ----
  45.   #endif    /* sparc.  */
  46.   #endif    /* GCC.  */
  47.   
  48. + #ifndef MSDOS
  49.   #include <pwd.h>
  50. + #endif
  51.   
  52.   extern char *malloc (), *realloc ();
  53.   extern void free ();
  54. ***************
  55. *** 410,415 ****
  56. --- 417,423 ----
  57.         ++filename;
  58.       }
  59.   
  60. + #ifndef MSDOS
  61.     if (glob_tilde && *pathname == '~')
  62.       {
  63.         if (directory_len == 0)
  64. ***************
  65. *** 455,461 ****
  66.           }
  67.       }
  68.       }
  69. !   else if (glob_pattern_p (directory_name))
  70.       {
  71.         /* If directory_name contains globbing characters, then we
  72.        have to expand the previous levels.  Just recurse. */
  73. --- 463,471 ----
  74.           }
  75.       }
  76.       }
  77. !   else
  78. ! #endif
  79. !      if (glob_pattern_p (directory_name))
  80.       {
  81.         /* If directory_name contains globbing characters, then we
  82.        have to expand the previous levels.  Just recurse. */
  83. diff -cb orig/regex.c ./regex.c
  84. *** orig/regex.c    Tue Mar 20 19:08:42 1990
  85. --- ./regex.c    Tue Mar 20 18:58:30 1990
  86. ***************
  87. *** 55,60 ****
  88. --- 55,65 ----
  89.   #endif
  90.   #endif
  91.   
  92. + #ifdef MSDOS
  93. + #include <memory.h>
  94. + #include <malloc.h>
  95. + #endif
  96. + 
  97.   /*
  98.    * Define the syntax stuff, so we can do the \<...\> things.
  99.    */
  100. ***************
  101. *** 165,170 ****
  102. --- 170,176 ----
  103.   
  104.   #define PATUNFETCH p--
  105.   
  106. + #ifndef MSDOS
  107.   #define EXTEND_BUFFER                            \
  108.     { char *old_buffer = bufp->buffer;                    \
  109.       if (bufp->allocated == (1L<<16)) goto too_big;            \
  110. ***************
  111. *** 182,187 ****
  112. --- 188,212 ----
  113.       if (pending_exact)                            \
  114.         pending_exact = (pending_exact - old_buffer) + bufp->buffer;    \
  115.     }
  116. + #else
  117. + #define EXTEND_BUFFER                            \
  118. +   { char *old_buffer = bufp->buffer;                    \
  119. +     if (bufp->allocated == (1L<<15)) goto too_big;                      \
  120. +     bufp->allocated *= 2;                        \
  121. +     if (bufp->allocated > (1L<<15)) bufp->allocated = (1L<<15);         \
  122. +     bufp->buffer = (char *) realloc (bufp->buffer, bufp->allocated);    \
  123. +     if (bufp->buffer == 0)                        \
  124. +       goto memory_exhausted;                        \
  125. +     b = (b - old_buffer) + bufp->buffer;                \
  126. +     if (fixup_jump)                            \
  127. +       fixup_jump = (fixup_jump - old_buffer) + bufp->buffer;        \
  128. +     if (laststart)                            \
  129. +       laststart = (laststart - old_buffer) + bufp->buffer;        \
  130. +     begalt = (begalt - old_buffer) + bufp->buffer;            \
  131. +     if (pending_exact)                            \
  132. +       pending_exact = (pending_exact - old_buffer) + bufp->buffer;    \
  133. +   }
  134. + #endif
  135.   
  136.   static int store_jump (), insert_jump ();
  137.   
  138. ***************
  139. *** 256,262 ****
  140.   #endif
  141.   #endif
  142.   
  143. !   if (bufp->allocated == 0)
  144.       {
  145.         bufp->allocated = 28;
  146.         if (bufp->buffer)
  147. --- 281,287 ----
  148.   #endif
  149.   #endif
  150.   
  151. !   if (bufp->allocated < 10)
  152.       {
  153.         bufp->allocated = 28;
  154.         if (bufp->buffer)
  155. diff -cb orig/sed.c ./sed.c
  156. *** orig/sed.c    Tue Mar 20 19:08:48 1990
  157. --- ./sed.c    Tue Mar 20 19:13:10 1990
  158. ***************
  159. *** 296,302 ****
  160.   static char NO_ADDR[] = "Command doesn't take any addresses";
  161.   static char LINE_JUNK[] ="Extra characters after command";
  162.   static char BAD_EOF[] =  "Unexpected End-of-file";
  163. ! static char USAGE[] =   "Usage: %s [-n] [-e script...] [-f sfile...] [file...]\n";
  164.   static char NO_REGEX[] = "No previous regular expression";
  165.   
  166.   /* Yes, the main program, which parses arguments, and does the right thing with them,
  167. --- 296,302 ----
  168.   static char NO_ADDR[] = "Command doesn't take any addresses";
  169.   static char LINE_JUNK[] ="Extra characters after command";
  170.   static char BAD_EOF[] =  "Unexpected End-of-file";
  171. ! static char USAGE[] =   "Usage: %s [-n] [-e script...] [-f sfile...] [file...]";
  172.   static char NO_REGEX[] = "No previous regular expression";
  173.   
  174.   /* Yes, the main program, which parses arguments, and does the right thing with them,
  175. ***************
  176. *** 309,319 ****
  177.       struct sed_label *go,*lbl;
  178.   
  179.           myname=argv[0];
  180.           while((opt=getopt(argc,argv,"ne:f:"))!=EOF) {
  181.           switch(opt) {
  182.           case 'n':
  183.                           if(no_default_output)
  184. !                 panic(USAGE);
  185.               no_default_output++;
  186.               break;
  187.           case 'e':
  188. --- 309,322 ----
  189.       struct sed_label *go,*lbl;
  190.   
  191.           myname=argv[0];
  192. +         if ( argc == 1 )
  193. +           usage();
  194. + 
  195.           while((opt=getopt(argc,argv,"ne:f:"))!=EOF) {
  196.           switch(opt) {
  197.           case 'n':
  198.                           if(no_default_output)
  199. !                                 usage();
  200.               no_default_output++;
  201.               break;
  202.           case 'e':
  203. ***************
  204. *** 328,334 ****
  205.       }
  206.       if(!compiled) {
  207.           if(argc<=optind)
  208. !             panic("No program to run\n");
  209.           compile_string(argv[optind]);
  210.           optind++;
  211.       }
  212. --- 331,337 ----
  213.       }
  214.       if(!compiled) {
  215.           if(argc<=optind)
  216. !                         panic("No program to run");
  217.           compile_string(argv[optind]);
  218.           optind++;
  219.       }
  220. ***************
  221. *** 338,344 ****
  222.               if(!strcmp(lbl->name,go->name))
  223.                   break;
  224.           if(!lbl)
  225. !             panic("Can't find label for jump to '%s'\n",go->name);
  226.           go->v->v[go->v_index].x.jump=lbl;
  227.       }
  228.   
  229. --- 341,347 ----
  230.               if(!strcmp(lbl->name,go->name))
  231.                   break;
  232.           if(!lbl)
  233. !                         panic("Can't find label for jump to '%s'",go->name);
  234.           go->v->v[go->v_index].x.jump=lbl;
  235.       }
  236.   
  237. ***************
  238. *** 396,402 ****
  239. --- 399,432 ----
  240.       if(str[0]=='-' && str[1]=='\0')
  241.           prog_file=stdin;
  242.           else
  243. + #ifdef OS2
  244. +         {
  245. +                 char fname[256];
  246. + 
  247. +                 _searchenv(str, "INIT", fname);
  248. +                 if ( fname[0] == 0 )
  249. +                   _searchenv(str, "PATH", fname);
  250. +                 if ( fname[0] == 0 )
  251. +                   strcpy(fname,str);
  252. + 
  253. +                 prog_file=ck_fopen(fname,"r");
  254. +         }
  255. + #else
  256.                   prog_file=ck_fopen(str,"r");
  257. + #endif
  258. + 
  259. + #ifdef OS2
  260. +         if ( !isatty(fileno(prog_file)) )
  261. +         {
  262. +           char line[80];
  263. + 
  264. +           fgets(line, sizeof(line), prog_file);
  265. + 
  266. +           if ( strnicmp(line, "extproc ", 8) != 0 )
  267. +             rewind(prog_file);
  268. +         }
  269. + #endif
  270. + 
  271.       ch=getc(prog_file);
  272.       if(ch=='#') {
  273.           ch=getc(prog_file);
  274. ***************
  275. *** 729,737 ****
  276.   char *why;
  277.   {
  278.       if(prog_line)
  279. !         fprintf(stderr,"%s: file %s line %d: %s\n",myname,prog_name,prog_line,why);
  280.       else
  281. !         fprintf(stderr,"%s: %s\n",myname,why);
  282.       exit(1);
  283.   }
  284.   
  285. --- 759,767 ----
  286.   char *why;
  287.   {
  288.       if(prog_line)
  289. !                 fprintf(stderr,"\n%s: file %s line %d: %s\n",myname,prog_name,prog_line,why);
  290.       else
  291. !                 fprintf(stderr,"\n%s: %s\n",myname,why);
  292.       exit(1);
  293.   }
  294.   
  295. ***************
  296. *** 935,941 ****
  297.   
  298.               ptr=(errno>=0 && errno<sys_nerr) ? sys_errlist[errno] : "Unknown error code";
  299.               bad_input++;
  300. !             fprintf(stderr,"%s: can't read %s: %s\n",myname,name,ptr);
  301.   
  302.               return;
  303.           }
  304. --- 965,971 ----
  305.   
  306.               ptr=(errno>=0 && errno<sys_nerr) ? sys_errlist[errno] : "Unknown error code";
  307.               bad_input++;
  308. !                         fprintf(stderr,"\n%s: can't read %s: %s\n",myname,name,ptr);
  309.   
  310.               return;
  311.           }
  312. ***************
  313. *** 1126,1132 ****
  314.                           width+=2;
  315.                           break;
  316.                       default:
  317. !                         printf("/%02x",(*tmp)&0xFF);
  318.                           width+=2;
  319.                           break;
  320.                       }
  321. --- 1156,1162 ----
  322.                           width+=2;
  323.                           break;
  324.                       default:
  325. !                                                 printf("\\x%02x",(*tmp)&0xFF);
  326.                           width+=2;
  327.                           break;
  328.                       }
  329. ***************
  330. *** 1177,1183 ****
  331.                       }
  332.                   }
  333.                   if(ferror(cur_cmd->x.io_file))
  334. !                     panic("Read error on input file to 'r' command\n");
  335.               }
  336.               break;
  337.   
  338. --- 1207,1213 ----
  339.                       }
  340.                   }
  341.                   if(ferror(cur_cmd->x.io_file))
  342. !                                         panic("Read error on input file to 'r' command");
  343.               }
  344.               break;
  345.   
  346. ***************
  347. *** 1306,1312 ****
  348.               break;
  349.   
  350.           default:
  351. !             panic("INTERNAL ERROR: Bad cmd %c\n",cur_cmd->cmd);
  352.           }
  353.           if(end_cycle)
  354.               break;
  355. --- 1336,1342 ----
  356.               break;
  357.   
  358.           default:
  359. !                         panic("INTERNAL ERROR: Bad cmd %c",cur_cmd->cmd);
  360.           }
  361.           if(end_cycle)
  362.               break;
  363. ***************
  364. *** 1337,1343 ****
  365.           return (input_EOF) ? 1 : 0;
  366.   
  367.       default:
  368. !         panic("INTERNAL ERROR: bad address type\n");
  369.           break;
  370.       }
  371.       return -1;
  372. --- 1367,1373 ----
  373.           return (input_EOF) ? 1 : 0;
  374.   
  375.       default:
  376. !                 panic("INTERNAL ERROR: bad address type");
  377.           break;
  378.       }
  379.       return -1;
  380. ***************
  381. *** 1491,1496 ****
  382. --- 1521,1538 ----
  383.   /* These routines were written as part of a library (by me), but since most
  384.      people don't have the library, here they are.  */
  385.   
  386. + usage()
  387. + {
  388. +         printf("\n%s\n\n", version_string);
  389. +         printf(USAGE,myname);
  390. + 
  391. +         printf("\n\n  -n          no default output"
  392. +                "\n  -e script   read script as a sed command"
  393. +                "\n  -f file     read sed commands contained in file\n");
  394. + 
  395. +     exit(4);
  396. + }
  397. + 
  398.   #ifdef __STDC__
  399.   #include "stdarg.h"
  400.   
  401. ***************
  402. *** 1501,1507 ****
  403.       va_list iggy;
  404.   
  405.       va_start(iggy,str);
  406. !     fprintf(stderr,"%s: ",myname);
  407.   #ifdef NO_VFPRINTF
  408.       _doprnt(str,&iggy,stderr);
  409.   #else
  410. --- 1543,1549 ----
  411.       va_list iggy;
  412.   
  413.       va_start(iggy,str);
  414. !         fprintf(stderr,"\n%s: ",myname);
  415.   #ifdef NO_VFPRINTF
  416.       _doprnt(str,&iggy,stderr);
  417.   #else
  418. ***************
  419. *** 1522,1528 ****
  420.       va_list iggy;
  421.   
  422.       va_start(iggy);
  423. !     fprintf(stderr,"%s: ",myname);
  424.   #ifdef NO_VFPRINTF
  425.       _doprnt(str,&iggy,stderr);
  426.   #else
  427. --- 1564,1570 ----
  428.       va_list iggy;
  429.   
  430.       va_start(iggy);
  431. !         fprintf(stderr,"\n%s: ",myname);
  432.   #ifdef NO_VFPRINTF
  433.       _doprnt(str,&iggy,stderr);
  434.   #else
  435. ***************
  436. *** 1572,1578 ****
  437.   
  438.       ret=fopen(name,mode);
  439.       if(ret==(FILE *)0)
  440. !         panic("Couldn't open file %s\n",name);
  441.       for(n=0;n<N_FILE;n++) {
  442.           if(ret==__id_s[n].fp) {
  443.               free((VOID *)__id_s[n].name);
  444. --- 1614,1620 ----
  445.   
  446.       ret=fopen(name,mode);
  447.       if(ret==(FILE *)0)
  448. !                 panic("Couldn't open file %s",name);
  449.       for(n=0;n<N_FILE;n++) {
  450.           if(ret==__id_s[n].fp) {
  451.               free((VOID *)__id_s[n].name);
  452. ***************
  453. *** 1586,1592 ****
  454.               if(__id_s[n].fp==(FILE *)0)
  455.                   break;
  456.           if(n==N_FILE)
  457. !             panic("Internal error: too many files open\n");
  458.           __id_s[n].fp=ret;
  459.           __id_s[n].name=(char *)ck_malloc(strlen(name)+1);
  460.           strcpy(__id_s[n].name,name);
  461. --- 1628,1634 ----
  462.               if(__id_s[n].fp==(FILE *)0)
  463.                   break;
  464.           if(n==N_FILE)
  465. !                         panic("Internal error: too many files open");
  466.           __id_s[n].fp=ret;
  467.           __id_s[n].name=(char *)ck_malloc(strlen(name)+1);
  468.           strcpy(__id_s[n].name,name);
  469. ***************
  470. *** 1611,1617 ****
  471.   FILE *stream;
  472.   {
  473.       if(fclose(stream)==EOF)
  474. !         panic("Couldn't close %s\n",__fp_name(stream));
  475.   }
  476.   
  477.   /* Panic on failing malloc */
  478. --- 1653,1659 ----
  479.   FILE *stream;
  480.   {
  481.       if(fclose(stream)==EOF)
  482. !                 panic("Couldn't close %s",__fp_name(stream));
  483.   }
  484.   
  485.   /* Panic on failing malloc */
  486. ***************
  487. *** 1624,1630 ****
  488.   
  489.       ret=malloc(size);
  490.       if(ret==(VOID *)0)
  491. !         panic("Couldn't allocate memory\n");
  492.       return ret;
  493.   }
  494.   
  495. --- 1666,1672 ----
  496.   
  497.       ret=malloc(size);
  498.       if(ret==(VOID *)0)
  499. !                 panic("Couldn't allocate memory");
  500.       return ret;
  501.   }
  502.   
  503. ***************
  504. *** 1639,1645 ****
  505.   
  506.       ret=realloc(ptr,size);
  507.       if(ret==(VOID *)0)
  508. !         panic("Couldn't re-allocate memory\n");
  509.       return ret;
  510.   }
  511.   
  512. --- 1681,1687 ----
  513.   
  514.       ret=realloc(ptr,size);
  515.       if(ret==(VOID *)0)
  516. !                 panic("Couldn't re-allocate memory");
  517.       return ret;
  518.   }
  519.   
  520.