Quick Search:

Mode

Context

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

Other Diffs

Ignore

Blank Lines Whitespace: Expand:

Diff

1.254
 
1.255
 
MAIN:ragge:20120923083948
 
cc.c
_>523523                                 oerror(argp);
 524524                         break;
 525525 
<>526 -                case 'X':
 527 -                        Xflag++;
  526+                case 'c':
  527+                        cflag++;
528528                         break;
<>529 -                case 'W': /* Ignore (most of) W-flags */
 530 -                        if ((t = argnxt(argp, "-Wl,"))) {
 531 -                                u = strtok(t, ",");
 532 -                                do {
 533 -                                        strlist_append(&inputs, u);
 534 -                                } while ((u = strtok(NULL, ",")) != NULL);
 535 -                        } else if ((t = argnxt(argp, "-Wa,"))) {
 536 -                                u = strtok(t, ",");
 537 -                                do {
 538 -                                        strlist_append(&assembler_flags, u);
 539 -                                } while ((u = strtok(NULL, ",")) != NULL);
 540 -                        } else if ((t = argnxt(argp, "-Wc,"))) {
 541 -                                u = strtok(t, ",");
 542 -                                do {
 543 -                                        strlist_append(&compiler_flags, u);
 544 -                                } while ((u = strtok(NULL, ",")) != NULL);
 545 -                        } else if ((t = argnxt(argp, "-Wp,"))) {
 546 -                                u = strtok(t, ",");
 547 -                                do {
 548 -                                        strlist_append(&preprocessor_flags, u);
 549 -                                } while ((u = strtok(NULL, ",")) != NULL);
 550 -                        } else if (strcmp(argp, "-Werror") == 0) {
 551 -                                strlist_append(&compiler_flags, "-Werror");
 552 -                        } else if (strcmp(argp, "-Wall") == 0) {
 553 -                                for (Wf = Wflags; Wf->name; Wf++)
 554 -                                        if (Wf->flags & INWALL)
 555 -                                                strlist_append(&compiler_flags,
 556 -                                                    cat("-W", Wf->name));
 557 -                        } else if (strcmp(argp, "-WW") == 0) {
 558 -                                for (Wf = Wflags; Wf->name; Wf++)
 559 -                                        strlist_append(&compiler_flags,
 560 -                                            cat("-W", Wf->name));
 561 -                        } else {
 562 -                                /* pass through, if supported */
 563 -                                t = &argp[2];
 564 -                                if (strncmp(t, "no-", 3) == 0)
 565 -                                        t += 3;
 566 -                                if (strncmp(t, "error=", 6) == 0)
 567 -                                        t += 6;
 568 -                                for (Wf = Wflags; Wf->name; Wf++) {
 569 -                                        if (strcmp(t, Wf->name) == 0)
 570 -                                                strlist_append(&compiler_flags,
 571 -                                                    argp);
 572 -                                }
 573 -                        }
  529+
  530+                case 'd':
  531+                        owarning(argp);
574532                         break;
 575533 
<> 534+                case 'E':
  535+                        Eflag++;
  536+                        break;
  537+
576538                 case 'f': /* GCC compatibility flags */
 577539                         u = &argp[2];
 578540                         j = 0;
     
 !
600562                                 gflag++;
 601563                         break;
 602564 
<> 565+
  566+                case 'X':
  567+                        Xflag++;
  568+                        break;
  569+
603570                 case 'D':
 604571                 case 'U':
 605572                         strlist_append(&preprocessor_flags, argp);
     
 !
693660                         rflag = 1;
 694661                         break;
 695662 
<>696 -                case 'x':
 697 -                        t = nxtopt("-x");
 698 -                        if (match(t, "c"))
 699 -                                strlist_append(&inputs, ")c");
 700 -                        else if (match(t, "assembler"))
 701 -                                strlist_append(&inputs, ")s");
 702 -                        else if (match(t, "assembler-with-cpp"))
 703 -                                strlist_append(&inputs, ")S");
 704 -                        else if (match(t, "c++"))
 705 -                                strlist_append(&inputs, ")c++");
 706 -                        else {
 707 -                                strlist_append(&compiler_flags, "-x");
 708 -                                strlist_append(&compiler_flags, t);
 709 -                        }
 710 -                        break;
711663                 case 'T':
 712664                         strlist_append(&inputs, argp);
 713665                         if (argp[2] == 0 ||
     
 !
716668                             strcmp(argp, "-Tbss") == 0)
 717669                                 strlist_append(&inputs, nxtopt(0));
 718670                         break;
<>719 -                case 't':
 720 -                        tflag++;
  671+
  672+                case 's':
  673+                        if (match(argp, "-shared")) {
  674+                                shared = 1;
  675+                        } else if (match(argp, "-static")) {
  676+                                Bstatic = 1;
  677+                        } else if (match(argp, "-symbolic")) {
  678+                                strlist_append(&middle_linker_flags,
  679+                                    "-Bsymbolic");
  680+                        } else if (strncmp(argp, "-std", 4) == 0) {
  681+                                if (strcmp(&argp[5], "gnu99") == 0 ||
  682+                                    strcmp(&argp[5], "gnu9x") == 0)
  683+                                        xgnu99 = 1;
  684+                                if (strcmp(&argp[5], "gnu89") == 0)
  685+                                        xgnu89 = 1;
  686+                        } else
  687+                                owarning(argp);
721688                         break;
<> 689+
722690                 case 'S':
 723691                         Sflag++;
 724692                         cflag++;
 725693                         break;
<> 694+
  695+                case 't':
  696+                        tflag++;
  697+                        break;
  698+
