Subversion Repositories openrisc_me

double sin(double x);

double cos(double x);

double tan(double x);

double asin(double x);

double acos(double x);

double atan(double x);

double atan2(double y, double x);

double sinh(double x);

double cosh(double x);

double tanh(double x);

double exp(double x);

double expm1(double x);

double log(double x);

double log10(double x);

double log1p(double x);

double pow(double x, double y);

double sqrt(double x);

double cbrt(double x);

double ceil(double x);

double floor(double x);

double fabs(double x);

double frexp(double value, int *eptr);

double ldexp(double value, int exp);

double modf(double value, double *iptr);

double erf(double x);

double erfc(double x);

double atof(const char *nptr);

double hypot(double x, double y);

double lgamma(double x);

double j0(double x);

double j1(double x);

double jn(int n, double x);

double y0(double x);

double y1(double x);

double yn(int n, double x);

extern struct _iobuf {

 int _cnt;

 char *_ptr;

 char *_base;

 int _bufsiz;

 short _flag;

 char _file;

} _iob[];

typedef __SIZE_TYPE__ size_t;

typedef char *va_list;

struct _iobuf *fopen(const char *filename, const char *type);

struct _iobuf *freopen(const char *filename, const char *type, struct _iobuf *stream);

struct _iobuf *fdopen(int fildes, const char *type);

struct _iobuf *popen(const char *command, const char *type);

int pclose(struct _iobuf *stream);

int fflush(struct _iobuf *stream);

int fclose(struct _iobuf *stream);

int remove(const char *path);

int rename(const char *from, const char *to);

struct _iobuf *tmpfile(void);

char *tmpnam(char *s);

int setvbuf(struct _iobuf *iop, char *buf, int type, size_t size);

int setbuf(struct _iobuf *stream, char *buf);

int setbuffer(struct _iobuf *stream, char *buf, size_t size);

int setlinebuf(struct _iobuf *stream);

int fprintf(struct _iobuf *stream, const char *format, ...);

int printf(const char *format, ...);

char *sprintf(char *s, const char *format, ...);

int vfprintf(struct _iobuf *stream, const char *format, va_list arg);

int vprintf(const char *format, va_list arg);

int vsprintf(char *s, const char *format, va_list arg);

int fscanf(struct _iobuf *stream, const char *format, ...);

int scanf(const char *format, ...);

int sscanf(char *s, const char *format, ...);

int fgetc(struct _iobuf *stream);

int getw(struct _iobuf *stream);

char *fgets(char *s, int n, struct _iobuf *stream);

char *gets(char *s);

int fputc(int c, struct _iobuf *stream);

int putw(int w, struct _iobuf *stream);

int fputs(const char *s, struct _iobuf *stream);

int puts(const char *s);

int ungetc(int c, struct _iobuf *stream);

int fread(void *ptr, size_t size, size_t count, struct _iobuf *iop);

int fwrite(const void *ptr, size_t size, size_t count, struct _iobuf *iop);

int fseek(struct _iobuf *stream, long offset, int ptrname);

long ftell(struct _iobuf *stream);

void rewind(struct _iobuf *stream);

int fgetpos(struct _iobuf *stream, long *pos);

int fsetpos(struct _iobuf *stream, const long *pos);

void perror(const char *s);

typedef unsigned char byte;

typedef unsigned char uchar;

typedef unsigned short ushort;

typedef unsigned int uint;

typedef unsigned long ulong;

typedef unsigned char u_char;

typedef unsigned short u_short;

typedef unsigned int u_int;

typedef unsigned long u_long;

typedef unsigned short ushort_;

typedef struct _physadr { int r[1]; } *physadr;

typedef struct label_t {

 int val[11];

} label_t;

typedef struct _quad { long val[2]; } quad;

typedef long daddr_t;

typedef char * caddr_t;

typedef u_long ino_t;

typedef long swblk_t;

typedef long time_t;

typedef short dev_t;

typedef long off_t;

typedef u_short uid_t;

