Return to locals.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / c / n0

Annotation of coherent/b/bin/c/n0/locals.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * C compiler.
        !             3:  * Local variable declarations.
        !             4:  */
        !             5: #ifdef   vax
        !             6: #include "INC$LIB:cc0.h"
        !             7: #else
        !             8: #include "cc0.h"
        !             9: #endif
        !            10: 
        !            11: /*
        !            12:  * Read local variables.
        !            13:  * The correct lexic level is in "llex".
        !            14:  * The first token of the locals is in "s".
        !            15:  */
        !            16: locals()
        !            17: {
        !            18:        register SYM    *sp;
        !            19:        SYM             *nsp;
        !            20:        DIM             *dp, *ndp;
        !            21:        INFO            *ip;
        !            22:        int             seg;
        !            23:        int             rf;
        !            24:        int             c, dc, t;
        !            25: 
        !            26:        for (;;) {
        !            27:                gcandt(&c, &t, &dp, &ip, &rf);
        !            28:                if (c==C_NONE && t==T_NONE && rf==0)
        !            29:                        break;
        !            30:                if (s == SEMI) {
        !            31:                        lex();
        !            32:                        continue;
        !            33:                }
        !            34:                if (c == C_NONE)
        !            35:                        c = C_AUTO;
        !            36:                if (t == T_NONE)
        !            37:                        t = T_INT;
        !            38:                for (;;) {
        !            39:                        if (gdecl(&nsp, &ndp, dp, c, SL_VAR)) {
        !            40:                                sp = nsp;
        !            41:                                sp = declare(sp, c, t, ndp, ip, rf);
        !            42:                                if ((dc=sp->s_class) == C_SIN) {
        !            43:                                        seg = SPURE;
        !            44:                                        if ((rf&S_RONLY) == 0) {
        !            45:                                                if (s == ASSIGN)
        !            46:                                                        seg = SDATA;
        !            47:                                                else
        !            48:                                                        seg = SBSS;
        !            49:                                        }
        !            50:                                        newseg(seg);
        !            51:                                        align(sp);
        !            52:                                        sp->s_value = here();
        !            53:                                        sp->s_seg = seg;
        !            54:                                        if (s == ASSIGN) {
        !            55:                                                lex();
        !            56:                                                putautos();
        !            57:                                                init(sp, sp->s_dp, (sizeof_t)0, 1);
        !            58:                                        } else {
        !            59:                                                bput(BLOCK);
        !            60:                                                zput(ssize(sp));
        !            61:                                        }
        !            62:                                        newseg(SCODE);
        !            63:                                }
        !            64:                                if (dc==C_AUTO || dc==C_REG) {
        !            65:                                        bindlocal(sp);
        !            66:                                        if (s == ASSIGN) {
        !            67:                                                lex();
        !            68:                                                putautos();
        !            69:                                                init(sp, sp->s_dp, (sizeof_t)0, 0);
        !            70:                                        }
        !            71:                                }
        !            72: #ifdef KLUDGE
        !            73:                                if (dc == C_GREF) {
        !            74:                                        bput(SGUESS);
        !            75:                                        nput(sp->s_id);
        !            76:                                        if (isfunc(sp))
        !            77:                                                bput(SCODE);
        !            78:                                        else
        !            79:                                                bput(SDATA);
        !            80:                                }
        !            81: #endif
        !            82:                        }
        !            83:                        dblocal(sp);
        !            84:                        if (s != COMMA)
        !            85:                                break;
        !            86:                        lex();
        !            87:                }
        !            88:                xdropinfo(t, ip);
        !            89:                mustbe(SEMI);
        !            90:        }
        !            91: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.