| /* "p2c", a Pascal to C translator. | |
| Copyright (C) 1989, 1990, 1991 Free Software Foundation. | |
| Author's address: daveg@csvax.caltech.edu; 256-80 Caltech/Pasadena CA 91125. | |
| This program is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation (any version). | |
| This program is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| GNU General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with this program; see the file COPYING. If not, write to | |
| the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
| /* This needs to go before trans.h (and thus p2c.proto) is read */ | |
| typedef struct S_paren { | |
| struct S_paren *next; | |
| int pos, indent, qmindent, flags; | |
| } Paren; | |
| #define PROTO_OUT_C | |
| #include "trans.h" | |
| #ifndef USETIME | |
| # if defined(BSD) || defined(hpux) | |
| # define USETIME 1 | |
| # else | |
| # define USETIME 0 | |
| # endif | |
| #endif | |
| #if USETIME | |
| # include <sys/time.h> | |
| #else | |
| # include <time.h> | |
| #endif | |
| /* Output control characters: | |
| \001 \B Possible break point | |
| \002 \X Break point in parentheses | |
| \003 \( Invisible open paren | |
| \004 \) Invisible close paren | |
| \005 \T Set left margin | |
| \006 \F Forced break point | |
| \007 \A Preceding paren requires all-or-none breaking | |
| \010 \[ Invisible open paren, becomes visible if not all on one line | |
| \011 \S Break point after last "special argument" of a function | |
| \012 \n (newline) | |
| \013 \E Preceding break has extra penalty | |
| \014 \f (form-feed) | |
| \015 \H Hang-indent the preceding operator | |
| \016 \. (unused) | |
| \017 \C Break point for last : of a ?: construct | |
| */ | |
| char spchars[] = ".BX()TFA[SnEfH.C................"; | |
| Static int testinglinebreaker = 0; | |
| Static int deltaindent, thisindent, thisfutureindent; | |
| Static int sectionsize, blanklines, codesectsize, hdrsectsize; | |
| Static int codelnum, hdrlnum; | |
| #define MAXBREAKS 200 | |
| Static int numbreaks, bestnumbreaks; | |
| Static double bestbadness; | |
| Static int breakpos[MAXBREAKS], breakindent[MAXBREAKS]; | |
| Static int breakcount[MAXBREAKS], breakparen[MAXBREAKS]; | |
| Static int bestbreakpos[MAXBREAKS], bestbreakindent[MAXBREAKS]; | |
| Static int breakerrorflag; | |
| #define MAXEDITS 200 | |
| Static int numedits, bestnumedits; | |
| Static int editpos[MAXEDITS], besteditpos[MAXEDITS]; | |
| Static char editold[MAXEDITS], editnew[MAXEDITS]; | |
| Static char besteditold[MAXEDITS], besteditnew[MAXEDITS]; | |
| Static Paren *parenlist; | |
| Static long numalts, bestnumalts; | |
| Static int randombreaks; | |
| Static char *outbuf; | |
| Static int outbufpos, outbufcount, outbufsize; | |
| Static int suppressnewline, lastlinelength; | |
| Static int eatblanks; | |
| Static int embeddedcode; | |
| Static int showingsourcecode = 0; | |
| #define BIGBADNESS (1e20) | |
| void setup_out() | |
| { | |
| end_source(); | |
| if (!nobanner) | |
| fprintf(outf, "/* From input file \"%s\" */\n", infname); | |
| outf_lnum++; | |
| hdrlnum = 1; | |
| outindent = 0; | |
| deltaindent = 0; | |
| thisindent = 0; | |
| thisfutureindent = -1; | |
| sectionsize = 2; | |
| blanklines = 0; | |
| dontbreaklines = 0; | |
| embeddedcode = 0; | |
| outputmode = 0; | |
| suppressnewline = 0; | |
| eatblanks = 0; | |
| outbufsize = 1000; | |
| outbuf = ALLOC(outbufsize, char, misc); | |
| outbufpos = 0; | |
| outbufcount = 0; | |
| srand(17); | |
| } | |
| void select_outfile(fp) | |
| FILE *fp; | |
| { | |
| if (outf == codef) { | |
| codesectsize = sectionsize; | |
| codelnum = outf_lnum; | |
| } else { | |
| hdrsectsize = sectionsize; | |
| hdrlnum = outf_lnum; | |
| } | |
| outf = fp; | |
| if (outf == codef) { | |
| sectionsize = codesectsize; | |
| outf_lnum = codelnum; | |
| } else { | |
| sectionsize = hdrsectsize; | |
| outf_lnum = hdrlnum; | |
| } | |
| } | |
| void start_source() | |
| { | |
| if (!showingsourcecode) { | |
| fprintf(outf, "\n#ifdef Pascal\n"); | |
| showingsourcecode = 1; | |
| } | |
| } | |
| void end_source() | |
| { | |
| if (showingsourcecode) { | |
| fprintf(outf, "#endif /*Pascal*/\n\n"); | |
| showingsourcecode = 0; | |
| } | |
| } | |
| int line_start() | |
| { | |
| return (outbufcount == 0); | |
| } | |
| int cur_column() | |
| { | |
| if (outbufpos == 0) | |
| return outindent; | |
| else | |
| return thisindent + outbufcount; | |
| } | |
| int lookback(n) | |
| int n; | |
| { | |
| if (n <= 0 || n > outbufpos) | |
| return 0; | |
| else | |
| return outbuf[outbufpos - n]; | |
| } | |
| int lookback_prn(n) | |
| int n; | |
| { | |
| for (;;) { | |
| if (n <= 0 || n > outbufpos) | |
| return 0; | |
| else if (outbuf[outbufpos - n] >= ' ') | |
| return outbuf[outbufpos - n]; | |
| else | |
| n++; | |
| } | |
| } | |
| /* Combine two indentation adjustments */ | |
| int adddeltas(d1, d2) | |
| int d1, d2; | |
| { | |
| if (d2 >= 1000) | |
| return d2; | |
| else | |
| return d1 + d2; | |
| } | |
| /* Apply an indentation delta */ | |
| int applydelta(i, d) | |
| int i, d; | |
| { | |
| if (d >= 1000) | |
| return d - 1000; | |
| else | |
| return i + d; | |
| } | |
| /* Adjust the current indentation by delta */ | |
| void moreindent(delta) | |
| int delta; | |
| { | |
| outindent = applydelta(outindent, delta); | |
| } | |
| /* Adjust indentation for just this line */ | |
| void singleindent(delta) | |
| int delta; | |
| { | |
| deltaindent = adddeltas(deltaindent, delta); | |
| } | |
| /* Predict indentation for next line */ | |
| void futureindent(num) | |
| int num; | |
| { | |
| thisfutureindent = applydelta(applydelta(outindent, deltaindent), num); | |
| } | |
| int parsedelta(cp, def) | |
| char *cp; | |
| int def; | |
| { | |
| if (!cp || !*cp) | |
| return def; | |
| if ((*cp == '+' || *cp == '-') && isdigit(cp[1])) | |
| return atoi(cp); | |
| if (*cp == '*' && isdigit(cp[1])) | |
| return 2000 + atoi(cp+1); | |
| else | |
| return 1000 + atoi(cp); | |
| } | |
| Static void leading_tab(col) | |
| int col; | |
| { | |
| if (col > maxlinewidth) | |
| return; /* something wrong happened! */ | |
| if (phystabsize > 0) { | |
| while (col >= phystabsize) { | |
| putc('\t', outf); | |
| col -= phystabsize; | |
| } | |
| } | |
| while (col > 0) { | |
| putc(' ', outf); | |
| col--; | |
| } | |
| } | |
| void eatblanklines() | |
| { | |
| eatblanks = 1; | |
| } | |
| Static void flush_outbuf(numbreaks, breakpos, breakindent, | |
| numedits, editpos, editold, editnew) | |
| int numbreaks, *breakpos, *breakindent, numedits, *editpos; | |
| char *editold, *editnew; | |
| { | |
| unsigned char ch, ch2; | |
| char *cp; | |
| int i, j, linelen = 0, spaces, hashline; | |
| int editsaves[MAXEDITS]; | |
| end_source(); | |
| if (outbufcount > 0) { | |
| for (i = 0; i < numedits; i++) { | |
| editsaves[i] = outbuf[editpos[i]]; | |
| outbuf[editpos[i]] = editnew[i]; | |
| } | |
| leading_tab(thisindent); | |
| cp = outbuf; | |
| hashline = (*cp == '#'); /* a preprocessor directive */ | |
| spaces = 0; | |
| j = 1; | |
| for (i = 0; i < outbufpos; ) { | |
| if (j < numbreaks && i == breakpos[j]) { | |
| if (hashline) | |
| fprintf(outf, " \\"); /* trailing backslash required */ | |
| putc('\n', outf); | |
| outf_lnum++; | |
| leading_tab(breakindent[j]); | |
| linelen = breakindent[j]; | |
| j++; | |
| while (i < outbufpos && *cp == ' ') | |
| i++, cp++; /* eat leading spaces */ | |
| spaces = 0; /* eat trailing spaces */ | |
| } else { | |
| ch = *cp++; | |
| if (ch == ' ') { | |
| spaces++; | |
| } else if (ch > ' ') { | |
| linelen += spaces; | |
| while (spaces > 0) | |
| putc(' ', outf), spaces--; | |
| linelen++; | |
| if (ch == '\\' && embeddedcode) { | |
| if (*cp == '[') { | |
| putc('{', outf); | |
| cp++, i++; | |
| } else if (*cp == ']') { | |
| putc('}', outf); | |
| cp++, i++; | |
| } else | |
| putc(ch, outf); | |
| } else | |
| putc(ch, outf); | |
| } else if (testinglinebreaker >= 3) { | |
| linelen += spaces; | |
| while (spaces > 0) | |
| putc(' ', outf), spaces--; | |
| linelen++; | |
| putc('\\', outf); | |
| ch2 = spchars[ch]; | |
| if (ch2 != '.') | |
| putc(ch2, outf); | |
| else { | |
| putc('0' + ((ch >> 6) & 7), outf); | |
| putc('0' + ((ch >> 3) & 7), outf); | |
| putc('0' + (ch & 7), outf); | |
| } | |
| } | |
| i++; | |
| } | |
| } | |
| for (i = 0; i < numedits; i++) | |
| outbuf[editpos[i]] = editsaves[i]; | |
| eatblanks = 0; | |
| } else if (eatblanks) { | |
| return; | |
| } | |
| if (suppressnewline) { | |
| lastlinelength = linelen; | |
| } else | |
| putc('\n', outf); | |
| outf_lnum++; | |
| } | |
| #define ISQUOTE(ch) ((ch)=='"' || (ch)=='\'') | |
| #define ISOPENP(ch) ((ch)=='(' || (ch)=='[' || (ch)=='\003' || (ch)=='\010') | |
| #define ISCLOSEP(ch) ((ch)==')' || (ch)==']' || (ch)=='\004') | |
| #define ISBREAK(ch) ((ch)=='\001' || (ch)=='\002' || (ch)=='\006' || (ch)=='\011' || (ch)=='\017') | |
| Static int readquotes(posp, err) | |
| int *posp, err; | |
| { | |
| int pos; | |
| char quote; | |
| pos = *posp; | |
| quote = outbuf[pos++]; | |
| while (pos < outbufpos && outbuf[pos] != quote) { | |
| if (outbuf[pos] == '\\') | |
| pos++; | |
| pos++; | |
| } | |
| if (pos >= outbufpos) { | |
| if (err && breakerrorflag) { | |
| intwarning("output", "Mismatched quotes [248]"); | |
| breakerrorflag = 0; | |
| } | |
| return 0; | |
| } else { | |
| *posp = pos; | |
| return 1; | |
| } | |
| } | |
| Static int maxdepth; | |
| Static int readparens(posp, err) | |
| int *posp, err; | |
| { | |
| char ch, closing; | |
| int pos, level; | |
| pos = *posp; | |
| switch (outbuf[pos]) { | |
| case '(': | |
| closing = ')'; | |
| break; | |
| case '[': | |
| closing = ']'; | |
| break; | |
| case '\003': | |
| case '\010': | |
| closing = '\004'; | |
| break; | |
| default: | |
| closing = 0; | |
| break; | |
| } | |
| level = 0; | |
| for (;;) { | |
| pos++; | |
| if (pos >= outbufpos) | |
| break; | |
| ch = outbuf[pos]; | |
| if (ISOPENP(ch)) { | |
| level++; | |
| if (level > maxdepth) | |
| maxdepth = level; | |
| } else if (ISCLOSEP(ch)) { | |
| level--; | |
| if (level < 0) { | |
| if (closing && outbuf[pos] != closing) | |
| break; | |
| *posp = pos; | |
| return 1; | |
| } | |
| } else if (ISQUOTE(ch)) { | |
| if (!readquotes(&pos, err)) | |
| return 0; | |
| } | |
| } | |
| if (err && breakerrorflag) { | |
| switch (closing) { | |
| case ')': | |
| intwarning("output", "Mismatched parentheses [249]"); | |
| break; | |
| case ']': | |
| intwarning("output", "Mismatched brackets [249]"); | |
| break; | |
| default: | |
| intwarning("output", "Mismatched clauses [250]"); | |
| break; | |
| } | |
| breakerrorflag = 0; | |
| } | |
| return 0; | |
| } | |
| Static int measurechars(first, last) | |
| int first, last; | |
| { | |
| int count = 0; | |
| while (first <= last) { | |
| if (outbuf[first] >= ' ') | |
| count++; | |
| first++; | |
| } | |
| return count; | |
| } | |
| Static void makeedit(pos, ch) | |
| int pos, ch; | |
| { | |
| editpos[numedits] = pos; | |
| editold[numedits] = outbuf[pos]; | |
| editnew[numedits] = ch; | |
| outbuf[pos] = ch; | |
| numedits++; | |
| } | |
| Static void unedit() | |
| { | |
| numedits--; | |
| outbuf[editpos[numedits]] = editold[numedits]; | |
| } | |
| Static int parencount(par) | |
| Paren *par; | |
| { | |
| int count = 0; | |
| while (par) { | |
| count++; | |
| par = par->next; | |
| } | |
| return count; | |
| } | |
| /* The following routine explores the tree of all possible line breaks, | |
| pruning according to the fact that "badness" and "extra" are | |
| increasing functions. The object is to find the set of breaks and | |
| indentation with the least total badness. | |
| (The basic idea was borrowed from Donald Knuth's "TeX".) | |
| */ | |
| /* As an additional optimization, the concept of a "simple" line is used, | |
| i.e., a line with a structure such that the best break is sure to be | |
| the straightforward left-to-right fill used by a simple word processor. | |
| (For example, a long line with nothing but comma-breakpoints is simple.) | |
| Also, if the line is very long a few initial random passes are made just | |
| to scope out an estimate of the eventual badness of the line. This | |
| combined with the badness cull helps keep the breaker from using up its | |
| quota of tries before even considering a key break point! Note that | |
| when randombreaks==1, each call to trybreakline is fast since only one | |
| branch is taken at each decision point. | |
| */ | |
| #define randtest(lim) (!randombreaks ? -1 \ | |
| : randombreaks > 0 \ | |
| ? parencount(parens) < randombreaks-1 \ | |
| : randombreaks == -2 \ | |
| ? 0 \ | |
| : (rand() & 0xfff) < (lim)) | |
| #define TB_BRKCOUNT 0x0ff | |
| #define TB_FORCEBRK 0x100 | |
| #define TB_NOBREAK 0x200 | |
| #define TB_ALREADYBRK 0x400 | |
| #define TB_ALLORNONE 0x800 | |
| #define TB_EXTRAIND 0x1000 | |
| #define TB_EXTRAIND2 0x2000 | |
| #define TBR_ABORT 0x1 | |
| #define TBR_SIMPLE 0x2 | |
| #define TBR_REACHED 0x4 | |
| Static int trybreakline(pos, count, indent, badness, flags, parens) | |
| int pos, count, indent, flags; | |
| double badness; | |
| Paren *parens; | |
| { | |
| int edited; | |
| int i, j, jmask, f, pos2, r; | |
| char ch, ch2, closing; | |
| double extra, penalty; | |
| Paren *pp; | |
| #if 0 | |
| { static double save = -1; | |
| if (showbadlimit != save) printf("Showbadlimit = %g\n", showbadlimit); | |
| save = showbadlimit; | |
| } | |
| #endif | |
| if (numalts >= maxalts) | |
| return TBR_ABORT; | |
| jmask = -1; | |
| for (;;) { | |
| if (numbreaks >= MAXBREAKS) { /* must leave rest of line alone */ | |
| count += measurechars(pos, outbufpos-1); | |
| pos = outbufpos; | |
| } | |
| i = count - breakcount[numbreaks-1] + | |
| breakindent[numbreaks-1] - linewidth; | |
| if (i <= 0) | |
| extra = 0; | |
| else { | |
| if (i + linewidth >= maxlinewidth || randombreaks == -2) | |
| return 0; /* absolutely too long! */ | |
| extra = overwidepenalty + ((long)i*i)*overwideextrapenalty; | |
| jmask &= ~TBR_SIMPLE; | |
| if (extra < 0) | |
| extra = 0; | |
| } | |
| if ((testinglinebreaker > 1 && showbadlimit > 0) ? | |
| (badness + extra >= showbadlimit) : | |
| (badness + extra >= bestbadness)) { | |
| numalts++; | |
| return 0; /* no point in going on, badness will only increase */ | |
| } | |
| if (pos >= outbufpos) | |
| break; | |
| if (parens && pos >= parens->pos) { | |
| indent = parens->indent; | |
| flags = parens->flags; | |
| parens = parens->next; | |
| } | |
| ch = outbuf[pos++]; | |
| if (ch >= ' ') | |
| count++; | |
| switch (ch) { | |
| case '(': | |
| case '[': | |
| case '\003': /* "invisible open paren" */ | |
| case '\010': /* "semi-invisible open paren" */ | |
| pos2 = pos - 1; | |
| if (!readparens(&pos2, 1)) | |
| break; | |
| i = measurechars(pos, pos2); | |
| if (count + i - breakcount[numbreaks-1] + | |
| breakindent[numbreaks-1] <= linewidth) { | |
| /* it fits, so leave it on one line */ | |
| #if 0 /* I don't think this is necessary */ | |
| while (pos <= pos2) { | |
| if (outbuf[pos] == '\002') { | |
| jmask &= ~TBR_SIMPLE; | |
| pos = pos2 + 1; | |
| break; | |
| } | |
| pos++; | |
| } | |
| #else | |
| pos = pos2 + 1; | |
| #endif | |
| count += i; | |
| break; | |
| } | |
| pp = ALLOC(1, Paren, parens); /* doesn't fit, try poss breaks */ | |
| pp->next = parens; | |
| pp->pos = pos2; | |
| pp->indent = indent; | |
| pp->qmindent = indent; | |
| pp->flags = flags; | |
| parens = pp; | |
| flags = 0; | |
| if (ch == '\010' && /* change to real parens when broken */ | |
| numedits+1 < MAXEDITS) { /* (assume it will be broken!) */ | |
| makeedit(pos-1, '('); | |
| makeedit(pos2, ')'); | |
| count++; /* count the new open paren */ | |
| edited = 1; | |
| } else | |
| edited = 0; | |
| i = breakindent[numbreaks-1] + count - breakcount[numbreaks-1]; | |
| if (i <= thisindent) | |
| r = 0; /* e.g., don't break top-level assignments */ | |
| else if (i == indent + extraindent) | |
| r = 1; /* don't waste time on identical operations */ | |
| else | |
| r = randtest(0xc00); | |
| if (r != 0) { | |
| j = trybreakline(pos, count, i, | |
| badness + MAX(- extraindentpenalty,0), | |
| flags, parens); | |
| } else | |
| j = 0; | |
| if (r != 1) { | |
| j &= trybreakline(pos, count, indent + extraindent, | |
| badness + MAX(extraindentpenalty,0), | |
| flags | TB_EXTRAIND, parens); | |
| } | |
| if (!randombreaks && bumpindent != 0) { | |
| if (i == thisfutureindent) { | |
| j &= trybreakline(pos, count, i + bumpindent, | |
| badness + MAX(- extraindentpenalty,0) | |
| + bumpindentpenalty, | |
| flags, parens); | |
| } else if (indent + extraindent == thisfutureindent) { | |
| j &= trybreakline(pos, count, | |
| indent + extraindent + bumpindent, | |
| badness + MAX(extraindentpenalty,0) | |
| + bumpindentpenalty, | |
| flags | TB_EXTRAIND, parens); | |
| } | |
| } | |
| if (edited) { | |
| unedit(); | |
| unedit(); | |
| } | |
| FREE(pp); | |
| return j & jmask; | |
| case '\005': /* "set left margin" */ | |
| indent = breakindent[numbreaks-1] + | |
| count - breakcount[numbreaks-1]; | |
| break; | |
| case '\007': /* "all-or-none breaking" */ | |
| flags |= TB_ALLORNONE; | |
| break; | |
| case '\001': /* "possible break point" */ | |
| case '\002': /* "break point in parens" */ | |
| case '\006': /* "forced break point" */ | |
| case '\011': /* "break point after special args" */ | |
| case '\017': /* "break point for final : operator" */ | |
| /* first try the non-breaking case */ | |
| if (ch != '\001' && ch != '\006') | |
| jmask &= ~TBR_SIMPLE; | |
| if ((flags & TB_BRKCOUNT) != TB_BRKCOUNT) | |
| flags++; /* increment TB_BRKCOUNT field */ | |
| if (outbuf[pos] == '?' && parens) | |
| parens->qmindent = breakindent[numbreaks-1] + | |
| count - breakcount[numbreaks-1]; | |
| j = TBR_REACHED; | |
| if (ch == '\006' || (flags & TB_FORCEBRK)) { | |
| /* don't try the non-breaking case */ | |
| } else { | |
| if (ch == '\011') { | |
| i = breakindent[numbreaks-1] + | |
| count - breakcount[numbreaks-1] + 2; | |
| } else { | |
| i = indent; | |
| } | |
| f = flags; | |
| if (f & TB_ALLORNONE) | |
| f |= TB_NOBREAK; | |
| r = randtest(0x800); | |
| if (r != 1 || (flags & TB_NOBREAK)) { | |
| j = trybreakline(pos, count, i, badness, f, parens) & | |
| jmask; | |
| if (randombreaks == -2 && !(j & TBR_REACHED)) { | |
| r = -1; | |
| j |= TBR_REACHED; | |
| } | |
| if (r == 0 || (j & TBR_SIMPLE)) | |
| flags |= TB_NOBREAK; | |
| } | |
| } | |
| if (flags & TB_NOBREAK) | |
| return j; | |
| if (flags & TB_ALLORNONE) | |
| flags |= TB_FORCEBRK; | |
| if (flags & TB_EXTRAIND) { | |
| flags &= ~TB_EXTRAIND; | |
| flags |= TB_EXTRAIND2; | |
| } | |
| /* now try breaking here */ | |
| if (ch == '\017') | |
| indent = parens->qmindent; | |
| if (indent < 0) | |
| indent = 0; | |
| breakpos[numbreaks] = pos; | |
| breakcount[numbreaks] = count; | |
| breakindent[numbreaks] = indent; | |
| breakparen[numbreaks] = parens ? parens->pos : 0; | |
| numbreaks++; | |
| penalty = extra; | |
| if (indent == thisfutureindent) { | |
| i = pos; | |
| while (i < outbufpos-1 && outbuf[i] <= ' ') | |
| i++; | |
| ch2 = outbuf[i]; /* first character on next line */ | |
| if (ch2 != '(' && ch2 != '!' && ch2 != '~' && ch2 != '-') | |
| penalty += nobumpindentpenalty; | |
| } | |
| switch (ch) { | |
| case '\001': | |
| penalty += commabreakpenalty; | |
| if (flags & TB_ALREADYBRK) | |
| penalty += morebreakpenalty; | |
| break; | |
| case '\011': | |
| i = parencount(parens); | |
| penalty += specialargbreakpenalty + commabreakextrapenalty*i; | |
| break; | |
| case '\002': | |
| case '\017': | |
| i = parencount(parens); | |
| if (outbuf[pos-2] == '(') | |
| penalty += parenbreakpenalty + parenbreakextrapenalty*i; | |
| else if (outbuf[pos-2] == ',') | |
| penalty += commabreakpenalty + commabreakextrapenalty*i; | |
| else if (((outbuf[pos] == '&' || outbuf[pos] == '|') && | |
| outbuf[pos+1] == outbuf[pos]) || | |
| ((outbuf[pos-3] == '&' || outbuf[pos-3] == '|') && | |
| outbuf[pos-3] == outbuf[pos-2])) | |
| penalty += logbreakpenalty + logbreakextrapenalty*i; | |
| else if (((outbuf[pos] == '<' || outbuf[pos] == '>') && | |
| outbuf[pos+1] != outbuf[pos]) || | |
| ((outbuf[pos] == '=' || outbuf[pos] == '!') && | |
| outbuf[pos+1] == '=') || | |
| ((outbuf[pos-2] == '<' || outbuf[pos-2] == '>') && | |
| outbuf[pos-3] != outbuf[pos-2]) || | |
| ((outbuf[pos-3] == '<' || outbuf[pos-3] == '>' || | |
| outbuf[pos-3] == '=' || outbuf[pos-3] == '!') && | |
| outbuf[pos-2] == '=')) | |
| penalty += relbreakpenalty + relbreakextrapenalty*i; | |
| else if (outbuf[pos-2] == '=') | |
| penalty += assignbreakpenalty + assignbreakextrapenalty*i; | |
| else if (outbuf[pos] == '?') { | |
| penalty += qmarkbreakpenalty + qmarkbreakextrapenalty*i; | |
| if (parens) | |
| parens->qmindent = breakindent[numbreaks-1] + | |
| count - breakcount[numbreaks-1]; | |
| } else | |
| penalty += opbreakpenalty + opbreakextrapenalty*i; | |
| if (outbuf[pos-2] == '-') | |
| penalty += exhyphenpenalty; | |
| if (flags & TB_ALREADYBRK) | |
| penalty += morebreakpenalty + morebreakextrapenalty*i; | |
| break; | |
| default: | |
| break; | |
| } | |
| while (pos < outbufpos && outbuf[pos] == '\013') { | |
| penalty += wrongsidepenalty; | |
| pos++; | |
| } | |
| penalty -= earlybreakpenalty*(flags & TB_BRKCOUNT); | |
| /* the following test is not quite right, but it's not too bad. */ | |
| if (breakindent[numbreaks-2] == breakindent[numbreaks-1] && | |
| breakparen[numbreaks-2] != breakparen[numbreaks-1]) | |
| penalty += sameindentpenalty; | |
| #if 0 | |
| else if (ch == '\002' && parens && /*don't think this is needed*/ | |
| parens->indent == breakindent[numbreaks-1] && | |
| parens->pos != breakparen[numbreaks-1]) | |
| penalty += sameindentpenalty + 0.001; /***/ | |
| #endif | |
| penalty += (breakindent[numbreaks-1] - thisindent) * | |
| indentamountpenalty; | |
| if (penalty < 1) penalty = 1; | |
| pos2 = pos; | |
| while (pos2 < outbufpos && outbuf[pos2] == ' ') | |
| pos2++; | |
| flags |= TB_ALREADYBRK; | |
| j = trybreakline(pos2, count, indent, badness + penalty, | |
| flags, parens) & jmask; | |
| numbreaks--; | |
| return j; | |
| case '\015': /* "hang-indent operator" */ | |
| if (count <= breakcount[numbreaks-1] + 2 && | |
| !(flags & TB_EXTRAIND2)) { | |
| breakindent[numbreaks-1] -= count - breakcount[numbreaks-1]; | |
| pos2 = pos; | |
| while (pos2 < outbufpos && outbuf[pos2] <= ' ') { | |
| if (outbuf[pos2] == ' ') | |
| breakindent[numbreaks-1]--; | |
| pos2++; | |
| } | |
| } | |
| break; | |
| case '"': | |
| case '\'': | |
| closing = ch; | |
| while (pos < outbufpos && outbuf[pos] != closing) { | |
| if (outbuf[pos] == '\\') | |
| pos++, count++; | |
| pos++; | |
| count++; | |
| } | |
| if (pos >= outbufpos) { | |
| intwarning("output", "Mismatched quotes [248]"); | |
| continue; | |
| } | |
| pos++; | |
| count++; | |
| break; | |
| case '/': | |
| if (pos < outbufpos && (outbuf[pos] == '*' || | |
| (outbuf[pos] == '/' && cplus > 0))) { | |
| count += measurechars(pos, outbufpos-1); | |
| pos = outbufpos; /* assume comment is at end of line */ | |
| } | |
| break; | |
| } | |
| } | |
| numalts++; | |
| badness += extra; | |
| if (testinglinebreaker > 1) { | |
| if (badness >= bestbadness && | |
| (badness < showbadlimit || showbadlimit == 0)) { | |
| fprintf(outf, "\n#if 0 /* rejected #%ld, badness = %g >= %g */\n", numalts, badness, bestbadness); | |
| flush_outbuf(numbreaks, breakpos, breakindent, | |
| numedits, editpos, editold, editnew); | |
| fprintf(outf, "#endif\n"); | |
| return TBR_SIMPLE & jmask; | |
| } else if ((bestbadness < showbadlimit || showbadlimit == 0) && | |
| bestnumalts > 0) { | |
| fprintf(outf, "\n#if 0 /* rejected #%ld, badness = %g > %g */\n", bestnumalts, bestbadness, badness); | |
| flush_outbuf(bestnumbreaks, bestbreakpos, bestbreakindent, | |
| bestnumedits, besteditpos, | |
| besteditold, besteditnew); | |
| fprintf(outf, "#endif\n"); | |
| } | |
| } | |
| bestbadness = badness; | |
| bestnumbreaks = numbreaks; | |
| bestnumalts = numalts; | |
| for (i = 0; i < numbreaks; i++) { | |
| bestbreakpos[i] = breakpos[i]; | |
| bestbreakindent[i] = breakindent[i]; | |
| } | |
| bestnumedits = numedits; | |
| for (i = 0; i < numedits; i++) { | |
| besteditpos[i] = editpos[i]; | |
| besteditold[i] = editold[i]; | |
| besteditnew[i] = editnew[i]; | |
| } | |
| return TBR_SIMPLE & jmask; | |
| } | |
| int parse_breakstr(cp) | |
| char *cp; | |
| { | |
| short val = 0; | |
| if (isdigit(*cp)) | |
| return atoi(cp); | |
| while (*cp && !isspace(*cp) && *cp != '}') { | |
| switch (toupper(*cp++)) { | |
| case 'N': | |
| case '=': | |
| break; | |
| case 'L': | |
| val |= BRK_LEFT; | |
| break; | |
| case 'R': | |
| val |= BRK_RIGHT; | |
| break; | |
| case 'H': | |
| val |= BRK_HANG | BRK_LEFT; | |
| break; | |
| case '>': | |
| if (val & BRK_LEFT) | |
| val |= BRK_LPREF; | |
| else if (val & BRK_RIGHT) | |
| val |= BRK_RPREF; | |
| else | |
| return -1; | |
| break; | |
| case '<': | |
| if (val & BRK_LEFT) | |
| val |= BRK_RPREF; | |
| else if (val & BRK_RIGHT) | |
| val |= BRK_LPREF; | |
| else | |
| return -1; | |
| break; | |
| case 'A': | |
| val |= BRK_ALLNONE; | |
| break; | |
| default: | |
| return -1; | |
| } | |
| } | |
| return val; | |
| } | |
| long getcurtime() | |
| { | |
| #if USETIME | |
| static unsigned long starttime = 0; | |
| struct timeval t; | |
| struct timezone tz; | |
| gettimeofday(&t, &tz); | |
| if (starttime == 0) | |
| starttime = t.tv_sec; | |
| t.tv_sec -= starttime; | |
| return (t.tv_sec*1000 + t.tv_usec/1000); | |
| #else | |
| static unsigned long starttime = 0; | |
| if (!starttime) starttime = time(NULL); | |
| return (time(NULL) - starttime) * 1000; | |
| #endif | |
| } | |
| void output(msg) | |
| register char *msg; | |
| { | |
| unsigned char ch; | |
| double savelimit; | |
| int i, savemaxlw, maxdp; | |
| long alts; | |
| long time0, time0a, time1; | |
| debughook(); | |
| if (outputmode) { | |
| end_source(); | |
| while ((ch = *msg++) != 0) { | |
| if (ch >= ' ') { | |
| putc(ch, outf); | |
| } else if (ch == '\n') { | |
| putc('\n', outf); | |
| outf_lnum++; | |
| } | |
| } | |
| return; | |
| } | |
| while ((ch = *msg++) != 0) { | |
| if (ch == '\n') { | |
| if (outbufpos == 0) { /* blank line */ | |
| thisfutureindent = -1; | |
| blanklines++; | |
| continue; | |
| } | |
| if (sectionsize > blanklines) | |
| blanklines = sectionsize; | |
| sectionsize = 0; | |
| if (eatblanks) | |
| blanklines = 0; | |
| while (blanklines > 0) { | |
| blanklines--; | |
| end_source(); | |
| putc('\n', outf); | |
| outf_lnum++; | |
| } | |
| if (thisindent + outbufcount >= linewidth && !dontbreaklines) { | |
| numbreaks = 1; | |
| bestnumbreaks = 0; | |
| bestbadness = BIGBADNESS; | |
| breakpos[0] = 0; | |
| breakindent[0] = thisindent; | |
| breakcount[0] = 0; | |
| breakerrorflag = 1; | |
| numedits = 0; | |
| bestnumedits = 0; | |
| savelimit = showbadlimit; | |
| numalts = 0; | |
| bestnumalts = 0; | |
| savemaxlw = maxlinewidth; | |
| time0 = time0a = getcurtime(); | |
| if (regression) | |
| srand(17); | |
| if (thisindent + outbufcount > linewidth*3/2) { | |
| i = 0; | |
| maxdepth = 0; | |
| readparens(&i, 0); | |
| maxdp = maxdepth; | |
| for (;;) { /* try some simple fixed methods first... */ | |
| for (i = 1; i <= 20; i++) { | |
| randombreaks = -1; | |
| trybreakline(0, 0, thisindent, 0.0, 0, NULL); | |
| } | |
| randombreaks = -2; | |
| trybreakline(0, 0, thisindent, 0.0, 0, NULL); | |
| for (i = 0; i <= maxdp+1; i++) { | |
| randombreaks = i+1; | |
| trybreakline(0, 0, thisindent, 0.0, 0, NULL); | |
| } | |
| if (bestbadness == BIGBADNESS && maxlinewidth < 9999) { | |
| maxlinewidth = 9999; /* no choice but to relax */ | |
| numalts = 0; | |
| } else | |
| break; | |
| } | |
| time0a = getcurtime(); | |
| } | |
| randombreaks = 0; | |
| trybreakline(0, 0, thisindent, 0.0, 0, NULL); | |
| if (bestbadness == BIGBADNESS && maxlinewidth < 9999) { | |
| numalts = 0; | |
| maxlinewidth = 9999; /* no choice but to relax this */ | |
| trybreakline(0, 0, thisindent, 0.0, 0, NULL); | |
| } | |
| time1 = getcurtime() - time0; | |
| alts = numalts; | |
| if (testinglinebreaker) { | |
| if (savelimit < 0 && testinglinebreaker > 1) { | |
| showbadlimit = bestbadness * (-savelimit); | |
| numalts = 0; | |
| bestnumalts = 0; | |
| trybreakline(0, 0, thisindent, 0.0, 0, NULL); | |
| } | |
| fprintf(outf, "\n#if 1 /* accepted #%ld, badness = %g, tried %ld in %.3f sec */\n", bestnumalts, bestbadness, alts, time1/1000.0); | |
| } | |
| showbadlimit = savelimit; | |
| maxlinewidth = savemaxlw; | |
| flush_outbuf(bestnumbreaks, bestbreakpos, bestbreakindent, | |
| bestnumedits, besteditpos, | |
| besteditold, besteditnew); | |
| if (((USETIME && time1 > 1000) || alts >= maxalts) && | |
| !regression) { | |
| sprintf(outbuf, "Line breaker spent %.1f", | |
| (time1 + time0 - time0a) / 1000.0); | |
| if (time0 != time0a) | |
| sprintf(outbuf + strlen(outbuf), | |
| "+%.2f", (time0a - time0) / 1000.0); | |
| sprintf(outbuf + strlen(outbuf), | |
| " seconds, %ld tries on line %d [251]", alts, outf_lnum); | |
| note(outbuf); | |
| } else if (verbose) { | |
| fprintf(logf, "%s, %d/%d: Line breaker spent %ld tries\n", | |
| infname, inf_lnum, outf_lnum, alts); | |
| } | |
| if (testinglinebreaker) | |
| fprintf(outf, "#endif\n\n"); | |
| } else { | |
| if (testinglinebreaker < 2) | |
| flush_outbuf(0, NULL, NULL, 0, NULL, NULL, NULL); | |
| } | |
| thisfutureindent = -1; | |
| outbufpos = 0; | |
| outbufcount = 0; | |
| } else { | |
| if (outbufpos == 0) { | |
| if (ch == ' ' && !dontbreaklines) /* eat leading spaces */ | |
| continue; | |
| thisindent = applydelta(outindent, deltaindent); | |
| deltaindent = 0; | |
| } | |
| if (outbufpos == outbufsize) { | |
| outbufsize *= 2; | |
| outbuf = REALLOC(outbuf, outbufsize, char); | |
| } | |
| outbuf[outbufpos++] = ch; | |
| if (ch >= ' ') | |
| outbufcount++; | |
| } | |
| } | |
| } | |
| void out_n_spaces(n) | |
| int n; | |
| { | |
| while (--n >= 0) | |
| output(" "); | |
| } | |
| void out_spaces(spc, over, len, delta) | |
| int spc, over, len, delta; | |
| { | |
| int n; | |
| if (spc == -999) | |
| spc = commentindent; | |
| if (spc < 0) { /* right-justify */ | |
| n = (-spc) - cur_column() - len; | |
| if (n < minspcthresh) | |
| n = minspacing; | |
| else | |
| over = 1000; | |
| } else if (spc >= 2000) { /* tab to multiple */ | |
| spc -= 2000; | |
| n = (spc-1) - ((cur_column()+spc-1) % spc); | |
| if (n < minspcthresh) | |
| n += spc; | |
| } else if (spc >= 1000) { /* absolute column */ | |
| spc -= 1000; | |
| n = spc - cur_column(); | |
| if (n < minspcthresh) | |
| n = minspacing; | |
| } else /* relative spacing */ | |
| n = spc; | |
| if (line_start()) { | |
| singleindent(n); | |
| } else if (len > 0 && over != 1000 && cur_column() + n + len > linewidth) { | |
| output("\n"); | |
| out_spaces(over, 1000, len, 0); | |
| singleindent(delta); | |
| } else { | |
| out_n_spaces(n); | |
| } | |
| } | |
| void testlinebreaker(lev, fn) | |
| int lev; | |
| char *fn; | |
| { | |
| char buf[256], *bp, *cp; | |
| int first, indent; | |
| testinglinebreaker = lev; | |
| if (!fn) | |
| return; | |
| inf = fopen(fn, "r"); | |
| if (!inf) { | |
| perror(fn); | |
| exit(1); | |
| } | |
| sprintf(buf, "%s.br", fn); | |
| outf = fopen(buf, "w"); | |
| if (!outf) { | |
| perror(buf); | |
| exit(1); | |
| } | |
| setup_out(); | |
| outindent = 4; | |
| first = 1; | |
| while (fgets(buf, 256, inf)) { | |
| cp = buf + strlen(buf) - 2; | |
| if (cp >= buf) { | |
| bp = buf; | |
| indent = 0; | |
| while (isspace(*bp)) | |
| if (*bp++ == '\t') | |
| indent += 8; | |
| else | |
| indent++; | |
| if (first) { | |
| first = 0; | |
| outindent = indent; | |
| } | |
| if (!(*cp == '{' || | |
| *cp == ')' || | |
| *cp == ';') || | |
| (*cp == '/' && cp[-1] == '*')) { | |
| cp[1] = '\001'; /* eat the \n */ | |
| } else { | |
| first = 1; | |
| } | |
| output(bp); | |
| } | |
| } | |
| fclose(outf); | |
| fclose(inf); | |
| } | |
| void outsection(size) | |
| int size; | |
| { | |
| if (size > sectionsize) | |
| sectionsize = size; | |
| } | |
| int isembedcomment(cmt) | |
| Strlist *cmt; | |
| { | |
| int len = strlen(embedcomment); | |
| return (cmt && len > 0 && !strncmp(cmt->s, embedcomment, len) && | |
| (isspace(cmt->s[len]) || | |
| (!cmt->s[len] && cmt->next && | |
| (*cmt->next->s == '\002' || *cmt->next->s == '\003')))); | |
| } | |
| Strlist *outcomments(cmt) | |
| Strlist *cmt; | |
| { | |
| char *cp; | |
| int saveindent = outindent, savesingle = deltaindent, theindent; | |
| int saveeat = eatcomments; | |
| int i = 0; | |
| if (!cmt) | |
| return NULL; | |
| if (!commentvisible(cmt)) { | |
| setcommentkind(cmt, CMT_DONE); | |
| return cmt->next; | |
| } | |
| if (*cmt->s == '\001') { | |
| if (cmtdebug) | |
| output(format_sd("[] [%s:%d]", | |
| CMT_NAMES[getcommentkind(cmt)], | |
| cmt->value & CMT_MASK)); | |
| for (cp = cmt->s; *cp; cp++) { | |
| output("\n"); | |
| if (cmtdebug && cp[1]) | |
| output("[]"); | |
| } | |
| setcommentkind(cmt, CMT_DONE); | |
| return cmt->next; | |
| } | |
| dontbreaklines++; | |
| if (isembedcomment(cmt)) { | |
| embeddedcode = 1; | |
| eatcomments = 0; | |
| if (!strcmp(cmt->s, embedcomment)) { | |
| cmt = cmt->next; | |
| theindent = 0; | |
| cp = cmt/*->next*/->s + 1; | |
| while (*cp++ == ' ') | |
| theindent++; | |
| } else { | |
| strcpy(cmt->s, cmt->s + strlen(embedcomment) + 1); | |
| moreindent(deltaindent); | |
| theindent = outindent; | |
| deltaindent = 0; | |
| } | |
| } else { | |
| moreindent(deltaindent); | |
| if (cmt->s[0] == '\004') | |
| outindent = 0; | |
| theindent = outindent; | |
| deltaindent = 0; | |
| output("/*"); | |
| } | |
| cp = cmt->s; | |
| for (;;) { | |
| if (*cp == '\002') | |
| cp++; | |
| else if (*cp == '\003' || *cp == '\004') { | |
| outindent = 0; | |
| cp++; | |
| } | |
| if (embeddedcode) { | |
| for (i = 0; *cp == ' ' && i < theindent; i++) | |
| cp++; | |
| i = *cp; | |
| if (*cp == '#') | |
| outindent = 0; | |
| } | |
| output(cp); | |
| if (cmtdebug) | |
| output(format_sd(" [%s:%d] ", | |
| CMT_NAMES[getcommentkind(cmt)], | |
| cmt->value & CMT_MASK)); | |
| setcommentkind(cmt, CMT_DONE); | |
| cmt = cmt->next; | |
| if (!cmt || !commentvisible(cmt)) | |
| break; | |
| cp = cmt->s; | |
| if (*cp != '\002' && *cp != '\003') | |
| break; | |
| output("\n"); | |
| if (!embeddedcode) { | |
| outindent = (*cp == '\002') ? theindent : 0; | |
| deltaindent = 0; | |
| } | |
| } | |
| if (embeddedcode) { | |
| embeddedcode = 0; | |
| if (i) { /* eat final blank line */ | |
| output("\n"); | |
| } | |
| } else { | |
| output("*/\n"); | |
| } | |
| outindent = saveindent; | |
| deltaindent = savesingle; | |
| dontbreaklines--; | |
| eatcomments = saveeat; | |
| return cmt; | |
| } | |
| void outcomment(cmt) | |
| Strlist *cmt; | |
| { | |
| Strlist *savenext; | |
| if (cmt) { | |
| savenext = cmt->next; | |
| cmt->next = NULL; | |
| outcomments(cmt); | |
| cmt->next = savenext; | |
| } | |
| } | |
| void outtrailcomment(cmt, serial, indent) | |
| Strlist *cmt; | |
| int serial, indent; | |
| { | |
| int savedelta = deltaindent; | |
| #if 0 | |
| suppressnewline = 1; | |
| output("\n"); | |
| suppressnewline = 0; | |
| #endif | |
| cmt = findcomment(cmt, CMT_TRAIL, serial); | |
| if (commentvisible(cmt)) { | |
| out_spaces(indent, commentoverindent, commentlen(cmt), 0); | |
| outcomment(cmt); | |
| deltaindent = savedelta; | |
| } else | |
| output("\n"); | |
| } | |
| void flushcomments(cmt, kind, serial) | |
| Strlist **cmt; | |
| int kind, serial; | |
| { | |
| Strlist *cmt2, *cmt3; | |
| int saveindent, savesingle, saveeat; | |
| if (!cmt) | |
| cmt = &curcomments; | |
| cmt2 = extractcomment(cmt, kind, serial); | |
| saveindent = outindent; | |
| savesingle = deltaindent; | |
| moreindent(deltaindent); | |
| deltaindent = 0; | |
| saveeat = eatcomments; | |
| if (eatcomments == 2) | |
| eatcomments = 0; | |
| cmt3 = cmt2; | |
| while (cmt3) | |
| cmt3 = outcomments(cmt3); | |
| eatcomments = saveeat; | |
| outindent = saveindent; | |
| deltaindent = savesingle; | |
| strlist_empty(&cmt2); | |
| } | |
| char *rawCstring(fmt, s, len, special) | |
| char *fmt; | |
| register char *s; | |
| int len, special; | |
| { | |
| char buf[500]; | |
| register char *cp; | |
| register unsigned char ch; | |
| cp = buf; | |
| while (--len >= 0) { | |
| ch = *((unsigned char *) s); | |
| s++; | |
| if (ch == 0 && (len == 0 || !isdigit(*s))) { | |
| *cp++ = '\\'; | |
| *cp++ = '0'; | |
| } else if (ch == '\n') { | |
| *cp++ = '\\'; | |
| *cp++ = 'n'; | |
| } else if (ch == '\b') { | |
| *cp++ = '\\'; | |
| *cp++ = 'b'; | |
| } else if (ch == '\t') { | |
| *cp++ = '\\'; | |
| *cp++ = 't'; | |
| } else if (ch == '\f') { | |
| *cp++ = '\\'; | |
| *cp++ = 'f'; | |
| #if 0 | |
| } else if (ch == '\r') { | |
| *cp++ = '\\'; | |
| *cp++ = 'r'; | |
| #endif | |
| } else if (ch < ' ' || ch >= 127) { | |
| *cp++ = '\\'; | |
| *cp++ = '0' + (ch>>6); | |
| *cp++ = '0' + ((ch>>3) & 7); | |
| *cp++ = '0' + (ch & 7); | |
| } else if (ch == special) { | |
| switch (ch) { | |
| case '%': | |
| *cp++ = ch; | |
| *cp++ = ch; | |
| break; | |
| } | |
| } else { | |
| if (ch == '"' || ch == '\\') | |
| *cp++ = '\\'; | |
| *cp++ = ch; | |
| } | |
| } | |
| *cp = 0; | |
| return format_s(fmt, buf); | |
| } | |
| char *makeCstring(s, len) | |
| register char *s; | |
| int len; | |
| { | |
| return rawCstring("\"%s\"", s, len, 0); | |
| } | |
| char *makeCchar(ich) | |
| int ich; | |
| { | |
| char buf[500]; | |
| register char *cp; | |
| register unsigned char ch = (ich & 0xff); | |
| if (ich < 0 || ich > 255 || (ich == 0 && !nullcharconst)) | |
| return format_d("%d", ich); | |
| cp = buf; | |
| if (ch == 0) { | |
| *cp++ = '\\'; | |
| *cp++ = '0'; | |
| } else if (ch == '\n') { | |
| *cp++ = '\\'; | |
| *cp++ = 'n'; | |
| } else if (ch == '\b') { | |
| *cp++ = '\\'; | |
| *cp++ = 'b'; | |
| } else if (ch == '\t') { | |
| *cp++ = '\\'; | |
| *cp++ = 't'; | |
| } else if (ch == '\f') { | |
| *cp++ = '\\'; | |
| *cp++ = 'f'; | |
| #if 0 | |
| } else if (ch == '\r') { | |
| *cp++ = '\\'; | |
| *cp++ = 'r'; | |
| #endif | |
| } else if (ch < ' ' || ch >= 127) { | |
| *cp++ = '\\'; | |
| *cp++ = '0' + (ch>>6); | |
| *cp++ = '0' + ((ch>>3) & 7); | |
| *cp++ = '0' + (ch & 7); | |
| } else { | |
| if (ch == '\'' || ch == '\\') | |
| *cp++ = '\\'; | |
| *cp++ = ch; | |
| } | |
| *cp = 0; | |
| return format_s("'%s'", buf); | |
| } | |
| /* End. */ | |