Return to genblitter.c CVS log

Up to [UNIX Amiga Emulator] / uae

Annotation of uae/genblitter.c, revision 1.1

1.1     ! root        1:  /* 
        !             2:   * UAE - The Un*x Amiga Emulator
        !             3:   * 
        !             4:   * Optimized blitter minterm function generator
        !             5:   * 
        !             6:   * (c) 1995 Bernd Schmidt
        !             7:   */
        !             8: 
        !             9: #include <stdio.h>
        !            10: #include <string.h>
        !            11: 
        !            12: #include "config.h"
        !            13: #include "amiga.h"
        !            14: 
        !            15: static bool bitset(int mt, int bit)
        !            16: {
        !            17:     return mt & (1<<bit);
        !            18: }
        !            19: 
        !            20: int main(void)
        !            21: {
        !            22:     int minterm;
        !            23:     printf("static __inline__ UWORD blit_func(UWORD srca, UWORD srcb, UWORD srcc, UBYTE mt)\n{\nswitch(mt){\n");
        !            24:     for (minterm = 0; minterm < 256; minterm++) {
        !            25:        bool firstor = true;
        !            26:        int bits = 0;
        !            27:        int i;
        !            28:        printf("case 0x%x:\n", minterm);
        !            29:        printf("\treturn ");
        !            30:        for(i=0; i<8; i++) {
        !            31:            if (bitset(minterm, i) && !bitset(bits,i)) {
        !            32:                int j;
        !            33:                int dontcare = 0;
        !            34:                bool firstand = true;
        !            35:                int bitbucket[8], bitcount;
        !            36:                
        !            37:                bits |= 1<<i;
        !            38:                bitcount = 1; bitbucket[0] = i;
        !            39:                for(j=1; j<8; j *= 2) {
        !            40:                    bool success = true;
        !            41:                    int k;
        !            42:                    for(k=0; k < bitcount; k++) {                       
        !            43:                        if (!bitset(minterm, bitbucket[k] ^ j)) {
        !            44:                            success = false;
        !            45:                        }
        !            46:                    }
        !            47:                    if (success) {
        !            48:                        int l;
        !            49:                        dontcare |= j;
        !            50:                        for(l=bitcount; l < bitcount*2; l++) {
        !            51:                            bitbucket[l] = bitbucket[l-bitcount] ^ j;
        !            52:                            bits |= 1 << bitbucket[l];
        !            53:                        }
        !            54:                        bitcount *= 2;
        !            55:                    }
        !            56:                }
        !            57:                if (firstor) {
        !            58:                    firstor = false;
        !            59:                } else {
        !            60:                    printf(" | ");
        !            61:                }
        !            62:                for (j=1; j<8; j *= 2) {
        !            63:                    if (!(dontcare & j)) {
        !            64:                        if (firstand) {
        !            65:                            firstand = false;
        !            66:                            printf("(");
        !            67:                        } else {
        !            68:                            printf(" & ");
        !            69:                        }
        !            70:                        if (!(i & j))
        !            71:                            printf("~");
        !            72:                        printf("src%c", (j == 1 ? 'c' : j == 2 ? 'b' : 'a'));
        !            73:                    }
        !            74:                }
        !            75:                if (!firstand) {                    
        !            76:                    printf(")");
        !            77:                } else {
        !            78:                    printf("0xFFFF");
        !            79:                }
        !            80:            }
        !            81:        }
        !            82:        if (firstor)
        !            83:            printf("0");
        !            84:        printf(";\n");
        !            85:     }
        !            86:     printf("}\n");
        !            87:     printf("return 0;\n"); /* No, sir, it doesn't! */
        !            88:     printf("}\n");
        !            89:     return 0;
        !            90: }

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