Return to ans2msg.c CVS log

Up to [Synchronet] / sbbs / sbbs2 / ans2msg

Annotation of sbbs/sbbs2/ans2msg/ans2msg.c, revision 1.1

1.1     ! root        1: /* ANS2MSG.C */
        !             2: 
        !             3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
        !             4: 
        !             5: /* Convert ANSI messages to Synchronet .MSG (Ctrl-A code) format */
        !             6: 
        !             7: #include <stdio.h>
        !             8: #include <conio.h>
        !             9: 
        !            10: int main(int argc, char **argv)
        !            11: {
        !            12:        char esc,n[25],ni;
        !            13:        int i,ch;
        !            14:        FILE *in,*out;
        !            15: 
        !            16: if(argc<3) {
        !            17:        printf("\nANS2MSG v1.06\n");
        !            18:        printf("\nusage: ans2msg infile.ans outfile.msg\n");
        !            19:        exit(0); }
        !            20: 
        !            21: if((in=fopen(argv[1],"rb"))==NULL) {
        !            22:        printf("\nerror opening %s\n",argv[1]);
        !            23:        exit(1); }
        !            24: 
        !            25: if((out=fopen(argv[2],"wb"))==NULL) {
        !            26:        printf("\nerror opening %s\n",argv[2]);
        !            27:        exit(1); }
        !            28: 
        !            29: esc=0;
        !            30: while((ch=fgetc(in))!=EOF) {
        !            31:        if(ch=='[' && esc) {    /* ANSI escape sequence */
        !            32:                ni=0;                           /* zero number index */
        !            33:                while((ch=fgetc(in))!=EOF) {
        !            34:                        if(isdigit(ch)) {                       /* 1 digit */
        !            35:                                n[ni]=ch&0xf;
        !            36:                                ch=fgetc(in);
        !            37:                                if(ch==EOF)
        !            38:                                        break;
        !            39:                                if(isdigit(ch)) {               /* 2 digits */
        !            40:                                        n[ni]*=10;
        !            41:                                        n[ni]+=ch&0xf;
        !            42:                                        ch=fgetc(in);
        !            43:                                        if(ch==EOF)
        !            44:                                                break;
        !            45:                                        if(isdigit(ch)) {       /* 3 digits */
        !            46:                                                n[ni]*=10;
        !            47:                                                n[ni]+=ch&0xf;
        !            48:                                                ch=fgetc(in); } }
        !            49:                                ni++; }
        !            50:                        if(ch==';')
        !            51:                                continue;
        !            52:                        switch(ch) {
        !            53:                                case '=':
        !            54:                                case '?':
        !            55:                                        ch=fgetc(in);      /* First digit */
        !            56:                                        if(isdigit(ch)) ch=fgetc(in);   /* l or h ? */
        !            57:                                        if(isdigit(ch)) ch=fgetc(in);
        !            58:                                        if(isdigit(ch)) fgetc(in);
        !            59:                                        break;
        !            60:                                case 'J':
        !            61:                                        if(n[0]==2)                                     /* clear screen */
        !            62:                                                fputs("\1l",out);           /* ctrl-al */
        !            63:                                        break;
        !            64:                                case 'K':
        !            65:                                        fputs("\1>",out);               /* clear to eol */
        !            66:                                        break;
        !            67:                                case 'm':
        !            68:                                        for(i=0;i<ni;i++) {
        !            69:                                                fputc(1,out);                           /* ctrl-ax */
        !            70:                                                switch(n[i]) {
        !            71:                                                        default:
        !            72:                                                        case 0:
        !            73:                                                        case 2:                                 /* no attribute */
        !            74:                                                                fputc('n',out);
        !            75:                                                                break;
        !            76:                                                        case 1:                                 /* high intensity */
        !            77:                                                                fputc('h',out);
        !            78:                                                                break;
        !            79:                                                        case 3:
        !            80:                                                        case 4:
        !            81:                                                        case 5:                                 /* blink */
        !            82:                                                        case 6:
        !            83:                                                        case 7:
        !            84:                                                                fputc('i',out);
        !            85:                                                                break;
        !            86:                                                        case 8:                                 /* concealed */
        !            87:                                                                fputc('e',out);
        !            88:                                                                break;
        !            89:                                                        case 30:
        !            90:                                                                fputc('k',out);
        !            91:                                                                break;
        !            92:                                                        case 31:
        !            93:                                                                fputc('r',out);
        !            94:                                                                break;
        !            95:                                                        case 32:
        !            96:                                                                fputc('g',out);
        !            97:                                                                break;
        !            98:                                                        case 33:
        !            99:                                                                fputc('y',out);
        !           100:                                                                break;
        !           101:                                                        case 34:
        !           102:                                                                fputc('b',out);
        !           103:                                                                break;
        !           104:                                                        case 35:
        !           105:                                                                fputc('m',out);
        !           106:                                                                break;
        !           107:                                                        case 36:
        !           108:                                                                fputc('c',out);
        !           109:                                                                break;
        !           110:                                                        case 37:
        !           111:                                                                fputc('w',out);
        !           112:                                                                break;
        !           113:                                                        case 40:
        !           114:                                                                fputc('0',out);
        !           115:                                                                break;
        !           116:                                                        case 41:
        !           117:                                                                fputc('1',out);
        !           118:                                                                break;
        !           119:                                                        case 42:
        !           120:                                                                fputc('2',out);
        !           121:                                                                break;
        !           122:                                                        case 43:
        !           123:                                                                fputc('3',out);
        !           124:                                                                break;
        !           125:                                                        case 44:
        !           126:                                                                fputc('4',out);
        !           127:                                                                break;
        !           128:                                                        case 45:
        !           129:                                                                fputc('5',out);
        !           130:                                                                break;
        !           131:                                                        case 46:
        !           132:                                                                fputc('6',out);
        !           133:                                                                break;
        !           134:                                                        case 47:
        !           135:                                                                fputc('7',out);
        !           136:                                                                break; } }
        !           137:                                        break;
        !           138:                                case 'C':
        !           139:                                        fprintf(out,"\1%c",0x7f+n[0]);
        !           140:                                        break;
        !           141:                                default:
        !           142:                                        printf("Unsupported ANSI code '%c'\r\n",ch);
        !           143:                                        break; }
        !           144:                        break; }        /* end of while */
        !           145:                esc=0;
        !           146:                continue; }     /* end of ANSI expansion */
        !           147:        if(ch=='\x1b')
        !           148:                esc=1;
        !           149:        else {
        !           150:                esc=0;
        !           151:                fputc(ch,out); } }
        !           152: fcloseall();
        !           153: return(0);
        !           154: }
        !           155: 

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