home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 1 / FFMCD01.bin / bbs / libdisks / d800t899 / disk848.lha / CWeb / CWeb27.lha / ctangle.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  28.8 KB  |  1,443 lines
  1. #define banner "This is CTANGLE (Version 2.7 [p6a])\n"
  2. #line 56 "ctangle.w"
  3.  
  4. #define max_bytes 90000 \
  5.  
  6. #line 161 "ctangl-p.ch"
  7.  
  8. #define max_toks 270000
  9. #line 95 "ctangle.w"
  10.  
  11. #define max_names 4000 \
  12.  
  13. #define max_texts 2500
  14. #define hash_size 353
  15. #define longest_name 400
  16. #define stack_size 50
  17. #define buf_size 100 \
  18.  
  19. #define tangle 0
  20. #define weave 1 \
  21.  
  22. #define and_and 04
  23. #define lt_lt 020
  24. #define gt_gt 021
  25. #define plus_plus 013
  26. #define minus_minus 01
  27. #define minus_gt 031
  28. #define not_eq 032
  29. #define lt_eq 034
  30. #define gt_eq 035
  31. #define eq_eq 036
  32. #define or_or 037
  33. #define colon_colon 06
  34. #define period_ast 026
  35. #define minus_gt_ast 027 \
  36.  
  37. #define dot_dot_dot 016 \
  38.  \
  39.  
  40. #define length(c)(c+1)->byte_start-(c)->byte_start
  41. #define print_id(c)term_write((c)->byte_start,length((c))) \
  42.  
  43. #define llink link
  44. #define rlink dummy.Rlink
  45. #define root name_dir->rlink \
  46.  \
  47.  
  48. #define spotless 0
  49. #define harmless_message 1
  50. #define error_message 2
  51. #define fatal_message 3
  52. #define mark_harmless {if(history==spotless)history= harmless_message;}
  53. #define mark_error history= error_message
  54. #define confusion(s)fatal("! This can't happen: ",s)
  55. #define fatal(s,t){ \
  56. printf(s);err_print(t); \
  57. history= fatal_message;wrap_up(); \
  58. }
  59. #define overflow(t){ \
  60. printf("\n! Sorry, %s capacity exceeded",t);fatal("",""); \
  61. } \
  62.  
  63. #define max_file_name_length 60
  64. #define cur_file file[include_depth]
  65. #define cur_file_name file_name[include_depth]
  66. #define web_file_name file_name[0]
  67. #define cur_line line[include_depth] \
  68.  
  69. #define show_banner flags['b']
  70. #define show_progress flags['p']
  71. #define show_happiness flags['h']
  72. #define use_amiga_keywords flags['a']
  73. #define use_german_macros flags['g'] \
  74.  
  75. #define update_terminal fflush(stdout)
  76. #define new_line putchar('\n')
  77. #define putxchar putchar
  78. #define term_write(a,b)fflush(stdout),write(1,a,b)
  79. #define line_write(c)write(fileno(C_file),c)
  80. #define C_printf(c,a)fprintf(C_file,c,a)
  81. #define C_putc(c)putc(c,C_file) \
  82.  
  83. #define equiv equiv_or_xref \
  84.  
  85. #define module_flag max_texts \
  86.  
  87. #define string 02
  88. #define join 0177 \
  89.  
  90. #define cur_end cur_state.end_field
  91. #define cur_byte cur_state.byte_field
  92. #define cur_name cur_state.name_field
  93. #define cur_repl cur_state.repl_field
  94. #define cur_mod cur_state.mod_field \
  95.  
  96. #define module_number 0201
  97. #define identifier 0202 \
  98.  
  99. #define misc 0
  100. #define num_or_id 1
  101. #define unbreakable 3
  102. #define verbatim 4 \
  103.  
  104. #define max_files 256
  105. #define ignore 0
  106. #define ord 0302
  107. #define control_text 0303
  108. #define format_code 0304
  109. #define definition 0305
  110. #define begin_C 0306
  111. #define module_name 0307
  112. #define new_module 0310 \
  113.  
  114. #define constant 03 \
  115.  
  116. #define isxalpha(c)((c)=='_') \
  117.  
  118. #line 387 "ctangl-p.ch"
  119.  
  120. #define compress(c)if(loc++<=limit)return(c) \
  121.  
  122. #define macro 0
  123. #define app_repl(c){if(tok_ptr==tok_mem_end)overflow("token");*tok_ptr++= c;} \
  124.  
  125. /*2:*/
  126. #line 67 "ctangle.w"
  127.  
  128. /*5:*/
  129. #line 61 "common-p.h"
  130.  
  131. #include <stdio.h>
  132. #ifdef __TURBOC__
  133. #include <io.h>
  134. #endif
  135.  
  136. /*:5*//*53:*/
  137. #line 746 "ctangle.w"
  138.  
  139. #include <ctype.h> 
  140.  
  141. /*:53*//*83:*/
  142. #line 571 "ctangl-p.ch"
  143.  
  144. #include <string.h>
  145. #include <fcntl.h>
  146.  
  147. /*:83*/
  148. #line 68 "ctangle.w"
  149.  
  150. /*4:*/
  151. #line 48 "common-p.h"
  152.  
  153. typedef short boolean;
  154. typedef char unsigned eight_bits;
  155. extern boolean program;
  156. extern int phase;
  157. extern void common_init(void);
  158. extern void print_stats(void);
  159. #ifdef __TURBOC__
  160. #define HUGE huge
  161. #else
  162. #define HUGE
  163. #endif
  164.  
  165. /*:4*//*6:*/
  166. #line 88 "common-p.h"
  167.  
  168. char mod_text[longest_name+1];
  169. char*mod_text_end= mod_text+longest_name;
  170. char*id_first;
  171. char*id_loc;
  172.  
  173. /*:6*//*7:*/
  174. #line 96 "common-p.h"
  175.  
  176. extern char buffer[];
  177. extern char*buffer_end;
  178. extern char*loc;
  179. extern char*limit;
  180.  
  181. /*:7*//*8:*/
  182. #line 111 "common-p.h"
  183.  
  184. typedef struct name_info{
  185. char HUGE*byte_start;
  186. struct name_info HUGE*link;
  187. union{
  188. struct name_info HUGE*Rlink;
  189.  
  190. char Ilk;
  191. }dummy;
  192. char HUGE*equiv_or_xref;
  193. }name_info;
  194. typedef name_info HUGE*name_pointer;
  195. typedef name_pointer*hash_pointer;
  196. #ifdef __TURBOC__
  197. extern char HUGE*byte_mem;
  198. extern name_info HUGE*name_dir;
  199. #else
  200. extern char byte_mem[];
  201. extern name_info name_dir[];
  202. #endif
  203. extern char HUGE*byte_mem_end;
  204. extern name_pointer name_dir_end;
  205. extern name_pointer name_ptr;
  206. extern char HUGE*byte_ptr;
  207. #ifdef __TURBOC__
  208. void far*allocsafe(unsigned long nunits,unsigned long unitsz);
  209. #endif
  210. extern name_pointer hash[];
  211. extern hash_pointer hash_end;
  212. extern hash_pointer h;
  213. extern name_pointer id_lookup(char*first,char*last,char t);
  214.  
  215. extern name_pointer mod_lookup(char*k,char*l);
  216. extern name_pointer prefix_lookup(char*k,char*l);
  217. extern boolean names_match(name_pointer p,char*first,int l,eight_bits t);
  218. extern void init_p(name_pointer p,eight_bits t);
  219. extern void init_node(name_pointer p);
  220.  
  221. /*:8*//*9:*/
  222. #line 165 "common-p.h"
  223.  
  224. extern history;
  225. extern void err_print(char*s);
  226. extern void wrap_up(void);
  227.  
  228. /*:9*//*10:*/
  229. #line 178 "common-p.h"
  230.  
  231. extern include_depth;
  232. extern FILE*file[];
  233. extern FILE*change_file;
  234. extern char C_file_name[];
  235. extern char tex_file_name[];
  236. extern char file_name[][max_file_name_length];
  237.  
  238. extern char change_file_name[];
  239. extern line[];
  240. extern change_line;
  241. extern boolean input_has_ended;
  242. extern boolean changing;
  243. extern boolean web_file_open;
  244. extern void reset_input(void);
  245. extern boolean get_line(void);
  246. extern void check_complete(void);
  247.  
  248. /*:10*//*11:*/
  249. #line 197 "common-p.h"
  250.  
  251. typedef unsigned short sixteen_bits;
  252. extern sixteen_bits module_count;
  253. extern boolean changed_module[];
  254. extern boolean change_pending;
  255. extern boolean print_where;
  256.  
  257. /*:11*//*12:*/
  258. #line 211 "common-p.h"
  259.  
  260. extern int argc;
  261. extern char**argv;
  262. extern boolean flags[];
  263.  
  264. /*:12*//*13:*/
  265. #line 224 "common-p.h"
  266.  
  267. extern FILE*C_file;
  268. extern FILE*tex_file;
  269. #line 108 "ctangle.w"
  270.  
  271. /*:13*/
  272. #line 69 "ctangle.w"
  273.  
  274. /*14:*/
  275. #line 132 "ctangle.w"
  276.  
  277. typedef struct{
  278. #line 173 "ctangl-p.ch"
  279. eight_bits HUGE*tok_start;
  280. #line 135 "ctangle.w"
  281. sixteen_bits text_link;
  282. }text;
  283. typedef text*text_pointer;
  284.  
  285. /*:14*//*25:*/
  286. #line 272 "ctangle.w"
  287.  
  288. typedef struct{
  289. #line 259 "ctangl-p.ch"
  290. eight_bits HUGE*end_field;
  291. eight_bits HUGE*byte_field;
  292. #line 276 "ctangle.w"
  293. name_pointer name_field;
  294. text_pointer repl_field;
  295. sixteen_bits mod_field;
  296. }output_state;
  297. typedef output_state*stack_pointer;
  298.  
  299. /*:25*/
  300. #line 70 "ctangle.w"
  301.  
  302. /*15:*/
  303. #line 139 "ctangle.w"
  304.  
  305. text text_info[max_texts];
  306. text_pointer text_info_end= text_info+max_texts-1;
  307. text_pointer text_ptr;
  308. #line 181 "ctangl-p.ch"
  309. #ifdef __TURBOC__
  310. eight_bits HUGE*tok_mem;
  311. eight_bits HUGE*tok_mem_end;
  312. #else
  313. eight_bits tok_mem[max_toks];
  314. eight_bits*tok_mem_end= tok_mem+max_toks-1;
  315. #endif
  316. eight_bits HUGE*tok_ptr;
  317. #line 146 "ctangle.w"
  318.  
  319. /*:15*//*21:*/
  320. #line 205 "ctangle.w"
  321.  
  322. text_pointer last_unnamed;
  323.  
  324. /*:21*//*26:*/
  325. #line 288 "ctangle.w"
  326.  
  327. output_state cur_state;
  328.  
  329. output_state stack[stack_size+1];
  330. stack_pointer stack_ptr;
  331. stack_pointer stack_end= stack+stack_size;
  332.  
  333. /*:26*//*30:*/
  334. #line 353 "ctangle.w"
  335.  
  336. int cur_val;
  337.  
  338. /*:30*//*34:*/
  339. #line 429 "ctangle.w"
  340.  
  341. eight_bits out_state;
  342. boolean protect;
  343.  
  344. /*:34*//*36:*/
  345. #line 456 "ctangle.w"
  346.  
  347. name_pointer output_files[max_files];
  348. name_pointer*cur_out_file,*end_output_files,*an_output_file;
  349. char cur_module_char;
  350. char output_file_name[longest_name];
  351.  
  352. /*:36*//*47:*/
  353. #line 667 "ctangle.w"
  354.  
  355. eight_bits ccode[128];
  356.  
  357. /*:47*//*50:*/
  358. #line 711 "ctangle.w"
  359.  
  360. #line 712 "ctangle.w"
  361. boolean comment_continues= 0;
  362.  
  363. /*:50*//*52:*/
  364. #line 743 "ctangle.w"
  365.  
  366. name_pointer cur_module;
  367.  
  368. /*:52*//*66:*/
  369. #line 1009 "ctangle.w"
  370.  
  371. text_pointer cur_text;
  372. eight_bits next_control;
  373.  
  374. #line 455 "ctangl-p.ch"
  375. /*:66*//*73:*/
  376. #line 1130 "ctangle.w"
  377.  
  378. extern sixteen_bits module_count;
  379.  
  380. /*:73*/
  381. #line 71 "ctangle.w"
  382.  
  383.  
  384. #line 132 "ctangl-p.ch"
  385. /*82:*/
  386. #line 553 "ctangl-p.ch"
  387.  
  388. static void store_two_bytes(sixteen_bits x);
  389. static void push_level(name_pointer p);
  390. static void pop_level(void);
  391. static void get_output(void);
  392. static void flush_buffer(void);
  393. static void phase_two(void);
  394. static void out_char(eight_bits cur_char);
  395. static eight_bits skip_ahead(void);
  396. static boolean skip_comment(boolean long_style);
  397. static eight_bits get_next(void);
  398. static void scan_repl(eight_bits t);
  399. static void scan_module(void);
  400. static void phase_one(void);
  401.  
  402. /*:82*/
  403. #line 132 "ctangl-p.ch"
  404.  
  405.  
  406. int main(int ac,char*av[])
  407. #line 76 "ctangle.w"
  408. {
  409. argc= ac;argv= av;
  410. program= tangle;
  411. /*16:*/
  412. #line 147 "ctangle.w"
  413.  
  414. #line 194 "ctangl-p.ch"
  415. #ifdef __TURBOC__
  416. tok_mem= allocsafe(max_toks,sizeof(*tok_mem));
  417. tok_mem_end= tok_mem+max_toks-1;
  418. #endif
  419. text_info->tok_start= tok_ptr= tok_mem;
  420. #line 149 "ctangle.w"
  421. text_ptr= text_info+1;text_ptr->tok_start= tok_mem;
  422.  
  423.  
  424. /*:16*//*18:*/
  425. #line 157 "ctangle.w"
  426.  
  427. #line 204 "ctangl-p.ch"
  428. name_dir->equiv= (char HUGE*)text_info;
  429. #line 159 "ctangle.w"
  430.  
  431. /*:18*//*22:*/
  432. #line 208 "ctangle.w"
  433. last_unnamed= text_info;text_info->text_link= 0;
  434.  
  435. /*:22*//*37:*/
  436. #line 466 "ctangle.w"
  437.  
  438. cur_out_file= end_output_files= output_files+max_files;
  439.  
  440. /*:37*//*48:*/
  441. #line 670 "ctangle.w"
  442. {
  443. int c;
  444. for(c= 0;c<=127;c++)ccode[c]= ignore;
  445. ccode[' ']= ccode['\t']= ccode['\n']= ccode['\v']= ccode['\r']= ccode['\f']
  446. = ccode['*']= new_module;
  447. ccode['@']= '@';ccode['=']= string;
  448. ccode['d']= ccode['D']= definition;
  449. ccode['f']= ccode['F']= ccode['s']= ccode['S']= format_code;
  450. ccode['c']= ccode['C']= ccode['p']= ccode['P']= begin_C;
  451. ccode['^']= ccode[':']= ccode['.']= ccode['t']= ccode['T']= 
  452. ccode['q']= ccode['Q']= control_text;
  453. ccode['&']= join;
  454. ccode['<']= ccode['(']= module_name;
  455. ccode['\'']= ord;
  456. }
  457.  
  458. /*:48*//*62:*/
  459. #line 937 "ctangle.w"
  460. mod_text[0]= ' ';
  461.  
  462. /*:62*/
  463. #line 79 "ctangle.w"
  464. ;
  465. common_init();
  466. if(show_banner)printf(banner);
  467. phase_one();
  468. phase_two();
  469. #line 141 "ctangl-p.ch"
  470. wrap_up();
  471. return(0);
  472. #line 85 "ctangle.w"
  473. }
  474.  
  475. #line 149 "ctangl-p.ch"
  476. /*:2*//*19:*/
  477. #line 163 "ctangle.w"
  478.  
  479. #line 214 "ctangl-p.ch"
  480. boolean names_match(name_pointer p,char*first,int l,eight_bits dummy)
  481.  
  482.  
  483.  
  484.  
  485. #line 168 "ctangle.w"
  486. {
  487. if(length(p)!=l)return 0;
  488. #line 224 "ctangl-p.ch"
  489. return((boolean)!strncmp(first,p->byte_start,l));
  490. #line 171 "ctangle.w"
  491. }
  492.  
  493. /*:19*//*20:*/
  494. #line 178 "ctangle.w"
  495.  
  496. #line 231 "ctangl-p.ch"
  497. void init_node(name_pointer node)
  498. #line 181 "ctangle.w"
  499. {
  500. #line 237 "ctangl-p.ch"
  501. node->equiv= (char HUGE*)text_info;
  502. #line 183 "ctangle.w"
  503. }
  504. #line 244 "ctangl-p.ch"
  505. void init_p(name_pointer dummy1,eight_bits dummy2)
  506. {}
  507. #line 185 "ctangle.w"
  508.  
  509. /*:20*//*24:*/
  510. #line 252 "ctangl-p.ch"
  511. static void store_two_bytes(sixteen_bits x)
  512. #line 240 "ctangle.w"
  513. {
  514. if(tok_ptr+2>tok_mem_end)overflow("token");
  515. *tok_ptr++= x>>8;
  516. *tok_ptr++= x&0377;
  517. }
  518.  
  519. /*:24*//*28:*/
  520. #line 267 "ctangl-p.ch"
  521. static void push_level(name_pointer p)
  522. #line 314 "ctangle.w"
  523. {
  524. if(stack_ptr==stack_end)overflow("stack");
  525. *stack_ptr= cur_state;
  526. stack_ptr++;
  527. cur_name= p;cur_repl= (text_pointer)p->equiv;
  528. cur_byte= cur_repl->tok_start;cur_end= (cur_repl+1)->tok_start;
  529. cur_mod= 0;
  530. }
  531.  
  532. /*:28*//*29:*/
  533. #line 273 "ctangl-p.ch"
  534. static void pop_level(void)
  535. #line 328 "ctangle.w"
  536. {
  537. if(cur_repl->text_link<module_flag){
  538. cur_repl= cur_repl->text_link+text_info;
  539. cur_byte= cur_repl->tok_start;cur_end= (cur_repl+1)->tok_start;
  540. return;
  541. }
  542. stack_ptr--;
  543. if(stack_ptr>stack)cur_state= *stack_ptr;
  544. }
  545.  
  546. /*:29*//*31:*/
  547. #line 279 "ctangl-p.ch"
  548. static void get_output(void)
  549. #line 360 "ctangle.w"
  550. {
  551. sixteen_bits a;
  552. restart:if(stack_ptr==stack)return;
  553. if(cur_byte==cur_end){
  554. cur_val= -((int)cur_mod);
  555. pop_level();
  556. if(cur_val==0)goto restart;
  557. out_char(module_number);return;
  558. }
  559. a= *cur_byte++;
  560. if(a<0200)out_char(a);
  561. else{
  562. a= (a-0200)*0400+*cur_byte++;
  563. switch(a/024000){
  564. case 0:cur_val= a;out_char(identifier);break;
  565. case 1:/*32:*/
  566. #line 385 "ctangle.w"
  567.  
  568. a-= 024000;
  569. #line 285 "ctangl-p.ch"
  570. if((a+name_dir)->equiv!=(char HUGE*)text_info)push_level(a+name_dir);
  571. #line 388 "ctangle.w"
  572. else if(a!=0){
  573. printf("\n! Not present: <");print_id(a+name_dir);err_print(">");
  574.  
  575. }
  576. goto restart;
  577.  
  578. /*:32*/
  579. #line 375 "ctangle.w"
  580. ;
  581. default:cur_val= a-050000;if(cur_val>0)cur_mod= cur_val;
  582. out_char(module_number);
  583. }
  584. }
  585. }
  586.  
  587. /*:31*//*35:*/
  588. #line 291 "ctangl-p.ch"
  589. static void flush_buffer(void)
  590. #line 438 "ctangle.w"
  591. {
  592. C_putc('\n');
  593. if(cur_line%100==0&&show_progress){
  594. printf(".");
  595. if(cur_line%500==0)printf("%d",cur_line);
  596. update_terminal;
  597. }
  598. cur_line++;
  599. }
  600.  
  601. /*:35*//*39:*/
  602. #line 487 "ctangle.w"
  603.  
  604. #line 297 "ctangl-p.ch"
  605. static void phase_two(void){
  606. #line 489 "ctangle.w"
  607. web_file_open= 0;
  608. cur_line= 1;
  609. /*41:*/
  610. #line 541 "ctangle.w"
  611. {
  612. sixteen_bits a;
  613. for(cur_text= text_info+1;cur_text<text_ptr;cur_text++)
  614. if(cur_text->text_link==0){
  615. cur_byte= cur_text->tok_start;
  616. cur_end= (cur_text+1)->tok_start;
  617. C_printf("#define ",0);
  618. out_state= misc;
  619. protect= 1;
  620. while(cur_byte<cur_end){
  621. a= *cur_byte++;
  622. if(cur_byte==cur_end&&a=='\n')break;
  623. if(a<0200)out_char(a);
  624. else{
  625. a= (a-0200)*0400+*cur_byte++;
  626. if(a<024000){
  627. cur_val= a;out_char(identifier);
  628. }
  629. else if(a<050000){confusion("macros defs have strange char");}
  630. else{
  631. cur_val= a-050000;cur_mod= cur_val;out_char(module_number);
  632. }
  633.  
  634. }
  635. }
  636. protect= 0;
  637. flush_buffer();
  638. }
  639. }
  640.  
  641. /*:41*/
  642. #line 491 "ctangle.w"
  643. ;
  644. if(text_info->text_link==0&&cur_out_file==end_output_files){
  645. printf("\n! No program text was specified.");mark_harmless;
  646.  
  647. }
  648. else{
  649. if(show_progress){
  650. if(cur_out_file==end_output_files)
  651. printf("\nWriting the output file (%s):",C_file_name);
  652. else{printf("\nWriting the output files:");
  653.  
  654. if(text_info->text_link==0)goto writeloop;
  655. printf(" (%s)",C_file_name);
  656. update_terminal;
  657. }
  658. }
  659. /*27:*/
  660. #line 301 "ctangle.w"
  661.  
  662. stack_ptr= stack+1;cur_name= name_dir;cur_repl= text_info->text_link+text_info;
  663. cur_byte= cur_repl->tok_start;cur_end= (cur_repl+1)->tok_start;cur_mod= 0;
  664.  
  665. /*:27*/
  666. #line 507 "ctangle.w"
  667. ;
  668. while(stack_ptr>stack)get_output();
  669. flush_buffer();
  670. writeloop:/*40:*/
  671. #line 518 "ctangle.w"
  672.  
  673. for(an_output_file= end_output_files;an_output_file>cur_out_file;){
  674. an_output_file--;
  675. strncpy(output_file_name,(*an_output_file)->byte_start,longest_name);
  676. output_file_name[length(*an_output_file)]= '\0';
  677. fclose(C_file);
  678. C_file= fopen(output_file_name,"w");
  679. if(C_file==0)fatal("! Cannot open output file:",output_file_name);
  680.  
  681. printf("\n(%s)",output_file_name);update_terminal;
  682. cur_line= 1;
  683. stack_ptr= stack+1;
  684. cur_name= (*an_output_file);
  685. cur_repl= (text_pointer)cur_name->equiv;
  686. cur_byte= cur_repl->tok_start;
  687. cur_end= (cur_repl+1)->tok_start;
  688. while(stack_ptr>stack)get_output();
  689. flush_buffer();
  690. }
  691.  
  692. /*:40*/
  693. #line 510 "ctangle.w"
  694. ;
  695. if(show_happiness)printf("\nDone.");
  696. }
  697. }
  698.  
  699. /*:39*//*42:*/
  700. #line 304 "ctangl-p.ch"
  701. static void out_char(eight_bits cur_char)
  702. #line 575 "ctangle.w"
  703. {
  704. #line 310 "ctangl-p.ch"
  705. char HUGE*j;
  706. #line 577 "ctangle.w"
  707. switch(cur_char){
  708. case'\n':if(protect)C_putc(' ');
  709. if(protect||out_state==verbatim)C_putc('\\');
  710. flush_buffer();if(out_state!=verbatim)out_state= misc;break;
  711. /*44:*/
  712. #line 613 "ctangle.w"
  713.  
  714. case identifier:
  715. if(out_state==num_or_id)C_putc(' ');
  716. for(j= (cur_val+name_dir)->byte_start;j<(name_dir+cur_val+1)->byte_start;
  717. j++)C_putc(*j);
  718. out_state= num_or_id;break;
  719.  
  720. /*:44*/
  721. #line 581 "ctangle.w"
  722. ;
  723. /*45:*/
  724. #line 620 "ctangle.w"
  725.  
  726. case module_number:
  727. if(cur_val>0)C_printf("/*%d:*/",cur_val);
  728. else if(cur_val<0)C_printf("/*:%d*/",-cur_val);
  729. else{
  730. sixteen_bits a;
  731. a= 0400**cur_byte++;
  732. a+= *cur_byte++;
  733. C_printf("\n#line %d \"",a);
  734. cur_val= *cur_byte++;
  735. cur_val= 0400*(cur_val-0200)+*cur_byte++;
  736. for(j= (cur_val+name_dir)->byte_start;j<(name_dir+cur_val+1)->byte_start;
  737. j++)C_putc(*j);
  738. C_printf("\"\n",0);
  739. }
  740. break;
  741.  
  742. /*:45*/
  743. #line 582 "ctangle.w"
  744. ;
  745. /*43:*/
  746. #line 600 "ctangle.w"
  747.  
  748. case plus_plus:C_putc('+');C_putc('+');out_state= misc;break;
  749. case minus_minus:C_putc('-');C_putc('-');out_state= misc;break;
  750. case minus_gt:C_putc('-');C_putc('>');out_state= misc;break;
  751. case gt_gt:C_putc('>');C_putc('>');out_state= misc;break;
  752. case eq_eq:C_putc('=');C_putc('=');out_state= misc;break;
  753. case lt_lt:C_putc('<');C_putc('<');out_state= misc;break;
  754. case gt_eq:C_putc('>');C_putc('=');out_state= misc;break;
  755. case lt_eq:C_putc('<');C_putc('=');out_state= misc;break;
  756. case not_eq:C_putc('!');C_putc('=');out_state= misc;break;
  757. case and_and:C_putc('&');C_putc('&');out_state= misc;break;
  758. #line 316 "ctangl-p.ch"
  759. case or_or:C_putc('|');C_putc('|');out_state= misc;break;
  760. case colon_colon:C_putc(':');C_putc(':');out_state= misc;break;
  761. case period_ast:C_putc('.');C_putc('*');out_state= misc;break;
  762. case minus_gt_ast:C_putc('-');C_putc('>');C_putc('*');out_state= misc;
  763. break;
  764. case dot_dot_dot:C_putc('.');C_putc('.');C_putc('.');out_state= misc;
  765. break;
  766. #line 612 "ctangle.w"
  767.  
  768. /*:43*/
  769. #line 583 "ctangle.w"
  770. ;
  771. case'=':C_putc('=');if(out_state!=verbatim){
  772. C_putc(' ');out_state= misc;
  773. }
  774. break;
  775. case join:out_state= unbreakable;break;
  776. case constant:if(out_state==verbatim){
  777. out_state= num_or_id;break;
  778. }
  779. if(out_state==num_or_id)C_putc(' ');out_state= verbatim;break;
  780. case string:if(out_state==verbatim)out_state= misc;
  781. else out_state= verbatim;break;
  782. default:C_putc(cur_char);if(out_state!=verbatim)out_state= misc;
  783. break;
  784. }
  785. }
  786.  
  787. /*:42*//*49:*/
  788. #line 328 "ctangl-p.ch"
  789. static eight_bits skip_ahead(void)
  790. #line 690 "ctangle.w"
  791. {
  792. eight_bits c;
  793. while(1){
  794. if(loc>limit&&(get_line()==0))return(new_module);
  795. *(limit+1)= '@';
  796. while(*loc!='@')loc++;
  797. if(loc<=limit){
  798. loc++;c= ccode[*loc];loc++;
  799. if(c!=ignore||*(loc-1)=='>')return(c);
  800. }
  801. }
  802. }
  803.  
  804. /*:49*//*51:*/
  805. #line 714 "ctangle.w"
  806.  
  807. #line 350 "ctangl-p.ch"
  808. static boolean skip_comment(boolean long_style)
  809. #line 716 "ctangle.w"
  810. {
  811. char c;
  812. while(1){
  813. #line 367 "ctangl-p.ch"
  814. if(loc>limit){
  815. if(long_style){
  816. if(get_line())return(comment_continues= 1);
  817. else{
  818. err_print("! Input ended in mid-comment");
  819.  
  820. return(comment_continues= 0);
  821. }
  822. }
  823. else return(comment_continues= 0);
  824. }
  825. c= *(loc++);
  826. if(long_style&&c=='*'&&*loc=='/'){
  827. loc++;return(comment_continues= 0);
  828. }
  829. #line 728 "ctangle.w"
  830. if(c=='@'){
  831. if(ccode[*loc]==new_module){
  832. err_print("! Section name ended in mid-comment");loc--;
  833.  
  834. return(comment_continues= 0);
  835. }
  836. else loc++;
  837. }
  838. }
  839. }
  840.  
  841. /*:51*//*54:*/
  842. #line 387 "ctangl-p.ch"
  843. static eight_bits get_next(void)
  844. #line 755 "ctangle.w"
  845. {
  846. static int preprocessing= 0;
  847. eight_bits c;
  848. while(1){
  849. if(loc>limit){
  850. if(preprocessing&&*(limit-1)!='\\')preprocessing= 0;
  851. if(get_line()==0)return(new_module);
  852. else if(print_where){
  853. print_where= 0;
  854. /*68:*/
  855. #line 1034 "ctangle.w"
  856.  
  857. store_two_bytes(0150000);
  858. if(changing)id_first= change_file_name;
  859. else id_first= cur_file_name;
  860. id_loc= id_first+strlen(id_first);
  861. if(changing)store_two_bytes((sixteen_bits)change_line);
  862. else store_two_bytes((sixteen_bits)cur_line);
  863. #line 462 "ctangl-p.ch"
  864. {int a= id_lookup(id_first,id_loc,' ')-name_dir;app_repl((a/0400)+0200);
  865. #line 1042 "ctangle.w"
  866. app_repl(a%0400);}
  867.  
  868. /*:68*/
  869. #line 764 "ctangle.w"
  870. ;
  871. }
  872. else return('\n');
  873. }
  874. c= *loc;
  875. #line 394 "ctangl-p.ch"
  876. if(comment_continues||(c=='/'&&(*(loc+1)=='*'||*(loc+1)=='/'))){
  877. skip_comment(comment_continues||*(loc+1)=='*');
  878.  
  879. #line 771 "ctangle.w"
  880. if(comment_continues)return('\n');
  881. else continue;
  882. }
  883. loc++;
  884. if(isdigit(c)||c=='\\'||c=='.')/*57:*/
  885. #line 818 "ctangle.w"
  886. {
  887. id_first= loc-1;
  888. if(*id_first=='.'&&!isdigit(*loc))goto mistake;
  889. if(*id_first=='\\')while(isdigit(*loc))loc++;
  890. else{
  891. if(*id_first=='0'){
  892. if(*loc=='x'||*loc=='X'){
  893. loc++;while(isxdigit(*loc))loc++;goto found;
  894. }
  895. }
  896. while(isdigit(*loc))loc++;
  897. if(*loc=='.'){
  898. loc++;
  899. while(isdigit(*loc))loc++;
  900. }
  901. if(*loc=='e'||*loc=='E'){
  902. if(*++loc=='+'||*loc=='-')loc++;
  903. while(isdigit(*loc))loc++;
  904. }
  905. }
  906. found:if(*loc=='l'||*loc=='L')loc++;
  907. id_loc= loc;
  908. return(constant);
  909. }
  910.  
  911. /*:57*/
  912. #line 775 "ctangle.w"
  913.  
  914. else if(isalpha(c)||isxalpha(c))/*56:*/
  915. #line 812 "ctangle.w"
  916. {
  917. id_first= --loc;
  918. while(isalpha(*++loc)||isdigit(*loc)||isxalpha(*loc));
  919. id_loc= loc;return(identifier);
  920. }
  921.  
  922. /*:56*/
  923. #line 776 "ctangle.w"
  924.  
  925. else if(c=='\''||c=='\"')/*58:*/
  926. #line 848 "ctangle.w"
  927. {
  928. char delim= c;
  929. id_first= mod_text+1;
  930. id_loc= mod_text;*++id_loc= delim;
  931. while(1){
  932. if(loc>=limit){
  933. if(*(limit-1)!='\\'){
  934. err_print("! String didn't end");loc= limit;break;
  935.  
  936. }
  937. if(get_line()==0){
  938. err_print("! Input ended in middle of string");loc= buffer;break;
  939.  
  940. }
  941. else if(++id_loc<=mod_text_end)*id_loc= '\n';
  942.  
  943. }
  944. if((c= *loc++)==delim){
  945. if(++id_loc<=mod_text_end)*id_loc= c;
  946. break;
  947. }
  948. if(c=='\\'){
  949. if(loc>=limit)continue;
  950. if(++id_loc<=mod_text_end)*id_loc= '\\';
  951. c= *loc++;
  952. }
  953. if(++id_loc<=mod_text_end)*id_loc= c;
  954. }
  955. if(id_loc>=mod_text_end){
  956. printf("\n! String too long: ");
  957.  
  958. term_write(mod_text+1,25);
  959. err_print("...");
  960. }
  961. id_loc++;
  962. return(string);
  963. }
  964.  
  965. /*:58*/
  966. #line 777 "ctangle.w"
  967.  
  968. else if(c=='@')/*59:*/
  969. #line 889 "ctangle.w"
  970. {
  971. c= ccode[*loc++];
  972. switch(c){
  973. case ignore:continue;
  974. case control_text:while((c= skip_ahead())=='@');
  975.  
  976. if(*(loc-1)!='>')err_print("! Improper @ within control text");
  977.  
  978. continue;
  979. case module_name:
  980. cur_module_char= *(loc-1);
  981. /*61:*/
  982. #line 920 "ctangle.w"
  983. {
  984. char*k;
  985. /*63:*/
  986. #line 939 "ctangle.w"
  987.  
  988. k= mod_text;
  989. while(1){
  990. if(loc>limit&&get_line()==0){
  991. err_print("! Input ended in section name");
  992.  
  993. loc= buffer+1;break;
  994. }
  995. c= *loc;
  996. /*64:*/
  997. #line 963 "ctangle.w"
  998.  
  999. if(c=='@'){
  1000. c= *(loc+1);
  1001. if(c=='>'){
  1002. loc+= 2;break;
  1003. }
  1004. if(ccode[c]==new_module){
  1005. err_print("! Section name didn't end");break;
  1006.  
  1007. }
  1008. *(++k)= '@';loc++;
  1009. }
  1010.  
  1011. /*:64*/
  1012. #line 948 "ctangle.w"
  1013. ;
  1014. loc++;if(k<mod_text_end)k++;
  1015. if(isspace(c)){
  1016. c= ' ';if(*(k-1)==' ')k--;
  1017. }
  1018. *k= c;
  1019. }
  1020. if(k>=mod_text_end){
  1021. printf("\n! Section name too long: ");
  1022.  
  1023. term_write(mod_text+1,25);
  1024. printf("...");mark_harmless;
  1025. }
  1026. if(*k==' '&&k>mod_text)k--;
  1027.  
  1028. /*:63*/
  1029. #line 922 "ctangle.w"
  1030. ;
  1031. if(k-mod_text>3&&strncmp(k-2,"...",3)==0)cur_module= prefix_lookup(mod_text+1,k-3);
  1032. else cur_module= mod_lookup(mod_text+1,k);
  1033. if(cur_module_char=='(')
  1034. /*38:*/
  1035. #line 470 "ctangle.w"
  1036.  
  1037. {
  1038. if(cur_out_file>output_files){
  1039. for(an_output_file= cur_out_file;
  1040. an_output_file<end_output_files;an_output_file++)
  1041. if(*an_output_file==cur_module)break;
  1042. if(an_output_file==end_output_files)
  1043. *--cur_out_file= cur_module;
  1044. }else{
  1045. overflow("output files");
  1046. }
  1047. }
  1048.  
  1049.  
  1050. /*:38*/
  1051. #line 927 "ctangle.w"
  1052. ;
  1053. return(module_name);
  1054. }
  1055.  
  1056. /*:61*/
  1057. #line 900 "ctangle.w"
  1058. ;
  1059. case string:/*65:*/
  1060. #line 981 "ctangle.w"
  1061. {
  1062. id_first= loc++;*(limit+1)= '@';*(limit+2)= '>';
  1063. while(*loc!='@'||*(loc+1)!='>')loc++;
  1064. if(loc>=limit)err_print("! Verbatim string didn't end");
  1065.  
  1066. id_loc= loc;loc+= 2;
  1067. return(string);
  1068. }
  1069.  
  1070. /*:65*/
  1071. #line 901 "ctangle.w"
  1072. ;
  1073. case ord:/*60:*/
  1074. #line 430 "ctangl-p.ch"
  1075.  
  1076. id_first= loc;
  1077. if(*loc=='\\'){
  1078. if(*++loc=='\'')loc++;
  1079. }
  1080. #line 910 "ctangle.w"
  1081. while(*loc!='\''){
  1082. loc++;
  1083. if(loc>limit){
  1084. err_print("! String didn't end");loc= limit-1;break;
  1085. #line 445 "ctangl-p.ch"
  1086.  
  1087. }
  1088. }
  1089. id_loc= loc++;
  1090. #line 918 "ctangle.w"
  1091. return(ord);
  1092.  
  1093. /*:60*/
  1094. #line 902 "ctangle.w"
  1095. ;
  1096. default:return(c);
  1097. }
  1098. }
  1099.  
  1100. #line 427 "ctangl-p.ch"
  1101. /*:59*/
  1102. #line 778 "ctangle.w"
  1103.  
  1104. else if(isspace(c)){
  1105. if(!preprocessing||loc>limit)continue;
  1106.  
  1107. else return(' ');
  1108. }
  1109. else if(c=='#'&&loc==buffer+1)preprocessing= 1;
  1110. mistake:/*55:*/
  1111. #line 797 "ctangle.w"
  1112.  
  1113. switch(c){
  1114. case'+':if(*loc=='+')compress(plus_plus);break;
  1115. case'-':if(*loc=='-'){compress(minus_minus);}
  1116. #line 411 "ctangl-p.ch"
  1117. else if(*loc=='>')if(*(loc+1)=='*'){loc++;compress(minus_gt_ast);}
  1118. else compress(minus_gt);break;
  1119. case'.':if(*loc=='*'){compress(period_ast);}
  1120. else if(*loc=='.'&&*(loc+1)=='.'){
  1121. loc++;compress(dot_dot_dot);
  1122. }
  1123. break;
  1124. case':':if(*loc==':')compress(colon_colon);break;
  1125. #line 802 "ctangle.w"
  1126. case'=':if(*loc=='=')compress(eq_eq);break;
  1127. case'>':if(*loc=='='){compress(gt_eq);}
  1128. else if(*loc=='>')compress(gt_gt);break;
  1129. case'<':if(*loc=='='){compress(lt_eq);}
  1130. else if(*loc=='<')compress(lt_lt);break;
  1131. case'&':if(*loc=='&')compress(and_and);break;
  1132. case'|':if(*loc=='|')compress(or_or);break;
  1133. case'!':if(*loc=='=')compress(not_eq);break;
  1134. }
  1135.  
  1136. /*:55*/
  1137. #line 785 "ctangle.w"
  1138.  
  1139. return(c);
  1140. }
  1141. }
  1142.  
  1143. /*:54*//*67:*/
  1144. #line 455 "ctangl-p.ch"
  1145. static void scan_repl(eight_bits t)
  1146. #line 1015 "ctangle.w"
  1147. {
  1148. sixteen_bits a;
  1149. if(t==module_name){/*68:*/
  1150. #line 1034 "ctangle.w"
  1151.  
  1152. store_two_bytes(0150000);
  1153. if(changing)id_first= change_file_name;
  1154. else id_first= cur_file_name;
  1155. id_loc= id_first+strlen(id_first);
  1156. if(changing)store_two_bytes((sixteen_bits)change_line);
  1157. else store_two_bytes((sixteen_bits)cur_line);
  1158. #line 462 "ctangl-p.ch"
  1159. {int a= id_lookup(id_first,id_loc,' ')-name_dir;app_repl((a/0400)+0200);
  1160. #line 1042 "ctangle.w"
  1161. app_repl(a%0400);}
  1162.  
  1163. /*:68*/
  1164. #line 1017 "ctangle.w"
  1165. ;}
  1166. while(1)switch(a= get_next()){
  1167. /*69:*/
  1168. #line 1044 "ctangle.w"
  1169.  
  1170. #line 469 "ctangl-p.ch"
  1171. case identifier:a= id_lookup(id_first,id_loc,' ')-name_dir;app_repl((a/0400)+0200);
  1172. #line 1046 "ctangle.w"
  1173. app_repl(a%0400);break;
  1174. case module_name:if(t!=module_name)goto done;
  1175. else{
  1176. /*70:*/
  1177. #line 1066 "ctangle.w"
  1178. {
  1179. char*try_loc= loc;
  1180. while(*try_loc==' '&&try_loc<limit)try_loc++;
  1181. if(*try_loc=='+'&&try_loc<limit)try_loc++;
  1182. while(*try_loc==' '&&try_loc<limit)try_loc++;
  1183. if(*try_loc=='=')err_print("! Missing `@ ' before a named module");
  1184.  
  1185. }
  1186.  
  1187. /*:70*/
  1188. #line 1049 "ctangle.w"
  1189. ;
  1190. a= cur_module-name_dir;
  1191. app_repl((a/0400)+0250);
  1192. app_repl(a%0400);
  1193. /*68:*/
  1194. #line 1034 "ctangle.w"
  1195.  
  1196. store_two_bytes(0150000);
  1197. if(changing)id_first= change_file_name;
  1198. else id_first= cur_file_name;
  1199. id_loc= id_first+strlen(id_first);
  1200. if(changing)store_two_bytes((sixteen_bits)change_line);
  1201. else store_two_bytes((sixteen_bits)cur_line);
  1202. #line 462 "ctangl-p.ch"
  1203. {int a= id_lookup(id_first,id_loc,' ')-name_dir;app_repl((a/0400)+0200);
  1204. #line 1042 "ctangle.w"
  1205. app_repl(a%0400);}
  1206.  
  1207. /*:68*/
  1208. #line 1053 "ctangle.w"
  1209. ;break;
  1210. }
  1211. case constant:case string:
  1212. /*71:*/
  1213. #line 1075 "ctangle.w"
  1214.  
  1215. app_repl(a);
  1216. while(id_first<id_loc){
  1217. if(*id_first=='@'){
  1218. if(*(id_first+1)=='@')id_first++;
  1219. else err_print("! Double @ should be used in strings");
  1220.  
  1221. }
  1222. app_repl(*id_first++);
  1223. }
  1224. app_repl(a);break;
  1225.  
  1226. /*:71*/
  1227. #line 1056 "ctangle.w"
  1228. ;
  1229. case ord:
  1230. /*72:*/
  1231. #line 1091 "ctangle.w"
  1232. {
  1233. int c= *id_first;
  1234. if(c=='@'){
  1235. if(*(id_first+1)!='@')err_print("! Double @ should be used in strings");
  1236.  
  1237. else id_first++;
  1238. }
  1239. else if(c=='\\'){
  1240. c= *++id_first;
  1241. switch(c){
  1242. case't':c= '\t';break;
  1243. case'n':c= '\n';break;
  1244. case'b':c= '\b';break;
  1245. case'f':c= '\f';break;
  1246. case'v':c= '\v';break;
  1247. case'r':c= '\r';break;
  1248. #line 478 "ctangl-p.ch"
  1249. case'a':c= '\7';break;
  1250. case'?':c= '?';break;
  1251. case'x':c= 0;
  1252. while(++id_first<id_loc)
  1253. if(isdigit(*id_first))c= 16*c+(*id_first-'0');
  1254. else if(isxdigit(*id_first))c= 16*c+(toupper(*id_first)-'A'+10);
  1255. else err_print("! Illegal hexadecimal digit");
  1256.  
  1257. break;
  1258. case'0':case'1':case'2':case'3':case'4':case'5':case'6':case'7':
  1259. c= *id_first-'0';
  1260. while(++id_first<id_loc)
  1261. if(isdigit(*id_first)&&*id_first<='7')c= 8*c+(*id_first-'0');
  1262. else err_print("! Illegal octal digit");
  1263.  
  1264. break;
  1265. #line 1108 "ctangle.w"
  1266. case'\\':c= '\\';break;
  1267. case'\'':c= '\'';break;
  1268. case'\"':c= '\"';break;
  1269. default:err_print("! Unrecognized escape sequence");
  1270.  
  1271. }
  1272. }
  1273.  
  1274. app_repl(constant);
  1275. if(c>=100)app_repl('0'+c/100);
  1276. if(c>=10)app_repl('0'+(c/10)%10);
  1277. app_repl('0'+c%10);
  1278. app_repl(constant);
  1279. }
  1280. break;
  1281.  
  1282. /*:72*/
  1283. #line 1058 "ctangle.w"
  1284. ;
  1285. case definition:case format_code:case begin_C:if(t!=module_name)goto done;
  1286. else{
  1287. err_print("! @d, @f and @c are ignored in C text");continue;
  1288.  
  1289. }
  1290. case new_module:goto done;
  1291.  
  1292. /*:69*/
  1293. #line 1022 "ctangle.w"
  1294.  
  1295. default:app_repl(a);
  1296. }
  1297. done:next_control= (eight_bits)a;
  1298. if(text_ptr>text_info_end)overflow("text");
  1299. cur_text= text_ptr;(++text_ptr)->tok_start= tok_ptr;
  1300. }
  1301.  
  1302. /*:67*//*74:*/
  1303. #line 499 "ctangl-p.ch"
  1304. static void scan_module(void)
  1305. #line 1135 "ctangle.w"
  1306. {
  1307. name_pointer p;
  1308. text_pointer q;
  1309. sixteen_bits a;
  1310. module_count++;
  1311. if(*(loc-1)=='*'&&show_progress){
  1312. printf("*%d",module_count);update_terminal;
  1313. }
  1314. /*75:*/
  1315. #line 1147 "ctangle.w"
  1316.  
  1317. next_control= 0;
  1318. while(1){
  1319. while(next_control<=format_code)
  1320. if((next_control= skip_ahead())==module_name){
  1321. loc-= 2;next_control= get_next();
  1322. }
  1323. if(next_control!=definition)break;
  1324. while((next_control= get_next())=='\n');
  1325. if(next_control!=identifier){
  1326. err_print("! Definition flushed, must start with identifier");
  1327.  
  1328. continue;
  1329. }
  1330. #line 507 "ctangl-p.ch"
  1331. app_repl(((a= id_lookup(id_first,id_loc,' ')-name_dir)/0400)+0200);
  1332. #line 1162 "ctangle.w"
  1333. app_repl(a%0400);
  1334. if(*loc!='('){
  1335. app_repl(string);app_repl(' ');app_repl(string);
  1336. }
  1337. print_where= 0;scan_repl(macro);
  1338. cur_text->text_link= 0;
  1339. }
  1340.  
  1341. /*:75*/
  1342. #line 1143 "ctangle.w"
  1343. ;
  1344. /*76:*/
  1345. #line 1170 "ctangle.w"
  1346.  
  1347. switch(next_control){
  1348. case begin_C:p= name_dir;break;
  1349. case module_name:p= cur_module;
  1350. /*77:*/
  1351. #line 1182 "ctangle.w"
  1352.  
  1353. while((next_control= get_next())=='+');
  1354. if(next_control!='='&&next_control!=eq_eq){
  1355. err_print("! C text flushed, = sign is missing");
  1356.  
  1357. while((next_control= skip_ahead())!=new_module);
  1358. return;
  1359. }
  1360.  
  1361. /*:77*/
  1362. #line 1174 "ctangle.w"
  1363. ;
  1364. break;
  1365. default:return;
  1366. }
  1367. /*78:*/
  1368. #line 1191 "ctangle.w"
  1369.  
  1370. store_two_bytes((sixteen_bits)(0150000+module_count));
  1371.  
  1372.  
  1373. /*:78*/
  1374. #line 1178 "ctangle.w"
  1375. ;
  1376. scan_repl(module_name);
  1377. /*79:*/
  1378. #line 1195 "ctangle.w"
  1379.  
  1380. if(p==name_dir||p==0){
  1381. (last_unnamed)->text_link= cur_text-text_info;last_unnamed= cur_text;
  1382. }
  1383. #line 513 "ctangl-p.ch"
  1384. else if(p->equiv==(char HUGE*)text_info)p->equiv= (char HUGE*)cur_text;
  1385. #line 1200 "ctangle.w"
  1386.  
  1387. else{
  1388. q= (text_pointer)p->equiv;
  1389. while(q->text_link<module_flag)q= q->text_link+text_info;
  1390. q->text_link= cur_text-text_info;
  1391. }
  1392. cur_text->text_link= module_flag;
  1393.  
  1394. #line 519 "ctangl-p.ch"
  1395. /*:79*/
  1396. #line 1180 "ctangle.w"
  1397. ;
  1398.  
  1399. /*:76*/
  1400. #line 1144 "ctangle.w"
  1401. ;
  1402. }
  1403.  
  1404. /*:74*//*80:*/
  1405. #line 519 "ctangl-p.ch"
  1406. static void phase_one(void){
  1407. #line 1209 "ctangle.w"
  1408. phase= 1;
  1409. module_count= 0;
  1410. reset_input();
  1411. while((next_control= skip_ahead())!=new_module);
  1412. while(!input_has_ended)scan_module();
  1413. check_complete();
  1414. phase= 2;
  1415. }
  1416.  
  1417. /*:80*//*81:*/
  1418. #line 1218 "ctangle.w"
  1419.  
  1420. #ifdef STAT
  1421. #line 525 "ctangl-p.ch"
  1422.  void print_stats(void){
  1423. #line 1221 "ctangle.w"
  1424. printf("\nMemory usage statistics:\n");
  1425. #line 534 "ctangl-p.ch"
  1426. #ifdef __TURBOC__
  1427. printf("%ld names (out of %ld)\n",name_ptr-name_dir,(long)max_names);
  1428. printf("%ld replacement texts (out of %ld)\n",text_ptr-text_info,(long)max_texts);
  1429. printf("%ld bytes (out of %ld)\n",byte_ptr-byte_mem,(long)max_bytes);
  1430. printf("%ld tokens (out of %ld)\n",tok_ptr-tok_mem,(long)max_toks);
  1431. #else
  1432. printf("%d names (out of %d)\n",name_ptr-name_dir,max_names);
  1433. printf("%d replacement texts (out of %d)\n",text_ptr-text_info,max_texts);
  1434. printf("%d bytes (out of %d)\n",byte_ptr-byte_mem,max_bytes);
  1435. printf("%d tokens (out of %d)\n",tok_ptr-tok_mem,max_toks);
  1436. #endif
  1437. #line 1226 "ctangle.w"
  1438. }
  1439. #endif
  1440.  
  1441. #line 550 "ctangl-p.ch"
  1442. /*:81*/
  1443.