Return to fontgen.c CVS log

Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / tools

Annotation of coherent/d/PS2_KERNEL/tools/fontgen.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * fontgen - generate 16x8 font assembler source on stdout.
                      3:  */
                      4: 
                      5: #define        BIT(n)  (1 << (n))
                      6: #define        BITS(n) (((n) >= 4) ? (3 << (((n) - 4) * 2)) : (3 << (((n) + 4) * 2)))
                      7: 
                      8: unsigned char ibuf[1024];
                      9: unsigned char odef[] = "\tB________ = 0000000\n";
                     10: unsigned char obuf[] = "\t.word\tB________\n";
                     11: 
                     12: main()
                     13: {
                     14:        register unsigned s;
                     15:        register unsigned j;
                     16:        register unsigned i;
                     17:        extern long lseek();
                     18: 
                     19:        /*
                     20:         * Read fonts from /dev/mem at offset 0xFFA6E.
                     21:         */
                     22:        close(0);
                     23:        if (open("/dev/mem", 0) != 0)
                     24:                fatal("/dev/mem: can't open\n");
                     25:        if (lseek( 0, 0xFFA6EL, 0) != 0xFFA6EL)
                     26:                fatal("/dev/mem: can't seek to fonts");
                     27:        if (read( 0, ibuf, sizeof ibuf ) != sizeof ibuf)
                     28:                fatal("/dev/mem: can't read fonts");
                     29: 
                     30:        /*
                     31:         * Define symbolic constants.
                     32:         */
                     33:        for (i=0; i < 256; ++i) {
                     34:                /* Generate constant's name. */
                     35:                s = i;
                     36:                for (j=10; --j >= 2; s>>=1)
                     37:                        odef[j] = (s&1) ? 'X' : '_';
                     38: 
                     39:                /* Convert 8 pixel width to 16 pixels */
                     40:                s = 0;
                     41:                for (j=0; j < 8; ++j)
                     42:                        if (i & BIT(j))
                     43:                                s |= BITS(j);
                     44: 
                     45:                /* Generate constant's value */
                     46:                for (j=19; j >= 14; --j) {
                     47:                        odef[j] = (s & 7) + '0';
                     48:                        s >>= 3;
                     49:                }
                     50: 
                     51:                /* Print constant's name and value */
                     52:                send( odef );
                     53:        }
                     54:        send( "\n\t.globl\tfontw_\nfontw_:" );
                     55: 
                     56:        /*
                     57:         * Define fonts for 128 characters.
                     58:         */
                     59:        for (i=0; i < sizeof ibuf; ++i) {
                     60: 
                     61:                /* Format and print one pixel line */
                     62:                j = 16;
                     63:                s = ibuf[i];
                     64:                while ( --j >= 8 ) {
                     65:                        obuf[j] = (s&1) ? 'X' : '_' ;
                     66:                        s >>= 1;
                     67:                }
                     68:                send( obuf );
                     69: 
                     70:                /* Insert blank line between characters for readability */
                     71:                if ( (i & 7) == 7 )
                     72:                        send( "\n" );
                     73:        }
                     74:        exit( 0 );
                     75: }
                     76: 
                     77: /*
                     78:  * Fatal( msg ) - report error, and abort.
                     79:  */
                     80: 
                     81: fatal( msg )
                     82: register char *msg;
                     83: {
                     84:        write( 2, msg, strlen(msg) );
                     85:        exit( 1 );
                     86: }
                     87: 
                     88: /*
                     89:  * send( s ) - write null-terminated string to standard output.
                     90:  */
                     91: 
                     92: send( s )
                     93: register char *s;
                     94: {
                     95:        write( 1, s, strlen(s) );
                     96: }

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