Return to fontgen.c CVS log

Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io / tools

Annotation of coherent/d/286_KERNEL/USRSRC/io/tools/fontgen.c, revision 1.1.1.1

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

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