Return to makebuf.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / bsc / cmd / 3270

Annotation of cci/usr/src/usr.bin/bsc/cmd/3270/makebuf.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: FILE * f;
        !             3: char buf[133];
        !             4: int cc,count;
        !             5: 
        !             6: main(argc,argv)
        !             7: char *argv[];
        !             8: int argc;
        !             9: {
        !            10:        long ftell(), where1, where2;
        !            11:        f = fopen(argv[1],"w");
        !            12: top:
        !            13:        where1 = ftell(f);
        !            14:        count = 0;
        !            15:        putw(count,f);
        !            16:        fputc(0x27,f);  /* ESC */
        !            17:        ++count;
        !            18:        puts("Cmd code: (1 - Write, 2 - Rdbuf, 5 - Erase/Write, ");
        !            19:        puts("           6 - Rdmod, 7 - Copy, ? - EAU) ");
        !            20:        gets(buf);
        !            21:        ascebc(buf,1);
        !            22:        fputc(buf[0],f); ++count;
        !            23:        ebcasc(buf,1);
        !            24:        if (buf[0] == '1' || buf[0] == '5') {
        !            25:                puts("WCC: Print format (0 - var., 1 - 40, 2 - 64, 3 - 80)");
        !            26:                gets(buf);
        !            27:                cc = ((buf[0] - '0') << 4) | 0x40;
        !            28:                puts("     Start Print: (1/0)");
        !            29:                gets(buf);
        !            30:                if (buf[0] == '1') cc |= 0x08;
        !            31:                puts("     Sound Alarm: (1/0)");
        !            32:                gets(buf);
        !            33:                if (buf[0] == '1') cc |= 0x04;
        !            34:                puts("     Restore Keyboard: (1/0)");
        !            35:                gets(buf);
        !            36:                if (buf[0] == '1') cc |= 0x02;
        !            37:                puts("     Reset MDT Bits: (1/0)");
        !            38:                gets(buf);
        !            39:                if (buf[0] == '1') cc |= 0x01;
        !            40:                fputc(cc,f); ++count;
        !            41:                puts("Orders and/or Buffer Data: (ESC/CR to enter Order)");
        !            42:                for (gets(buf); buf[0]; gets(buf)) {
        !            43:                        if (buf[0] == 033) {    /* Order */
        !            44:                                puts("  Order: 1=SF 2=SBA 3=IC 4=PT 5=RA 6=EUA 7=EM, 8=end buffer");
        !            45:                                gets(buf);
        !            46:                                switch (buf[0]-'0') {
        !            47:                                case 1: /* SF, followed by attr char */
        !            48:                                        fputc(0x1d,f); ++count;
        !            49:                                        cc = 0x40;
        !            50:                                        puts("Attr Char: Protected: (1/0)");
        !            51:                                        gets(buf);
        !            52:                                        if (buf[0] == '1') cc |= 0x20;
        !            53:                                        puts("           Numeric: (1/0)");
        !            54:                                        gets(buf);
        !            55:                                        if (buf[0] == '1') cc |= 0x10;
        !            56:                                        puts("           Display:0=yes 2=hl 3=invis");
        !            57:                                        gets(buf);
        !            58:                                        cc |= ((buf[0] - '0') << 2);
        !            59:                                        puts("           MDT: (1/0)");
        !            60:                                        gets(buf);
        !            61:                                        if (buf[0] == '1') cc |= 0x01;
        !            62:                                        fputc(cc,f); ++count;
        !            63:                                        break;
        !            64:                                case 2: /* SBA, followed by addr */
        !            65:                                        fputc(0x11,f); ++count;
        !            66:                                        doaddr();
        !            67:                                        break;
        !            68:                                case 3:  /* IC */
        !            69:                                        fputc(0x13,f); ++count;
        !            70:                                        break;
        !            71:                                case 4:  /* PT */
        !            72:                                        fputc(0x05,f); ++count;
        !            73:                                        break;
        !            74:                                case 5: /* RA, followed by addr and char  */
        !            75:                                        fputc(0x3c,f); ++count;
        !            76:                                        doaddr();
        !            77:                                        puts("Character to repeat:");
        !            78:                                        gets(buf);
        !            79:                                        ascebc(buf,1);
        !            80:                                        fputc(buf[0],f); ++count;
        !            81:                                        break;
        !            82:                                case 6: /* EUA, then addr */
        !            83:                                        fputc(0x12,f); ++count;
        !            84:                                        doaddr();
        !            85:                                        break;
        !            86:                                /* case 3:  newline 
        !            87:                                        fputc(0x15,f); ++count;
        !            88:                                        break;
        !            89:                                case 4:  form feed 
        !            90:                                        fputc(0x0c,f); ++count;
        !            91:                                        break;
        !            92:                                case 5: carriage return 
        !            93:                                        fputc(0x0d,f); ++count;
        !            94:                                        break;
        !            95:                                
        !            96:                                case 6:  SI 
        !            97:                                        fputc(0x0f,f); ++count;
        !            98:                                        break;  */
        !            99:                                case 7: /* EM */
        !           100:                                        fputc(0x19,f); ++count;
        !           101:                                        break;
        !           102:                                case 8: /* end buffer, start new one */
        !           103:                                startnew:
        !           104:                                        puts("Start new or Quit (s/q):");
        !           105:                                        gets(buf);
        !           106:                                        where2 = ftell(f);
        !           107:                                        fseek(f, where1, 0);
        !           108:                                        putw(count,f);
        !           109:                                        if (buf[0] == 's' || buf[0] == 'S') {
        !           110:                                                fseek(f, where2, 0);
        !           111:                                                goto top;
        !           112:                                        }
        !           113:                                        fclose(f);
        !           114:                                        exit(0);
        !           115:                                }
        !           116:                        }
        !           117:                        else    {  /* data */
        !           118:                                ascebc(buf,strlen(buf));
        !           119:                                fputs(buf,f);
        !           120:                                count += strlen(buf);
        !           121:                        }               
        !           122:                }
        !           123:        }
        !           124:        goto startnew;
        !           125: }
        !           126: char eadr_tbl[] = {    /* EBCDIC hex cursor address encoding table */
        !           127:        0x40,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0x4a,0x4b,
        !           128:        0x4c,0x4d,0x4e,0x4f,0x50,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,
        !           129:        0xd8,0xd9,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,0x60,0x61,0xe2,0xe3,
        !           130:        0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,
        !           131:        0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0x7a,0x7b,
        !           132:        0x7c,0x7d,0x7e,0x7f};
        !           133: doaddr() {
        !           134:        puts("Address (0-1919):");
        !           135:        gets(buf);
        !           136:        cc = atoi(buf);
        !           137:        fputc(eadr_tbl[cc/64],f); ++count;
        !           138:        cc &= 0x3f;
        !           139:        fputc(eadr_tbl[cc],f); ++count;
        !           140: }

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