[BACK]Return to c22.c CVS log [TXT] [DIR] Up to [Research Unix] / researchv10no / cmd / c2

Annotation of researchv10no/cmd/c2/c22.c, revision 1.1

1.1     ! root        1: static char sccsid[] = "@(#)c22.c 4.1 10/16/80";
        !             2: #include "c2.h"
        !             3: /* char c22[] = "@(#)c22.c 1.10 80/03/14 10:27:37"; */
        !             4: #define readonly
        !             5: 
        !             6: readonly char revbr[] = {
        !             7:        JNE, JEQ, JGT, JLT, JGE, JLE,
        !             8:        JNE, JEQ, JHI, JLO, JHIS, JLOS,
        !             9:        JBS, JBC, JLBS, JLBC, JBSC, JBCC, JBSS, JBCS };
        !            10: 
        !            11: /* cursed be the preprocessor, whose impotence and stupidity
        !            12: /* prevented this table being macro-generated from ../as/instrs
        !            13: */
        !            14: readonly struct optab optab[] = {
        !            15: {"jbr",JBR},
        !            16: {"jeql",T(CBR,JEQ)},
        !            17: {"jneq",T(CBR,JNE)},
        !            18: {"jleq",T(CBR,JLE)},
        !            19: {"jgeq",T(CBR,JGE)},
        !            20: {"jlss",T(CBR,JLT)},
        !            21: {"jgtr",T(CBR,JGT)},
        !            22: {"jbc",T(CBR,JBC)},
        !            23: {"jbs",T(CBR,JBS)},
        !            24: {"jlequ",T(CBR,JLOS)},
        !            25: {"jgequ",T(CBR,JHIS)},
        !            26: {"jlssu",T(CBR,JLO)},
        !            27: {"jgtru",T(CBR,JHI)},
        !            28: {"jlbc",T(CBR,JLBC)},
        !            29: {"jlbs",T(CBR,JLBS)},
        !            30: {"jbcc",T(CBR,JBCC)},
        !            31: {"jbsc",T(CBR,JBSC)},
        !            32: {"jbcs",T(CBR,JBCS)},
        !            33: {"jbss",T(CBR,JBSS)},
        !            34: {"acbb",T(ACB,BYTE)},
        !            35: {"acbd",T(ACB,DOUBLE)},
        !            36: {"acbf",T(ACB,FLOAT)},
        !            37: {"acbl",T(ACB,LONG)},
        !            38: {"acbw",T(ACB,WORD)},
        !            39: {"addb2",T(ADD,U(BYTE,OP2))},
        !            40: {"addb3",T(ADD,U(BYTE,OP3))},
        !            41: {"addd2",T(ADD,U(DOUBLE,OP2))},
        !            42: {"addd3",T(ADD,U(DOUBLE,OP3))},
        !            43: {"addf2",T(ADD,U(FLOAT,OP2))},
        !            44: {"addf3",T(ADD,U(FLOAT,OP3))},
        !            45: {"addl2",T(ADD,U(LONG,OP2))},
        !            46: {"addl3",T(ADD,U(LONG,OP3))},
        !            47: {"addw2",T(ADD,U(WORD,OP2))},
        !            48: {"addw3",T(ADD,U(WORD,OP3))},
        !            49: {"aobleq",AOBLEQ},
        !            50: {"aoblss",AOBLSS},
        !            51: {"ashl",T(ASH,LONG)},
        !            52: {"ashq",T(ASH,QUAD)},
        !            53: {"bbc",T(CBR,JBC)},
        !            54: {"bbcc",T(CBR,JBCC)},
        !            55: {"bbcci",T(CBR,JBCC)},
        !            56: {"bbcs",T(CBR,JBCS)},
        !            57: {"bbs",T(CBR,JBS)},
        !            58: {"bbsc",T(CBR,JBSC)},
        !            59: {"bbss",T(CBR,JBSS)},
        !            60: {"bbssi",T(CBR,JBSS)},
        !            61: {"bcc",T(CBR,JHIS)},
        !            62: {"bcs",T(CBR,JLO)},
        !            63: {"beql",T(CBR,JEQ)},
        !            64: {"beqlu",T(CBR,JEQ)},
        !            65: {"bgeq",T(CBR,JGE)},
        !            66: {"bgequ",T(CBR,JHIS)},
        !            67: {"bgtr",T(CBR,JGT)},
        !            68: {"bgtru",T(CBR,JHI)},
        !            69: {"bicb2",T(BIC,U(BYTE,OP2))},
        !            70: {"bicb3",T(BIC,U(BYTE,OP3))},
        !            71: {"bicl2",T(BIC,U(LONG,OP2))},
        !            72: {"bicl3",T(BIC,U(LONG,OP3))},
        !            73: {"bicw2",T(BIC,U(WORD,OP2))},
        !            74: {"bicw3",T(BIC,U(WORD,OP3))},
        !            75: {"bisb2",T(BIS,U(BYTE,OP2))},
        !            76: {"bisb3",T(BIS,U(BYTE,OP3))},
        !            77: {"bisl2",T(BIS,U(LONG,OP2))},
        !            78: {"bisl3",T(BIS,U(LONG,OP3))},
        !            79: {"bisw2",T(BIS,U(WORD,OP2))},
        !            80: {"bisw3",T(BIS,U(WORD,OP3))},
        !            81: {"bitb",T(BIT,BYTE)},
        !            82: {"bitl",T(BIT,LONG)},
        !            83: {"bitw",T(BIT,WORD)},
        !            84: {"blbs",T(CBR,JLBS)},
        !            85: {"blbc",T(CBR,JLBC)},
        !            86: {"bleq",T(CBR,JLE)},
        !            87: {"blequ",T(CBR,JLOS)},
        !            88: {"blss",T(CBR,JLT)},
        !            89: {"blssu",T(CBR,JLO)},
        !            90: {"bneq",T(CBR,JNE)},
        !            91: {"bnequ",T(CBR,JNE)},
        !            92: {"brb",JBR},
        !            93: {"brw",JBR},
        !            94: {"bvc",T(CBR,0)},
        !            95: {"bvs",T(CBR,0)},
        !            96: {"callg",CALLS},
        !            97: {"calls",CALLS},
        !            98: {"caseb",T(CASE,BYTE)},
        !            99: {"casel",T(CASE,LONG)},
        !           100: {"casew",T(CASE,WORD)},
        !           101: {"clrb",T(CLR,BYTE)},
        !           102: {"clrd",T(CLR,DOUBLE)},
        !           103: {"clrf",T(CLR,FLOAT)},
        !           104: {"clrl",T(CLR,LONG)},
        !           105: {"clrq",T(CLR,QUAD)},
        !           106: {"clrw",T(CLR,WORD)},
        !           107: {"cmpb",T(CMP,BYTE)},
        !           108: {"cmpd",T(CMP,DOUBLE)},
        !           109: {"cmpf",T(CMP,FLOAT)},
        !           110: {"cmpl",T(CMP,LONG)},
        !           111: {"cmpw",T(CMP,WORD)},
        !           112: {"cvtbd",T(CVT,U(BYTE,DOUBLE))},
        !           113: {"cvtbf",T(CVT,U(BYTE,FLOAT))},
        !           114: {"cvtbl",T(CVT,U(BYTE,LONG))},
        !           115: {"cvtbw",T(CVT,U(BYTE,WORD))},
        !           116: {"cvtdb",T(CVT,U(DOUBLE,BYTE))},
        !           117: {"cvtdf",T(CVT,U(DOUBLE,FLOAT))},
        !           118: {"cvtdl",T(CVT,U(DOUBLE,LONG))},
        !           119: {"cvtdw",T(CVT,U(DOUBLE,WORD))},
        !           120: {"cvtfb",T(CVT,U(FLOAT,BYTE))},
        !           121: {"cvtfd",T(CVT,U(FLOAT,DOUBLE))},
        !           122: {"cvtfl",T(CVT,U(FLOAT,LONG))},
        !           123: {"cvtfw",T(CVT,U(FLOAT,WORD))},
        !           124: {"cvtlb",T(CVT,U(LONG,BYTE))},
        !           125: {"cvtld",T(CVT,U(LONG,DOUBLE))},
        !           126: {"cvtlf",T(CVT,U(LONG,FLOAT))},
        !           127: {"cvtlw",T(CVT,U(LONG,WORD))},
        !           128: {"cvtrdl",T(CVT,U(DOUBLE,LONG))},
        !           129: {"cvtrfl",T(CVT,U(FLOAT,LONG))},
        !           130: {"cvtwb",T(CVT,U(WORD,BYTE))},
        !           131: {"cvtwd",T(CVT,U(WORD,DOUBLE))},
        !           132: {"cvtwf",T(CVT,U(WORD,FLOAT))},
        !           133: {"cvtwl",T(CVT,U(WORD,LONG))},
        !           134: {"decb",T(DEC,BYTE)},
        !           135: {"decl",T(DEC,LONG)},
        !           136: {"decw",T(DEC,WORD)},
        !           137: {"divb2",T(DIV,U(BYTE,OP2))},
        !           138: {"divb3",T(DIV,U(BYTE,OP3))},
        !           139: {"divd2",T(DIV,U(DOUBLE,OP2))},
        !           140: {"divd3",T(DIV,U(DOUBLE,OP3))},
        !           141: {"divf2",T(DIV,U(FLOAT,OP2))},
        !           142: {"divf3",T(DIV,U(FLOAT,OP3))},
        !           143: {"divl2",T(DIV,U(LONG,OP2))},
        !           144: {"divl3",T(DIV,U(LONG,OP3))},
        !           145: {"divw2",T(DIV,U(WORD,OP2))},
        !           146: {"divw3",T(DIV,U(WORD,OP3))},
        !           147: {"extv",T(EXTV,LONG)},
        !           148: {"extzv",T(EXTZV,LONG)},
        !           149: {"incb",T(INC,BYTE)},
        !           150: {"incl",T(INC,LONG)},
        !           151: {"incw",T(INC,WORD)},
        !           152: {"insv",T(INSV,-1)},
        !           153: {"jmp",JMP},
        !           154: {"mcomb",T(COM,BYTE)},
        !           155: {"mcoml",T(COM,LONG)},
        !           156: {"mcomw",T(COM,WORD)},
        !           157: {"mnegb",T(NEG,BYTE)},
        !           158: {"mnegd",T(NEG,DOUBLE)},
        !           159: {"mnegf",T(NEG,FLOAT)},
        !           160: {"mnegl",T(NEG,LONG)},
        !           161: {"mnegw",T(NEG,WORD)},
        !           162: {"movab",T(MOVA,BYTE)},
        !           163: {"movad",T(MOVA,DOUBLE)},
        !           164: {"movaf",T(MOVA,FLOAT)},
        !           165: {"moval",T(MOVA,LONG)},
        !           166: {"movaq",T(MOVA,QUAD)},
        !           167: {"movaw",T(MOVA,WORD)},
        !           168: {"movb",T(MOV,BYTE)},
        !           169: {"movd",T(MOV,DOUBLE)},
        !           170: {"movf",T(MOV,FLOAT)},
        !           171: {"movl",T(MOV,LONG)},
        !           172: {"movq",T(MOV,QUAD)},
        !           173: {"movw",T(MOV,WORD)},
        !           174: {"movzbl",T(MOVZ,U(BYTE,LONG))},
        !           175: {"movzbw",T(MOVZ,U(BYTE,WORD))},
        !           176: {"movzwl",T(MOVZ,U(WORD,LONG))},
        !           177: {"mulb2",T(MUL,U(BYTE,OP2))},
        !           178: {"mulb3",T(MUL,U(BYTE,OP3))},
        !           179: {"muld2",T(MUL,U(DOUBLE,OP2))},
        !           180: {"muld3",T(MUL,U(DOUBLE,OP3))},
        !           181: {"mulf2",T(MUL,U(FLOAT,OP2))},
        !           182: {"mulf3",T(MUL,U(FLOAT,OP3))},
        !           183: {"mull2",T(MUL,U(LONG,OP2))},
        !           184: {"mull3",T(MUL,U(LONG,OP3))},
        !           185: {"mulw2",T(MUL,U(WORD,OP2))},
        !           186: {"mulw3",T(MUL,U(WORD,OP3))},
        !           187: {"pushab",T(PUSHA,BYTE)},
        !           188: {"pushad",T(PUSHA,DOUBLE)},
        !           189: {"pushaf",T(PUSHA,FLOAT)},
        !           190: {"pushal",T(PUSHA,LONG)},
        !           191: {"pushaq",T(PUSHA,QUAD)},
        !           192: {"pushaw",T(PUSHA,WORD)},
        !           193: {"pushl",T(PUSH,LONG)},
        !           194: {"ret",T(JBR,RET)},
        !           195: {"sobgeq",SOBGEQ},
        !           196: {"sobgtr",SOBGTR},
        !           197: {"subb2",T(SUB,U(BYTE,OP2))},
        !           198: {"subb3",T(SUB,U(BYTE,OP3))},
        !           199: {"subd2",T(SUB,U(DOUBLE,OP2))},
        !           200: {"subd3",T(SUB,U(DOUBLE,OP3))},
        !           201: {"subf2",T(SUB,U(FLOAT,OP2))},
        !           202: {"subf3",T(SUB,U(FLOAT,OP3))},
        !           203: {"subl2",T(SUB,U(LONG,OP2))},
        !           204: {"subl3",T(SUB,U(LONG,OP3))},
        !           205: {"subw2",T(SUB,U(WORD,OP2))},
        !           206: {"subw3",T(SUB,U(WORD,OP3))},
        !           207: {"tstb",T(TST,BYTE)},
        !           208: {"tstd",T(TST,DOUBLE)},
        !           209: {"tstf",T(TST,FLOAT)},
        !           210: {"tstl",T(TST,LONG)},
        !           211: {"tstw",T(TST,WORD)},
        !           212: {"xorb2",T(XOR,U(BYTE,OP2))},
        !           213: {"xorb3",T(XOR,U(BYTE,OP3))},
        !           214: {"xorl2",T(XOR,U(LONG,OP2))},
        !           215: {"xorl3",T(XOR,U(LONG,OP3))},
        !           216: {"xorw2",T(XOR,U(WORD,OP2))},
        !           217: {"xorw3",T(XOR,U(WORD,OP3))},
        !           218: {"movc3",T(CHRINS,U(3,5))},    /* number of operands, highest register smashed */
        !           219: {".globl",EROU},
        !           220: {".text",TEXT},
        !           221: {".data",DATA},
        !           222: {".bss",BSS},
        !           223: {".align",ALIGN},
        !           224: {".word",WGEN},
        !           225: {".long",LGEN},
        !           226: {".set",SET},
        !           227: {".lcomm",LCOMM},
        !           228: {".comm",COMM},
        !           229: {".end",END},
        !           230: {"rsb",T(JBR,RSB)},
        !           231: {"jsb",JSB},
        !           232: {"mfpr",T(MFPR,LONG)},
        !           233: {"mtpr",T(MTPR,LONG)},
        !           234: {"prober",T(PROBER,BYTE)},
        !           235: {"probew",T(PROBEW,BYTE)},
        !           236: {"adawi",0},
        !           237: {"addp4",0},
        !           238: {"addp6",0},
        !           239: {"adwc",0},
        !           240: {"ashp",0},
        !           241: {"bicpsw",0},
        !           242: {"bispsw",0},
        !           243: {"bpt",0},
        !           244: {"bsbb",0},
        !           245: {"bsbw",0},
        !           246: {"chme",0},
        !           247: {"chmk",0},
        !           248: {"chms",0},
        !           249: {"chmu",0},
        !           250: {"cmpc3",T(CHRINS, U(3,3))},
        !           251: {"cmpc5",T(CHRINS, U(5,3))},
        !           252: {"cmpp3",0},
        !           253: {"cmpp4",0},
        !           254: {"cmpv",0},
        !           255: {"cmpzv",0},
        !           256: {"crc",T(CHRINS, U(4,3))},     /* hack */
        !           257: {"cvtlp",0},
        !           258: {"cvtpl",0},
        !           259: {"cvttp",0},
        !           260: {"cvtpt",0},
        !           261: {"cvtps",0},
        !           262: {"cvtsp",0},
        !           263: {"divp",0},
        !           264: {"editpc",0},
        !           265: {"ediv",0},
        !           266: {"emodd",0},
        !           267: {"emodf",0},
        !           268: {"emul",0},
        !           269: {"ffc",0},
        !           270: {"ffs",0},
        !           271: {"halt",0},
        !           272: {"index",0},
        !           273: {"insque",0},
        !           274: {"ldpctx",0},
        !           275: {"locc",T(CHRINS, U(3,1))},
        !           276: {"matchc",T(CHRINS, U(4,3))},
        !           277: {"movc5",T(CHRINS, U(5,5))},
        !           278: {"movp",0},
        !           279: {"movpsl",0},
        !           280: {"movtc",T(CHRINS, U(6,5))},
        !           281: {"movtuc",T(CHRINS, U(6,5))},
        !           282: {"mulp",0},
        !           283: {"nop",0},
        !           284: {"polyd",0},
        !           285: {"polyf",0},
        !           286: {"popr",0},
        !           287: {"pushr",0},
        !           288: {"rei",0},
        !           289: {"remque",0},
        !           290: {"rotl",0},
        !           291: {"sbwc",0},
        !           292: {"scanc",T(CHRINS, U(4,3))},
        !           293: {"skpc",T(CHRINS, U(3,1))},
        !           294: {"spanc",T(CHRINS, U(4,3))},
        !           295: {"subp4",0},
        !           296: {"subp6",0},
        !           297: {"svpctx",0},
        !           298: {"xfc",0},
        !           299: {"escd",0},
        !           300: {"esce",0},
        !           301: {"escf",0},
        !           302: {      0,      0}
        !           303: };
unix.superglobalmegacorp.com

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