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

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

编译器/解释器

开发平台：

C/C++

comment.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. */
  20. #define PROTO_COMMENT_C
  21. #include "trans.h"
  25. Static int cmttablesize;
  26. Static uchar *cmttable;
  28. Static int grabbed_comment;
  33. /* Special comment forms:
  35.    010101...      Blank line(s), one 01 char per blank line
  36.    02text...          Additional line for previous comment
  37.    03text...          Additional comment line, absolutely indented
  38.    04text... Note or warning line, unindented
  40. */
  45. void setup_comment()
  46. {
  47.     curcomments = NULL;
  48.     cmttablesize = 200;
  49.     cmttable = ALLOC(cmttablesize, uchar, misc);
  50.     grabbed_comment = 0;
  51. }
  57. int commentlen(cmt)
  58. Strlist *cmt;
  59. {
  60.     if (cmt)
  61. if (*(cmt->s))
  62.     return strlen(cmt->s) + 4;
  63. else
  64.     return 5;
  65.     else
  66. return 0;
  67. }
  70. int commentvisible(cmt)
  71. Strlist *cmt;
  72. {
  73.     return (cmt &&
  74.     getcommentkind(cmt) != CMT_DONE &&
  75.     eatcomments != 1 && eatcomments != 2);
  76. }
  83. /* If preceding statement's POST comments include blank lines,
  84.    steal all comments after longest stretch of blank lines as
  85.    PRE comments for the next statement. */
  87. void steal_comments(olds, news, always)
  88. long olds, news;
  89. int always;
  90. {
  91.     Strlist *cmt, *cmtfirst = NULL, *cmtblank = NULL;
  92.     int len, longest;
  94.     for (cmt = curcomments; cmt; cmt = cmt->next) {
  95. if ((cmt->value & CMT_MASK) == olds &&
  96.     getcommentkind(cmt) == CMT_POST) {
  97.     if (!cmtfirst)
  98. cmtfirst = cmt;
  99. } else {
  100.     cmtfirst = NULL;
  101. }
  102.     }
  103.     if (cmtfirst) {
  104. if (!always) {
  105.     longest = 0;
  106.     for (cmt = cmtfirst; cmt; cmt = cmt->next) {
  107. if (cmt->s[0] == '01') {   /* blank line(s) */
  108.     len = strlen(cmt->s);
  109.     if (len > longest) {
  110. longest = len;
  111. cmtblank = cmt;
  112.     }
  113. }
  114.     }
  115.     if (longest > 0) {
  116. if (blankafter)
  117.     cmtfirst = cmtblank->next;
  118. else
  119.     cmtfirst = cmtblank;
  120.     } else if (commentafter == 1)
  121. cmtfirst = NULL;
  122. }
  123. changecomments(cmtfirst, CMT_POST, olds, CMT_PRE, news);
  124.     }
  125. }
  129. Strlist *fixbeginendcomment(cmt)
  130. Strlist *cmt;
  131. {
  132.     char *cp, *cp2;
  134.     if (!cmt)
  135. return NULL;
  136.     cp = cmt->s;
  137.     while (isspace(*cp))
  138. cp++;
  139.     if (!strcincmp(cp, "procedure ", 10)) {    /* remove "PROCEDURE" keyword */
  140. strcpy(cp, cp+10);
  141.     } else if (!strcincmp(cp, "function ", 9)) {
  142. strcpy(cp, cp+9);
  143.     }
  144.     while (isspace(*cp))
  145. cp++;
  146.     if (!*cp)
  147. return NULL;
  148.     if (getcommentkind(cmt) == CMT_ONBEGIN) {
  149. cp2 = curctx->sym->name;
  150. while (*cp2) {
  151.     if (toupper(*cp2++) != toupper(*cp++))
  152. break;
  153. }
  154. while (isspace(*cp))
  155.     cp++;
  156. if (!*cp2 && !*cp)
  157.     return NULL;     /* eliminate function-begin comment */
  158.     }
  159.     return cmt;
  160. }
  165. Static void attach_mark(sp)
  166. Stmt *sp;
  167. {
  168.     long serial;
  170.     while (sp) {
  171. serial = sp->serial;
  172. if (serial >= 0 && serial < cmttablesize) {
  173.     cmttable[serial]++;
  174.     if (sp->kind == SK_IF && serial+1 < cmttablesize)
  175. cmttable[serial+1]++;   /* the "else" branch */
  176. }
  177. attach_mark(sp->stm1);
  178. attach_mark(sp->stm2);
  179. sp = sp->next;
  180.     }
  181. }
  185. void attach_comments(sbase)
  186. Stmt *sbase;
  187. {
  188.     Strlist *cmt;
  189.     long serial, i, j;
  190.     int kind;
  192.     if (spitorphancomments)
  193. return;
  194.     if (serialcount >= cmttablesize) {
  195. cmttablesize = serialcount + 100;
  196. cmttable = REALLOC(cmttable, cmttablesize, uchar);
  197.     }
  198.     for (i = 0; i < cmttablesize; i++)
  199. cmttable[i] = 0;
  200.     attach_mark(sbase);
  201.     for (cmt = curcomments; cmt; cmt = cmt->next) {
  202. serial = cmt->value & CMT_MASK;
  203. kind = getcommentkind(cmt);
  204. if (serial < 0 || serial >= cmttablesize || cmttable[serial])
  205.     continue;
  206. i = 0;
  207. j = 0;
  208. do {
  209.     if (commentafter == 1) {
  210. j++;
  211. if (j % 3 == 0)
  212.     i++;
  213.     } else if (commentafter == 0) {
  214. i++;
  215. if (i % 3 == 0)
  216.     j++;
  217.     } else {
  218. i++;
  219. j++;
  220.     }
  221.     if (serial+i < cmttablesize && cmttable[serial+i]) {
  222. setcommentkind(cmt, CMT_PRE);
  223. cmt->value += i;
  224. break;
  225.     }
  226.     if (serial-j > 0 && cmttable[serial-j]) {
  227. setcommentkind(cmt, CMT_POST);
  228. cmt->value -= j;
  229. break;
  230.     }
  231. } while (serial+i < cmttablesize || serial-j > 0);
  232.     }
  233. }
  238. void setcommentkind(cmt, kind)
  239. Strlist *cmt;
  240. int kind;
  241. {
  242.     cmt->value = (cmt->value & CMT_MASK) | (kind << CMT_SHIFT);
  243. }
  247. void commentline(kind)
  248. int kind;
  249. {
  250.     char *cp;
  251.     Strlist *sl;
  253.     if (grabbed_comment) {
  254. grabbed_comment = 0;
  255. return;
  256.     }
  257.     if (blockkind == TOK_IMPORT || skipping_module)
  258. return;
  259.     if (eatcomments == 1)
  260. return;
  261.     for (cp = curtokbuf; (cp = my_strchr(cp, '*')) != NULL; ) {
  262. if (*++cp == '/') {
  263.     cp[-1] = '%';
  264.     note("Changed "* /" to "% /" in comment [140]");
  265. }
  266.     }
  267.     sl = strlist_append(&curcomments, curtokbuf);
  268.     sl->value = curserial;
  269.     setcommentkind(sl, kind);
  270. }
  274. void addnote(msg, serial)
  275. char *msg;
  276. long serial;
  277. {
  278.     int len1, len2, xextra, extra;
  279.     int defer = (notephase > 0 && spitcomments == 0);
  280.     Strlist *sl, *base = NULL, **pbase = (defer) ? &curcomments : &base;
  281.     char *prefix;
  283.     if (defer && (outf != stdout || !quietmode))
  284. printf("%s, line %d: %sn", infname, inf_lnum, msg);
  285.     else if (outf != stdout)
  286. printf("%s, line %d/%d: %sn", infname, inf_lnum, outf_lnum, msg);
  287.     if (verbose)
  288. fprintf(logf, "%s, %d/%d: %sn", infname, inf_lnum, outf_lnum, msg);
  289.     if (notephase == 2 || regression)
  290. prefix = format_s("04 p2c: %s:", infname);
  291.     else
  292. prefix = format_sd("04 p2c: %s, line %d:", infname, inf_lnum);
  293.     len1 = strlen(prefix);
  294.     len2 = strlen(msg) + 2;
  295.     if (len1 + len2 < linewidth-4) {
  296. msg = format_ss("%s %s ", prefix, msg);
  297.     } else {
  298. extra = xextra = 0;
  299. while (len2 - extra > linewidth-6) {
  300.     while (extra < len2 && !isspace(msg[extra]))
  301. extra++;
  302.     xextra = extra;
  303.     while (extra < len2 && isspace(msg[extra]))
  304. extra++;
  305. }
  306. prefix = format_sds("%s %.*s", prefix, xextra, msg);
  307. msg += extra;
  308. sl = strlist_append(pbase, prefix);
  309. sl->value = serial;
  310. setcommentkind(sl, CMT_POST);
  311. msg = format_s("03 * %s ", msg);
  312.     }
  313.     sl = strlist_append(pbase, msg);
  314.     sl->value = serial;
  315.     setcommentkind(sl, CMT_POST);
  316.     outputmode++;
  317.     outcomments(base);
  318.     outputmode--;
  319. }
  325. /* Grab a comment off the end of the current line */
  326. Strlist *grabcomment(kind)
  327. int kind;
  328. {
  329.     char *cp, *cp2;
  330.     Strlist *cmt, *savecmt;
  332.     if (grabbed_comment || spitcomments == 1)
  333. return NULL;
  334.     cp = inbufptr;
  335.     while (isspace(*cp))
  336. cp++;
  337.     if (*cp == ';' || *cp == ',' || *cp == '.')
  338. cp++;
  339.     while (isspace(*cp))
  340. cp++;
  341.     cp2 = curtokbuf;
  342.     if (*cp == '{') {
  343. cp++;
  344. while (*cp && *cp != '}')
  345.     *cp2++ = *cp++;
  346. if (!*cp)
  347.     return NULL;
  348. cp++;
  349.     } else if (*cp == '(' && cp[1] == '*') {
  350. cp += 2;
  351. while (*cp && (*cp != '*' || cp[1] != ')'))
  352.     *cp2++ = *cp++;
  353. if (!*cp)
  354.     return NULL;
  355. cp += 2;
  356.     } else
  357. return NULL;
  358.     while (isspace(*cp))
  359. cp++;
  360.     if (*cp)
  361. return NULL;
  362.     *cp2 = 0;
  363.     savecmt = curcomments;
  364.     curcomments = NULL;
  365.     commentline(kind);
  366.     cmt = curcomments;
  367.     curcomments = savecmt;
  368.     grabbed_comment = 1;
  369.     if (cmtdebug > 1)
  370. fprintf(outf, "Grabbed comment [%d] "%s"n", cmt->value & CMT_MASK, cmt->s);
  371.     return cmt;
  372. }
  376. int matchcomment(cmt, kind, stamp)
  377. Strlist *cmt;
  378. int kind, stamp;
  379. {
  380.     if (spitcomments == 1 && (cmt->value & CMT_MASK) != 10000 &&
  381. *cmt->s != '01' && (kind >= 0 || stamp >= 0))
  382. return 0;
  383.     if (!cmt || getcommentkind(cmt) == CMT_DONE)
  384. return 0;
  385.     if (stamp >= 0 && (cmt->value & CMT_MASK) != stamp)
  386. return 0;
  387.     if (kind >= 0) {
  388. if (kind & CMT_NOT) {
  389.     if (getcommentkind(cmt) == kind - CMT_NOT)
  390. return 0;
  391. } else {
  392.     if (getcommentkind(cmt) != kind)
  393. return 0;
  394. }
  395.     }
  396.     return 1;
  397. }
  401. Strlist *findcomment(cmt, kind, stamp)
  402. Strlist *cmt;
  403. int kind, stamp;
  404. {
  405.     while (cmt && !matchcomment(cmt, kind, stamp))
  406. cmt = cmt->next;
  407.     if (cmt && cmtdebug > 1)
  408. fprintf(outf, "Found comment [%d] "%s"n", cmt->value & CMT_MASK, cmt->s);
  409.     return cmt;
  410. }
  414. Strlist *extractcomment(cmt, kind, stamp)
  415. Strlist **cmt;
  416. int kind, stamp;
  417. {
  418.     Strlist *base, **last, *sl;
  420.     last = &base;
  421.     while ((sl = *cmt)) {
  422. if (matchcomment(sl, kind, stamp)) {
  423.     if (cmtdebug > 1)
  424. fprintf(outf, "Extracted comment [%d] "%s"n",
  425.         sl->value & CMT_MASK, sl->s);
  426.     *cmt = sl->next;
  427.     *last = sl;
  428.     last = &sl->next;
  429. } else
  430.     cmt = &sl->next;
  431.     }
  432.     *last = NULL;
  433.     return base;
  434. }
  437. void changecomments(cmt, okind, ostamp, kind, stamp)
  438. Strlist *cmt;
  439. int okind, ostamp, kind, stamp;
  440. {
  441.     while (cmt) {
  442. if (matchcomment(cmt, okind, ostamp)) {
  443.     if (cmtdebug > 1)
  444. fprintf(outf, "Changed comment [%s:%d] "%s" ",
  445. CMT_NAMES[getcommentkind(cmt)],
  446. cmt->value & CMT_MASK, cmt->s);
  447.     if (kind >= 0)
  448. setcommentkind(cmt, kind);
  449.     if (stamp >= 0)
  450. cmt->value = (cmt->value & ~CMT_MASK) | stamp;
  451.     if (cmtdebug > 1)
  452. fprintf(outf, " to [%s:%d]n",
  453. CMT_NAMES[getcommentkind(cmt)], cmt->value & CMT_MASK);
  454. }
  455. cmt = cmt->next;
  456.     }
  457. }
  464. /* End. */