开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
out.c
资源名称：pascal2c.tar.Z　[点击查看]
上传用户：upcnvip
上传日期：2007-01-06
资源大小：474k
文件大小：33k
源码类别：

编译器/解释器

开发平台：

C/C++

out.c：源码内容
  1. /* "p2c", a Pascal to C translator.
  2.    Copyright (C) 1989 David Gillespie.
  3.    Author's address: daveg@csvax.caltech.edu; 256-80 Caltech/Pasadena CA 91125.
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation (any version).
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with this program; see the file COPYING.  If not, write to
  16. the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
  21. /* This needs to go before trans.h (and thus p2c.proto) is read */
  23. typedef struct S_paren {
  24.     struct S_paren *next;
  25.     int pos, indent, qmindent, flags;
  26. } Paren;
  30. #define PROTO_OUT_C
  31. #include "trans.h"
  34. #ifndef USETIME
  35. # if defined(BSD) || defined(hpux)
  36. #  define USETIME 1
  37. # else
  38. #  define USETIME 0
  39. # endif
  40. #endif
  42. #if USETIME
  43. # include <sys/time.h>
  44. #else
  45. # include <time.h>
  46. #endif
  51. /* Output control characters:
  53.    01  B  Possible break point
  54.    02  X  Break point in parentheses
  55.    03  (  Invisible open paren
  56.    04  )  Invisible close paren
  57.    05  T  Set left margin
  58.    06  F  Forced break point
  59.    07  A  Preceding paren requires all-or-none breaking
  60.    10  [  Invisible open paren, becomes visible if not all on one line
  61.    11  S  Break point after last "special argument" of a function
  62.    12  n  (newline)
  63.    13  E  Preceding break has extra penalty
  64.    14  f  (form-feed)
  65.    15  H  Hang-indent the preceding operator
  66.    16  .  (unused)
  67.    17  C  Break point for last : of a ?: construct
  69. */
  71. char spchars[] = ".BX()TFA[SnEfH.C................";
  75. Static int testinglinebreaker = 0;
  77. Static int deltaindent, thisindent, thisfutureindent;
  78. Static int sectionsize, blanklines, codesectsize, hdrsectsize;
  79. Static int codelnum, hdrlnum;
  81. #define MAXBREAKS  200
  82. Static int numbreaks, bestnumbreaks;
  83. Static double bestbadness;
  84. Static int breakpos[MAXBREAKS], breakindent[MAXBREAKS];
  85. Static int breakcount[MAXBREAKS], breakparen[MAXBREAKS];
  86. Static int bestbreakpos[MAXBREAKS], bestbreakindent[MAXBREAKS];
  87. Static int breakerrorflag;
  89. #define MAXEDITS  200
  90. Static int numedits, bestnumedits;
  91. Static int editpos[MAXEDITS], besteditpos[MAXEDITS];
  92. Static char editold[MAXEDITS], editnew[MAXEDITS];
  93. Static char besteditold[MAXEDITS], besteditnew[MAXEDITS];
  95. Static Paren *parenlist;
  97. Static long numalts, bestnumalts;
  98. Static int randombreaks;
  100. Static char *outbuf;
  101. Static int outbufpos, outbufcount, outbufsize;
  102. Static int suppressnewline, lastlinelength;
  103. Static int eatblanks;
  104. Static int embeddedcode;
  105. Static int showingsourcecode = 0;
  107. #define BIGBADNESS  (1e20)
  111. void setup_out()
  112. {
  113.     end_source();
  114.     fprintf(outf, "/* From input file "%s" */n", infname);
  115.     outf_lnum++;
  116.     hdrlnum = 1;
  117.     outindent = 0;
  118.     deltaindent = 0;
  119.     thisindent = 0;
  120.     thisfutureindent = -1;
  121.     sectionsize = 2;
  122.     blanklines = 0;
  123.     dontbreaklines = 0;
  124.     embeddedcode = 0;
  125.     outputmode = 0;
  126.     suppressnewline = 0;
  127.     eatblanks = 0;
  128.     outbufsize = 1000;
  129.     outbuf = ALLOC(outbufsize, char, misc);
  130.     outbufpos = 0;
  131.     outbufcount = 0;
  132.     srand(17);
  133. }
  137. void select_outfile(fp)
  138. FILE *fp;
  139. {
  140.     if (outf == codef) {
  141.         codesectsize = sectionsize;
  142. codelnum = outf_lnum;
  143.     } else {
  144.         hdrsectsize = sectionsize;
  145. hdrlnum = outf_lnum;
  146.     }
  147.     outf = fp;
  148.     if (outf == codef) {
  149.         sectionsize = codesectsize;
  150. outf_lnum = codelnum;
  151.     } else {
  152.         sectionsize = hdrsectsize;
  153. outf_lnum = hdrlnum;
  154.     }
  155. }
  159. void start_source()
  160. {
  161.     if (!showingsourcecode) {
  162. fprintf(outf, "n#ifdef Pascaln");
  163. showingsourcecode = 1;
  164.     }
  165. }
  167. void end_source()
  168. {
  169.     if (showingsourcecode) {
  170. fprintf(outf, "#endif /*Pascal*/nn");
  171. showingsourcecode = 0;
  172.     }
  173. }
  177. int line_start()
  178. {
  179.     return (outbufcount == 0);
  180. }
  183. int cur_column()
  184. {
  185.     if (outbufpos == 0)
  186. return outindent;
  187.     else
  188. return thisindent + outbufcount;
  189. }
  193. int lookback(n)
  194. int n;
  195. {
  196.     if (n <= 0 || n > outbufpos)
  197. return 0;
  198.     else
  199. return outbuf[outbufpos - n];
  200. }
  203. int lookback_prn(n)
  204. int n;
  205. {
  206.     for (;;) {
  207. if (n <= 0 || n > outbufpos)
  208.     return 0;
  209. else if (outbuf[outbufpos - n] >= ' ')
  210.     return outbuf[outbufpos - n];
  211. else
  212.     n++;
  213.     }
  214. }
  218. /* Combine two indentation adjustments */
  219. int adddeltas(d1, d2)
  220. int d1, d2;
  221. {
  222.     if (d2 >= 1000)
  223. return d2;
  224.     else
  225. return d1 + d2;
  226. }
  229. /* Apply an indentation delta */
  230. int applydelta(i, d)
  231. int i, d;
  232. {
  233.     if (d >= 1000)
  234. return d - 1000;
  235.     else
  236. return i + d;
  237. }
  240. /* Adjust the current indentation by delta */
  241. void moreindent(delta)
  242. int delta;
  243. {
  244.     outindent = applydelta(outindent, delta);
  245. }
  248. /* Adjust indentation for just this line */
  249. void singleindent(delta)
  250. int delta;
  251. {
  252.     deltaindent = adddeltas(deltaindent, delta);
  253. }
  256. /* Predict indentation for next line */
  257. void futureindent(num)
  258. int num;
  259. {
  260.     thisfutureindent = applydelta(applydelta(outindent, deltaindent), num);
  261. }
  264. int parsedelta(cp, def)
  265. char *cp;
  266. int def;
  267. {
  268.     if (!cp || !*cp)
  269. return def;
  270.     if ((*cp == '+' || *cp == '-') && isdigit(cp[1]))
  271. return atoi(cp);
  272.     if (*cp == '*' && isdigit(cp[1]))
  273. return 2000 + atoi(cp+1);
  274.     else
  275. return 1000 + atoi(cp);
  276. }
  281. Static void leading_tab(col)
  282. int col;
  283. {
  284.     if (col > maxlinewidth)
  285. return;    /* something wrong happened! */
  286.     if (phystabsize > 0) {
  287. while (col >= phystabsize) {
  288.     putc('t', outf);
  289.     col -= phystabsize;
  290. }
  291.     }
  292.     while (col > 0) {
  293. putc(' ', outf);
  294. col--;
  295.     }
  296. }
  300. void eatblanklines()
  301. {
  302.     eatblanks = 1;
  303. }
  307. Static void flush_outbuf(numbreaks, breakpos, breakindent,
  308.  numedits, editpos, editold, editnew)
  309. int numbreaks, *breakpos, *breakindent, numedits, *editpos;
  310. char *editold, *editnew;
  311. {
  312.     unsigned char ch, ch2;
  313.     char *cp;
  314.     int i, j, linelen = 0, spaces, hashline;
  315.     int editsaves[MAXEDITS];
  317.     end_source();
  318.     if (outbufcount > 0) {
  319. for (i = 0; i < numedits; i++) {
  320.     editsaves[i] = outbuf[editpos[i]];
  321.     outbuf[editpos[i]] = editnew[i];
  322. }
  323. leading_tab(thisindent);
  324. cp = outbuf;
  325. hashline = (*cp == '#');    /* a preprocessor directive */
  326. spaces = 0;
  327. j = 1;
  328. for (i = 0; i < outbufpos; ) {
  329.     if (j < numbreaks && i == breakpos[j]) {
  330. if (hashline)
  331.     fprintf(outf, " \");   /* trailing backslash required */
  332. putc('n', outf);
  333. outf_lnum++;
  334. leading_tab(breakindent[j]);
  335. linelen = breakindent[j];
  336. j++;
  337. while (i < outbufpos && *cp == ' ')
  338.     i++, cp++;   /* eat leading spaces */
  339. spaces = 0;      /* eat trailing spaces */
  340.     } else {
  341. ch = *cp++;
  342. if (ch == ' ') {
  343.     spaces++;
  344. } else if (ch > ' ') {
  345.     linelen += spaces;
  346.     while (spaces > 0)
  347. putc(' ', outf), spaces--;
  348.     linelen++;
  349.     if (ch == '\' && embeddedcode) {
  350. if (*cp == '[') {
  351.     putc('{', outf);
  352.     cp++, i++;
  353. } else if (*cp == ']') {
  354.     putc('}', outf);
  355.     cp++, i++;
  356. } else
  357.     putc(ch, outf);
  358.     } else
  359. putc(ch, outf);
  360. } else if (testinglinebreaker >= 3) {
  361.     linelen += spaces;
  362.     while (spaces > 0)
  363. putc(' ', outf), spaces--;
  364.     linelen++;
  365.     putc('\', outf);
  366.     ch2 = spchars[ch];
  367.     if (ch2 != '.')
  368. putc(ch2, outf);
  369.     else {
  370. putc('0' + ((ch >> 6) & 7), outf);
  371. putc('0' + ((ch >> 3) & 7), outf);
  372. putc('0' + (ch & 7), outf);
  373.     }
  374. }
  375. i++;
  376.     }
  377. }
  378. for (i = 0; i < numedits; i++)
  379.     outbuf[editpos[i]] = editsaves[i];
  380. eatblanks = 0;
  381.     } else if (eatblanks) {
  382. return;
  383.     }
  384.     if (suppressnewline) {
  385. lastlinelength = linelen;
  386.     } else
  387. putc('n', outf);
  388.     outf_lnum++;
  389. }
  393. #define ISQUOTE(ch)  ((ch)=='"' || (ch)==''')
  394. #define ISOPENP(ch)  ((ch)=='(' || (ch)=='[' || (ch)=='03' || (ch)=='10')
  395. #define ISCLOSEP(ch) ((ch)==')' || (ch)==']' || (ch)=='04')
  396. #define ISBREAK(ch)  ((ch)=='01' || (ch)=='02' || (ch)=='06' || (ch)=='11' || (ch)=='17')
  398. Static int readquotes(posp, err)
  399. int *posp, err;
  400. {
  401.     int pos;
  402.     char quote;
  404.     pos = *posp;
  405.     quote = outbuf[pos++];
  406.     while (pos < outbufpos && outbuf[pos] != quote) {
  407. if (outbuf[pos] == '\')
  408.     pos++;
  409. pos++;
  410.     }
  411.     if (pos >= outbufpos) {
  412. if (err && breakerrorflag) {
  413.     intwarning("output", "Mismatched quotes [248]");
  414.     breakerrorflag = 0;
  415. }
  416. return 0;
  417.     } else {
  418. *posp = pos;
  419. return 1;
  420.     }    
  421. }
  424. Static int maxdepth;
  426. Static int readparens(posp, err)
  427. int *posp, err;
  428. {
  429.     char ch, closing;
  430.     int pos, level;
  432.     pos = *posp;
  433.     switch (outbuf[pos]) {
  434.       case '(':
  435. closing = ')';
  436. break;
  437.       case '[':
  438. closing = ']';
  439. break;
  440.       case '03':
  441.       case '10':
  442. closing = '04';
  443. break;
  444.       default:
  445. closing = 0;
  446. break;
  447.     }
  448.     level = 0;
  449.     for (;;) {
  450. pos++;
  451. if (pos >= outbufpos)
  452.     break;
  453. ch = outbuf[pos];
  454. if (ISOPENP(ch)) {
  455.     level++;
  456.     if (level > maxdepth)
  457. maxdepth = level;
  458. } else if (ISCLOSEP(ch)) {
  459.     level--;
  460.     if (level < 0) {
  461. if (closing && outbuf[pos] != closing)
  462.     break;
  463. *posp = pos;
  464. return 1;
  465.     }
  466. } else if (ISQUOTE(ch)) {
  467.     if (!readquotes(&pos, err))
  468. return 0;
  469. }
  470.     }
  471.     if (err && breakerrorflag) {
  472. switch (closing) {
  473.   case ')':
  474.     intwarning("output", "Mismatched parentheses [249]");
  475.     break;
  476.   case ']':
  477.     intwarning("output", "Mismatched brackets [249]");
  478.     break;
  479.   default:
  480.     intwarning("output", "Mismatched clauses [250]");
  481.     break;
  482. }
  483. breakerrorflag = 0;
  484.     }
  485.     return 0;
  486. }
  490. Static int measurechars(first, last)
  491. int first, last;
  492. {
  493.     int count = 0;
  495.     while (first <= last) {
  496. if (outbuf[first] >= ' ')
  497.     count++;
  498. first++;
  499.     }
  500.     return count;
  501. }
  505. Static void makeedit(pos, ch)
  506. int pos, ch;
  507. {
  508.     editpos[numedits] = pos;
  509.     editold[numedits] = outbuf[pos];
  510.     editnew[numedits] = ch;
  511.     outbuf[pos] = ch;
  512.     numedits++;
  513. }
  515. Static void unedit()
  516. {
  517.     numedits--;
  518.     outbuf[editpos[numedits]] = editold[numedits];
  519. }
  522. Static int parencount(par)
  523. Paren *par;
  524. {
  525.     int count = 0;
  527.     while (par) {
  528. count++;
  529. par = par->next;
  530.     }
  531.     return count;
  532. }
  537. /* The following routine explores the tree of all possible line breaks,
  538.    pruning according to the fact that "badness" and "extra" are
  539.    increasing functions.  The object is to find the set of breaks and
  540.    indentation with the least total badness.
  541.    (The basic idea was borrowed from Donald Knuth's "TeX".)
  542. */
  544. /* As an additional optimization, the concept of a "simple" line is used,
  545.    i.e., a line with a structure such that the best break is sure to be
  546.    the straightforward left-to-right fill used by a simple word processor.
  547.    (For example, a long line with nothing but comma-breakpoints is simple.)
  549.    Also, if the line is very long a few initial random passes are made just
  550.    to scope out an estimate of the eventual badness of the line.  This
  551.    combined with the badness cull helps keep the breaker from using up its
  552.    quota of tries before even considering a key break point!  Note that
  553.    when randombreaks==1, each call to trybreakline is fast since only one
  554.    branch is taken at each decision point.
  555. */
  558. #define randtest(lim)  (!randombreaks ? -1    
  559. : randombreaks > 0    
  560.     ? parencount(parens) < randombreaks-1   
  561. : randombreaks == -2  
  562.     ? 0 
  563. : (rand() & 0xfff) < (lim))
  565. #define TB_BRKCOUNT   0x0ff
  566. #define TB_FORCEBRK   0x100
  567. #define TB_NOBREAK    0x200
  568. #define TB_ALREADYBRK 0x400
  569. #define TB_ALLORNONE  0x800
  570. #define TB_EXTRAIND   0x1000
  571. #define TB_EXTRAIND2  0x2000
  573. #define TBR_ABORT     0x1
  574. #define TBR_SIMPLE    0x2
  575. #define TBR_REACHED   0x4
  577. Static int trybreakline(pos, count, indent, badness, flags, parens)
  578. int pos, count, indent, flags;
  579. double badness;
  580. Paren *parens;
  581. {
  582.     int edited;
  583.     int i, j, jmask, f, pos2, r;
  584.     char ch, ch2, closing;
  585.     double extra, penalty;
  586.     Paren *pp;
  588. #if 0
  589.     { static double save = -1;
  590.       if (showbadlimit != save) printf("Showbadlimit = %gn", showbadlimit);
  591.       save = showbadlimit;
  592.     }
  593. #endif
  595.     if (numalts >= maxalts)
  596. return TBR_ABORT;
  597.     jmask = -1;
  598.     for (;;) {
  599. if (numbreaks >= MAXBREAKS) {   /* must leave rest of line alone */
  600.     count += measurechars(pos, outbufpos-1);
  601.     pos = outbufpos;
  602. }
  603. i = count - breakcount[numbreaks-1] +
  604.     breakindent[numbreaks-1] - linewidth;
  605. if (i <= 0)
  606.     extra = 0;
  607. else {
  608.     if (i + linewidth >= maxlinewidth || randombreaks == -2)
  609. return 0;   /* absolutely too long! */
  610.     extra = overwidepenalty + ((long)i*i)*overwideextrapenalty;
  611.     jmask &= ~TBR_SIMPLE;
  612.     if (extra < 0)
  613. extra = 0;
  614. }
  615. if ((testinglinebreaker > 1 && showbadlimit > 0) ?
  616.     (badness + extra >= showbadlimit) :
  617.     (badness + extra >= bestbadness)) {
  618.     numalts++;
  619.     return 0;   /* no point in going on, badness will only increase */
  620. }
  621. if (pos >= outbufpos)
  622.     break;
  623. if (parens && pos >= parens->pos) {
  624.     indent = parens->indent;
  625.     flags = parens->flags;
  626.     parens = parens->next;
  627. }
  628. ch = outbuf[pos++];
  629. if (ch >= ' ')
  630.     count++;
  631. switch (ch) {
  633.   case '(':
  634.   case '[':
  635.   case '03':     /* "invisible open paren" */
  636.   case '10':     /* "semi-invisible open paren" */
  637.     pos2 = pos - 1;
  638.     if (!readparens(&pos2, 1))
  639. break;
  640.     i = measurechars(pos, pos2);
  641.     if (count + i - breakcount[numbreaks-1] +
  642. breakindent[numbreaks-1] <= linewidth) {
  643. /* it fits, so leave it on one line */
  644. #if 0  /* I don't think this is necessary */
  645. while (pos <= pos2) {
  646.     if (outbuf[pos] == '02') {
  647. jmask &= ~TBR_SIMPLE;
  648. pos = pos2 + 1;
  649. break;
  650.     }
  651.     pos++;
  652. }
  653. #else
  654. pos = pos2 + 1;
  655. #endif
  656. count += i;
  657. break;
  658.     }
  659.     pp = ALLOC(1, Paren, parens);   /* doesn't fit, try poss breaks */
  660.     pp->next = parens;
  661.     pp->pos = pos2;
  662.     pp->indent = indent;
  663.     pp->qmindent = indent;
  664.     pp->flags = flags;
  665.     parens = pp;
  666.     flags = 0;
  667.     if (ch == '10' &&       /* change to real parens when broken */
  668. numedits+1 < MAXEDITS) {    /* (assume it will be broken!) */
  669. makeedit(pos-1, '(');
  670. makeedit(pos2, ')');
  671. count++;    /* count the new open paren */
  672. edited = 1;
  673.     } else
  674. edited = 0;
  675.     i = breakindent[numbreaks-1] + count - breakcount[numbreaks-1];
  676.     if (i <= thisindent)
  677. r = 0;  /* e.g., don't break top-level assignments */
  678.     else if (i == indent + extraindent)
  679. r = 1;  /* don't waste time on identical operations */
  680.     else
  681. r = randtest(0xc00);
  682.     if (r != 0) {
  683. j = trybreakline(pos, count, i,
  684.  badness + MAX(- extraindentpenalty,0),
  685.  flags, parens);
  686.     } else
  687. j = 0;
  688.     if (r != 1) {
  689. j &= trybreakline(pos, count, indent + extraindent,
  690.   badness + MAX(extraindentpenalty,0),
  691.   flags | TB_EXTRAIND, parens);
  692.     }
  693.     if (!randombreaks && bumpindent != 0) {
  694. if (i == thisfutureindent) {
  695.     j &= trybreakline(pos, count, i + bumpindent,
  696.       badness + MAX(- extraindentpenalty,0)
  697.               + bumpindentpenalty,
  698.       flags, parens);
  699. } else if (indent + extraindent == thisfutureindent) {
  700.     j &= trybreakline(pos, count,
  701.       indent + extraindent + bumpindent,
  702.       badness + MAX(extraindentpenalty,0)
  703.               + bumpindentpenalty,
  704.       flags | TB_EXTRAIND, parens);
  705. }
  706.     }
  707.     if (edited) {
  708. unedit();
  709. unedit();
  710.     }
  711.     FREE(pp);
  712.     return j & jmask;
  714.   case '05':   /* "set left margin" */
  715.     indent = breakindent[numbreaks-1] +
  716.      count - breakcount[numbreaks-1];
  717.     break;
  719.   case '07':   /* "all-or-none breaking" */
  720.     flags |= TB_ALLORNONE;
  721.     break;
  723.   case '01':   /* "possible break point" */
  724.   case '02':   /* "break point in parens" */
  725.   case '06':   /* "forced break point" */
  726.   case '11':   /* "break point after special args" */
  727.   case '17':   /* "break point for final : operator" */
  728.     /* first try the non-breaking case */
  729.     if (ch != '01' && ch != '06')
  730. jmask &= ~TBR_SIMPLE;
  731.     if ((flags & TB_BRKCOUNT) != TB_BRKCOUNT)
  732. flags++;   /* increment TB_BRKCOUNT field */
  733.     if (outbuf[pos] == '?' && parens)
  734. parens->qmindent = breakindent[numbreaks-1] +
  735.                    count - breakcount[numbreaks-1];
  736.     j = TBR_REACHED;
  737.     if (ch == '06' || (flags & TB_FORCEBRK)) {
  738. /* don't try the non-breaking case */
  739.     } else {
  740. if (ch == '11') {
  741.     i = breakindent[numbreaks-1] +
  742. count - breakcount[numbreaks-1] + 2;
  743. } else {
  744.     i = indent;
  745. }
  746. f = flags;
  747. if (f & TB_ALLORNONE)
  748.     f |= TB_NOBREAK;
  749. r = randtest(0x800);
  750. if (r != 1 || (flags & TB_NOBREAK)) {
  751.     j = trybreakline(pos, count, i, badness, f, parens) &
  752. jmask;
  753.     if (randombreaks == -2 && !(j & TBR_REACHED)) {
  754. r = -1;
  755. j |= TBR_REACHED;
  756.     }
  757.     if (r == 0 || (j & TBR_SIMPLE))
  758. flags |= TB_NOBREAK;
  759. }
  760.     }
  761.     if (flags & TB_NOBREAK)
  762. return j;
  763.     if (flags & TB_ALLORNONE)
  764. flags |= TB_FORCEBRK;
  765.     if (flags & TB_EXTRAIND) {
  766. flags &= ~TB_EXTRAIND;
  767. flags |= TB_EXTRAIND2;
  768.     }
  769.     /* now try breaking here */
  770.     if (ch == '17')
  771. indent = parens->qmindent;
  772.     if (indent < 0)
  773. indent = 0;
  774.     breakpos[numbreaks] = pos;
  775.     breakcount[numbreaks] = count;
  776.     breakindent[numbreaks] = indent;
  777.     breakparen[numbreaks] = parens ? parens->pos : 0;
  778.     numbreaks++;
  779.     penalty = extra;
  780.     if (indent == thisfutureindent) {
  781. i = pos;
  782. while (i < outbufpos-1 && outbuf[i] <= ' ')
  783.     i++;
  784. ch2 = outbuf[i];   /* first character on next line */
  785. if (ch2 != '(' && ch2 != '!' && ch2 != '~' && ch2 != '-')
  786.     penalty += nobumpindentpenalty;
  787.     }
  788.     switch (ch) {
  789.       case '01':
  790. penalty += commabreakpenalty;
  791. if (flags & TB_ALREADYBRK)
  792.     penalty += morebreakpenalty;
  793. break;
  794.       case '11':
  795. i = parencount(parens);
  796. penalty += specialargbreakpenalty + commabreakextrapenalty*i;
  797. break;
  798.       case '02':
  799.       case '17':
  800. i = parencount(parens);
  801. if (outbuf[pos-2] == '(')
  802.     penalty += parenbreakpenalty + parenbreakextrapenalty*i;
  803. else if (outbuf[pos-2] == ',')
  804.     penalty += commabreakpenalty + commabreakextrapenalty*i;
  805. else if (outbuf[pos-2] == '=')
  806.     penalty += assignbreakpenalty + assignbreakextrapenalty*i;
  807. else if (outbuf[pos] == '?') {
  808.     penalty += qmarkbreakpenalty + qmarkbreakextrapenalty*i;
  809.     if (parens)
  810. parens->qmindent = breakindent[numbreaks-1] +
  811.                    count - breakcount[numbreaks-1];
  812. } else
  813.     penalty += opbreakpenalty + opbreakextrapenalty*i;
  814. if (outbuf[pos-2] == '-')
  815.     penalty += exhyphenpenalty;
  816. if (flags & TB_ALREADYBRK)
  817.     penalty += morebreakpenalty + morebreakextrapenalty*i;
  818. break;
  819.       default:
  820. break;
  821.     }
  822.     while (pos < outbufpos && outbuf[pos] == '13') {
  823. penalty += wrongsidepenalty;
  824. pos++;
  825.     }
  826.     penalty -= earlybreakpenalty*(flags & TB_BRKCOUNT);
  827.     /* the following test is not quite right, but it's not too bad. */
  828.     if (breakindent[numbreaks-2] == breakindent[numbreaks-1] &&
  829. breakparen[numbreaks-2] != breakparen[numbreaks-1])
  830. penalty += sameindentpenalty;
  831. #if 0
  832.     else if (ch == '02' && parens &&  /*don't think this is needed*/
  833.      parens->indent == breakindent[numbreaks-1] &&
  834.      parens->pos != breakparen[numbreaks-1])
  835. penalty += sameindentpenalty + 0.001;   /***/
  836. #endif
  837.     penalty += (breakindent[numbreaks-1] - thisindent) *
  838.        indentamountpenalty;
  839.     if (penalty < 1) penalty = 1;
  840.     pos2 = pos;
  841.     while (pos2 < outbufpos && outbuf[pos2] == ' ')
  842. pos2++;
  843.     flags |= TB_ALREADYBRK;
  844.     j = trybreakline(pos2, count, indent, badness + penalty,
  845.      flags, parens) & jmask;
  846.     numbreaks--;
  847.     return j;
  848.     
  849.   case '15':    /* "hang-indent operator" */
  850.     if (count <= breakcount[numbreaks-1] + 2 &&
  851. !(flags & TB_EXTRAIND2)) {
  852. breakindent[numbreaks-1] -= count - breakcount[numbreaks-1];
  853. pos2 = pos;
  854. while (pos2 < outbufpos && outbuf[pos2] <= ' ') {
  855.     if (outbuf[pos2] == ' ')
  856. breakindent[numbreaks-1]--;
  857.     pos2++;
  858. }
  859.     }
  860.     break;
  862.   case '"':
  863.   case ''':
  864.     closing = ch;
  865.     while (pos < outbufpos && outbuf[pos] != closing) {
  866. if (outbuf[pos] == '\')
  867.     pos++, count++;
  868. pos++;
  869. count++;
  870.     }
  871.     if (pos >= outbufpos) {
  872. intwarning("output", "Mismatched quotes [248]");
  873. continue;
  874.     }
  875.     pos++;
  876.     count++;
  877.     break;
  879.   case '/':
  880.     if (pos < outbufpos && (outbuf[pos] == '*' ||
  881.     (outbuf[pos] == '/' && cplus > 0))) {
  882. count += measurechars(pos, outbufpos-1);
  883. pos = outbufpos;   /* assume comment is at end of line */
  884.     }
  885.     break;
  887. }
  888.     }
  889.     numalts++;
  890.     badness += extra;
  891.     if (testinglinebreaker > 1) {
  892. if (badness >= bestbadness &&
  893.     (badness < showbadlimit || showbadlimit == 0)) {
  894.     fprintf(outf, "n#if 0   /* rejected #%ld, badness = %g >= %g */n", numalts, badness, bestbadness);
  895.     flush_outbuf(numbreaks, breakpos, breakindent,
  896.  numedits, editpos, editold, editnew);
  897.     fprintf(outf, "#endifn");
  898.     return TBR_SIMPLE & jmask;
  899. } else if ((bestbadness < showbadlimit || showbadlimit == 0) &&
  900.    bestnumalts > 0) {
  901.     fprintf(outf, "n#if 0   /* rejected #%ld, badness = %g > %g */n", bestnumalts, bestbadness, badness);
  902.     flush_outbuf(bestnumbreaks, bestbreakpos, bestbreakindent,
  903.  bestnumedits, besteditpos,
  904.  besteditold, besteditnew);
  905.     fprintf(outf, "#endifn");
  906. }
  907.     }
  908.     bestbadness = badness;
  909.     bestnumbreaks = numbreaks;
  910.     bestnumalts = numalts;
  911.     for (i = 0; i < numbreaks; i++) {
  912. bestbreakpos[i] = breakpos[i];
  913. bestbreakindent[i] = breakindent[i];
  914.     }
  915.     bestnumedits = numedits;
  916.     for (i = 0; i < numedits; i++) {
  917. besteditpos[i] = editpos[i];
  918. besteditold[i] = editold[i];
  919. besteditnew[i] = editnew[i];
  920.     }
  921.     return TBR_SIMPLE & jmask;
  922. }
  927. int parse_breakstr(cp)
  928. char *cp;
  929. {
  930.     short val = 0;
  932.     if (isdigit(*cp))
  933. return atoi(cp);
  934.     while (*cp && !isspace(*cp) && *cp != '}') {
  935. switch (toupper(*cp++)) {
  937.   case 'N':
  938.   case '=':
  939.     break;
  941.   case 'L':
  942.     val |= BRK_LEFT;
  943.     break;
  945.   case 'R':
  946.     val |= BRK_RIGHT;
  947.     break;
  949.   case 'H':
  950.     val |= BRK_HANG | BRK_LEFT;
  951.     break;
  953.   case '>':
  954.     if (val & BRK_LEFT)
  955. val |= BRK_LPREF;
  956.     else if (val & BRK_RIGHT)
  957. val |= BRK_RPREF;
  958.     else
  959. return -1;
  960.     break;
  962.   case '<':
  963.     if (val & BRK_LEFT)
  964. val |= BRK_RPREF;
  965.     else if (val & BRK_RIGHT)
  966. val |= BRK_LPREF;
  967.     else
  968. return -1;
  969.     break;
  971.   case 'A':
  972.     val |= BRK_ALLNONE;
  973.     break;
  975.   default:
  976.     return -1;
  978. }
  979.     }
  980.     return val;
  981. }
  986. long getcurtime()
  987. {
  988. #if USETIME
  989.     static unsigned long starttime = 0;
  990.     struct timeval t;
  991.     struct timezone tz;
  993.     gettimeofday(&t, &tz);
  994.     if (starttime == 0)
  995. starttime = t.tv_sec;
  996.     t.tv_sec -= starttime;
  997.     return (t.tv_sec*1000 + t.tv_usec/1000);
  998. #else
  999.     static unsigned long starttime = 0;
  1000.     if (!starttime) starttime = time(NULL);
  1001.     return (time(NULL) - starttime) * 1000;
  1002. #endif
  1003. }
  1007. void output(msg)
  1008. register char *msg;
  1009. {
  1010.     unsigned char ch;
  1011.     double savelimit;
  1012.     int i, savemaxlw, maxdp;
  1013.     long alts;
  1014.     long time0, time0a, time1;
  1016.     debughook();
  1017.     if (outputmode) {
  1018. end_source();
  1019. while ((ch = *msg++) != 0) {
  1020.     if (ch >= ' ') {
  1021. putc(ch, outf);
  1022.     } else if (ch == 'n') {
  1023. putc('n', outf);
  1024. outf_lnum++;
  1025.     }
  1026. }
  1027. return;
  1028.     }
  1029.     while ((ch = *msg++) != 0) {
  1030. if (ch == 'n') {
  1031.     if (outbufpos == 0) {      /* blank line */
  1032. thisfutureindent = -1;
  1033. blanklines++;
  1034. continue;
  1035.     }
  1036.     if (sectionsize > blanklines)
  1037. blanklines = sectionsize;
  1038.     sectionsize = 0;
  1039.     if (eatblanks)
  1040. blanklines = 0;
  1041.             while (blanklines > 0) {
  1042.                 blanklines--;
  1043. end_source();
  1044.                 putc('n', outf);
  1045. outf_lnum++;
  1046.             }
  1047.     if (thisindent + outbufcount >= linewidth && !dontbreaklines) {
  1048. numbreaks = 1;
  1049. bestnumbreaks = 0;
  1050. bestbadness = BIGBADNESS;
  1051. breakpos[0] = 0;
  1052. breakindent[0] = thisindent;
  1053. breakcount[0] = 0;
  1054. breakerrorflag = 1;
  1055. numedits = 0;
  1056. bestnumedits = 0;
  1057. savelimit = showbadlimit;
  1058. numalts = 0;
  1059. bestnumalts = 0;
  1060. savemaxlw = maxlinewidth;
  1061. time0 = time0a = getcurtime();
  1062. if (regression)
  1063.     srand(17);
  1064. if (thisindent + outbufcount > linewidth*3/2) {
  1065.     i = 0;
  1066.     maxdepth = 0;
  1067.     readparens(&i, 0);
  1068.     maxdp = maxdepth;
  1069.     for (;;) {    /* try some simple fixed methods first... */
  1070. for (i = 1; i <= 20; i++) {
  1071.     randombreaks = -1;
  1072.     trybreakline(0, 0, thisindent, 0.0, 0, NULL);
  1073. }
  1074. randombreaks = -2;
  1075. trybreakline(0, 0, thisindent, 0.0, 0, NULL);
  1076. for (i = 0; i <= maxdp+1; i++) {
  1077.     randombreaks = i+1;
  1078.     trybreakline(0, 0, thisindent, 0.0, 0, NULL);
  1079. }
  1080. if (bestbadness == BIGBADNESS && maxlinewidth < 9999) {
  1081.     maxlinewidth = 9999;   /* no choice but to relax */
  1082.     numalts = 0;
  1083. } else
  1084.     break;
  1085.     }
  1086.     time0a = getcurtime();
  1087. }
  1088. randombreaks = 0;
  1089. trybreakline(0, 0, thisindent, 0.0, 0, NULL);
  1090. if (bestbadness == BIGBADNESS && maxlinewidth < 9999) {
  1091.     numalts = 0;
  1092.     maxlinewidth = 9999;   /* no choice but to relax this */
  1093.     trybreakline(0, 0, thisindent, 0.0, 0, NULL);
  1094. }
  1095. time1 = getcurtime() - time0;
  1096. alts = numalts;
  1097. if (testinglinebreaker) {
  1098.     if (savelimit < 0 && testinglinebreaker > 1) {
  1099. showbadlimit = bestbadness * (-savelimit);
  1100. numalts = 0;
  1101. bestnumalts = 0;
  1102. trybreakline(0, 0, thisindent, 0.0, 0, NULL);
  1103.     }
  1104.     fprintf(outf, "n#if 1   /* accepted #%ld, badness = %g, tried %ld in %.3f sec */n", bestnumalts, bestbadness, alts, time1/1000.0);
  1105. }
  1106. showbadlimit = savelimit;
  1107. maxlinewidth = savemaxlw;
  1108. flush_outbuf(bestnumbreaks, bestbreakpos, bestbreakindent,
  1109.      bestnumedits, besteditpos,
  1110.      besteditold, besteditnew);
  1111. if (((USETIME && time1 > 1000) || alts >= maxalts) &&
  1112.     !regression) {
  1113.     sprintf(outbuf, "Line breaker spent %.1f",
  1114.     (time1 + time0 - time0a) / 1000.0);
  1115.     if (time0 != time0a)
  1116. sprintf(outbuf + strlen(outbuf),
  1117. "+%.2f", (time0a - time0) / 1000.0);
  1118.     sprintf(outbuf + strlen(outbuf),
  1119.     " seconds, %ld tries on line %d [251]", alts, outf_lnum);
  1120.     note(outbuf);
  1121. } else if (verbose) {
  1122.     fprintf(logf, "%s, %d/%d: Line breaker spent %ld triesn",
  1123.     infname, inf_lnum, outf_lnum, alts);
  1124. }
  1125. if (testinglinebreaker)
  1126.     fprintf(outf, "#endifnn");
  1127.     } else {
  1128. if (testinglinebreaker < 2)
  1129.     flush_outbuf(0, NULL, NULL, 0, NULL, NULL, NULL);
  1130.     }
  1131.     thisfutureindent = -1;
  1132.     outbufpos = 0;
  1133.     outbufcount = 0;
  1134. } else {
  1135.     if (outbufpos == 0) {
  1136. if (ch == ' ' && !dontbreaklines)    /* eat leading spaces */
  1137.     continue;
  1138. thisindent = applydelta(outindent, deltaindent);
  1139. deltaindent = 0;
  1140.     }
  1141.     if (outbufpos == outbufsize) {
  1142. outbufsize *= 2;
  1143. outbuf = REALLOC(outbuf, outbufsize, char);
  1144.     }
  1145.     outbuf[outbufpos++] = ch;
  1146.     if (ch >= ' ')
  1147. outbufcount++;
  1148. }
  1149.     }
  1150. }
  1154. void out_n_spaces(n)
  1155. int n;
  1156. {
  1157.     while (--n >= 0)
  1158. output(" ");
  1159. }
  1163. void out_spaces(spc, over, len, delta)
  1164. int spc, over, len, delta;
  1165. {
  1166.     int n;
  1168.     if (spc == -999)
  1169. spc = commentindent;
  1170.     if (spc < 0) {               /* right-justify */
  1171. n = (-spc) - cur_column() - len;
  1172. if (n < minspcthresh)
  1173.     n = minspacing;
  1174. else
  1175.     over = 1000;
  1176.     } else if (spc >= 2000) {    /* tab to multiple */
  1177. spc -= 2000;
  1178. n = (spc-1) - ((cur_column()+spc-1) % spc);
  1179. if (n < minspcthresh)
  1180.     n += spc;
  1181.     } else if (spc >= 1000) {    /* absolute column */
  1182. spc -= 1000;
  1183. n = spc - cur_column();
  1184. if (n < minspcthresh)
  1185.     n = minspacing;
  1186.     } else                       /* relative spacing */
  1187. n = spc;
  1188.     if (line_start()) {
  1189. singleindent(n);
  1190.     } else if (len > 0 && over != 1000 && cur_column() + n + len > linewidth) {
  1191. output("n");
  1192. out_spaces(over, 1000, len, 0);
  1193. singleindent(delta);
  1194.     } else {
  1195. out_n_spaces(n);
  1196.     }
  1197. }
  1202. void testlinebreaker(lev, fn)
  1203. int lev;
  1204. char *fn;
  1205. {
  1206.     char buf[256], *bp, *cp;
  1207.     int first, indent;
  1209.     testinglinebreaker = lev;
  1210.     if (!fn)
  1211. return;
  1212.     inf = fopen(fn, "r");
  1213.     if (!inf) {
  1214. perror(fn);
  1215. exit(1);
  1216.     }
  1217.     sprintf(buf, "%s.br", fn);
  1218.     outf = fopen(buf, "w");
  1219.     if (!outf) {
  1220. perror(buf);
  1221. exit(1);
  1222.     }
  1223.     setup_out();
  1224.     outindent = 4;
  1225.     first = 1;
  1226.     while (fgets(buf, 256, inf)) {
  1227. cp = buf + strlen(buf) - 2;
  1228. if (cp >= buf) {
  1229.     bp = buf;
  1230.     indent = 0;
  1231.     while (isspace(*bp))
  1232. if (*bp++ == 't')
  1233.     indent += 8;
  1234. else
  1235.     indent++;
  1236.     if (first) {
  1237. first = 0;
  1238. outindent = indent;
  1239.     }
  1240.     if (!(*cp == '{' ||
  1241.   *cp == ')' ||
  1242.   *cp == ';') ||
  1243.   (*cp == '/' && cp[-1] == '*')) {
  1244. cp[1] = '01';   /* eat the n */
  1245.     } else {
  1246. first = 1;
  1247.     }
  1248.     output(bp);
  1249. }
  1250.     }
  1251.     fclose(outf);
  1252.     fclose(inf);
  1253. }
  1259. void outsection(size)
  1260. int size;
  1261. {
  1262.     if (size > sectionsize)
  1263.         sectionsize = size;
  1264. }
  1268. Strlist *outcomments(cmt)
  1269. Strlist *cmt;
  1270. {
  1271.     char *cp;
  1272.     int saveindent = outindent, savesingle = deltaindent, theindent;
  1273.     int i = 0;
  1275.     if (!cmt)
  1276. return NULL;
  1277.     if (!commentvisible(cmt)) {
  1278. setcommentkind(cmt, CMT_DONE);
  1279. return cmt->next;
  1280.     }
  1281.     if (*cmt->s == '01') {
  1282. if (cmtdebug)
  1283.     output(format_sd("[]  [%s:%d]",
  1284.      CMT_NAMES[getcommentkind(cmt)],
  1285.      cmt->value & CMT_MASK));
  1286. for (cp = cmt->s; *cp; cp++) {
  1287.     output("n");
  1288.     if (cmtdebug && cp[1])
  1289. output("[]");
  1290. }
  1291. setcommentkind(cmt, CMT_DONE);
  1292. return cmt->next;
  1293.     }
  1294.     dontbreaklines++;
  1295.     if (!strcmp(cmt->s, embedcomment) && *embedcomment && cmt->next &&
  1296. (*cmt->next->s == '02' || *cmt->next->s == '03')) {
  1297. cmt = cmt->next;
  1298. embeddedcode = 1;
  1299. theindent = 0;
  1300. cp = cmt->next->s + 1;
  1301. while (*cp++ == ' ')
  1302.     theindent++;
  1303.     } else {
  1304. moreindent(deltaindent);
  1305. if (cmt->s[0] == '04')
  1306.     outindent = 0;
  1307. theindent = outindent;
  1308. deltaindent = 0;
  1309. output("/*");
  1310.     }
  1311.     cp = cmt->s;
  1312.     for (;;) {
  1313. if (*cp == '02' || *cp == '03' || *cp == '04')
  1314.     cp++;
  1315. if (embeddedcode) {
  1316.     for (i = 0; *cp == ' ' && i < theindent; i++)
  1317. cp++;
  1318.     i = *cp;
  1319. }
  1320. output(cp);
  1321. if (cmtdebug)
  1322.     output(format_sd(" [%s:%d] ",
  1323.      CMT_NAMES[getcommentkind(cmt)],
  1324.      cmt->value & CMT_MASK));
  1325. setcommentkind(cmt, CMT_DONE);
  1326. cmt = cmt->next;
  1327. if (!cmt || !commentvisible(cmt))
  1328.     break;
  1329. cp = cmt->s;
  1330. if (*cp != '02' && *cp != '03')
  1331.     break;
  1332. output("n");
  1333. if (!embeddedcode) {
  1334.     outindent = (*cp == '02') ? theindent : 0;
  1335.     deltaindent = 0;
  1336. }
  1337.     }
  1338.     if (embeddedcode) {
  1339. embeddedcode = 0;
  1340. if (i) {   /* eat final blank line */
  1341.     output("n");
  1342. }
  1343.     } else {
  1344. outindent = saveindent;
  1345. deltaindent = savesingle;
  1346. output("*/n");
  1347.     }
  1348.     dontbreaklines--;
  1349.     return cmt;
  1350. }
  1354. void outcomment(cmt)
  1355. Strlist *cmt;
  1356. {
  1357.     Strlist *savenext;
  1358.     
  1359.     if (cmt) {
  1360. savenext = cmt->next;
  1361. cmt->next = NULL;
  1362. outcomments(cmt);
  1363. cmt->next = savenext;
  1364.     }
  1365. }
  1369. void outtrailcomment(cmt, serial, indent)
  1370. Strlist *cmt;
  1371. int serial, indent;
  1372. {
  1373.     int savedelta = deltaindent;
  1375. #if 0
  1376.     suppressnewline = 1;
  1377.     output("n");
  1378.     suppressnewline = 0;
  1379. #endif
  1380.     cmt = findcomment(cmt, CMT_TRAIL, serial);
  1381.     if (commentvisible(cmt)) {
  1382. out_spaces(indent, commentoverindent, commentlen(cmt), 0);
  1383. outcomment(cmt);
  1384. deltaindent = savedelta;
  1385.     } else
  1386. output("n");
  1387. }
  1391. void flushcomments(cmt, kind, serial)
  1392. Strlist **cmt;
  1393. int kind, serial;
  1394. {
  1395.     Strlist *cmt2, *cmt3;
  1396.     int saveindent, savesingle, saveeat;
  1398.     if (!cmt)
  1399. cmt = &curcomments;
  1400.     cmt2 = extractcomment(cmt, kind, serial);
  1401.     saveindent = outindent;
  1402.     savesingle = deltaindent;
  1403.     moreindent(deltaindent);
  1404.     deltaindent = 0;
  1405.     saveeat = eatcomments;
  1406.     if (eatcomments == 2)
  1407. eatcomments = 0;
  1408.     cmt3 = cmt2;
  1409.     while (cmt3)
  1410. cmt3 = outcomments(cmt3);
  1411.     eatcomments = saveeat;
  1412.     outindent = saveindent;
  1413.     deltaindent = savesingle;
  1414.     strlist_empty(&cmt2);
  1415. }
  1421. char *rawCstring(fmt, s, len, special)
  1422. char *fmt;
  1423. register char *s;
  1424. int len, special;
  1425. {
  1426.     char buf[500];
  1427.     register char *cp;
  1428.     register unsigned char ch;
  1430.     cp = buf;
  1431.     while (--len >= 0) {
  1432.         ch = *((unsigned char *) s);
  1433.         s++;
  1434.         if (ch == 0 && (len == 0 || !isdigit(*s))) {
  1435.             *cp++ = '\';
  1436.             *cp++ = '0';
  1437.         } else if (ch == 'n') {
  1438.             *cp++ = '\';
  1439.             *cp++ = 'n';
  1440.         } else if (ch == 'b') {
  1441.             *cp++ = '\';
  1442.             *cp++ = 'b';
  1443.         } else if (ch == 't') {
  1444.             *cp++ = '\';
  1445.             *cp++ = 't';
  1446.         } else if (ch == 'f') {
  1447.             *cp++ = '\';
  1448.             *cp++ = 'f';
  1449. #if 0
  1450.         } else if (ch == 'r') {
  1451.             *cp++ = '\';
  1452.             *cp++ = 'r';
  1453. #endif
  1454.         } else if (ch < ' ' || ch >= 127) {
  1455.             *cp++ = '\';
  1456.             *cp++ = '0' + (ch>>6);
  1457.             *cp++ = '0' + ((ch>>3) & 7);
  1458.             *cp++ = '0' + (ch & 7);
  1459.         } else if (ch == special) {
  1460.             switch (ch) {
  1461.                 case '%':
  1462.                     *cp++ = ch;
  1463.                     *cp++ = ch;
  1464.                     break;
  1465.             }
  1466.         } else {
  1467.             if (ch == '"' || ch == '\')
  1468.                 *cp++ = '\';
  1469.             *cp++ = ch;
  1470.         }
  1471.     }
  1472.     *cp = 0;
  1473.     return format_s(fmt, buf);
  1474. }
  1477. char *makeCstring(s, len)
  1478. register char *s;
  1479. int len;
  1480. {
  1481.     return rawCstring(""%s"", s, len, 0);
  1482. }
  1486. char *makeCchar(ich)
  1487. int ich;
  1488. {
  1489.     char buf[500];
  1490.     register char *cp;
  1491.     register unsigned char ch = (ich & 0xff);
  1493.     if (ich < 0 || ich > 255 || (ich == 0 && !nullcharconst))
  1494.         return format_d("%d", ich);
  1495.     cp = buf;
  1496.     if (ch == 0) {
  1497.         *cp++ = '\';
  1498.         *cp++ = '0';
  1499.     } else if (ch == 'n') {
  1500.         *cp++ = '\';
  1501.         *cp++ = 'n';
  1502.     } else if (ch == 'b') {
  1503.         *cp++ = '\';
  1504.         *cp++ = 'b';
  1505.     } else if (ch == 't') {
  1506.         *cp++ = '\';
  1507.         *cp++ = 't';
  1508.     } else if (ch == 'f') {
  1509.         *cp++ = '\';
  1510.         *cp++ = 'f';
  1511. #if 0
  1512.     } else if (ch == 'r') {
  1513.         *cp++ = '\';
  1514.         *cp++ = 'r';
  1515. #endif
  1516.     } else if (ch < ' ' || ch >= 127) {
  1517.         *cp++ = '\';
  1518.         *cp++ = '0' + (ch>>6);
  1519.         *cp++ = '0' + ((ch>>3) & 7);
  1520.         *cp++ = '0' + (ch & 7);
  1521.     } else {
  1522.         if (ch == ''' || ch == '\')
  1523.             *cp++ = '\';
  1524.         *cp++ = ch;
  1525.     }
  1526.     *cp = 0;
  1527.     return format_s("'%s'", buf);
  1528. }
  1535. /* End. */