typedef u_short gid_t;

typedef signed char prio_t;

typedef long fd_mask;

typedef struct fd_set {

 fd_mask fds_bits[(((256 )+(( (sizeof(fd_mask) * 8 ) )-1))/( (sizeof(fd_mask) * 8 ) )) ];

} fd_set;

typedef struct qhdr {

 struct qhdr *link, *rlink;

} *queue_t;

typedef char *ptr_ord_t;

typedef double floatp;

typedef char *(*proc_alloc_t)(unsigned num_elements, unsigned element_size, const char *client_name );

typedef void (*proc_free_t)(char *data, unsigned num_elements, unsigned element_size, const char *client_name );

extern struct _iobuf *gs_out;

typedef struct gs_point_s {

 double x, y;

} gs_point;

typedef struct gs_int_point_s {

 int x, y;

} gs_int_point;

typedef struct gs_rect_s {

 gs_point p, q;

} gs_rect;

typedef struct gs_int_rect_s {

 gs_int_point p, q;

} gs_int_rect;

typedef struct gs_state_s gs_state;

typedef struct {

 proc_alloc_t alloc;

 proc_free_t free;

} gs_memory_procs;

char *gs_malloc(uint, uint, const char * );

void gs_free(char *, uint, uint, const char * );

extern char gs_debug[128];

extern int gs_log_error(int, const char *, int );

typedef long fixed;

typedef struct gs_fixed_point_s {

 fixed x, y;

} gs_fixed_point;

typedef struct gs_fixed_rect_s {

 gs_fixed_point p, q;

} gs_fixed_rect;

typedef struct gs_matrix_s {

 long _xx; float xx; long _xy; float xy; long _yx; float yx; long _yy; float yy; long _tx; float tx; long _ty; float ty;

} gs_matrix;

void gs_make_identity(gs_matrix * );

int gs_make_translation(floatp, floatp, gs_matrix * ),

 gs_make_scaling(floatp, floatp, gs_matrix * ),

 gs_make_rotation(floatp, gs_matrix * );

int gs_matrix_multiply(const gs_matrix *, const gs_matrix *, gs_matrix * ),

 gs_matrix_invert(const gs_matrix *, gs_matrix * ),

 gs_matrix_rotate(const gs_matrix *, floatp, gs_matrix * );

int gs_point_transform(floatp, floatp, const gs_matrix *, gs_point * ),

 gs_point_transform_inverse(floatp, floatp, const gs_matrix *, gs_point * ),

 gs_distance_transform(floatp, floatp, const gs_matrix *, gs_point * ),

 gs_distance_transform_inverse(floatp, floatp, const gs_matrix *, gs_point * ),

 gs_bbox_transform_inverse(gs_rect *, gs_matrix *, gs_rect * );

typedef struct gs_matrix_fixed_s {

 long _xx; float xx; long _xy; float xy; long _yx; float yx; long _yy; float yy; long _tx; float tx; long _ty; float ty;

 fixed tx_fixed, ty_fixed;

} gs_matrix_fixed;

extern void gs_update_matrix_fixed(gs_matrix_fixed * );

int gs_point_transform2fixed(gs_matrix_fixed *, floatp, floatp, gs_fixed_point * ),

 gs_distance_transform2fixed(gs_matrix_fixed *, floatp, floatp, gs_fixed_point * );

typedef struct {

 long xx, xy, yx, yy;

 int skewed;

 int shift;

 int max_bits;

 fixed round;

} fixed_coeff;

typedef enum {

 gs_cap_butt = 0,

 gs_cap_round = 1,

 gs_cap_square = 2

} gs_line_cap;

typedef enum {

 gs_join_miter = 0,

 gs_join_round = 1,

 gs_join_bevel = 2

} gs_line_join;

gs_state *gs_state_alloc(proc_alloc_t, proc_free_t );

int gs_state_free(gs_state * );

int gs_gsave(gs_state * ),

 gs_grestore(gs_state * ),

 gs_grestoreall(gs_state * );

