From 1030dc837b10a03a02a85d5504cbeec168ce49e2 Mon Sep 17 00:00:00 2001 From: Bernie Innocenti Date: Mon, 03 May 2010 21:53:47 +0000 Subject: Import XaoS r489 (trunk after version 3.5) --- (limited to 'src/include') diff --git a/src/include/aconfig.h.in b/src/include/aconfig.h.in new file mode 100644 index 0000000..40d0f7e --- /dev/null +++ b/src/include/aconfig.h.in @@ -0,0 +1,60 @@ +#ifndef ACONFIG_H +#define ACONFIG_H +#undef HAVE_PTHREAD_SIGHANDLER +#undef DATAPATH +#undef C_ALLOCA +#undef const +#undef USE_PTHREAD +/*Avoid stack frame explosion on Windoze*/ +#ifndef _WIN32 +/*BeOS crashes badly when large amounts of stack are consumed */ +#ifndef __BEOS__ +#undef HAVE_ALLOCA +#undef HAVE_ALLOCA_H +#endif +#endif +#undef HAVE_FABSL +#undef HAVE__FABSL +#undef HAVE___FABSL +#undef HAVE_FTIME +#undef USE_PNG +#undef HAVE_FINITE +#undef HAVE_SELECT +#undef HAVE_LONG_DOUBLE +#undef HAVE_REDRAWWIN +#undef HAVE_WREDRAWLN +#undef USE_NCURSES +#undef inline +#undef _POSIX_SOURCE +#undef STDC_HEADERS +/* Define if you can safely include both and . */ +#undef TIME_WITH_SYS_TIME +#undef HAVE_GETTIMEOFDAY +#undef HAVE_USLEEP +#undef HAVE_TERMATTRS +#undef HAVE_MOUSEMASK +#undef HAVE_SETITIMER +/* Define if you have the header file. */ +#undef HAVE_LIMITS_H +/* Define if you have the header file. */ +#undef HAVE_SYS_TIME_H +/* Define if you have the header file. */ +#undef HAVE_UNISTD_H +#undef MITSHM +#undef CURSES_DRIVER +#undef BEOS_DRIVER +#undef AA_DRIVER +#undef GTK_DRIVER +#undef GGI_DRIVER +#undef X11_DRIVER +#undef DGA_DRIVER +#undef SVGA_DRIVER +#undef WIN32_DRIVER +#undef DDRAW_DRIVER +#undef HTML_HELP +#undef SIZEOF_SHORT +#undef SIZEOF_INT +#undef SIZEOF_LONG +#undef HAVE_GETTEXT +#undef NO_MALLOC_H +#endif diff --git a/src/include/archaccel.h b/src/include/archaccel.h new file mode 100644 index 0000000..498f028 --- /dev/null +++ b/src/include/archaccel.h @@ -0,0 +1,14 @@ +#ifndef ACCEL_H +#define ACCEL_H +#ifdef __GNUC__ +#ifdef __i386__ +#ifdef __OPTIMIZE__ +#include +#endif +#endif +#endif +#endif + +#ifndef memset_long +#define memset_long(x,y,z) memset(x,y,z) +#endif diff --git a/src/include/btrace.h b/src/include/btrace.h new file mode 100644 index 0000000..a014934 --- /dev/null +++ b/src/include/btrace.h @@ -0,0 +1,12 @@ +#ifndef BTRACE_H +#define BTRACE_H +#ifdef __cplusplus +extern "C" { +#endif + int boundarytrace(int x1, int y1, int x2, int y2, number_t * xpos, + number_t * ypos); + int boundarytraceall(number_t * xpos, number_t * ypos); +#ifdef __cplusplus +} +#endif +#endif diff --git a/src/include/c256.h b/src/include/c256.h new file mode 100644 index 0000000..5854ba1 --- /dev/null +++ b/src/include/c256.h @@ -0,0 +1,12 @@ +#ifdef cpixel_t +#undef cpixel_t +#undef cpixeldata_t +#undef cppixel_t +#undef bpp +#endif +#define cpixel_t pixel8_t +#define cppixel_t ppixel8_t +#define cpixeldata_t pixel8_t +#define bpp 1 +#include +#define bpp1 diff --git a/src/include/catalog.h b/src/include/catalog.h new file mode 100644 index 0000000..ba33f84 --- /dev/null +++ b/src/include/catalog.h @@ -0,0 +1,27 @@ +/* Small library to handle catalog files + */ +#ifndef CATALOG_H +#define CATALOG_H +#define CHASHMAX 31 /*Just small hash table. Should be OK */ +#include +#ifdef __cplusplus +extern "C" { +#endif + struct varnames { + struct varnames *left, *right; + char *name; + char *value; + }; + typedef struct catalog { + struct varnames *root[CHASHMAX]; + } catalog_t; +/*Find text in catalog */ + extern char *find_text(catalog_t * catalog, CONST char *name); +/*Load catalog from file */ + extern catalog_t *load_catalog(xio_file f, CONST char **error); +/*Free memory used by catalog */ + extern void free_catalog(catalog_t *); +#ifdef __cplusplus +} +#endif +#endif /*VARIABLE_H */ diff --git a/src/include/complex.h b/src/include/complex.h new file mode 100644 index 0000000..75b31e6 --- /dev/null +++ b/src/include/complex.h @@ -0,0 +1,63 @@ +/* + * XaoS, a fast portable realtime fractal zoomer + * Copyright (C) 1996,1997 by + * + * Jan Hubicka (hubicka@paru.cas.cz) + * Thomas Marsh (tmarsh@austin.ibm.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* Simplified version. See XaoS2.2 for full version of this library. + * It caused problems (overflows) at certain preprocesors + */ +#ifndef COMPLEX_H +#define COMPLEX_H +#include + +#define c_add(ar,ai,br,bi,or,oi) ((or)=(ar)+(br),(oi)=(ai)+(bi)) +#define c_mul(ar,ai,br,bi,or,oi) ((or)=(ar)*(br)-(ai)*(bi),(oi)=((ar)*(bi))+((ai)*(br))) + +#define c_sub(ar,ai,br,bi,or,oi) ((or)=(ar)-(br),(oi)=(ai)-(bi)) + +#define c_div_rp(ar,ai,br,bi) (((ar) * (br) + (ai) * (bi))/ ((bi) * (bi) + (br) * (br))) +#define c_div_ip(ar,ai,br,bi) ((-(ar) * (bi) + (ai) * (br)) / ((br) * (br) + (bi) * (bi))) +#define c_div(ar,ai,br,bi,or,oi) ((or)=c_div_rp(ar,ai,br,bi),(oi)=c_div_ip(ar,ai,br,bi)) + +#define c_pow2_rp(ar,ai) ((ar)*(ar)-(ai)*(ai)) +#define c_pow2_ip(ar,ai) (2*(ar)*(ai)) +#define c_pow2(ar,ai,or,oi) ((or)=c_pow2_rp(ar,ai),(oi)=c_pow2_ip(ar,ai)) + + +#define c_pow3_rp(ar,ai) ((ar)*(ar)*(ar)-3*(ar)*(ai)*(ai)) +#define c_pow3_ip(ar,ai) (3*(ar)*(ar)*(ai)-(ai)*(ai)*(ai)) +#define c_pow3(ar,ai,or,oi) ((or)=c_pow3_rp(ar,ai),(oi)=c_pow3_ip(ar,ai)) + +#define c_pow4_rp(ar,ai) ((ar)*(ar)*(ar)*(ar)-6*(ar)*(ar)*(ai)*(ai)+(ai)*(ai)*(ai)*(ai)) +#define c_pow4_ip(ar,ai) (4*(ar)*(ar)*(ar)*(ai)-4*(ar)*(ai)*(ai)*(ai)) +#define c_pow4(ar,ai,or,oi) ((or)=c_pow4_rp(ar,ai),(oi)=c_pow4_ip(ar,ai)) + + +#ifndef __GNUC__ +#ifdef INLINEFABS +#define myabs(x) INLINEFABS(x) +#else +#define myabs(x) ((x)>0?(x):-(x)) +#endif +#else +#include +#endif + +#endif /* COMPLEX_H */ diff --git a/src/include/config/aconfig.std b/src/include/config/aconfig.std new file mode 100644 index 0000000..9c10eed --- /dev/null +++ b/src/include/config/aconfig.std @@ -0,0 +1,28 @@ +/* aconfig.h. Generated automatically by configure. */ +#ifndef ACONFIG_H +#define DATAPATH "./" +#define ACONFIG_H +#define HAVE_LONG_DOUBLE 1 +#define USE_PNG +#define SIZEOF_INT 4 +#define HAVE_FINITE +#define USE_STDIO +#define SIZEOF_SHORT 2 +#define SIZEOF_LONG 4 +/* #undef inline */ +/* #undef _POSIX_SOURCE */ +#define STDC_HEADERS 1 +/* Define if you can safely include both and . */ +#define TIME_WITH_SYS_TIME 1 +#define HAVE_GETTIMEOFDAY 1 +#define HAVE_MOUSEMASK 1 +#define HAVE_USLEEP 1 +#define USE_ALLEGRO 1 +#define HAVE_UCLOCK 1 +#define HAVE_TERMATTRS 1 +#define HAVE_SETITIMER 1 +#define HAVE_LIMITS_H 1 +#define HAVE_SYS_TIME_H 1 +#define HAVE_UNISTD_H 1 +#define AA_DRIVER 1 +#endif diff --git a/src/include/config/config.autoconf b/src/include/config/config.autoconf new file mode 100644 index 0000000..8553574 --- /dev/null +++ b/src/include/config/config.autoconf @@ -0,0 +1,141 @@ +#ifndef CONFIG_H +#define CONFIG_H +#define HOMEDIR + +#ifdef __BEOS__ +#define MAIN_FUNCTION be_main +#ifdef __POWERPC__ +# define SLOWCACHESYNC +# ifdef __MWERKS__ +# define INLINEFABS(x) __fabs(x) +# endif +#endif +#endif + +#ifdef _WIN32 +#define CONFIGFILE "XaoS.cfg" +#else +#define CONFIGFILE ".XaoSrc" +#endif + +/*For compilers that don't support nameless unions, do a +#define NONAMELESSUNION +before #include */ +#ifdef _WIN32 +#define NONAMELESSUNION +#endif + +/*#define I_WAS_HERE */ /*uncoment this to disable changing of parameters by atoconf */ + +#define FPOINT_TYPE long double + /*floating point math type on computers + with medium speed floating point math should + use float instead */ +#include +#define USE_STDIO +#if !defined(HAVE_LONG_DOUBLE)&&!defined(I_WAS_HERE) +#undef FPOINT_TYPE +#define FPOINT_TYPE double +#endif +#define CONST const +#define INLINE inline + +/* BeOS have broken long double IO routines on i386. Use our replacements */ +#ifdef __BEOS__ +#ifdef __i386__ +#define USE_XLDIO +#endif +#endif + +/* Win32 don't support long double IO. Use our replacements if possible */ +#ifdef _WIN32 +#ifndef __GNUC__ +1 +/* You need to solve long double IO problems to compile XaoS on non-gcc + * compiler */ +#endif +#define USE_XLDIO +#endif + +#include "gccaccel.h" +#ifdef HAVE_MOUSEMASK +#define NCURSESMOUSE +#endif +#ifndef HAVE_LIMITS_H +#define INT_MAX 2127423647 +#endif +#ifdef SVGA_DRIVER +#define DESTICKY +#endif +#ifdef COCOA_DRIVER +#define SFIXEDCOLOR +#define STRUECOLOR +#define STRUECOLOR16 +#define STRUECOLOR24 +#define SMBITMAPS +#define SLBITMAPS +#endif +#ifdef GTK_DRIVER +#define SFIXEDCOLOR +#define STRUECOLOR +#define STRUECOLOR16 +#define STRUECOLOR24 +#define SMBITMAPS +#define SLBITMAPS +#endif +#ifdef X11_DRIVER +#define SFIXEDCOLOR +#define STRUECOLOR +#define STRUECOLOR16 +#define STRUECOLOR24 +#define SMBITMAPS +#define SLBITMAPS +#endif +#ifdef SVGA_DRIVER +#undef STRUECOLOR16 +#define STRUECOLOR16 +#undef STRUECOLOR24 +#define STRUECOLOR24 +#endif +#ifdef GGI_DRIVER +#undef STRUECOLOR16 +#define STRUECOLOR16 +#undef STRUECOLOR24 +#define STRUECOLOR24 +#undef SLBITMAPS +#define SLBITMAPS +#endif +#ifdef BEOS_DRIVER +#ifdef __cplusplus +extern "C" { +#endif +#ifdef __GNUC__ +void be_exit_xaos(int i) __attribute__ ((__noreturn__)); +#else +void be_exit_xaos(int i); +#endif +#ifdef __cplusplus +} +#endif +#define exit_xaos(i) be_exit_xaos(i) +#undef STRUECOLOR16 +#define STRUECOLOR16 +#undef SFIXEDCOLOR +#define SFIXEDCOLOR +#undef SMBITMAPS +#define SMBITMAPS +#undef SLBITMAPS +#define SLBITMAPS +#endif +#ifdef WIN32_DRIVER +#define MAIN_FUNCTION XaoS_main +#undef STRUECOLOR16 +#define STRUECOLOR16 +#undef STRUECOLOR24 +#define STRUECOLOR24 +#endif +#ifdef HAVE_SELECT +#define COMPILE_PIPE +#endif +#endif /*CONFIG_H */ + diff --git a/src/include/config/config.std b/src/include/config/config.std new file mode 100644 index 0000000..c5313e9 --- /dev/null +++ b/src/include/config/config.std @@ -0,0 +1,28 @@ +#ifndef CONFIG_H +#define CONFIG_H +#define CONFIGFILE "xaos.cfg" +#define FPOINT_TYPE long double + /*floating point math type on computers + with medium speed floating point math should + use float instead */ +#define USE_LONG /*for autoconf..undefine if + fpoint_type is set to other than + long_double */ +/*#define MITSHM */ + /*undefine this if you system does not + support shared memory */ +/* You don't need to change these lines unless you now what you are doing */ + +#include +#define USE_STDIO +#include +#define HAVE_GETTIMEOFDAY +#define TIME_WITH_SYS_TIME +#define HAVE_LIMITS_H +#define HAVE_UNISTH_H +#define HAVE_SYS_TIME_H +#define +#define STRUECOLOR24 +#define STRUECOLOR +#define STRUECOLOR16 +#endif /*CONFIG_H */ diff --git a/src/include/cursor.h b/src/include/cursor.h new file mode 100644 index 0000000..45859fc --- /dev/null +++ b/src/include/cursor.h @@ -0,0 +1,56 @@ +CONST static unsigned char wait_pointer_data[256] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 1, 0, + 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, + 0, 0, 0, 1, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, + 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, + 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 0, + 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, + 0, 0, 0, 1, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, + 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, + 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, +}; + +CONST static unsigned char mouse_pointer_data[256] = { + 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 1, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 1, 0, 1, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static unsigned char replay_pointer_data[256] = { + 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; diff --git a/src/include/fconfig.h b/src/include/fconfig.h new file mode 100644 index 0000000..bd007b3 --- /dev/null +++ b/src/include/fconfig.h @@ -0,0 +1,63 @@ +#ifndef FCONFIG_H +#define FCONFIG_H +#include +#define TUTORIALPATH DATAPATH"/tutorial/" +#define EXAMPLESPATH DATAPATH"/examples/" +#define CATALOGSPATH DATAPATH"/catalogs/" +#define HELPPATH DATAPATH"/help/xaos.hlp" + +#define DEFAULT_MAX_ITER 170 + /*default number of iterations should be set + lower for slow computers */ +#define DEFAULT_BAILOUT 4 +#define MAXSTEP (0.008*3) + /*zooming step. For slow computer should + be set lower. Longer steps takes more time + and invoke yet longer ones etc.. */ +#define STEP (0.0006*3) + /*speedup */ +#define XSIZE 640 + /*default sizes of window */ +#define YSIZE 480 +#define ROTATIONSPEED 30 + + + + /*some constatnts used by various parts of XaoS */ +#ifndef DEBUG +#define NDEBUG +#endif +#ifndef FRAMERATE /*plan9 seems to require this */ +#define FRAMERATE 20 +#define LOOKSIZE 2 + /*size explored by autopilot */ +#define RANGE1 30 +#define NGUESSES (RANGE1*RANGE1/2) +#define MAXTIME 10 + /*maximum zooming time to one direction */ +#define NGUESSES1 10 + /*maximum number of guesses using first + method */ +#define NGUESSES2 1000 + /*maximum number of guesses using second + method */ +#define SPEEDUP 1.05 + /*speedup of speedup */ +#endif +/*#define SLOWFUNCPTR*/ + +#ifdef _plan9_ +#undef number_t +#define number_t double +#else +typedef FPOINT_TYPE number_t; +#endif + +#undef STAT +#ifdef STATISTICS +#define STAT(x) x +#else +#define STAT(x) +#endif +#define NUMBER_BIG ((number_t)INT_MAX) +#endif /*FCONFIG_H */ diff --git a/src/include/filter.h b/src/include/filter.h new file mode 100644 index 0000000..be27bd5 --- /dev/null +++ b/src/include/filter.h @@ -0,0 +1,335 @@ +#ifndef IMAGE_H +#define IMAGE_H +#include "fconfig.h" +#ifdef __cplusplus +extern "C" { +#endif + + typedef unsigned char pixel_t; + typedef unsigned char rgb_t[4]; /*4 is better than 3 - makes multiplying easier */ + struct truec { + int rshift, gshift, bshift; /*the shift ammounts */ + int rprec, gprec, bprec; /*precisity - 0=8bit, 1=7bit, -1=9bit etc... */ + unsigned int rmask, gmask, bmask; /*masks */ + unsigned int mask1, mask2, allmask; /*Mask1 and mask2 are distinc color masks + allmask are mask for all colors */ + int byteexact; /*When every colors is at one byte */ + int missingbyte; /*for 32bit truecolor and exact byte places one byte is + unused... */ + }; + union paletteinfo { + struct truec truec; + }; + struct palette { + int start; + int end; + int maxentries; + int version; + int type; + unsigned int *pixels; + int npreallocated; + rgb_t *rgb; + int flags; + int (*alloccolor) (struct palette * pal, int init, int r, int g, + int b); + void (*setpalette) (struct palette * pal, int start, int end, + rgb_t * rgb); + void (*allocfinished) (struct palette * pal); + void (*cyclecolors) (struct palette * pal, int direction); + int size; /*number of allocated color entries */ + void *data; /*userdata */ + /*Preallocated palette cells */ + int ncells; + unsigned int *index; + CONST rgb_t *prergb; + union paletteinfo info; + }; + struct image { + float pixelwidth, pixelheight; + pixel_t **oldlines; + pixel_t **currlines; + void (*flip) (struct image * img); + int width, height, nimages; + int bytesperpixel; + int currimage; + int flags; + int scanline; + int version; + struct palette *palette; + void *data; /*userdata */ + }; +#define interpol1(i1,i2,n,mask) ((((i1)&(mask))*(n)+((i2)&(mask))*(256-(n)))&((mask)<<8)) +#define interpol(i1,i2,n,mr,mg,mb) ((interpol1(i1,i2,n,mr)+interpol1(i1,i2,n,mg)+interpol1(i1,i2,n,mb))>>8) +#define intergray(i1,i2,n) (((i1)*n+(i2)*(256-(n)))>>8) + /* + * J.B. Langston 3/13/2008 + * + * The Mac OS X driver requires a 32-bit rgb mask where the most significant + * byte is on (e.g., 0xffffff00). This exposed a bug in the interpol macro + * that resulted in distorted colors for the smooth coloring modes. + * If the interpol macro is applied to such a mask, it causes an overflow + * of the 32-bit int, and the left-most color byte is lost. + * + * I added shiftinterpol macro to handle such masks. It shifts everything 1 + * byte to the right, performs the calculation, and then shifts everything + * back 1 byte to the left when it is done. + * + * I also created the safeinterpol macro which detects if the most + * signficant byte in the mask is on, and uses the shiftinterpol macro if + * so, or the orignal interpol macro if not. + * + * I then modified the interpoltype macro to use the safeinterpol macro + * instead of the interpol macro directly. + */ +#define shiftinterpol(i1,i2,n,mr,mg,mb) (interpol((i1)>>8,(i2)>>8,n,(mr)>>8,(mg)>>8,(mb)>>8)<<8) +#define safeinterpol(i1,i2,n,mr,mg,mb) ((((mr)|(mg)|(mb))&0xff000000)?shiftinterpol(i1,i2,n,mr,mg,mb):interpol(i1,i2,n,mr,mg,mb)) +#define interpoltype(palette,i1,i2,n) ((palette).type==GRAYSCALE || (palette).type == LARGEITER?intergray(i1,i2,n):safeinterpol(i1,i2,n,(palette).info.truec.rmask,(palette).info.truec.gmask,(palette).info.truec.bmask)) +/*palette flags */ +#define UNKNOWNENTRIES 1 +#define DONOTCHANGE 2 +#define FINISHLATER 4 +#define UNFINISHED 8 +/*image flags */ +#define FREELINES 1 +#define FREEDATA 2 +#define AAIMAGE 4 +#define PROTECTBUFFERS 8 +/*palette types supported by most of engine*/ +#define C256 1 +#define GRAYSCALE 2 +#define TRUECOLOR16 4 +#define TRUECOLOR24 8 +#define TRUECOLOR 16 +/*special mage types used internaly by XaoS */ +#define LARGEITER 32 +#define SMALLITER 64 + +/*palette types handled by the dithering filter*/ +#define LBITMAP 256 +#define MBITMAP 512 +#define LIBITMAP 1024 +#define MIBITMAP 2048 +#define FIXEDCOLOR 4096 + +#define ALLMASK (C256|TRUECOLOR16|TRUECOLOR24|LARGEITER|GRAYSCALE) +#define BITMAPS (LBITMAP|MBITMAP|LIBITMAP|MIBITMAP) +#define MASK1BPP (SMALLITER|C256|GRAYSCALE) +#define MASK2BPP (TRUECOLOR16|LARGEITER) +#define MASK3BPP (TRUECOLOR24) +#define MASK4BPP (TRUECOLOR) + +/*flags for requirements */ +#define IMAGEDATA 1 +#define TOUCHIMAGE 2 +#define NEWIMAGE 4 +/*flags for initdata */ +#define DATALOST 1 +/*flags for doit */ +#define INTERRUPTIBLE 1 +#define PALETTEONLY 2 +/*return flags */ +#define INEXACT 1 +#define CHANGED 2 +#define ANIMATION 4 +#define UNCOMPLETTE (1<<29) +/*flags for filters */ +#define ALLOCEDIMAGE 1 /*used by inherimage mechanizm */ +#define SHAREDDATA 2 + +#define PALGORITHMS 3 +#ifdef _plan9_ +#undef pixel32_t +#undef pixel8_t +#undef pixel16_t +#define pixel32_t unsigned int +#define pixel16_t unsigned short +#define pixel8_t unsigned char +#undef ppixel8_t +#undef ppixel16_t +#undef ppixel24_t +#undef ppixel32_t +#define ppixel8_t pixel8_t * +#define ppixel16_t pixel16_t * +#define ppixel24_t unsigned char * +#define ppixel32_t pixel32_t * +#else +#include /*avoid problems with plan9-it ignores #if + So code must be separated into another file */ +#endif +#define imgetpixel(image,x,y) ((image)->bytesperpixel==1?(image)->currlines[y][x]:((image)->bytesperpixel==4?((pixel32_t*)(image)->currlines[y])[x]:(image)->bytesperpixel==3?(((pixel16_t *)(image)->currlines[y])[x]+((image)->currlines[y][3*(x)+2]<<16)):(((pixel16_t*)(image)->currlines[y])[x]))) + struct requirements { + int nimages; + int supportedmask; + int flags; + }; + struct filter { + struct filter *next, *previous; + struct queue *queue; + CONST struct filteraction *action; + struct image *image, *childimage; + struct requirements req; + struct fractal_context *fractalc; + void *data; + CONST char *name; + int flags; + int imageversion; /*For detection whether image changed or not */ + void (*wait_function) (struct filter * f); + /*stuff for wait_function */ + int pos, max, incalculation, readyforinterrupt, interrupt; + CONST char *pass; + }; + struct initdata { + void (*wait_function) (struct filter * f); + struct image *image; + struct fractal_context *fractalc; + int flags; + }; + struct filteraction { + CONST char *name; + CONST char *shortname; + int flags; + struct filter *(*getinstance) (CONST struct filteraction * a); + void (*destroyinstance) (struct filter * f); + int (*doit) (struct filter * f, int flags, int time); + int (*requirement) (struct filter * f, struct requirements * r); + int (*initialize) (struct filter * f, struct initdata * i); + void (*convertup) (struct filter * f, int *x, int *y); + void (*convertdown) (struct filter * f, int *x, int *y); + void (*removefilter) (struct filter * f); + }; + struct queue { + struct filter *first, *last; + int isinitialized; + struct filter *palettechg; + struct image *saveimage; + }; + + +#define datalost(f,i) (((i)->flags&DATALOST)||((f)->imageversion&&(f)->imageversion!=(i)->image->version)) +/*filter actions */ + + extern unsigned int col_diff[3][512]; + struct filter *createfilter(CONST struct filteraction *fa); + struct queue *create_queue(struct filter *f); + void insertfilter(struct filter *f1, struct filter *f2); + void removefilter(struct filter *f); + void addfilter(struct filter *f1, struct filter *f2); + int initqueue(struct queue *q); + +/*Filter utility functions */ + int reqimage(struct filter *f, struct requirements *req, + int supportedmask, int flags); + int inherimage(struct filter *f, struct initdata *data, int flags, + int width, int height, struct palette *palette, + float pixelwidth, float pixelheight); + void destroyinheredimage(struct filter *f); + void updateinheredimage(struct filter *f); + + void inhermisc(struct filter *f, CONST struct initdata *i); + +/*image actions */ + + void flipgeneric(struct image *img); + struct image *create_image_lines(int width, int height, + int nimages, pixel_t ** lines1, + pixel_t ** lines2, + struct palette *palette, + void (*flip) (struct image * img), + int flags, float pixelwidth, + float pixelheight); + struct image *create_image_cont(int width, int height, + int scanlinesize, int nimages, + pixel_t * buf1, pixel_t * buf2, + struct palette *palette, + void (*flip) (struct image * img), + int flags, float pixelwidth, + float pixelheight); + struct image *create_image_mem(int width, int height, int nimages, + struct palette *palette, + float pixelwidth, float pixelheight); + struct image *create_subimage(struct image *simg, int width, + int height, int nimages, + struct palette *palette, + float pixelwidth, float pixelheight); + + void destroy_image(struct image *img); + void clear_image(struct image *img); + +/*palette */ + + int bytesperpixel(int type) CONSTF; + void bestfit_init(void); + struct palette *createpalette(int start, int end, int type, int flags, + int maxentries, + int (*alloccolor) (struct palette * pal, + int init, int r, + int g, int b), + void (*setcolor) (struct palette * pal, + int start, int end, + rgb_t * rgb), + void (*allocfinished) (struct palette * + pal), + void (*cyclecolors) (struct palette * + pal, int direction), + union paletteinfo *info); + void destroypalette(struct palette *palette); + int mkdefaultpalette(struct palette *palette); + int mkstereogrampalette(struct palette *palette); + int mkstarfieldpalette(struct palette *palette); + int mkblurpalette(struct palette *palette); + int mkgraypalette(struct palette *palette); + int mkrgb(struct palette *palette); + int mkpalette(struct palette *palette, int seed, int algorithm); + int shiftpalette(struct palette *palette, int n); + void preallocpalette(struct palette *pal); + struct palette *clonepalette(struct palette *palette); + void restorepalette(struct palette *dest, struct palette *src); + void convertupgeneric(struct filter *f, int *x, int *y); + void convertdowngeneric(struct filter *f, int *x, int *y); + int fixedalloccolor(struct palette *palette, int init, int r, int g, + int b) CONSTF; + +#define setfractalpalette(f,p) if((f)->fractalc->palette==(f)->image->palette) (f)->fractalc->palette=(p) + +#ifdef STRUECOLOR24 +#define TRUECOLOR24CASE(x) case 3:x;break; +#else +#define TRUECOLOR24CASE(x) +#endif + +#ifdef STRUECOLOR16 +#define SUPPORT16 +#endif +#ifdef SUPPORT16 +#define TRUECOLOR16CASE(x) case 2:x;break; +#else +#define TRUECOLOR16CASE(x) +#endif + +#define drivercall(i,x1,x2,x3,x4) switch((i).bytesperpixel) { \ + TRUECOLOR24CASE(x3); \ + TRUECOLOR16CASE(x2); \ + case 1:x1;break; \ + case 4:x4; \ +} +#ifdef SMBITMAPS +#define SBITMAPS +#else +#ifdef SLBITMAPS +#define SBITMAPS +#endif +#endif + +#ifdef SBITMAPS +#define SCONVERTORS +#else +#ifdef SFIXEDCOLOR +#define SCONVERTORS +#endif +#endif + +#ifdef __cplusplus +} +#endif +#include "formulas.h" +#endif diff --git a/src/include/formulas.h b/src/include/formulas.h new file mode 100644 index 0000000..4a061cc --- /dev/null +++ b/src/include/formulas.h @@ -0,0 +1,64 @@ +/* + * XaoS, a fast portable realtime fractal zoomer + * Copyright (C) 1996,1997 by + * + * Jan Hubicka (hubicka@paru.cas.cz) + * Thomas Marsh (tmarsh@austin.ibm.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#ifndef FORMULAS_H +#define FORMULAS_H + +#include +#include + +#ifdef SFFE_USING +#include "sffe.h" +#ifdef SFFE_CMPLX_ASM +#include "sffe_cmplx_asm.h" +#elif SFFE_CMPLX_GSL +#include "sffe_cmplx_gsl.h" +#endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef SFFE_USING + /*extern sffe* parser; + extern sffe* pinit; */ + extern cmplx Z; + extern cmplx pZ; + extern cmplx C; +#endif + +#define MAX_LAMBDA 2 + + +#define FORMULAMAGIC 1121 + + extern CONST char *CONST incolorname[]; + extern CONST struct formula formulas[]; + extern CONST char *CONST outcolorname[]; + extern CONST char *CONST tcolorname[]; + extern CONST int nformulas; + extern CONST int nmformulas; + +#ifdef __cplusplus +} +#endif +#endif /* FORMULAS_H */ diff --git a/src/include/fractal.h b/src/include/fractal.h new file mode 100644 index 0000000..188ac8d --- /dev/null +++ b/src/include/fractal.h @@ -0,0 +1,170 @@ +/* + * XaoS, a fast portable realtime fractal zoomer + * Copyright (C) 1996,1997 by + * + * Jan Hubicka (hubicka@paru.cas.cz) + * Thomas Marsh (tmarsh@austin.ibm.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#ifndef FRACTAL1_H +#define FRACTAL1_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "config.h" +#include "fconfig.h" +#define INCOLORING 11 +#define OUTCOLORING 11 +#define TCOLOR 15 + + typedef struct { + number_t y0, k; + } symetrytype; + + struct symetryinfo { + number_t xsym, ysym; + int nsymetries; + CONST symetrytype *symetry; + }; + typedef struct { + number_t mc, nc; + number_t mi, ni; + } vrect; + typedef struct { + number_t cr, ci; + number_t rr, ri; + } vinfo; + typedef unsigned int (*iterationfunc) (number_t, number_t, number_t, + number_t) CONSTF REGISTERS(3); + struct formula { + int magic; +#ifndef SLOWFUNCPTR + iterationfunc calculate, calculate_periodicity, smooth_calculate, + smooth_calculate_periodicity; +#endif + void (*calculate_julia) (struct image * img, register number_t pre, + register number_t pim); + CONST char *name[2]; + CONST char *shortname; + vinfo v; + int hasperiodicity; + int mandelbrot; + number_t pre, pim; + struct symetryinfo (out[OUTCOLORING + 1]); + struct symetryinfo (in[INCOLORING + 1]); + int flags; + }; + + struct fractal_context { + number_t pre, pim; + number_t bre, bim; + CONST struct formula *currentformula; + number_t angle; + int periodicity; + unsigned int maxiter; + number_t bailout; + int coloringmode, incoloringmode; + int intcolor, outtcolor; + int mandelbrot; + int plane; + int version; + int range; + float windowwidth, windowheight; + vinfo s; + vrect rs; + number_t sin, cos; + int slowmode; /* 1 in case we want to be exact, not fast */ + /*values temporary filled by set_fractal_context */ + iterationfunc calculate[2]; + number_t periodicity_limit; + struct palette *palette; /*fractal's palette */ + }; + typedef struct fractal_context fractal_context; + typedef struct { + double y0, k, kk, y0k; + } symetry2; + + struct symetryinfo2 { + number_t xsym, ysym; + int nsymetries; + symetry2 *symetry; + number_t xmul, ymul, xdist, ydist; + }; +#define STARTZERO 1 +#define JULIA_BTRACE 2 +#define MANDEL_BTRACE 4 + +#ifdef SFFE_USING +#define SFFE_FRACTAL 8 +#endif + +#define BTRACEOK ((cformula.flags&(2< + +#ifdef __cplusplus +} +#endif +#endif /* FRACTAL_H */ diff --git a/src/include/gccaccel.h b/src/include/gccaccel.h new file mode 100644 index 0000000..cd08fb4 --- /dev/null +++ b/src/include/gccaccel.h @@ -0,0 +1,40 @@ +/* GNU C accelerators */ +#if defined (__GNUC__) +#define myfabs(x) fabs(x) +#if __GNUC__ >= 2 && (__GNUC__ > 2 || __GNUC_MINOR__ >= 95) +#define __GNUC__EGCS +#endif +#if __GNUC__ >= 2 && (__GNUC__ > 2 || __GNUC_MINOR__ > 7) +#if __GNUC__ >= 2 && (__GNUC__ > 2 || __GNUC_MINOR__ >= 95) +#define RESTRICT __restrict__ +#endif +#define CONSTF __attribute__ ((__const__)) +#if __GNUC__ >= 3 +#define PUREF __attribute__ ((__pure__)) +#endif +#define NORETURN __attribute__ ((__noreturn__)) +#ifdef __i386__ +#ifndef NOREGISTERS +#define REGISTERS(n) __attribute__ ((__regparm__(n))) +#endif /*NOREGISTERS*/ +#endif /*__i386__ */ +#endif /*version */ +#endif /*__GNUC__*/ +#ifndef RESTRICT +#define RESTRICT +#endif +#ifndef CONSTF +#define CONSTF +#endif +#ifndef PUREF +#define PUREF +#endif +#ifndef NORETURN +#define NORETURN +#endif +#ifndef REGISTERS +#define REGISTERS(n) +#endif +#ifndef myfabs +#define myfabs(x) ((x)>0?(x):-(x)) +#endif diff --git a/src/include/gccbuild.h b/src/include/gccbuild.h new file mode 100644 index 0000000..11601c9 --- /dev/null +++ b/src/include/gccbuild.h @@ -0,0 +1,65 @@ +/* BUGS: + * bellow gcc 2.7.2 builtins are not supported + * gcc 2.7.2.x don't inline long doubles + * egcc 1.0.1 crash in constant propagation when certain builtins are enabled + */ + + +#ifndef __GCCBUILD +#define __GCCBUILD +#if defined(__GLIBC__) +#include "math.h" +#else +#if defined(__GNUC__) && defined(__i386__) && defined(__OPTIMIZE__) +#if 0 +#include "i386/__math.h" +#endif +#endif +#endif + +/* We really want to use builtins. Avoid any defines */ +#if defined __GNUC__ && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)) +#define __HAVE_FABSL +#define __fabsl(x) __builtin_fabsl(x) +#define __fabs(x) __builtin_fabsl(x) +#define __fabsf(x) __builtin_fabsf(x) +#define sin(x) __builtin_sin(x) +#define cos(x) __builtin_cos(x) +#endif + + +#include "aconfig.h" + +#ifndef __HAVE_FABSL +#ifdef HAVE_FABSL +#define __fabsl fabsl +#define __HAVE_FABSL +#else +#ifdef HAVE__FABSL +#define __fabsl _fabsl +#define __HAVE_FABSL +#else +#ifdef HAVE___FABSL +#define __HAVE___FABSL +#endif +#endif +#endif +#endif + +/* GCC 2.7.x have problems with long double inlines. Disable them! */ +#if defined __GNUC__ && (__GNUC__ == 2 && __GNUC_MINOR__ <= 7) +#undef __HAVE_FABSL +#endif + +#ifdef HAVE_LONG_DOUBLE +#ifndef __HAVE_FABSL +#define myabs(x) ((x)>0?(x):-(x)) +#else +#define myabs(x) __fabsl((number_t)(x)) +#endif +#else +#define myabs(x) fabs((number_t)(x)) +#endif + + +#endif /*gccbuild */ diff --git a/src/include/generic.h b/src/include/generic.h new file mode 100644 index 0000000..b4f1cee --- /dev/null +++ b/src/include/generic.h @@ -0,0 +1,15 @@ +#undef p_set +#undef p_get +#undef p_setp +#undef bpp1 +#undef p_getp +#undef p_add +#undef p_inc +#undef p_copy +#define p_set(ptr,val) (*(ptr)=(val)) +#define p_get(ptr) (*(ptr)) +#define p_setp(ptr,pos,val) ((ptr)[(pos)]=(val)) +#define p_getp(ptr,pos) ((ptr)[(pos)]) +#define p_add(ptr,val) ((ptr)+(val)) +#define p_inc(ptr,val) ((ptr)+=(val)) +#define p_copy(ptr1,val1,ptr2,val2) ((ptr1)[val1]=(ptr2)[val2]) diff --git a/src/include/grlib.h b/src/include/grlib.h new file mode 100644 index 0000000..288b0dd --- /dev/null +++ b/src/include/grlib.h @@ -0,0 +1,40 @@ +#ifndef _TEXT_H +#define _TEXT_H +#ifdef __cplusplus +extern "C" { +#endif + extern CONST struct xfont { + CONST unsigned char *data; + int width, height, realwidth, encoding; + } xsmallfont, xbigfont, xbigfont2, xaafont, xsmallfontil1, xbigfontil1, + xmedfontil1, xbigfont3; + int xiconv(int encoding, char *out, int *outlen, const char *in, + int *inlen); + int xprint(struct image *image, CONST struct xfont *current, int x, + int y, CONST char *text, int fgcolor, + int bgcolor, int mode); +#define TEXT_PRESSED 1 +/* +#define xtextheight(font) ((font)->height+1) +#define xtextcharw(font,c) ((font)->width) + */ + int xtextwidth(CONST struct xfont *font, CONST char *text); + int xtextheight(CONST struct xfont *font); + int xtextcharw(CONST struct xfont *font, CONST char c); + void xrectangle(struct image *image, int x, int y, int width, + int height, int fgcolor); + void xvline(struct image *image, int x, int y, int height, + int fgcolor); + void xhline(struct image *image, int x, int y, int width, int fgcolor); + char *xsaveline(struct image *img, int x1, int y1, int x2, int y2); + void xrestoreline(struct image *img, char *data, int x1, int y1, + int x2, int y2); + void xline(struct image *img, int x1, int y1, int x2, int y2, + int color); + void xprepareimage(struct image *img); + void xdrawcursor(struct image *img, int x, int y, int color, + int height); +#ifdef __cplusplus +} +#endif +#endif diff --git a/src/include/hicolor.h b/src/include/hicolor.h new file mode 100644 index 0000000..4807190 --- /dev/null +++ b/src/include/hicolor.h @@ -0,0 +1,16 @@ +#ifdef cpixel_t +#undef cpixel_t +#undef cpixeldata_t +#undef cppixel_t +#undef bpp +#undef UNSUPPORTED +#undef bpp1 +#endif +#ifndef SUPPORT16 +#define UNSUPPORTED +#endif +#define cpixel_t pixel16_t +#define cpixeldata_t pixel16_t +#define cppixel_t ppixel16_t +#define bpp 4 +#include diff --git a/src/include/i386/__math.h b/src/include/i386/__math.h new file mode 100644 index 0000000..0274d52 --- /dev/null +++ b/src/include/i386/__math.h @@ -0,0 +1,586 @@ +/* Inline math functions for i387. + Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by John C. Bowman , 1995. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + + +#ifndef __GLIBC__ +#ifdef __cplusplus +# define __MATH_INLINE __inline +#else +# define __MATH_INLINE extern __inline +#endif + +#ifndef ____MATH_H +#define ____MATH_H + + +#if defined __USE_ISOC9X && defined __GNUC__ && __GNUC__ >= 2 +/* ISO C 9X defines some macros to perform unordered comparisons. The + ix87 FPU supports this with special opcodes and we should use them. + These must not be inline functions since we have to be able to handle + all floating-point types. */ +# ifdef __i686__ +/* For the PentiumPro and more recent processors we can provide + better code. */ +# define isgreater(x, y) \ + ({ register char __result; \ + __asm__ ("fucomip %%st(1), %%st; seta %%al" \ + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st"); \ + __result; }) +# define isgreaterequal(x, y) \ + ({ register char __result; \ + __asm__ ("fucomip %%st(1), %%st; setae %%al" \ + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st"); \ + __result; }) + +# define isless(x, y) \ + ({ register char __result; \ + __asm__ ("fucomip %%st(1), %%st; seta %%al" \ + : "=a" (__result) : "u" (x), "t" (y) : "cc", "st"); \ + __result; }) + +# define islessequal(x, y) \ + ({ register char __result; \ + __asm__ ("fucomip %%st(1), %%st; setae %%al" \ + : "=a" (__result) : "u" (x), "t" (y) : "cc", "st"); \ + __result; }) + +# define islessgreater(x, y) \ + ({ register char __result; \ + __asm__ ("fucomip %%st(1), %%st; setne %%al" \ + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st"); \ + __result; }) + +# define isunordered(x, y) \ + ({ register char __result; \ + __asm__ ("fucomip %%st(1), %%st; setp %%al" \ + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st"); \ + __result; }) +# else +/* This is the dumb, portable code for i386 and above. */ +# define isgreater(x, y) \ + ({ register char __result; \ + __asm__ ("fucompp; fnstsw; testb $0x45, %%ah; setz %%al" \ + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ + __result; }) + +# define isgreaterequal(x, y) \ + ({ register char __result; \ + __asm__ ("fucompp; fnstsw; testb $0x05, %%ah; setz %%al" \ + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ + __result; }) + +# define isless(x, y) \ + ({ register char __result; \ + __asm__ ("fucompp; fnstsw; testb $0x45, %%ah; setz %%al" \ + : "=a" (__result) : "u" (x), "t" (y) : "cc", "st", "st(1)"); \ + __result; }) + +# define islessequal(x, y) \ + ({ register char __result; \ + __asm__ ("fucompp; fnstsw; testb $0x05, %%ah; setz %%al" \ + : "=a" (__result) : "u" (x), "t" (y) : "cc", "st", "st(1)"); \ + __result; }) + +# define islessgreater(x, y) \ + ({ register char __result; \ + __asm__ ("fucompp; fnstsw; testb $0x44, %%ah; setz %%al" \ + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ + __result; }) + +# define isunordered(x, y) \ + ({ register char __result; \ + __asm__ ("fucompp; fnstsw; sahf; setp %%al" \ + : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \ + __result; }) +# endif /* __i686__ */ + +/* Test for negative number. Used in the signbit() macro. */ +__MATH_INLINE int __signbitf(float __x) +{ + union { + float __f; + int __i; + } __u = { + __f:__x}; + return __u.__i < 0; +} + +__MATH_INLINE int __signbit(double __x) +{ + union { + double __d; + int __i[2]; + } __u = { + __d:__x}; + return __u.__i[1] < 0; +} + +__MATH_INLINE int __signbitl(long double __x) +{ + union { + long double __l; + int __i[3]; + } __u = { + __l:__x}; + return (__u.__i[2] & 0x8000) != 0; +} +#endif + + +/* The gcc, version 2.7 or below, has problems with all this inlining + code. So disable it for this version of the compiler. */ +#if defined __GNUC__ && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 7)) + +#if ((!defined __NO_MATH_INLINES || defined __LIBC_INTERNAL_MATH_INLINES) \ + && defined __OPTIMIZE__) + +/* A macro to define float, double, and long double versions of various + math functions for the ix87 FPU. FUNC is the function name (which will + be suffixed with f and l for the float and long double version, + respectively). OP is the name of the FPU operation. */ + +#if defined __USE_MISC || defined __USE_ISOC9X +# define __inline_mathop(func, op) \ + __inline_mathop_ (double, func, op) \ + __inline_mathop_ (float, __CONCAT(func,f), op) \ + __inline_mathop_ (long double, __CONCAT(func,l), op) +#else +# define __inline_mathop(func, op) \ + __inline_mathop_ (double, func, op) +#endif + +#define __inline_mathop_(float_type, func, op) \ + __inline_mathop_decl_ (float_type, func, op, "0" (__x)) + + +#if defined __USE_MISC || defined __USE_ISOC9X +# define __inline_mathop_decl(func, op, params...) \ + __inline_mathop_decl_ (double, func, op, params) \ + __inline_mathop_decl_ (float, __CONCAT(func,f), op, params) \ + __inline_mathop_decl_ (long double, __CONCAT(func,l), op, params) +#else +# define __inline_mathop_decl(func, op, params...) \ + __inline_mathop_decl_ (double, func, op, params) +#endif + +#define __inline_mathop_decl_(float_type, func, op, params...) \ + __MATH_INLINE float_type func (float_type); \ + __MATH_INLINE float_type func (float_type __x) \ + { \ + register float_type __result; \ + __asm __volatile__ (op : "=t" (__result) : params); \ + return __result; \ + } + + +#if defined __USE_MISC || defined __USE_ISOC9X +# define __inline_mathcode(func, arg, code) \ + __inline_mathcode_ (double, func, arg, code) \ + __inline_mathcode_ (float, __CONCAT(func,f), arg, code) \ + __inline_mathcode_ (long double, __CONCAT(func,l), arg, code) +# define __inline_mathcode2(func, arg1, arg2, code) \ + __inline_mathcode2_ (double, func, arg1, arg2, code) \ + __inline_mathcode2_ (float, __CONCAT(func,f), arg1, arg2, code) \ + __inline_mathcode2_ (long double, __CONCAT(func,l), arg1, arg2, code) +# define __inline_mathcode3(func, arg1, arg2, arg3, code) \ + __inline_mathcode3_ (double, func, arg1, arg2, arg3, code) \ + __inline_mathcode3_ (float, __CONCAT(func,f), arg1, arg2, arg3, code) \ + __inline_mathcode3_ (long double, __CONCAT(func,l), arg1, arg2, arg3, code) +#else +# define __inline_mathcode(func, arg, code) \ + __inline_mathcode_ (double, func, (arg), code) +# define __inline_mathcode2(func, arg1, arg2, code) \ + __inline_mathcode2_ (double, func, arg1, arg2, code) +# define __inline_mathcode3(func, arg1, arg2, arg3, code) \ + __inline_mathcode3_ (double, func, arg1, arg2, arg3, code) +#endif + +#define __inline_mathcode_(float_type, func, arg, code) \ + __MATH_INLINE float_type func (float_type); \ + __MATH_INLINE float_type func (float_type arg) \ + { \ + code; \ + } + +#define __inline_mathcode2_(float_type, func, arg1, arg2, code) \ + __MATH_INLINE float_type func (float_type, float_type); \ + __MATH_INLINE float_type func (float_type arg1, float_type arg2) \ + { \ + code; \ + } + +#define __inline_mathcode3_(float_type, func, arg1, arg2, arg3, code) \ + __MATH_INLINE float_type func (float_type, float_type, float_type); \ + __MATH_INLINE float_type func (float_type arg1, float_type arg2, \ + float_type arg3) \ + { \ + code; \ + } +#endif + + +#if !defined __NO_MATH_INLINES && defined __OPTIMIZE__ +/* Miscellaneous functions */ + +__inline_mathcode(__sgn, __x, + return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0)) + __inline_mathcode(__pow2, __x, + register long double __value; + register long double __exponent; + __extension__ long long int __p = (long long int)__x; + if (__x == (long double) __p) + { +__asm __volatile__("fscale": "=t"(__value):"0"(1.0), "u"(__x)); + return + __value;} +__asm __volatile__("fld %%st(0)\n\t" "frndint # int(x)\n\t" "fxch\n\t" "fsub %%st(1) # fract(x)\n\t" "f2xm1 # 2^(fract(x)) - 1\n\t": "=t"(__value), "=u"(__exponent): "0"(__x)); __value += 1.0; __asm __volatile__("fscale": "=t"(__value):"0"(__value), "u"(__exponent)); + return + __value) +#define __sincos_code \ + register long double __cosr; \ + register long double __sinr; \ + __asm __volatile__ \ + ("fsincos\n\t" \ + "fnstsw %%ax\n\t" \ + "testl $0x400, %%eax\n\t" \ + "jz 1f\n\t" \ + "fldpi\n\t" \ + "fadd %%st(0)\n\t" \ + "fxch %%st(1)\n\t" \ + "2: fprem1\n\t" \ + "fnstsw %%ax\n\t" \ + "testl $0x400, %%eax\n\t" \ + "jnz 2b\n\t" \ + "fstp %%st(1)\n\t" \ + "fsincos\n\t" \ + "1:" \ + : "=t" (__cosr), "=u" (__sinr) : "0" (__x)); \ + *__sinx = __sinr; \ + *__cosx = __cosr + + __MATH_INLINE void __sincos(double __x, double *__sinx, + double *__cosx); +__MATH_INLINE void __sincos(double __x, double *__sinx, double *__cosx) +{ + __sincos_code; +} + +__MATH_INLINE void __sincosf(float __x, float *__sinx, float *__cosx); +__MATH_INLINE void __sincosf(float __x, float *__sinx, float *__cosx) +{ + __sincos_code; +} + +__MATH_INLINE void __sincosl(long double __x, long double *__sinx, + long double *__cosx); +__MATH_INLINE void +__sincosl(long double __x, long double *__sinx, long double *__cosx) +{ + __sincos_code; +} + + +/* Optimized inline implementation, sometimes with reduced precision + and/or argument range. */ + +#define __expm1_code \ + register long double __value; \ + register long double __exponent; \ + register long double __temp; \ + __asm __volatile__ \ + ("fldl2e # e^x - 1 = 2^(x * log2(e)) - 1\n\t" \ + "fmul %%st(1) # x * log2(e)\n\t" \ + "fst %%st(1)\n\t" \ + "frndint # int(x * log2(e))\n\t" \ + "fxch\n\t" \ + "fsub %%st(1) # fract(x * log2(e))\n\t" \ + "f2xm1 # 2^(fract(x * log2(e))) - 1\n\t" \ + "fscale # 2^(x * log2(e)) - 2^(int(x * log2(e)))\n\t" \ + : "=t" (__value), "=u" (__exponent) : "0" (__x)); \ + __asm __volatile__ \ + ("fscale # 2^int(x * log2(e))\n\t" \ + : "=t" (__temp) : "0" (1.0), "u" (__exponent)); \ + __temp -= 1.0; \ + return __temp + __value +__inline_mathcode_(long double, __expm1l, __x, __expm1_code) +#define __exp_code \ + register long double __value; \ + register long double __exponent; \ + __asm __volatile__ \ + ("fldl2e # e^x = 2^(x * log2(e))\n\t" \ + "fmul %%st(1) # x * log2(e)\n\t" \ + "fst %%st(1)\n\t" \ + "frndint # int(x * log2(e))\n\t" \ + "fxch\n\t" \ + "fsub %%st(1) # fract(x * log2(e))\n\t" \ + "f2xm1 # 2^(fract(x * log2(e))) - 1\n\t" \ + : "=t" (__value), "=u" (__exponent) : "0" (__x)); \ + __value += 1.0; \ + __asm __volatile__ \ + ("fscale" \ + : "=t" (__value) : "0" (__value), "u" (__exponent)); \ + return __value +__inline_mathcode(exp, __x, __exp_code) __inline_mathcode_(long double, __expl, __x, __exp_code) __inline_mathcode(tan, __x, register long double __value; register long double __value2 __attribute__ ((__unused__)); __asm __volatile__("fptan": "=t"(__value2), "=u"(__value):"0"(__x)); return __value) +#define __atan2_code \ + register long double __value; \ + __asm __volatile__ \ + ("fpatan\n\t" \ + : "=t" (__value) : "0" (__x), "u" (__y) : "st(1)"); \ + return __value + __inline_mathcode2(atan2, __y, __x, + __atan2_code) __inline_mathcode2_(long double, __atan2l, + __y, __x, + __atan2_code) +__inline_mathcode2(fmod, __x, __y, register long double __value; __asm __volatile__("1: fprem\n\t" "fnstsw %%ax\n\t" "sahf\n\t" "jp 1b": "=t"(__value): "0"(__x), "u"(__y):"ax", "cc"); return __value) + __inline_mathcode2(pow, __x, __y, + register long double __value; + register long double __exponent; + __extension__ long long int __p = + (long long int)__y; if (__x == 0.0 && __y > 0.0) + return 0.0; if (__y == (double) __p) + { + long double __r = 1.0; + if (__p == 0) return 1.0; if (__p < 0) { + __p = -__p; __x = 1.0 / __x;} + while (1) { + if (__p & 1) + __r *= __x; + __p >>= 1; if (__p == 0) return __r; __x *= __x;} + /* NOTREACHED */ + } + +__asm __volatile__("fyl2x": "=t"(__value): "0"(__x), "u"(1.0): "st(1)"); __asm __volatile__("fmul %%st(1) # y * log2(x)\n\t" "fst %%st(1)\n\t" "frndint # int(y * log2(x))\n\t" "fxch\n\t" "fsub %%st(1) # fract(y * log2(x))\n\t" "f2xm1 # 2^(fract(y * log2(x))) - 1\n\t": "=t"(__value), "=u"(__exponent): "0"(__y), "1"(__value)); __value += 1.0; __asm __volatile__("fscale": "=t"(__value):"0"(__value), "u"(__exponent)); + return + __value) + + + __inline_mathop(sqrt, "fsqrt") + __inline_mathop_(long double, __sqrtl, "fsqrt") +#if defined __GNUC__ && (__GNUC__ > 2 || __GNUC__ == 2 && __GNUC_MINOR__ >= 8) + __inline_mathcode_(double, fabs, __x, return __builtin_fabs(__x)) + __inline_mathcode_(float, fabsf, __x, return __builtin_fabsf(__x)) + __inline_mathcode_(long double, fabsl, __x, + return __builtin_fabsl(__x)) + __inline_mathcode_(long double, __fabsl, __x, + return __builtin_fabsl(__x)) +#else + __inline_mathop(fabs, "fabs") + __inline_mathop_(long double, __fabsl, "fabs") +#endif +/* The argument range of this inline version is reduced. */ + __inline_mathop(sin, "fsin") +/* The argument range of this inline version is reduced. */ + __inline_mathop(cos, "fcos") + __inline_mathop(atan, "fld1; fpatan") + __inline_mathop(log, "fldln2; fxch; fyl2x") + __inline_mathop(log10, "fldlg2; fxch; fyl2x") + __inline_mathcode(asin, __x, + return __atan2l(__x, + __sqrtl(1.0 - + __x * + __x))) + __inline_mathcode(acos, __x, + return __atan2l(__sqrtl(1.0 - __x * __x), + __x)) __inline_mathcode_(long + double, + __sgn1l, + __x, + return + __x >= + 0.0 ? + 1.0 : + -1.0) +/* The argument range of the inline version of sinhl is slightly reduced. */ + __inline_mathcode(sinh, __x, register long double __exm1 = + __expm1l(__fabsl(__x)); + return 0.5 * (__exm1 / (__exm1 + 1.0) + + __exm1) * + __sgn1l(__x)) __inline_mathcode(cosh, __x, + register long double + __ex = __expl(__x); + return 0.5 * (__ex + + 1.0 / + __ex)) +__inline_mathcode(tanh, __x, register long double __exm1 = __expm1l(-__fabsl(__x + __x)); return __exm1 / (__exm1 + 2.0) * __sgn1l(-__x)) __inline_mathcode(floor, __x, register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile("fnstcw %0":"=m"(__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0400; + /* rounding down */ +__asm __volatile("fldcw %0": : "m"(__cwtmp)); __asm __volatile("frndint": "=t"(__value): "0"(__x)); __asm __volatile("fldcw %0": : "m"(__cw)); return __value) +__inline_mathcode(ceil, __x, register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile("fnstcw %0":"=m"(__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0800; + /* rounding up */ +__asm __volatile("fldcw %0": : "m"(__cwtmp)); __asm __volatile("frndint": "=t"(__value): "0"(__x)); __asm __volatile("fldcw %0": :"m"(__cw)); + return + __value) +#define __ldexp_code \ + register long double __value; \ + __asm __volatile__ \ + ("fscale" \ + : "=t" (__value) : "0" (__x), "u" ((long double) __y)); \ + return __value +__MATH_INLINE double ldexp(double __x, int __y); +__MATH_INLINE double ldexp(double __x, int __y) +{ + __ldexp_code; +} + + +/* Optimized versions for some non-standardized functions. */ +#if defined __USE_ISOC9X || defined __USE_MISC + +__inline_mathcode(expm1, __x, __expm1_code) +/* We cannot rely on M_SQRT being defined. So we do it for ourself + here. */ +# define __M_SQRT2 1.41421356237309504880L /* sqrt(2) */ + __inline_mathcode(log1p, __x, + register long double __value; + if (__fabsl(__x) >= 1.0 - 0.5 * __M_SQRT2) + __value = logl(1.0 + __x); + else +__asm __volatile__("fldln2\n\t" "fxch\n\t" "fyl2xp1": "=t"(__value):"0"(__x)); + return + __value) + + +/* The argument range of the inline version of asinhl is slightly reduced. */ + __inline_mathcode(asinh, __x, + register long double __y = __fabsl(__x); + return (log1pl + (__y * __y / + (__sqrtl(__y * __y + 1.0) + 1.0) + + __y) * + __sgn1l(__x))) __inline_mathcode(acosh, __x, + return + logl(__x + + __sqrtl + (__x - + 1.0) + * + __sqrtl + (__x + + 1.0))) + __inline_mathcode(atanh, __x, register long double __y = __fabsl(__x); + return -0.5 * log1pl(-(__y + __y) / (1.0 + __y)) * + __sgn1l(__x)) +/* The argument range of the inline version of hypotl is slightly reduced. */ +__inline_mathcode2(hypot, __x, __y, return __sqrtl(__x * __x + __y * __y)) __inline_mathcode(logb, __x, register long double __value; register long double __junk; __asm __volatile__("fxtract\n\t": "=t"(__junk), "=u"(__value):"0"(__x)); return __value) +#endif +#ifdef __USE_ISOC9X + __inline_mathop(log2, "fld1; fxch; fyl2x") +__MATH_INLINE float ldexpf(float __x, int __y); +__MATH_INLINE float ldexpf(float __x, int __y) +{ + __ldexp_code; +} + +__MATH_INLINE long double ldexpl(long double __x, int __y); +__MATH_INLINE long double ldexpl(long double __x, int __y) +{ + __ldexp_code; +} + +__inline_mathcode3(fma, __x, __y, __z, return (__x * __y) + __z) + __inline_mathop(rint, "frndint") +#define __lrint_code \ + long int __lrintres; \ + __asm__ __volatile__ \ + ("fistpl %0" \ + : "=m" (__lrintres) : "t" (__x) : "st"); \ + return __lrintres +__MATH_INLINE long int lrintf(float __x) +{ + __lrint_code; +} + +__MATH_INLINE long int lrint(double __x) +{ + __lrint_code; +} + +__MATH_INLINE long int lrintl(long double __x) +{ + __lrint_code; +} + +#undef __lrint_code + +#define __llrint_code \ + long long int __llrintres; \ + __asm__ __volatile__ \ + ("fistpll %0" \ + : "=m" (__llrintres) : "t" (__x) : "st"); \ + return __llrintres +__MATH_INLINE long long int llrintf(float __x) +{ + __llrint_code; +} + +__MATH_INLINE long long int llrint(double __x) +{ + __llrint_code; +} + +__MATH_INLINE long long int llrintl(long double __x) +{ + __llrint_code; +} + +#undef __llrint_code + +#endif + + +#ifdef __USE_MISC + +__inline_mathcode2(drem, __x, __y, register double __value; register int __clobbered; __asm __volatile__("1: fprem1\n\t" "fstsw %%ax\n\t" "sahf\n\t" "jp 1b": "=t"(__value), "=&a"(__clobbered): "0"(__x), "u"(__y):"cc"); return __value) +/* This function is used in the `isfinite' macro. */ +#if 0 +__MATH_INLINE int __finite(double __x) __attribute__ ((__const__)); +__MATH_INLINE int __finite(double __x) +{ + return (__extension__(((((union { + double __d; + int __i[2]; + } + ) { + __d: __x} + ).__i[1] | 0x800fffff) + 1) >> 31)); +} +#endif + +/* Miscellaneous functions */ + +__inline_mathcode(__coshm1, __x, + register long double __exm1 = __expm1l(__fabsl(__x)); + return 0.5 * (__exm1 / (__exm1 + 1.0)) * __exm1) + __inline_mathcode(__acosh1p, __x, + return log1pl(__x + __sqrtl(__x) * __sqrtl(__x + 2.0))) +#endif /* __USE_MISC */ +/* Undefine some of the large macros which are not used anymore. */ +#undef __expm1_code +#undef __exp_code +#undef __atan2_code +#undef __sincos_code +#endif /* __NO_MATH_INLINES */ +/* This code is used internally in the GNU libc. */ +#ifdef __LIBC_INTERNAL_MATH_INLINES +__inline_mathop(__ieee754_sqrt, "fsqrt") __inline_mathcode2(__ieee754_atan2, __y, __x, register long double __value; __asm __volatile__("fpatan\n\t": "=t"(__value): "0"(__x), "u"(__y):"st(1)"); return __value; + ) +#endif +#endif /* __GNUC__ */ +#endif +#endif diff --git a/src/include/i386/ctrl87.h b/src/include/i386/ctrl87.h new file mode 100644 index 0000000..02b4490 --- /dev/null +++ b/src/include/i386/ctrl87.h @@ -0,0 +1,120 @@ +/* + * This file is part of ms-dos port for XaoS + * ctrl87.h + * + */ + + +#ifndef __CONTROL87_H__ + + +#define __CONTROL87_H__ + + +#ifdef __CONTROL87_C__ +#define EXTERN +#else +#define EXTERN extern +#endif + + +/* 8087/80287 Status Word format */ + +#define SW_INVALID 0x0001 /* Invalid operation */ +#define SW_DENORMAL 0x0002 /* Denormalized operand */ +#define SW_ZERODIVIDE 0x0004 /* Zero divide */ +#define SW_OVERFLOW 0x0008 /* Overflow */ +#define SW_UNDERFLOW 0x0010 /* Underflow */ +#define SW_INEXACT 0x0020 /* Precision (Inexact result) */ + +/* 8087/80287 Control Word format */ + +#define MCW_EM 0x003f /* interrupt Exception Masks */ +#define EM_INVALID 0x0001 /* invalid */ +#define EM_DENORMAL 0x0002 /* denormal */ +#define EM_ZERODIVIDE 0x0004 /* zero divide */ +#define EM_OVERFLOW 0x0008 /* overflow */ +#define EM_UNDERFLOW 0x0010 /* underflow */ +#define EM_INEXACT 0x0020 /* inexact (precision) */ + +#define MCW_IC 0x1000 /* Infinity Control */ +#define IC_AFFINE 0x1000 /* affine */ +#define IC_PROJECTIVE 0x0000 /* projective */ + +#define MCW_RC 0x0c00 /* Rounding Control */ +#define RC_CHOP 0x0c00 /* chop */ +#define RC_UP 0x0800 /* up */ +#define RC_DOWN 0x0400 /* down */ +#define RC_NEAR 0x0000 /* near */ + +#define MCW_PC 0x0300 /* Precision Control */ +#define PC_24 0x0000 /* 24 bits */ +#define PC_53 0x0200 /* 53 bits */ +#define PC_64 0x0300 /* 64 bits */ + +/**************************************************************************/ +/************************* Type declarations **************************/ +/**************************************************************************/ + +/**************************************************************************/ +/************************ Function declarations ***********************/ +/**************************************************************************/ + +/* + _control87 changes floating-point control word. + + Declaration: + ------------ + unsigned short _control87(unsigned short newcw, unsigned short mask); + + Remarks: + -------- + _control87 retrieves or changes the floating-point control word. + + The floating-point control word is an unsigned short that specifies the + following modes in the 80x87 FPU: + o allowed exceptions + o infinity mode + o rounding mode + o precision mode + + Changing these modes allows you to mask or unmask floating-point exceptions. + + _control87 matches the bits in mask to the bits in newcw. + + If any mask bit = 1, the corresponding bit in newcw contains the new value + for the same bit in the floating-point control word. + + If mask = 0000, _control87 returns the floating-point control word without + altering it. + + Examples: + --------- + Switching to projective infinity mode: + _control87(IC_PROJECTIVE, MCW_IC); + + Disabling all exceptions: + _control87(MCW_EM, MCW_EM); + + Return Value: + ------------- + The bits in the value returned reflect the new floating-point control word. +*/ +EXTERN unsigned short _control87(unsigned short, unsigned short); + + +/**************************************************************************/ +/************************** Global variables **************************/ +/**************************************************************************/ + + + +#ifdef __CONTROL87_C__ +#else +#endif + + +#undef EXTERN + + +#endif diff --git a/src/include/i386/sstring.h b/src/include/i386/sstring.h new file mode 100644 index 0000000..bd2dd2d --- /dev/null +++ b/src/include/i386/sstring.h @@ -0,0 +1,414 @@ +#if 0 +#ifndef _I386_STRING_I486_H_ +#define _I386_STRING_I486_H_ +#if defined(__OPTIMIZE__) && defined(__GNUC__) && defined(__i386__) +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. + * + * Copyright (C) 1991, 1992 Linus Torvalds + * Revised and optimized for i486/pentium + * 1994/03/15 by Alberto Vignani/Davide Parodi @crf.it + * + * Split into 2 CPU specific files by Alan Cox to keep #ifdef noise down. + * + * Revised and optimized again by Jan Hubicka (1997/11/16) + * (please report bugs to hubicka@paru.cas.cz) + * + * memset and memcpy routines seems to be always faster at 486 and + * pentium but at pentium MMX they are sometimes bit slower (5-10%).. + * because of less strict register allocation they produces better code. + */ + + +#define __HAVE_ARCH_MEMCPY +#define memcpy(d,s,count) \ +(__builtin_constant_p(count) ? \ + __memcpy_c((d),(s),(count)) : \ + __memcpy_g((d),(s),(count))) + +/* + * These ought to get tweaked to do some cache priming. + */ + + +/* This implementation of the memcpy is designed for moveoldpoints from + * mkrealloctables. It is expected to work well for both small and large + * sizes. + * + * Small (1-10) and meduim (300) sizes seems to be important for XaoS. + * So implementation is not super fast for large sizes, but my experiemnts + * don't show large improvements in speed anyway. + * + * We use rep movsX operations (they works well on PPro and don't seems to be + * so bad on Pentium) and expect cld operation to be set. Hope that it will + * not make problems. + * + * My attempt was to use c code where possible to let GCC do the + */ +extern inline void *__memcpy_g(void *to, const register void *from, + register size_t n); +extern inline void *__memcpy_g(void *to, const register void *from, + register size_t n) +{ + register void *tmp = (void *) to; + if (n >= 7) { + register int c = (-(int) to) & 3; + n -= c; + __asm__ __volatile__( /*Align the destination */ + "rep\n\tmovsb":"=c"(c), "=D"(tmp), + "=S"(from):"c"(c), "D"((long) tmp), + "S"((long) from):"memory"); + c = n >> 2; + __asm__ __volatile__( /*Copy the main body */ + "rep\n\tmovsl":"=c"(c), "=D"(tmp), + "=S"(from):"c"(c), "D"((long) tmp), + "S"((long) from):"memory"); + n &= 3; + } + __asm__ __volatile__("rep\n\tmovsb":"=c"(n), "=D"(tmp), + "=S"(from):"c"(n), "D"((long) tmp), + "S"((long) from):"memory"); + return (to); +} + +/* + * This looks horribly ugly, but the compiler can optimize it totally, + * as the count is constant. + */ + +#define COMMON(x) \ +__asm__ __volatile__ ( \ + "\n.align 4\n" \ + "1:\tmovl (%2),%0\n\t" \ + "addl $4,%2\n\t" \ + "movl %0,(%1)\n\t" \ + "addl $4,%1\n\t" \ + "decl %3\n\t" \ + "jnz 1b\n" \ + x \ + :"=r" (dummy1), "=r" (tmp), "=r" (from), "=r" (dummy2) \ + :"1" (tmp), "2" (from), "3" (n/4) \ + :"memory"); \ +return (to); \ + +extern inline void *__memcpy_c(void *to, const void *from, size_t n); +extern inline void *__memcpy_c(void *to, const void *from, size_t n) +{ + if (n < 24) { + if (n >= 4) + ((unsigned long *) to)[0] = ((const unsigned long *) from)[0]; + if (n >= 8) + ((unsigned long *) to)[1] = ((const unsigned long *) from)[1]; + if (n >= 12) + ((unsigned long *) to)[2] = ((const unsigned long *) from)[2]; + if (n >= 16) + ((unsigned long *) to)[3] = ((const unsigned long *) from)[3]; + if (n >= 20) + ((unsigned long *) to)[4] = ((const unsigned long *) from)[4]; + switch ((unsigned int) (n % 4)) { + case 3: + ((unsigned short *) to)[n / 2 - 1] = + ((const unsigned short *) from)[n / 2 - 1]; + ((unsigned char *) to)[n - 1] = + ((const unsigned char *) from)[n - 1]; + return to; + case 2: + ((unsigned short *) to)[n / 2 - 1] = + ((const unsigned short *) from)[n / 2 - 1]; + return to; + case 1: + ((unsigned char *) to)[n - 1] = + ((const unsigned char *) from)[n - 1]; + case 0: + return to; + } + } + { + register void *tmp = (void *) to; + register int dummy1, dummy2; + switch ((unsigned int) (n % 4)) { + case 0: + COMMON(""); + case 1: + COMMON("movb (%2),%b0 ; movb %b0,(%1)"); + case 2: + COMMON("movw (%2),%w0 ; movw %w0,(%1)"); + case 3: + COMMON("movw (%2),%w0 ; movw %w0,(%1)\n\t" + "movb 2(%2),%b0 ; movb %b0,2(%1)"); + } + } + return to; +} + +#undef COMMON + + +#define __HAVE_ARCH_MEMMOVE +extern inline void *memmove(void *dest, const void *src, size_t n); +extern inline void *memmove(void *dest, const void *src, size_t n) +{ + register void *tmp = (void *) dest; + if (dest < src) + __asm__ __volatile__("cld\n\t" "rep\n\t" "movsb": /* no output */ + :"c"(n), "S"(src), "D"(tmp):"cx", "si", "di", + "memory"); + else + __asm__ __volatile__("std\n\t" "rep\n\t" "movsb\n\t" "cld": /* no output */ + : "c"(n), "S"(n - 1 + (const char *) src), "D"(n - 1 + (char *) tmp):"cx", "si", "di", "memory"); + return dest; +} + +#define memcmp __builtin_memcmp + +#define __HAVE_ARCH_MEMCHR +extern inline void *memchr(const void *cs, int c, size_t count); +extern inline void *memchr(const void *cs, int c, size_t count) +{ + register void *__res; + if (!count) + return NULL; + __asm__ __volatile__("cld\n\t" + "repne\n\t" + "scasb\n\t" + "je 1f\n\t" + "movl $1,%0\n" + "1:\tdecl %0":"=D"(__res):"a"(c), "D"(cs), + "c"(count):"cx"); + return __res; +} + + + +#define __HAVE_ARCH_MEMSET +#define memset(s,c,count) \ +(__builtin_constant_p(c) ? \ + (__builtin_constant_p(count) ? \ + __memset_cc((s),(c),(count)) : \ + __memset_cg((s),(c),(count))) : \ + (__builtin_constant_p(count) ? \ + __memset_gc((s),(c),(count)) : \ + __memset_gg((s),(c),(count)))) + + + + +extern inline void *__memset_cg(void *s, char c, size_t count); +extern inline void *__memset_cg(void *s, char c, size_t count) +{ + int tmp2; + register void *tmp = (void *) s; + __asm__ __volatile__("shrl $1,%%ecx\n\t" + "rep\n\t" + "stosw\n\t" + "jnc 1f\n\t" + "movb %%al,(%%edi)\n" + "1:":"=c"(tmp2), "=D"(tmp):"c"(count), "D"(tmp), + "a"(0x0101U * (unsigned char) c):"memory"); + return s; +} + +extern inline void *__memset_gg(void *s, char c, size_t count); +extern inline void *__memset_gg(void *s, char c, size_t count) +{ + register void *tmp = (void *) s; + int tmp2; + __asm__ __volatile__("movb %%al,%%ah\n\t" + "shrl $1,%%ecx\n\t" + "rep\n\t" + "stosw\n\t" + "jnc 1f\n\t" + "movb %%al,(%%edi)\n" + "1:":"=c"(tmp2), "=D"(tmp):"c"(count), "D"(tmp), + "a"(c):"memory"); + return s; +} + +/* + * This non-rep routines are not much faster (slower for small strings) + * but they allows better register allocation + */ +#define COMMON(x) \ +__asm__ __volatile__ ( \ + "\n.align 4\n" \ + "1:\tmovl %k2,(%k0)\n\t" \ + "addl $4,%k0\n\t" \ + "decl %k1\n\t" \ + "jnz 1b\n" \ + x \ + :"=r" (tmp), "=r" (dummy) \ + :"q" ((unsigned) pattern), "0" (tmp), "1" (count/4) \ + :"memory"); \ +return s; + +extern inline void *__memset_cc(void *s, unsigned long pattern, + size_t count); +extern inline void *__memset_cc(void *s, unsigned long pattern, + size_t count) +{ + pattern = ((unsigned char) pattern) * 0x01010101UL; + if (count < 24) { + /*Handle small values manualy since they are incredibly slow */ + + if (count >= 4) + *(unsigned long *) s = pattern; + if (count >= 8) + ((unsigned long *) s)[1] = pattern; + if (count >= 12) + ((unsigned long *) s)[2] = pattern; + if (count >= 16) + ((unsigned long *) s)[3] = pattern; + if (count >= 20) + ((unsigned long *) s)[4] = pattern; + switch ((unsigned int) (count % 4)) { + case 3: + ((unsigned short *) s)[count / 2 - 1] = pattern; + ((unsigned char *) s)[count - 1] = pattern; + return s; + case 2: + ((unsigned short *) s)[count / 2 - 1] = pattern; + return s; + case 1: + ((unsigned char *) s)[count - 1] = pattern; + case 0: + return s; + } + } else { + register void *tmp = (void *) s; + register int dummy; + switch ((unsigned int) (count % 4)) { + case 0: + COMMON(""); + case 1: + COMMON("movb %b2,(%0)"); + case 2: + COMMON("movw %w2,(%0)"); + case 3: + COMMON("movw %w2,(%0)\n\tmovb %b2,2(%0)"); + } + } + return s; +} + +extern inline void *__memset_gc(void *s, unsigned long pattern, + size_t count); +extern inline void *__memset_gc(void *s, unsigned long pattern, + size_t count) +{ + if (count < 4) { + if (count > 1) + __asm__("movb %b0,%h0\n\t": "=q"(pattern):"0"((unsigned) + pattern)); + switch ((unsigned int) (count)) { + case 3: + ((unsigned short *) s)[0] = pattern; + ((unsigned char *) s)[2] = pattern; + return s; + case 2: + *((unsigned short *) s) = pattern; + return s; + case 1: + *(unsigned char *) s = pattern; + case 0: + return s; + } + } + + __asm__("movb %b0,%h0\n\t" "pushw %w0\n\t" "shll $16,%k0\n\t" "popw %w0\n": "=q"(pattern):"0"((unsigned) + pattern)); + + if (count < 24) { + /*Handle small values manualy since they are incredibly slow */ + + *(unsigned long *) s = pattern; + if (count >= 8) + ((unsigned long *) s)[1] = pattern; + if (count >= 12) + ((unsigned long *) s)[2] = pattern; + if (count >= 16) + ((unsigned long *) s)[3] = pattern; + if (count >= 20) + ((unsigned long *) s)[4] = pattern; + switch ((unsigned int) (count % 4)) { + case 3: + ((unsigned short *) s)[count / 2 - 1] = pattern; + ((unsigned char *) s)[count - 1] = pattern; + return s; + case 2: + ((unsigned short *) s)[count / 2 - 1] = pattern; + return s; + case 1: + ((unsigned char *) s)[count - 1] = pattern; + case 0: + return s; + } + } else { + register void *tmp = (void *) s; + register int dummy; + switch ((unsigned int) (count % 4)) { + case 0: + COMMON(""); + case 1: + COMMON("movb %b2,(%0)"); + case 2: + COMMON("movw %w2,(%0)"); + case 3: + COMMON("movw %w2,(%0)\n\tmovb %b2,2(%0)"); + } + } + return s; +} + +#undef COMMON + + +/* + * find the first occurrence of byte 'c', or 1 past the area if none + */ +#define __HAVE_ARCH_MEMSCAN +extern inline void *memscan(void *addr, int c, size_t size); +extern inline void *memscan(void *addr, int c, size_t size) +{ + if (!size) + return addr; + __asm__ __volatile__("cld\n\t" + "repnz; scasb\n\t" + "jnz 1f\n\t" + "dec %%edi\n\t" + "1:":"=D"(addr), "=c"(size):"0"(addr), "1"(size), + "a"(c)); + return addr; +} + +#define memset_long(x,y,z) __memset_long(x,y,z) + +extern inline void *__memset_long(void *s, char c, size_t count); +extern inline void *__memset_long(void *s, char c, size_t count) +{ + register unsigned int fill = c; + register void *tmp = (void *) s; + if (count >= 7) { + register int c = (-(int) s) & 3; +/*__asm__ __volatile__ ("movb %b0,%h0":"=r"(fill):"r"(fill));*/ + fill |= fill << 8; + count -= c; + fill |= fill << 16; + __asm__ __volatile__("rep\n\tstosb":"=c"(c), "=D"(tmp):"c"(c), + "D"(tmp), "a"(fill):"memory"); + c = count >> 2; + __asm__ __volatile__("rep\n\tstosl":"=c"(c), "=D"(tmp):"c"(c), + "D"(tmp), "a"(fill):"memory"); + count &= 3; + } + __asm__ __volatile__("rep\n\tstosb":"=c"(count), "=D"(tmp):"c"(count), + "D"(tmp), "a"((char) fill):"memory"); + return s; +} +#endif +#endif +#endif diff --git a/src/include/include.pri b/src/include/include.pri new file mode 100644 index 0000000..22a4996 --- /dev/null +++ b/src/include/include.pri @@ -0,0 +1,38 @@ +HEADERS += \ + $$PWD/archaccel.h \ + $$PWD/btrace.h \ + $$PWD/c256.h \ + $$PWD/catalog.h \ + $$PWD/complex.h \ + $$PWD/cursor.h \ + $$PWD/fconfig.h \ + $$PWD/filter.h \ + $$PWD/formulas.h \ + $$PWD/fractal.h \ + $$PWD/gccaccel.h \ + $$PWD/gccbuild.h \ + $$PWD/generic.h \ + $$PWD/grlib.h \ + $$PWD/hicolor.h \ + $$PWD/misc-f.h \ + $$PWD/param.h \ + $$PWD/pixel_t.h \ + $$PWD/plane.h \ + $$PWD/sffe.h \ + $$PWD/sffe_cmplx_asm.h \ + $$PWD/sffe_cmplx_gsl.h \ + $$PWD/timers.h \ + $$PWD/true24.h \ + $$PWD/truecolor.h \ + $$PWD/ui.h \ + $$PWD/ui_helper.h \ + $$PWD/xerror.h \ + $$PWD/xio.h \ + $$PWD/xldio.h \ + $$PWD/xmenu.h \ + $$PWD/xshl.h \ + $$PWD/xthread.h \ + $$PWD/zoom.h \ + $$PWD/i386/ctrl87.h \ + $$PWD/i386/sstring.h \ + $$PWD/i386/__math.h diff --git a/src/include/misc-f.h b/src/include/misc-f.h new file mode 100644 index 0000000..64ed054 --- /dev/null +++ b/src/include/misc-f.h @@ -0,0 +1,17 @@ +#ifndef IUTIL_H +#define IUTIL_H +#include +#ifdef __cplusplus +extern "C" { +#endif + struct image; + + CONST char *writepng(xio_constpath filename, CONST struct image *image); + void XaoS_srandom(unsigned int x); + long int XaoS_random(void); + char *mystrdup(CONST char *); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/src/include/param.h b/src/include/param.h new file mode 100644 index 0000000..c9ac6f1 --- /dev/null +++ b/src/include/param.h @@ -0,0 +1,48 @@ +/* + * XaoS, a fast portable realtime fractal zoomer + * Copyright (C) 1996,1997 by + * + * Jan Hubicka (hubicka@paru.cas.cz) + * Thomas Marsh (tmarsh@austin.ibm.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#ifndef PARAMS_H +#define PARAMS_H + +#ifdef __cplusplus +extern "C" { +#endif + + struct params { + CONST char *name; + int type; + void *value; + CONST char *help; + }; + +#define P_SWITCH 0 +#define P_NUMBER 1 +#define P_STRING 2 +#define P_FLOAT 3 +#define P_HELP 4 + + int params_parser(int, char **); + void params_register(CONST struct params *par); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/src/include/pixel_t.h b/src/include/pixel_t.h new file mode 100644 index 0000000..9b9555c --- /dev/null +++ b/src/include/pixel_t.h @@ -0,0 +1,21 @@ +#if SIZEOF_INT==4 +typedef unsigned int pixel32_t; +#elif SIZEOF_LONG==4 +typedef unsigned long pixel32_t; +#else +/*#error define size for pixel32 please */ +00 +#endif +#if SIZEOF_SHORT==2 +typedef unsigned short pixel16_t; +#elif SIZEOF_INT==2 +typedef unsigned int pixel16_t; +#else +/*#error define size for pixel16 please */ + 00 +#endif +typedef unsigned char pixel8_t; +typedef unsigned char ppixel24_t[3]; +typedef pixel8_t *ppixel8_t; +typedef pixel16_t *ppixel16_t; +typedef pixel32_t *ppixel32_t; diff --git a/src/include/plane.h b/src/include/plane.h new file mode 100644 index 0000000..a37b16a --- /dev/null +++ b/src/include/plane.h @@ -0,0 +1,58 @@ +/* + * XaoS, a fast portable realtime fractal zoomer + * Copyright (C) 1996,1997 by + * + * Jan Hubicka (hubicka@paru.cas.cz) + * Thomas Marsh (tmarsh@austin.ibm.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#ifndef PLANE_H +#define PLANE_H + +#include +#include + +#ifdef SFFE_USING +#include "sffe.h" +#endif + +#ifdef __cplusplus +extern "C" { +#endif + + +/*#define PLANES 7*/ +#define P_MU 0 +#define P_INVERSE 1 +#define P_PARABOL 2 +#define P_LAMBDA 3 +#define P_INVLAMBDA 4 +#define P_TRANLAMBDA 5 +#define P_MEREBERG 6 +#define P_USER 7 + extern void recalculate(int plane, number_t *, + number_t *) REGISTERS(3); + + extern CONST char *CONST planename[]; + +#ifdef SFFE_USING + extern CONST sffe *planec; +#endif + +#ifdef __cplusplus +} +#endif +#endif /* PLANE_H */ diff --git a/src/include/sffe.h b/src/include/sffe.h new file mode 100644 index 0000000..3f21869 --- /dev/null +++ b/src/include/sffe.h @@ -0,0 +1,139 @@ +/*///////////////////////////////////////////////////////////////////////////////////// +// project : sFFe ( SegFault (or Segmentation Fault :) ) formula evalutaor ) +// author : Mateusz Malczak ( mateusz@malczak.info ) +// wpage : www.segfaultlabs.com/projects/sffe +/////////////////////////////////////////////////////////////////////////////////////// +// possible config definitions +// general +// SFFE_DEVEL - print extra info to stdout +// SFFE_DLL - Windows DLL +// complex numbers +// SFFE_CMPLX_GSL - uses GSL complex number routines +// SFFE_CMPLX_ASM - uses my asm complex unit (compile it with NASM) +/////////////////////////////////////////////////////////////////////////////////////// +// special build for XaoS, for more info visit +// http://www.segfaultlabs.com/projects/sfXaos +/////////////////////////////////////////////////////////////////////////////////////*/ + +#ifndef SFFE_H +#define SFFE_H +#include +#include + +/* dont udef next line. removing this definitions can lead to compile and/or runtime errors */ +#define SFFE_COMPLEX 1 + +/* --- */ +/*TODO long double needed*/ +#ifdef SFFE_CMPLX_ASM +typedef struct cmpx__ { + double r, i; +} cmplx; +#define sfNumber cmplx +#elif SFFE_CMPLX_GSL +#include +typedef gsl_complex cmplx; +#define sfNumber gsl_complex +#endif + +/* basic sffe argument 'stack' */ +typedef struct sfargument__ { + struct sfargument__ *parg; + sfNumber *value; +} sfarg; + +/* sffe function prototype, parameters order is right-to-left (cdecl) */ +typedef sfarg *(*sffptr) (sfarg * const a); + +/* constats eval functions */ +typedef void (*cfptr) (sfNumber * cnst); + +/* function type structure */ +typedef struct sffunction__ { + sffptr fptr; + unsigned char parcnt; + /*FIXME changed from char* to char[20] to get rid of warnings during compilation */ + char name[20]; +} sffunction; + +/* basic sffe 'stack' operation ( function + result slot ) */ +typedef struct sfoperation__ { + sfarg *arg; + sffptr f; +} sfopr; + +/* SFFE main structure */ +typedef struct sffe__ { +/*public*/ + char *expression; /* parsed expression (read-only) */ + char *errormsg; /* parser errors (read-only) */ + sfNumber *result; /* evaluation result (read-only) */ +/* protected/private */ + unsigned int argCount; /* number of argument in use */ + sfarg *args; + unsigned int oprCount; /* number of operations in use */ + sfopr *oprs; + unsigned int varCount; /* number of used variables */ + char *varChars; + sfNumber **varPtrs; + unsigned int userfCount; /* number of user functions */ + sffunction *userf; +/* not used + unsigned int stCount; + sfNumber* statics; +*/ +} sffe; + +#define SFFE sffe +#define sffeparser sffe +#define sfparser sffe +#define SFFEPARSER sffe + +/* 'stack' slot value */ +#define sfvalue(p) (*((p)->value)) + +/* function parameters */ +#define sfaram1(p) ((p)->parg) +#define sfaram2(p) ((p)->parg->parg) +#define sfaram3(p) ((p)->parg->parg->parg) +#define sfaram4(p) ((p)->parg->parg->parg->parg) +#define sfaram5(p) ((p)->parg->parg->parg->parg->parg) +/* and so on */ + + +#ifdef __cplusplus +extern "C" { +#endif + +/* create formula evaluator structure */ + sffe *sffe_alloc(void); +/* free fe structure */ + void sffe_free(sffe ** parser); +/* parse expression 'expression' and strore result in 'parser' struct, error (if any) returned */ + int sffe_parse(sffe ** parser, char *expression); +/* evaulate function and return evaluation result */ + sfNumber sffe_eval(sffe * const parser); +/* evaluate without returnig result */ +//void sffe_eval2(sffe *const parser); +/* register user function with name 'vname', with 'parcnt' parameters and defined with function pointed by 'funptr'*/ + void *sffe_regfunc(sffe ** parser, char *vname, unsigned int parcnt, + sffptr funptr); +/* register single variable 'vptrs' identified by name 'vchars' */ + void *sffe_regvar(sffe ** parser, sfNumber * vptrs, char vchars); +/* register multiple variables */ + void *sffe_regvars(sffe ** parser, unsigned int cN, sfNumber ** vptrs, + char *vchars); +/* get variable 'vchar' pointer */ + sfNumber *sffe_varptr(sffe * const parser, char vchar); +/* set 'vptrs' as 'vchars' variable */ + sfNumber *sffe_setvar(sffe ** parser, sfNumber * vptrs, char vchars); + +#ifdef __cplusplus +} +#endif +#ifdef SFFE_CMPLX_ASM +#include "sffe_cmplx_asm.h" +#elif SFFE_CMPLX_GSL +#include "sffe_cmplx_gsl.h" +#endif +#endif diff --git a/src/include/sffe_cmplx_asm.h b/src/include/sffe_cmplx_asm.h new file mode 100644 index 0000000..f14aae8 --- /dev/null +++ b/src/include/sffe_cmplx_asm.h @@ -0,0 +1,140 @@ +/*///////////////////////////////////////////////////////////////////////////////////// +// project : sFFe ( SegFault (or Segmentation Fault :) ) formula evalutaor ) +// author : Mateusz Malczak ( mateusz@malczak.info ) +// wpage : www.segfaultlabs.com/projects/sffe +/////////////////////////////////////////////////////////////////////////////////////// +// special build for XaoS, for more info visit +// http://www.segfaultlabs.com/projects/sfXaos +/////////////////////////////////////////////////////////////////////////////////////*/ +#ifndef SFFE_CMPLX_ASM_H +#define SFFE_CMPLX_ASM_H + +#include +#ifdef SFFE_CMPLX_ASM + +#include "sffe.h" + +#define sffnctscount 43 +#define sfvarscount 6 +#define cmplxset(c,r,i) ( c = cset(r,i) ) +#define real(c) (c).r +#define imag(c) (c).i + +#ifdef __ELF__ +#define sffecabs _sffecabs +#define sffecarg _sffecarg +#define sffecargs _sffecargs +#define sffecargc _sffecargc +#define sffecinv _sffecinv +#define sffecexp _sffecexp +#define sffecln _sffecln +#define sffeclog2 _sffeclog2 +#define sffeclog _sffeclog +#define sffecsin _sffecsin +#define sffeccos _sffeccos +#define sffectan _sffectan +#define sffeccot _sffeccot +#define sffecsinh _sffecsinh +#define sffeccosh _sffeccosh +#define sffectanh _sffectanh +#define sffeccoth _sffeccoth +#define sffeccpow _sffeccpow +#define sffecpowd _sffecpowd +#define sffecpowi _sffecpowi +#define sffecpowc _sffecpowc +#define sffecsqrt _sffecsqrt +#define sffecrtni _sffecrtni +#endif + +#ifdef __cplusplus +extern "C" { +#endif + + /* written with asm in file cmplx.asm, compile with NASM */ + extern double sffecabs(const cmplx c); + extern double sffecarg(const cmplx c); + extern double sffecargs(const cmplx c); + extern double sffecargc(const cmplx c); + extern cmplx sffecinv(const cmplx c); + extern cmplx sffecexp(const cmplx c); + extern cmplx sffecln(const cmplx c); + extern cmplx sffeclog2(const cmplx c); + extern cmplx sffeclog(const cmplx c, unsigned int base); + extern cmplx sffecsin(const cmplx c); + extern cmplx sffeccos(const cmplx c); + extern cmplx sffectan(const cmplx c); + extern cmplx sffeccot(const cmplx c); + extern cmplx sffecsinh(const cmplx c); + extern cmplx sffeccosh(const cmplx c); + extern cmplx sffectanh(const cmplx c); + extern cmplx sffeccoth(const cmplx c); + /* power functions */ + extern cmplx sffeccpow(const cmplx b, const cmplx exp); + extern cmplx sffecpowd(const cmplx b, double exp); + extern cmplx sffecpowi(const cmplx b, int exp); + extern cmplx sffecpowc(double b, const cmplx exp); + extern cmplx sffecsqrt(const cmplx b); /* square root */ + extern cmplx sffecrtni(const cmplx b, int n, int i); /* i-th solution of N-th order root of a CN */ +/*complex numbers for mparser*/ + cmplx cset(double r, double i); + cmplx cadd(const cmplx c1, const cmplx c2); + cmplx csub(const cmplx c1, const cmplx c2); + cmplx cmul(const cmplx c1, const cmplx c2); + cmplx cdiv(const cmplx c1, const cmplx c2); + sfarg *sfadd(sfarg * const p); /* + */ + sfarg *sfsub(sfarg * const p); /* - */ + sfarg *sfmul(sfarg * const p); /* * */ + sfarg *sfdiv(sfarg * const p); /* / */ + sfarg *sfsin(sfarg * const p); /* sin */ + sfarg *sfcos(sfarg * const p); /* cos */ + sfarg *sftan(sfarg * const p); /* tan */ + sfarg *sfcot(sfarg * const p); /* ctan */ + sfarg *sfasin(sfarg * const p); /* asin */ + sfarg *sfacos(sfarg * const p); /* acos */ + sfarg *sfatan(sfarg * const p); /* atan */ + sfarg *sfacot(sfarg * const p); /* actan */ + sfarg *sfatan2(sfarg * const p); /* atan2 */ + sfarg *sfsinh(sfarg * const p); /* sinh */ + sfarg *sfcosh(sfarg * const p); /* cosh */ + sfarg *sftanh(sfarg * const p); /* tanh */ + sfarg *sfcoth(sfarg * const p); /* ctanh */ + sfarg *sfexp(sfarg * const p); /* exp */ + sfarg *sflog(sfarg * const p); /* log */ + sfarg *sflog2(sfarg * const p); /* log2 */ + sfarg *sflog10(sfarg * const p); /* log2 */ + sfarg *sflogN(sfarg * const p); /* logN */ + sfarg *sflogCN(sfarg * const p); /* logCN */ + sfarg *sfpow(sfarg * const p); /* csflx pow */ + sfarg *sfpowi(sfarg * const p); /* int pow */ + sfarg *sfpowd(sfarg * const p); /* double pow */ + sfarg *sfpowdc(sfarg * const p); /* double to csflx pow */ + sfarg *sfsqr(sfarg * const p); /* sqr */ + sfarg *sfsqrt(sfarg * const p); /* sqrt */ + sfarg *sfrtni(sfarg * const p); /* rtni *//*cos tu nie tak jak powinno byc ;( */ + sfarg *sfinv(sfarg * const p); /* cinv */ + sfarg *sfceil(sfarg * const p); /* ceil */ + sfarg *sffloor(sfarg * const p); /* floor */ + sfarg *sfabs(sfarg * const p); /* abs - |z| */ + sfarg *sfre(sfarg * const p); /* RE */ + sfarg *sfim(sfarg * const p); /* IM */ + sfarg *sfrabs(sfarg * const p); /* abs - real numbers */ + sfarg *sfrand(sfarg * const p); /* rand */ +/*const eval*/ + void sfcPI(sfNumber * cnst); + void sfcPI2(sfNumber * cnst); + void sfc2PI(sfNumber * cnst); + void sfcE(sfNumber * cnst); + void sfcI(sfNumber * cnst); + void sfcRND(sfNumber * cnst); +#ifdef __cplusplus +} +#endif +/* all available function (function pointer, number of parameters, name )*/ + extern const sffunction sfcmplxfunc[sffnctscount]; +/* all available buildin variables */ +extern const char sfcnames[sfvarscount][5]; +/* available variables function pointers */ +extern const cfptr sfcvals[sfvarscount]; + +#endif +#endif diff --git a/src/include/sffe_cmplx_gsl.h b/src/include/sffe_cmplx_gsl.h new file mode 100644 index 0000000..7bc5b66 --- /dev/null +++ b/src/include/sffe_cmplx_gsl.h @@ -0,0 +1,82 @@ +/*///////////////////////////////////////////////////////////////////////////////////// +// project : sFFe ( SegFault (or Segmentation Fault :) ) formula evalutaor ) +// author : Mateusz Malczak ( mateusz@malczak.info ) +// wpage : www.segfaultlabs.com/projects/sffe +/////////////////////////////////////////////////////////////////////////////////////// +// special build for XaoS, for more info visit +// http://www.segfaultlabs.com/projects/sfXaos +/////////////////////////////////////////////////////////////////////////////////////*/ +#ifndef SFFE_CMPLX_GSL_H +#define SFFE_CMPLX_GSL_H + +#include +#ifdef SFFE_CMPLX_GSL + +#include "sffe.h" + +#include +#include + +#define sffnctscount 43 +#define sfvarscount 6 +#define cmplxset(c,r,i) GSL_SET_COMPLEX(&c,r,i) +#define real(c) GSL_REAL((c)) +#define imag(c) GSL_IMAG((c)) + +sfarg *sfadd(sfarg * const p); /* + */ +sfarg *sfsub(sfarg * const p); /* - */ +sfarg *sfmul(sfarg * const p); /* * */ +sfarg *sfdiv(sfarg * const p); /* / */ +sfarg *sfsin(sfarg * const p); /* sin */ +sfarg *sfcos(sfarg * const p); /* cos */ +sfarg *sftan(sfarg * const p); /* tan */ +sfarg *sfcot(sfarg * const p); /* ctan */ +sfarg *sfasin(sfarg * const p); /* asin */ +sfarg *sfacos(sfarg * const p); /* acos */ +sfarg *sfatan(sfarg * const p); /* atan */ +sfarg *sfacot(sfarg * const p); /* actan */ +sfarg *sfatan2(sfarg * const p); /* atan2 */ +sfarg *sfsinh(sfarg * const p); /* sinh */ +sfarg *sfcosh(sfarg * const p); /* cosh */ +sfarg *sftanh(sfarg * const p); /* tanh */ +sfarg *sfcoth(sfarg * const p); /* ctanh */ +sfarg *sfexp(sfarg * const p); /* exp */ +sfarg *sflog(sfarg * const p); /* log */ +sfarg *sflog10(sfarg * const p); /* log10 */ +sfarg *sflog2(sfarg * const p); /* log2 */ +sfarg *sflogN(sfarg * const p); /* logN */ +sfarg *sfpow(sfarg * const p); /* csflx pow */ +sfarg *sfpowd(sfarg * const p); /* double pow */ +sfarg *sfpowi(sfarg * const p); /* double pow */ +sfarg *sfpowdc(sfarg * const p); /* double to csflx pow */ +sfarg *sfsqr(sfarg * const p); /* sqr */ +sfarg *sfsqrt(sfarg * const p); /* sqrt */ +sfarg *sfrtni(sfarg * const p); /* rtni */ +sfarg *sfinv(sfarg * const p); /* cinv */ +sfarg *sfceil(sfarg * const p); /* ceil */ +sfarg *sffloor(sfarg * const p); /* floor */ +sfarg *sfabs(sfarg * const p); /* abs - |z| */ +sfarg *sfre(sfarg * const p); /* RE */ +sfarg *sfim(sfarg * const p); /* IM */ +sfarg *sfrabs(sfarg * const p); /* abs - real numbers */ +sfarg *sfrand(sfarg * const p); /* rand */ +/*const eval*/ +void sfcPI(sfNumber * cnst); +void sfcPI2(sfNumber * cnst); +void sfc2PI(sfNumber * cnst); +void sfcE(sfNumber * cnst); +void sfcI(sfNumber * cnst); +void sfcRND(sfNumber * cnst); +#ifdef __cplusplus +} +#endif + +/* all available function (function pointer, number of parameters, name )*/ +extern const sffunction sfcmplxfunc[sffnctscount]; +/* all available buildin variables */ +extern const char sfcnames[sfvarscount][5]; +/* available variables function pointers */ +extern const cfptr sfcvals[sfvarscount]; + +#endif +#endif diff --git a/src/include/timers.h b/src/include/timers.h new file mode 100644 index 0000000..140151f --- /dev/null +++ b/src/include/timers.h @@ -0,0 +1,67 @@ +/* + * XaoS, a fast portable realtime fractal zoomer + * Copyright (C) 1996,1997 by + * + * Jan Hubicka (hubicka@paru.cas.cz) + * Thomas Marsh (tmarsh@austin.ibm.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef TIMERS_H +#define TIMERS_H +#include "config.h" +#ifdef __cplusplus +extern "C" { +#endif + + struct timer; + struct timeemulator; + typedef struct timer tl_timer; + typedef struct timer tl_group; + + void tl_update_time(void); + tl_timer *tl_create_timer(void); + tl_group *tl_create_group(void); + void tl_set_interval(tl_timer * timer, int interval); + void tl_set_handler(tl_timer * timer, void (*handler) (void *), + void *userdata); + void tl_set_multihandler(tl_timer * timer, + void (*handler) (void *, int), + void *userdata); + void tl_add_timer(tl_group * group, tl_timer * timer); + void tl_remove_timer(tl_timer * timer); + void tl_free_timer(tl_timer * timer); + void tl_free_group(tl_group * timer); + void tl_stop_timer(tl_timer * t); + void tl_resume_timer(tl_timer * t); + void tl_slowdown_timer(tl_timer * t, int time); + int tl_process_group(tl_group * group, int *activated); + extern tl_group *syncgroup, *asyncgroup; + void tl_sleep(int); + void tl_allegromode(int mode); /*Just for djgpp */ + int tl_lookup_timer(tl_timer * t) REGISTERS(3); + void tl_reset_timer(tl_timer * t) REGISTERS(3); + + struct timeemulator *tl_create_emulator(void); + void tl_free_emulator(struct timeemulator *t); + void tl_elpased(struct timeemulator *t, int elpased); + void tl_emulate_timer(struct timer *t, struct timeemulator *e); + void tl_unemulate_timer(struct timer *t); + +#ifdef __cplusplus +} +#endif +#endif /* TIMER_H */ diff --git a/src/include/true24.h b/src/include/true24.h new file mode 100644 index 0000000..de626a3 --- /dev/null +++ b/src/include/true24.h @@ -0,0 +1,31 @@ +#ifdef cpixel_t +#undef cpixel_t +#undef cpixeldata_t +#undef cppixel_t +#undef cpixeldata_t +#undef bpp +#undef bpp1 +#undef p_add +#undef p_inc +#undef p_set +#undef p_get +#undef p_setp +#undef UNSUPPORTED +#undef p_getp +#undef p_copy +#endif +#ifndef STRUECOLOR24 +#define UNSUPPORTED +#endif +#define cpixel_t pixel8_t +#define cppixel_t ppixel8_t +#define cpixeldata_t pixel32_t +#define bpp 3 +/*FIXME this should make problems at small edian machines? */ +#define p_set(ptr,val) ((*(pixel16_t *)(ptr))=(pixel16_t)(val),((ptr)[2])=(pixel8_t)((val)>>16)) +#define p_get(ptr) (((pixel32_t)*(pixel16_t *)(ptr)+(pixel32_t)(*((ptr)+2)<<16))) +#define p_copy(ptr1,pos1,ptr2,pos2) (*((pixel16_t *)((ptr1)+(pos1)*3))=*(pixel16_t *)((ptr2)+(pos2)*3),(ptr1)[(pos1)*3+2]=(ptr2)[(pos2)*3+2]) +#define p_setp(ptr,pos,val) p_set((ptr)+(pos)*3,val) +#define p_getp(ptr,pos) p_get((ptr)+(pos)*3) +#define p_add(ptr,pos) ((ptr)+(pos)*3) +#define p_inc(ptr,pos) ((ptr)+=(pos)*3) diff --git a/src/include/truecolor.h b/src/include/truecolor.h new file mode 100644 index 0000000..9025318 --- /dev/null +++ b/src/include/truecolor.h @@ -0,0 +1,13 @@ +#ifdef cpixel_t +#undef UNSUPPORTED +#undef cpixel_t +#undef cpixeldata_t +#undef cppixel_t +#undef bpp +#undef bpp1 +#endif +#define cpixel_t pixel32_t +#define cpixeldata_t pixel32_t +#define cppixel_t ppixel32_t +#define bpp 4 +#include diff --git a/src/include/ui.h b/src/include/ui.h new file mode 100644 index 0000000..8bdf783 --- /dev/null +++ b/src/include/ui.h @@ -0,0 +1,160 @@ +/* + * XaoS, a fast portable realtime fractal zoomer + * Copyright (C) 1996,1997 by + * + * Jan Hubicka (hubicka@paru.cas.cz) + * Thomas Marsh (tmarsh@austin.ibm.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#ifndef UI_H +#define UI_H +/* +#include "xio.h" +#include "zoom.h" +*/ +#include "config.h" +#include "param.h" +#include "xmenu.h" +#ifdef __cplusplus +extern "C" { +#endif + + +#undef BUTTON1 +#undef BUTTON2 +#undef BUTTON3 +#define BUTTON1 256 +#define BUTTON2 512 +#define BUTTON3 1024 +#define UI_C256 1 +#define UI_GRAYSCALE 2 +#define UI_TRUECOLOR16 4 +#define UI_TRUECOLOR24 8 +#define UI_TRUECOLOR 16 +#define UI_PROTECTIMAGES 32 +#define UI_LBITMAP 256 +#define UI_MBITMAP 512 +#define UI_LIBITMAP 1024 +#define UI_MIBITMAP 2048 +#define UI_FIXEDCOLOR 4096 + + +#define NORMALMOUSE 0 +#define WAITMOUSE 1 +#define REPLAYMOUSE 2 +#define VJMOUSE 3 + +#define UIKEY_UP 257 +#define UIKEY_DOWN 258 +#define UIKEY_LEFT 259 +#define UIKEY_RIGHT 260 +#define UIKEY_ESC 261 +#define UIKEY_BACKSPACE 8 +#define UIKEY_TAB '\t' +#define UIKEY_HOME 262 +#define UIKEY_END 263 +#define UIKEY_PGUP 264 +#define UIKEY_PGDOWN 265 + + typedef unsigned char ui_rgb[4]; + typedef ui_rgb *ui_palette; + struct uih_context; + struct gui_driver { + void (*setrootmenu) (struct uih_context * c, CONST char *name); + void (*enabledisable) (struct uih_context * c, CONST char *name); + void (*menu) (struct uih_context * c, CONST char *name); + void (*dialog) (struct uih_context * c, CONST char *name); + void (*help) (struct uih_context * c, CONST char *name); + }; + struct ui_driver { + CONST char *name; + int (*init) (void); /*initializing function. recturns 0 if fail */ + void (*getsize) (int *, int *); /*get current size..in fullscreen versions + i.e svga and dos asks user for it */ + void (*processevents) (int, int *, int *, int *, int *); + /*processevents..calls ui_resize,ui_key + laso returns possitions of mouse.. + waits for event if first parameter is + 1 */ + void (*getmouse) (int *, int *, int *); + /*returns current mouse possitions */ + void (*uninit) (void); + /*called before exit */ + int (*set_color) (int, int, int, int); + void (*set_range) (ui_palette palette, int, int); + /*sets palette color and returns number */ + void (*print) (int, int, CONST char *); /*prints text */ + void (*display) (void); /*displays bitmap */ + int (*alloc_buffers) (char **buffer1, char **buffer2); /*makes buffers */ + void (*free_buffers) (char *buffer1, char *buffer2); /*frees buffers */ + void (*flip_buffers) (void); /*prints text */ + void (*mousetype) (int type); + void (*flush) (void); + int textwidth; + int textheight; /*width of text */ + /*int helpsize; */ + CONST struct params *params; + int flags; + float width, height; + int maxwidth, maxheight; + int imagetype; + int palettestart, paletteend, maxentries; + int rmask, gmask, bmask; + CONST struct gui_driver *gui_driver; + }; + + extern struct uih_context *globaluih; + +#ifdef USE_LOCALEPATH + extern char *localepath; +#endif + + number_t ui_getfloat(CONST char *text); + void ui_resize(void); + void ui_call_resize(void); + void ui_quit(void) NORETURN; + void ui_menu(CONST char *text); + void ui_menuactivate(CONST menuitem * item, dialogparam * d); + int ui_key(int); + void ui_loadstr(CONST char *data); + xio_path ui_getfile(CONST char *basename, CONST char *extension); + void ui_help(CONST char *name); + char *ui_getpos(void); + int MAIN_FUNCTION(int argc, char **argv); + + + +#ifndef RANDOM_PALETTE_SIZE +#define RANDOM_PALETTE_SIZE 1 /*FIXME currently ignored */ +#define FULLSCREEN 2 +#define UPDATE_AFTER_PALETTE 4 +#define UPDATE_AFTER_RESIZE 8 +#define PALETTE_ROTATION 16 +#define ASYNC_PALETTE 32 +#define ROTATE_INSIDE_CALCULATION 64 +#define PALETTE_REDISPLAYS 128 +#define SCREENSIZE 256 +#define PIXELSIZE 512 +#define RESOLUTION 1024 +#endif +#define NOFLUSHDISPLAY 2048 +#define AALIB (4096*2) +#define RESIZE_COMMAND (4096*4) + +#ifdef __cplusplus +} +#endif +#endif /* UI_H */ diff --git a/src/include/ui_helper.h b/src/include/ui_helper.h new file mode 100644 index 0000000..73ead16 --- /dev/null +++ b/src/include/ui_helper.h @@ -0,0 +1,550 @@ +#ifndef UI_HELPER_H +#define UI_HELPER_H +#include "timers.h" +#include "xio.h" + +#ifdef SFFE_USING +#include "sffe.h" +#endif + +#ifdef __cplusplus +extern "C" { +#endif +#define MAXFILTERS 20 +#define AVRGSIZE 50 +#define NMESSAGES 5 +#define BGCOLOR(uih) uih->palette->index[0] +#define FGCOLOR(uih) uih->palette->index[1] +#define SELCOLOR(uih) uih->palette->index[2] +#define DARKGRAYCOLOR(uih) uih->palette->index[3] +#define LIGHTGRAYCOLOR(uih) uih->palette->index[4] +#define LIGHTGRAYCOLOR2(uih) uih->palette->index[5] +#define NONTRANSPARENTW 1 +#define DRAWBORDER 2 +#define BORDER_PRESSED 4 +#define BORDER_TRANSPARENT 8 +#define BORDER_LIGHT 16 + + struct uih_message { + char *message[NMESSAGES]; + tl_timer *messagetimer[NMESSAGES]; + int messagetype[NMESSAGES]; + struct uih_window *w[NMESSAGES]; + int pid[NMESSAGES]; + int messagestart; + }; + struct uih_line { + int key; + int morph; + int color; + int posmode; + number_t x1, y1, x2, y2; + int mposmode; + number_t mx1, my1, mx2, my2; + struct uih_line *next, *prev; + struct uih_window *w; + }; + struct uih_lines { + struct uih_line *first; + int morphing; + int currkey; + }; + + struct uih_savedcontext { + xio_file file; + int mode; + number_t speedup, maxstep; + number_t xcenter, ycenter; + tl_timer *timer; + tl_timer *synctimer; + struct fractal_context *fcontext; + int clearscreen; + int fastmode, juliamode, fastrotate, autorotate; + number_t rotationspeed; + int firsttime; + int filter[MAXFILTERS]; + int pressed; + int rotatepressed; + int cycling; + int shifted; + int manualpaletteshift; + int direction; + int cyclingspeed; + int zoomactive; + int xtextpos, ytextpos; + int writefailed; + int nonfractalscreen; + int color; + }; +#define MAXLEVEL 10 /*Maximal include level */ + struct uih_playcontext { + xio_file file; + xio_file prevfiles[MAXLEVEL + 1]; + int level; + xio_path directory; + tl_timer *timer; + int waittime; + int playframe; + int timerin; + int frametime, starttime; + int morph; + int morphtimes[2]; + int morphjulia; + int morphjuliatimes[2]; + int morphangle; + int morphangletimes[2]; + vinfo destination; + vinfo source; + number_t srcangle, destangle; + number_t sr, si, dr, di; + int readfailed; + int line; + struct uih_lines lines; + int morphlinetimes[2]; + }; +#define SQR(val) (((double)(val))*(val)) +#define MORPHVALUE(time,len,starttime,endtime) \ + (time)<0?0.0 \ + :(time)>=(len)?1.0 \ + :(time)<(starttime) && (starttime)?(SQR((time)/(double)(starttime))/2*(starttime)/((len)-(starttime)/2-(endtime)/2))\ + :((len)-(time)<(endtime)) && (endtime)?1-(SQR(((len)-(time))/(double)(endtime))/2*(endtime)/((len)-(starttime)/2-(endtime)/2)) \ + :((time)-(starttime)/2)/((double)(len)-(starttime)/2-(endtime)/2) +#ifdef _NEVER_ +#define MORPHVALUE(time,len,starttime,endtime) \ + (((time))/((double)(len))) +#endif +#define DOMORPH(time,len,starttime,endtime,startval,endval) \ + ((startval)+((endval)-(startval))*MORPHVALUE(time,len, starttime,endtime)) + +#define UNDOLEVEL 256 + struct uih_undocontext { + int last; + char *undos[256]; + }; + struct uih_context { + void (*updatemenus) (struct uih_context *, CONST char *); + /*stuff that should be visible from outside */ + number_t speedup, maxstep; /*zooming speed */ + + /* Informations provided to the user interface: */ + CONST char *menuroot; + int display; /*1 when ui wants to display something */ + int save; /*1 if save animation is enabled */ + int play; /*1 if animation replay is active */ + int cycling; /*1 if cycling is enabled */ + int incalculation; /*1 if calulcation is currently in process */ + int flags; + int interrupt; /*set to interrupt current calculation */ + + /*server's callbacks */ + int (*passfunc) (struct uih_context *, int, CONST char *, float); + void (*longwait) (struct uih_context *); + + struct uih_undocontext undo; + /*Filter system state */ + struct image *image; + struct palette *palette; + struct fractal_context *fcontext; /*fractal informations */ + struct queue *queue; + struct filter *uifilter; /*user interface layer */ + struct filter *rotatef; /* Special filters handler by ui_helper: */ + struct filter *zengine; + struct filter *fixedcolor; + /*Julia/filter mechanizm */ + struct filter *subwindow, *julia, *smalliter; + struct filter *filter[MAXFILTERS]; + + /*General status variables */ + double mul; /*speed of last iteration */ + int rotatemode; /*ROTATE_NONE, ROTATE_CONTINUOUS or ROTATE_NONE */ + number_t rotationspeed; /*speed of continuous rotation */ + int fastmode; /*when draw in fast mode */ + int juliamode; + int fastrotate; + int uncomplette; /*1 if image is not complettly caluclated or in animation */ + int dirty; /*1 if image is inexact */ + int inanimation; /*1 if uih_update wants to be called soon */ + int fastanimation; /*1 if animation needs to be fast */ + int palettetype, paletteseed; /*0 for default palette,1,2 for random */ + int clearscreen; /*1 when ui want to clear screen */ + int indofractal; /*1 when caluclation is in the process */ + int xtextpos, ytextpos; /*possitioning of text */ + int color; /*Color of text */ + int recalculatemode; /*informations for user interface */ + int stoppedtimers; /*1 when timers are stopped */ + int nletters; /*Number of letters displayed at screen */ + int letterspersec; /*Number of letters per second user should read */ + char *text[3]; /*Currently displayed text informations: */ + struct uih_window *textwindow[3], *cscreenwindow; + int textpos[3], textcolor[3]; + CONST char *errstring; /*String of last unprocessed error */ + + CONST struct xfont *font; /*Font used by UI */ + struct uih_window *wtop; + int wflipped; + int wdisplayed; + + /*Save variables */ + int todisplayletters; + struct uih_savedcontext *savec; + int viewchanged; /*When to generate setview commands */ + int palettechanged; /*When to generate setpalette commands */ + int displaytext; /*When text was displayed in this frame */ + int nonfractalscreen; + /*waiting variables */ + void (*complettehandler) (void *); /*Handler to be activated when calculation is complette */ + void *handlerdata; + /*replay variables */ + struct uih_playcontext *playc; + int playpos; + CONST char *playstring; + + /*For constant framerate */ + struct timeemulator *emulator; + int emulatedframetime; + int aliasnum; + int fixedstep; + + /*zoom/unzoom */ + number_t speed, step; + number_t xcenter, ycenter; + int xcenterm, ycenterm; + int zoomactive; + + /*drag&drop move */ + int pressed; + number_t oldx, oldy; + int moved; + + /*drag&drop rotate */ + int rotatepressed; + number_t oldangle; + + int ddatalost; + int tbreak; + + int autopilot; /*for uih side of autopilot */ + int autopilotx, autopiloty, autopilotbuttons; + + /*calculation time variables */ + int interruptiblemode; + int starttime, endtime; + int maxtime; + + /*dynamical timeout measuring */ + int times[2][AVRGSIZE]; /*for statistics */ + int timespos, count[2]; + double lastspeed, lasttime; + + /*number_t xsize, ysize; */ + tl_timer *maintimer, *cyclingtimer, *autopilottimer, + *calculatetimer, *doittimer; + tl_group *autopilotgroup; + + /*color cycling values */ + int direction; + int cyclingdirection; + int stopped; + int cyclingspeed; + + /*autopilot internal values */ + int x1, y1, c1; + number_t minsize; + number_t maxsize; + int autopilotversion; + int autime; + int minlong; + int interlevel; + + /*saved palettes */ + struct palette *palette2; + + int paletteshift; + int manualpaletteshift; + + struct uih_message messg; + + /*Used by uih_update to figure out when save undo */ + int lastbuttons; + + int encoding; + + /* performers really don't want text echoed to the screen */ + int inhibittextoutput; + + /* user data */ + void *data; + +#ifdef SFFE_USING + /*User formulas (used in sffe parser) */ + /*sffe *cparser; user define c evaluation formula, not used now, not used yet */ + sffe *parser; /* fractal formula */ + sffe *pinit; +#endif + + }; + typedef void (*uih_getposfunc) (struct uih_context * c, int *x, int *y, + int *width, int *height, void *data); + typedef void (*uih_drawfunc) (struct uih_context * c, void *data); + struct uih_window { + int x, y, width, height; + uih_getposfunc getpos; + uih_drawfunc draw; + struct uih_window *next; + struct uih_window *previous; + int savedline, savedpos; + char *saveddata; + void *data; + int flags; + }; + typedef struct uih_context uih_context; + +#define UIH_SAVEALL 2 +#define UIH_SAVEANIMATION 1 +#define UIH_SAVEPOS 0 + +#define UIH_PALETTEDRAW -2 +#define UIH_FILTERANIMATION -1 +#define UIH_INTERRUPTIBLE 0 +#define UIH_ANIMATION 1 +#define UIH_NEW_IMAGE 2 +#define UIH_UNINTERRUPTIBLE 3 +#define FRAMETIME (1000000/FRAMERATE) + +#define UIH_TEXTTOP 0 +#define UIH_TEXTMIDDLE 1 +#define UIH_TEXTBOTTOM 2 + +#define UIH_TEXTLEFT 0 +#define UIH_TEXTCENTER 1 +#define UIH_TEXTRIGHT 2 + +#define RANDOM_PALETTE_SIZE 1 +#define FULLSCREEN 2 +#define UPDATE_AFTER_PALETTE 4 +#define UPDATE_AFTER_RESIZE 8 +#define PALETTE_ROTATION 16 +#define ASYNC_PALETTE 32 +#define ROTATE_INSIDE_CALCULATION 64 +#define PALETTE_REDISPLAYS 128 +#define SCREENSIZE 256 +#define PIXELSIZE 512 +#define RESOLUTION 1024 + +#define BUTTON1 256 +#define BUTTON2 512 +#define BUTTON3 1024 + +#define ROTATE_NONE 0 +#define ROTATE_MOUSE 1 +#define ROTATE_CONTINUOUS 2 + +#define uih_needrecalculate(context) ((context)->recalculatemode) +#define uih_needdisplay(context) ((context)->display) +#define GETMAX(a,b) ((a)>(b)?(a):(b)) +#define uih_newimage(c) ((c)->display=1,((c)->recalculatemode=GETMAX((c)->recalculatemode,UIH_NEW_IMAGE))) +#define uih_animate_image(c) ((c)->display=1,(c)->recalculatemode=GETMAX((c)->recalculatemode,UIH_ANIMATION)) + +#define uih_updatemenus(uih,c) if(uih->updatemenus!=NULL) uih->updatemenus(uih,c); + + extern CONST struct filteraction *CONST uih_filters[MAXFILTERS]; + extern CONST int uih_nfilters; + + struct uih_context *uih_mkcontext(int flags, struct image *image, + int (*passfunc) (struct uih_context + *, int, + CONST char *, + float), + void (*longwait) (struct uih_context + *), + void (*updatemenus) (struct + uih_context * c, + CONST char *)); + int uih_updateimage(uih_context * c, struct image *img); + void uih_freecontext(uih_context * c); + + + void uih_callcomplette(uih_context * c); +/*palette functions */ + void uih_mkdefaultpalette(uih_context * c); + void uih_mkpalette(uih_context * c); + void uih_savepalette(uih_context * c); + void uih_restorepalette(uih_context * c); + void uih_loadpalette(uih_context * c, struct palette *palette); + +/*autopilot handling */ + void uih_autopilot_on(uih_context * c); + void uih_autopilot_off(uih_context * c); + +/*misc functions */ + int uih_update(uih_context * c, int mousex, int mousey, + int mousebuttons); + CONST char *uih_save(struct uih_context *c, xio_constpath filename); + void uih_tbreak(uih_context * c); + double uih_displayed(uih_context * c); + void uih_do_fractal(uih_context * c); + void uih_prepare_image(uih_context * c); + void uih_interrupt(uih_context * c); + void uih_stopzooming(uih_context * c); + void uih_setspeedup(uih_context * c, number_t speed); + void uih_setmaxstep(uih_context * c, number_t speed); + void uih_setcomplettehandler(uih_context * c, void (h) (void *), + void *d); + void uih_recalculate(struct uih_context *c); + void uih_initstate(struct uih_context *uih); + void uih_screentofractalcoord(uih_context * c, int mousex, int mousey, + number_t * re, number_t * im); + + +/*cycling functions */ + void uih_cycling_off(struct uih_context *c); + void uih_cycling_stop(struct uih_context *c); + void uih_cycling_continue(struct uih_context *c); + void uih_setcycling(struct uih_context *c, int speed); + int uih_cycling_on(struct uih_context *c); + int uih_cycling(struct uih_context *c, int mode); + +/*fractal context manipulation routines */ + void uih_setformula(uih_context * c, int formula); + void uih_setperbutation(uih_context * c, number_t re, number_t im); + void uih_perbutation(uih_context * c, int mousex, int mousey); + void uih_setmaxiter(uih_context * c, int maxiter); + void uih_setbailout(uih_context * c, number_t bailout); + void uih_setincoloringmode(uih_context * c, int mode); + void uih_setoutcoloringmode(uih_context * c, int mode); + void uih_setintcolor(uih_context * c, int mode); + void uih_setouttcolor(uih_context * c, int mode); + void uih_setplane(uih_context * c, int mode); + void uih_setmandelbrot(uih_context * c, int mode, int mousex, + int mousey); + void uih_setfastmode(uih_context * c, int mode); + void uih_setguessing(uih_context * c, int range); + void uih_setperiodicity(uih_context * c, int periodicity); + void uih_display(uih_context * c); + void uih_disablejulia(uih_context * c); + int uih_enablejulia(uih_context * c); + int uih_setjuliamode(uih_context * c, int mode); + void uih_setjuliaseed(uih_context * c, number_t zre, number_t zim); + +/*filter manipulation */ + int uih_enablefilter(uih_context * c, int n); + void uih_disablefilter(uih_context * c, int n); + +/*Animation save routines */ + int uih_save_enable(struct uih_context *uih, xio_file f, int mode); + void uih_save_disable(struct uih_context *uih); + void uih_saveframe(struct uih_context *uih); + void uih_save_possition(struct uih_context *uih, xio_file f, int mode); + + void uih_load(struct uih_context *uih, xio_file f, xio_constpath name); + void uih_loadstr(struct uih_context *uih, CONST char *data); + void uih_playstr(struct uih_context *uih, CONST char *data); + void uih_playupdate(struct uih_context *uih); + void uih_replaydisable(struct uih_context *uih); + void uih_skipframe(struct uih_context *uih); + int uih_replayenable(struct uih_context *uih, xio_file f, + xio_constpath filename, int animroot); + void uih_command(struct uih_context *uih, CONST char *command); + void uih_playtutorial(struct uih_context *c, CONST char *name); + +/* Easy to use functions for handling save/load*/ + void uih_loadfile(struct uih_context *uih, xio_constpath d); + void uih_playfile(struct uih_context *c, xio_constpath d); + void uih_loadexample(struct uih_context *c); + void uih_savepngfile(struct uih_context *c, xio_constpath d); + void uih_saveposfile(struct uih_context *c, xio_constpath d); + char *uih_savepostostr(struct uih_context *c); + void uih_savecfg(struct uih_context *c); + void uih_saveanimfile(struct uih_context *c, xio_constpath d); + void uih_update_lines(uih_context * c); + + +/*timer functions */ + void uih_stoptimers(uih_context * c); + void uih_resumetimers(uih_context * c); + void uih_slowdowntimers(uih_context * c, int time); + +/*text output functions */ + void uih_clearscreen(uih_context * c); + void uih_settextpos(uih_context * c, int x, int y); + void uih_text(uih_context * c, CONST char *text); + void uih_letterspersec(uih_context * c, int n); + +/*image rotation functions */ + int uih_fastrotate(uih_context * c, int mode); + int uih_fastrotateenable(uih_context * c); + void uih_fastrotatedisable(uih_context * c); + void uih_angle(uih_context * c, number_t angle); + void uih_rotatemode(uih_context * c, int mode); + void uih_rotate(uih_context * c, int mode); + void uih_rotationspeed(uih_context * c, number_t speed); + +/*Catalog functions */ + int uih_loadcatalog(uih_context * c, CONST char *name); + void uih_freecatalog(uih_context * c); + + void uih_registermenus(void); + void uih_registermenus_i18n(void); + void uih_registermenudialogs_i18n(void); + void uih_unregistermenus(void); + +/*Windows :)*/ + struct uih_window *uih_registerw(struct uih_context *uih, + uih_getposfunc getpos, + uih_drawfunc draw, void *data, + int flags); + void uih_removew(struct uih_context *uih, struct uih_window *w); + void uih_clearwindows(struct uih_context *uih); + void uih_drawwindows(struct uih_context *uih); + void uih_drawborder(struct uih_context *uih, int x, int y, int width, + int height, int flags); + void uih_setline(struct uih_context *uih, struct uih_window *w, + int color, int x1, int y1, int x2, int y2); + struct uih_window *uih_registerline(struct uih_context *uih, int color, + int x1, int y1, int x2, int y2); + + +/*Messages*/ + void uih_scrollup(uih_context * c); + void uih_clearmessages(uih_context * c); + int uih_message(uih_context * c, CONST char *message); + int uih_error(uih_context * c, CONST char *error); + void uih_rmmessage(uih_context * c, int pid); + void uih_printmessages(uih_context * c); + +/*Constant framerate functions*/ + void uih_emulatetimers(uih_context * c); + void uih_constantframetime(uih_context * c, int time); + void uih_noconstantframetime(uih_context * c); + +/*undo and redo*/ + void uih_saveundo(uih_context * c); + void uih_undo(uih_context * c); + void uih_redo(uih_context * c); + + void uih_setfont(uih_context * c); + +/*animation rendering*/ + int uih_renderanimation(struct uih_context *gc, CONST char *basename, + CONST xio_constpath animation, int width, + int height, float pixelwidth, + float pixelheight, int frametime, int type, + int antialiasing, int slowmode, + int letterspersec, CONST char *catalog, + int motionvectors, int iframedist2); + int uih_renderimage(struct uih_context *gc1, xio_file af, + xio_constpath path, struct image *img, + int antialias, CONST char *catalog, int noise); + + void uih_initmessages(uih_context * c); + void uih_destroymessages(uih_context * c); + void uih_inittext(uih_context * c); + void uih_destroytext(uih_context * c); + + void uih_inhibittextsw(uih_context * c); + int uih_inhibittextselected(uih_context * c); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/src/include/version.h.in b/src/include/version.h.in new file mode 100644 index 0000000..8b80450 --- /dev/null +++ b/src/include/version.h.in @@ -0,0 +1,23 @@ +/* + * XaoS, a fast portable realtime fractal zoomer + * Copyright (C) 1996,1997 by + * + * Jan Hubicka (hubicka@paru.cas.cz) + * Thomas Marsh (tmarsh@austin.ibm.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#undef PACKAGE_VERSION +#define XaoS_VERSION PACKAGE_VERSION diff --git a/src/include/xerror.h b/src/include/xerror.h new file mode 100644 index 0000000..2ae5638 --- /dev/null +++ b/src/include/xerror.h @@ -0,0 +1,12 @@ +#ifndef XERROR_H +#define XERROR_H +#ifdef __cplusplus +extern "C" { +#endif + void x_message(CONST char *text, ...); + void x_error(CONST char *text, ...); + void x_fatalerror(CONST char *text, ...) NORETURN; +#ifdef __cplusplus +} +#endif +#endif diff --git a/src/include/xio.h b/src/include/xio.h new file mode 100644 index 0000000..2395302 --- /dev/null +++ b/src/include/xio.h @@ -0,0 +1,107 @@ +/* This is implementation of input/output routines similar to stdio. + purpose of this library is to hide differences between OSes (Mac OS don't + have stdio!) and allow general streams to strings etc. */ +#ifndef XIO1_H +#define XIO1_H 1 +#include +#ifdef __cplusplus +extern "C" { +#endif + + +#define XIO_FAILED NULL + struct xio_filestruct { + void *data; + int (*fputc) (int c, struct xio_filestruct * f); + int (*fputs) (const char *s, struct xio_filestruct * f); + int (*fgetc) (struct xio_filestruct * f); + int (*fungetc) (int c, struct xio_filestruct * f); + int (*xeof) (struct xio_filestruct * f); + int (*fclose) (struct xio_filestruct * f); + int (*flush) (struct xio_filestruct * f); + }; + + typedef struct xio_filestruct *xio_file; + +#define xio_puts(s,f) (f)->fputs((s),(f)) +#define xio_putc(s,f) (f)->fputc((s),(f)) +#define xio_getc(f) (f)->fgetc((f)) +#define xio_ungetc(s,f) (f)->fungetc((s),(f)) +#define xio_feof(f) (f)->xeof((f)) +#define xio_close(f) (f)->fclose((f)) +#define xio_flush(f) if ((f)->flush!=NULL) (f)->flush((f)) + +/* Standard stdio maps. These defines says, that filenames are strings and + path is separated by slash or backslash (windoze, dog) + the main I/O routines are in the xstdio file +*/ + +#ifdef USE_STDIO +/* Ugly hack because of unknown problems w/ va_list in v*print* in plan9 */ +#ifdef _plan9_ +#define va_list char * +#endif +#include + + typedef char *xio_path; + typedef CONST char *xio_constpath; + typedef char xio_pathdata[4096]; + extern char *xio_appdir; /*Where application binary is */ + extern char *xio_homedir; + + +#ifdef _WIN32 +#define XIO_PATHSEP '\\' +#define XIO_PATHSEPSTR "\\" +#define XIO_EMPTYPATH ".\\" /*Should be also call to currentdir function */ +#else +#ifdef DJGPP +#define XIO_PATHSEP '\\' +#define XIO_PATHSEPSTR "\\" +#define XIO_EMPTYPATH ".\\" /*Should be also call to currentdir function */ +#else +#define XIO_PATHSEP '/' +#define XIO_PATHSEPSTR "/" +#define XIO_EMPTYPATH "./" /*Should be also call to currentdir function */ +#endif +#endif +#define XIO_EOF EOF + +#define xio_addfname(destination, dirrectory, filename) \ +{strcpy(destination,dirrectory);if (strlen(dirrectory)&&destination[strlen(destination)-1]!=XIO_PATHSEP) strcat(destination,XIO_PATHSEPSTR);strcat(destination,filename);} +#define xio_addextension(destination,extension) strcat(destination,extension) + +#ifdef _plan9_ +#define xio_errorstring() errstr +#else +#define xio_errorstring() strerror(errno) +#endif /*plan9 */ + + char *xio_fixpath(CONST char *name); +#endif /*USE_STDIO */ + + xio_file xio_ropen(xio_constpath name); + xio_file xio_wopen(xio_constpath name); + xio_file xio_strropen(CONST char *c); + xio_file xio_strwopen(void); + char *xio_getstring(xio_file f); + xio_path xio_getdirectory(xio_constpath name); + xio_path xio_getfilename(CONST char *base, CONST char *extension); + xio_file xio_getrandomexample(xio_path name); + xio_file xio_getcatalog(CONST char *name); + xio_file xio_gethelp(void); + xio_file xio_gettutorial(CONST char *name, xio_path result); + + /*look trought directory with examples, choose one file, open it (and return + *descriptor+put name into name parameter*/ + int xio_exist(xio_constpath name); + int xio_getfiles(xio_constpath path, char ***names, char ***dirs, + int *nnames, int *ndirs); + void xio_init(CONST char *c); + void xio_uninit(void); + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/src/include/xldio.h b/src/include/xldio.h new file mode 100644 index 0000000..b17a993 --- /dev/null +++ b/src/include/xldio.h @@ -0,0 +1,14 @@ +#ifndef X_LDIO_H +#define X_LDIO_H +#ifdef USE_XLDIO +#include "xio.h" +#ifdef __cplusplus +extern "C" { +#endif + void x_ldout(long double param, int prec, xio_file stream); + long double x_strtold(CONST char *s, CONST char **sret); +#ifdef __cplusplus +} +#endif +#endif /*USE_XLDIO */ +#endif /*X_LDIO_H */ diff --git a/src/include/xmenu.h b/src/include/xmenu.h new file mode 100644 index 0000000..70d3ccc --- /dev/null +++ b/src/include/xmenu.h @@ -0,0 +1,377 @@ +#ifndef XMENU_H +#define XMENU_H +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + + struct uih_context; + typedef union { + char *dstring; + int dint; + number_t number; + number_t dcoord[2]; + xio_path dpath; + void *dummy; + } dialogparam; + typedef struct dialog { + CONST char *question; + int type; + int defint; + CONST char *defstr; + number_t deffloat; + number_t deffloat2; + } menudialog; + + typedef char *(*tokenfunc) (struct uih_context * c); +#define DIALOG_INT 1 +#define DIALOG_FLOAT 2 +#define DIALOG_STRING 3 +#define DIALOG_KEYSTRING 4 +#define DIALOG_IFILE 5 +#define DIALOG_OFILE 6 +#define DIALOG_CHOICE 7 +#define DIALOG_ONOFF 8 +#define DIALOG_COORD 9 + +#define DIALOGIFILE(question,filename) {question, DIALOG_IFILE, 0,filename} +#define DIALOGOFILE(question,filename) {question, DIALOG_OFILE, 0,filename} +#define DIALOGSTR(question,default) {question, DIALOG_STRING, 0, default} +#define DIALOGKEYSTR(question,default) {question, DIALOG_KEYSTRING, 0, default} +#define DIALOGINT(question,default) {question, DIALOG_INT, default} +#define DIALOGONOFF(question,default) {question, DIALOG_ONOFF, default} +#define DIALOGFLOAT(question,default) {question, DIALOG_FLOAT, 0, NULL, default} +#define DIALOGCHOICE(question,table,default) {question, DIALOG_CHOICE, default,(CONST char *)table} +#define DIALOGCOORD(question,default1,default2) {question, DIALOG_COORD,0, NULL, default1,default2} + +#define DIALOGIFILE_I(_question,_filename) \ + menudialogs_i18n[no_menudialogs_i18n].question=_question; \ + menudialogs_i18n[no_menudialogs_i18n].type=DIALOG_IFILE; \ + menudialogs_i18n[no_menudialogs_i18n].defint=0; \ + menudialogs_i18n[no_menudialogs_i18n].defstr=_filename; \ + menudialogs_i18n[no_menudialogs_i18n].deffloat=0; \ + menudialogs_i18n[no_menudialogs_i18n].deffloat2=0; \ + ++no_menudialogs_i18n; +#define DIALOGOFILE_I(_question,_filename) \ + menudialogs_i18n[no_menudialogs_i18n].question=_question; \ + menudialogs_i18n[no_menudialogs_i18n].type=DIALOG_OFILE; \ + menudialogs_i18n[no_menudialogs_i18n].defint=0; \ + menudialogs_i18n[no_menudialogs_i18n].defstr=_filename; \ + ++no_menudialogs_i18n; +#define DIALOGKEYSTR_I(_question,_default) \ + menudialogs_i18n[no_menudialogs_i18n].question=_question; \ + menudialogs_i18n[no_menudialogs_i18n].type=DIALOG_KEYSTRING; \ + menudialogs_i18n[no_menudialogs_i18n].defint=0; \ + menudialogs_i18n[no_menudialogs_i18n].defstr=_default; \ + ++no_menudialogs_i18n; +#define DIALOGSTR_I(_question,_default) \ + menudialogs_i18n[no_menudialogs_i18n].question=_question; \ + menudialogs_i18n[no_menudialogs_i18n].type=DIALOG_STRING; \ + menudialogs_i18n[no_menudialogs_i18n].defint=0; \ + menudialogs_i18n[no_menudialogs_i18n].defstr=_default; \ + ++no_menudialogs_i18n; +#define DIALOGINT_I(_question,_default) \ + menudialogs_i18n[no_menudialogs_i18n].question=_question; \ + menudialogs_i18n[no_menudialogs_i18n].type=DIALOG_INT; \ + menudialogs_i18n[no_menudialogs_i18n].defint=_default; \ + ++no_menudialogs_i18n; +#define DIALOGONOFF_I(_question,_default) \ + menudialogs_i18n[no_menudialogs_i18n].question=_question; \ + menudialogs_i18n[no_menudialogs_i18n].type=DIALOG_ONOFF; \ + menudialogs_i18n[no_menudialogs_i18n].defint=_default; \ + ++no_menudialogs_i18n; +#define DIALOGFLOAT_I(_question,_default) \ + menudialogs_i18n[no_menudialogs_i18n].question=_question; \ + menudialogs_i18n[no_menudialogs_i18n].type=DIALOG_FLOAT; \ + menudialogs_i18n[no_menudialogs_i18n].defint=0; \ + menudialogs_i18n[no_menudialogs_i18n].defstr=NULL; \ + menudialogs_i18n[no_menudialogs_i18n].deffloat=_default; \ + ++no_menudialogs_i18n; +#define DIALOGCHOICE_I(_question,_table,_default) \ + menudialogs_i18n[no_menudialogs_i18n].question=_question; \ + menudialogs_i18n[no_menudialogs_i18n].type=DIALOG_CHOICE; \ + menudialogs_i18n[no_menudialogs_i18n].defint=_default; \ + menudialogs_i18n[no_menudialogs_i18n].defstr=(CONST char *)_table; \ + ++no_menudialogs_i18n; +#define DIALOGCOORD_I(_question,_default1,_default2) \ + menudialogs_i18n[no_menudialogs_i18n].question=_question; \ + menudialogs_i18n[no_menudialogs_i18n].type=DIALOG_COORD; \ + menudialogs_i18n[no_menudialogs_i18n].defint=0; \ + menudialogs_i18n[no_menudialogs_i18n].defstr=NULL; \ + menudialogs_i18n[no_menudialogs_i18n].deffloat=_default1; \ + menudialogs_i18n[no_menudialogs_i18n].deffloat2=_default2; \ + ++no_menudialogs_i18n; + +#define NULL_I() \ + menudialogs_i18n[no_menudialogs_i18n].question=NULL; \ + menudialogs_i18n[no_menudialogs_i18n].type=0; \ + menudialogs_i18n[no_menudialogs_i18n].defint=0; \ + menudialogs_i18n[no_menudialogs_i18n].defstr=NULL; \ + menudialogs_i18n[no_menudialogs_i18n].deffloat=0; \ + menudialogs_i18n[no_menudialogs_i18n].deffloat2=0; \ + ++no_menudialogs_i18n; + + typedef struct menuitem { + CONST char *menuname; + CONST char *key; + CONST char *name; + CONST char *shortname; + int type; + int flags; + void (*function) (void); + int iparam; + CONST void *pparam; + int (*control) (void); + CONST menudialog *(*dialog) (struct uih_context *); + } menuitem; + +#define MENU_NOPARAM 1 +#define MENU_SUBMENU 2 +#define MENU_INT 3 +#define MENU_STRING 4 +#define MENU_DIALOG 6 +#define MENU_CUSTOMDIALOG 7 +#define MENU_SEPARATOR 8 + +/* Definitions for static menuitems. These items cannot be internationalized. + All of these definitions will become obsolete soon: */ + +#define MENUNOP(menuname,key,name,shortname,flags,function) {menuname, key,name,shortname, MENU_NOPARAM, flags, (void (*)(void))function} +#define MENUNOPCB(menuname,key,name,shortname,flags,function,checkbutton) {menuname, key, name,shortname, MENU_NOPARAM, (flags)|MENUFLAG_CHECKBOX, (void (*)(void))function,0,NULL,(int (*)(void))checkbutton} +#define MENUCOORDCB(menuname,key,name,shortname,flags,function,checkbutton) {menuname, key, name,shortname, MENU_COORD, (flags)|MENUFLAG_CHECKBOX, (void (*)(void))function,0,NULL,(int (*)(void))checkbutton} +#define MENUCOORD(menuname,key,name,shortname,flags,function) {menuname, key, name,shortname, MENU_COORD, flags, (void (*)(void))function} + +#define MENUINT(menuname,key,name,shortname,flags,function,param) {menuname, key, name,shortname, MENU_INT, flags, (void (*)(void))function,param} +#define MENUINTRB(menuname,key,name,shortname,flags,function,param,checkbutton) {menuname, key, name,shortname, MENU_INT, (flags)|MENUFLAG_RADIO, (void (*)(void))function,param,NULL,(int (*)(void))checkbutton} +#define SUBMENU(menuname,key,name,param) {menuname, key, name,param, MENU_SUBMENU, 0, NULL,0,NULL} + +#define MENUSEPARATOR(menuname) {menuname, 0, "", NULL, MENU_SEPARATOR, 0, NULL,0,NULL} +#define SUBMENUNOOPT(menuname,key,name,param) {menuname, key, name,param, MENU_SUBMENU, MENUFLAG_NOOPTION, NULL,0,NULL} +#define MENUDIALOG(menuname,key,name,shortname,flags,function,param) {menuname, key, name,shortname, MENU_DIALOG, flags, (void (*)(void))function,0,param} +#define MENUDIALOGCB(menuname,key,name,shortname,flags,function,param,check) {menuname, key, name,shortname, MENU_DIALOG, flags|MENUFLAG_CHECKBOX, (void (*)(void))function,0,param,(int (*)(void))check} +#define MENUCDIALOG(menuname,key,name,shortname,flags,function,param) {menuname, key, name,shortname, MENU_CUSTOMDIALOG, flags, (void (*)(void))function,0,NULL,NULL,(CONST menudialog *(*)(struct uih_context *))param} +#define MENUCDIALOGCB(menuname,key,name,shortname,flags,function,param,check) {menuname, key, name,shortname, MENU_CUSTOMDIALOG, flags|MENUFLAG_CHECKBOX,(void (*)(void))function,0,NULL,(int (*)(void))check,(CONST menudialog *(*)(struct uih_context *))param} +#define MENUSTRING(menuname,key,name,shortname,flags,function,param) {menuname, key, name,shortname, MENU_STRING, flags, (void (*)(void))function,0,param} + + +/* Definitions for internationalized menus. All of them must be defined + dynamically because gettext() cannot be used within a static + variable. Usage (example): + + SUBMENU_I("file", "q", "Quit", "quitmenu") + + See ui/ui.c, ui_registermenus_i18n() for further details. */ + +#define MENUNOP_I(_menuname,_key,_name,_shortname,_flags,_function)\ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = _shortname; \ + menuitems_i18n[no_menuitems_i18n].key = _key; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_NOPARAM; \ + menuitems_i18n[no_menuitems_i18n].flags = _flags; \ + menuitems_i18n[no_menuitems_i18n].iparam = 0; \ + menuitems_i18n[no_menuitems_i18n].name = _name; \ + menuitems_i18n[no_menuitems_i18n].pparam = NULL; \ + menuitems_i18n[no_menuitems_i18n].function = (void (*)(void))_function; \ + ++no_menuitems_i18n; + +#define MENUNOPCB_I(_menuname,_key,_name,_shortname,_flags,_function,_checkbutton) \ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = _shortname; \ + menuitems_i18n[no_menuitems_i18n].key = _key; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_NOPARAM; \ + menuitems_i18n[no_menuitems_i18n].flags = (_flags)|MENUFLAG_CHECKBOX; \ + menuitems_i18n[no_menuitems_i18n].iparam = 0; \ + menuitems_i18n[no_menuitems_i18n].name = _name; \ + menuitems_i18n[no_menuitems_i18n].pparam = NULL; \ + menuitems_i18n[no_menuitems_i18n].function = (void (*)(void))_function; \ + menuitems_i18n[no_menuitems_i18n].control = (int (*)(void))_checkbutton; \ + ++no_menuitems_i18n; + +#define MENUINT_I(_menuname,_key,_name,_shortname,_flags,_function,_param) \ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = _shortname; \ + menuitems_i18n[no_menuitems_i18n].key = _key; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_INT; \ + menuitems_i18n[no_menuitems_i18n].flags = _flags; \ + menuitems_i18n[no_menuitems_i18n].iparam = _param; \ + menuitems_i18n[no_menuitems_i18n].name = _name; \ + menuitems_i18n[no_menuitems_i18n].function = (void (*)(void))_function; \ + ++no_menuitems_i18n; + +#define MENUINTRB_I(_menuname,_key,_name,_shortname,_flags,_function,_param,_checkbutton) \ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = _shortname; \ + menuitems_i18n[no_menuitems_i18n].key = _key; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_INT; \ + menuitems_i18n[no_menuitems_i18n].flags = (_flags)|MENUFLAG_RADIO; \ + menuitems_i18n[no_menuitems_i18n].iparam = _param; \ + menuitems_i18n[no_menuitems_i18n].pparam = NULL; \ + menuitems_i18n[no_menuitems_i18n].name = _name; \ + menuitems_i18n[no_menuitems_i18n].function = (void (*)(void))_function; \ + menuitems_i18n[no_menuitems_i18n].control = (int (*)(void))_checkbutton; \ + ++no_menuitems_i18n; + +#define SUBMENU_I(_menuname,_key,_name,_param) \ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = _param; \ + menuitems_i18n[no_menuitems_i18n].key = _key; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_SUBMENU; \ + menuitems_i18n[no_menuitems_i18n].flags = 0; \ + menuitems_i18n[no_menuitems_i18n].iparam = 0; \ + menuitems_i18n[no_menuitems_i18n].name = _name; \ + menuitems_i18n[no_menuitems_i18n].pparam = NULL; \ + menuitems_i18n[no_menuitems_i18n].function = NULL; \ + ++no_menuitems_i18n; + +#define MENUDIALOG_I(_menuname,_key,_name,_shortname,_flags,_function,_param) \ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = _shortname; \ + menuitems_i18n[no_menuitems_i18n].key = _key; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_DIALOG; \ + menuitems_i18n[no_menuitems_i18n].flags = _flags; \ + menuitems_i18n[no_menuitems_i18n].iparam = 0; \ + menuitems_i18n[no_menuitems_i18n].name = _name; \ + menuitems_i18n[no_menuitems_i18n].pparam = _param; \ + menuitems_i18n[no_menuitems_i18n].function = (void (*)(void))_function; \ + ++no_menuitems_i18n; + +#define MENUDIALOGCB_I(_menuname,_key,_name,_shortname,_flags,_function,_param,_check) \ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = _shortname; \ + menuitems_i18n[no_menuitems_i18n].key = _key; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_DIALOG; \ + menuitems_i18n[no_menuitems_i18n].flags = (_flags)|MENUFLAG_CHECKBOX; \ + menuitems_i18n[no_menuitems_i18n].iparam = 0; \ + menuitems_i18n[no_menuitems_i18n].name = _name; \ + menuitems_i18n[no_menuitems_i18n].pparam = _param; \ + menuitems_i18n[no_menuitems_i18n].function = (void (*)(void))_function; \ + menuitems_i18n[no_menuitems_i18n].control = (int (*)(void))_check; \ + ++no_menuitems_i18n; + +#define MENUCDIALOG_I(_menuname,_key,_name,_shortname,_flags,_function,_param) \ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = _shortname; \ + menuitems_i18n[no_menuitems_i18n].key = _key; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_CUSTOMDIALOG; \ + menuitems_i18n[no_menuitems_i18n].flags = _flags; \ + menuitems_i18n[no_menuitems_i18n].iparam = 0; \ + menuitems_i18n[no_menuitems_i18n].name = _name; \ + menuitems_i18n[no_menuitems_i18n].pparam = NULL; \ + menuitems_i18n[no_menuitems_i18n].control = NULL; \ + menuitems_i18n[no_menuitems_i18n].function = (void (*)(void))_function; \ + menuitems_i18n[no_menuitems_i18n].dialog = (CONST menudialog *(*)(struct uih_context *))_param; \ + ++no_menuitems_i18n; + +#define MENUCDIALOGCB_I(_menuname,_key,_name,_shortname,_flags,_function,_param,_check)\ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = _shortname; \ + menuitems_i18n[no_menuitems_i18n].key = _key; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_CUSTOMDIALOG; \ + menuitems_i18n[no_menuitems_i18n].flags = (_flags)|MENUFLAG_CHECKBOX; \ + menuitems_i18n[no_menuitems_i18n].iparam = 0; \ + menuitems_i18n[no_menuitems_i18n].name = _name; \ + menuitems_i18n[no_menuitems_i18n].pparam = _param; \ + menuitems_i18n[no_menuitems_i18n].function = (void (*)(void))_function; \ + menuitems_i18n[no_menuitems_i18n].control = (int (*)(void))_check; \ + menuitems_i18n[no_menuitems_i18n].dialog = (CONST menudialog *(*)(struct uih_context *))_param; \ + ++no_menuitems_i18n; + +#define MENUSEPARATOR_I(_menuname) \ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = NULL; \ + menuitems_i18n[no_menuitems_i18n].key = 0; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_SEPARATOR; \ + menuitems_i18n[no_menuitems_i18n].flags = 0; \ + menuitems_i18n[no_menuitems_i18n].iparam = 0; \ + menuitems_i18n[no_menuitems_i18n].name = ""; \ + menuitems_i18n[no_menuitems_i18n].pparam = NULL; \ + menuitems_i18n[no_menuitems_i18n].function = NULL; \ + ++no_menuitems_i18n; + +#define SUBMENUNOOPT_I(_menuname,_key,_name,_param) \ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = _param; \ + menuitems_i18n[no_menuitems_i18n].key = _key; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_SUBMENU; \ + menuitems_i18n[no_menuitems_i18n].flags = MENUFLAG_NOOPTION; \ + menuitems_i18n[no_menuitems_i18n].iparam = 0; \ + menuitems_i18n[no_menuitems_i18n].name = _name; \ + menuitems_i18n[no_menuitems_i18n].pparam = NULL; \ + menuitems_i18n[no_menuitems_i18n].function = NULL; \ + ++no_menuitems_i18n; + +#define MENUSTRING_I(_menuname,_key,_name,_shortname,_flags,_function,_param) \ + menuitems_i18n[no_menuitems_i18n].menuname = _menuname; \ + menuitems_i18n[no_menuitems_i18n].shortname = _shortname; \ + menuitems_i18n[no_menuitems_i18n].key = _key; \ + menuitems_i18n[no_menuitems_i18n].type = MENU_STRING; \ + menuitems_i18n[no_menuitems_i18n].flags = _flags; \ + menuitems_i18n[no_menuitems_i18n].iparam = 0; \ + menuitems_i18n[no_menuitems_i18n].name = _name; \ + menuitems_i18n[no_menuitems_i18n].pparam = _param; \ + menuitems_i18n[no_menuitems_i18n].function = (void (*)(void))_function; \ + ++no_menuitems_i18n; + +/* End of i18n definitions. */ + + +#define MENUFLAG_CHECKBOX 1 +#define MENUFLAG_RADIO 2 +#define MENUFLAG_INTERRUPT 4 +#define MENUFLAG_INCALC 8 +#define MENUFLAG_NOMENU 16 +#define MENUFLAG_NOOPTION 32 +#define MENUFLAG_NOPLAY 64 +#define MENUFLAG_ATSTARTUP 128 +#define MENUFLAG_DIALOGATDISABLE 256 + +#define NITEMS(n) (sizeof(n)/sizeof(menuitem)) +#define menu_getdialog(context, m) \ + ((m)->type==MENU_DIALOG?(CONST menudialog *)(m)->pparam:(m)->dialog(context)) + + void menu_add(CONST menuitem * item, int n); + void menu_insert(CONST menuitem * item, CONST char *before, int n); + CONST menuitem *menu_findkey(CONST char *key, CONST char *root); + CONST menuitem *menu_findcommand(CONST char *name); + CONST char *menu_fullname(CONST char *menu); + CONST menuitem *menu_item(CONST char *menu, int n); + void menu_delete(CONST menuitem * items, int n); + int menu_enabled(CONST menuitem * item, struct uih_context *c); + void menu_activate(CONST menuitem * item, struct uih_context *c, + dialogparam * d); + CONST menuitem *menu_genernumbered(int n, CONST char *menuname, + CONST char *CONST * CONST names, + CONST char *keys, int type, + int flags, + void (*fint) (struct uih_context * + context, int), + int (*cint) (struct uih_context * + context, int), + CONST char *prefix); + void menu_delnumbered(int n, CONST char *name); + void menu_addqueue(CONST menuitem * item, dialogparam * d); + CONST menuitem *menu_delqueue(dialogparam ** d); + void menu_destroydialog(CONST menuitem * item, dialogparam * d, + struct uih_context *uih); + int menu_havedialog(CONST menuitem * item, struct uih_context *c); + int menu_available(CONST menuitem * item, CONST char *root); + CONST char *menu_processcommand(struct uih_context *uih, tokenfunc f, + int scheme, int mask, + CONST char *root); + void menu_printhelp(void); + + number_t menu_getfloat(CONST char *s, CONST char **error); + CONST char *menu_fillparam(struct uih_context *uih, tokenfunc f, + CONST menudialog * d, dialogparam * p); + int menu_processargs(int n, int argc, char **argv); + void uih_xshlprintmenu(struct uih_context *c, CONST char *name); + void uih_xshlprintmenus(struct uih_context *c); + void menu_forall(struct uih_context *c, + void (*callback) (struct uih_context * c, + CONST menuitem * item)); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/src/include/xshl.h b/src/include/xshl.h new file mode 100644 index 0000000..05631f8 --- /dev/null +++ b/src/include/xshl.h @@ -0,0 +1,50 @@ +#ifndef XSHL_H +#define XSHL_H +#ifdef __cplusplus +extern "C" { +#endif + +#define XSHL_BIG 1 +#define XSHL_EMPH 2 +#define XSHL_WHITE 4 +#define XSHL_RED 8 +#define XSHL_BLACK 16 +#define XSHL_COLORMASK (XSHL_BLACK|XSHL_RED|XSHL_WHITE) +#define XSHL_RIGHTALIGN 32 +#define XSHL_CENTERALIGN 64 +#define XSHL_MONOSPACE 128 +#define XSHL_LINK 256 + struct xshl_context { + int flags; + char *linktext; + }; + struct xshl_item { + struct xshl_context c; + char *text; + int x; + int width; + struct xshl_item *next; + }; + struct xshl_line { + int y; + struct xshl_item *first; + }; + extern char *xshl_error; + struct xshl_line *xshl_interpret(void *userdata, int (*get) (void *), + int width, int getwidth(void *, + int flags, + CONST char + *text), + int startflags, int smallheight, + int bigheight); + void xshl_free(struct xshl_line *); + int xshl_textlen(void *data, int flags, CONST char *text); + void xshl_print(int startskip, struct xshl_line *lines); + struct xshl_line *help_make(CONST char *command, + int getwidth(void *, int flags, + CONST char *text), int width, + int smallheight, int bigheight); +#ifdef __cplusplus +} +#endif +#endif diff --git a/src/include/xthread.h b/src/include/xthread.h new file mode 100644 index 0000000..01f210c --- /dev/null +++ b/src/include/xthread.h @@ -0,0 +1,208 @@ +/* + * An XaoS thread API implementation + * Many functions are implemented as macros that maps simple + * XaoS thread API into architecture depended API. + * I tried avoid functions because of speed issues + * So this header will be quite messy soon :) + * + * Supported API for now: + * pthread (POSIX) enabled using USE_PTHREAD + * nothread (my own) enabled by default + */ +#ifndef THREAD_H +#define THREAD_H 1 +#include +#ifdef __cplusplus +extern "C" { +#endif +#define MAXTHREADS 32 + /*You might increase this constant if needed + (xaos on connection machine? :) */ + +#define NSEMAPHORS 2 +#define MAXSEMAPHORS 2 +#define NSLEEPS 2 +#define MAXCONDS 2 + +#ifdef USE_PTHREAD +#include +#endif +#ifdef __BEOS__ +#include +#endif + + struct taskinfo { + int n; +#ifdef USE_PTHREAD + pthread_t id; +#endif +#ifdef _plan9_ + int id; +#endif +#ifdef __BEOS__ + thread_id id; +#endif + }; + + extern struct taskinfo definfo; + extern int ethreads; /*Is threading enabled? */ + extern int nthreads; /*Number of threads */ + typedef void (*xfunction) (void *, struct taskinfo *, int, int); + +/*No-thread API implementation version */ +#define nothread { } +#define nothread_init(nthreads) nothread +#define nothread_uninit() nothread +#define nothread_function(f,data,range) f(data,&definfo,0,range) +#define nothread_bgjob(f,d) f(d,&definfo,0,0) +#define nothread_lock(n) nothread +#define nothread_unlock(n) nothread +#define nothread_sync() nothread +#define nothread_sleep(n,l) nothread +#define nothread_wakeup(n) nothread +#define nothread_wakefirst(n) nothread + +#define xth_wrap(f1,f2) if(nthreads!=1) f1(); else f2(); + +#ifdef USE_PTHREAD +/* A posix thread API maps */ + void pth_init(int nthreads); + void pth_uninit(void); + void pth_function(xfunction f, void *d, int r); + void pth_synchronize(void); + void pth_bgjob(xfunction f, void *d); + extern pthread_mutex_t semaphors[MAXSEMAPHORS]; + extern pthread_cond_t conds[MAXCONDS]; + +/*Map pthread API to XaoS thread API */ + +#define xth_init(nthreads) pth_init(nthreads) +#define xth_uninit() pth_uninit() +#define xth_lock(n) if(ethreads) pthread_mutex_lock(semaphors+(n)) +#define xth_unlock(n) if(ethreads) pthread_mutex_unlock(semaphors+(n)) +#define xth_function(f,d,r) if(ethreads) pth_function(f,d,r); else nothread_function(f,d,r) +#define xth_nthread(ts) (ethreads?ts->n:0) +#define xth_sync() if(ethreads) pth_synchronize(); +#define xth_bgjob(f,d) if(ethreads) pth_bgjob(f,d); else f(d,&definfo,0,0); +#define xth_sleep(n,l) if(ethreads) pthread_cond_wait(conds+(n),semaphors+(l)) +#define xth_wakeup(n) if(ethreads) pthread_cond_broadcast(conds+(n)) +#define xth_wakefirst(n) if(ethreads) pthread_cond_signal(conds+(n)) +#define API_MAPPED +#endif /*USE_PTHREAD */ + +#ifdef _plan9_ + + struct Stack { + int nwaiting; + int tags[MAXTHREADS]; + }; +#ifdef _plan9v2_ +#include /* in plan9v3 part of libc */ +#endif +/* A plan9 thread API maps */ + void p9wait(struct Stack *s, Lock * l); + void p9wakeup(struct Stack *s); + void p9wakeall(struct Stack *s); + void p9init(int nthreads); + void p9uninit(void); + void p9function(xfunction f, void *d, int r); + void p9synchronize(void); + void p9bgjob(xfunction f, void *d); + extern Lock semaphors[MAXSEMAPHORS]; + extern struct Stack conds[MAXCONDS]; + +/*Map pthread API to XaoS thread API */ + +#define xth_init(nthreads) p9init(nthreads) +#define xth_uninit() p9uninit() +#define xth_lock(n) if(ethreads) lock(semaphors+(n)) +#define xth_unlock(n) if(ethreads) unlock(semaphors+(n)) +#define xth_function(f,d,r) if(ethreads) p9function(f,d,r); else nothread_function(f,d,r) +#define xth_nthread(ts) (ethreads?ts->n:0) +#define xth_sync() if(ethreads) p9synchronize(); +#define xth_bgjob(f,d) if(ethreads) p9bgjob(f,d); else f(d,&definfo,0,0); +#define xth_sleep(n,l) if(ethreads) p9wait(conds+(n), semaphors+(l)) +#define xth_wakeup(n) if(ethreads) p9wakeall(conds+(n)) +#define xth_wakefirst(n) if(ethreads) p9wakeup(conds+(n)) +#define API_MAPPED +#endif /*USE_PTHREAD */ + +#ifdef __BEOS__ + typedef struct { + int32 cnt; + sem_id sem; + } benaphore; + + void acquire_benaphore(benaphore * p); + void release_benaphore(benaphore * p); +#ifdef __GNUC__ + extern +#endif + inline void acquire_benaphore(benaphore * p) { + if (atomic_add(&(p->cnt), 1) >= 1) { + /* Someone was faster. */ + while (acquire_sem(p->sem) == B_INTERRUPTED); + } + } +#ifdef __GNUC__ + extern +#endif + inline void release_benaphore(benaphore * p) { + if (atomic_add(&(p->cnt), -1) > 1) { + /* Someone was slower. */ + release_sem(p->sem); + } + } + + extern benaphore mutexes[MAXSEMAPHORS]; + extern benaphore condvars[MAXCONDS]; + + void be_thread_init(int num_threads); + void be_thread_uninit(void); + void be_thread_function(xfunction f, void *d, int r); + void be_thread_synchronize(void); + void be_thread_bgjob(xfunction f, void *d); + void be_thread_sleep(benaphore * pCondition, benaphore * pMutex); + void be_thread_wakeup(benaphore * pCondition); + void be_thread_wakefirst(benaphore * pCondition); + +/* Map BeOS API to XaoS thread API. */ + +#define xth_init(nthreads) be_thread_init(nthreads) +#define xth_uninit() be_thread_uninit() +#define xth_function(f,d,r) if(ethreads) be_thread_function(f,d,r); else nothread_function(f,d,r) +#define xth_nthread(ts) (ethreads?ts->n:0) +#define xth_sync() if(ethreads) be_thread_synchronize(); +#define xth_bgjob(f,d) if(ethreads) be_thread_bgjob(f,d); else f(d,&definfo,0,0); +#define xth_lock(n) if(ethreads) acquire_benaphore(mutexes+(n)) +#define xth_unlock(n) if(ethreads) release_benaphore(mutexes+(n)) +#define xth_sleep(n,l) if(ethreads) be_thread_sleep(condvars+(n),mutexes+(l)) +#define xth_wakeup(n) if(ethreads) be_thread_wakeup(condvars+(n)) +#define xth_wakefirst(n) if(ethreads) be_thread_wakefirst(condvars+(n)) +#define API_MAPPED +#endif /* __BEOS__ */ + +#ifndef API_MAPPED +/* + * No thread support is compiled - do just wrappers + * to nothread implementation + */ +#define nthreads 1 +#define ethreads 0 +#define xth_init(n) nothread_init(n) +#define xth_uninit() nothread_uninit() +#define xth_function(f,d,r) nothread_function(f,d,r) +#define xth_lock(n) nothread_lock(n) +#define xth_unlock(n) nothread_unlock(n) +#define xth_sync() nothread_sync() +#define xth_bgjob(f,d) nothread_bgjob(f,d) +#define xth_nthread(ts) 0 +#define xth_wakeup(n) nothreads_wakeup(n) +#define xth_wakefirst(n) nothreads_wakefirst(n) +#define xth_sleep(n,l) nothreads_sleep(n,l) +#endif + +#ifdef __cplusplus +} +#endif +#endif diff --git a/src/include/zoom.h b/src/include/zoom.h new file mode 100644 index 0000000..f42eecd --- /dev/null +++ b/src/include/zoom.h @@ -0,0 +1,40 @@ +/* + * XaoS, a fast portable realtime fractal zoomer + * Copyright (C) 1996,1997 by + * + * Jan Hubicka (hubicka@paru.cas.cz) + * Thomas Marsh (tmarsh@austin.ibm.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#ifndef ZOOM_H +#define ZOOM_H +#ifdef __cplusplus +extern "C" { +#endif + + +#define LOWQUALITY (1<<30) +#define ZOOMMASK (LOWQUALITY|UNCOMPLETTE) + + extern CONST struct filteraction zoom_filter; + extern struct filter cfilter; + extern CONST struct filteraction subwindow_filter; + void subwindow_setsecond(struct filter *f, struct filter *f1); + +#ifdef __cplusplus +} +#endif +#endif /* ZOOM_H */ -- cgit v0.9.1