Quick Search:

Mode

Context

Displaying 3 lines of context. None | Less | More | Full

Other Diffs

Ignore

Blank Lines Whitespace: Expand:

Diff

1.36
 
1.37
 
MAIN:ragge:20061007091725
 
cpp.c
_>6666  * from V7 cpp, and at last ansi/c99 support.
 6767  */
 6868 
<>69 -/*
 70 - * Arbetsgång:
 71 - *      1) Skriv om så att det finns en input() som förprocessar streamen.
 72 - *      2) Skriv om så att makros går framifrån, inte bakifrån.
 73 - *      3) Skriv om så att man använder lex, inte manuellt.
 74 - */
 75 -
7669 #include "../../config.h"
 7770 
 7871 #include <sys/wait.h>
     
 !
110103 #define DDPRINT(x)
 111104 #endif
 112105 
<>113 -FILE *obuf;
 114 -static int exfail;
  106+static int ofd;
115107 struct symtab symtab[SYMSIZ];
<> 108+static usch outbuf[CPPBUF];
  109+static int obufp, istty;
116110 int Cflag;
 117111 
 118112 /* avoid recursion */
     
 !
147141  *
 148142  * The first character (from the end) in the replacement list is
 149143  * the number of arguments:
<> 144+ *   VARG  - ends with ellipsis, next char is argcount without ellips.
150145  *   OBJCT - object-type macro
 151146  *   0     - empty parenthesis, foo()
 152147  *   1->   - number of args.
 153148  */
 154149 
<> 150+#define VARG    0xfe    /* has varargs */
155151 #define OBJCT   0xff
 156152 #define WARN    1       /* SOH, not legal char */
 157153 #define CONC    2       /* STX, not legal char */
     
 !
169165 static int canexpand(struct recur *, struct symtab *np);
 170166 void include(void);
 171167 void line(void);
<> 168+void flbuf(void);
  169+void usage(void);
172170 
 173171 int
 174172 main(int argc, char **argv)
     
 !
230228                         tflag = 1;
 231229                         break;
 232230 
<> 231+                case '?':
  232+                        usage();
233233                 default:
<>234 -                        fprintf(stderr, "bad arg %c\n", ch);
 235 -                        exit(1);
  234+                        error("bad arg %c\n", ch);
236235                 }
 237236         argc -= optind;
 238237         argv += optind;
 239238 
<>240 -        exfail = 0;
 241 -
242239         filloc = lookup("__FILE__", ENTER);
 243240         linloc = lookup("__LINE__", ENTER);
 244241         filloc->value = linloc->value = ""; /* Just something */
     
 !
266263         }
 267264 
 268265         if (argc == 2) {
<>269 -                if ((obuf = fopen(argv[1], "w")) == 0) {
 270 -                        fprintf(stderr, "Can't creat %s\n", argv[1]);
 271 -                        exit(8);
 272 -                }
  266+                if ((ofd = open(argv[1], O_WRONLY|O_CREAT, 0600)) < 0)
  267+                        error("Can't creat %s", argv[1]);
273268         } else
<>274 -                obuf = stdout;
  269+                ofd = 1; /* stdout */
  270+        istty = isatty(ofd);
275271 
 276272         if (pushfile(argc ? argv[0] : NULL))
 277273                 error("cannot open %s", argv[0]);
 278274 
<>279 -        fclose(obuf);
 280 -        return exfail;
  275+        flbuf();
  276+        close(ofd);
  277+        return 0;
281278 }
 282279 
<>283 -void
  280+/*
  281+ * Expand the symbol nl read from input.
  282+ * Return a pointer to the fully expanded result.
  283+ * It is the responsibility of the caller to reset the heap usage.
  284+ */
  285+usch *
