home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / fweb153.zip / fweb-1.53 / web / style.web < prev    next >
Text File  |  1995-09-23  |  35KB  |  1,612 lines
  1. @z --- style.web ---
  2.  
  3. FWEB version 1.53 (September 23, 1995)
  4.  
  5. Based on version 0.5 of S. Levy's CWEB [copyright (C) 1987 Princeton University]
  6.  
  7. @x-----------------------------------------------------------------------------
  8.  
  9.  
  10. \Title{STYLE.WEB} % Reading the style file for FWEAVE and FTANGLE.
  11.  
  12. @c
  13. @* INTRODUCTION.
  14. Here we read a style file. Style files are used to customize the output of
  15. \FWEAVE---for example, to adjust the appearance of the index.  The default
  16. style file is called \.{fweb.sty} in the directory set by the environment
  17. variable \.{FWEB\_STYLE\_DIR}, or in the directory of the \WEB\ source.
  18. The name can be changed with the \.{-z}~option: ``\.{-znew\_name}''.
  19.  
  20. Unlike the rest of the \FWEB\ processors, the style file does not
  21. automatically convert its input into |ASCII|.  That's because most of its
  22. fields are never manipulated internally, but are just written to the output
  23. file.  This may or may not have been a good design decision.
  24.  
  25. Associations between vocabulary words and internal \FWEB\ fields are made
  26. in \.{map.web}.
  27.  
  28. \It{We should discuss the detailed scheme here.}
  29.  
  30. @m _STYLE_
  31. @d _STYLE_h
  32.  
  33. @A 
  34. @<Include files@>@;
  35. @<Typedef declarations@>@;
  36. @<Global variables@>@;
  37.  
  38. @I typedefs.hweb
  39.  
  40. @
  41. @<Include...@>=
  42. #include "map.h"
  43.  
  44. @ 
  45.  
  46. @d CMNT_CHAR '%' // The comment character in the style file.
  47.  
  48. @I mem.hweb
  49.  
  50. @ We need a few miscellaneous declarations.
  51. @<Glob...@>=
  52.  
  53. outer_char HUGE *sprm_buf,HUGE *sprm_ptr,HUGE *sprm_end; // For \.{-p} option.
  54. outer_char HUGE *sprm_ptr0; // Marks beginning of command-line \.{-p} options.
  55.  
  56. boolean from_sprm;
  57. static BUF_SIZE sbuf_len; // Length of line buffer.
  58. static outer_char HUGE *stemp, HUGE *stemp_end,HUGE *tloc; /* Temporary
  59.     hold for the argument, and position in it. */ 
  60. static outer_char cur_char; /* Current character after possible escape
  61.                 translation. */
  62. extern ASCII xord[];
  63. extern outer_char xchr[];
  64.  
  65. @* PROCESSING ARGUMENTS. We begin with a routine that converts the
  66. character representation of an escaped character to the proper byte.  Note
  67. that the escapes \.{'\\\\'}, \.{'\\''}, \.{'\\"'}, and~\.{'\\?'} can be
  68. handled as part of the |default|.  This routine also handles octal and hex
  69. escapes of the form~\.{\\123} or~\.{\\xFF}.  The function takes the address
  70. of a pointer to the first character; when it exits, that pointer has been
  71. updated to the next non-translated character.  We provide separate
  72. functions for escaping |outer_char|s and |ASCII|s.
  73.  
  74. @d isodigit(c) (isdigit(c) && (c)!='8' && (c)!='9')
  75.     // An |outer_char| octal digit?
  76.  
  77. @a
  78. outer_char esc_char FCN((ppc))
  79.     CONST outer_char HUGE * HUGE *ppc C1("")@;
  80. {
  81. int k;
  82. unsigned n;
  83. CONST outer_char HUGE *pc = *ppc; // Pointer to first character after~'\.\\'.
  84.  
  85. if(isodigit(*pc))
  86.     @<Process octal constant@>@;
  87. else if(*pc == 'x' && isxdigit(*(pc+1)))
  88.     @<Process hex constant@>@;
  89. else 
  90.     { /* Handle ordinary escaped character. */
  91.     switch(*pc)
  92.         {
  93.           case 'a': n = '\007'; @+ break;
  94.        case 'b': n = '\b'; @+ break;
  95.        case 'f': n = '\f'; @+ break;
  96.        case 'n': n = '\n'; @+ break;
  97.        case 'r': n = '\r'; @+ break;
  98.        case 't': n = '\t'; @+ break;
  99.        case 'v': n = '\v'; @+ break;
  100.        default: 
  101.         n = (unsigned)(*pc); // Unknowns, like '\.{\\m}' $\to$~'\.m'.
  102.         break;
  103.         }
  104.     pc++;
  105.     }
  106.  
  107. *ppc = pc;
  108. return (outer_char)n;
  109. }
  110.  
  111. @ Octal constants have the form \.{\\123}.
  112. @<Process octal constant@>=
  113. {
  114. n = ctoi(*pc++);
  115. for(k=0; k<2; k++)
  116.     {
  117.     if(!isodigit(*pc)) break;
  118.     n = 8*n + ctoi(*pc++);
  119.     }
  120. }
  121.  
  122. @ Hex constants have the form \.{\\xFF}.
  123. @<Process hex constant@>=
  124. {
  125. pc++; // Position after \.{'x'}.
  126. n = ctoi(*pc++);
  127. if(isxdigit(*pc)) n = 16*n + ctoi(*pc++);
  128. }
  129.  
  130. @ The corresponding function for |ASCII|.
  131.  
  132. @a
  133. ASCII esc_achar FCN((ppc))
  134.     CONST ASCII HUGE * HUGE *ppc C1("")@;
  135. {
  136. int k;
  137. unsigned n;
  138. CONST ASCII HUGE *pc = *ppc; // Pointer to first character after~'\.\\'.
  139.  
  140. if(isOdigit(*pc))
  141.     @<Process Octal constant@>@;
  142. else if(*pc == @'x' && isXdigit(*(pc+1)))
  143.     @<Process Hex constant@>@;
  144. else 
  145.     {
  146.     switch(*pc)
  147.         {
  148.           case @'a': n = @'\007'; @+ break;
  149.        case @'b': n = @'\b'; @+ break;
  150.        case @'f': n = @'\f'; @+ break;
  151.        case @'n': n = @'\n'; @+ break;
  152.        case @'r': n = @'\r'; @+ break;
  153.        case @'t': n = @'\t'; @+ break;
  154.        case @'v': n = @'\v'; @+ break;
  155.        default: n = *pc; @+ break; // Unknowns, like '\.{\\m}' $\to$~'\.m'.
  156.         }
  157.  
  158. #if(DEBUG_XCHR)
  159.     n = XCHR(n);
  160. #endif
  161.     pc++;
  162.     }
  163.  
  164. *ppc = pc; // Advance the pointer to point beyond the end of the constant.
  165.  
  166. #if(DEBUG_XCHR)
  167.     n = xord[n];
  168. #endif
  169.  
  170. return (ASCII)n; // Return the value.
  171. }
  172.  
  173. @ Octal constants have the form \.{\\123}.  The following is for |ASCII|.
  174. @<Process Octal constant@>=
  175. {
  176. n = Ctoi(*pc++);
  177. for(k=0; k<2; k++)
  178.     {
  179.     if(!isOdigit(*pc)) break;
  180.     n = 8*n + Ctoi(*pc++);
  181.     }
  182. }
  183.  
  184. @ Hex constants have the form \.{\\xFF}.  The following is for |ASCII|.
  185. @<Process Hex constant@>=
  186. {
  187. pc++; // Position after \.{'x'}.
  188. n = Ctoi(*pc++);
  189. if(isXdigit(*pc)) n = 16*n + Ctoi(*pc++);
  190. }
  191.  
  192. @ Translate a hex |outer_char| into integer.
  193.  
  194. @m XC(cin,cout) case cin: return 0x##cout@;
  195.  
  196. @d Ctoi(c) ctoi(XCHR(c)) // For |ASCII|.
  197.  
  198. @a
  199. int ctoi FCN((c))
  200.     outer_char c C1("")@;
  201. {
  202. switch(c)
  203.     {
  204.    XC('0',0); XC('1',1); XC('2',2); XC('3',3); XC('4',4); XC('5',5);
  205.    XC('6',6); XC('7',7); XC('8',8); XC('9',9); 
  206.    XC('a',a); @+ XC('A',A);
  207.    XC('b',b); @+ XC('B',B);
  208.    XC('c',c); @+ XC('C',C);
  209.    XC('d',d); @+ XC('D',D);
  210.    XC('e',e); @+ XC('E',E);
  211.    XC('f',f); @+ XC('F',F);
  212.    default: return 0;
  213.     }
  214. }
  215.  
  216. @ Search for a keyword.  Returns address of the relevant |S_MAP| entry.
  217. @a
  218. S_MAP HUGE *find_sty FCN((m,keyword))
  219.     S_MAP HUGE *m C0("Array of map variables")@;
  220.     CONST outer_char HUGE *keyword C1("Search for this keyword")@;
  221. {
  222. for(; *(m->keyword); m++)
  223.     if(STRCMP(keyword,m->keyword) == 0) return m;
  224.  
  225. return NULL;
  226. }
  227.  
  228. @ Read one line from style file. 
  229. @a
  230. boolean sty_line(VOID)
  231. {
  232. typedef enum {FROM_INI, FROM_LOCAL, FROM_CMD_LINE} STYLE_MODE;
  233.  
  234. static STYLE_MODE mode = FROM_INI;
  235.  
  236. from_sprm = BOOLEAN(mode == FROM_INI || mode == FROM_CMD_LINE);
  237.  
  238. switch(mode)
  239.     {
  240.    case FROM_INI:
  241.     if(!sty0_line(sprm_ptr0))
  242.         mode++;
  243.     else
  244.         return YES;
  245.  
  246.    case FROM_LOCAL:
  247.     if(!sty0_line(NULL))
  248.         mode++;
  249.     else
  250.         return YES;
  251.  
  252.    case FROM_CMD_LINE:
  253.     return sty0_line(sprm_end);
  254.     }
  255.  
  256. return YES; // Dummy.
  257. }
  258.  
  259. boolean sty0_line FCN((last_sprm))
  260.     outer_char HUGE *last_sprm C1("")@;
  261. {
  262. int c; /* Single character read from style file. |int| rather than |char|
  263.         because that's what |getc| returns. */
  264.  
  265. sloc = slimit = sbuf; // Position to beginning of line.
  266.  
  267. if(last_sprm)
  268.     { /* Read from the \.{-p} buffer. */
  269.     if(sprm_ptr >= last_sprm) 
  270.         { /* Nothing more in the \.{-p} buffer. */
  271.         s_line = 0;
  272.         return NO;
  273.         }
  274.     else
  275.         { /* Copy line from \.{-p} buffer. */
  276.         int n;
  277.         outer_char HUGE *p;
  278.  
  279.         if((p=(outer_char HUGE *)STRCHR(sprm_ptr,'\n')) == NULL)
  280.             {
  281.             err_print(S,"Trouble in sty_line");
  282.             return NO;
  283.             }
  284.         else n = PTR_DIFF(int, p, sprm_ptr);
  285.     
  286.         STRNCPY(sloc,sprm_ptr,n);
  287.         sprm_ptr += n + 1;
  288.         slimit += n;
  289.         s_line++;
  290.         }
  291.     }
  292. else
  293.     { /* Read from the local style file. */
  294.     if(!sty_file) 
  295.         @<Attempt to open style file@>@;
  296.  
  297.     @<Move characters from style file; |return NO| if end-of-file@>@;
  298.     }
  299.  
  300. return YES;
  301. }
  302.  
  303. @
  304. @<Attempt to open...@>=
  305. {
  306. outer_char full_sty_name[MAX_FILE_NAME_LENGTH];
  307.  
  308. /* If there's no style file, do nothing. */
  309. if(!*sty_file_name) return NO;
  310.  
  311. if(warn_if_absent) 
  312.     {
  313.     STRCPY(full_sty_name,sty_file_name);
  314.     add_prefix(full_sty_name);
  315.     }
  316. else mk_fname(full_sty_name,MAX_FILE_NAME_LENGTH,
  317.                 OC(ENV_FWEB_STY),NO,sty_file_name);
  318.  
  319. if((sty_file = fopen((char *)full_sty_name,"r")) == NULL)
  320.     {
  321.     if(warn_if_absent) 
  322.         {
  323.         err_print(C,"Can't open style file \"%s\"",
  324.             full_sty_name);
  325.         }
  326.     return NO;
  327.     }
  328.  
  329. reading(full_sty_name,YES);
  330. }
  331.  
  332. @
  333. @<Move characters from style...@>=
  334. {
  335. if(feof(sty_file)) 
  336.     return NO;
  337.  
  338. s_line++;
  339.  
  340. while((c = getc(sty_file)) != EOF && c != '\n')
  341.     {
  342.     if(slimit == sbuf_end)
  343.         {
  344.         err_print(S,"Input line too long; max is %lu characters",
  345.             sbuf_len);
  346.         ungetc(c,sty_file);
  347.         break;
  348.         }
  349.  
  350.     *slimit++ = (outer_char)c; // Put character into buffer.
  351.     }
  352. }
  353.  
  354. @ Extract the next argument from the style file.  Keywords begin with an
  355. alphabetic character or an underscore.
  356. @a
  357. STY_TYPE next_sty(VOID)
  358. {
  359. outer_char c; /* Single character from the buffer. */
  360.  
  361. WHILE()
  362.     {
  363. /* If we get to the end of the line or recognize a comment, read the next
  364. line. */
  365.     if(sloc == slimit || (c= *sloc++) == CMNT_CHAR) 
  366.         {
  367.         if(!sty_line()) return S_DONE; // Get more.
  368.         continue;
  369.         }
  370.  
  371.     if(isalpha(c) || c=='_') @<Style keyword@>@;
  372.     else if(isdigit(c) || c=='-' || c=='+') @<Style number@>@;
  373.     else if(c == '"') @<Style string@>@;
  374.     else if(c == '\'') @<Style character@>@;
  375.     else if(c==' ' || c=='\t' || c=='=') continue;
  376.     else 
  377.         {
  378.         err_print(S,"Invalid style-file field; \
  379. skipping remainder of file");
  380.         longjmp(top_of_style,1);
  381.         }
  382.     }
  383.  
  384. DUMMY_RETURN(S_DONE);
  385. }
  386.  
  387. @ Read a keyword into the buffer |stemp|.  Keywords consists of
  388. alphanumeric characters, underscores, or periods.  However, the periods are
  389. made equivalent to underscore so one can things such as ``\.{color.red}''
  390. instead of ``\.{color\_red}''.
  391.  
  392. @m S_RETURN(t) *tloc = '\0'; return S_##t@; /* Terminate |stemp|, and
  393.                     return the appropriate type. */
  394.  
  395. @<Style keyword@>=
  396. {
  397. sloc--;
  398. tloc = stemp;
  399. while(isalpha(*sloc) || isdigit(*sloc) || *sloc=='_' || *sloc=='.')
  400.     {
  401.     cur_char = *sloc++;
  402.     @<Copy and translate style character@>@; 
  403.     }
  404.  
  405. S_RETURN(KEYWORD);
  406. }
  407.  
  408. @ Move one character into |stemp|.
  409. @<Copy and translate style char...@>=
  410. {
  411. if(tloc < stemp_end) 
  412.     *tloc++ = (outer_char)CHOICE(cur_char=='.', '_', cur_char);
  413. else
  414.     {
  415.     err_print(S,"Buffer overflow");
  416.     break;
  417.     }
  418. }
  419.  
  420. @
  421. @<Copy style character@>=
  422. {
  423. if(tloc < stemp_end) *tloc++ = cur_char;
  424. else
  425.     {
  426.     err_print(S,"Buffer overflow");
  427.     break;
  428.     }
  429. }
  430.  
  431. @ Process a string argument (bracketed by double quotes).  We must allow
  432. for escapes, such as ``\.{\\123}''.
  433. @<Style string@>=
  434. {
  435. tloc = stemp; /* Start of buffer. */
  436.  
  437. while(*sloc != '"')
  438.     {
  439.     if(*sloc == '\\')
  440.         if(++sloc == slimit)
  441.             {
  442.             sty_line(); // String is continued.
  443.             continue;
  444.             }
  445.         else cur_char = esc_char(&sloc);
  446.     else cur_char = *sloc++;
  447.  
  448.     @<Copy sty...@>@;
  449.     }
  450.  
  451. sloc++; // Skip over terminating quote.
  452.  
  453. S_RETURN(STRING);
  454. }
  455.  
  456. @ Process a numerical argument.
  457. @<Style number@>=
  458. {
  459. sloc--;
  460. tloc = stemp;
  461. if(*sloc=='+' || *sloc=='-') {cur_char = *sloc++; @<Copy sty...@>@;}
  462.  
  463. while(isdigit(*sloc)) {cur_char = *sloc++; @<Copy sty...@>@;}
  464.  
  465. /* We allow the possibility of long integers. */
  466. if(*sloc == 'l' || *sloc == 'L')
  467.     {
  468.     sloc++; // Skip over '\.L'.
  469.     S_RETURN(LONG);
  470.     }
  471.  
  472. S_RETURN(INT);
  473. }
  474.  
  475. @ Process a character argument such as~'\.c' or~'\.{\\n}'.
  476. @<Style character@>=
  477. {
  478. tloc = stemp;
  479.  
  480. /* If the character is escaped, turn the next character into the actual
  481. byte. */
  482. if(*sloc == '\\') {sloc++; cur_char = esc_char(&sloc);}
  483. else cur_char = *sloc++;
  484.  
  485. @<Copy sty...@>@;
  486. sloc++; // Skip over closing quote.
  487.  
  488. S_RETURN(CHAR);
  489. }
  490.  
  491. @* READING the STYLE FILE.
  492. The style file is both opened and closed in this module.
  493.  
  494. @f jmp_buf int
  495.  
  496. @<Glob...@>=
  497.  
  498. static CONST outer_char *sty_file_name;
  499. static boolean warn_if_absent;
  500. static FILE *sty_file;
  501. static S_MAP HUGE *map_array = fweb_map; /* Points to the common map
  502.     array for both \FWEAVE\ and \FTANGLE. */
  503. jmp_buf top_of_style; // Environment for the |setjmp|--|longjmp|.
  504.  
  505. @ It's read line by line into a buffer. The length of that buffer can be
  506. set by dynamic memory allocation with option~\.{-ysb}.
  507.  
  508. @d ENV_FWEB_STY "FWEB_STYLE_DIR" /* Environment variable that defines
  509.         directory of style file.  */
  510.  
  511. @a
  512. SRTN read_sty FCN((sty_file_name0,warn_if_absent0))
  513.     CONST outer_char sty_file_name0[] C0("")@;
  514.     boolean warn_if_absent0 C1("")@;
  515. {
  516. sty_file_name = sty_file_name0;
  517. warn_if_absent = warn_if_absent0;
  518.  
  519. @<Modify defaults based on option settings@>@;
  520.  
  521. @<Allocate buffers for the style file@>@;
  522.  
  523. if(setjmp(top_of_style) != 0) goto done_sty;
  524.  
  525. /* Read the first line of style file. If the file's empty, do nothing. */
  526. if(!sty_line()) goto done_sty;
  527.  
  528. /* Parse the file. */
  529. WHILE()
  530.     switch(next_sty())
  531.         {
  532.         case S_CMNT: break;
  533.  
  534.         case S_KEYWORD:
  535.             @<Process style keyword@>@;
  536.             break;
  537.  
  538.         default:
  539.             err_print(S,"Was expecting keyword or comment here; \
  540. skipping remainder of file"); // Falls through to |case S_DONE@:|.
  541.  
  542.         case S_DONE:
  543.          done_sty:
  544.             if(sty_file) fclose(sty_file);
  545.             if(sprm_buf) FREE(sprm_buf);
  546.             FREE_MEM(stemp,"stemp",sbuf_len,outer_char);
  547.             FREE_MEM(sbuf,ABBREV(sbuf_len),sbuf_len,outer_char);
  548.             return;
  549.         }
  550. }
  551.  
  552. @ In a few cases, the proper defaults depend on command-line options; for
  553. example, which processor will be used to process \FWEAVE's output.
  554. @<Modify defaults...@>=
  555. {
  556. IN_COMMON outer_char HUGE *style_args;
  557.  
  558. if(TeX_processor == LaTeX_p)
  559.     {
  560.     W_META HUGE *m = &w_style.misc.meta;
  561.     INDEX HUGE *i = &w_style.indx;
  562.  
  563.     pfmt->id = pfmt->id_outer = pfmt->id_inner = OC("\\>");
  564.     pfmt->ID = pfmt->ID_OUTER = pfmt->ID_INNER = OC("\\WUC");
  565.     pfmt->RESERVED = OC("\\WRS");
  566.  
  567.     m->TeX.begin = OC("\\begin{verbatim}");
  568.     m->TeX.end = OC("\\end{verbatim}");    
  569.     m->code.begin = OC("\\WBM ");
  570.     m->code.end = OC("\\WEM ");
  571.  
  572.     i->encap_prefix = OC("\\M");
  573.     i->encap_infix = OC("{");
  574.     i->encap_suffix = OC("}");
  575.     }
  576.  
  577. if(prn_style_defaults) 
  578.     see_style(style_args, YES);
  579. }
  580.  
  581. @ We temporarily allocate buffers for working with the style file.
  582. @<Allocate buffers...@>=
  583. {
  584. ALLOC(outer_char,sbuf,ABBREV(sbuf_len),sbuf_len,0);
  585. sbuf_end = sbuf + sbuf_len;
  586.  
  587. stemp = GET_MEM("stemp",sbuf_len,outer_char);
  588. stemp_end = stemp + sbuf_len;
  589.  
  590. /* Reset the \.{-p} buffer. */
  591. sprm_end = sprm_ptr; // Actual end of material in buffer.
  592. sprm_ptr = sprm_buf; // Start at beginning.
  593. }
  594.  
  595. @ At the very beginning, initializations must be finished.
  596. @a
  597. SRTN ini_style(VOID)
  598. {
  599. ini_colors(NO_COLOR);
  600.  
  601. @<Finish initializing mappings@>@;
  602. }
  603.  
  604. @ We've recognized a keyword. Now deal with its arguments.  First, the
  605. argument is copied into the appropriate field.  Then, if an initialization
  606. routine has been defined, that routine is run on the argument.  The
  607. argument might be checked for validity, or it might be changed into
  608. something else.
  609. @<Process style key...@>=
  610. {
  611. S_MAP HUGE *ps; // Returned from |find_sty|.
  612. STY_TYPE type;
  613.  
  614. /* Is it a valid keyword? */
  615. if((ps = find_sty(map_array,stemp)) == NULL)
  616.     {
  617.     err_print(S,"Invalid style-file keyword; skipping remainder of line");
  618.     sty_line();
  619.     break;
  620.     }
  621.  
  622. /* Get the next argument. Is its type correct? */
  623. type = ps->type & ~S_MODIFIED;
  624.  
  625. if(type != next_sty())
  626.     {
  627.     err_print(S,"Argument of keyword \"%s\" has wrong type; \
  628. conversion attempted",ps->keyword);
  629.     }
  630.  
  631. switch(type)
  632.     {
  633.     case S_INT:
  634.     case S_LONG:
  635.     case S_STRING:
  636.     case S_CHAR:
  637.     break;
  638.  
  639.     default:
  640.         err_print(S,"Was expecting integer, double-quoted string, \
  641. or single-quoted character here; argument not processed");
  642.         goto processed;
  643.     }
  644.  
  645. /* Store the argument, check for validity, or process the result in some
  646. way. */
  647. if(ps->init) 
  648.     (*ps->init)(ps); 
  649. else 
  650.     CONFUSION("style keyword","NULL ini fcn");
  651.  
  652. /* Flag it as modified. */
  653. ps->type |= S_MODIFIED;
  654.  
  655. processed:;
  656. }
  657.  
  658.     
  659. @ Initialize a string.  (No error checking.)
  660. @a
  661. SRTN set_str FCN((ps))
  662.     S_MAP HUGE *ps C1("")@;
  663. {
  664. a_str(ps->ptr,(CONST outer_char HUGE *)stemp);
  665. }
  666.  
  667. @ Here we add a string to an already-existing (non-NULL) one, placing a
  668. newline in between.  If the original string is null, we just initialize it
  669. as usual.
  670.  
  671. @a
  672. SRTN add_str FCN((ps))
  673.     S_MAP HUGE *ps C1("")@;
  674. {
  675. outer_char HUGE *pa = *(outer_char HUGE **)ps->ptr, HUGE *pb;
  676.  
  677. if(*pa)
  678.     {
  679.     pb = GET_MEM("add_str",STRLEN(pa) + STRLEN(stemp) + 2,outer_char);
  680.     STRCPY(pb,pa);
  681.     STRCAT(pb,"\n");
  682.     STRCAT(pb,stemp);
  683.     *(outer_char HUGE **)ps->ptr = pb;
  684.     }
  685. else set_str(ps);
  686. }
  687.  
  688. @ Initialize an integer.  (No error checking.)
  689. @a
  690. SRTN set_int FCN((ps))
  691.     S_MAP HUGE *ps C1("")@;
  692. {
  693. *((int *)ps->ptr) = ATOI(stemp);
  694. }
  695.  
  696. @ Similarly, initialize a long.  (No error checking.)
  697. @a
  698. SRTN set_long FCN((ps))
  699.     S_MAP HUGE *ps C1("")@;
  700. {
  701. *((long *)ps->ptr) = ATOL(stemp);
  702. }
  703.  
  704. @ Initialize a character (no error checking).
  705. @a
  706. SRTN set_char FCN((ps))
  707.     S_MAP HUGE *ps C1("")@;
  708. {
  709. *((outer_char *)ps->ptr) = *stemp;
  710. }
  711.  
  712. @
  713. @<Typedef...@>=
  714.  
  715. typedef struct
  716.     {
  717.     CONST char *name;
  718.     COLOR value;
  719.     } CLR_MATCH;
  720.  
  721. CLR_MATCH clr_match[] = {
  722.     {"blue",BLUE},
  723.     {"default",NORMAL},
  724.     {"green",GREEN},
  725.     {"normal",NORMAL},
  726.     {"orange",ORANGE},
  727.     {"red",RED},
  728.     {"yellow",YELLOW},
  729.     {"",NORMAL}
  730.     };
  731.  
  732. @* VALIDITY CHECKS. 
  733. We begin with an initialization routine for color.  It replaces strings like
  734. \.{"red"} by enumerated values like~|RED|.
  735. @a
  736. SRTN ini_aclr FCN((ps))
  737.     S_MAP HUGE *ps C1("")@;
  738. {
  739. CLR_MATCH HUGE *c;
  740.  
  741. set_str(ps);
  742.  
  743. for(c=clr_match; STRCMP(c->name,"") != 0; c++)
  744.     if(STRCMP(c->name,*(outer_char HUGE **)ps->ptr) == 0)
  745.         {
  746.         *(COLOR *)ps->ptr = c->value;
  747.         return;
  748.         }
  749.  
  750. CLR_PRINTF(warning,("! Color name \"%s\" is invalid; \
  751. replaced by \"default\"\n",(char *)ps->ptr));
  752. mark_harmless;
  753.  
  754. *(COLOR *)ps->ptr = NORMAL;
  755. }
  756.  
  757. @ Initialization routine for \.{color.mode}.
  758. @a
  759. SRTN ini_clr FCN((ps))
  760.     S_MAP HUGE *ps C1("")@;
  761. {
  762. set_int(ps);
  763. ini_colors((COLOR_MODE)(*(int *)ps->ptr));
  764. }
  765.  
  766. @ Initialization routines for file name extension are create via a \WEB\
  767. macro. 
  768.  
  769. @m EXT_LINK(file,dflt) link0(&wt_style.input_ext.file,OC(dflt),ext_set)
  770.  
  771. @m INI_EXT(file) 
  772.     SRTN ini_##file FCN((ps))
  773.         CONST S_MAP HUGE *ps C1("")@;
  774.     {
  775.     EXT_LINK(file,(outer_char *)ps->ptr);
  776.     }
  777.  
  778. @<Unused@>=
  779. /* Actual functions are being created here. */
  780. INI_EXT(web)@;
  781. INI_EXT(change)@;
  782. INI_EXT(hweb)@;
  783. INI_EXT(hchange)@;
  784.  
  785. @
  786. @a
  787. SRTN ini_ext FCN((ps))
  788.     S_MAP HUGE *ps C1("")@;
  789. {
  790. set_str(ps);
  791. ext_set((CONST outer_char HUGE **)ps->ptr);
  792. }
  793.  
  794. @ Convert the delimiters for dot constants to |ASCII|.
  795. @a
  796. SRTN ini_dot FCN((ps))
  797.     S_MAP HUGE *ps C1("")@;
  798. {
  799. set_char(ps);
  800. *(ASCII *)ps->ptr = XORD(*(outer_char *)ps->ptr);
  801. }
  802.  
  803. @
  804. @a
  805. SRTN ini_cchar FCN((ps))
  806.     S_MAP HUGE *ps C1("")@;
  807. {
  808. outer_char c;
  809.  
  810. set_char(ps);
  811. c = *(outer_char *)ps->ptr;
  812.  
  813. if(!(c && isprint(c) && c != ' ' && c != '0'))
  814.     {
  815.     *(outer_char *)ps->ptr = CCHAR;
  816.     err_print(S,"Invalid continuation character '%c'; '%c' assumed",
  817.         c,CCHAR);
  818.     }
  819. }
  820.  
  821. @ Here we check the validity of the line length for Fortran's output.
  822.  
  823. @a
  824. SRTN ini_output_line_length FCN((ps))
  825.     S_MAP HUGE *ps C1("")@;
  826. {
  827. int output_line_length;
  828.  
  829. set_int(ps);
  830. output_line_length = *(int *)ps->ptr;
  831.  
  832. if(output_line_length < MIN_OUTPUT_LINE_LENGTH ||
  833.         output_line_length > MAX_OUTPUT_LINE_LENGTH)
  834.     {
  835.     *(int *)ps->ptr = STANDARD_OUTPUT_LINE_LENGTH;
  836.     err_print(S,"Invalid line length; %d assumed",
  837.         STANDARD_OUTPUT_LINE_LENGTH);
  838.     }
  839. }
  840.  
  841. @ 
  842. @<Unused@>=
  843. SRTN ini_cdir FCN((ps))
  844.     CONST S_MAP HUGE *ps C1("")@;
  845. {
  846. outer_char *temp;
  847. int n;
  848.  
  849. temp = GET_MEM("temp_cdir",
  850.     (n=2*STRLEN(*((outer_char HUGE **)ps->ptr)))+1,outer_char); 
  851. esc_buf(temp,temp+n,*((CONST outer_char HUGE **)ps->ptr),stemp,YES);
  852. }
  853.  
  854. @* INITIALIZING CONTROL CODES.
  855. The control code mapping can be overridden from the style file, although
  856. this is not recommended except in unusual circumstances.
  857.  
  858. @d ignore 0
  859.  
  860. @<Glob...@>=
  861.  
  862. eight_bits ccode[128]; // Meaning of a character following '\.{@@}'.
  863. CONST outer_char *cname[128]; // Associated names of control codes.
  864. CONST ASCII HUGE *at_codes;
  865.  
  866. @ Here we initialize |ccode| with values that aren't allowed to be changed
  867. by the style file.  The flag |USED_BY_NEITHER| is written into everything
  868. first; if such a control code is encountered during the scan of either
  869. processor, an error message will be issued.
  870.  
  871. @a
  872. SRTN zero_ccodes(VOID)
  873. @{
  874. int c; // Must be |int|, not |eight_bits|, so the |for| loop will end.
  875.  
  876. @b
  877. /* Start out by initializing the array to a special flag. */
  878.  for (c=0; c<=127; c++) 
  879.     {
  880.     ccode[c] = USED_BY_NEITHER;
  881.     cname[c] = OC("?");
  882.     }
  883.  
  884. @<Initialize unchangable codes@>@;
  885. }
  886.  
  887. @ The following several codes aren't allowed to be changed.
  888. @<Initialize unchangable...@>=
  889. {
  890. ccode[@'@@']=@'@@'; /* `quoted' at sign. This is so fundamental that it
  891.             isn't allowed to be changed by the style file. */
  892.  
  893. ccode[@'{'] = @'{'; /* Since this is related to the C or \Ratfor\ languages,
  894.             it shouldn't be changed. */
  895. ccode[@'}'] = @'}'; // As above.
  896.  
  897. ccode[@'>'] = ignore; /* This is historical, and probably dangerous.  But
  898.             it can't be |USED_BY_NEITHER|! */
  899. }
  900.  
  901. @ The next routine is used by \FWEAVE\ or \FTANGLE\ to initialize the
  902. control code table. Say, for example,
  903. ``\.{INI\_CCODE("Aa",begin\_code)}.  If at any point a |ccode|
  904. entry has already been filled in, that means we \It{must} use the default
  905. value. Thus, if the style file has attempted to override that value,
  906. we complain---and abort after we've checked all the initializations.
  907. @a
  908. SRTN ini_ccode FCN((keyword,defaults,code))
  909.     CONST outer_char *keyword C0("The desired keyword.")@;
  910.     CONST outer_char *defaults C0("String of default characters.")@;
  911.     eight_bits code C1("Assign this \FWEB\ universal code")@;
  912. {
  913. CONST outer_char *pc; /* Pointer to the default characters to initialize. */
  914. CONST S_MAP HUGE *m; /* Points to map entry for requested keyword. */
  915. boolean bad_code = NO;
  916. eight_bits cval;
  917. boolean override; /* Are the default values overridden by the style file? */
  918. IN_COMMON outer_char style_file_name[];
  919. ASCII a; // Position in |ccode|.
  920.  
  921. /* Search for the keyword in the map array. */
  922. if( (m=find_sty(map_array,keyword)) == NULL)
  923.     override = NO; // The keyword isn't even in the table.
  924. else
  925. /* If the style file has set some values for this keyword, and the default
  926.   values for this code are non-zero, then use the values from the style file.
  927.   Otherwise, use the defaults. */
  928.     override = BOOLEAN(*(outer_char **)m->ptr != NULL); 
  929.         // The style file is overriding.
  930.  
  931. pc = (override && code) ? *(outer_char **)m->ptr : defaults;
  932.  
  933. /* If we're not ignoring this code completely, assign it to the relevant
  934. values. */
  935. if(code != USED_BY_NEITHER)
  936.    while(*pc)
  937.     {
  938.     if(override && ((cval = ccode[XORD(*pc)]) != USED_BY_NEITHER) )
  939.         {
  940.         printf("! ccode['%c'] already filled with \"%s\"; \
  941. not filled with \"%s\" = \"%s\".\n",
  942.             *pc, (char *)ccode_name(cval), (char *)keyword,
  943.             (char *)ccode_name(code));
  944.         bad_code = YES;
  945.         }
  946.  
  947.     a = XORD(*pc++);
  948.     ccode[a] = code;
  949.     cname[a] = keyword;
  950.     }
  951.  
  952. if(bad_code) 
  953.     FATAL(S, "!! Invalid control code mapping; check the style file ",
  954.         style_file_name);
  955. }
  956.  
  957. @ For \FTANGLE, after all the |ccode|s have been assigned, a few of them
  958. must be reinterpreted. For example, by default the codes ``\.{\^.9tT}'' are
  959. all interpreted as |control_text|.
  960. @a
  961. SRTN reassign FCN((old_code,new_code))
  962.     eight_bits old_code C0("")@;
  963.     eight_bits new_code C1("")@;
  964. {
  965. int c;
  966.  
  967. for(c=0; c<128; c++)
  968.     if(ccode[c] == old_code) 
  969.         ccode[c] = new_code;
  970. }
  971.  
  972. @ The following array is used for sorting the control-code keywords.
  973. @<Glob...@>=
  974.  
  975. static CC_BUF HUGE *cc_buf;
  976.  
  977. @ Here we print out the control code mappings in resonse to \.{-@@}.  They
  978. are printed twice, first alphabetized by the control code, next by the
  979. keyword.  These are printed out side by side.
  980.  
  981. @a
  982. SRTN prn_codes(VOID)
  983. {
  984. IN_COMMON boolean found_web;
  985. int HUGE *cc_indices;
  986. boolean prn_all = NO;
  987.  
  988. int k;
  989. int n = 0; // Number of codes to print.
  990.  
  991. if(!at_codes) 
  992.     return;
  993.  
  994. puts("Control-code assignments \
  995. ([S,D,C]==`Begins [section,definition,code])':");
  996.  
  997. cc_buf = GET_MEM("cc_buf", 128, CC_BUF);
  998. cc_indices = GET_MEM("cc_indices", 128, int);
  999.  
  1000. if(*at_codes && at_codes[0] == @'*' && at_codes[1] == @'*')
  1001.     prn_all = YES;
  1002.  
  1003. if(*at_codes && !prn_all)
  1004.     { /* A specific list was given on command line. */
  1005.     CONST ASCII *p;
  1006.  
  1007.     for(p=at_codes; *p; p++)
  1008.         prn0_code(*p, cc_buf, &n);
  1009.     }
  1010. else
  1011.     { /* Do all of them. */
  1012.     ASCII a;
  1013.  
  1014.     for(a=0; a<128; a++)
  1015.         {
  1016.         if(ccode[a] == USED_BY_NEITHER && !prn_all)
  1017.             continue;
  1018.  
  1019.         prn0_code(a, cc_buf, &n);
  1020.         }
  1021.     }
  1022.  
  1023. FREE_MEM(at_codes, "at_codes", 200, ASCII);
  1024.  
  1025. for(k=0; k<n; k++)
  1026.     cc_indices[k] = k;
  1027.  
  1028. QSORT(cc_indices, n, sizeof(int), cc_cmp);
  1029.  
  1030. for(k=0; k<n; k++)
  1031.     STRCPY(cc_buf[k][1], cc_buf[cc_indices[k]][0]);
  1032.  
  1033. for(k=0; k<n; k++)
  1034.     printf("%-40s%-40s\n", cc_buf[k][0], cc_buf[k][1]);
  1035.  
  1036. FREE_MEM(cc_buf, "cc_buf", 128, CC_BUF);
  1037. FREE_MEM(cc_indices, "cc_indices", 128, int);
  1038.  
  1039. if(!found_web) 
  1040.     wrap_up();
  1041. }
  1042.  
  1043. @ We alphabetize on the keywords, which follow the `\.{---}'.
  1044.  
  1045. @a
  1046. int cc_cmp FCN((k0, k1))
  1047.     CONST VOID *pk0 C0("")@;
  1048.     CONST VOID *pk1 C1("")@;
  1049. {
  1050. char *s0, *s1;
  1051.  
  1052. s0 = strrchr(cc_buf[*(int *)pk0][0], '-');
  1053. s1 = strrchr(cc_buf[*(int *)pk1][0], '-');
  1054.  
  1055. return STRCMP(s0, s1);
  1056. }
  1057.  
  1058. @ Print out one control code.
  1059. @a
  1060. SRTN prn0_code FCN((a, cc_buf, pk))
  1061.     ASCII a C0("")@;
  1062.     CC_BUF HUGE *cc_buf C0("")@;
  1063.     int *pk C1("")@;
  1064. {    
  1065. ASCII new_module, begin_code, formatt;
  1066. ASCII cc = ccode[a];
  1067. outer_char c;
  1068. int n;
  1069. outer_char *letter;
  1070.  
  1071. /* The following assumes that these particular codes never change.  This
  1072. was easier than including the header files. */
  1073. new_module = ccode[@'*'];
  1074. begin_code = ccode[@'a'];
  1075. formatt = ccode[@'f'];
  1076.  
  1077. c = XCHR(a);
  1078.  
  1079. if(cc == USED_BY_NEITHER)
  1080.     letter = OC("   ");
  1081. else if(cc >= new_module)
  1082.     letter = OC("[S]");
  1083. else if(cc >= begin_code)
  1084.     letter = OC("[C]");
  1085. else if(cc >= formatt)
  1086.     letter = OC("[D]");
  1087. else
  1088.     letter = OC("   ");
  1089.  
  1090. n = NSPRINTF((outer_char *)&cc_buf[*pk][0][0], 
  1091. isprint(c) ? "  %s @@%c" : " %s@@'0x%02x'", 
  1092.         isprint(c) ? letter : OC(""), c);
  1093.  
  1094. switch(c)
  1095.     {
  1096.    case '/':
  1097.     cname[c] = OC("(verbatim comment)");
  1098.     break;
  1099.  
  1100.    case '>':
  1101.     cname[c] = OC("(end of module name)");
  1102.     break;
  1103.  
  1104.    case '@@':
  1105.     cname[c] = OC("(literal '@@')");
  1106.     break;
  1107.     }
  1108.  
  1109. sprintf(&cc_buf[*pk][0][n], " --- %s", (char *)cname[c]);
  1110. (*pk)++; // Increment array index.
  1111. }
  1112.  
  1113. @* COLOR.
  1114.  
  1115. @d SET_ACOLOR(field,clr) wt_style.color.field.value = clr
  1116.  
  1117. @<Glob...@>=
  1118. static outer_char HUGE *termcap; // Name of termcap file.
  1119. static outer_char HUGE *tcap_buffer; // Allocated dynamically.
  1120.  
  1121. @  Colors are initialized to default values, then overridden for several
  1122. built-in palettes.
  1123. @a
  1124. SRTN ini_colors FCN((color_mode))
  1125.     COLOR_MODE color_mode C1("")@;
  1126. {
  1127. @<Set default colors@>@; // Attach colors to fields.
  1128.  
  1129. if(!(termcap=get_termcap())) wt_style.color_mode = color_mode = NO_COLOR;
  1130.  
  1131. @<Make default links between bilevel mode and colors@>@;
  1132.  
  1133. switch(color_mode)
  1134.     {
  1135.    case NO_COLOR:
  1136.     break;
  1137.  
  1138.    case BILEVEL:
  1139.     CLR_LINK(YELLOW,md);
  1140.     CLR_LINK(GREEN,md);
  1141.     CLR_LINK(RED,mdmr);
  1142.     break;
  1143.  
  1144.    case TRUE_COLOR:
  1145.     CLR_LINK(YELLOW,md);
  1146.     CLR_LINK(GREEN,us);
  1147.     CLR_LINK(BLUE,md);
  1148.     CLR_LINK(ORANGE,md);
  1149.     CLR_LINK(RED,mdmr);
  1150.     break;
  1151.     }
  1152. }
  1153.  
  1154. @ Get control sequence for a color.  This is an ini routine for
  1155. \.{color.red} etc.
  1156. @a
  1157. SRTN ini_bilevel FCN((ps))
  1158.     S_MAP HUGE *ps C1("")@;
  1159. {
  1160. set_str(ps);
  1161.  
  1162. if(termcap==NULL) return;
  1163.  
  1164. termset(ps->ptr);
  1165. }
  1166.  
  1167. @ Default color assignments to the various FWEB fields. Change these in the
  1168. style file by saying ``\.{color.error = "red"}''.
  1169. @<Set default colors@>=
  1170. {
  1171. SET_ACOLOR(ordinary,NORMAL);
  1172. SET_ACOLOR(program_name,YELLOW);
  1173. SET_ACOLOR(info,GREEN);
  1174. SET_ACOLOR(warning,ORANGE);
  1175. SET_ACOLOR(error,RED);
  1176. SET_ACOLOR(fatal,RED);
  1177. SET_ACOLOR(module_num,ORANGE);
  1178. SET_ACOLOR(line_num,ORANGE);
  1179. SET_ACOLOR(in_file,YELLOW);
  1180. SET_ACOLOR(include_file,BLUE);
  1181. SET_ACOLOR(out_file,YELLOW);
  1182. SET_ACOLOR(timing,ORANGE);
  1183. }
  1184.  
  1185. @ Associate a color with a control sequence.
  1186.  
  1187. @m CLR_LINK(CLR,id) link0(&wt_style.color._##CLR,OC(#id),termset)
  1188.  
  1189. @<Make default links...@>=
  1190.  
  1191. CLR_LINK(NORMAL,me);
  1192. CLR_LINK(YELLOW,md);
  1193. CLR_LINK(GREEN,me);
  1194. CLR_LINK(ORANGE,me);
  1195. CLR_LINK(RED,mdmr);
  1196. CLR_LINK(BLUE,me);
  1197.  
  1198. @
  1199. @a
  1200. SRTN link0 FCN((pp,id,fcn))
  1201.     outer_char HUGE **pp C0("")@;
  1202.     CONST outer_char HUGE *id C0("")@;
  1203.     SRTN (HUGE_FCN_PTR *fcn)PROTO((CONST outer_char HUGE **)) C1("")@;
  1204. {
  1205. a_str(pp,id); // Allocate space, and store abbreviation string.
  1206. (*fcn)((CONST outer_char HUGE **)pp); /* Replace that string by actual escape
  1207.                     sequences. */
  1208. }
  1209.  
  1210. @ Similarly, initialize extensions.
  1211.  
  1212. @<Finish initializing mappings@>=
  1213. {
  1214. EXT_LINK(web,"web");
  1215. EXT_LINK(change,"ch");
  1216. EXT_LINK(hweb,"hweb");
  1217. EXT_LINK(hchange,"hch");
  1218. }
  1219.  
  1220. @ Allocate and store an abbreviation string.
  1221. @a
  1222. SRTN a_str FCN((pp,id))
  1223.     outer_char HUGE **pp C0("")@;
  1224.     CONST outer_char HUGE *id C1("")@;
  1225. {
  1226. @% if(*pp) FREE(*pp); // It's VERY destructive to free memory here!
  1227. *((outer_char HUGE * *)pp) = GET_MEM("map_string",STRLEN(id)+1,outer_char); 
  1228. STRCPY(*((outer_char HUGE * *)pp),id);
  1229. }
  1230.  
  1231. @ Open and read the termcap file.
  1232.  
  1233. @d ENV_TERM "TERM" // Unix environment variable for terminal type.
  1234.  
  1235. @a
  1236. outer_char *get_termcap(VOID)
  1237. {
  1238. #if !HAVE_GETENV
  1239.     return NULL;
  1240. #else
  1241. if((termcap = GETENV(ENV_TERM)) == NULL) return NULL;
  1242.  
  1243. tcap_buffer = GET_MEM("tcap_buffer",1024,outer_char);
  1244.  
  1245. switch(tgetent(tcap_buffer,termcap))
  1246.     {
  1247.    case -1:
  1248.     printf("! Can't open termcap file \"%s\"\n", (char *)termcap);
  1249.  
  1250.    case 0:
  1251.     return NULL;
  1252.     }
  1253.  
  1254. return termcap;
  1255. #endif // |HAVE_GETENV|
  1256. }
  1257.  
  1258. @ On entry, takes as argument a pointer to a string of blank-separated
  1259. abbreviations.  On exit, the pointer is changed to point to a |SEQUENCES|
  1260. structure that contains the actual escape sequences.
  1261.  
  1262. @d NUM_TEMP_PTRS 20
  1263.  
  1264. @a
  1265. SRTN termset FCN((pid))
  1266.     CONST outer_char HUGE **pid C1("")@;
  1267. {
  1268. outer_char value_buf[500], *area = value_buf; // For |tgetstr|.
  1269. outer_char *s;
  1270. CONST outer_char HUGE *t;
  1271. outer_char id[3];
  1272. int k,n;
  1273. SEQUENCES HUGE *ps = GET_MEM("termcap struct",1,SEQUENCES);
  1274. outer_char *string[NUM_TEMP_PTRS];
  1275.  
  1276. if(!termcap) return;
  1277.  
  1278. for(t=*pid,n=0; *t; t+=2)
  1279.     {
  1280.     if(n == NUM_TEMP_PTRS) break;
  1281.     while(*t==' ') t++;
  1282.  
  1283. /* Put the abbreviation for escape sequence into |id|. */
  1284.     STRNCPY(id,t,2);
  1285.     TERMINATE(id,2);
  1286.  
  1287. /* Get the actual escape sequence from termcap file. */
  1288.     if((s=tgetstr(id,&area)) == NULL)
  1289.         printf("! Termcap entry \"%s\" not found \
  1290. for terminal type \"%s\".\n", (char *)id, (char *)termcap);
  1291.     else string[n++] = s;
  1292.     }
  1293.  
  1294. @<Allocate and initialize memory for the strings@>@;
  1295. }
  1296.  
  1297. @
  1298. @<Allocate and initialize memory for the strings@>=
  1299. {
  1300. ps->n = (short)n;
  1301. ps->string = GET_MEM("termcap strings",n,outer_char *);
  1302.  
  1303. for(k=0; k<n; k++)
  1304.     {
  1305.     ps->string[k] = GET_MEM("termcap string",
  1306.         STRLEN(string[k])+1,outer_char);
  1307.     STRCPY(ps->string[k],string[k]);
  1308.     }
  1309.  
  1310. FREE((void *)(*pid));
  1311. *pid = (CONST outer_char HUGE *)ps;
  1312. }
  1313.  
  1314. @ A similar routine processes a blank-delimited list of extensions.
  1315. @a
  1316. SRTN ext_set FCN((pid))
  1317.     CONST outer_char HUGE **pid C1("")@;
  1318. {
  1319. outer_char id[1000],*p,*p0;
  1320. CONST outer_char HUGE *t;
  1321. outer_char *string[NUM_TEMP_PTRS];
  1322. int k,n;
  1323. SEQUENCES HUGE *ps = GET_MEM("termcap struct",1,SEQUENCES);
  1324.  
  1325. t = *pid; // Beginning of blank-separated list.
  1326. n = 0; // Number of fields found.
  1327. p = id; // Start of storage area
  1328.  
  1329. while(*t)
  1330.     {
  1331.     if(n == NUM_TEMP_PTRS) break;
  1332.     while(*t == ' ') t++; // Skip initial white space.
  1333.     
  1334.     p0 = p;
  1335.     while(*t != ' ' && *t) *p++ = *t++;
  1336.     TERMINATE(p,0);
  1337.     p++;
  1338.     string[n++] = p0; // Remember where string is.
  1339.     }
  1340.  
  1341. @<Allocate and init...@>@;
  1342. }
  1343.  
  1344. @ Used by |tputs|, which is an output routine used to send one character.
  1345. We need this intermediate function |put_out| because |putchar| is a macro
  1346. on some systems.
  1347. @a
  1348. int put_out FCN((c))
  1349.     int c C1("")@;
  1350. {
  1351. return putchar(c);
  1352. }
  1353.  
  1354. @ Output the control sequences corresponding to a color.  This needs to be
  1355. generalized for~X.
  1356.  
  1357. @m SEND(CLR) tput((SEQUENCES *)wt_style.color._##CLR)
  1358.  
  1359. @m CLR_CASE(CLR) 
  1360.     case CLR:
  1361.        SEND(CLR);
  1362.        break@;
  1363.  
  1364. @a
  1365. SRTN set_color FCN((clr))
  1366.     COLOR clr C1("")@;
  1367. {
  1368. color0.last = color0.present; // Save the incoming color, for later restore.
  1369.  
  1370. if(wt_style.color_mode != NO_COLOR)
  1371.   switch(clr)
  1372.     {
  1373.     CLR_CASE(NORMAL);
  1374.     CLR_CASE(GREEN);
  1375.     CLR_CASE(RED);
  1376.     CLR_CASE(BLUE);
  1377.     CLR_CASE(ORANGE);
  1378.     CLR_CASE(YELLOW);
  1379.  
  1380.    default:
  1381.     SEND(NORMAL);
  1382.     break;
  1383.     }
  1384.  
  1385. color0.present = clr;
  1386. }
  1387.  
  1388. @ Send each abbreviation in turn.
  1389. @a
  1390. SRTN tput FCN((ps))
  1391.     SEQUENCES *ps C1("")@;
  1392. {
  1393. int k;
  1394.  
  1395. for(k=0; k<ps->n; k++)
  1396.     tputs(ps->string[k],1,put_out);
  1397. }
  1398.  
  1399. @ Print to terminal in particular color.  (This routine is independent of
  1400. the particular color mechanism.) \It{Check the variable arguments; they're
  1401. not right for Sun-CC yet.}
  1402. @<Unused@>=
  1403.  
  1404. SRTN clr_printf FCN(VA_ALIST((clr,fmt VA_ARGS)))
  1405.     VA_DCL(
  1406.     COLOR clr C0("")@;
  1407.     outer_char *fmt C2("")@;)@;
  1408. {
  1409. VA_LIST(arg_ptr)@;
  1410.  
  1411. set_color(clr); // Remembers previous color in |color0.last|.
  1412.  
  1413. VA_START(arg_ptr,fmt);
  1414. vprintf_(fmt,arg_ptr);
  1415. va_end(arg_ptr);
  1416.  
  1417. set_color(color0.last); // Restore color.
  1418. }
  1419.  
  1420. @* PRINTING OUT VALUES.
  1421. @<Unused@>=
  1422. boolean out_map FCN((name))
  1423.     outer_char *name C1("")@;
  1424. {
  1425. outer_char *p;
  1426. outer_char key_name[100];
  1427. S_MAP *m;
  1428.  
  1429. STRCPY(key_name,name);
  1430. for(p=key_name; *p; p++)
  1431.     if(*p == '.') *p = '_';
  1432.  
  1433. for(m=fweb_map; *m->keyword; m++)
  1434.     if(STRCMP(m->keyword,key_name) == 0)
  1435.         {
  1436.         for(p=key_name; *p; p++)
  1437.             if(*p == '_') *p = '.';
  1438.  
  1439.         printf("%s = ",key_name);
  1440.         switch(m->type)
  1441.             {
  1442.            case S_STRING:
  1443.             if(*(int *)m->ptr < (int)HIGHEST_COLOR)
  1444.                 printf("%s\n",clr_name[*(int *)m->ptr]);
  1445.             else printf("\"%s\"\n",*(char * *)m->ptr);
  1446.             break;
  1447.  
  1448.            case S_CHAR:
  1449.             printf("'%c'\n",*(char *)m->ptr);
  1450.             break;
  1451.  
  1452.            case S_INT:
  1453.             printf("%d\n",*(int *)m->ptr);
  1454.             break;
  1455.  
  1456.            case S_LONG:
  1457.             printf("%ld\n",*(long *)m->ptr);
  1458.             break;
  1459.  
  1460.            default:
  1461.             printf("INVALID TYPE\n");
  1462.             break;
  1463.             }
  1464.  
  1465.         return YES;
  1466.         }
  1467.  
  1468. return NO;
  1469. }
  1470.  
  1471. @ Query the style-file parameters; from \.{-Z}~option.
  1472. @a
  1473. SRTN see_style FCN((pa,see_all))
  1474.     CONST outer_char HUGE *pa C0("")@;
  1475.     boolean see_all C1("")@;
  1476. {
  1477. S_MAP HUGE **s0,HUGE **s,HUGE **s1,HUGE *m;
  1478.  
  1479. s0 = GET_MEM("s0",sizeof(fweb_map)/sizeof(S_MAP),S_MAP HUGE *);
  1480.  
  1481. /* Fill an array of pointers. */
  1482. for(s=s0,m=fweb_map; *(m->keyword); s++,m++)
  1483.     *s = m;
  1484.  
  1485. /* Sort the array. */
  1486. QSORT(s0,s-s0,sizeof(S_MAP HUGE *),cmpr_s_map);
  1487.  
  1488. /* Print out the values. */
  1489. printf("%s style-file parameters%s%s%s%s:\n",
  1490.     see_all ? "Default" : "Modified",
  1491.     *pa ? " beginning with \"" : "", (char *)pa, *pa ? "\"" : "",
  1492.     see_all ? "\n (null or empty values for colors and \
  1493. @@ command codes are misleading)" : "");
  1494.  
  1495. if(*pa)
  1496.     { /* Convert \.{'.'} to \.{'\_'}. */
  1497.     outer_char HUGE *p;
  1498.  
  1499.     for(p=(outer_char HUGE *)pa; *p; p++)
  1500.         if(*p == '.')
  1501.             *p = '_';
  1502.     }
  1503.  
  1504. for(s1=s0; s1<s; s1++)
  1505.     see_map(*s1,pa,see_all);
  1506.  
  1507. FREE_MEM(s0,"s0",sizeof(fweb_map)/sizeof(S_MAP),S_MAP);
  1508. }
  1509.  
  1510. @
  1511. @a
  1512. int cmpr_s_map FCN((s0,s1))
  1513.     S_MAP HUGE **s0 C0("")@;
  1514.     S_MAP HUGE **s1 C1("")@;
  1515. {
  1516. return STRCMP((*s0)->keyword,(*s1)->keyword);
  1517. }
  1518.  
  1519. @ Print out an individual style-file parameter.
  1520. @a
  1521. SRTN see_map FCN((s,pa,see_all))
  1522.     S_MAP HUGE *s C0("")@;
  1523.     CONST outer_char HUGE *pa C0("")@;
  1524.     boolean see_all C1("")@;
  1525. {
  1526. if(*pa && STRNCMP(pa,s->keyword,STRLEN(pa)) != 0) return;
  1527.  
  1528. if(see_all) 
  1529.     printf(" ");
  1530. else
  1531.     { /* Handled modified parameters. */
  1532.     if(s->type & S_MODIFIED) 
  1533.         {
  1534.         printf("*");
  1535.         s->type &= ~S_MODIFIED;
  1536.         }
  1537.  
  1538.     else return;
  1539.     }
  1540.  
  1541. printf(" %s = ", (char *)s->keyword);
  1542.  
  1543. switch(s->type)
  1544.     {
  1545.    case S_STRING:
  1546.     see_str(*((outer_char **)s->ptr));
  1547.     break;
  1548.  
  1549.    case S_CHAR:
  1550.     printf("'%c'\n",*(outer_char *)s->ptr);
  1551.     break;
  1552.  
  1553.    case S_INT:
  1554.     printf("%d\n",*(int *)s->ptr);
  1555.     break;
  1556.  
  1557.    case S_LONG:
  1558.     printf("%ld\n",*(long *)s->ptr);
  1559.     break;
  1560.  
  1561.    default:
  1562.     break;
  1563.     }
  1564. }
  1565.  
  1566. @
  1567. @a
  1568. SRTN see_str FCN((s))
  1569.     CONST outer_char HUGE *s C1("")@;
  1570. {
  1571. outer_char c;
  1572.  
  1573. if(s==NULL) 
  1574.     {
  1575.     printf("NULL\n");
  1576.     return;
  1577.     }
  1578. else if(s < (outer_char HUGE *)100) 
  1579.     { /* Horrible kludge to handle stupid color processing. */
  1580.     printf("\n");
  1581.     return;
  1582.     }
  1583.  
  1584. printf("\"");
  1585.  
  1586. while((c = *s++))
  1587.   print_it:
  1588.     if(c=='\\') printf("\\\\");
  1589.     else if(isprint(c)) printf("%c",c);
  1590.     else 
  1591.         {
  1592.         printf("\\");
  1593.         switch(c)
  1594.             {
  1595.            case '\a': c = 'a'; goto print_it;
  1596.            case '\b': c = 'b'; goto print_it;
  1597.            case '\f': c = 'f'; goto print_it;
  1598.            case '\n': c = 'n'; goto print_it;
  1599.            case '\r': c = 'r'; goto print_it;
  1600.            case '\t': c = 't'; goto print_it;
  1601.            case '\v': c = 'v'; goto print_it;
  1602.            default:
  1603.             printf("%o",c);
  1604.             break;
  1605.             }
  1606.         }
  1607.  
  1608. printf("\"\n");
  1609. }
  1610.  
  1611. @* INDEX.
  1612.