home *** CD-ROM | disk | FTP | other *** search
/ Mega CD-ROM 1 / megacd_rom_1.zip / megacd_rom_1 / GNUISH / INDENT11.ZIP / PATCHES < prev    next >
Text File  |  1990-09-23  |  52KB  |  1,833 lines
  1. diff -cBdNp e:/gnu/indent/gnu/args.c ./args.c
  2. *** e:/gnu/indent/gnu/args.c    Mon Jul 02 20:39:16 1990
  3. --- ./args.c    Mon Jul 02 20:39:26 1990
  4. ***************
  5. *** 18,23 ****
  6. --- 18,40 ----
  7.    * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  8.    */
  9.   
  10. + /*
  11. +  * MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  12. +  *
  13. +  * To this port, the same copying conditions apply as to the
  14. +  * original release.
  15. +  *
  16. +  * IMPORTANT:
  17. +  * This file is not identical to the original GNU release!
  18. +  * You should have received this code as patch to the official
  19. +  * GNU release.
  20. +  *
  21. +  * MORE IMPORTANT:
  22. +  * This port comes with ABSOLUTELY NO WARRANTY.
  23. +  *
  24. +  * $Header: e:/gnu/indent/RCS/args.c'v 1.1.0.2 90/07/02 10:32:18 tho Exp $
  25. +  */
  26. + 
  27.   #ifndef lint
  28.   static char sccsid[] = "@(#)args.c    5.8 (Berkeley) 5/15/89";
  29.   #endif /* not lint */
  30. *************** struct pro {
  31. *** 157,166 ****
  32. --- 174,190 ----
  33.   struct pro pro[] = {
  34.   
  35.       {"T", PRO_KEY, 0, ONOFF_NA, 0, &exp_T},
  36. + #ifdef MSDOS
  37. +     {"bacc", PRO_BOOL, false, ON,
  38. +       &blanklines_around_cond_comp, &exp_bacc},
  39. +     {"badp", PRO_BOOL, false, ON,
  40. +        &blanklin_after_decl_proctop, &exp_badp},
  41. + #else
  42.       {"bacc", PRO_BOOL, false, ON,
  43.         &blanklines_around_conditional_compilation, &exp_bacc},
  44.       {"badp", PRO_BOOL, false, ON,
  45.          &blanklines_after_declarations_at_proctop, &exp_badp},
  46. + #endif /* MSDOS */
  47.       {"bad", PRO_BOOL, false, ON, &blanklines_after_declarations, &exp_bad},
  48.       {"bap", PRO_BOOL, false, ON, &blanklines_after_procs, &exp_bap},
  49.       {"bbb", PRO_BOOL, false, ON, &blanklines_before_blockcomments, &exp_bbb},
  50. *************** struct pro pro[] = {
  51. *** 203,212 ****
  52. --- 227,243 ----
  53.       {"lc", PRO_INT, 0, ONOFF_NA, &block_comment_max_col, &exp_lc},
  54.       {"lp", PRO_BOOL, true, ON, &lineup_to_parens, &exp_lp},
  55.       {"l", PRO_INT, 78, ONOFF_NA, &max_col, &exp_l},
  56. + #ifdef MSDOS
  57.       {"nbacc", PRO_BOOL, false, OFF,
  58. +        &blanklines_around_cond_comp, &exp_bacc},
  59. +     {"nbadp", PRO_BOOL, false, OFF,
  60. +        &blanklin_after_decl_proctop, &exp_badp},
  61. + #else
  62. +     {"nbacc", PRO_BOOL, false, OFF,
  63.          &blanklines_around_conditional_compilation, &exp_bacc},
  64.       {"nbadp", PRO_BOOL, false, OFF,
  65.          &blanklines_after_declarations_at_proctop, &exp_badp},
  66. + #endif /* MSDOS */
  67.       {"nbad", PRO_BOOL, false, OFF, &blanklines_after_declarations, &exp_bad},
  68.       {"nbap", PRO_BOOL, false, OFF, &blanklines_after_procs, &exp_bap},
  69.       {"nbbb", PRO_BOOL, false, OFF, &blanklines_before_blockcomments, &exp_bbb},
  70. *************** struct pro pro[] = {
  71. *** 249,257 ****
  72. --- 280,300 ----
  73.    * set_profile reads $HOME/.indent.pro and ./.indent.pro and handles arguments
  74.    * given in these files.
  75.    */
  76. + void
  77.   set_profile()
  78.   {
  79.       register FILE *f;
  80. + #ifdef MSDOS
  81. +     static char prof[] = "indent.pro";
  82. +     char fname[_MAX_PATH],
  83. +      device[_MAX_DRIVE],
  84. +      homedir[_MAX_DIR],
  85. +      filename[_MAX_FNAME],
  86. +      ext[_MAX_EXT];
  87. +                     /* look for profile in indent's dir */
  88. +     _splitpath( my_name, device, homedir, filename, ext);
  89. +     _makepath( fname, device, homedir, prof, "");
  90. + #else
  91.       char *fname;
  92.       static char prof[] = ".indent.pro";
  93.       char *homedir;
  94. *************** set_profile()
  95. *** 259,264 ****
  96. --- 302,309 ----
  97.       homedir = getenv("HOME");
  98.       fname = xmalloc(strlen(homedir) + 10 + sizeof prof);
  99.       sprintf(fname, "%s/%s", homedir, prof);
  100. + #endif
  101. + 
  102.       if ((f = fopen(option_source = fname, "r")) != NULL) {
  103.       scan_profile(f);
  104.       (void) fclose(f);
  105. *************** set_profile()
  106. *** 271,276 ****
  107. --- 316,322 ----
  108.       free (fname);
  109.   }
  110.   
  111. + void
  112.   scan_profile(f)
  113.       register FILE *f;
  114.   {
  115. *************** scan_profile(f)
  116. *** 279,285 ****
  117.       char        buf[BUFSIZ];
  118.   
  119.       while (1) {
  120. !     for (p = buf; (i = getc(f)) != EOF && (*p = i) > ' '; ++p);
  121.       if (p != buf) {
  122.           *p++ = 0;
  123.           if (verbose)
  124. --- 325,331 ----
  125.       char        buf[BUFSIZ];
  126.   
  127.       while (1) {
  128. !     for (p = buf; (i = getc(f)) != EOF && (*p = (char) i) > ' '; ++p);
  129.       if (p != buf) {
  130.           *p++ = 0;
  131.           if (verbose)
  132. *************** eqin(s1, s2, start_param)
  133. *** 311,316 ****
  134. --- 357,363 ----
  135.   /*
  136.    * Set the defaults.
  137.    */
  138. + void
  139.   set_defaults()
  140.   {
  141.       register struct pro *p;
  142. *************** set_defaults()
  143. *** 325,330 ****
  144. --- 372,378 ----
  145.      specified (as opposed to being taken from a PRO_SETTINGS group of
  146.      settings).  */
  147.   
  148. + void
  149.   set_option (arg, explicit)
  150.        char *arg;
  151.        int explicit;
  152. diff -cBdNp e:/gnu/indent/gnu/globs.c ./globs.c
  153. *** e:/gnu/indent/gnu/globs.c    Mon Jul 02 20:39:18 1990
  154. --- ./globs.c    Mon Jul 02 20:39:26 1990
  155. ***************
  156. *** 15,24 ****
  157. --- 15,53 ----
  158.    * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  159.    */
  160.   
  161. + /*
  162. +  * MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  163. +  *
  164. +  * To this port, the same copying conditions apply as to the
  165. +  * original release.
  166. +  *
  167. +  * IMPORTANT:
  168. +  * This file is not identical to the original GNU release!
  169. +  * You should have received this code as patch to the official
  170. +  * GNU release.
  171. +  *
  172. +  * MORE IMPORTANT:
  173. +  * This port comes with ABSOLUTELY NO WARRANTY.
  174. +  *
  175. +  * $Header: e:/gnu/indent/RCS/globs.c'v 1.1.0.4 90/07/02 20:25:09 tho Exp $
  176. +  */
  177. + 
  178.   #include "indent_globs.h"
  179.   
  180.   /* Like malloc but get error if no storage available.  */
  181.   
  182. + #ifdef MSDOS
  183. + void *xmalloc (size_t size)        /* cleaner anyway ... */
  184. + {
  185. +   register void *val = malloc (size);
  186. +   if (!val)
  187. +     {
  188. +       fprintf (stderr,"indent: Virtual memory exhausted.\n");
  189. +       exit (1);
  190. +     }
  191. +   return val;
  192. + }
  193. + #else /* not MSDOS */
  194.   char *
  195.   xmalloc (size)
  196.        long size;
  197. *************** xmalloc (size)
  198. *** 31,39 ****
  199. --- 60,81 ----
  200.       }
  201.     return val;
  202.   }
  203. + #endif /* not MSDOS */
  204.   
  205.   /* Like realloc but get error if no storage available.  */
  206.   
  207. + #ifdef MSDOS
  208. + void *xrealloc (void *ptr, size_t size)    /* cleaner anyway ... */
  209. + {
  210. +   register void *val = realloc (ptr, size);
  211. +   if (!val)
  212. +     {
  213. +       fprintf (stderr,"indent: Virtual memory exhausted.\n");
  214. +       exit (1);
  215. +     }
  216. +   return val;
  217. + }
  218. + #else /* not MSDOS */
  219.   char *
  220.   xrealloc (ptr, size)
  221.        char *ptr;
  222. *************** xrealloc (ptr, size)
  223. *** 47,52 ****
  224. --- 89,95 ----
  225.       }
  226.     return val;
  227.   }
  228. + #endif /* not MSDOS */
  229.   
  230.   /* Some systems lack memcpy so this does the same thing.
  231.      If your system-supplied memcpy is more efficient, you might want
  232. *************** xrealloc (ptr, size)
  233. *** 54,59 ****
  234. --- 97,103 ----
  235.   
  236.      Copy LEN bytes starting at SRCADDR to DESTADDR.  Result undefined
  237.      if the source overlaps with the destination.  */
  238. + #ifndef MSDOS
  239.   char *
  240.   mymemcpy (destaddr, srcaddr, len)
  241.        char *destaddr;
  242. *************** mymemcpy (destaddr, srcaddr, len)
  243. *** 64,66 ****
  244. --- 108,229 ----
  245.       *destaddr++ = *srcaddr++;
  246.     return destaddr;
  247.   }
  248. + #endif /* not MSDOS */
  249. + 
  250. + 
  251. + /* malloc a block of memory, with fatal error message if we can't do it. */
  252. + 
  253. + #ifdef M_I86HM
  254. + 
  255. + #include <dos.h>
  256. + 
  257. + void huge *
  258. + xhalloc (long size)
  259. + {
  260. +   void huge *value = (void huge *) halloc (size, (size_t)1 );
  261. + 
  262. +   if (!value)
  263. +     {
  264. +       fprintf (stderr, "indent: Virtual memory exhausted.\n");
  265. +       exit (1);
  266. +     }
  267. +   return value;
  268. + }
  269. + 
  270. + /* Here we do a huge "realloc" by allocating a new block and
  271. +    moving the old block afterwards.  This is *slow*, but should
  272. +    be reliable.  */
  273. + 
  274. + void huge *
  275. + xhrealloc (void huge *ptr, long new_size, long old_size)
  276. + {
  277. +   void huge *value = (void huge *) halloc (new_size, (size_t)1 );
  278. + 
  279. +   if (!value)
  280. +     {
  281. +       fprintf (stderr,"indent: Virtual memory exhausted.\n");
  282. +       exit (1);
  283. +     }
  284. +   else
  285. +     {
  286. +       char huge *dest = value;
  287. +       char huge *src = ptr;
  288. + 
  289. +       while (old_size > 0L)
  290. +     {
  291. +       unsigned int bytes = (unsigned int) min (0x8000L, old_size);
  292. +       memcpy (dest, src, bytes);
  293. +       old_size -= (long) bytes;
  294. +       dest += (long) bytes;
  295. +       src += (long) bytes;
  296. +     }
  297. +     }
  298. +   hfree (ptr);
  299. +   return value;
  300. + }
  301. + 
  302. + long        /* doesn't belong here, but is also a 'huge' pointer kludge */
  303. + hread (int fd, void huge *buffer, long bytes)
  304. + {
  305. +   long bytes_read = 0L;
  306. + 
  307. +   while (1)
  308. +     {
  309. +       int n = read (fd, buffer, (unsigned int) min (0x4000L, bytes));
  310. + 
  311. +       if (n > 0)
  312. +     {
  313. +       bytes_read += (long) n;
  314. +       bytes -= (long) n;
  315. +       /* we can't say buffer += n here, because we have to make
  316. +          sure that the offset of BUFFER doesn't overflow during
  317. +          the read() system call.  Therefore we add what we read
  318. +          to the segment of BUFFER.  */
  319. +       FP_SEG(buffer) += (n >> 4);
  320. +       FP_OFF(buffer) += (n & 0x0F);
  321. +     }
  322. +       else if (n == 0)
  323. +     return bytes_read;    /* done */
  324. +       else
  325. +     {
  326. +       perror ("indent: Error while reading input");
  327. +       exit (1);
  328. +     }
  329. +     }
  330. + }
  331. + 
  332. + 
  333. + long
  334. + hwrite (int fd, void huge *buffer, long bytes)
  335. + {
  336. +   long bytes_written = 0L;
  337. + 
  338. +   while (1)
  339. +     {
  340. +       unsigned int n = (unsigned int) min (0x4000L, bytes);
  341. +       unsigned int m = write (fd, buffer, n);
  342. + 
  343. +       if (m == n)
  344. +     {
  345. +       bytes_written += (long) m;
  346. +       bytes -= (long) m;
  347. + 
  348. +       if (bytes <= 0)
  349. +         return bytes_written;
  350. + 
  351. +       /* we can't say buffer += n here, because we have to make
  352. +          sure that the offset of BUFFER doesn't overflow during
  353. +          the read() system call.  Therefore we add what we read
  354. +          to the segment of BUFFER.  */
  355. +       FP_SEG(buffer) += (m >> 4);
  356. +       FP_OFF(buffer) += (m & 0x0F);
  357. +     }
  358. +       else
  359. +     {
  360. +       perror ("indent: Error while reading input");
  361. +       exit (1);
  362. +     }
  363. +     }
  364. + }
  365. + 
  366. + #endif /* M_I86HM */
  367. diff -cBdNp e:/gnu/indent/gnu/indent.c ./indent.c
  368. *** e:/gnu/indent/gnu/indent.c    Mon Jul 02 20:39:20 1990
  369. --- ./indent.c    Mon Jul 02 20:39:34 1990
  370. ***************
  371. *** 18,23 ****
  372. --- 18,40 ----
  373.    * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  374.    */
  375.   
  376. + /*
  377. +  * MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  378. +  *
  379. +  * To this port, the same copying conditions apply as to the
  380. +  * original release.
  381. +  *
  382. +  * IMPORTANT:
  383. +  * This file is not identical to the original GNU release!
  384. +  * You should have received this code as patch to the official
  385. +  * GNU release.
  386. +  *
  387. +  * MORE IMPORTANT:
  388. +  * This port comes with ABSOLUTELY NO WARRANTY.
  389. +  *
  390. +  * $Header: e:/gnu/indent/RCS/indent.c'v 1.1.0.3 90/07/02 20:25:11 tho Exp $
  391. +  */
  392. + 
  393.   #ifndef lint
  394.   char copyright[] =
  395.   "@(#) Copyright (c) 1985 Sun Microsystems, Inc.\n\
  396. *************** char       *out_name = 0;    /* will always
  397. *** 41,46 ****
  398. --- 58,64 ----
  399.   /* The following variables are documented in indent_globs.h.  */
  400.   int else_or_endif = false;
  401.   
  402. + void
  403.   main(argc, argv)
  404.       int         argc;
  405.       char      **argv;
  406. *************** main(argc, argv)
  407. *** 54,60 ****
  408.       int *di_stack;
  409.       /* Currently allocated size of di_stack.  */
  410.       int di_stack_alloc;
  411. !     
  412.       int         flushed_nl;    /* used when buffering up comments to remember
  413.                    * that a newline was passed over */
  414.       int         force_nl;    /* when true, code must be broken */
  415. --- 72,78 ----
  416.       int *di_stack;
  417.       /* Currently allocated size of di_stack.  */
  418.       int di_stack_alloc;
  419. ! 
  420.       int         flushed_nl;    /* used when buffering up comments to remember
  421.                    * that a newline was passed over */
  422.       int         force_nl;    /* when true, code must be broken */
  423. *************** main(argc, argv)
  424. *** 72,78 ****
  425.          decremented at the beginning of the loop, so it will reach zero
  426.          when the second token after the ')' is read.  */
  427.       int last_token_ends_sp = 0;
  428. !     
  429.       int         squest;        /* when this is positive, we have seen a ?
  430.                    * without the matching : in a <c>?<s>:<s>
  431.                    * construct */
  432. --- 90,96 ----
  433.          decremented at the beginning of the loop, so it will reach zero
  434.          when the second token after the ')' is read.  */
  435.       int last_token_ends_sp = 0;
  436. ! 
  437.       int         squest;        /* when this is positive, we have seen a ?
  438.                    * without the matching : in a <c>?<s>:<s>
  439.                    * construct */
  440. *************** main(argc, argv)
  441. *** 86,93 ****
  442. --- 104,121 ----
  443.       |              INITIALIZATION              |
  444.       \*-----------------------------------------------*/
  445.   
  446. + #ifdef MSDOS
  447. +     my_name = xmalloc( strlen(argv[0]) + 1 );        /* who am I?      */
  448. +     strcpy( my_name, argv[0] );
  449. + #endif /* MSDOS */
  450. + 
  451.       parser_state_tos = (struct parser_state *)
  452.         xmalloc(sizeof(struct parser_state));
  453. + 
  454. + #ifdef MSDOS
  455. +     memset(parser_state_tos,'\0',sizeof(struct parser_state));    /* tidy      */
  456. + #endif /* MSDOS */
  457. + 
  458.       parser_state_tos->next = 0;
  459.       /* Allocate initial stacks for the parser.  */
  460.       parser_state_tos->p_stack_size = INITIAL_STACK_SIZE;
  461. *************** main(argc, argv)
  462. *** 101,107 ****
  463.       parser_state_tos->paren_indents_size = 1;
  464.       parser_state_tos->paren_indents = (short *) xmalloc
  465.         (parser_state_tos->paren_indents_size * sizeof (short));
  466. !     
  467.       parser_state_tos->p_stack[0] = stmt;    /* this is the parser's stack */
  468.       parser_state_tos->last_nl = true;        /* this is true if the last thing scanned was
  469.                    * a newline */
  470. --- 129,135 ----
  471.       parser_state_tos->paren_indents_size = 1;
  472.       parser_state_tos->paren_indents = (short *) xmalloc
  473.         (parser_state_tos->paren_indents_size * sizeof (short));
  474. ! 
  475.       parser_state_tos->p_stack[0] = stmt;    /* this is the parser's stack */
  476.       parser_state_tos->last_nl = true;        /* this is true if the last thing scanned was
  477.                    * a newline */
  478. *************** main(argc, argv)
  479. *** 127,138 ****
  480.       sp_sw = force_nl = false;
  481.       parser_state_tos->in_or_st = false;
  482.       parser_state_tos->bl_line = true;
  483. !     
  484.       dec_ind = 0;
  485.       di_stack_alloc = 2;
  486.       di_stack = (int *)xmalloc (di_stack_alloc * sizeof (*di_stack));
  487.       di_stack[parser_state_tos->dec_nest = 0] = 0;
  488. !     
  489.       parser_state_tos->want_blank = parser_state_tos->in_stmt = parser_state_tos->ind_stmt = false;
  490.       parser_state_tos->procname = parser_state_tos->procname_end = "\0";
  491.   
  492. --- 155,166 ----
  493.       sp_sw = force_nl = false;
  494.       parser_state_tos->in_or_st = false;
  495.       parser_state_tos->bl_line = true;
  496. ! 
  497.       dec_ind = 0;
  498.       di_stack_alloc = 2;
  499.       di_stack = (int *)xmalloc (di_stack_alloc * sizeof (*di_stack));
  500.       di_stack[parser_state_tos->dec_nest = 0] = 0;
  501. ! 
  502.       parser_state_tos->want_blank = parser_state_tos->in_stmt = parser_state_tos->ind_stmt = false;
  503.       parser_state_tos->procname = parser_state_tos->procname_end = "\0";
  504.   
  505. *************** main(argc, argv)
  506. *** 296,302 ****
  507.                  necessary to keep track of the text between the if() and
  508.              the start of the statement which follows.  Use save_com
  509.              to do so.  */
  510. !         
  511.           switch (type_code) {
  512.           case newline:
  513.           ++line_no;
  514. --- 324,330 ----
  515.                  necessary to keep track of the text between the if() and
  516.              the start of the statement which follows.  Use save_com
  517.              to do so.  */
  518. ! 
  519.           switch (type_code) {
  520.           case newline:
  521.           ++line_no;
  522. *************** main(argc, argv)
  523. *** 318,324 ****
  524.              if (foo) {
  525.                / * comment here * /
  526.             */
  527. !           
  528.             save_com.ptr[0] = '{';
  529.   
  530.           else
  531. --- 346,352 ----
  532.              if (foo) {
  533.                / * comment here * /
  534.             */
  535. ! 
  536.             save_com.ptr[0] = '{';
  537.   
  538.           else
  539. *************** check_type:
  540. *** 543,549 ****
  541.           /* Do not put a space before the '{'.  */
  542.           parser_state_tos->want_blank = false;
  543.             }
  544. !         
  545.           /* Count parens so we know how deep we are.  */
  546.           if (++parser_state_tos->p_l_follow
  547.           >= parser_state_tos->paren_indents_size)
  548. --- 571,577 ----
  549.           /* Do not put a space before the '{'.  */
  550.           parser_state_tos->want_blank = false;
  551.             }
  552. ! 
  553.           /* Count parens so we know how deep we are.  */
  554.           if (++parser_state_tos->p_l_follow
  555.           >= parser_state_tos->paren_indents_size)
  556. *************** check_type:
  557. *** 891,897 ****
  558. --- 919,929 ----
  559.                            * a declaration, so dont do
  560.                            * special indentation of
  561.                            * comments */
  562. + #ifdef MSDOS
  563. +         if (blanklin_after_decl_proctop
  564. + #else
  565.           if (blanklines_after_declarations_at_proctop
  566. + #endif /* MSDOS */
  567.               && parser_state_tos->in_parameter_declaration)
  568.               postfix_blankline_requested = 1;
  569.           parser_state_tos->in_parameter_declaration = 0;
  570. *************** check_type:
  571. *** 902,908 ****
  572.              Needed so that the '=' in "enum bar {a = 1" does not
  573.              get interpreted as the start of an initializer.  */
  574.           parser_state_tos->in_or_st = false;
  575. !            
  576.           parse(lbrace);    /* let parser know about this */
  577.           if (parser_state_tos->want_blank)    /* put a blank before '{' if '{' is not at
  578.                    * start of line */
  579. --- 934,940 ----
  580.              Needed so that the '=' in "enum bar {a = 1" does not
  581.              get interpreted as the start of an initializer.  */
  582.           parser_state_tos->in_or_st = false;
  583. ! 
  584.           parse(lbrace);    /* let parser know about this */
  585.           if (parser_state_tos->want_blank)    /* put a blank before '{' if '{' is not at
  586.                    * start of line */
  587. *************** check_type:
  588. *** 1103,1109 ****
  589.                 check_code_size;
  590.                 *e_code++ = *t_ptr;
  591.               }
  592. !         }    
  593.           parser_state_tos->want_blank = true;
  594.   
  595.           /* If the token is va_dcl, it appears without a semicolon,
  596. --- 1135,1141 ----
  597.                 check_code_size;
  598.                 *e_code++ = *t_ptr;
  599.               }
  600. !         }
  601.           parser_state_tos->want_blank = true;
  602.   
  603.           /* If the token is va_dcl, it appears without a semicolon,
  604. *************** check_type:
  605. *** 1245,1251 ****
  606. --- 1277,1287 ----
  607.           }
  608.   
  609.           if (strncmp(s_lab + 1, "if", 2) == 0) {
  610. + #ifdef MSDOS
  611. +         if (blanklines_around_cond_comp) {
  612. + #else
  613.           if (blanklines_around_conditional_compilation) {
  614. + #endif /* MSDOS */
  615.               register    c;
  616.               prefix_blankline_requested++;
  617.               while ((c = *in_prog_pos++) == '\n');
  618. *************** check_type:
  619. *** 1286,1292 ****
  620.               (parser_state_tos->paren_indents_size * sizeof (short));
  621.             mymemcpy (new->paren_indents, parser_state_tos->paren_indents,
  622.                 parser_state_tos->paren_indents_size * sizeof (short));
  623. !           
  624.             new->next = parser_state_tos;
  625.             parser_state_tos = new;
  626.           }
  627. --- 1322,1328 ----
  628.               (parser_state_tos->paren_indents_size * sizeof (short));
  629.             mymemcpy (new->paren_indents, parser_state_tos->paren_indents,
  630.                 parser_state_tos->paren_indents_size * sizeof (short));
  631. ! 
  632.             new->next = parser_state_tos;
  633.             parser_state_tos = new;
  634.           }
  635. *************** check_type:
  636. *** 1316,1322 ****
  637.               mymemcpy (parser_state_tos, second,
  638.                   sizeof(struct parser_state));
  639.               parser_state_tos->next = second;
  640. !             
  641.               /* Now copy the arrays from the second to top of
  642.                  stack to the top of stack.  */
  643.               /* Since the p_stack, etc. arrays only grow, never
  644. --- 1352,1358 ----
  645.               mymemcpy (parser_state_tos, second,
  646.                   sizeof(struct parser_state));
  647.               parser_state_tos->next = second;
  648. ! 
  649.               /* Now copy the arrays from the second to top of
  650.                  stack to the top of stack.  */
  651.               /* Since the p_stack, etc. arrays only grow, never
  652. *************** check_type:
  653. *** 1369,1375 ****
  654. --- 1405,1415 ----
  655.             }
  656.           else
  657.               diag(1, "Unmatched #endif");
  658. + #ifdef MSDOS
  659. +         if (blanklines_around_cond_comp) {
  660. + #else
  661.           if (blanklines_around_conditional_compilation) {
  662. + #endif /* MSDOS */
  663.               postfix_blankline_requested++;
  664.               n_real_blanklines = 0;
  665.           }
  666. *************** check_type:
  667. *** 1403,1408 ****
  668. --- 1443,1449 ----
  669.    * backup file will be "file.BAK" then make the backup file the input and
  670.    * original input file the output
  671.    */
  672. + void
  673.   bakcopy()
  674.   {
  675.       /* file descriptor for the output file */
  676. *************** bakcopy()
  677. *** 1410,1433 ****
  678.   
  679.       /* Used to walk around file names */
  680.       register char *p;
  681.   
  682.       /* Buffer for error message.  */
  683.       char *errbuf;
  684.       /* Backup file name.  */
  685.       char *bakfile;
  686. !     
  687.       /* construct name of backup file */
  688.       for (p = in_name; *p; p++);    /* skip to end of string */
  689.       while (p > in_name && *p != '/')    /* find last '/' */
  690.       p--;
  691.       if (*p == '/')
  692.       p++;
  693.       bakfile = xmalloc(40 + strlen(p));
  694.       sprintf(bakfile, "%s.BAK", p);
  695.       errbuf = xmalloc(80 + strlen(p));
  696.   
  697.       sprintf(errbuf,"indent: %s",bakfile);
  698. !       
  699.       /* copy in_name to backup file */
  700.       /* permissions 0666 means rw-rw-rw- (modified by umask).  */
  701.       bakchn = creat(bakfile, 0666);
  702. --- 1451,1495 ----
  703.   
  704.       /* Used to walk around file names */
  705.       register char *p;
  706. + #ifdef MSDOS
  707. +     char *p_no_ext,
  708. +      *p_ext;
  709. + #endif /* MSDOS */
  710.   
  711.       /* Buffer for error message.  */
  712.       char *errbuf;
  713.       /* Backup file name.  */
  714.       char *bakfile;
  715. ! 
  716.       /* construct name of backup file */
  717.       for (p = in_name; *p; p++);    /* skip to end of string */
  718. + #ifdef MSDOS
  719. +     while (p > in_name && *p != '/' && *p != '\\' )
  720. +     p--;
  721. +     if (*p == '/' || *p == '\\' )
  722. +     p++;
  723. + #else
  724.       while (p > in_name && *p != '/')    /* find last '/' */
  725.       p--;
  726.       if (*p == '/')
  727.       p++;
  728. + #endif /* MSDOS */
  729. + 
  730.       bakfile = xmalloc(40 + strlen(p));
  731. + #ifdef MSDOS                /* strip extension! */
  732. +     p_no_ext = xmalloc(strlen(p)+1);
  733. +     strcpy(p_no_ext,p);
  734. +     if( p_ext = strrchr(p_no_ext,'.'))
  735. +     *p_ext = '\0';
  736. +     sprintf(bakfile, "%s.BAK", p_no_ext);
  737. +     free(p_no_ext);
  738. + #else
  739.       sprintf(bakfile, "%s.BAK", p);
  740. + #endif /* MSDOS */
  741.       errbuf = xmalloc(80 + strlen(p));
  742.   
  743.       sprintf(errbuf,"indent: %s",bakfile);
  744. ! 
  745.       /* copy in_name to backup file */
  746.       /* permissions 0666 means rw-rw-rw- (modified by umask).  */
  747.       bakchn = creat(bakfile, 0666);
  748. *************** bakcopy()
  749. *** 1437,1443 ****
  750. --- 1499,1509 ----
  751.       exit(1);
  752.         }
  753.   
  754. + #ifdef M_I86HM
  755. +     if (hwrite(bakchn, in_prog, in_prog_size) != in_prog_size)
  756. + #else
  757.       if (write(bakchn, in_prog, in_prog_size) != in_prog_size)
  758. + #endif
  759.         {
  760.       perror(errbuf);
  761.       exit(1);
  762. *************** bakcopy()
  763. *** 1444,1450 ****
  764.         }
  765.   
  766.       close(bakchn);
  767. !     
  768.       /* now the original input file will be the output */
  769.       output = fopen(in_name, "w");
  770.       if (output == 0) {
  771. --- 1510,1516 ----
  772.         }
  773.   
  774.       close(bakchn);
  775. ! 
  776.       /* now the original input file will be the output */
  777.       output = fopen(in_name, "w");
  778.       if (output == 0) {
  779. diff -cBdNp e:/gnu/indent/gnu/indent_g.h ./indent_g.h
  780. *** e:/gnu/indent/gnu/indent_g.h    Mon Jul 02 20:39:20 1990
  781. --- ./indent_g.h    Mon Jul 02 20:39:38 1990
  782. ***************
  783. *** 20,26 ****
  784. --- 20,64 ----
  785.    *    @(#)indent_globs.h    5.7 (Berkeley) 9/15/88
  786.    */
  787.   
  788. + /*
  789. +  * MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  790. +  *
  791. +  * To this port, the same copying conditions apply as to the
  792. +  * original release.
  793. +  *
  794. +  * IMPORTANT:
  795. +  * This file is not identical to the original GNU release!
  796. +  * You should have received this code as patch to the official
  797. +  * GNU release.
  798. +  *
  799. +  * MORE IMPORTANT:
  800. +  * This port comes with ABSOLUTELY NO WARRANTY.
  801. +  *
  802. +  * $Header: e:/gnu/indent/RCS/indent_g.h'v 1.1.0.4 90/07/02 20:25:28 tho Exp $
  803. +  */
  804. + 
  805.   #include <stdio.h>
  806. + 
  807. + #ifdef MSDOS
  808. + 
  809. + #include <stdlib.h>
  810. + #include <string.h>
  811. + #include <malloc.h>
  812. + #include <io.h>
  813. + 
  814. + #define mymemcpy memcpy
  815. + 
  816. + #ifdef M_I86HM
  817. + /* This symbol is predefined by the Microsoft C Compiler,
  818. +    when it is creating "huge memory model" code.
  819. +    In that case we need long offsets and buffer lengths.  */
  820. + #define LONG long
  821. + #else
  822. + #define LONG unsigned int
  823. + #endif
  824. + 
  825. + #else /* not MSDOS */
  826. + 
  827.   #include <strings.h>
  828.   
  829.   /* Standard memory allocation routines.  */
  830. *************** char *realloc ();
  831. *** 31,41 ****
  832.   char *xmalloc ();
  833.   char *xrealloc ();
  834.   
  835.   /* Because some systems lack memcpy, I have provided one, called
  836.      mymemcpy.  If you system memcpy is more efficient, you might
  837.      want to use it by uncommenting the following line.  */
  838.   /* #define mymemcpy memcpy */
  839. ! char *mymemcpy ();
  840.   
  841.   #define BACKSLASH '\\'
  842.   #define label_offset 2        /* number of levels a label is placed to left
  843. --- 69,83 ----
  844.   char *xmalloc ();
  845.   char *xrealloc ();
  846.   
  847. + #define LONG unsigned int
  848. + 
  849. + #endif /* not MSDOS */
  850. + 
  851.   /* Because some systems lack memcpy, I have provided one, called
  852.      mymemcpy.  If you system memcpy is more efficient, you might
  853.      want to use it by uncommenting the following line.  */
  854.   /* #define mymemcpy memcpy */
  855. ! /* char *mymemcpy ();        see below, [tho] Mon Nov 13 01:12:02 1989 */
  856.   
  857.   #define BACKSLASH '\\'
  858.   #define label_offset 2        /* number of levels a label is placed to left
  859. *************** enum codes {code_eof = 0,  /* end of fil
  860. *** 61,70 ****
  861.             sp_nparen, ifstmt, whilestmt,
  862.             forstmt, stmt, stmtl, elselit, dolit, dohead, ifhead,
  863.             elsehead, period };
  864. !           
  865.   #define false 0
  866.   #define true  1
  867.   
  868.   /* Name of input file.  */
  869.   extern char *in_name;
  870.   
  871. --- 103,116 ----
  872.             sp_nparen, ifstmt, whilestmt,
  873.             forstmt, stmt, stmtl, elselit, dolit, dohead, ifhead,
  874.             elsehead, period };
  875. ! 
  876.   #define false 0
  877.   #define true  1
  878.   
  879. + #ifdef MSDOS
  880. + char *my_name;                /* argv[0] */
  881. + #endif /* MSDOS */
  882. + 
  883.   /* Name of input file.  */
  884.   extern char *in_name;
  885.   
  886. *************** char *in_prog_pos;
  887. *** 78,84 ****
  888.   char *cur_line;
  889.   
  890.   /* Size of the input program, not including the ' \n\0' we add at the end */
  891. ! int in_prog_size;
  892.   
  893.   FILE       *output;        /* the output file */
  894.   
  895. --- 124,131 ----
  896.   char *cur_line;
  897.   
  898.   /* Size of the input program, not including the ' \n\0' we add at the end */
  899. ! LONG in_prog_size;
  900. ! 
  901.   
  902.   FILE       *output;        /* the output file */
  903.   
  904. *************** int         pointer_as_binop;
  905. *** 177,183 ****
  906. --- 224,234 ----
  907.   int         blanklines_after_declarations;
  908.   int         blanklines_before_blockcomments;
  909.   extern int blanklines_after_procs;
  910. + #ifdef MSDOS
  911. + int         blanklines_around_cond_comp;
  912. + #else /* not MSDOS */
  913.   int         blanklines_around_conditional_compilation;
  914. + #endif /* not MSDOS */
  915.   int         swallow_optional_blanklines;
  916.   int         n_real_blanklines;
  917.   int         prefix_blankline_requested;
  918. *************** extern int paren_target;
  919. *** 241,247 ****
  920.   
  921.   int         Bill_Shannon;    /* true iff a blank should always be inserted
  922.                    * after sizeof */
  923. ! int         blanklines_after_declarations_at_proctop;    /* This is vaguely
  924.                                * similar to
  925.                                * blanklines_after_decla
  926.                                * rations except that
  927. --- 292,303 ----
  928.   
  929.   int         Bill_Shannon;    /* true iff a blank should always be inserted
  930.                    * after sizeof */
  931. ! #ifdef MSDOS
  932. ! int         blanklin_after_decl_proctop;
  933. ! #else /* not MSDOS */
  934. ! int         blanklines_after_declarations_at_proctop;
  935. ! #endif /* not MSDOS */
  936. !                             /* This is vaguely
  937.                                * similar to
  938.                                * blanklines_after_decla
  939.                                * rations except that
  940. *************** extern int         use_stdinout;
  941. *** 294,299 ****
  942. --- 350,358 ----
  943.   struct fstate {
  944.       char        font[4];
  945.       char        size;
  946. + #ifdef MSDOS
  947. +     unsigned
  948. + #endif /* MSDOS */
  949.       int         allcaps:1;
  950.   };
  951.   char       *chfont();
  952. *************** extern struct parser_state *parser_state
  953. *** 415,417 ****
  954. --- 474,516 ----
  955.   /* The column in which comments to the right of #else and #endif should
  956.      start.  */
  957.   extern int else_endif_col;
  958. + 
  959. + #ifdef MSDOS
  960. + char *chfont (struct fstate *, struct fstate *, char *);
  961. + enum codes lexi (void);
  962. + int compute_code_target (void);
  963. + int compute_label_target (void);
  964. + int count_spaces (int, char *);
  965. + int eqin (char *, char *, char * *);
  966. + void fill_buffer (void);
  967. + int pad_output (int, int);
  968. + struct templ *is_reserved (char *, int);
  969. + void *mymemcpy (void *, const void *, size_t);
  970. + void *xmalloc (size_t);
  971. + void *xrealloc (void *, size_t);
  972. + void addkey (char *, enum rwcodes);
  973. + void bakcopy (void);
  974. + void diag (int, char *,...);
  975. + void dump_line (void);
  976. + void fill_buffer (void);
  977. + void main (int, char * *);
  978. + void parse (enum codes);
  979. + void parsefont (struct fstate *, char *);
  980. + void pr_comment (void);
  981. + void read_file (char *);
  982. + void read_stdin (void);
  983. + void reduce (void);
  984. + void scan_profile (FILE *);
  985. + void set_defaults (void);
  986. + void set_option (char *, int);
  987. + void set_profile (void);
  988. + void writefdef (struct fstate *, int);
  989. + 
  990. + #ifdef M_I86HM
  991. + void huge *xhalloc (long size);
  992. + void huge *xhrealloc (void huge *ptr, long new_size, long old_size);
  993. + long hread (int fd, void huge *buffer, long bytes);
  994. + long hwrite (int fd, void huge *buffer, long bytes);
  995. + #endif /* M_I86HM */
  996. + 
  997. + #endif /* MSDOS */
  998. diff -cBdNp e:/gnu/indent/gnu/io.c ./io.c
  999. *** e:/gnu/indent/gnu/io.c    Mon Jul 02 20:39:22 1990
  1000. --- ./io.c    Mon Jul 02 20:39:42 1990
  1001. ***************
  1002. *** 18,23 ****
  1003. --- 18,40 ----
  1004.    * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  1005.    */
  1006.   
  1007. + /*
  1008. +  * MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  1009. +  *
  1010. +  * To this port, the same copying conditions apply as to the
  1011. +  * original release.
  1012. +  *
  1013. +  * IMPORTANT:
  1014. +  * This file is not identical to the original GNU release!
  1015. +  * You should have received this code as patch to the official
  1016. +  * GNU release.
  1017. +  *
  1018. +  * MORE IMPORTANT:
  1019. +  * This port comes with ABSOLUTELY NO WARRANTY.
  1020. +  *
  1021. +  * $Header: e:/gnu/indent/RCS/io.c'v 1.1.0.5 90/07/02 20:28:47 tho Exp $
  1022. +  */
  1023. + 
  1024.   #ifndef lint
  1025.   static char sccsid[] = "@(#)io.c    5.10 (Berkeley) 9/15/88";
  1026.   #endif /* not lint */
  1027. *************** int paren_target;
  1028. *** 39,44 ****
  1029. --- 56,62 ----
  1030.   /* true if INDENT OFF is in effect */
  1031.   static int inhibit_formatting;
  1032.   
  1033. + void
  1034.   dump_line()
  1035.   {                /* dump_line is the routine that actually
  1036.                    * effects the printing of the new source. It
  1037. *************** dump_line()
  1038. *** 142,148 ****
  1039.           fprintf(output, ".*/\n");
  1040.           }
  1041.           target_col = compute_code_target();
  1042. !         /* If a line ends in an lparen character, the following 
  1043.              line should not line up with the parenthesis, but
  1044.              should be indented by the usual amount.  */
  1045.           if (parser_state_tos->last_token == lparen)
  1046. --- 160,166 ----
  1047.           fprintf(output, ".*/\n");
  1048.           }
  1049.           target_col = compute_code_target();
  1050. !         /* If a line ends in an lparen character, the following
  1051.              line should not line up with the parenthesis, but
  1052.              should be indented by the usual amount.  */
  1053.           if (parser_state_tos->last_token == lparen)
  1054. *************** dump_line()
  1055. *** 225,231 ****
  1056. --- 243,253 ----
  1057.           }
  1058.           }
  1059.           else {        /* print comment, if any */
  1060. + #ifdef MSDOS
  1061. +         register int target = parser_state_tos->com_col;
  1062. + #else
  1063.           register    target = parser_state_tos->com_col;
  1064. + #endif
  1065.           register char *com_st = s_com;
  1066.   
  1067.           target += parser_state_tos->comment_delta;
  1068. *************** inhibit_newline:
  1069. *** 301,314 ****
  1070. --- 323,345 ----
  1071.   int
  1072.   compute_code_target()
  1073.   {
  1074. + #ifdef MSDOS
  1075. +     register int target_col = parser_state_tos->ind_level + 1;
  1076. + #else
  1077.       register    target_col = parser_state_tos->ind_level + 1;
  1078. + #endif /* MSDOS */
  1079.   
  1080.       if (parser_state_tos->paren_level)
  1081.       if (!lineup_to_parens)
  1082.           target_col += continuation_indent * parser_state_tos->paren_level;
  1083.       else {
  1084. + #ifdef MSDOS
  1085. +         register int w;
  1086. +         register int t = paren_target;
  1087. + #else
  1088.           register    w;
  1089.           register    t = paren_target;
  1090. + #endif /* MSDOS */
  1091.   
  1092.           if ((w = count_spaces(t, s_code) - max_col) > 0
  1093.               && count_spaces(target_col, s_code) <= max_col) {
  1094. *************** compute_label_target()
  1095. *** 333,340 ****
  1096.       : parser_state_tos->ind_level - label_offset + 1;
  1097.   }
  1098.   
  1099. ! /* Allocate space for FILENAME, read in the file, and set in_prog and 
  1100. !    in_prog_pos to point to the buffer.  If any errors occur, report an 
  1101.      error message and abort.  */
  1102.   void
  1103.   read_file(filename)
  1104. --- 364,371 ----
  1105.       : parser_state_tos->ind_level - label_offset + 1;
  1106.   }
  1107.   
  1108. ! /* Allocate space for FILENAME, read in the file, and set in_prog and
  1109. !    in_prog_pos to point to the buffer.  If any errors occur, report an
  1110.      error message and abort.  */
  1111.   void
  1112.   read_file(filename)
  1113. *************** read_file(filename)
  1114. *** 345,350 ****
  1115. --- 376,382 ----
  1116.   
  1117.     /* File status for the input file */
  1118.     struct stat in_stat;
  1119. +   LONG bytes_read;
  1120.   
  1121.     /* buffer used for error messages */
  1122.     char *errbuf;
  1123. *************** read_file(filename)
  1124. *** 364,378 ****
  1125.         perror(errbuf);
  1126.         exit(1);
  1127.       }
  1128.     in_prog_size = in_stat.st_size;
  1129.     in_prog = xmalloc(in_prog_size + 3); /* 3 for ' ','\n','\0' */
  1130.   
  1131. !   if (read(in_fd,in_prog,in_prog_size) < 0)
  1132.       {
  1133.         perror(errbuf);
  1134.         exit(1);
  1135.       }
  1136.   
  1137.     if (close(in_fd) < 0)
  1138.       {
  1139.         perror(errbuf);
  1140. --- 396,448 ----
  1141.         perror(errbuf);
  1142.         exit(1);
  1143.       }
  1144. + 
  1145. + #ifdef MSDOS
  1146. + 
  1147. + #ifdef M_I86HM
  1148.     in_prog_size = in_stat.st_size;
  1149. +   in_prog = xhalloc(in_prog_size + 3); /* 3 for ' ','\n','\0' */
  1150. + 
  1151. +   if ( (bytes_read=hread(in_fd,in_prog,in_prog_size)) < 0)
  1152. +     {
  1153. +       perror(errbuf);
  1154. +       exit(1);
  1155. +     }
  1156. + #else /* not M_I86HM */
  1157. +   if (in_stat.st_size >= 0xfff0)
  1158. +     {
  1159. +       fprintf (stderr,  "Can't handle large files (> 64k) under MS-DOS, "
  1160. +            "if not compiled with huge pointers.\nSorry.\n");
  1161. +       exit (1);
  1162. +     }
  1163. +   in_prog_size = (unsigned int) in_stat.st_size;
  1164.     in_prog = xmalloc(in_prog_size + 3); /* 3 for ' ','\n','\0' */
  1165.   
  1166. !   if ( (bytes_read=read(in_fd,in_prog,in_prog_size)) < 0)
  1167. !     {
  1168. !       perror(errbuf);
  1169. !       exit(1);
  1170. !     }
  1171. ! #endif /* not M_I86HM */
  1172. ! 
  1173. !   if (close(in_fd) < 0)
  1174.       {
  1175.         perror(errbuf);
  1176.         exit(1);
  1177.       }
  1178.   
  1179. +   in_prog_size = bytes_read;        /* the crlf story ... */
  1180. + 
  1181. + #else /* not MSDOS */
  1182. + 
  1183. +   in_prog_size = in_stat.st_size;
  1184. +   in_prog = xmalloc(in_prog_size + 3); /* 3 for ' ','\n','\0' */
  1185. + 
  1186. +   if ( (bytes_read=read(in_fd,in_prog,in_prog_size)) < 0)
  1187. +     {
  1188. +       perror(errbuf);
  1189. +       exit(1);
  1190. +     }
  1191.     if (close(in_fd) < 0)
  1192.       {
  1193.         perror(errbuf);
  1194. *************** read_file(filename)
  1195. *** 379,387 ****
  1196.         exit(1);
  1197.       }
  1198.   
  1199.     in_prog[in_prog_size] = ' ';
  1200.     in_prog[in_prog_size+1] = '\n';
  1201. !   in_prog[in_prog_size+2] = 0;
  1202.     in_prog_pos = in_prog;
  1203.   
  1204.     free (errbuf);
  1205. --- 449,459 ----
  1206.         exit(1);
  1207.       }
  1208.   
  1209. + #endif /* not MSDOS */
  1210. + 
  1211.     in_prog[in_prog_size] = ' ';
  1212.     in_prog[in_prog_size+1] = '\n';
  1213. !   in_prog[in_prog_size+2] = '\0';
  1214.     in_prog_pos = in_prog;
  1215.   
  1216.     free (errbuf);
  1217. *************** read_file(filename)
  1218. *** 391,396 ****
  1219. --- 464,523 ----
  1220.   void
  1221.   read_stdin()
  1222.   {
  1223. + #ifdef MSDOS
  1224. + 
  1225. +   LONG alloc_size = 10000;
  1226. +   int ch;
  1227. + 
  1228. +   in_prog_pos = in_prog
  1229. + #ifdef M_I86HM
  1230. +     = xhalloc (alloc_size);
  1231. + #else /* not M_I86HM */
  1232. +     = xmalloc (alloc_size);
  1233. + #endif /* not M_I86HM */
  1234. + 
  1235. +   in_prog_size = 0;
  1236. +   do
  1237. +     {
  1238. +       /* Copy up until 3 bytes before the end of the buffer,
  1239. +      (the 3 is for ' \n\0')...  */
  1240. +       for (; in_prog_size < alloc_size - 3; in_prog_size++)
  1241. +     {
  1242. +       ch = getc(stdin);
  1243. +       if (ch == EOF)
  1244. +           break;
  1245. +       in_prog[in_prog_size] = (char) ch;
  1246. +     }
  1247. +       /* ...and if that's not enough allocate more.  */
  1248. +       if (ch != EOF) {
  1249. + #ifdef M_I86HM
  1250. + 
  1251. +     LONG old_alloc_size = alloc_size;
  1252. +     alloc_size *= 2;
  1253. +     in_prog = xhrealloc (in_prog, alloc_size, old_alloc_size);
  1254. + 
  1255. + #else /* not M_I86HM */
  1256. + 
  1257. +     if (alloc_size >= 0xFFE0)
  1258. +       {
  1259. +         fprintf (stderr,  "Can't handle large files (> 64k) under MS-DOS, "
  1260. +              "if not compiled with huge pointers.\nSorry.\n");
  1261. +         exit (1);
  1262. +       }
  1263. +     else if (alloc_size >= 0x7FF0)
  1264. +       alloc_size = 0xFFE0;
  1265. +     else
  1266. +       alloc_size *= 2;
  1267. + 
  1268. +     in_prog = xrealloc(in_prog,alloc_size);
  1269. + 
  1270. + #endif /* not M_I86HM */
  1271. +       }
  1272. +     }
  1273. +   while (ch != EOF);
  1274. + 
  1275. + #else /* not MSDOS */
  1276. + 
  1277.     unsigned int alloc_size = 10000;
  1278.     int ch;
  1279.   
  1280. *************** read_stdin()
  1281. *** 405,411 ****
  1282.         ch = getc(stdin);
  1283.         if (ch == EOF)
  1284.             break;
  1285. !       in_prog[in_prog_size] = ch;
  1286.       }
  1287.         /* ...and if that's not enough allocate more.  */
  1288.         if (ch != EOF) {
  1289. --- 532,538 ----
  1290.         ch = getc(stdin);
  1291.         if (ch == EOF)
  1292.             break;
  1293. !       in_prog[in_prog_size] = (char) ch;
  1294.       }
  1295.         /* ...and if that's not enough allocate more.  */
  1296.         if (ch != EOF) {
  1297. *************** read_stdin()
  1298. *** 414,432 ****
  1299.         }
  1300.       }
  1301.     while (ch != EOF);
  1302. !   
  1303.     in_prog[in_prog_size] = ' ';
  1304.     in_prog[in_prog_size+1] = '\n';
  1305.     in_prog[in_prog_size+2] = 0;
  1306. !   in_prog_pos = in_prog;  
  1307.   }
  1308.   
  1309. ! /* Advance buf_ptr so that it points to the next line of input.  Skip 
  1310.      over indent errors (comments beginning with *INDENT**), ignoring
  1311.      them.  Process INDENT ON and INDENT OFF. (Note: the name of this
  1312.      function is a historical artifact from before the time that indent
  1313.      kept the whole source file in memory). */
  1314.   
  1315.   fill_buffer()
  1316.   {
  1317.     /* Point various places in the buffer.  */
  1318. --- 541,562 ----
  1319.         }
  1320.       }
  1321.     while (ch != EOF);
  1322. ! 
  1323. ! #endif /* not MSDOS */
  1324. ! 
  1325.     in_prog[in_prog_size] = ' ';
  1326.     in_prog[in_prog_size+1] = '\n';
  1327.     in_prog[in_prog_size+2] = 0;
  1328. !   in_prog_pos = in_prog;
  1329.   }
  1330.   
  1331. ! /* Advance buf_ptr so that it points to the next line of input.  Skip
  1332.      over indent errors (comments beginning with *INDENT**), ignoring
  1333.      them.  Process INDENT ON and INDENT OFF. (Note: the name of this
  1334.      function is a historical artifact from before the time that indent
  1335.      kept the whole source file in memory). */
  1336.   
  1337. + void
  1338.   fill_buffer()
  1339.   {
  1340.     /* Point various places in the buffer.  */
  1341. *************** fill_buffer()
  1342. *** 434,440 ****
  1343.   
  1344.     /* Have we found INDENT ON or INDENT OFF ? */
  1345.     enum {None,Indent_on,Indent_off} com;
  1346. !   
  1347.     if (bp_save != 0)
  1348.       {        /* there is a partly filled input buffer left */
  1349.       buf_ptr = bp_save;    /* dont read anything, just switch buffers */
  1350. --- 564,570 ----
  1351.   
  1352.     /* Have we found INDENT ON or INDENT OFF ? */
  1353.     enum {None,Indent_on,Indent_off} com;
  1354. ! 
  1355.     if (bp_save != 0)
  1356.       {        /* there is a partly filled input buffer left */
  1357.       buf_ptr = bp_save;    /* dont read anything, just switch buffers */
  1358. *************** fill_buffer()
  1359. *** 451,457 ****
  1360.     buf_ptr = in_prog_pos;
  1361.     for (p = buf_ptr; *p && *p++ != '\n';)
  1362.       ;
  1363. !   
  1364.     buf_end = p;
  1365.     if (!*p)
  1366.       had_eof = true;
  1367. --- 581,587 ----
  1368.     buf_ptr = in_prog_pos;
  1369.     for (p = buf_ptr; *p && *p++ != '\n';)
  1370.       ;
  1371. ! 
  1372.     buf_end = p;
  1373.     if (!*p)
  1374.       had_eof = true;
  1375. *************** fill_buffer()
  1376. *** 458,464 ****
  1377.   
  1378.     p = buf_ptr;
  1379.     in_prog_pos = buf_end;
  1380. !   
  1381.     while (*p == ' ' || *p == '\t')
  1382.       p++;
  1383.     if (*p == '/' && p[1] == '*')
  1384. --- 588,594 ----
  1385.   
  1386.     p = buf_ptr;
  1387.     in_prog_pos = buf_end;
  1388. ! 
  1389.     while (*p == ' ' || *p == '\t')
  1390.       p++;
  1391.     if (*p == '/' && p[1] == '*')
  1392. *************** fill_buffer()
  1393. *** 502,539 ****
  1394.       putc(*p,output);
  1395.         while (*p++ != '\n');
  1396.       }
  1397. !       
  1398.   }
  1399. !   
  1400. !       
  1401. !   
  1402.   /*
  1403.    * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
  1404. !  * 
  1405.    * All rights reserved
  1406. !  * 
  1407. !  * 
  1408.    * NAME: pad_output
  1409. !  * 
  1410.    * FUNCTION: Writes tabs and spaces to move the current column up to the desired
  1411.    * position.
  1412. !  * 
  1413.    * ALGORITHM: Put tabs and/or blanks into pobuf, then write pobuf.
  1414. !  * 
  1415.    * PARAMETERS: current        integer        The current column target
  1416.    * nteger        The desired column
  1417. !  * 
  1418.    * RETURNS: Integer value of the new column.  (If current >= target, no action is
  1419.    * taken, and current is returned.
  1420. !  * 
  1421.    * GLOBALS: None
  1422. !  * 
  1423.    * CALLS: write (sys)
  1424. !  * 
  1425.    * CALLED BY: dump_line
  1426. !  * 
  1427.    * HISTORY: initial coding     November 1976    D A Willcox of CAC
  1428. !  * 
  1429.    */
  1430.   pad_output(current, target)    /* writes tabs and blanks (if necessary) to
  1431.                    * get the current output position up to the
  1432. --- 633,670 ----
  1433.       putc(*p,output);
  1434.         while (*p++ != '\n');
  1435.       }
  1436. ! 
  1437.   }
  1438. ! 
  1439. ! 
  1440. ! 
  1441.   /*
  1442.    * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
  1443. !  *
  1444.    * All rights reserved
  1445. !  *
  1446. !  *
  1447.    * NAME: pad_output
  1448. !  *
  1449.    * FUNCTION: Writes tabs and spaces to move the current column up to the desired
  1450.    * position.
  1451. !  *
  1452.    * ALGORITHM: Put tabs and/or blanks into pobuf, then write pobuf.
  1453. !  *
  1454.    * PARAMETERS: current        integer        The current column target
  1455.    * nteger        The desired column
  1456. !  *
  1457.    * RETURNS: Integer value of the new column.  (If current >= target, no action is
  1458.    * taken, and current is returned.
  1459. !  *
  1460.    * GLOBALS: None
  1461. !  *
  1462.    * CALLS: write (sys)
  1463. !  *
  1464.    * CALLED BY: dump_line
  1465. !  *
  1466.    * HISTORY: initial coding     November 1976    D A Willcox of CAC
  1467. !  *
  1468.    */
  1469.   pad_output(current, target)    /* writes tabs and blanks (if necessary) to
  1470.                    * get the current output position up to the
  1471. *************** pad_output(current, target)    /* writes ta
  1472. *** 562,584 ****
  1473.   
  1474.   /*
  1475.    * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
  1476. !  * 
  1477.    * All rights reserved
  1478. !  * 
  1479. !  * 
  1480.    * NAME: count_spaces
  1481. !  * 
  1482.    * FUNCTION: Find out where printing of a given string will leave the current
  1483.    * character position on output.
  1484. !  * 
  1485.    * ALGORITHM: Run thru input string and add appropriate values to current
  1486.    * position.
  1487. !  * 
  1488.    * RETURNS: Integer value of position after printing "buffer" starting in column
  1489.    * "current".
  1490. !  * 
  1491.    * HISTORY: initial coding     November 1976    D A Willcox of CAC
  1492. !  * 
  1493.    */
  1494.   int
  1495.   count_spaces(current, buffer)
  1496. --- 693,715 ----
  1497.   
  1498.   /*
  1499.    * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
  1500. !  *
  1501.    * All rights reserved
  1502. !  *
  1503. !  *
  1504.    * NAME: count_spaces
  1505. !  *
  1506.    * FUNCTION: Find out where printing of a given string will leave the current
  1507.    * character position on output.
  1508. !  *
  1509.    * ALGORITHM: Run thru input string and add appropriate values to current
  1510.    * position.
  1511. !  *
  1512.    * RETURNS: Integer value of position after printing "buffer" starting in column
  1513.    * "current".
  1514. !  *
  1515.    * HISTORY: initial coding     November 1976    D A Willcox of CAC
  1516. !  *
  1517.    */
  1518.   int
  1519.   count_spaces(current, buffer)
  1520. *************** count_spaces(current, buffer)
  1521. *** 621,630 ****
  1522.   /* Nonzero if we have found an error (not a warning).  */
  1523.   int    found_err;
  1524.   
  1525. ! /* Signal an error.  LEVEL is nonzero if it is an error (as opposed to 
  1526. !    a warning.  MSG is a printf-style format string.  Additional 
  1527.      arguments are additional arguments for printf.  */
  1528.   /* VARARGS2 */
  1529.   diag(level, msg, a, b)
  1530.        char *msg;
  1531.   {
  1532. --- 752,762 ----
  1533.   /* Nonzero if we have found an error (not a warning).  */
  1534.   int    found_err;
  1535.   
  1536. ! /* Signal an error.  LEVEL is nonzero if it is an error (as opposed to
  1537. !    a warning.  MSG is a printf-style format string.  Additional
  1538.      arguments are additional arguments for printf.  */
  1539.   /* VARARGS2 */
  1540. + void
  1541.   diag(level, msg, a, b)
  1542.        char *msg;
  1543.   {
  1544. *************** diag(level, msg, a, b)
  1545. *** 642,647 ****
  1546. --- 774,780 ----
  1547.       }
  1548.   }
  1549.   
  1550. + void
  1551.   writefdef(f, nm)
  1552.       register struct fstate *f;
  1553.   {
  1554. *************** chfont(of, nf, s)
  1555. *** 685,691 ****
  1556.       return s;
  1557.   }
  1558.   
  1559. ! 
  1560.   parsefont(f, s0)
  1561.       register struct fstate *f;
  1562.       char       *s0;
  1563. --- 818,824 ----
  1564.       return s;
  1565.   }
  1566.   
  1567. ! void
  1568.   parsefont(f, s0)
  1569.       register struct fstate *f;
  1570.       char       *s0;
  1571. *************** parsefont(f, s0)
  1572. *** 693,704 ****
  1573.       register char *s = s0;
  1574.       int         sizedelta = 0;
  1575.       int i;
  1576. !     
  1577.       f->size = 0;
  1578.       f->allcaps = 1;
  1579.       for (i = 0; i < 4; i++)
  1580.         f->font[i] = 0;
  1581. !     
  1582.       while (*s) {
  1583.       if (isdigit(*s))
  1584.           f->size = f->size * 10 + *s - '0';
  1585. --- 826,837 ----
  1586.       register char *s = s0;
  1587.       int         sizedelta = 0;
  1588.       int i;
  1589. ! 
  1590.       f->size = 0;
  1591.       f->allcaps = 1;
  1592.       for (i = 0; i < 4; i++)
  1593.         f->font[i] = 0;
  1594. ! 
  1595.       while (*s) {
  1596.       if (isdigit(*s))
  1597.           f->size = f->size * 10 + *s - '0';
  1598. diff -cBdNp e:/gnu/indent/gnu/lexi.c ./lexi.c
  1599. *** e:/gnu/indent/gnu/lexi.c    Mon Jul 02 20:39:22 1990
  1600. --- ./lexi.c    Mon Jul 02 20:39:44 1990
  1601. ***************
  1602. *** 18,23 ****
  1603. --- 18,40 ----
  1604.    * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  1605.    */
  1606.   
  1607. + /*
  1608. +  * MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  1609. +  *
  1610. +  * To this port, the same copying conditions apply as to the
  1611. +  * original release.
  1612. +  *
  1613. +  * IMPORTANT:
  1614. +  * This file is not identical to the original GNU release!
  1615. +  * You should have received this code as patch to the official
  1616. +  * GNU release.
  1617. +  *
  1618. +  * MORE IMPORTANT:
  1619. +  * This port comes with ABSOLUTELY NO WARRANTY.
  1620. +  *
  1621. +  * $Header: e:/gnu/indent/RCS/lexi.c'v 1.1.0.1 90/07/02 10:32:29 tho Exp $
  1622. +  */
  1623. + 
  1624.   #ifndef lint
  1625.   static char sccsid[] = "@(#)lexi.c    5.11 (Berkeley) 9/15/88";
  1626.   #endif /* not lint */
  1627. *************** static char sccsid[] = "@(#)lexi.c    5.11 
  1628. *** 31,36 ****
  1629. --- 48,57 ----
  1630.   #include "indent_globs.h"
  1631.   #include <ctype.h>
  1632.   
  1633. + #ifdef MSDOS
  1634. + static int hash (char *, int);
  1635. + #endif
  1636. + 
  1637.   #define alphanum 1
  1638.   #define opchar 3
  1639.   
  1640. *************** lexi()
  1641. *** 582,587 ****
  1642. --- 603,609 ----
  1643.   /*
  1644.    * Add the given keyword to the keyword table, using val as the keyword type
  1645.    */
  1646. + void
  1647.   addkey(key, val)
  1648.       char       *key;
  1649.        enum rwcodes val;
  1650. diff -cBdNp e:/gnu/indent/gnu/makefile ./makefile
  1651. *** e:/gnu/indent/gnu/makefile    Mon Jul 02 20:40:01 1990
  1652. --- ./makefile    Mon Jul 02 20:39:48 1990
  1653. ***************
  1654. *** 0 ****
  1655. --- 1,62 ----
  1656. + # Copyright (c) 1987 Regents of the University of California.
  1657. + # All rights reserved.
  1658. + #
  1659. + # Redistribution and use in source and binary forms are permitted
  1660. + # provided that the above copyright notice and this paragraph are
  1661. + # duplicated in all such forms and that any documentation,
  1662. + # advertising materials, and other materials related to such
  1663. + # distribution and use acknowledge that the software was developed
  1664. + # by the University of California, Berkeley.  The name of the
  1665. + # University may not be used to endorse or promote products derived
  1666. + # from this software without specific prior written permission.
  1667. + # THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  1668. + # IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  1669. + # WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  1670. + #
  1671. + #    @(#)Makefile    5.9 (Berkeley) 9/15/88
  1672. + #
  1673. + # $Header: e:/gnu/indent/RCS/makefile.'v 1.1.0.3 90/07/02 20:22:49 tho Exp $
  1674. + #
  1675. + 
  1676. + BINDIR    = c:/bin
  1677. + 
  1678. + # MSC 5.1 bombs with -Oailt -Gs, we have not yet taken pains to spot
  1679. + # the faulty module.
  1680. + # Floating point makes no sense, pretending to use the alternate library
  1681. + # prevents the dumb linker from loading to much floating point code.
  1682. + 
  1683. + CFLAGS    = -AH -FPa -Oilt -Gs -W3
  1684. + LDFLAGS    = /e/st:0x2000
  1685. + 
  1686. + SRCS    = indent.c io.c lexi.c parse.c pr_comment.c args.c globs.c
  1687. + OBJS    = indent.obj io.obj lexi.obj parse.obj pr_comment.obj \
  1688. +       args.obj globs.obj
  1689. + HEADERS    = indent_g.h version.h
  1690. + 
  1691. + all: indent.exe
  1692. + 
  1693. + indent.exe: $(OBJS)
  1694. +     $(LINK) $(LDFLAGS) $(OBJS), $@;
  1695. + 
  1696. + zip:
  1697. +     pkzip -f indent'v
  1698. + 
  1699. + disk:
  1700. +     cp indent'v.zip b:/indent'v.zip
  1701. +     pkunzip -t b:/indent'v | grep -vw OK
  1702. + 
  1703. + $(OBJS): indent_globs.h
  1704. + args.obj: version.h
  1705. + 
  1706. + install:
  1707. +     cp indent.exe $(BINDIR)
  1708. + 
  1709. + clean:
  1710. +     rm -f *.exe *.obj errs tags
  1711. +     rcsclean *.c *.h
  1712. + 
  1713. + tags: $(SRCS) $(HEADERS)
  1714. +     etags -t *.h *.c
  1715. + 
  1716. + 
  1717. + 
  1718. diff -cBdNp e:/gnu/indent/gnu/parse.c ./parse.c
  1719. *** e:/gnu/indent/gnu/parse.c    Mon Jul 02 20:39:22 1990
  1720. --- ./parse.c    Mon Jul 02 20:39:46 1990
  1721. ***************
  1722. *** 18,23 ****
  1723. --- 18,40 ----
  1724.    * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  1725.    */
  1726.   
  1727. + /*
  1728. +  * MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  1729. +  *
  1730. +  * To this port, the same copying conditions apply as to the
  1731. +  * original release.
  1732. +  *
  1733. +  * IMPORTANT:
  1734. +  * This file is not identical to the original GNU release!
  1735. +  * You should have received this code as patch to the official
  1736. +  * GNU release.
  1737. +  *
  1738. +  * MORE IMPORTANT:
  1739. +  * This port comes with ABSOLUTELY NO WARRANTY.
  1740. +  *
  1741. +  * $Header: e:/gnu/indent/RCS/parse.c'v 1.1.0.1 90/07/02 10:32:31 tho Exp $
  1742. +  */
  1743. + 
  1744.   #ifndef lint
  1745.   static char sccsid[] = "@(#)parse.c    5.8 (Berkeley) 9/15/88";
  1746.   #endif /* not lint */
  1747. *************** static char sccsid[] = "@(#)parse.c    5.8 
  1748. *** 24,29 ****
  1749. --- 41,50 ----
  1750.   
  1751.   #include "indent_globs.h"
  1752.   
  1753. + #ifdef MSDOS
  1754. + static int inc_pstack (void);
  1755. + #endif
  1756. + 
  1757.   struct parser_state *parser_state_tos;
  1758.   
  1759.   /* like ++parser_state_tos->tos but checks for stack overflow and extends
  1760. *************** parse(tk)
  1761. *** 280,285 ****
  1762. --- 301,307 ----
  1763.   /*----------------------------------------------*\
  1764.   |   REDUCTION PHASE                    |
  1765.   \*----------------------------------------------*/
  1766. + void
  1767.   reduce()
  1768.   {
  1769.   
  1770. diff -cBdNp e:/gnu/indent/gnu/pr_comme.c ./pr_comme.c
  1771. *** e:/gnu/indent/gnu/pr_comme.c    Mon Jul 02 20:39:24 1990
  1772. --- ./pr_comme.c    Mon Jul 02 20:39:46 1990
  1773. ***************
  1774. *** 18,23 ****
  1775. --- 18,40 ----
  1776.    * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  1777.    */
  1778.   
  1779. + /*
  1780. +  * MS-DOS port (c) 1990 by Thorsten Ohl, td12@ddagsi3.bitnet
  1781. +  *
  1782. +  * To this port, the same copying conditions apply as to the
  1783. +  * original release.
  1784. +  *
  1785. +  * IMPORTANT:
  1786. +  * This file is not identical to the original GNU release!
  1787. +  * You should have received this code as patch to the official
  1788. +  * GNU release.
  1789. +  *
  1790. +  * MORE IMPORTANT:
  1791. +  * This port comes with ABSOLUTELY NO WARRANTY.
  1792. +  *
  1793. +  * $Header: e:/gnu/indent/RCS/pr_comme.c'v 1.1.0.1 90/07/02 10:32:33 tho Exp $
  1794. +  */
  1795. + 
  1796.   #ifndef lint
  1797.   static char sccsid[] = "@(#)pr_comment.c    5.9 (Berkeley) 9/15/88";
  1798.   #endif /* not lint */
  1799. *************** static char sccsid[] = "@(#)pr_comment.c
  1800. *** 56,62 ****
  1801.   
  1802.   #include "indent_globs.h"
  1803.   
  1804. ! 
  1805.   pr_comment()
  1806.   {
  1807.       int         now_col;    /* column we are in now */
  1808. --- 73,79 ----
  1809.   
  1810.   #include "indent_globs.h"
  1811.   
  1812. ! void
  1813.   pr_comment()
  1814.   {
  1815.       int         now_col;    /* column we are in now */
  1816. diff -cBdNp e:/gnu/indent/gnu/version.h ./version.h
  1817. *** e:/gnu/indent/gnu/version.h    Mon Jul 02 20:39:24 1990
  1818. --- ./version.h    Mon Jul 02 20:39:48 1990
  1819. ***************
  1820. *** 1,5 ****
  1821.   #define VERSION_STRING \
  1822. ! "GNU indent 1.1.  Based on Berkeley indent 5.11 (9/15/88)."
  1823.   
  1824.   /* Not strictly true, because I've merged in a bunch of changes
  1825.      from the BSD version of Sep 89, but it wouldn't really be correct
  1826. --- 1,6 ----
  1827.   #define VERSION_STRING \
  1828. ! "GNU indent 1.1.  Based on Berkeley indent 5.11 (9/15/88).\n"\
  1829. ! "$Header: e:/gnu/indent/RCS/version.h'v 1.1.0.1 90/01/16 22:09:21 tho Exp $"
  1830.   
  1831.   /* Not strictly true, because I've merged in a bunch of changes
  1832.      from the BSD version of Sep 89, but it wouldn't really be correct
  1833.