← Back to branch summary

~ubuntu-branches/ubuntu/lucid/9base/lucid

« back to all changes in this revision

Viewing changes to bc/bc.y

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2009-08-20 17:34:06 UTC
  • mfrom: (6.2.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090820173406-xpwqa9ruyevvc0ut
Tags: 1:3-3
* Updating maintainer field.
* Updating vcs fields.
* Updating package to standards version 3.8.3.
* Updatin variables writing in rules to consistent style.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bc/bc.y
6
6
        #define bsp_max 5000
7
7
 
8
8
        Biobuf  *in;
9
 
        #define stdin bstdin
10
 
        #define stdout bstdout
11
 
        Biobuf  stdin;
12
 
        Biobuf  stdout;
 
9
        Biobuf  bstdin;
 
10
        Biobuf  bstdout;
13
11
        char    cary[1000];
14
12
        char*   cp = { cary };
15
13
        char    string[1000];
19
17
        int     bindx = 0;
20
18
        int     lev = 0;
21
19
        int     ln;
22
 
        int*    ttp;
 
20
        char*   ttp;
23
21
        char*   ss = "";
24
22
        int     bstack[10] = { 0 };
25
23
        char*   numb[15] =
28
26
                " 6", " 7", " 8", " 9", " 10", " 11",
29
27
                " 12", " 13", " 14"
30
28
        };
31
 
        int*    pre;
32
 
        int*    post;
 
29
        char*   pre;
 
30
        char*   post;
33
31
 
34
32
        long    peekc = -1;
35
33
        int     sargc;
61
59
                "u","v","w","x","y","z"
62
60
        };
63
61
        char*   dot = { "." };
64
 
        int     bspace[bsp_max];
65
 
        int*    bsp_nxt = { bspace };
 
62
        char*   bspace[bsp_max];
 
63
        char**  bsp_nxt = bspace;
66
64
        int     bdebug = 0;
67
65
        int     lflag;
68
66
        int     cflag;
69
67
        int     sflag;
70
68
 
71
 
        int*    bundle(int, ...);
72
 
        void    conout(int*, char*);
 
69
        char*   bundle(int, ...);
 
70
        void    conout(char*, char*);
73
71
        int     cpeek(int, int, int);
74
72
        int     getch(void);
75
 
        int*    geta(char*);
76
 
        int*    getf(char*);
 
73
        char*   geta(char*);
 
74
        char*   getf(char*);
77
75
        void    getout(void);
78
 
        void    output(int*);
 
76
        void    output(char*);
79
77
        void    pp(char*);
80
 
        void    routput(int*);
 
78
        void    routput(char*);
81
79
        void    tp(char*);
82
80
        void    yyerror(char*, ...);
83
81
        int     yyparse(void);
84
82
 
85
83
        typedef void*   pointer;
86
 
/*      #pragma varargck        type    "lx"    pointer */
 
84
        #pragma varargck        type    "lx"    pointer
87
85
 
88
86
%}
89
87
%union
90
88
{
91
 
        int*    iptr;
92
89
        char*   cptr;
93
90
        int     cc;
94
91
}
95
92
 
96
 
%type   <iptr>  pstat stat stat1 def slist dlets e ase nase
97
 
%type   <iptr>  slist re fprefix cargs eora cons constant lora
 
93
%type   <cptr>  pstat stat stat1 def slist dlets e ase nase
 
94
%type   <cptr>  slist re fprefix cargs eora cons constant lora
98
95
%type   <cptr>  crs
99
96
 
100
97
%token  <cptr>  LETTER EQOP _AUTO DOT
124
121
                ttp = bundle(6, pre, $6, post , "0", numb[lev], "Q");
125
122
                conout(ttp, (char*)$1);
126
123
                rcrs = crs;
127
 
                output((int*)"");       /* this is horse puk!! */
 
124
                output("");
128
125
                lev = bindx = 0;
129
126
        }
130
127
 
550
547
        _DEFINE LETTER '('