284286 gotident(struct symtab *nl)
 285287 {
 286288         struct symtab *thisnl;
<>287 -        usch *osp, *ss2;
  289+        usch *osp, *ss2, *base;
288290         int c;
 289291 
 290292         thisnl = NULL;
 291293         slow = 1;
<>292 -        osp = stringbuf;
  294+        base = osp = stringbuf;
293295         goto found;
 294296 
 295297         while ((c = yylex()) != 0) {
     
 !
330332                         stringbuf = ss2;
 331333 
 332334 found:                  if (nl == 0 || subst(nl, NULL) == 0) {
<>333 -                                fputs(yytext, obuf);
  335+                                if (nl)
  336+                                        savstr(nl->namep);
  337+                                else
  338+                                        savstr(yytext);
334339                         } else if (osp != stringbuf) {
 335340                                 DPRINT(("IDENT1: unput osp %p stringbuf %p\n",
 336341                                     osp, stringbuf));
     
 !
339344                                 while (ss2 > osp)
 340345                                         cunput(*--ss2);
 341346                                 thisnl = nl;
<> 347+                                stringbuf = osp; /* clean up heap */
342348                         }
<>343 -                        stringbuf = osp; /* clean up heap */
344349                         break;
 345350 
 346351                 case EXPAND:
 347352                         DPRINT(("EXPAND!\n"));
 348353                         thisnl = NULL;
 349354                         break;
 350355 
<>351 -                case CHARCON:
352356                 case STRING:
 353357                 case '\n':
 354358                 case NUMBER:
 355359                 case FPOINT:
 356360                 case WSPACE:
 357361                         if (flslvl == 0)
<>358 -                                fputs(yytext, obuf);
  362+                                savstr(yytext);
359363                         break;
 360364 
 361365                 default:
 362366                         if (flslvl == 0) {
 363367                                 if (c < 256)
<>364 -                                        putch(c);
  368+                                        savch(c);
365369                                 else
 366370                                         error("bad dir2 %d", c);
 367371                         }
 368372                         break;
 369373                 }
 370374                 if (thisnl == NULL) {
 371375                         slow = 0;
<>372 -                        return;
  376+                        savch(0);
  377+                        return base;
373378                 }
 374379         }
<> 380+        error("preamture EOF");
  381+        /* NOTREACHED */
  382+        return NULL; /* XXX gcc */
375383 }
 376384 
 377385 void
<>378 -mainscan()
 379 -{
 380 -        struct symtab *nl, *thisnl;
 381 -        usch *osp, *ss2;
 382 -        int c;
 383 -
 384 -        thisnl = NULL;
 385 -        while ((c = yylex()) != 0) {
 386 -                switch (c) {
 387 -                case IDENT:
 388 -                        if (flslvl)
 389 -                                break;
 390 -                        osp = stringbuf;
 391 -if(dflag)printf("IDENT0: %s\n", yytext);
 392 -                        nl = lookup(yytext, FIND);
 393 -if(dflag)printf("IDENT: %s\n", yytext);
 394 -                        slow = 1;
 395 -                        if (nl == 0 || thisnl == 0)
 396 -                                goto found;
 397 -                        if (thisnl == nl) {
 398 -                                nl = 0;
 399 -                                goto found;
 400 -                        }
 401 -                        ss2 = stringbuf;
 402 -                        if ((c = yylex()) == WSPACE) {
 403 -                                savstr(yytext);
 404 -                                c = yylex();
 405 -                        }
 406 -                        if (c != EXPAND) {
 407 -                                unpstr(yytext);
 408 -                                if (ss2 != stringbuf)
 409 -                                        unpstr(ss2);
 410 -                                unpstr(nl->namep);
 411 -                                (void)yylex(); /* get yytext correct */
 412 -                                nl = 0; /* ignore */
 413 -                        } else {
 414 -                                thisnl = NULL;
 415 -                                if (nl->value[0] == OBJCT) {
 416 -                                        unpstr(nl->namep);
 417 -                                        (void)yylex(); /* get yytext correct */
 418 -                                        nl = 0;
 419 -                                }
 420 -                        }
 421 -                        stringbuf = ss2;
 422 -
 423 -found:                  if (nl == 0 || subst(nl, NULL) == 0) {
 424 -                                fputs(yytext, obuf);
 425 -                        } else if (osp != stringbuf) {
 426 -if(dflag)printf("IDENT1: unput osp %p stringbuf %p\n", osp, stringbuf);
 427 -                                ss2 = stringbuf;
 428 -                                cunput(EXPAND);
 429 -                                while (ss2 > osp)
 430 -                                        cunput(*--ss2);
 431 -                                thisnl = nl;
 432 -                        }
 433 -                        stringbuf = osp; /* clean up heap */
 434 -                        slow = 0;
 435 -                        break;
 436 -
 437 -                case EXPAND:
 438 -if(dflag)printf("EXPAND!\n");
 439 -                        thisnl = NULL;
 440 -                        break;
 441 -
 442 -                case CHARCON:
 443 -                case STRING:
 444 -                case '\n':
 445 -                        error("bad dir %d", c);
 446 -                        break;
 447 -
 448 -                case NUMBER:
 449 -                case FPOINT:
 450 -                case WSPACE:
 451 -                        if (flslvl == 0)
 452 -                                fputs(yytext, obuf);
 453 -                        break;
 454 -
 455 -                default:
 456 -                        if (flslvl == 0) {
 457 -                                if (c < 256)
 458 -                                        putch(c);
 459 -                                else
 460 -                                        error("bad dir2 %d", c);
 461 -                        }
 462 -                        break;
 463 -                }
 464 -        }
 465 -}
 466 -
 467 -void
