Return to read.c CVS log

Up to [Research Unix] / researchv8dc / cmd / cyntax / cem

Annotation of researchv8dc/cmd/cyntax/cem/read.c, revision 1.1

1.1     ! root        1: #include       <errno.h>
        !             2: #include       "cem.h"
        !             3: #define        STD_OBJ 1
        !             4: #include       "stdobj.h"
        !             5: 
        !             6: /*
        !             7:  *     Read and load an object file.
        !             8:  */
        !             9: static void
        !            10: read_obj(s, fd)
        !            11: register char  *s;
        !            12: register int   fd;
        !            13: {
        !            14:        register int    i;
        !            15:        register long   sz;
        !            16:        header          obj_header;
        !            17:        static char     cmd[]   = CMD;
        !            18:        static char     mac[]   = MAC;
        !            19:        extern void     enter_types();
        !            20:        extern void     enter_vars();
        !            21:        extern void     install_strings();
        !            22: 
        !            23:        switch (read(fd, (char *)&obj_header, sizeof (header)))
        !            24:        {
        !            25:        case SYSERROR:
        !            26:                fprintf(stderr, "%s: could not read ", my_name);
        !            27:                fflush(stderr);
        !            28:                perror(s);
        !            29:                exit(1);
        !            30: 
        !            31:        case sizeof (header):
        !            32:                break;
        !            33: 
        !            34:        default:
        !            35:                fprintf(stderr, "%s: %s is not an object module\n", my_name, s);
        !            36:                exit(1);
        !            37:        }
        !            38: 
        !            39:        if (strncmp(obj_header.hd_cmd, cmd, CMD_SZ) != 0)
        !            40:        {
        !            41:                fprintf(stderr, "%s: %s is not an object module\n", my_name, s);
        !            42:                exit(1);
        !            43:        }
        !            44: 
        !            45:        if (strncmp(obj_header.hd_mac, mac, MAC_SZ) != 0)
        !            46:        {
        !            47:                fprintf(stderr, "%s: version mismatch for %s (recompile)\n", my_name, s);
        !            48:                exit(1);
        !            49:        }
        !            50: 
        !            51:        if (obj_header.hd_type_size == 0)
        !            52:        {
        !            53:                fprintf(stderr, "%s: %s has compilation errors\n", my_name, s);
        !            54:                exit(1);
        !            55:        }
        !            56: 
        !            57:        sz = obj_header.hd_str_off + obj_header.hd_str_size - sizeof (header);
        !            58:        data_base = salloc(sz);
        !            59:        str_base = data_base + obj_header.hd_str_off - sizeof (header) - 1;
        !            60: 
        !            61:        if ((i = read(fd, data_base, (int)sz)) != sz)
        !            62:        {
        !            63:                if (i == SYSERROR)
        !            64:                {
        !            65:                        fprintf(stderr, "%s: could not read ", my_name);
        !            66:                        fflush(stderr);
        !            67:                        perror(s);
        !            68:                }
        !            69:                else
        !            70:                        fprintf(stderr, "%s: %s is too small\n", my_name, s);
        !            71: 
        !            72:                exit(1);
        !            73:        }
        !            74: 
        !            75: #if    DEBUG
        !            76:        if (debug)
        !            77:        {
        !            78:                register char   *id;
        !            79:                register long   l0;
        !            80:                register long   l1;
        !            81:                register long   l2;
        !            82: 
        !            83:                data_ptr = data_base;
        !            84:                data_end = data_base + obj_header.hd_str_off - sizeof (header);
        !            85:                type_index = 1;
        !            86:                var_index = 1;
        !            87:                str_num = 0;
        !            88: 
        !            89:                while (data_ptr < data_end)
        !            90:                {
        !            91:                        i = getd();
        !            92: 
        !            93:                        switch (obj_item(i))
        !            94:                        {
        !            95:                        case i_data:
        !            96:                                l0 = getv();
        !            97:                                l1 = getv();
        !            98:                                printf("data: var %ld (%s:%ld)\n", l0, &str_base[l1], getv());
        !            99: 
        !           100:                                loop
        !           101:                                {
        !           102:                                        i = getd();
        !           103: 
        !           104:                                        switch (obj_item(i))
        !           105:                                        {
        !           106:                                        case d_addr:
        !           107:                                                printf("\taddr var %ld for %ld\n", get4(), obj_id(i));
        !           108:                                                continue;
        !           109: 
        !           110:                                        case d_bytes:
        !           111:                                                if (obj_id(i) == 0)
        !           112:                                                        l0 = getv();
        !           113:                                                else
        !           114:                                                        l0 = obj_id(i);
        !           115: 
        !           116:                                                printf("\tbytes %ld\n", l0);
        !           117:                                                data_ptr += l0;
        !           118:                                                continue;
        !           119: 
        !           120:                                        case d_end:
        !           121:                                                printf("\tend\n");
        !           122:                                                break;
        !           123: 
        !           124:                                        case d_istring:
        !           125:                                                if (obj_id(i) == 0)
        !           126:                                                        l0 = getv();
        !           127:                                                else
        !           128:                                                        l0 = obj_id(i);
        !           129: 
        !           130:                                                data_ptr += l0;
        !           131:                                                printf("\tstring %ld, length %ld\n", str_num++, l0);
        !           132:                                                continue;
        !           133: 
        !           134:                                        case d_irstring:
        !           135:                                                if (obj_id(i) == 0)
        !           136:                                                        l0 = getv();
        !           137:                                                else
        !           138:                                                        l0 = obj_id(i);
        !           139: 
        !           140:                                                data_ptr += l0;
        !           141:                                                printf("\tstring %ld + %ld, length %ld\n", str_num++, get4(), l0);
        !           142:                                                continue;
        !           143: 
        !           144:                                        case d_space:
        !           145:                                                printf("\tspace %ld\n", obj_id(i) == 0 ? getv() : obj_id(i));
        !           146:                                                continue;
        !           147: 
        !           148:                                        case d_string:
        !           149:                                                printf("\tstring %ld\n", getv());
        !           150:                                                continue;
        !           151: 
        !           152:                                        case d_reloc:
        !           153:                                                l0 = getv();
        !           154:                                                printf("\treloc var %ld + %ld for %ld\n", l0, get4(), obj_id(i));
        !           155:                                                continue;
        !           156: 
        !           157:                                        case d_rstring:
        !           158:                                                l0 = getv();
        !           159:                                                printf("\tstring %ld + %ld\n", l0, get4());
        !           160:                                                continue;
        !           161: 
        !           162:                                        default:
        !           163:                                                fprintf(stderr, "%s: unknown data id %d\n", my_name, i);
        !           164:                                                exit(1);
        !           165:                                        }
        !           166: 
        !           167:                                        break;
        !           168:                                }
        !           169: 
        !           170:                                break;
        !           171: 
        !           172:                        case i_lib:
        !           173:                                printf("lib: %s\n", &str_base[getv()]);
        !           174:                                break;
        !           175: 
        !           176:                        case i_src:
        !           177:                                printf("src: %s\n", &str_base[getv()]);
        !           178:                                break;
        !           179: 
        !           180:                        case i_string:
        !           181:                                if (obj_id(i) == 0)
        !           182:                                        l0 = getv();
        !           183:                                else
        !           184:                                        l0 = obj_id(i);
        !           185: 
        !           186:                                printf("string %ld, length %ld\n", str_num++, l0);
        !           187:                                data_ptr += l0;
        !           188:                                break;
        !           189: 
        !           190:                        case i_type:
        !           191:                                printf("type ");
        !           192: 
        !           193:                                switch (obj_id(i))
        !           194:                                {
        !           195:                                case t_arrayof:
        !           196:                                        l0 = getv();
        !           197:                                        l1 = getv();
        !           198:                                        printf("%ld: array %ld of %ld\n", type_index++, l0, l1);
        !           199:                                        break;
        !           200: 
        !           201:                                case t_basetype:
        !           202:                                        printf("%ld: ", type_index++);
        !           203:                                        print_basetype(getd() & 0xFF);
        !           204:                                        printf("\n");
        !           205:                                        break;
        !           206: 
        !           207:                                case t_bitfield:
        !           208:                                        l0 = getv();
        !           209:                                        l1 = getv();
        !           210:                                        printf("%ld: bitfield %ld of %ld\n", type_index++, l0, l1);
        !           211:                                        break;
        !           212: 
        !           213:                                case t_dimless:
        !           214:                                        printf("%ld: array [] of %ld\n", type_index++, getv());
        !           215:                                        break;
        !           216: 
        !           217:                                case t_elaboration:
        !           218:                                        l0 = getv();
        !           219:                                        l1 = getv();
        !           220:                                        printf("elab %ld: (%s:%ld) ", l0, &str_base[l1], getv());
        !           221:                                        
        !           222:                                        switch (i = obj_id(getd()))
        !           223:                                        {
        !           224:                                        case t_enum:
        !           225:                                                printf("enum\n");
        !           226:                                                l0 = getv();
        !           227:                                                goto elab_enum;
        !           228: 
        !           229:                                        case t_structof:
        !           230:                                                printf("struct\n");
        !           231:                                                l0 = getv();
        !           232: 
        !           233:                                                do
        !           234:                                                {
        !           235:                                                        l1 = getv();
        !           236:                                                        printf("\t%s = %ld @ %ld\n", &str_base[l0], l1, getv());
        !           237:                                                        l0 = getv();
        !           238:                                                }
        !           239:                                                while (l0 != 0);
        !           240: 
        !           241:                                                printf("\t(%ld)\n", getv());
        !           242:                                                break;
        !           243: 
        !           244:                                        case t_unionof:
        !           245:                                                printf("union\n");
        !           246:                                                l0 = getv();
        !           247: 
        !           248:                                                do
        !           249:                                                {
        !           250:                                                        l1 = getv();
        !           251:                                                        printf("\t%s = %ld\n", &str_base[l0], l1);
        !           252:                                                        l0 = getv();
        !           253:                                                }
        !           254:                                                while (l0 != 0);
        !           255: 
        !           256:                                                printf("\t(%ld)\n", getv());
        !           257:                                                break;
        !           258: 
        !           259:                                        default:
        !           260:                                                fprintf(stderr, "%s: unknown elaboration id %d\n", my_name, i);
        !           261:                                                exit(1);
        !           262:                                        }
        !           263: 
        !           264:                                        break;
        !           265: 
        !           266:                                case t_enum:
        !           267:                                        printf("%ld: ", type_index++);
        !           268: 
        !           269:                                        if ((l0 = getv()) == 0)
        !           270:                                                id = "<anon>";
        !           271:                                        else
        !           272:                                                id = &str_base[l0];
        !           273: 
        !           274:                                        l0 = getv();
        !           275:                                        l1 = getv();
        !           276: 
        !           277:                                        printf("enum %s (%s:%ld)\n", id, &str_base[l0], l1);
        !           278: 
        !           279:                                        if ((l0 = getv()) == 0)
        !           280:                                        {
        !           281:                                                printf("\tforward\n");
        !           282:                                                break;
        !           283:                                        }
        !           284: 
        !           285:                                elab_enum:
        !           286:                                        do
        !           287:                                        {
        !           288:                                                l1 = getu();
        !           289:                                                printf("\t%s = %ld\n", &str_base[l0], l1);
        !           290:                                                l0 = getv();
        !           291:                                        }
        !           292:                                        while (l0 != 0);
        !           293: 
        !           294:                                        l0 = getu();
        !           295:                                        l1 = getu();
        !           296: 
        !           297:                                        printf("\t(%ld, %ld)\n", l0, l1);
        !           298:                                        break;
        !           299: 
        !           300:                                case t_ftnreturning:
        !           301:                                        printf("%ld: function returning %ld\n", type_index++, getv());
        !           302:                                        break;
        !           303: 
        !           304:                                case t_ptrto:
        !           305:                                        printf("%ld: pointer to %ld\n", type_index++, getv());
        !           306:                                        break;
        !           307: 
        !           308:                                case t_structof:
        !           309:                                        printf("%ld: ", type_index++);
        !           310: 
        !           311:                                        if ((l0 = getv()) == 0)
        !           312:                                                id = "<anon>";
        !           313:                                        else
        !           314:                                                id = &str_base[l0];
        !           315: 
        !           316:                                        l0 = getv();
        !           317:                                        l1 = getv();
        !           318: 
        !           319:                                        printf("struct %s (%s:%ld)\n", id, &str_base[l0], l1);
        !           320:                                        break;
        !           321: 
        !           322:                                case t_unionof:
        !           323:                                        printf("%ld: ", type_index++);
        !           324: 
        !           325:                                        if ((l0 = getv()) == 0)
        !           326:                                                id = "<anon>";
        !           327:                                        else
        !           328:                                                id = &str_base[l0];
        !           329: 
        !           330:                                        l0 = getv();
        !           331:                                        l1 = getv();
        !           332: 
        !           333:                                        printf("union %s (%s:%ld)\n", id, &str_base[l0], l1);
        !           334:                                        break;
        !           335: 
        !           336:                                default:
        !           337:                                        fprintf(stderr, "%s: unknown type id %d\n", my_name, obj_id(i));
        !           338:                                        exit(1);
        !           339:                                }
        !           340: 
        !           341:                                break;
        !           342: 
        !           343:                        case i_var:
        !           344:                                printf("var ");
        !           345: 
        !           346:                                switch (obj_id(i))
        !           347:                                {
        !           348:                                case v_arglist:
        !           349:                                        l0 = getv();
        !           350:                                        l1 = getv();
        !           351:                                        printf("arglist: %ld (%s:%ld)\n", l0, &str_base[l1], getv());
        !           352: 
        !           353:                                        while ((l0 = getv()) != 0)
        !           354:                                        {
        !           355:                                                l1 = getv();
        !           356:                                                l2 = getv();
        !           357:                                                printf("\t%ld: %s type %ld (%s:%ld)\n", var_index++, &str_base[l0], l1, &str_base[l2], getv());
        !           358:                                        }
        !           359: 
        !           360:                                        break;
        !           361: 
        !           362:                                case v_array_size:
        !           363:                                        l0 = getv();
        !           364:                                        printf("array %ld new type %ld\n", l0, getv());
        !           365:                                        break;
        !           366: 
        !           367:                                case v_auto:
        !           368:                                        id = "auto";
        !           369:                                        goto get_var;
        !           370: 
        !           371:                                case v_block_static:
        !           372:                                        id = "block static";
        !           373:                                        goto get_var;
        !           374: 
        !           375:                                case v_call:
        !           376:                                        l0 = getv();
        !           377:                                        l1 = getv();
        !           378:                                        printf("call: var %ld (%s:%ld)\n", l0, &str_base[l1], getv());
        !           379: 
        !           380:                                        while ((l0 = getv()) != 0)
        !           381:                                                printf("\ttype %ld\n", l0);
        !           382: 
        !           383:                                        break;
        !           384: 
        !           385:                                case v_global:
        !           386:                                        id = "global";
        !           387:                                        goto get_var;
        !           388: 
        !           389:                                case v_implicit_function:
        !           390:                                        id = "implicit()";
        !           391:                                        goto get_var;
        !           392: 
        !           393:                                case v_static:
        !           394:                                        id = "static";
        !           395:                                        goto get_var;
        !           396: 
        !           397:                                get_var:
        !           398:                                        l0 = getv();
        !           399:                                        l1 = getv();
        !           400:                                        l2 = getv();
        !           401:                                        printf("%ld: %s %s type %ld (%s:%ld)\n", var_index++, id, &str_base[l0], l1, &str_base[l2], getv());
        !           402:                                        break;
        !           403: 
        !           404:                                case v_varargs:
        !           405:                                        l0 = getv();
        !           406:                                        printf("%ld: varargs %ld\n", l0, getv());
        !           407:                                        break;
        !           408: 
        !           409:                                default:
        !           410:                                        fprintf(stderr, "%s: unknown var id %d\n", my_name, obj_id(i));
        !           411:                                        exit(1);
        !           412:                                }
        !           413: 
        !           414:                                break;
        !           415: 
        !           416:                        default:
        !           417:                                fprintf(stderr, "%s: unknown obj_item %d\n", my_name, obj_item(i));
        !           418:                                exit(1);
        !           419:                        }
        !           420:                }
        !           421: 
        !           422:                fflush(stdout);
        !           423:        }
        !           424: #endif DEBUG
        !           425: 
        !           426:        file_errors = 0;
        !           427:        install_strings(str_base + 1, obj_header.hd_str_size);
        !           428: 
        !           429:        type_index = 1;
        !           430:        data_ptr = data_base;
        !           431:        data_end = data_base + obj_header.hd_str_off - sizeof (header);
        !           432:        enter_types(obj_header.hd_type_size);
        !           433: 
        !           434:        str_num = 0;
        !           435:        var_index = 1;
        !           436:        data_ptr = data_base;
        !           437:        data_end = data_base + obj_header.hd_str_off - sizeof (header);
        !           438:        enter_vars(obj_header.hd_var_size);
        !           439: 
        !           440:        free((char *)str_trans);
        !           441:        free((char *)type_trans);
        !           442:        free((char *)var_trans);
        !           443:        free(data_base);
        !           444:        src_file = NULL;
        !           445: 
        !           446:        if (file_errors)
        !           447:                fflush(stdout);
        !           448: }
        !           449: 
        !           450: /*
        !           451:  *     Open a library and load it.
        !           452:  */
        !           453: void
        !           454: load_lib(l)
        !           455: char   *l;
        !           456: {
        !           457:        register int    fd;
        !           458:        register char   *s;
        !           459:        extern int      errno;
        !           460:        extern char     *strcat();
        !           461:        extern char     *strcpy();
        !           462: 
        !           463:        s = salloc(strlen(LIB_PATH) + strlen(l) + 1L);
        !           464:        (void)strcat(strcpy(s, LIB_PATH), l);
        !           465: 
        !           466:        if ((fd = open(s, 0)) == SYSERROR)
        !           467:        {
        !           468:                if (errno == ENOENT)
        !           469:                        fprintf(stderr, "%s: no library '-l%s'\n", my_name, l);
        !           470:                else
        !           471:                {
        !           472:                        fprintf(stderr, "%s: could not open ", my_name);
        !           473:                        fflush(stderr);
        !           474:                        perror(s);
        !           475:                }
        !           476: 
        !           477:                exit(1);
        !           478:        }
        !           479: 
        !           480:        read_obj(s, fd);
        !           481:        free(s);
        !           482:        (void)close(fd);
        !           483: }
        !           484: 
        !           485: /*
        !           486:  *     Open an object file and load it.
        !           487:  */
        !           488: void
        !           489: load_obj(s)
        !           490: register char  *s;
        !           491: {
        !           492:        register int    fd;
        !           493: 
        !           494:        if ((fd = open(s, 0)) == SYSERROR)
        !           495:        {
        !           496:                fprintf(stderr, "%s: could not open ", my_name);
        !           497:                fflush(stderr);
        !           498:                perror(s);
        !           499:                exit(1);
        !           500:        }
        !           501: 
        !           502:        read_obj(s, fd);
        !           503:        (void)close(fd);
        !           504: }

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