gs_state *gs_gstate(gs_state * );

int gs_currentgstate(gs_state * , const gs_state * ),

 gs_setgstate(gs_state * , const gs_state * );

gs_state *gs_state_swap_saved(gs_state *, gs_state * );

void gs_state_swap(gs_state *, gs_state * );

int gs_initgraphics(gs_state * );

typedef struct gx_device_s gx_device;

int gs_flushpage(gs_state * );

int gs_copypage(gs_state * );

int gs_output_page(gs_state *, int, int );

int gs_copyscanlines(gx_device *, int, byte *, uint, int *, uint * );

gx_device * gs_getdevice(int );

int gs_copydevice(gx_device **, gx_device *, proc_alloc_t );

int gs_makeimagedevice(gx_device **, gs_matrix *, uint, uint, byte *, int, proc_alloc_t );

void gs_nulldevice(gs_state * );

int gs_setdevice(gs_state *, gx_device * );

gx_device * gs_currentdevice(gs_state * );

const char * gs_devicename(gx_device * );

void gs_deviceinitialmatrix(gx_device *, gs_matrix * );

int gs_closedevice(gx_device * );

int gs_setlinewidth(gs_state *, floatp );

float gs_currentlinewidth(const gs_state * );

int gs_setlinecap(gs_state *, gs_line_cap );

gs_line_cap gs_currentlinecap(const gs_state * );

int gs_setlinejoin(gs_state *, gs_line_join );

gs_line_join gs_currentlinejoin(const gs_state * );

int gs_setmiterlimit(gs_state *, floatp );

float gs_currentmiterlimit(const gs_state * );

int gs_setdash(gs_state *, const float *, uint, floatp );

uint gs_currentdash_length(const gs_state * );

int gs_currentdash_pattern(const gs_state *, float * );

float gs_currentdash_offset(const gs_state * );

int gs_setflat(gs_state *, floatp );

float gs_currentflat(const gs_state * );

int gs_setstrokeadjust(gs_state *, int );

int gs_currentstrokeadjust(const gs_state * );

typedef enum {

 gs_color_space_DeviceGray = 0,

 gs_color_space_DeviceRGB,

 gs_color_space_DeviceCMYK

} gs_color_space;

typedef struct gs_color_s gs_color;

extern const uint gs_color_sizeof;

int gs_setgray(gs_state *, floatp );

float gs_currentgray(gs_state * );

int gs_sethsbcolor(gs_state *, floatp, floatp, floatp ),

 gs_currenthsbcolor(gs_state *, float [3] ),

 gs_setrgbcolor(gs_state *, floatp, floatp, floatp ),

 gs_currentrgbcolor(gs_state *, float [3] );

int gs_currentcolorspace(gs_state *, gs_color_space * );

typedef float (*gs_transfer_proc)(gs_state *, floatp );

int gs_settransfer(gs_state *, gs_transfer_proc ),

 gs_settransfer_remap(gs_state *, gs_transfer_proc, int );

gs_transfer_proc gs_currenttransfer(gs_state * );

int gs_setcolortransfer(gs_state *, gs_transfer_proc ,

 gs_transfer_proc , gs_transfer_proc ,

 gs_transfer_proc ),

 gs_setcolortransfer_remap(gs_state *, gs_transfer_proc ,

 gs_transfer_proc , gs_transfer_proc ,

 gs_transfer_proc , int );

void gs_currentcolortransfer(gs_state *, gs_transfer_proc [4] );

int gs_setscreen(gs_state *, floatp, floatp, float (*)(floatp, floatp ) );

int gs_currentscreen(gs_state *, float *, float *, float (**)(floatp, floatp ) );

int gs_sethalftonephase(gs_state *, int, int );

int gs_currenthalftonephase(gs_state *, gs_int_point * );

typedef struct gs_screen_enum_s gs_screen_enum;

extern const uint gs_screen_enum_sizeof;