726699                 case 'o':
 727700                         if (outfile)
 728701                                 errorx(8, "too many -o");
 729702                         outfile = nxtopt("-o");
 730703                         break;
<> 704+
731705                 case 'O':
 732706                         if (argp[2] == '\0')
 733707                                 Oflag++;
     
 !
739713                         else
 740714                                 oerror(argp);
 741715                         break;
<>742 -                case 'E':
 743 -                        Eflag++;
 744 -                        break;
  716+
745717                 case 'P':
 746718                         strlist_append(&preprocessor_flags, argp);
 747719                         break;
 748720 
<>749 -                case 'c':
 750 -                        cflag++;
 751 -                        break;
 752 -
753721                 case 'M':
 754722                         needM = 1;
 755723                         if (match(argp, "-M")) {
     
 !
771739                                 oerror(argp);
 772740                         break;
 773741 
<>774 -                case 'd':
 775 -                        owarning(argp);
 776 -                        break;
777742                 case 'v':
 778743                         printf("%s\n", VERSSTR);
 779744                         vflag++;
 780745                         break;
 781746 
<>782 -                case 's':
 783 -                        if (match(argp, "-shared")) {
 784 -                                shared = 1;
 785 -                        } else if (match(argp, "-static")) {
 786 -                                Bstatic = 1;
 787 -                        } else if (match(argp, "-symbolic")) {
 788 -                                strlist_append(&middle_linker_flags,
 789 -                                    "-Bsymbolic");
 790 -                        } else if (strncmp(argp, "-std", 4) == 0) {
 791 -                                if (strcmp(&argp[5], "gnu99") == 0 ||
 792 -                                    strcmp(&argp[5], "gnu9x") == 0)
 793 -                                        xgnu99 = 1;
 794 -                                if (strcmp(&argp[5], "gnu89") == 0)
 795 -                                        xgnu89 = 1;
 796 -                        } else
 797 -                                owarning(argp);
  747+                case 'W': /* Ignore (most of) W-flags */
  748+                        if ((t = argnxt(argp, "-Wl,"))) {
  749+                                u = strtok(t, ",");
  750+                                do {
  751+                                        strlist_append(&inputs, u);
  752+                                } while ((u = strtok(NULL, ",")) != NULL);
  753+                        } else if ((t = argnxt(argp, "-Wa,"))) {
  754+                                u = strtok(t, ",");
  755+                                do {
  756+                                        strlist_append(&assembler_flags, u);
  757+                                } while ((u = strtok(NULL, ",")) != NULL);
  758+                        } else if ((t = argnxt(argp, "-Wc,"))) {
  759+                                u = strtok(t, ",");
  760+                                do {
  761+                                        strlist_append(&compiler_flags, u);
  762+                                } while ((u = strtok(NULL, ",")) != NULL);
  763+                        } else if ((t = argnxt(argp, "-Wp,"))) {
  764+                                u = strtok(t, ",");
  765+                                do {
  766+                                        strlist_append(&preprocessor_flags, u);
  767+                                } while ((u = strtok(NULL, ",")) != NULL);
  768+                        } else if (strcmp(argp, "-Werror") == 0) {
  769+                                strlist_append(&compiler_flags, "-Werror");
  770+                        } else if (strcmp(argp, "-Wall") == 0) {
  771+                                for (Wf = Wflags; Wf->name; Wf++)
  772+                                        if (Wf->flags & INWALL)
  773+                                                strlist_append(&compiler_flags,
  774+                                                    cat("-W", Wf->name));
  775+                        } else if (strcmp(argp, "-WW") == 0) {
  776+                                for (Wf = Wflags; Wf->name; Wf++)
  777+                                        strlist_append(&compiler_flags,
  778+                                            cat("-W", Wf->name));
  779+                        } else {
  780+                                /* pass through, if supported */
  781+                                t = &argp[2];
  782+                                if (strncmp(t, "no-", 3) == 0)
  783+                                        t += 3;
  784+                                if (strncmp(t, "error=", 6) == 0)
  785+                                        t += 6;
  786+                                for (Wf = Wflags; Wf->name; Wf++) {
  787+                                        if (strcmp(t, Wf->name) == 0)
  788+                                                strlist_append(&compiler_flags,
  789+                                                    argp);
  790+                                }
  791+                        }
798792                         break;
<> 793+
  794+                case 'x':
  795+                        t = nxtopt("-x");
  796+                        if (match(t, "c"))
  797+                                strlist_append(&inputs, ")c");
  798+                        else if (match(t, "assembler"))
  799+                                strlist_append(&inputs, ")s");
  800+                        else if (match(t, "assembler-with-cpp"))
  801+                                strlist_append(&inputs, ")S");
  802+                        else if (match(t, "c++"))
  803+                                strlist_append(&inputs, ")c++");
  804+                        else {
  805+                                strlist_append(&compiler_flags, "-x");
  806+                                strlist_append(&compiler_flags, t);
  807+                        }
  808+                        break;
  809+
799810                 }
 800811                 continue;
 801812 
     
 !
869880                         ascpp = match(msuffix, "S");
 870881                         continue;
 871882                 }
<>872 -                if (ifile[0] == '-' && ifile[1] != 0)
  883+                if (ifile[0] == '-' && ifile[1] == 0)
  884+                        suffix = msuffix ? msuffix : "c";
  885+                else if (ifile[0] == '-')
<_873886                         suffix = "o"; /* source files cannot begin with - */
 874887                 else if (msuffix)
 875888                         suffix = msuffix;
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-09-01 20:33 +0200