Return to c22.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / c2

Annotation of 3BSD/cmd/c2/c22.c, revision 1.1

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

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