int gs_screen_init(gs_screen_enum *, gs_state *, floatp, floatp );

int gs_screen_currentpoint(gs_screen_enum *, gs_point * );

int gs_screen_next(gs_screen_enum *, floatp );

struct gs_state_s {

 gs_state *saved;

 gs_memory_procs memory_procs;

 gs_matrix_fixed ctm;

 gs_matrix ctm_inverse;

 int inverse_valid;

 struct gx_path_s *path;

 struct gx_clip_path_s *clip_path;

 int clip_rule;

 struct line_params_s *line_params;

 struct halftone_params_s *halftone;

 float (*ht_proc)(floatp, floatp );

 gs_int_point ht_phase;

 gs_int_point phase_mod;

 struct gs_color_s *color;

 struct gx_device_color_s *dev_color;

 struct gx_transfer_s *transfer;

 struct gs_font_s *font;

 gs_matrix char_tm;

 int char_tm_valid;

 byte in_cachedevice;

 byte in_charpath;

 int level;

 float flatness;

 int stroke_adjust;

 struct device_s *device;

 int device_is_shared;

};

typedef unsigned long gx_bitmap_id;

typedef struct gx_bitmap_s {

 byte *data;

 int raster;

 gs_int_point size;

 gx_bitmap_id id;

 ushort rep_width, rep_height;

} gx_bitmap;

typedef unsigned long gx_color_index;

typedef unsigned short gx_color_value;

typedef struct gx_device_color_info_s {

 int num_components;

 int depth;

 gx_color_value max_gray;

 gx_color_value max_rgb;

 gx_color_value dither_gray;

 gx_color_value dither_rgb;

} gx_device_color_info;

typedef struct gx_device_procs_s gx_device_procs;

struct gx_device_s {

 int params_size; gx_device_procs *procs; const char *dname; int width; int height; float x_pixels_per_inch; float y_pixels_per_inch; float l_margin, b_margin, r_margin, t_margin; gx_device_color_info color_info; int is_open;

};

typedef struct gs_prop_item_s gs_prop_item;

struct gx_device_procs_s {

 int (*open_device)(gx_device *dev );

 void (*get_initial_matrix)(gx_device *dev, gs_matrix *pmat );

 int (*sync_output)(gx_device *dev );

 int (*output_page)(gx_device *dev, int num_copies, int flush );

 int (*close_device)(gx_device *dev );

 gx_color_index (*map_rgb_color)(gx_device *dev, gx_color_value red, gx_color_value green, gx_color_value blue );

 int (*map_color_rgb)(gx_device *dev, gx_color_index color, gx_color_value rgb[3] );

 int (*fill_rectangle)(gx_device *dev, int x, int y, int width, int height, gx_color_index color );

 int (*tile_rectangle)(gx_device *dev, gx_bitmap *tile, int x, int y, int width, int height, gx_color_index color0, gx_color_index color1, int phase_x, int phase_y );

 int (*copy_mono)(gx_device *dev, unsigned char *data, int data_x, int raster, gx_bitmap_id id, int x, int y, int width, int height, gx_color_index color0, gx_color_index color1 );

 int (*copy_color)(gx_device *dev, unsigned char *data, int data_x, int raster, gx_bitmap_id id, int x, int y, int width, int height );

 int (*draw_line)(gx_device *dev, int x0, int y0, int x1, int y1, gx_color_index color );

 int (*get_bits)(gx_device *dev, int y, unsigned char *data, unsigned int size, int pad_to_word );

 int (*get_props)(gx_device *dev, gs_prop_item *plist );

 int (*put_props)(gx_device *dev, gs_prop_item *plist, int count );

};

extern unsigned int gx_device_bytes_per_scan_line(gx_device *dev, int pad_to_word );

int gx_default_open_device(gx_device *dev );

void gx_default_get_initial_matrix(gx_device *dev, gs_matrix *pmat );

int gx_default_sync_output(gx_device *dev );

int gx_default_output_page(gx_device *dev, int num_copies, int flush );