468386 line()
 469387 {
<> 388+        static usch *lbuf;
  389+        static int llen;
470390         struct symtab *nl;
 471391         int c;
 472392 
<> 393+        slow = 1;
473394         if (yylex() != WSPACE)
 474395                 goto bad;
 475396         if ((c = yylex()) == IDENT) {
 476397                 /* Do macro preprocessing first */
 477398                 usch *osp = stringbuf;
 478399                 if ((nl = lookup(yytext, FIND)) == NULL)
 479400                         goto bad;
<>480 -                if (subst(nl, NULL) == 0)
 481 -                        goto bad;
 482 -                while (stringbuf > osp)
 483 -                        cunput(*--stringbuf);
  401+                unpstr(gotident(nl));
  402+                stringbuf = osp;
484403                 c = yylex();
 485404         }
 486405 
 487406         if (c != NUMBER)
 488407                 goto bad;
<>489 -        setline(atoi(yytext));
  408+        ifiles->lineno = atoi(yytext);
490409 
 491410         if ((c = yylex()) != '\n' && c != WSPACE)
 492411                 goto bad;
<>493 -        if (c == '\n')
 494 -                return setline(curline()+1);
  412+        if (c == '\n') {
  413+                slow = 0;
  414+                return;
  415+        }
495416         if (yylex() != STRING)
 496417                 goto bad;
<> 418+        c = strlen(yytext);
  419+        if (llen < c) {
  420+                /* may loose heap space */
  421+                lbuf = stringbuf;
  422+                stringbuf += c;
  423+                llen = c;
  424+        }
497425         yytext[strlen(yytext)-1] = 0;
<>498 -        setfile(&yytext[1]);
  426+        strcpy(lbuf, &yytext[1]);
  427+        ifiles->fname = lbuf;
  428+        if (yylex() != '\n')
  429+                goto bad;
  430+        slow = 0;
499431         return;
 500432 
 501433 bad:    error("bad line directive");
     
 !
515447         char *fn;
 516448         int i, c, it;
 517449 
<> 450+        if (flslvl)
  451+                return;
518452         osp = stringbuf;
<> 453+        slow = 1;
519454         if (yylex() != WSPACE)
 520455                 goto bad;
 521456 again:  if ((c = yylex()) != STRING && c != '<' && c != IDENT)
     
 !
537472                         savstr(yytext);
 538473                 }
 539474                 savch('\0');
<> 475+                while ((c = yylex()) == WSPACE)
  476+                        ;
  477+                if (c != '\n')
  478+                        goto bad;
540479                 it = SYSINC;
 541480         } else {
 542481                 usch *nm = stringbuf;
 543482 
 544483                 yytext[strlen(yytext)-1] = 0;
 545484                 fn = &yytext[1];
 546485                 /* first try to open file relative to previous file */
<>547 -                savstr(curfile());
  486+                savstr(ifiles->fname);
548487                 if ((stringbuf = strrchr(nm, '/')) == NULL)
 549488                         stringbuf = nm;
 550489                 else
 551490                         stringbuf++;
 552491                 savstr(fn); savch(0);
<> 492+                while ((c = yylex()) == WSPACE)
  493+                        ;
  494+                if (c != '\n')
  495+                        goto bad;
  496+                slow = 0;
553497                 if (pushfile(nm) == 0)
<>554 -                        goto ret;
  498+                        return;
555499                 stringbuf = nm;
 556500         }
 557501 
 558502         /* create search path and try to open file */
