Return to asm.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / dbx

Annotation of 42BSD/ucb/dbx/asm.c, revision 1.1.1.1

1.1       root        1: /* Copyright (c) 1982 Regents of the University of California */
                      2: 
                      3: static char sccsid[] = "@(#)asm.c 1.2 12/15/82";
                      4: 
                      5: /*
                      6:  * Assembly language dependent symbol routines.
                      7:  */
                      8: 
                      9: #include "defs.h"
                     10: #include "symbols.h"
                     11: #include "asm.h"
                     12: #include "languages.h"
                     13: #include "tree.h"
                     14: #include "eval.h"
                     15: #include "operators.h"
                     16: #include "mappings.h"
                     17: #include "process.h"
                     18: #include "runtime.h"
                     19: #include "machine.h"
                     20: 
                     21: #define isdouble(range) ( \
                     22:     range->symvalue.rangev.upper == 0 and range->symvalue.rangev.lower > 0 \
                     23: )
                     24: 
                     25: /*
                     26:  * Initialize assembly language information.
                     27:  */
                     28: 
                     29: public asm_init()
                     30: {
                     31:     Language lang;
                     32: 
                     33:     lang = language_define("assembler", ".s");
                     34:     language_setop(lang, L_PRINTDECL, asm_printdecl);
                     35:     language_setop(lang, L_PRINTVAL, asm_printval);
                     36:     language_setop(lang, L_TYPEMATCH, asm_typematch);
                     37: }
                     38: 
                     39: /*
                     40:  * Test if two types are compatible.
                     41:  */
                     42: 
                     43: public Boolean asm_typematch(type1, type2)
                     44: Symbol type1, type2;
                     45: {
                     46:     Boolean b;
                     47: 
                     48:     b = false;
                     49:     return b;
                     50: }
                     51: 
                     52: public asm_printdecl(s)
                     53: Symbol s;
                     54: {
                     55:     switch (s->class) {
                     56:        case VAR:
                     57:        case REF:
                     58:            printf("&%s = 0x%x", symname(s), s->symvalue.offset);
                     59:            break;
                     60: 
                     61:        case PROC:
                     62:        case FUNC:
                     63:            printf("%s (0x%x):", symname(s), codeloc(s));
                     64:            break;
                     65: 
                     66:        default:
                     67:            error("class %s in c_printdecl", classname(s));
                     68:     }
                     69:     putchar('\n');
                     70: }
                     71: 
                     72: /*
                     73:  * Print out the value on the top of the expression stack
                     74:  * in the format for the type of the given symbol.
                     75:  */
                     76: 
                     77: public asm_printval(s)
                     78: register Symbol s;
                     79: {
                     80:     register Symbol t;
                     81:     register Integer len;
                     82: 
                     83:     switch (s->class) {
                     84:        case ARRAY:
                     85:            t = rtype(s->type);
                     86:            if (t->class == RANGE and istypename(t->type, "$char")) {
                     87:                len = size(s);
                     88:                sp -= len;
                     89:                printf("\"%.*s\"", len, sp);
                     90:            } else {
                     91:                printarray(s);
                     92:            }
                     93:            break;
                     94: 
                     95:        default:
                     96:            printf("0x%x", pop(Integer));
                     97:            break;
                     98:     }
                     99: }

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