Annotation of sbbs/sbbs2/ans2msg/ans2msg.c, revision 1.1.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: 

unix.superglobalmegacorp.com

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