<> 503+        slow = 0;
559504         for (i = 0; i < 2; i++) {
 560505                 for (w = incdir[i]; w; w = w->next) {
 561506                         usch *nm = stringbuf;
 562507 
 563508                         savstr(w->dir); savch('/');
 564509                         savstr(fn); savch(0);
 565510                         if (pushfile(nm) == 0)
<>566 -                                goto ret;
  511+                                return;
567512                         stringbuf = nm;
 568513                 }
 569514         }
 570515         error("cannot find '%s'", fn);
<>571 -        stringbuf = osp;
 572 -        return;
  516+        /* error() do not return */
573517 
 574518 bad:    error("bad include");
<>575 -        stringbuf = osp;
 576 -ret:    prtline();
  519+        /* error() do not return */
577520 }
 578521 
<> 522+static int
  523+definp(void)
  524+{
  525+        int c;
  526+
  527+        do
  528+                c = yylex();
  529+        while (c == WSPACE);
  530+        return c;
  531+}
  532+
579533 void
 580534 define()
 581535 {
 582536         struct symtab *np;
 583537         usch *args[MAXARG], *ubuf, *sbeg;
 584538         int c, i, redef;
 585539         int mkstr = 0, narg = -1;
<> 540+        int ellips = 0;
586541 
<> 542+        if (flslvl)
  543+                return;
587544         slow = 1;
 588545         if (yylex() != WSPACE || yylex() != IDENT)
<>589 -                error("bad define1");
  546+                goto bad;
590547 
 591548         np = lookup(yytext, ENTER);
 592549         redef = np->value != NULL;
     
 !
595552         if ((c = yylex()) == '(') {
 596553                 narg = 0;
 597554                 /* function-like macros, deal with identifiers */
<>598 -                while ((c = yylex()) != ')') {
 599 -                        while (c == WSPACE) c = yylex();
 600 -                        if (c == ',') c = yylex(); /* XXX may fail */
 601 -                        while (c == WSPACE) c = yylex();
  555+                for (;;) {
  556+                        c = definp();
602557                         if (c == ')')
 603558                                 break;
<>604 -                        if (c != IDENT)
 605 -                                error("define error");
 606 -                        args[narg] = alloca(strlen(yytext)+1);
 607 -                        strcpy(args[narg], yytext);
 608 -                        narg++;
  559+                        if (c == ELLIPS) {
  560+                                ellips = 1;
  561+                                if (definp() != ')')
  562+                                        goto bad;
  563+                                break;
  564+                        }
  565+                        if (c == IDENT) {
  566+                                args[narg] = alloca(strlen(yytext)+1);
  567+                                strcpy(args[narg], yytext);
  568+                                narg++;
  569+                                if ((c = definp()) == ',')
  570+                                        continue;
  571+                                if (c == ')')
  572+                                        break;
  573+                                goto bad;
  574+                        }
  575+                        goto bad;
609576                 }
 610577                 c = yylex();
 611578         } else if (c == '\n') {
 612579                 /* #define foo */
 613580                 ;
 614581         } else if (c != WSPACE)
<>615 -                error("bad define");
  582+                goto bad;
616583 
 617584         while (c == WSPACE)
 618585                 c = yylex();
     
 !
652619                         if ((c = yylex()) == WSPACE)
 653620                                 c = yylex(); /* whitespace, ignore */
 654621                         mkstr = 1;
<> 622+                        if (c == VA_ARGS)
  623+                                continue;
655624 
 656625                         /* FALLTHROUGH */
 657626                 case IDENT:
     
 !
672641                                 savch(SNUFF), mkstr = 0;
 673642                         break;
 674643 
<> 644+                case VA_ARGS:
  645+                        if (ellips == 0)
  646+                                error("unwanted %s", yytext);
  647+                        savch(VARG);
  648+                        savch(WARN);
  649+                        if (mkstr)
  650+                                savch(SNUFF), mkstr = 0;
  651+                        break;
  652+
675653                 default:
 676654 id:                     savstr(yytext);
 677655                         break;
     
 !
685663                 else
 686664                         break;
 687665         }
<>688 -        savch(narg < 0 ? OBJCT : narg);
  666+        if (ellips) {
  667+                savch(narg);
  668+                savch(VARG);
  669+        } else
  670+                savch(narg < 0 ? OBJCT : narg);
689671         if (redef) {
 690672                 usch *o = np->value, *n = stringbuf-1;
 691673 
     
 !
705687                 printf("!define: ");
 706688                 if (*w == OBJCT)
 707689                         printf("[object]");
<>708 -                else
 709 -                        printf("[%d]", *w);
  690+                else if (*w == VARG)
  691+                        printf("[VARG%d]", *--w);
710692                 while (*--w) {
 711693                         switch (*w) {
 712694                         case WARN: printf("<%d>", *--w); break;
     
 !
719701         }
 720702 #endif
 721703         slow = 0;
<> 704+        return;
  705+
  706+bad:    error("bad define");
722707 }
 723708 
 724709 void
<>725 -error(char *s, ...)
  710+xerror(usch *s)
726711 {
<>727 -        va_list ap;
  712+        usch *t;
728713 
<>729 -        va_start(ap, s);
 730 -        fprintf(stderr, "%s:%d: ", curfile(), curline());
 731 -        vfprintf(stderr, s, ap);
 732 -        fputc('\n', stderr);
 733 -        exfail++;
 734 -        va_end(ap);
 735 -        exit(8);
  714+        if (ifiles != NULL) {
  715+                t = sheap("%s:%d: ", ifiles->fname, ifiles->lineno);
  716+                write (2, t, strlen(t));
  717+        }
  718+        write (2, s, strlen(s));
  719+        write (2, "\n", 1);
  720+        exit(1);
736721 }
 737722 
 738723 /*
     
 !
745730         if (stringbuf-sbf < SBSIZE)
 746731                 return;
 747732         error("Too much defining");
<>748 -        exit(1);
749733 }
 750734 
 751735 /*
     
 !
761745         register struct symtab *sp;
 762746         int i, c, around;
 763747 
<>764 -if (dflag)printf("lookup '%s'\n", namep);
  748+        DPRINT(("lookup '%s'\n", namep));
765749         np = namep;
 766750         around = i = 0;
 767751         while ((c = *np++))
     
 !
797781         register usch *vp, *cp;
 798782         int c, rv = 0;
 799783 
<>800 -if (dflag)printf("subst: %s\n", sp->namep);
  784+        DPRINT(("subst: %s\n", sp->namep));
801785         /*
 802786          * First check for special macros.
 803787          */
 804788         if (sp == filloc) {
<>805 -                savch('"');
 806 -                savstr(curfile());
 807 -                savch('"');
  789+                (void)sheap("\"%s\"", ifiles->fname);
808790                 return 1;
 809791         } else if (sp == linloc) {
<>810 -                char buf[12];
 811 -                sprintf(buf, "%d", curline());
 812 -                savstr(buf);
  792+                (void)sheap("%d", ifiles->lineno);
813793                 return 1;
 814794         }
 815795         vp = sp->value;
     
 !
10261006 {
 10271007         usch **args, *sptr, *ap, *bp, *sp;
 10281008         int narg, c, i, plev, snuff, instr;
<> 1009+        int ellips = 0;
10291010 
 10301011         DPRINT(("expdef %s rp %s\n", vp, (rp ? (char *)rp->sp->namep : "")));
 10311012         if ((c = yylex()) != '(')
 10321013                 error("got %c, expected )", c);
<>1033 -        narg = vp[1];
 1034 -        args = alloca(sizeof(usch *) * narg);
  1014+        if (vp[1] == VARG) {
  1015+                narg = *vp--;
  1016+                ellips = 1;
  1017+        } else
  1018+                narg = vp[1];
  1019+        args = alloca(sizeof(usch *) * (narg+ellips));
10351020 
 10361021 
 10371022         /*
     
 !
10531038                                 plev--;
 10541039                         savstr(yytext);
 10551040                         while ((c = yylex()) == '\n')
<>1056 -                                c = yylex(), savch('\n');
  1041+                                savch('\n');
10571042                 }
 10581043                 while (args[i] < stringbuf &&
 10591044                     (stringbuf[-1] == ' ' || stringbuf[-1] == '\t'))
 10601045                         stringbuf--;
 10611046                 savch('\0');
 10621047         }
<>1063 -        if (narg == 0)
  1048+        if (ellips && c != ')') {
  1049+                args[i] = stringbuf;
  1050+                plev = 0;
  1051+                while ((c = yylex()) == WSPACE)
  1052+                        ;
  1053+                for (;;) {
  1054+                        if (plev == 0 && c == ')')
  1055+                                break;
  1056+                        if (c == '(')
  1057+                                plev++;
  1058+                        if (c == ')')
  1059+                                plev--;
  1060+                        savstr(yytext);
  1061+                        while ((c = yylex()) == '\n')
  1062+                                savch('\n');
  1063+                }
  1064+                while (args[i] < stringbuf &&
  1065+                    (stringbuf[-1] == ' ' || stringbuf[-1] == '\t'))
  1066+                        stringbuf--;
  1067+                savch('\0');
  1068+                
  1069+        }
  1070+        if (narg == 0 && ellips == 0)
10641071                 c = yylex();
<>1065 -        if (c != ')' || i != narg)
  1072+        if (c != ')' || (i != narg && ellips == 0) || (i < narg && ellips == 1))
10661073                 error("wrong arg count");
 10671074 
 10681075         while (gotwarn--)
     
 !
10831090                         ;
 10841091                 else if (*sp == WARN) {
 10851092 
<>1086 -                        bp = ap = args[(int)*--sp];
  1093+                        if (sp[-1] == VARG) {
  1094+                                bp = ap = args[narg];
  1095+                                sp--;
  1096+                        } else
  1097+                                bp = ap = args[(int)*--sp];
10871098                         if (sp[2] != CONC && !snuff && sp[-1] != CONC) {
 10881099                                 cunput(WARN);
 10891100                                 while (*bp)
     
 !
11661177 }
 11671178 
 11681179 void
<> 1180+flbuf()
  1181+{
  1182+        if (obufp == 0)
  1183+                return;
  1184+        if (write(ofd, outbuf, obufp) < 0)
  1185+                error("obuf write error");
  1186+        obufp = 0;
  1187+}
  1188+
  1189+void
11691190 putch(int ch)
 11701191 {
<>1171 -        putc(ch, obuf);
  1192+        outbuf[obufp++] = ch;
  1193+        if (obufp == CPPBUF || (istty && ch == '\n'))
  1194+                flbuf();
11721195 }
 11731196 
 11741197 void
 11751198 putstr(usch *s)
 11761199 {
<>1177 -        while (*s) {
 1178 -                putc(*s, obuf);
 1179 -                s++;
  1200+        for (; *s; s++) {
  1201+                outbuf[obufp++] = *s;
  1202+                if (obufp == CPPBUF || (istty && *s == '\n'))
  1203+                        flbuf();
11801204         }
 11811205 }
 11821206 
<_ 1207+/*
  1208+ * convert a number to an ascii string.
  1209+ */
  1210+usch *
  1211+num2str(int num)
  1212+{
  1213+        static usch buf[12];
  1214+        usch *b = buf;
  1215+
  1216+        if (num) {
  1217+                while (num)
  1218+                        *b++ = num % 10 + '0', num /= 10;
  1219+        } else
  1220+                *b++ = '0';
  1221+        *b = 0;
  1222+        return buf;
  1223+}
  1224+
  1225+/*
  1226+ * similar to sprintf, but only handles %s and %d.
  1227+ * saves result on heap.
  1228+ */
  1229+usch *
  1230+sheap(char *fmt, ...)
  1231+{
  1232+        va_list ap;
  1233+        usch *op = stringbuf;
  1234+
  1235+        va_start(ap, fmt);
  1236+        for (; *fmt; fmt++) {
  1237+                if (*fmt == '%') {
  1238+                        fmt++;
  1239+                        switch (*fmt) {
  1240+                        case 's':
  1241+                                savstr(va_arg(ap, char *));
  1242+                                break;
  1243+                        case 'd':
  1244+                                savstr(num2str(va_arg(ap, int)));
  1245+                                break;
  1246+                        case 'c':
  1247+                                savch(va_arg(ap, int));
  1248+                                break;
  1249+                        default:
  1250+                                break; /* cannot call error() here */
  1251+                        }
  1252+                } else
  1253+                        savch(*fmt);
  1254+        }
  1255+        va_end(ap);
  1256+        *stringbuf = 0;
  1257+        return op;
  1258+}
  1259+
  1260+void
  1261+usage()
  1262+{
  1263+        error("Usage: cpp [-Cdt] [-Dvar=val] [-Uvar] [-Ipath] [-Spath]");
  1264+}
FishEye: Open Source License registered to PCC.
Your maintenance has expired. You can renew your license at http://www.atlassian.com/fisheye/renew
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-10-31 09:21 +0100