Return to c13.c CVS log

Up to [Research Unix] / researchv10no / cmd / PDP11 / 11c

Annotation of researchv10no/cmd/PDP11/11c/c13.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * C second pass -- tables
        !             3:  */
        !             4: #include "c1.h"
        !             5: /*
        !             6:  * Operator dope table-- see description in c0.
        !             7:  */
        !             8: int opdope[] = {
        !             9:        000000, /* EOFC */
        !            10:        000000, /* ; */
        !            11:        000000, /* { */
        !            12:        000000, /* } */
        !            13:        036000, /* [ */
        !            14:        002000, /* ] */
        !            15:        036000, /* ( */
        !            16:        002000, /* ) */
        !            17:        014201, /* : */
        !            18:        007001, /* , */
        !            19:        000000, /* field selection */
        !            20:        000000, /* reverse field selection */
        !            21:        000001, /* temporary field selection */
        !            22:        000001, /* int->ptr */
        !            23:        000001, /* ptr->int */
        !            24:        000001, /* long->ptr */
        !            25:        000001, /* field assignment */
        !            26:        000001, /* >> unsigned */
        !            27:        000001, /* >> unsigned */
        !            28:        000000, /* 19 */
        !            29:        000400, /* name */
        !            30:        000400, /* short constant */
        !            31:        000400, /* string */
        !            32:        000400, /* float */
        !            33:        000400, /* double */
        !            34:        0000400,        /* long const */
        !            35:        000400, /* long const <= 16 bits */
        !            36:        000400, /* autoi, *r++ */
        !            37:        000400, /* autod, *--r */
        !            38:        000400, /* () empty arglist */
        !            39:        034213, /* ++pre */
        !            40:        034213, /* --pre */
        !            41:        034213, /* ++post */
        !            42:        034213, /* --post */
        !            43:        034220, /* !un */
        !            44:        034202, /* &un */
        !            45:        034220, /* *un */
        !            46:        034200, /* -un */
        !            47:        034220, /* ~un */
        !            48:        036001, /* . (structure reference) */
        !            49:        030101, /* + */
        !            50:        030001, /* - */
        !            51:        032101, /* * */
        !            52:        032001, /* / */
        !            53:        032001, /* % */
        !            54:        026061, /* >> */
        !            55:        026061, /* << */
        !            56:        020161, /* & */
        !            57:        016161, /* | */
        !            58:        016161, /* ^ */
        !            59:        036001, /* -> */
        !            60:        001000, /* int -> double */
        !            61:        001000, /* double -> int */
        !            62:        000001, /* && */
        !            63:        000001, /* || */
        !            64:        030001, /* &~ */
        !            65:        001000, /* double -> long */
        !            66:        001000, /* long -> double */
        !            67:        001000, /* integer -> long */
        !            68:        000000, /* long -> integer */
        !            69:        022005, /* == */
        !            70:        022005, /* != */
        !            71:        024005, /* <= */
        !            72:        024005, /* < */
        !            73:        024005, /* >= */
        !            74:        024005, /* > */
        !            75:        024005, /* <p */
        !            76:        024005, /* <=p */
        !            77:        024005, /* >p */
        !            78:        024005, /* >=p */
        !            79:        012213, /* += */
        !            80:        012213, /* -= */
        !            81:        012213, /* *= */
        !            82:        012213, /* /= */
        !            83:        012213, /* %= */
        !            84:        012253, /* >>= */
        !            85:        012253, /* <<= */
        !            86:        012253, /* &= */
        !            87:        012253, /* |= */
        !            88:        012253, /* ^= */
        !            89:        012213, /* = */
        !            90:        030001, /* & for tests */
        !            91:        032001, /*  * (long) */
        !            92:        032001, /*  / (long) */
        !            93:        032001, /* % (long) */
        !            94:        012253, /* &= ~ */
        !            95:        012213, /* *= (long) */
        !            96:        012213, /* / (long) */
        !            97:        012213, /* % (long) */
        !            98:        000000, /* 89 */
        !            99:        014201, /* ? */
        !           100:        026061, /* long << */
        !           101:        012253, /* long <<= */
        !           102:        000101, /* max */
        !           103:        000101, /* maxp */
        !           104:        000101, /* min */
        !           105:        000101, /* minp */
        !           106:        000001, /* , */
        !           107:        000000, /* 98 */
        !           108:        000000, /* 99 */
        !           109:        036001, /* call */
        !           110:        036000, /* mcall */
        !           111:        000000, /* goto */
        !           112:        000000, /* jump cond */
        !           113:        000000, /* branch cond */
        !           114:        000400, /* set nregs */
        !           115:        000000, /* 106 */
        !           116:        030001, /* 107 */
        !           117:        000000, /* 108 */
        !           118:        000000, /* int->char */
        !           119:        000000, /* force r0 */
        !           120:        000000, /* 111 */
        !           121:        000000, /* 112 */
        !           122:        000000, /* 113 */
        !           123:        000000, /* 114 */
        !           124:        000000, /* structure assign */
        !           125:        000001, /* struct assignment setup */
        !           126:        032001, /* unsigned / */
        !           127:        032001, /* unsigned % */
        !           128:        012213, /* unsigned /= */
        !           129:        012213, /* unsigned %= */
        !           130: };
        !           131: 
        !           132: char   *opntab[] = {
        !           133:        0,
        !           134:        0,
        !           135:        0,
        !           136:        0,
        !           137:        0,
        !           138:        0,
        !           139:        0,
        !           140:        0,
        !           141:        ":",
        !           142:        ",",
        !           143:        "field select",
        !           144:        0,
        !           145:        0,
        !           146:        "int->ptr",
        !           147:        "ptr->int",
        !           148:        "long->ptr",
        !           149:        "field assign",
        !           150:        ">>",
        !           151:        ">>",
        !           152:        0,
        !           153:        "name",
        !           154:        "short constant",
        !           155:        "string",
        !           156:        "float",
        !           157:        "double",
        !           158:        "long constant",
        !           159:        "long constant",
        !           160:        "*r++",
        !           161:        "*--r",
        !           162:        "()",
        !           163:        "++pre",
        !           164:        "--pre",
        !           165:        "++post",
        !           166:        "--post",
        !           167:        "!un",
        !           168:        "&",
        !           169:        "*",
        !           170:        "-",
        !           171:        "~",
        !           172:        ".",
        !           173:        "+",
        !           174:        "-",
        !           175:        "*",
        !           176:        "/",
        !           177:        "%",
        !           178:        ">>",
        !           179:        "<<",
        !           180:        "&",
        !           181:        "|",
        !           182:        "^",
        !           183:        "->",
        !           184:        "int->double",
        !           185:        "double->int",
        !           186:        "&&",
        !           187:        "||",
        !           188:        "&~",
        !           189:        "double->long",
        !           190:        "long->double",
        !           191:        "integer->long",
        !           192:        "long->integer",
        !           193:        "==",
        !           194:        "!=",
        !           195:        "<=",
        !           196:        "<",
        !           197:        ">=",
        !           198:        ">",
        !           199:        "<p",
        !           200:        "<=p",
        !           201:        ">p",
        !           202:        ">=p",
        !           203:        "+=",
        !           204:        "-=",
        !           205:        "*=",
        !           206:        "/=",
        !           207:        "%=",
        !           208:        ">>=",
        !           209:        "<<=",
        !           210:        "&=",
        !           211:        "|=",
        !           212:        "^=",
        !           213:        "=",
        !           214:        "& for tests",
        !           215:        "*",
        !           216:        "/",
        !           217:        "%",
        !           218:        "&= ~",
        !           219:        "*=",
        !           220:        "/=",
        !           221:        "%=",
        !           222:        0,
        !           223:        "?",
        !           224:        "<<",
        !           225:        "<<=",
        !           226:        "\\/",
        !           227:        "\\/",
        !           228:        "/\\",
        !           229:        "/\\",
        !           230:        0,
        !           231:        "call",
        !           232:        "call",
        !           233:        "call",
        !           234:        0,
        !           235:        "goto",
        !           236:        "jump cond",
        !           237:        "branch cond",
        !           238:        "set nregs",
        !           239:        "load value",
        !           240:        "ptr->integer",
        !           241:        0,
        !           242:        "int->char",
        !           243:        "force register",
        !           244:        "",
        !           245:        "",
        !           246:        "",
        !           247:        "",
        !           248:        "=structure",
        !           249:        "= (struct setup)",
        !           250:        "/",
        !           251:        "%",
        !           252:        "/=",
        !           253:        "%=",
        !           254: };
        !           255: 
        !           256: /*
        !           257:  * Strings for instruction tables.
        !           258:  */
        !           259: char   mov[]   = "mov";
        !           260: char   clr[]   = "clr";
        !           261: char   cmp[]   = "cmp";
        !           262: char   tst[]   = "tst";
        !           263: char   add[]   = "add";
        !           264: char   sub[]   = "sub";
        !           265: char   inc[]   = "inc";
        !           266: char   dec[]   = "dec";
        !           267: char   mul[]   = "mul";
        !           268: char   div[]   = "div";
        !           269: char   asr[]   = "asr";
        !           270: char   ash[]   = "ash";
        !           271: char   asl[]   = "asl";
        !           272: char   bic[]   = "bic";
        !           273: char   bic1[]  = "bic $1,";
        !           274: char   bit[]   = "bit";
        !           275: char   bit1[]  = "bit $1,";
        !           276: char   bis[]   = "bis";
        !           277: char   bis1[]  = "bis $1,";
        !           278: char   xor[]   = "xor";
        !           279: char   neg[]   = "neg";
        !           280: char   com[]   = "com";
        !           281: char   stdol[] = "*$";
        !           282: char   ashc[]  = "ashc";
        !           283: char   slmul[] = "lmul";
        !           284: char   sldiv[] = "ldiv";
        !           285: char   slrem[] = "lrem";
        !           286: char   almul[] = "almul";
        !           287: char   aldiv[] = "aldiv";
        !           288: char   alrem[] = "alrem";
        !           289: char   udiv[]  = "udiv";
        !           290: char   urem[]  = "urem";
        !           291: char   jeq[]   = "jeq";
        !           292: char   jne[]   = "jne";
        !           293: char   jle[]   = "jle";
        !           294: char   jgt[]   = "jgt";
        !           295: char   jlt[]   = "jlt";
        !           296: char   jge[]   = "jge";
        !           297: char   jlos[]  = "jlos";
        !           298: char   jhi[]   = "jhi";
        !           299: char   jlo[]   = "jlo";
        !           300: char   jhis[]  = "jhis";
        !           301: char   nop[]   = "/nop";
        !           302: char   jbr[]   = "jbr";
        !           303: 
        !           304: /*
        !           305:  * Instruction tables, accessed by
        !           306:  * I (first operand) or I' (second) macros.
        !           307:  */
        !           308: 
        !           309: struct instab instab[] = {
        !           310:        LOAD,   mov,    tst,
        !           311:        ASSIGN, mov,    clr,
        !           312:        EQUAL,  cmp,    tst,
        !           313:        NEQUAL, cmp,    tst,
        !           314:        LESSEQ, cmp,    tst,
        !           315:        LESS,   cmp,    tst,
        !           316:        GREATEQ,cmp,    tst,
        !           317:        GREAT,  cmp,    tst,
        !           318:        LESSEQP,cmp,    tst,
        !           319:        LESSP,  cmp,    tst,
        !           320:        GREATQP,cmp,    tst,
        !           321:        GREATP, cmp,    tst,
        !           322:        PLUS,   add,    inc,
        !           323:        ASPLUS, add,    inc,
        !           324:        MINUS,  sub,    dec,
        !           325:        ASMINUS,sub,    dec,
        !           326:        INCBEF, add,    inc,
        !           327:        DECBEF, sub,    dec,
        !           328:        INCAFT, add,    inc,
        !           329:        DECAFT, sub,    dec,
        !           330:        TIMES,  mul,    mul,
        !           331:        ASTIMES,mul,    mul,
        !           332:        DIVIDE, div,    div,
        !           333:        ASDIV,  div,    div,
        !           334:        MOD,    div,    div,
        !           335:        ASMOD,  div,    div,
        !           336:        PTOI,   div,    div,
        !           337:        RSHIFT, ash,    asr,
        !           338:        ASRSH,  ash,    asr,
        !           339:        LSHIFT, ash,    asl,
        !           340:        ASLSH,  ash,    asl,
        !           341:        AND,    bic,    bic1,
        !           342:        ANDN,   bic,    bic1,
        !           343:        ASANDN, bic,    bic1,
        !           344:        TAND,   bit,    bit1,
        !           345:        OR,     bis,    bis1,
        !           346:        ASOR,   bis,    bis1,
        !           347:        EXOR,   xor,    xor,
        !           348:        ASXOR,  xor,    xor,
        !           349:        NEG,    neg,    neg,
        !           350:        COMPL,  com,    com,
        !           351:        CALL1,  stdol,  stdol,
        !           352:        CALL2,  "",     "",
        !           353:        LLSHIFT,ashc,   ashc,
        !           354:        ASLSHL, ashc,   ashc,
        !           355:        LTIMES, slmul,  slmul,
        !           356:        LDIV,   sldiv,  sldiv,
        !           357:        LMOD,   slrem,  slrem,
        !           358:        LASTIMES,almul, almul,
        !           359:        LASDIV, aldiv,  aldiv,
        !           360:        LASMOD, alrem,  alrem,
        !           361:        ULSH,   ashc,   ashc,
        !           362:        ASULSH, ashc,   ashc,
        !           363:        UDIV,   udiv,   udiv,
        !           364:        UMOD,   urem,   urem,
        !           365:        ASUDIV, udiv,   udiv,
        !           366:        ASUMOD, urem,   urem,
        !           367:        0,      0,      0};
        !           368: 
        !           369: /*
        !           370:  * Similar table for relationals.
        !           371:  * The first string is for the positive
        !           372:  * test, the second for the inverted one.
        !           373:  * The '200+' entries are 
        !           374:  * used in tests against 0 where a 'tst'
        !           375:  * instruction is used; it clears the c-bit
        !           376:  * the c-bit so ptr tests are funny.
        !           377:  */
        !           378: struct instab branchtab[] = {
        !           379:        EQUAL,  jeq,    jne,
        !           380:        NEQUAL, jne,    jeq,
        !           381:        LESSEQ, jle,    jgt,
        !           382:        LESS,   jlt,    jge,
        !           383:        GREATEQ,jge,    jlt,
        !           384:        GREAT,  jgt,    jle,
        !           385:        LESSEQP,jlos,   jhi,
        !           386:        LESSP,  jlo,    jhis,
        !           387:        GREATQP,jhis,   jlo,
        !           388:        GREATP, jhi,    jlos,
        !           389:        200+EQUAL,      jeq,    jne,
        !           390:        200+NEQUAL,     jne,    jeq,
        !           391:        200+LESSEQ,     jle,    jgt,
        !           392:        200+LESS,       jlt,    jge,
        !           393:        200+GREATEQ,    jge,    jlt,
        !           394:        200+GREAT,      jgt,    jle,
        !           395:        200+LESSEQP,    jeq,    jne,
        !           396:        200+LESSP,      nop,    jbr,
        !           397:        200+GREATQP,    jbr,    nop,
        !           398:        200+GREATP,     jne,    jeq,
        !           399:        0,      0,      0 };

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