int gx_default_close_device(gx_device *dev );

gx_color_index gx_default_map_rgb_color(gx_device *dev, gx_color_value red, gx_color_value green, gx_color_value blue );

int gx_default_map_color_rgb(gx_device *dev, gx_color_index color, gx_color_value rgb[3] );

int gx_default_tile_rectangle(gx_device *dev, gx_bitmap *tile, int x, int y, int width, int height, gx_color_index color0, gx_color_index color1, int phase_x, int phase_y );

int gx_default_copy_color(gx_device *dev, unsigned char *data, int data_x, int raster, gx_bitmap_id id, int x, int y, int width, int height );

int gx_default_draw_line(gx_device *dev, int x0, int y0, int x1, int y1, gx_color_index color );

int gx_default_get_bits(gx_device *dev, int y, unsigned char *data, unsigned int size, int pad_to_word );

int gx_default_get_props(gx_device *dev, gs_prop_item *plist );

int gx_default_put_props(gx_device *dev, gs_prop_item *plist, int count );

typedef struct device_s {

 gx_device *info;

 int is_band_device;

 gx_color_index white, black;

} device;

int gs_initmatrix(gs_state * ),

 gs_defaultmatrix(const gs_state *, gs_matrix * ),

 gs_currentmatrix(const gs_state *, gs_matrix * ),

 gs_setmatrix(gs_state *, const gs_matrix * ),

 gs_translate(gs_state *, floatp, floatp ),

 gs_scale(gs_state *, floatp, floatp ),

 gs_rotate(gs_state *, floatp ),

 gs_concat(gs_state *, const gs_matrix * );

int gs_transform(gs_state *, floatp, floatp, gs_point * ),

 gs_dtransform(gs_state *, floatp, floatp, gs_point * ),

 gs_itransform(gs_state *, floatp, floatp, gs_point * ),

 gs_idtransform(gs_state *, floatp, floatp, gs_point * );

static int

ctm_set_inverse(gs_state *pgs)

{ int code = gs_matrix_invert(&*(gs_matrix *)&(pgs)->ctm , &pgs->ctm_inverse);

 0;

 if ( code < 0 ) return code;

 pgs->inverse_valid = 1;

 return 0;

}

void

gs_update_matrix_fixed(gs_matrix_fixed *pmat)