551
548
        {
552
549
                $$ = getf($2);
553
 
                pre = (int*)"";
554
 
                post = (int*)"";
 
550
                pre = (char*)"";
 
551
                post = (char*)"";
555
552
                lev = 1;
556
553
                bindx = 0;
557
554
                bstack[bindx] = 0;
789
786
        peekc = -1;
790
787
        if(ch >= 0)
791
788
                return ch;
 
789
 
792
790
        ifile++;
793
 
        if(ifile > sargc) {
794
 
                if(ifile >= sargc+2)
 
791
        if(ifile >= sargc) {
 
792
                if(ifile >= sargc+1)
795
793
                        getout();
796
 
                in = &stdin;
 
794
                in = &bstdin;
797
795
                Binit(in, 0, OREAD);
798
796
                ln = 0;
799
797
                goto loop;
800
798
        }
801
 
        Bterm(in);
 
799
        if(in)
 
800
                Bterm(in);
802
801
        if((in = Bopen(sargv[ifile], OREAD)) != 0){
803
802
                ln = 0;
804
803
                ss = sargv[ifile];
805
804
                goto loop;
806
805
        }
 
806
        fprint(2, "open %s: %r\n", sargv[ifile]);
807
807
        yyerror("cannot open input file");
808
808
        return 0;               /* shut up ken */
809
809
}
810
810
 
811
 
int*
 
811
char*
812
812
bundle(int a, ...)
813
813
{
814
 
        int i, *p, *q;
815
 
 
816
 
        p = &a;
817
 
        i = *p++;
 
814
        int i;
 
815
        char **q;
 
816
        va_list arg;
 
817
        
 
818
        i = a;
 
819
        va_start(arg, a);
818
820
        q = bsp_nxt;
819
821
        if(bdebug)
820
822
                fprint(2, "bundle %d elements at %lx\n", i, q);
821
823
        while(i-- > 0) {
822
824
                if(bsp_nxt >= &bspace[bsp_max])
823
825
                        yyerror("bundling space exceeded");
824
 
                *bsp_nxt++ = *p++;
 
826
                *bsp_nxt++ = va_arg(arg, char*);
825
827
        }
826
828
        *bsp_nxt++ = 0;
827
 
        yyval.iptr = q;
828
 
        return q;
 
829
        va_end(arg);
 
830
        yyval.cptr = (char*)q;
 
831
        return (char*)q;
829
832
}
830
833
 
831
834
void
832
 
routput(int *p)
 
835
routput(char *p)
833
836
{
 
837
        char **pp;
 
838
        
834
839
        if(bdebug)
835
840
                fprint(2, "routput(%lx)\n", p);
836
 
        if(p >= &bspace[0] && p < &bspace[bsp_max]) {
 
841
        if((char**)p >= &bspace[0] && (char**)p < &bspace[bsp_max]) {
837
842
                /* part of a bundle */
838
 
                while(*p != 0)
839
 
                        routput((int*)(*p++));
 
843
                pp = (char**)p;
 
844
                while(*pp != 0)
 
845
                        routput(*pp++);
840
846
        } else
841
 
                Bprint(&stdout, (char*)p);      /* character string */
 
847
                Bprint(&bstdout, p);    /* character string */
842
848
}
843
849
 
844
850
void
845
 
output(int *p)
 
851
output(char *p)
846
852
{
847
853
        routput(p);
848
854
        bsp_nxt = &bspace[0];
849
 
        Bprint(&stdout, "\n");
850
 
        Bflush(&stdout);
 
855
        Bprint(&bstdout, "\n");
 
856
        Bflush(&bstdout);
851
857
        cp = cary;
852
858
        crs = rcrs;
853
859
}
854
860
 
855
861
void
856
 
conout(int *p, char *s)
 
862
conout(char *p, char *s)
857
863
{
858
 
        Bprint(&stdout, "[");
 
864
        Bprint(&bstdout, "[");
859
865
        routput(p);
860
 
        Bprint(&stdout, "]s%s\n", s);
861
 
        Bflush(&stdout);
 
866
        Bprint(&bstdout, "]s%s\n", s);
 
867
        Bflush(&bstdout);
862
868
        lev--;
863
869
}
864
870
 
867
873
{
868
874
        if(ifile > sargc)
869
875
                ss = "teletype";
870
 
        Bprint(&stdout, "c[%s on line %d, %s]pc\n", s, ln+1, ss);
871
 
        Bflush(&stdout);
 
876
        Bprint(&bstdout, "c[%s:%d, %s]pc\n", s, ln+1, ss);
 
877
        Bflush(&bstdout);
872
878
        cp = cary;
873
879
        crs = rcrs;
874
880
        bindx = 0;
881
887
{
882
888
        /* puts the relevant stuff on pre and post for the letter s */
883
889
        bundle(3, "S", s, pre);
884
 
        pre = yyval.iptr;
 
890
        pre = yyval.cptr;
885
891
        bundle(4, post, "L", s, "s.");
886
 
        post = yyval.iptr;
 
892
        post = yyval.cptr;
887
893
}
888
894
 
889
895
void
891
897
{
892
898
        /* same as pp, but for temps */
893
899
        bundle(3, "0S", s, pre);
894
 
        pre = yyval.iptr;
 
900
        pre = yyval.cptr;
895
901
        bundle(4, post, "L", s, "s.");
896
 
        post = yyval.iptr;
 
902
        post = yyval.cptr;
897
903
}
898
904
 
899
905
void
900
906
yyinit(int argc, char **argv)
901
907
{
902
 
        Binit(&stdout, 1, OWRITE);
 
908
        Binit(&bstdout, 1, OWRITE);
903
909
        sargv = argv;
904
 
        sargc = argc - 1;
 
910
        sargc = argc;
905
911
        if(sargc == 0) {
906
 
                in = &stdin;
 
912
                in = &bstdin;
907
913
                Binit(in, 0, OREAD);
908
 
        } else if((in = Bopen(sargv[1], OREAD)) == 0)
 
914
        } else if((in = Bopen(sargv[0], OREAD)) == 0)
909
915
                yyerror("cannot open input file");
910
 
        ifile = 1;
 
916
        ifile = 0;
911
917
        ln = 0;
912
 
        ss = sargv[1];
 
918
        ss = sargv[0];
913
919
}
914
920
 
915
921
void
916
922
getout(void)
917
923
{
918
 
        Bprint(&stdout, "q");
919
 
        Bflush(&stdout);
 
924
        Bprint(&bstdout, "q");
 
925
        Bflush(&bstdout);
920
926
        exits(0);
921
927
}
922
928
 
923
 
int*
 
929
char*
924
930
getf(char *p)
925
931
{
926
 
        return (int*)funtab[*p - 'a'];
 
932
        return funtab[*p - 'a'];
927
933
}
928
934
 
929
 
int*
 
935
char*
930
936
geta(char *p)
931
937
{
932
 
        return (int*)atab[*p - 'a'];
 
938
        return atab[*p - 'a'];
933
939
}
934
940
 
935
941
void
937
943
{
938
944
        int p[2];
939
945
 
940
 
        while(argc > 1 && *argv[1] == '-') {
941
 
                switch(argv[1][1]) {
942
 
                case 'd':
943
 
                        bdebug++;
944
 
                        break;
945
 
                case 'c':
946
 
                        cflag++;
947
 
                        break;
948
 
                case 'l':
949
 
                        lflag++;
950
 
                        break;
951
 
                case 's':
952
 
                        sflag++;
953
 
                        break;
954
 
                default:
955
 
                        fprint(2, "Usage: bc [-l] [-c] [file ...]\n");
956
 
                        exits("usage");
957
 
                }
958
 
                argc--;
959
 
                argv++;
960
 
        }
 
946
        ARGBEGIN{
 
947
        case 'd':
 
948
                bdebug++;
 
949
                break;
 
950
        case 'c':
 
951
                cflag++;
 
952
                break;
 
953
        case 'l':
 
954
                lflag++;
 
955
                break;
 
956
        case 's':
 
957
                sflag++;
 
958
                break;
 
959
        default:
 
960
                fprint(2, "Usage: bc [-l] [-c] [file ...]\n");
 
961
                exits("usage");
 
962
        }ARGEND
 
963
        
961
964
        if(lflag) {
 
965
                argc++;
962
966
                argv--;
963
 
                argc++;
964
 
                argv[1] = unsharp("#9/lib/bclib");
 
967
                *argv = unsharp("#9/lib/bclib");
965
968
        }
966
969
        if(cflag) {
967
970
                yyinit(argc, argv);
968
971
                for(;;)
969
972
                        yyparse();
970
 
                /* exits(0); */
 
973
                exits(0);
971
974
        }
972
975
        pipe(p);
973
976
        if(fork() == 0) {
981
984
        dup(p[0], 0);
982
985
        close(p[0]);
983
986
        close(p[1]);
984
 
        execlp("dc", "dc", (char*)0);
 
987
        execl(unsharp("#9/bin/dc"), "dc", nil);
985
988
}