Return to port.h CVS log

Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / fonts / compiler

Annotation of researchv9/X11/src/X.V11R1/fonts/compiler/port.h, revision 1.1.1.1

1.1       root        1: /* $Header: port.h,v 1.1 87/09/11 07:56:24 toddb Exp $ */
                      2: /*
                      3:  * The portable font format has the following properties:
                      4:  *     little-endian 16 and 32-bit integers
                      5:  *     no padding in structures
                      6:  *     lowest-addressed byte of a bitmap is leftmost on screen
                      7:  *     least-significant bit within a byte of a bitmap is leftmost on screen
                      8:  *     bitmaps are padded only to byte boundaries
                      9:  *
                     10:  * The "native" font format has the following properties:
                     11:  *     native-ended 16 and 32-bit integers
                     12:  *     padding in structures is that of the compiler with which the converter
                     13:  *             is compiled
                     14:  *     byte ordering along a scanline is set by a command-line option
                     15:  *     bit ordering within a byte of a bitmap is set by a command-line option
                     16:  *     bitmaps are padded only to byte boundaries
                     17:  */
                     18: #ifndef u_char
                     19: #define u_char unsigned char
                     20: #endif
                     21: 
                     22: /*
                     23:  * put i into 32 portable bits
                     24:  */
                     25: #define p32( i, pb)    \
                     26:        (pb)[0] =  i & 0xff;    \
                     27:        (pb)[1] = (i & 0xff00) >> 8;    \
                     28:        (pb)[2] = (i & 0xff0000) >> 16; \
                     29:        (pb)[3] = (i & 0xff000000) >> 24;
                     30: 
                     31: /*
                     32:  * put i into 16 portable bits
                     33:  */
                     34: #define p16( i, pb)    \
                     35:        (pb)[0] =  i & 0xff;    \
                     36:        (pb)[1] = (i & 0xff00) >> 8;
                     37: 
                     38: /*
                     39:  * naturalize 32 portable bits
                     40:  */
                     41: #define n32( p32)      \
                     42:        (((((u_char *)(p32))[3] << 8 | ((u_char *)(p32))[2]) << 8 | ((u_char *)(p32))[1]) << 8 | ((u_char *)(p32))[0])
                     43: 
                     44: /*
                     45:  * naturalize 16 portable bits
                     46:  */
                     47: #define n16( p16)      \
                     48:        (((u_char *)(p16))[1] << 8 | ((u_char *)(p16))[0])
                     49: 
                     50: 
                     51: /*
                     52:  * These increment the byte pointer as well.
                     53:  * no return value
                     54:  */
                     55: #define port32( pb, i) \
                     56:        p32( i, pb);    \
                     57:        pb += 4;
                     58: 
                     59: #define port16( pb, i) \
                     60:        p16( i, pb);    \
                     61:        pb += 2;
                     62: 
                     63: #define nat32( pb, i)  \
                     64:        i = n32( pb);   \
                     65:        pb += 4;
                     66: 
                     67: #define nat16( pb, i)  \
                     68:        i = n16( pb);   \
                     69:        pb += 2;
                     70: 
                     71: 
                     72: unsigned char  _b32[4];        /* a hidden temporary */
                     73: /*
                     74:  * These increment the file pointer as well.
                     75:  * Don't put more than one of these macros in an expression!
                     76:  * no return values
                     77:  */
                     78: #define put32( i, fp)  \
                     79:        p32( (i), _b32);        \
                     80:        fwrite( _b32, 4, 1, (fp));
                     81: 
                     82: #define put16( i, fp)  \
                     83:        p16( (i), _b32);        \
                     84:        fwrite( _b32, 2, 1, (fp));
                     85: 
                     86: #define get32( i, fp)  \
                     87:        ( fread( _b32, 4, 1, (fp)), g32( _b32))
                     88: 
                     89: #define get16( i, fp)  \
                     90:        ( fread( _b32, 2, 1, (fp)), g16( _b32))

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