{ (*pmat). tx = ((float)(((*pmat). tx_fixed = ((fixed)(((*pmat). tx)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , (*pmat). ty = ((float)(((*pmat). ty_fixed = ((fixed)(((*pmat). ty)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) )));

}

int

gs_initmatrix(gs_state *pgs)

{ gx_device *dev = pgs->device->info;

 (*dev->procs->get_initial_matrix)(dev, &*(gs_matrix *)&(pgs)->ctm );

 (pgs->ctm). tx = ((float)(((pgs->ctm). tx_fixed = ((fixed)(((pgs->ctm). tx)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , (pgs->ctm). ty = ((float)(((pgs->ctm). ty_fixed = ((fixed)(((pgs->ctm). ty)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , pgs->inverse_valid = 0, pgs->char_tm_valid = 0;

 return 0;

}

int

gs_defaultmatrix(const gs_state *pgs, gs_matrix *pmat)

{ gx_device *dev = pgs->device->info;

 (*dev->procs->get_initial_matrix)(dev, pmat);

 return 0;

}

int

gs_currentmatrix(const gs_state *pgs, gs_matrix *pmat)

{ *pmat = *(gs_matrix *)&(pgs)->ctm;

 return 0;

}

int

gs_setmatrix(gs_state *pgs, const gs_matrix *pmat)

{ *(gs_matrix *)&(pgs)->ctm = *pmat;

 (pgs->ctm). tx = ((float)(((pgs->ctm). tx_fixed = ((fixed)(((pgs->ctm). tx)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , (pgs->ctm). ty = ((float)(((pgs->ctm). ty_fixed = ((fixed)(((pgs->ctm). ty)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , pgs->inverse_valid = 0, pgs->char_tm_valid = 0;

 return 0;

}

int

gs_translate(gs_state *pgs, floatp dx, floatp dy)

{ gs_point pt;

 int code;

 if ( (code = gs_distance_transform(dx, dy, &*(gs_matrix *)&(pgs)->ctm , &pt)) < 0 )

 return code;

 pgs->ctm.tx += pt.x;

 pgs->ctm.ty += pt.y;

 (pgs->ctm). tx = ((float)(((pgs->ctm). tx_fixed = ((fixed)(((pgs->ctm). tx)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , (pgs->ctm). ty = ((float)(((pgs->ctm). ty_fixed = ((fixed)(((pgs->ctm). ty)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , pgs->inverse_valid = 0, pgs->char_tm_valid = 0;

 return 0;

}

int

gs_scale(gs_state *pgs, floatp sx, floatp sy)

{ pgs->ctm.xx *= sx;

 pgs->ctm.xy *= sx;

 pgs->ctm.yx *= sy;

 pgs->ctm.yy *= sy;

 pgs->inverse_valid = 0, pgs->char_tm_valid = 0;

 return 0;

}

int

gs_rotate(gs_state *pgs, floatp ang)

{ int code = gs_matrix_rotate(&*(gs_matrix *)&(pgs)->ctm , ang, &*(gs_matrix *)&(pgs)->ctm );

 pgs->inverse_valid = 0, pgs->char_tm_valid = 0;

 return code;

}

int

gs_concat(gs_state *pgs, const gs_matrix *pmat)

{ int code = gs_matrix_multiply(pmat, &*(gs_matrix *)&(pgs)->ctm , &*(gs_matrix *)&(pgs)->ctm );

 (pgs->ctm). tx = ((float)(((pgs->ctm). tx_fixed = ((fixed)(((pgs->ctm). tx)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , (pgs->ctm). ty = ((float)(((pgs->ctm). ty_fixed = ((fixed)(((pgs->ctm). ty)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , pgs->inverse_valid = 0, pgs->char_tm_valid = 0;

 return code;

}

int

gs_transform(gs_state *pgs, floatp x, floatp y, gs_point *pt)

{ return gs_point_transform(x, y, &*(gs_matrix *)&(pgs)->ctm , pt);

}

int

gs_dtransform(gs_state *pgs, floatp dx, floatp dy, gs_point *pt)

{ return gs_distance_transform(dx, dy, &*(gs_matrix *)&(pgs)->ctm , pt);

}

int

gs_itransform(gs_state *pgs, floatp x, floatp y, gs_point *pt)

{

 if ( !!(((*(long *)(&((&pgs->ctm)->xy)) | *(long *)(&( (&pgs->ctm)->yx)) ) << 1) == 0) )

 { return gs_point_transform_inverse(x, y, &*(gs_matrix *)&(pgs)->ctm , pt);

 }

 else

 { if ( !pgs->inverse_valid ) { int code = ctm_set_inverse(pgs); if ( code < 0 ) return code; };

 return gs_point_transform(x, y, &pgs->ctm_inverse, pt);

 }

}

int

gs_idtransform(gs_state *pgs, floatp dx, floatp dy, gs_point *pt)

{

 if ( !!(((*(long *)(&((&pgs->ctm)->xy)) | *(long *)(&( (&pgs->ctm)->yx)) ) << 1) == 0) )

 { return gs_distance_transform_inverse(dx, dy,

 &*(gs_matrix *)&(pgs)->ctm , pt);

 }

 else

 { if ( !pgs->inverse_valid ) { int code = ctm_set_inverse(pgs); if ( code < 0 ) return code; };

 return gs_distance_transform(dx, dy, &pgs->ctm_inverse, pt);

 }

}

int

gs_translate_to_fixed(register gs_state *pgs, fixed px, fixed py)

{ pgs->ctm.tx = ((float)((pgs->ctm.tx_fixed = px)*(1.0/(1<<12 ) )));