Return to options.h CVS log

Up to [UNIX Amiga Emulator] / uae / src / include

Annotation of uae/src/include/options.h, revision 1.1

1.1     ! root        1:  /*
        !             2:   * UAE - The Un*x Amiga Emulator
        !             3:   *
        !             4:   * cpp magic
        !             5:   *
        !             6:   * Copyright 1995, 1996 Bernd Schmidt, Ed Hanway
        !             7:   */
        !             8: 
        !             9: #define UAEMAJOR 0
        !            10: #define UAEMINOR 6
        !            11: #define UAEURSAMINOR 4
        !            12: 
        !            13: typedef enum { KBD_LANG_US, KBD_LANG_DE, KBD_LANG_SE, KBD_LANG_FR, KBD_LANG_IT } KbdLang;
        !            14: 
        !            15: extern int version;
        !            16: extern int framerate;
        !            17: extern int produce_sound;
        !            18: extern int correct_aspect;
        !            19: extern int use_fast_draw;
        !            20: extern int use_debugger;
        !            21: extern int use_serial;
        !            22: extern int illegal_mem;
        !            23: extern int use_fast_mem;
        !            24: extern int use_gfxlib;
        !            25: extern int no_xhair;
        !            26: extern int use_lores;
        !            27: extern int automount_uaedev;
        !            28: extern int fake_joystick;
        !            29: extern KbdLang keyboard_lang;
        !            30: extern int color_mode;
        !            31: extern int screen_res;
        !            32: extern int sound_desired_bits;
        !            33: extern int sound_desired_freq;
        !            34: extern int sound_desired_bsiz;
        !            35: extern int allow_save;
        !            36: extern int no_gui;
        !            37: extern long hardfile_size;
        !            38: 
        !            39: /* Contains the filename of .uaerc */
        !            40: extern char optionsfile[];
        !            41: 
        !            42: /* AIX doesn't think it is Unix. Neither do I. */
        !            43: #if defined(_ALL_SOURCE) || defined(_AIX)
        !            44: #undef __unix
        !            45: #define __unix
        !            46: #endif
        !            47: 
        !            48: #define MAX_COLOR_MODES 5
        !            49: #define MAX_SCREEN_MODES 4
        !            50: 
        !            51: extern void target_specific_usage(void);
        !            52: 
        !            53: extern char df0[], df1[], df2[], df3[], romfile[], prtname[], sername[];
        !            54: 
        !            55: #ifndef __unix
        !            56: extern void parse_cmdline(int argc, char **argv);
        !            57: #endif
        !            58: 
        !            59: #ifdef __mac__
        !            60: /* Apparently, no memcpy :-/ */
        !            61: static __inline__ void *memcpy(void *to, void *from, int size)
        !            62: {
        !            63:     BlockMove(from, to, size);
        !            64: }
        !            65: #endif
        !            66: 
        !            67: /* strdup() may be non-portable if you have a weird system */
        !            68: static char *my_strdup(const char*s)
        !            69: {
        !            70:     /* The casts to char * are there to shut up the compiler on HPUX */
        !            71:     char *x = (char*)malloc(strlen((char *)s) + 1);
        !            72:     strcpy(x, (char *)s);
        !            73:     return x;
        !            74: }
        !            75: 
        !            76: #undef REGPARAM
        !            77: #define fast_memcmp memcmp
        !            78: #define memcmpy generic_memcmpy
        !            79: 
        !            80: static __inline__ int generic_memcmpy(void *foo, const void *bar, int len)
        !            81: {
        !            82:     int res = memcmp(foo, bar, len);
        !            83:     if (res)
        !            84:        memcpy(foo, bar, len);
        !            85:     return res;
        !            86: }
        !            87: 
        !            88: #if defined(__GNUC_MINOR__)
        !            89: 
        !            90: #ifdef __i386__
        !            91: 
        !            92: #define INTEL_FLAG_OPT
        !            93: 
        !            94: #undef fast_memcmp
        !            95: #undef memcmpy
        !            96: 
        !            97: /*
        !            98:  * Careful: These inline functions may be used only _once_. We'd want to 
        !            99:  * generate unique labels for each inline function, but unfortunately not each
        !           100:  * installation of GCC comes with GAS. Bletch.
        !           101:  */
        !           102: 
        !           103: static __inline__ int fast_memcmp(const void *foo, const void *bar, int len)
        !           104: {
        !           105:     int differs, baz;
        !           106:     __asm__ __volatile__ ("subl $4, %2\n"
        !           107:                          "jc  LLA2\n"
        !           108:                          "LLA1:\n"
        !           109:                          "movl (%0),%%ebx\n"
        !           110:                          "cmpl (%1),%%ebx\n"
        !           111:                          "jne LLA5\n"
        !           112:                          "addl $4, %0\n"
        !           113:                          "addl $4, %1\n"
        !           114:                          "subl $4, %2\n"
        !           115:                          "jnc  LLA1\n"
        !           116:                          "LLA2:\n"
        !           117:                          "addl $4, %2\n"
        !           118:                          "jz LLA4\n"
        !           119:                          "LLA3:\n"
        !           120:                          "movb (%0),%%bl\n"
        !           121:                          "cmpb (%1),%%bl\n"
        !           122:                          "jne LLA5\n"
        !           123:                          "incl %0\n"
        !           124:                          "incl %1\n"
        !           125:                          "decl %2\n"
        !           126:                          "jnz LLA3\n"
        !           127:                          "LLA4:\n"
        !           128:                          "movl $0, %3\n"
        !           129:                          "jmp LLA6\n"
        !           130:                          "LLA5:\n"
        !           131:                          "movl $1, %3\n"
        !           132:                          "LLA6:\n"
        !           133:                          : "=&r" (foo), "=&r" (bar), "=&rm" (len), "=rm" (differs),
        !           134:                            "=&b" (baz)
        !           135:                          : "0" (foo), "1" (bar), "2" (len), "3" (baz) : "cc");
        !           136:     return differs;
        !           137: }
        !           138: 
        !           139: static __inline__ int memcmpy(void *foo, const void *bar, int len)
        !           140: {
        !           141:     int differs, baz = 0, uupzuq = 0;
        !           142: 
        !           143:     __asm__ __volatile__ ("subl %1, %2\n"
        !           144:                          "movl $0, %0\n"
        !           145:                          "subl $16, %3\n"
        !           146:                          "jc LLB7\n"
        !           147:                          
        !           148:                          "LLB8:\n"
        !           149:                          "movl (%1),%%ecx\n"
        !           150:                          "movl (%2,%1),%%ebx\n"
        !           151:                          "xorl %%ebx, %%ecx\n"
        !           152:                          "movl %%ebx, (%1)\n"
        !           153:                          "orl %%ecx, %0\n"
        !           154:                          
        !           155:                          "movl 4(%2,%1),%%ebx\n"
        !           156:                          "movl 4(%1),%%ecx\n"
        !           157:                          "xorl %%ebx, %%ecx\n"
        !           158:                          "movl %%ebx, 4(%1)\n"
        !           159:                          "orl %%ecx, %0\n"
        !           160:                          
        !           161:                          "movl 8(%2,%1),%%ebx\n"
        !           162:                          "movl 8(%1),%%ecx\n"
        !           163:                          "xorl %%ebx, %%ecx\n"
        !           164:                          "movl %%ebx, 8(%1)\n"
        !           165:                          "orl %%ecx, %0\n"
        !           166:                          
        !           167:                          "movl 12(%2,%1),%%ebx\n"
        !           168:                          "movl 12(%1),%%ecx\n"
        !           169:                          "xorl %%ebx, %%ecx\n"
        !           170:                          "movl %%ebx, 12(%1)\n"
        !           171:                          "orl %%ecx, %0\n"
        !           172:                          
        !           173:                          "addl $16, %1\n"
        !           174:                          "subl $16, %3\n"
        !           175:                          "jnc  LLB8\n"
        !           176:                          
        !           177:                          "LLB7:\n"
        !           178:                          "addl $16, %3\n"
        !           179:                          "subl $4, %3\n"
        !           180:                          "jc  LLB2\n"
        !           181:                          
        !           182:                          "LLB1:\n"
        !           183:                          "movl (%2,%1),%%ebx\n"
        !           184:                          "movl (%1),%%ecx\n"
        !           185:                          "xorl %%ebx, %%ecx\n"
        !           186:                          "movl %%ebx, (%1)\n"
        !           187:                          "orl %%ecx, %0\n"
        !           188:                          "addl $4, %1\n"
        !           189:                          "subl $4, %3\n"
        !           190:                          "jnc  LLB1\n"
        !           191:                          
        !           192:                          "LLB2:\n"
        !           193:                          "addl $4, %3\n"
        !           194:                          "jz LLB6\n"
        !           195:                          "xorl %%ecx, %%ecx\n"
        !           196:                          
        !           197:                          "LLB3:\n"
        !           198:                          "movb (%2,%1),%%bl\n"
        !           199:                          "movb (%1),%%cl\n"
        !           200:                          "xorb %%bl,%%cl\n"
        !           201:                          "movb %%bl,(%1)\n"
        !           202:                          "orl %%ecx, %0\n"
        !           203:                          "incl %1\n"
        !           204:                          "decl %3\n"
        !           205:                          "jnz LLB3\n"
        !           206:                          
        !           207:                          "LLB6:\n"
        !           208:                          : "=m" (differs)
        !           209:                          : "r" (foo), "r" (bar), "r" (len), "b" (baz), "c" (uupzuq) : "cc", "memory");
        !           210:     /* Now tell the compiler that foo, bar and len have been modified 
        !           211:      * If someone finds a way to express all this cleaner in constraints that
        !           212:      * GCC 2.7.2 understands, please FIXME */
        !           213:     __asm__ __volatile__ ("" : "=rm" (foo), "=rm" (bar), "=rm" (len) : :  "ebx", "ecx", "edx", "eax", "esi", "memory");
        !           214: 
        !           215:     return differs;
        !           216: }
        !           217: #endif /* __i386__ */
        !           218: 
        !           219: #if __GNUC__ > 2 || __GNUC_MINOR__ > 6
        !           220: 
        !           221: #if defined(__i386__) && !defined(USE_PROFILING)
        !           222: #define REGPARAM __attribute__((regparm(3)))
        !           223: #endif /* __i386__ */
        !           224: 
        !           225: #endif /* GCC version 2.7 or higher */
        !           226: #endif /* GCC 2 */
        !           227: 
        !           228: #ifndef REGPARAM
        !           229: #define REGPARAM
        !           230: #endif
        !           231: 
        !           232: /*
        !           233:  * You can specify numbers from 0 to 5 here. It is possible that higher
        !           234:  * numbers will make the CPU emulation slightly faster, but if the setting
        !           235:  * is too high, you will run out of memory while compiling.
        !           236:  * Best to leave this as it is.
        !           237:  */
        !           238: #define CPU_EMU_SIZE 0
        !           239: 
        !           240: #ifdef DONT_WANT_SOUND
        !           241: #undef LINUX_SOUND
        !           242: #undef AF_SOUND
        !           243: #undef SOLARIS_SOUND
        !           244: #undef SGI_SOUND
        !           245: #endif
        !           246: 
        !           247: /* #define NEED_TO_DEBUG_BADLY */
        !           248: 

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