From 73ef1c56c82c5df134ad8ca82d7a5cd8ed34613a Mon Sep 17 00:00:00 2001 From: master2i Date: Fri, 30 Sep 2016 17:34:41 +0200 Subject: [PATCH] add include --- BTKOM.o | Bin 0 -> 3352 bytes SRC/BTKOM.cpp | 30 + SRC/MonochromeLib.c | 1289 ++++++++++++++++++++++++++++++++++++++ SRC/bluetooth.cpp | 285 +++++++++ SRC/syscall.s | 106 ++++ SRC/syscall.src | 29 + addin.bin | Bin 0 -> 18772 bytes addin.elf | Bin 0 -> 58764 bytes addin.g1a | Bin 0 -> 19284 bytes addin.ld | 31 + bluetooth.o | Bin 0 -> 10432 bytes compi | 1 + crt0.o | Bin 0 -> 2032 bytes crt0.s | 172 +++++ icon.bmp | Bin 0 -> 1870 bytes include/BTKOM.h | 11 + include/MonochromeLib.h | 151 +++++ include/_h_c_lib.h | 29 + include/assert.h | 39 ++ include/bluetooth.h | 185 ++++++ include/builtin.h | 84 +++ include/complex | 189 ++++++ include/ctype.h | 66 ++ include/ensigdsp.h | 257 ++++++++ include/errno.h | 114 ++++ include/exception.h | 74 +++ include/filt_ws.h | 26 + include/float.h | 208 ++++++ include/iomanip | 60 ++ include/ios | 192 ++++++ include/iostream | 27 + include/istream | 112 ++++ include/libfx.h | 97 +++ include/libfx/dispbios.h | 94 +++ include/libfx/endian.h | 22 + include/libfx/filebios.h | 113 ++++ include/libfx/keybios.h | 155 +++++ include/libfx/timer.h | 23 + include/limits.h | 35 ++ include/machine.h | 23 + include/math.h | 111 ++++ include/mathf.h | 66 ++ include/mystrbuf | 53 ++ include/new | 31 + include/new_ecpp.h | 41 ++ include/new_edg.h | 122 ++++ include/ostream | 87 +++ include/setjmp.h | 48 ++ include/smachine.h | 28 + include/stdarg.h | 36 ++ include/stddef.h | 46 ++ include/stdexcept.h | 47 ++ include/stdio.h | 146 +++++ include/stdlib.h | 127 ++++ include/streambuf | 97 +++ include/string | 213 +++++++ include/string.h | 57 ++ include/syscall.h | 68 ++ include/typeinfo.h | 82 +++ include/umachine.h | 55 ++ libfx.a | Bin 0 -> 410910 bytes libmonochrome.a | Bin 0 -> 36736 bytes opti | 1 + wrapper | 1 + 64 files changed, 5892 insertions(+) create mode 100644 BTKOM.o create mode 100644 SRC/BTKOM.cpp create mode 100644 SRC/MonochromeLib.c create mode 100644 SRC/bluetooth.cpp create mode 100644 SRC/syscall.s create mode 100644 SRC/syscall.src create mode 100755 addin.bin create mode 100755 addin.elf create mode 100644 addin.g1a create mode 100644 addin.ld create mode 100644 bluetooth.o create mode 100755 compi create mode 100644 crt0.o create mode 100644 crt0.s create mode 100644 icon.bmp create mode 100644 include/BTKOM.h create mode 100644 include/MonochromeLib.h create mode 100644 include/_h_c_lib.h create mode 100644 include/assert.h create mode 100644 include/bluetooth.h create mode 100644 include/builtin.h create mode 100644 include/complex create mode 100644 include/ctype.h create mode 100644 include/ensigdsp.h create mode 100644 include/errno.h create mode 100644 include/exception.h create mode 100644 include/filt_ws.h create mode 100644 include/float.h create mode 100644 include/iomanip create mode 100644 include/ios create mode 100644 include/iostream create mode 100644 include/istream create mode 100644 include/libfx.h create mode 100644 include/libfx/dispbios.h create mode 100644 include/libfx/endian.h create mode 100644 include/libfx/filebios.h create mode 100644 include/libfx/keybios.h create mode 100644 include/libfx/timer.h create mode 100644 include/limits.h create mode 100644 include/machine.h create mode 100644 include/math.h create mode 100644 include/mathf.h create mode 100644 include/mystrbuf create mode 100644 include/new create mode 100644 include/new_ecpp.h create mode 100644 include/new_edg.h create mode 100644 include/ostream create mode 100644 include/setjmp.h create mode 100644 include/smachine.h create mode 100644 include/stdarg.h create mode 100644 include/stddef.h create mode 100644 include/stdexcept.h create mode 100644 include/stdio.h create mode 100644 include/stdlib.h create mode 100644 include/streambuf create mode 100644 include/string create mode 100644 include/string.h create mode 100644 include/syscall.h create mode 100644 include/typeinfo.h create mode 100644 include/umachine.h create mode 100644 libfx.a create mode 100644 libmonochrome.a create mode 100755 opti create mode 100755 wrapper diff --git a/BTKOM.o b/BTKOM.o new file mode 100644 index 0000000000000000000000000000000000000000..fbb239db01e43449dbf78dd326b01608e9480abb GIT binary patch literal 3352 zcmbVO&2Jk;6d&7AzWR|C3Waj8goKI&R;(2IAynl9H`~TZL()j4qMB^%ZN0)@@~%Tt z5g`ad_)sY)=z#+qfCHR3xg1hNC7}HS%7IITR4D=^#K$3^i12>v_qvm*ec@TN^WJZM z@4cBfJF|W>mp`6NB$P-(9aFI-s8VMhi1oop9aOv2b~WR)ZeNAHhR4deYXF?(UuT_m z$t#y@1UjwU*UqJx@7rKpxi><7_|y5^Y5jA)m2{TBNjjHuA33e>q7XxEq`w00S9q+Z zCzOgafVv7?_!OC&r_UiDve#rS;8CrJ4s~ z&(0K(FUDeR<$AQ-Rd`*+wAVh_+}u2O4SbfV+{>bN`q7b*qv->q6En}GpU(_r`g!yb z?h_ZMRAQkov48u0_peaMCkaP`?8akgXWzTYksaIeL?Ck?wHJYte1?aNlM25xz(^cC zWGp!nIj0F)08X+O4;i2A#0I1?!D1zJ=co@GoxUVm!z;U)&|3&qrs#&Q%FG3U$~0;n zBO3LqeyH6>!(CLFLakEqszk2VLN7xVcrFOt!fWJ#I9^GgZ@3jNO4|E@D&M1ir-I)t zsjhFXQYrd%lN3d=CybD;h{XaH0SgQ zJy&jeVXYRHRIKTZt^s4g|ed5TlP_hFJui(|gaW4qm3tnzsRb0Oc&LM_IvIK7N z;Yc~(pFBQ4pQHRS`%vJ8rx)v9ZgQ+(;@N&0kR&{2%px0j)#9CDNv+27y66Y>vb(6~ z>BOs1FC6n05qCN~?AHQ4=LX)v6I7wjEOjxc=@ONw>~$l(6fH#;7F_MpWfWD~s6`Y* z-8s29Njr?amy?B8Vi&ayy1*gh%mI!wAh?_-`0Zp4x(lq^@ym=O&K_zKr)lub+hEDy zKWy+<3>@DIiG%Y9vGac1f$47Q-0i~u)W9DlUGOgr{4oQ+$vEQUwv_e%$T;Hfqb6}~ zF%JIYtfRZlx*g|d1IJw|@*69Nzn_}K|BG?NG57Ir#=*yTPxuT+Hy_623QY3=un1>+ z(8A^Zd)30*Y`+XvYz8G=<}Wb*M|4~NIumD^i1p(viodKM=f&Wx=-R4*F#V+uUQ1 WF$X(8{z-MqKgoaL-nSB3ruq*xSFn5l literal 0 HcmV?d00001 diff --git a/SRC/BTKOM.cpp b/SRC/BTKOM.cpp new file mode 100644 index 0000000..1b158f3 --- /dev/null +++ b/SRC/BTKOM.cpp @@ -0,0 +1,30 @@ + +#include "BTKOM.h" + +Bluetooth bluetooth; + +void listen(){ + //bluetooth.receptMessage(); +} + + +int main(){ + unsigned int key; + int timer; + int err = 156; + char buffer[255] = {"lolilol"}; + Message toSend; + err = bluetooth.listen(2000, 0, listen, 1); + toSend.setType("REQ"); + toSend.setMessage(buffer); + bluetooth.sendMessage(&toSend); +ML_display_vram(); + while(1){ + GetKey(&key); + } + + return 1; +} + + + diff --git a/SRC/MonochromeLib.c b/SRC/MonochromeLib.c new file mode 100644 index 0000000..9b753c8 --- /dev/null +++ b/SRC/MonochromeLib.c @@ -0,0 +1,1289 @@ +/*************************************************************/ +/** MonochromeLib - monochrome graphic library for fx-9860G **/ +/** MonochromeLib is free software **/ +/** **/ +/** @author Pierre "PierrotLL" Le Gall **/ +/** @contact legallpierre89@gmail.com **/ +/** **/ +/** @file MonochromeLib.c **/ +/** Code file of MonochromeLib **/ +/** **/ +/** @date 11-22-2011 **/ +/*************************************************************/ + +#include "MonochromeLib.h" +#include + + +/******************************/ +/** Dependencies management **/ +/******************************/ + +#ifdef ML_ALL + #define ML_CLEAR_VRAM + #define ML_CLEAR_SCREEN + #define ML_DISPLAY_VRAM + #define ML_SET_CONTRAST + #define ML_GET_CONTRAST + #define ML_PIXEL + #define ML_POINT + #define ML_PIXEL_TEST + #define ML_LINE + #define ML_HORIZONTAL_LINE + #define ML_VERTICAL_LINE + #define ML_RECTANGLE + #define ML_POLYGON + #define ML_FILLED_POLYGON + #define ML_CIRCLE + #define ML_FILLED_CIRCLE + #define ML_ELLIPSE + #define ML_ELLIPSE_IN_RECT + #define ML_FILLED_ELLIPSE + #define ML_FILLED_ELLIPSE_IN_RECT + #define ML_HORIZONTAL_SCROLL + #define ML_VERTICAL_SCROLL + #define ML_BMP_OR + #define ML_BMP_AND + #define ML_BMP_XOR + #define ML_BMP_OR_CL + #define ML_BMP_AND_CL + #define ML_BMP_XOR_CL + #define ML_BMP_8_OR + #define ML_BMP_8_AND + #define ML_BMP_8_XOR + #define ML_BMP_8_OR_CL + #define ML_BMP_8_AND_CL + #define ML_BMP_8_XOR_CL + #define ML_BMP_16_OR + #define ML_BMP_16_AND + #define ML_BMP_16_XOR + #define ML_BMP_16_OR_CL + #define ML_BMP_16_AND_CL + #define ML_BMP_16_XOR_CL +#endif + +#ifdef ML_POLYGON + #define ML_LINE +#endif + +#ifdef ML_LINE + #define ML_PIXEL +#endif + +#ifdef ML_POINT + #define ML_PIXEL + #define ML_RECTANGLE +#endif + +#ifdef ML_RECTANGLE + #define ML_HORIZONTAL_LINE +#endif + +#ifdef ML_FILLED_POLYGON + #define ML_HORIZONTAL_LINE +#endif + +#ifdef ML_CIRCLE + #define ML_PIXEL +#endif + +#ifdef ML_FILLED_CIRCLE + #define ML_HORIZONTAL_LINE +#endif + +#ifdef ML_ELLIPSE_IN_RECT + #define ML_ELLIPSE +#endif + +#ifdef ML_ELLIPSE + #define ML_PIXEL +#endif + +#ifdef ML_FILLED_ELLIPSE_IN_RECT + #define ML_FILLED_ELLIPSE +#endif + +#ifdef ML_FILLED_ELLIPSE + #define ML_HORIZONTAL_LINE +#endif + + +/***************/ +/** Functions **/ +/***************/ + +#define sgn(x) (x<0?-1:1) +#define rnd(x) ((int)(x+0.5)) + +//Thanks to Simon Lothar for this function +static int SysCallCode[] = {0xD201422B,0x60F20000,0x80010070}; +static int (*SysCall)( int R4, int R5, int R6, int R7, int FNo ) = (void*)&SysCallCode; +char* ML_vram_adress() +{ + return (char*)((*SysCall)(0, 0, 0, 0, 309)); +} + +#ifdef ML_CLEAR_VRAM +void ML_clear_vram() +{ + int i, end, *pointer_long, vram; + char *pointer_byte; + vram = (int)ML_vram_adress(); + end = 4-vram&3; + pointer_byte = (char*)vram; + for(i=0 ; i>3)] |= 128>>(x&7); + break; + case ML_WHITE: + vram[(y<<4)+(x>>3)] &= ~(128>>(x&7)); + break; + case ML_XOR: + vram[(y<<4)+(x>>3)] ^= 128>>(x&7); + break; + case ML_CHECKER: + if(y&1^x&1) vram[(y<<4)+(x>>3)] &= ~(128>>(x&7)); + else vram[(y<<4)+(x>>3)] |= 128>>(x&7); + break; + } +} +#endif + +#ifdef ML_POINT +void ML_point(int x, int y, int width, ML_Color color) +{ + if(width < 1) return; + if(width == 1) ML_pixel(x, y, color); + else + { + int padding, pair; + padding = width>>1; + pair = !(width&1); + ML_rectangle(x-padding+pair, y-padding+pair, x+padding, y+padding, 0, 0, color); + } +} +#endif + +#ifdef ML_PIXEL_TEST +ML_Color ML_pixel_test(int x, int y) +{ + char *vram, byte; + if(x&~127 || y&~63) return ML_TRANSPARENT; + vram = ML_vram_adress(); + byte = 1<<(7-(x&7)); + return (vram[(y<<4)+(x>>3)] & byte ? ML_BLACK : ML_WHITE); + +} +#endif + +#ifdef ML_LINE +void ML_line(int x1, int y1, int x2, int y2, ML_Color color) +{ + int i, x, y, dx, dy, sx, sy, cumul; + x = x1; + y = y1; + dx = x2 - x1; + dy = y2 - y1; + sx = sgn(dx); + sy = sgn(dy); + dx = abs(dx); + dy = abs(dy); + ML_pixel(x, y, color); + if(dx > dy) + { + cumul = dx / 2; + for(i=1 ; i dx) + { + cumul -= dx; + y += sy; + } + ML_pixel(x, y, color); + } + } + else + { + cumul = dy / 2; + for(i=1 ; i dy) + { + cumul -= dy; + x += sx; + } + ML_pixel(x, y, color); + } + } +} +#endif + +#ifdef ML_HORIZONTAL_LINE +void ML_horizontal_line(int y, int x1, int x2, ML_Color color) +{ + int i; + char checker; + char* vram = ML_vram_adress(); + if(y&~63 || (x1<0 && x2<0) || (x1>127 && x2>127)) return; + if(x1 > x2) + { + i = x1; + x1 = x2; + x2 = i; + } + if(x1 < 0) x1 = 0; + if(x2 > 127) x2 = 127; + switch(color) + { + case ML_BLACK: + if(x1>>3 != x2>>3) + { + vram[(y<<4)+(x1>>3)] |= 255 >> (x1&7); + vram[(y<<4)+(x2>>3)] |= 255 << 7-(x2&7); + for(i=(x1>>3)+1 ; i>3 ; i++) + vram[(y<<4) + i] = 255; + } + else vram[(y<<4)+(x1>>3)] |= (255>>(x1%8 + 7-x2%8))<<(7-(x2&7)); + break; + case ML_WHITE: + if(x1>>3 != x2>>3) + { + vram[(y<<4)+(x1>>3)] &= 255 << 8-(x1&7); + vram[(y<<4)+(x2>>3)] &= 255 >> 1+(x2&7); + for(i=(x1>>3)+1 ; i>3 ; i++) + vram[(y<<4) + i] = 0; + } + else vram[(y<<4)+(x1>>3)] &= (255<<8-(x1&7)) | (255>>1+(x2&7)); + break; + case ML_XOR: + if(x1>>3 != x2>>3) + { + vram[(y<<4)+(x1>>3)] ^= 255 >> (x1&7); + vram[(y<<4)+(x2>>3)] ^= 255 << 7-(x2&7); + for(i=(x1>>3)+1 ; i<(x2>>3) ; i++) + vram[(y<<4) + i] ^= 255; + } + else vram[(y<<4)+(x1>>3)] ^= (255>>((x1&7) + 7-(x2&7)))<<(7-(x2&7)); + break; + case ML_CHECKER: + checker = (y&1 ? 85 : 170); + if(x1>>3 != x2>>3) + { + vram[(y<<4)+(x1>>3)] &= 255 << 8-(x1&7); + vram[(y<<4)+(x2>>3)] &= 255 >> 1+(x2&7); + vram[(y<<4)+(x1>>3)] |= checker & 255>>(x1&7); + vram[(y<<4)+(x2>>3)] |= checker & 255<<7-(x2&7); + for(i=(x1>>3)+1 ; i>3 ; i++) + vram[(y<<4) + i] = checker; + } + else + { + vram[(y<<4)+(x1>>3)] &= (255<<8-(x1&7)) | (255>>1+(x2&7)); + vram[(y<<4)+(x1>>3)] |= checker & (255>>(x1%8 + 7-x2%8))<<(7-(x2&7)); + } + break; + } +} + +#endif + +#ifdef ML_VERTICAL_LINE +void ML_vertical_line(int x, int y1, int y2, ML_Color color) +{ + int i, j; + char checker, byte, *vram = ML_vram_adress(); + if(x&~127 || (y1<0 && y2<0) || (y1>63 && y2>63)) return; + if(y1 > y2) + { + int tmp = y1; + y1 = y2; + y2 = tmp; + } + if(y1 < 0) y1 = 0; + if(y2 > 63) y2 = 63; + + i = (y1<<4)+(x>>3); + j = (y2<<4)+(x>>3); + switch(color) + { + case ML_BLACK: + byte = 128>>(x&7); + for( ; i<=j ; i+=16) + vram[i] |= byte; + break; + case ML_WHITE: + byte = ~(128>>(x&7)); + for( ; i<=j ; i+=16) + vram[i] &= byte; + break; + case ML_XOR: + byte = 128>>(x&7); + for( ; i<=j ; i+=16) + vram[i] ^= byte; + break; + case ML_CHECKER: + byte = 128>>(x&7); + checker = y1&1^x&1; + for( ; i<=j ; i+=16) + { + if(checker) vram[i] &= ~byte; + else vram[i] |= byte; + checker = !checker; + } + break; + } +} +#endif + +#ifdef ML_RECTANGLE +void ML_rectangle(int x1, int y1, int x2, int y2, int border_width, ML_Color border_color, ML_Color fill_color) +{ + int i; + if(x1 > x2) + { + i = x1; + x1 = x2; + x2 = i; + } + if(y1 > y2) + { + i = y1; + y1 = y2; + y2 = i; + } + if(border_width > (x2-x1)/2+1) border_width = (x2-x1)/2+1; + if(border_width > (y2-y1)/2+1) border_width = (y2-y1)/2+1; + if(border_color != ML_TRANSPARENT && border_width > 0) + { + for(i=0 ; i t[i]) + { + j++; + tmp = t[j]; + t[j] = t[i]; + t[i] = tmp; + } + } + t[r] = t[j+1]; + t[j+1] = x; + return j + 1; +} + +static void ML_filled_polygon_quicksord(int* t, int p, int r) +{ + int q; + if(p < r) + { + q = ML_filled_polygon_quicksord_partition(t, p, r); + ML_filled_polygon_quicksord(t, p, q-1); + ML_filled_polygon_quicksord(t, q+1, r); + } +} + + +void ML_filled_polygon(const int *x, const int *y, int nb_vertices, ML_Color color) +{ + int i, j, dx, dy, ymin, ymax; + int *cut_in_line, nb_cut; + if(nb_vertices < 3) return; + cut_in_line = malloc(nb_vertices*sizeof(int)); + if(!cut_in_line) return; + ymin = ymax = y[0]; + for(i=1 ; i ymax) ymax = y[i]; + } + for(i=ymin ; i<=ymax ; i++) + { + nb_cut = 0; + for(j=0 ; j=i) || (y[j]>=i && y[(j+1)%nb_vertices]<=i)) + { + dy = abs(y[j]-y[(j+1)%nb_vertices]); + if(dy) + { + dx = x[(j+1)%nb_vertices]-x[j]; + cut_in_line[nb_cut] = x[j] + rnd(abs(i-y[j]+sgn(i-y[j])/2)*dx/dy); + nb_cut++; + } + } + } + ML_filled_polygon_quicksord(cut_in_line, 0, nb_cut-1); + j = 0; + while(j plot_x) + { + if(d < 0) + d += 2*plot_x+3; + else + { + d += 2*(plot_x-plot_y)+5; + plot_y--; + } + plot_x++; + if(plot_y >= plot_x) + { + ML_pixel(x+plot_x, y+plot_y, color); + ML_pixel(x-plot_x, y+plot_y, color); + ML_pixel(x+plot_x, y-plot_y, color); + ML_pixel(x-plot_x, y-plot_y, color); + } + if(plot_y > plot_x) + { + ML_pixel(x+plot_y, y+plot_x, color); + ML_pixel(x-plot_y, y+plot_x, color); + ML_pixel(x+plot_y, y-plot_x, color); + ML_pixel(x-plot_y, y-plot_x, color); + } + } +} +#endif + +#ifdef ML_FILLED_CIRCLE +void ML_filled_circle(int x, int y, int radius, ML_Color color) +{ + int plot_x, plot_y, d; + + if(radius < 0) return; + plot_x = 0; + plot_y = radius; + d = 1 - radius; + + ML_horizontal_line(y, x-plot_y, x+plot_y, color); + while(plot_y > plot_x) + { + if(d < 0) + d += 2*plot_x+3; + else { + d += 2*(plot_x-plot_y)+5; + plot_y--; + ML_horizontal_line(y+plot_y+1, x-plot_x, x+plot_x, color); + ML_horizontal_line(y-plot_y-1, x-plot_x, x+plot_x, color); + } + plot_x++; + if(plot_y >= plot_x) + { + ML_horizontal_line(y+plot_x, x-plot_y, x+plot_y, color); + ML_horizontal_line(y-plot_x, x-plot_y, x+plot_y, color); + } + } +} +#endif + +#ifdef ML_ELLIPSE +void ML_ellipse(int x, int y, int radius1, int radius2, ML_Color color) +{ + int plot_x, plot_y; + float d1, d2; + if(radius1 < 1 || radius2 < 1) return; + plot_x = 0; + plot_y = radius2; + d1 = radius2*radius2 - radius1*radius1*radius2 + radius1*radius1/4; + ML_pixel(x, y+plot_y, color); + ML_pixel(x, y-plot_y, color); + while(radius1*radius1*(plot_y-.5) > radius2*radius2*(plot_x+1)) + { + if(d1 < 0) + { + d1 += radius2*radius2*(2*plot_x+3); + plot_x++; + } else { + d1 += radius2*radius2*(2*plot_x+3) + radius1*radius1*(-2*plot_y+2); + plot_x++; + plot_y--; + } + ML_pixel(x+plot_x, y+plot_y, color); + ML_pixel(x-plot_x, y+plot_y, color); + ML_pixel(x+plot_x, y-plot_y, color); + ML_pixel(x-plot_x, y-plot_y, color); + } + d2 = radius2*radius2*(plot_x+.5)*(plot_x+.5) + radius1*radius1*(plot_y-1)*(plot_y-1) - radius1*radius1*radius2*radius2; + while(plot_y > 0) + { + if(d2 < 0) + { + d2 += radius2*radius2*(2*plot_x+2) + radius1*radius1*(-2*plot_y+3); + plot_y--; + plot_x++; + } else { + d2 += radius1*radius1*(-2*plot_y+3); + plot_y--; + } + ML_pixel(x+plot_x, y+plot_y, color); + ML_pixel(x-plot_x, y+plot_y, color); + if(plot_y > 0) + { + ML_pixel(x+plot_x, y-plot_y, color); + ML_pixel(x-plot_x, y-plot_y, color); + } + } +} +#endif + +#ifdef ML_ELLIPSE_IN_RECT +void ML_ellipse_in_rect(int x1, int y1, int x2, int y2, ML_Color color) +{ + int radius1, radius2; + if(x1 > x2) + { + int tmp = x1; + x1 = x2; + x2 = tmp; + } + if(y1 > y2) + { + int tmp = y1; + y1 = y2; + y2 = tmp; + } + radius1 = (x2-x1)/2; + radius2 = (y2-y1)/2; + ML_ellipse(x1+radius1, y1+radius2, radius1, radius2, color); +} +#endif + +#ifdef ML_FILLED_ELLIPSE +void ML_filled_ellipse(int x, int y, int radius1, int radius2, ML_Color color) +{ + int plot_x, plot_y; + float d1, d2; + if(radius1 < 1 || radius2 < 1) return; + plot_x = 0; + plot_y = radius2; + d1 = radius2*radius2 - radius1*radius1*radius2 + radius1*radius1/4; + while(radius1*radius1*(plot_y-.5) > radius2*radius2*(plot_x+1)) + { + if(d1 < 0) + { + d1 += radius2*radius2*(2*plot_x+3); + plot_x++; + } else { + d1 += radius2*radius2*(2*plot_x+3) + radius1*radius1*(-2*plot_y+2); + ML_horizontal_line(y+plot_y, x-plot_x, x+plot_x, color); + ML_horizontal_line(y-plot_y, x-plot_x, x+plot_x, color); + plot_x++; + plot_y--; + } + } + ML_horizontal_line(y+plot_y, x-plot_x, x+plot_x, color); + ML_horizontal_line(y-plot_y, x-plot_x, x+plot_x, color); + d2 = radius2*radius2*(plot_x+.5)*(plot_x+.5) + radius1*radius1*(plot_y-1)*(plot_y-1) - radius1*radius1*radius2*radius2; + while(plot_y > 0) + { + if(d2 < 0) + { + d2 += radius2*radius2*(2*plot_x+2) + radius1*radius1*(-2*plot_y+3); + plot_y--; + plot_x++; + } else { + d2 += radius1*radius1*(-2*plot_y+3); + plot_y--; + } + ML_horizontal_line(y+plot_y, x-plot_x, x+plot_x, color); + if(plot_y > 0) + ML_horizontal_line(y-plot_y, x-plot_x, x+plot_x, color); + } +} +#endif + +#ifdef ML_FILLED_ELLIPSE_IN_RECT +void ML_filled_ellipse_in_rect(int x1, int y1, int x2, int y2, ML_Color color) +{ + int radius1, radius2; + if(x1 > x2) + { + int tmp = x1; + x1 = x2; + x2 = tmp; + } + if(y1 > y2) + { + int tmp = y1; + y1 = y2; + y2 = tmp; + } + radius1 = (x2-x1)/2; + radius2 = (y2-y1)/2; + ML_filled_ellipse(x1+radius1, y1+radius2, radius1, radius2, color); +} +#endif + +#ifdef ML_HORIZONTAL_SCROLL +void ML_horizontal_scroll(int scroll) +{ + int i, j; + char line[16], shift, *vram; + unsigned char next; + unsigned short word; + vram = ML_vram_adress(); + scroll %= 128; + shift = 8-(scroll&7); + for(i=0 ; i<64 ; i++) + { + for(j=0 ; j<16 ; j++) line[j] = vram[(i<<4)+((j-(scroll>>3)+15)&15)]; + next = line[15]; + vram[(i<<4)+15] = 0; + for(j=15 ; j>0 ; j--) + { + word = next << shift; + next = line[j-1]; + vram[(i<<4)+j] |= *((char*)&word+1); + vram[(i<<4)+j-1] = *((char*)&word); + } + word = next << shift; + vram[(i<<4)] |= *((char*)&word+1); + vram[(i<<4)+15] |= *((char*)&word); + } +} +#endif + +#ifdef ML_VERTICAL_SCROLL +void ML_vertical_scroll(int scroll) +{ + int i, j; + char column[64], *vram = ML_vram_adress(); + scroll %= 64; + for(i=0 ; i<16 ; i++) + { + for(j=0 ; j<64 ; j++) column[j] = vram[(j<<4)+i]; + for(j=0 ; j<64 ; j++) vram[(j<<4)+i] = column[(j-scroll+64)&63]; + } +} +#endif + +#ifdef ML_BMP_OR +void ML_bmp_or(const unsigned char *bmp, int x, int y, int width, int height) +{ + unsigned short line; + char shift, *screen, *p=(char*)&line; + int i, j, begin=0, end=height, real_width=(width-1>>3<<3)+8; + if(!bmp || x<0 || x>128-width || y<1-height || y>63 || width<1 || height<1) return; + if(y < 0) begin = -y; + if(y+height > 64) end = 64-y; + shift = 8-(x&7); + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i>3 ; j++) + { + line = bmp[i*(real_width>>3)+j]<>3)+j] & -1<<(real_width-width))<>3<<3)+8; + if(!bmp || x<0 || x>128-width || y<1-height || y>63 || width<1 || height<1) return; + if(y < 0) begin = -y; + if(y+height > 64) end = 64-y; + shift = 8-(x&7); + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i>3 ; j++) + { + line = ~((unsigned char)~bmp[i*(real_width>>3)+j]<>3)+j] | (unsigned char)-1>>8-(width&7))<>3<<3)+8; + if(!bmp || x<0 || x>128-width || y<1-height || y>63 || width<1 || height<1) return; + if(y < 0) begin = -y; + if(y+height > 64) end = 64-y; + shift = 8-(x&7); + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i>3 ; j++) + { + line = bmp[i*(real_width>>3)+j]<>3)+j] & -1<<(real_width-width))<127 || y<1-height || y>63 || height<1 || width<1) return; + p = (char*)&line; + real_width = (width-1>>3<<3)+8; + if(y < 0) begin_y = -y; + else begin_y = 0; + if(y+height > 64) end_y = 64-y; + else end_y = height; + shift = 8-(x&7); + if(x<0) + { + begin_x = -x>>3; + if(shift != 8) bool1 = 0; + } else begin_x = 0; + if(x+real_width > 128) end_x = 15-(x>>3), bool2 = 0; + else end_x = real_width-1>>3; + bool3 = (end_x == real_width-1>>3); + screen = ML_vram_adress()+(y+begin_y<<4)+(x>>3); + + for(i=begin_y ; i>3)+begin_x] << shift; + if(bool1) screen[begin_x] |= *p; + if(shift!=8) screen[begin_x+1] |= *(p+1); + for(j=begin_x+1 ; j>3)+j] << shift; + screen[j] |= *p; + if(shift!=8) screen[j+1] |= *(p+1); + } + } + line = bmp[i*(real_width>>3)+end_x]; + if(bool3) line &= -1<127 || y<1-height || y>63 || height<1 || width<1) return; + p = (char*)&line; + real_width = (width-1>>3<<3)+8; + if(y < 0) begin_y = -y; + else begin_y = 0; + if(y+height > 64) end_y = 64-y; + else end_y = height; + shift = 8-(x&7); + if(x<0) + { + begin_x = -x>>3; + if(shift != 8) bool1 = 0; + } else begin_x = 0; + if(x+real_width > 128) end_x = 15-(x>>3), bool2 = 0; + else end_x = real_width-1>>3; + bool3 = (end_x == real_width-1>>3); + screen = ML_vram_adress()+(y+begin_y<<4)+(x>>3); + + for(i=begin_y ; i>3)+begin_x]<>3)+j]<>3)+end_x]; + if(bool3) line &= -1<127 || y<1-height || y>63 || height<1 || width<1) return; + p = (char*)&line; + real_width = (width-1>>3<<3)+8; + if(y < 0) begin_y = -y; + else begin_y = 0; + if(y+height > 64) end_y = 64-y; + else end_y = height; + shift = 8-(x&7); + if(x<0) + { + begin_x = -x>>3; + if(shift != 8) bool1 = 0; + } else begin_x = 0; + if(x+real_width > 128) end_x = 15-(x>>3), bool2 = 0; + else end_x = real_width-1>>3; + bool3 = (end_x == real_width-1>>3); + screen = ML_vram_adress()+(y+begin_y<<4)+(x>>3); + + for(i=begin_y ; i>3)+begin_x] << shift; + if(bool1) screen[begin_x] ^= *p; + if(shift!=8) screen[begin_x+1] ^= *(p+1); + for(j=begin_x+1 ; j>3)+j] << shift; + screen[j] ^= *p; + if(shift!=8) screen[j+1] ^= *(p+1); + } + } + line = bmp[i*(real_width>>3)+end_x]; + if(bool3) line &= -1<120 || y<-7 || y>63) return; + if(y < 0) begin = -y; + if(y > 56) end = 64-y; + shift = 8-(x&7); + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i120 || y<-7 || y>63) return; + if(y < 0) begin = -y; + if(y > 56) end = 64-y; + shift = 8-(x&7); + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i120 || y<-7 || y>63) return; + if(y < 0) begin = -y; + if(y > 56) end = 64-y; + shift = 8-(x&7); + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i127 || y<-7 || y>63) return; + if(y < 0) begin = -y; + if(y > 56) end = 64-y; + shift = 8-(x&7); + if(x < 0) bool1 = 0; + if(x>120 || shift==8) bool2 = 0; + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i127 || y<-7 || y>63) return; + if(y < 0) begin = -y; + if(y > 56) end = 64-y; + shift = 8-(x&7); + if(x < 0) bool1 = 0; + if(x>120 || shift==8) bool2 = 0; + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i127 || y<-7 || y>63) return; + if(y < 0) begin = -y; + if(y > 56) end = 64-y; + shift = 8-(x&7); + if(x < 0) bool1 = 0; + if(x>120 || shift==8) bool2 = 0; + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i112 || y<-15 || y>63) return; + if(y < 0) begin = -y; + if(y > 48) end = 64-y; + shift = 8-(x&7); + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i112 || y<-15 || y>63) return; + if(y < 0) begin = -y; + if(y > 48) end = 64-y; + shift = 8-(x&7); + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i112 || y<-15 || y>63) return; + if(y < 0) begin = -y; + if(y > 48) end = 64-y; + shift = 8-(x&7); + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i127 || y<-15 || y>63) return; + if(y < 0) begin = -y; + if(y > 48) end = 64-y; + shift = 8-(x&7); + if(x < 0) bool1 = 0; + if(x<-8 || x>119) bool2 = 0; + if(x>111 || shift==8) bool3 = 0; + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i127 || y<-15 || y>63) return; + if(y < 0) begin = -y; + if(y > 48) end = 64-y; + shift = 8-(x&7); + if(x < 0) bool1 = 0; + if(x<-8 || x>119) bool2 = 0; + if(x>111 || shift==8) bool3 = 0; + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; i127 || y<-15 || y>63) return; + if(y < 0) begin = -y; + if(y > 48) end = 64-y; + shift = 8-(x&7); + if(x < 0) bool1 = 0; + if(x<-8 || x>119) bool2 = 0; + if(x>111 || shift==8) bool3 = 0; + screen = ML_vram_adress()+(y+begin<<4)+(x>>3); + for(i=begin ; itimer);return; + +/* --------------------------------------------------- */ +/* --------------------------------------------------- */ +/* ----------------- CLASS BLUETOOTH ----------------- */ +/* --------------------------------------------------- */ +/* --------------------------------------------------- */ + +Bluetooth::Bluetooth(){ + this->sentPacketsTotalSize = 0; + this->receivedPacketsTotalSize = 0; + this->unread = 0; + this->allowReception = 1; + this->ID = 0; + this->secondTry = 0; + memcpy(this->sender, "HC-06\0", 6); +} + +int Bluetooth::listen(int maxSize, int timer, void(*func)(void), int time){ + unsigned char conf[6] = {0, 5, 0, 0, 0, 0}; + max = maxSize; + this->ptr = (char*)malloc(maxSize); + this->ptr1ko = (char*)malloc(1000); + if(this->ptr == NULL || this->ptr1ko == NULL) return NOT_ENOUGH_RAM; + this->timer = Timer_Install(timer, func, time); + if(Serial_Open(conf) == 3) return SERIAL_ALREADY_OPEN; + + Timer_Start(this->timer); + + return 0; +} + +int Bluetooth::setSender(char *senderName){ + if(strlen(senderName)+1 <= 10){ + if(strlen(senderName) >= 0){ + memcpy(this->sender, senderName, strlen(senderName)+1); + }else{ + return SENDER_EMPTY; + } + }else{ + return SENDER_TOO_BIG; + } + return 0; +} + +int Bluetooth::sendMessage(Message *message){ + int split, RTCTime, temp; + char *ptr2; + unsigned char dateEx[] = "YYYY-MM-DD-HH-MM-SS"; + split = (int)((message->getLength())/208) + (message->getLength()%208) == 0 ? 0:1; + if((ptr2 = (char*)malloc(256)) == NULL) return NOT_ENOUGH_RAM; + this->ID++; + PrintMini(1,1,(const unsigned char*)itoa(split),MINI_OR); + for(int i=0; igetType() == NULL){ + memcpy(ptr2+19,"RQT",3); + }else{ + memcpy(ptr2+19, message->getType(), 3); + } + if(message->isHeader){ + memcpy(ptr+22, message->msg+22, sizeof(int)); + memcpy(ptr+26, message->msg+26, 10); + }else{ + memcpy(ptr+22, (int*)this->ID, sizeof(int)); + memcpy(ptr+26, this->sender, 10); + } + memcpy(ptr2+36, (int*)message->getLength(), sizeof(int)); + memcpy(ptr2+40, (int*)(((i+1)*208 > message->getLength()) ? (message->getLength() - i*208) : 208), sizeof(int)); + memcpy(ptr2+44, (unsigned short*)(i+1), sizeof(unsigned short)); + memcpy(ptr2+46, (unsigned short*)split, sizeof(unsigned short)); + memcpy(ptr2+48, (int*)(message->getMessage()+i*208, ((i+1)*208 > message->getLength()) ? (message->getLength() - i*208) : 208), sizeof(int)); + + Serial_WriteBytes((unsigned char*)ptr2,50); + + RTCTime = RTC_GetTicks(); + while(Serial_GetTxBufferFreeCapacity() != 0){ + if((RTC_GetTicks() - RTCTime)/RTC > 300){ + free(ptr2); + this->ID--; + return UNKNOWN_ERROR; + } + } + } + + free(ptr2); + return 0; + +} + +Message& Bluetooth::getLastMessage(){ + return msg; +} + +void Bluetooth::receptMessage(){ + int size, errorID; + int RTCTime; + int messageLength = 48; + int typeCase; + char buffer[50]; + int lengthPackets[2]; + unsigned short partsNumber[2] = {(unsigned short)0,(unsigned short)1}; + const char type[7][4] = {"RQT","ASW","ACK","MIS","FUL","ERR","END"}; + const char err[1][4] = {"ERR"}; + char ptr2[3]; + unsigned int messageID; + Message sendBack; + if((this->secondTry = Serial_GetRxBufferSize()) == 1000 || this->secondTry==Serial_GetRxBufferSize()){ + // if allowReception. else, send back a FUL packet to the device + if(this->allowReception){ + Serial_ReadBytes((unsigned char*)this->ptr1ko, 1000,(short*)&size); + memcpy(ptr2, this->ptr1ko+19, 3); + typeCase = tabcmp((const char**)type, 7, ptr2); + switch(typeCase){ + case RQT: + case END: + case ASW: + memcpy(&this->ID, (unsigned int*)this->ptr1ko+22, sizeof(unsigned int)); + if(size < 48){ + sendBack.init("HED", this->ID, this->sender, ""); + sendMessage(&sendBack); + RETURN + } + memcpy(this->sender, this->ptr1ko+26, 10); + for(unsigned short i=0; iptr1ko+22, sizeof(unsigned int)); + if(messageID != this->ID){ + sendBack.init("ERR", messageID, this->sender, "INCORRECT ID"); + sendMessage(&sendBack); + RETURN } + memcpy(lengthPackets, this->ptr1ko+36, sizeof(lengthPackets)); + sprintf(buffer,"%d", i+1); + if(partsNumber[0] != i+1){ + if(partsNumber[0] > i+1){ + sendBack.init("MIS", messageID, this->sender, buffer); + sendMessage(&sendBack); + }else{ + sendBack.init("ACK", messageID, this->sender, buffer); + sendMessage(&sendBack); + } + }else if(lengthPackets[1] != size-48){ + sendBack.init("ERR", messageID, this->sender, "INCOMPLETE PACKET SIZE"); + sendMessage(&sendBack); + RETURN + }else{ + messageLength+=size-48; + memcpy(this->ptr+48+i*952, this->ptr1ko+48, 952); + sendBack.init("ACK", messageID, this->sender, buffer); + sendMessage(&sendBack); + if(messageLength-48 == lengthPackets[0] && partsNumber[0] == partsNumber[1]){ + if(!(errorID = msg.setTotalMessage(this->ptr))){ + this->unread = 1; + this->allowReception = 0; + this->ID++; + RETURN + }else{ + sendBack.init("ERR", messageID, this->sender, (char*)&err[errorID]); + sendMessage(&sendBack); + RETURN + } + } + + } + RTCTime = RTC_GetTicks(); + while(Serial_GetRxBufferSize() != (lengthPackets[0]-messageLength-48>1000 ? 1000 : lengthPackets[0]-messageLength-48)){ + if((RTC_GetTicks() - RTCTime)/RTC > 300){ + RETURN + } + } + memcpy(partsNumber, this->ptr1ko+44, sizeof(partsNumber)); + } + break; + } + }else{ + sendBack.init("FUL", this->ID, this->sender, ""); + sendMessage(&sendBack); + RETURN + } + }else if(Serial_GetRxBufferSize()>0){ + this->secondTry = Serial_GetRxBufferSize(); + RETURN + } +} + + +/* --------------------------------------------------- */ +/* --------------------------------------------------- */ +/* ------------------ CLASS MESSAGE ------------------ */ +/* --------------------------------------------------- */ +/* --------------------------------------------------- */ + +Message::Message(){ + this->isHeader = 0; + this->isType = 0; + this->msg = (char*)NULL; +} + +int Message::init(const char* type, int ID, char* sender,const char* message){ + if(setType(type)) return INVALID_TYPE; + if(setMessage(message)) return NOT_ENOUGH_RAM; + return 0; +} + +int Message::setType(const char *typeH){ + memcpy(this->type, typeH, 3); + this->isType = 1; + return 0; +} + +int Message::setMessage(const char *message){ + int length; + length = strlen(message) + 49; + this->msg = (char*)realloc(this->msg, length); + if(this->msg == NULL) return NOT_ENOUGH_RAM; + memcpy(this->msg+48, message, length-48); + return 0; +} + +int Message::setTotalMessage(char *message){ + this->msg = message; + this->isHeader = 1; + return 0; +} + +char* Message::getTime(){ + if(this->isHeader){ + return this->msg; + }else{ + return (char*)NULL; + } +} + +char* Message::getType(){ + if(this->isHeader || this->isType){ + return this->msg+19; + }else{ + return (char*)NULL; + } +} + +char* Message::getSender(){ + if(this->isHeader){ + return this->msg+26; + }else{ + return (char*)NULL; + } +} + +int Message::getLength(){ + if(this->msg == NULL) return -1; + return strlen(this->msg+48)+1; +} + +unsigned char* Message::getMessage(){ + return (unsigned char*)this->msg+48; +} + +int tabcmp(const char *tab[4], int size, char* string){ + for(int i=0; i= 0) { + do{ + *--p = '0' + (i % 10); + i /= 10; + }while (i != 0); + return p; + }else { + do { + *--p = '0' - (i % 10); + i /= 10; + }while (i != 0); + *--p = '-'; + } + return p; +} diff --git a/SRC/syscall.s b/SRC/syscall.s new file mode 100644 index 0000000..a724b7c --- /dev/null +++ b/SRC/syscall.s @@ -0,0 +1,106 @@ +.global _Serial_ReadByte +_Serial_Readbyte: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x40C + +.global _Serial_ReadBytes +_Serial_ReadBytes: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x40D + +.global _Serial_WriteByte +_Serial_WriteByte: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x40E + +.global _Serial_WriteBytes +_Serial_WriteBytes: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x40F + +.global _Serial_WriteByteFIFO +_Serial_WriteByteFIFO: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x410 + +.global _Serial_GetRxBufferSize +_Serial_GetRxBufferSize: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x411 + +.global _Serial_GetTxBufferFreeCapacity +_Serial_GetTxBufferFreeCapacity: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x412 + +.global _Serial_Open +_Serial_Open: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x418 + +.global _Serial_IsOpen +_Serial_IsOpen: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x425 + +.global _Timer_Install +_Timer_Install: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x118 + +.global _Timer_Start +_Timer_Start: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x11A + +.global _Timer_Stop +_Timer_Stop: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x11B + +.global _RTC_GetTicks +_RTC_GetTicks: + mov.l sc_addr, r2 + mov.l 1f, r0 + jmp @r2 + nop +1: .long 0x03B + +sc_addr: .long 0x80010070 + diff --git a/SRC/syscall.src b/SRC/syscall.src new file mode 100644 index 0000000..436ab43 --- /dev/null +++ b/SRC/syscall.src @@ -0,0 +1,29 @@ + .SECTION P,CODE,ALIGN=4 + + .MACRO SYSCALL FUNO, SYSCALLNAME, TAIL=nop + .export \SYSCALLNAME' +\SYSCALLNAME' + mov.l #h'\FUNO, r0 + mov.l #H'80010070, r2 + jmp @r2 + \TAIL' + .ENDM + + SYSCALL 040C, _Serial_ReadByte + SYSCALL 040D, _Serial_ReadBytes + SYSCALL 040E, _Serial_WriteByte + SYSCALL 040F, _Serial_WriteBytes + SYSCALL 0410, _Serial_WriteByteFIFO + SYSCALL 0411, _Serial_GetRxBufferSize + SYSCALL 0412, _Serial_GetTxBufferFreeCapacity + SYSCALL 0413, _Serial_ClearReceiveBuffer + SYSCALL 0414, _Serial_ClearTransmitBuffer + SYSCALL 0418, _Serial_Open + SYSCALL 0419, _Serial_Close + SYSCALL 0422, _Serial_Peek + SYSCALL 0425, _Serial_IsOpen + SYSCALL 0118, _Timer_Install + SYSCALL 011A, _Timer_Start + SYSCALL 011B, _Timer_Stop + SYSCALL 003B, _RTC_GetTicks(); + .end diff --git a/addin.bin b/addin.bin new file mode 100755 index 0000000000000000000000000000000000000000..68a054db7ac3a6991ed7f541e7cfed97696c1356 GIT binary patch literal 18772 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 n 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 literal 0 HcmV?d00001 diff --git a/addin.elf b/addin.elf new file mode 100755 index 0000000000000000000000000000000000000000..3796fbb28b15b92515f68d68117f5c7d854f0d10 GIT binary patch literal 58764 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 D0JZXDpIpDuEQ0&WtB;tI>o>tWbmXI3a6h&m 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 GqW=Yn@cqsJ literal 0 HcmV?d00001 diff --git a/addin.ld b/addin.ld new file mode 100644 index 0000000..d176313 --- /dev/null +++ b/addin.ld @@ -0,0 +1,31 @@ +OUTPUT_ARCH(sh3) +ENTRY(initialize) +MEMORY +{ + rom : o = 0x00300200, l = 512k + ram : o = 0x08100000, l = 64k /* pretty safe guess */ +} +SECTIONS +{ + .text : { + *(.pretext) /* init stuff */ + *(.text) + } > rom + .rodata : { + *(.rodata) + *(.rodata.str1.4) + _romdata = . ; /* symbol for initialization data */ + } > rom + .bss : { + _bbss = . ; + _bssdatasize = . ; + LONG(0); /* bssdatasize */ + *(.bss) *(COMMON); + _ebss = . ; + } > ram + .data BLOCK(4) : AT(_romdata) { + _bdata = . ; + *(.data); + _edata = . ; + } > ram +} diff --git a/bluetooth.o b/bluetooth.o new file mode 100644 index 0000000000000000000000000000000000000000..0fd50ffaea0c1b33f014f86dca34dd2eee5d4dfe GIT binary patch literal 10432 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 + #include + #include "MonochromeLib.h" + #include "syscall.h" + #include "libfx.h" + +} + +#include "bluetooth.h" diff --git a/include/MonochromeLib.h b/include/MonochromeLib.h new file mode 100644 index 0000000..00f5c7b --- /dev/null +++ b/include/MonochromeLib.h @@ -0,0 +1,151 @@ +/*************************************************************/ +/** MonochromeLib - monochrome graphic library for fx-9860G **/ +/** MonochromeLib is free software **/ +/** **/ +/** @author Pierre "PierrotLL" Le Gall **/ +/** @contact legallpierre89@gmail.com **/ +/** **/ +/** @file MonochromeLib.h **/ +/** Include header for MonochromeLib **/ +/** **/ +/** @date 11-22-2011 **/ +/*************************************************************/ + +#ifndef MONOCHROMELIB +#define MONOCHROMELIB + +/****************************************************/ +/** uncomment #define of functions you want to use **/ +/****************************************************/ + +// #define ML_ALL //Auto define all functions + +#define ML_CLEAR_VRAM +#define ML_CLEAR_SCREEN +#define ML_DISPLAY_VRAM + +// #define ML_SET_CONTRAST +// #define ML_GET_CONTRAST + +// #define ML_PIXEL +// #define ML_POINT +// #define ML_PIXEL_TEST + +// #define ML_LINE +// #define ML_HORIZONTAL_LINE +// #define ML_VERTICAL_LINE + +// #define ML_RECTANGLE + +// #define ML_POLYGON +// #define ML_FILLED_POLYGON + +// #define ML_CIRCLE +// #define ML_FILLED_CIRCLE + +// #define ML_ELLIPSE +// #define ML_ELLIPSE_IN_RECT +// #define ML_FILLED_ELLIPSE +// #define ML_FILLED_ELLIPSE_IN_RECT + +// #define ML_HORIZONTAL_SCROLL +// #define ML_VERTICAL_SCROLL + +// #define ML_BMP_OR +// #define ML_BMP_AND +// #define ML_BMP_XOR +// #define ML_BMP_OR_CL +// #define ML_BMP_AND_CL +// #define ML_BMP_XOR_CL + +// #define ML_BMP_8_OR +// #define ML_BMP_8_AND +// #define ML_BMP_8_XOR +// #define ML_BMP_8_OR_CL +// #define ML_BMP_8_AND_CL +// #define ML_BMP_8_XOR_CL + +// #define ML_BMP_16_OR +// #define ML_BMP_16_AND +// #define ML_BMP_16_XOR +// #define ML_BMP_16_OR_CL +// #define ML_BMP_16_AND_CL +// #define ML_BMP_16_XOR_CL + + +/**************************/ +/** Functions prototypes **/ +/**************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +#define ML_SCREEN_WIDTH 128 +#define ML_SCREEN_HEIGHT 64 + +#define ML_CONTRAST_MIN 130 +#define ML_CONTRAST_NORMAL 168 +#define ML_CONTRAST_MAX 190 +typedef enum {ML_TRANSPARENT=-1, ML_WHITE, ML_BLACK, ML_XOR, ML_CHECKER} ML_Color; + +char* ML_vram_adress(); + +void ML_clear_vram(); +void ML_clear_screen(); +void ML_display_vram(); + +void ML_set_contrast(unsigned char contrast); +unsigned char ML_get_contrast(); + +void ML_pixel(int x, int y, ML_Color color); +void ML_point(int x, int y, int width, ML_Color color); +ML_Color ML_pixel_test(int x, int y); + +void ML_line(int x1, int y1, int x2, int y2, ML_Color color); +void ML_horizontal_line(int y, int x1, int x2, ML_Color color); +void ML_vertical_line(int x, int y1, int y2, ML_Color color); + +void ML_rectangle(int x1, int y1, int x2, int y2, int border_width, ML_Color border_color, ML_Color fill_color); + +void ML_polygon(const int *x, const int *y, int nb_vertices, ML_Color color); +void ML_filled_polygon(const int *x, const int *y, int nb_vertices, ML_Color color); + +void ML_circle(int x, int y, int radius, ML_Color color); +void ML_filled_circle(int x, int y, int radius, ML_Color color); + +void ML_ellipse(int x, int y, int radius1, int radius2, ML_Color color); +void ML_ellipse_in_rect(int x1, int y1, int x2, int y2, ML_Color color); +void ML_filled_ellipse(int x, int y, int radius1, int radius2, ML_Color color); +void ML_filled_ellipse_in_rect(int x, int y, int radius1, int radius2, ML_Color color); + +void ML_horizontal_scroll(int scroll); +void ML_vertical_scroll(int scroll); + +void ML_bmp_or(const unsigned char *bmp, int x, int y, int width, int height); +void ML_bmp_and(const unsigned char *bmp, int x, int y, int width, int height); +void ML_bmp_xor(const unsigned char *bmp, int x, int y, int width, int height); +void ML_bmp_or_cl(const unsigned char *bmp, int x, int y, int width, int height); +void ML_bmp_and_cl(const unsigned char *bmp, int x, int y, int width, int height); +void ML_bmp_xor_cl(const unsigned char *bmp, int x, int y, int width, int height); + +void ML_bmp_8_or(const unsigned char *bmp, int x, int y); +void ML_bmp_8_and(const unsigned char *bmp, int x, int y); +void ML_bmp_8_xor(const unsigned char *bmp, int x, int y); +void ML_bmp_8_or_cl(const unsigned char *bmp, int x, int y); +void ML_bmp_8_and_cl(const unsigned char *bmp, int x, int y); +void ML_bmp_8_xor_cl(const unsigned char *bmp, int x, int y); + +void ML_bmp_16_or(const unsigned short *bmp, int x, int y); +void ML_bmp_16_and(const unsigned short *bmp, int x, int y); +void ML_bmp_16_xor(const unsigned short *bmp, int x, int y); +void ML_bmp_16_or_cl(const unsigned short *bmp, int x, int y); +void ML_bmp_16_and_cl(const unsigned short *bmp, int x, int y); +void ML_bmp_16_xor_cl(const unsigned short *bmp, int x, int y); + +#ifdef __cplusplus +} +#endif + + +#endif //MONOCHROMELIB diff --git a/include/_h_c_lib.h b/include/_h_c_lib.h new file mode 100644 index 0000000..78fe26a --- /dev/null +++ b/include/_h_c_lib.h @@ -0,0 +1,29 @@ +/*------------------------------------------------------*/ +/* SH SERIES C/C++ Compiler Ver. 6.0 */ +/* Copyright (c) 1992,2000 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/***********************************************************************/ +/* SPEC; */ +/* NAME = _h_c_lib.h : */ +/* */ +/* FUNC = Include file for SH SERIES C/C++ Compiler environment */ +/* */ +/* CLAS = UNIT; */ +/* */ +/* END; */ +/***********************************************************************/ + +#ifndef _H_C_LIB +#define _H_C_LIB + +#ifdef __cplusplus +extern "C"{ +#endif +extern void _CALL_INIT(void); /* for global class object initial processing */ +extern void _CALL_END(void); /* for global class object post-processing */ +#ifdef __cplusplus +} +#endif /* #ifdef __cplusplus */ + +#endif /* #ifndef _H_C_LIB */ diff --git a/include/assert.h b/include/assert.h new file mode 100644 index 0000000..4c88665 --- /dev/null +++ b/include/assert.h @@ -0,0 +1,39 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/***********************************************************************/ +/* SPEC; */ +/* NAME = assert.h : debug macro define ; */ +/* */ +/* FUNC = this module do the following functions; */ +/* (1) if NDEBUG defined assert(x) = (void)0; */ +/* CLAS = UNIT; */ +/* */ +/* END; */ +/***********************************************************************/ +#ifndef _ASSERT +#define _ASSERT + +#include +#ifdef NDEBUG +#ifdef assert +#undef assert +#endif +#define assert(x) ((void)0) +#else +#ifdef assert +#undef assert +#endif +#define assert(x) ( x ? (void) 0 : (fprintf(stderr,\ + "ASSERTION FAILED: "#x" FILE %s,LINE %d \n", \ + __FILE__,__LINE__),abort(),(void)0)) +#endif +#ifdef __cplusplus +extern "C" { +void abort(void); +} +#endif + +#endif diff --git a/include/bluetooth.h b/include/bluetooth.h new file mode 100644 index 0000000..2ab29f7 --- /dev/null +++ b/include/bluetooth.h @@ -0,0 +1,185 @@ +/* + * AUTHOR : Xavier Bruni + * + * ---------------------------------------------------------------------------- + * "THE BEER-WARE LICENSE" (Revision 42): + * As long as you retain this notice you can do whatever you want with this + * stuff. If we meet some day, and you think this stuff is worth it, you can + * buy me a beer in return. + * ---------------------------------------------------------------------------- + */ + +extern "C"{ + #include "MonochromeLib.h" + #include "syscall.h" + #include + #include + #include + #include "libfx.h" +} + + +/* +This bluetooth library is working with the 3-pin port of your calculator. +This library is compatible with SuperH-3 and SuperH-4 processor : +This include : Graph 35+, 75, 85 & 95. +This library has been written for the following bluetooth module : HC-05, HC-06 +RAM can contain approximately 50KO of data. Each message can't do more than 32KO +You can't send more than 1ko -including header- from your smartphone to the calculator. In fact, the reception buffer has a size of 1ko max. +Without the header : 1000 - 48 = 952o +for sending : 256-48 = 208 +If the 32 ko buffer is full, it will return a FUL packet. +*/ + +/* +How does Bluetooth header have to look like in a Message: + +- (1) time : 19 bytes (YYYY-MM-DD-HH-MM-SS) +- (2) type : 3 bytes (3*char) +- (3) ID : 4 bytes (unsigned int) +- (4) sender : 10 bytes (10*char) +- (5) total length of the message (in bytes), headers not included : 4 bytes (unsigned int) +- (6) total length of this packet (in bytes), headers not included : 4 bytes (unsigned int) +- (7) part of the message / number of part : 2 bytes (short unsigned int) / 2 bytes (short unsigned int) + +Total : 48 bytes. +Length must contain the null byte ! Null byte must be at the end of the message. + +(2) type can be : +- RQT : request +- ASW : answer to a request +- ACK : acknowledgment. packet received. +- MIS : missing packet +- FUL : full reception buffer or RAM buffer or precedent message unread. It sends the ID of last message read. +- ERR : error. see error code in message content. +- HED : incorrect header +- END : terminate the connection. + +Those are classic types. You can also set your own type (3 characters). + +Practical informations and example : + +This library has been build to save as much as memory as it can. To do that, Bluetooth class is sharing the same message ptr as the Message class. +The fact is that it will delete your precedent message on new message reception. If you want to avoid that, you can copy the message to another location before accepting new message. + +- To read message : ptr = Obj.getMessage(); + +- To save message : length = Obj.getLength()+48\ + ptr = malloc(length);\ + memcpy(ptr, Obj.msg, length);\ + Message Obj2;\ + Obj2.setTotalMessage(ptr); + +*/ + +class Message{ + +public: + + Message(); + + // init message attribute. opt=1 to send the message directly (if possible) + int init(const char* type, int ID, char* sender,const char* message); + + // set the type of the message. You have not to worry about other things to set in the header. It is automatic. + int setType(const char *typeH); + + // set message content. + int setMessage(const char *message); + + int setTotalMessage(char *message); + + // get message content. (ptr + 48) + unsigned char* getMessage(); + + // header informations : + char* getTime(); + char* getType(); + char* getSender(); + int getLength(); + + // this is message address (with header) + char *msg; + int isHeader; + +private: + + char type[3]; + int isType; + +}; + + +class Bluetooth{ + +public: + + Bluetooth(); + + // listen for new message. This function is non blocking. maxSize is the maximum length of message to receive. + // it will return NOT_ENOUG_RAM if it can not allocate that much. call this function early in your code, you'll have more chance to have enough ram. + // There is no maximum restriction, but RAM is about 50KO. 32KO should be the maximum. + int listen(int maxSize, int timer, void(*)(void), int time); + + // Send a message. There is no maximum size. Indead, you will be limited by the RAM size (approx. 50ko) + int sendMessage(Message *message); + + // get last message. + Message& getLastMessage(); + + // set the sender name (for header) + int setSender(char *senderName); + + // set it to 1 if you want to allow message reception. it will delete previous message on new reception !! save it if you would like to keep it !! + unsigned int allowReception; + unsigned int unread; + + // point on the 32ko of data. + char* ptr; + // point to the 1ko to receive + char* ptr1ko; + + // call by a timber every 25ms. It CAN NOT recept more than 1 ko in a row. + // use (3) and (4) to send bigger message from your device. + void receptMessage(); + int timer; + +private: + // total size of all send packet + int sentPacketsTotalSize; + // total szie of all received packets + int receivedPacketsTotalSize; + int max; + char sender[10]; + unsigned int ID; + unsigned int secondTry; + + // Keep the last message in memory + Message msg; + +}; + +int tabcmp(const char *tab[], int size, char *string); +char *itoa(int integer); + +#define RTC 15.625 + +#define RQT 0 +#define ASW 1 +#define ACK 2 +#define MIS 3 +#define FUL 4 +#define ERR 5 +#define END 6 + +// Error code : + +#define TIMER_ERROR_INSTALL 1 +#define SENDER_TOO_BIG 2 +#define SENDER_EMPTY 3 +#define SERIAL_ALREADY_OPEN 4 +#define NOT_ENOUGH_RAM 5 +#define MISSING_ACK 6 +#define UNKNOWN_ERROR 7 +#define INVALID_TYPE 8 +#define END_OF_COMMUNICATION 9 diff --git a/include/builtin.h b/include/builtin.h new file mode 100644 index 0000000..abf96df --- /dev/null +++ b/include/builtin.h @@ -0,0 +1,84 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 6.0 */ +/* Copyright (c) 1992, 2000 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = builtin : */ +/* */ +/* FUNC = this header file do the following functions; */ +/* (1)builtin function prototype define; */ +/* */ +/* CLAS = UNIT ; */ +/* */ +/* END ; */ +/*****************************************************************/ + +#ifndef _BUILTIN +#define _BUILTIN + +#ifdef __cplusplus +extern "C" { +/* follow math.h & mathf.h */ +extern float _builtin_fabsf(float); +extern double _builtin_fabs(double); +extern float _builtin_sqrtf(float); +extern double _builtin_sqrt(double); + +/* follow private.h */ +extern void _builtin_fsca(long ,float *,float *); +extern float _builtin_fsrra(float); + +/* follow smachine.h */ +extern void _builtin_set_imask(int); +extern int _builtin_get_imask(void); +extern void _builtin_set_cr(int); +extern int _builtin_get_cr(void); +extern void _builtin_set_vbr(void *); +extern void *_builtin_get_vbr(void); +extern void _builtin_sleep(void); + +/* follow string.h */ +extern char *_builtin_strcpy(char *, const char *); +extern int _builtin_strcmp(const char *, const char *); + +/* follow umachine.h */ +extern void _builtin_set_gbr(void *); +extern void *_builtin_get_gbr(void); +extern unsigned char _builtin_gbr_read_byte(int); +extern unsigned short _builtin_gbr_read_word(int); +extern unsigned long _builtin_gbr_read_long(int); +extern void _builtin_gbr_write_byte(int, unsigned char); +extern void _builtin_gbr_write_word(int, unsigned short); +extern void _builtin_gbr_write_long(int, unsigned long); +extern void _builtin_gbr_and_byte(int, unsigned char); +extern void _builtin_gbr_or_byte(int, unsigned char); +extern void _builtin_gbr_xor_byte(int, unsigned char); +extern int _builtin_gbr_tst_byte(int, unsigned char); +extern int _builtin_tas(char *); +extern int _builtin_trapa(int); +extern int _builtin_macw(short *, short *, unsigned int); +extern int _builtin_macwl(short *, short *, unsigned int, unsigned int); +extern int _builtin_macl(int *, int *, unsigned int); +extern int _builtin_macll(int *, int *, unsigned int, unsigned int); +extern int _builtin_trapa_svc(...); +extern void _builtin_prefetch(void *); +extern void _builtin_set_fpscr(int); +extern int _builtin_get_fpscr(void); +extern float _builtin_fipr(float a1[], float b1[]); +extern void _builtin_ftrv(float a1[], float b1[]); +extern void _builtin_ftrvadd(float a1[], float b1[], float c1[]); +extern void _builtin_ftrvsub(float a1[], float b1[], float c1[]); +extern void _builtin_mtrx4mul(float [][4], float [][4]); +extern void _builtin_mtrx4muladd(float [][4], float [][4], float [][4]); +extern void _builtin_mtrx4mulsub(float [][4], float [][4], float [][4]); +extern void _builtin_ld_ext(float [][4]); +extern void _builtin_st_ext(float [][4]); +extern void _builtin_add4(float a1[], float b1[], float c1[]); +extern void _builtin_sub4(float a1[], float b1[], float c1[]); +extern void _builtin_trace(int); +} +#endif /* #ifdef __cplusplus */ + +#endif /* #ifndef _BUILTIN */ diff --git a/include/complex b/include/complex new file mode 100644 index 0000000..76b0085 --- /dev/null +++ b/include/complex @@ -0,0 +1,189 @@ +//Embedded C++ Library +//Copyright (c) Hitachi,Ltd. 1997 +//Licensed material of Hitachi,Ltd + +//==================================================================== +// File: complex +// Purpose: Numerics library / Complex numbers +// Header +// Create: 1997.09.20 Rev. 1.0 +//==================================================================== + +#ifndef _COMPLEX_ +#define _COMPLEX_ + +#include +#include + +class float_complex; // based on float +class double_complex; // based on double + +// complex specialization +class float_complex { +public: + typedef float value_type; + + float_complex(float re = 0.0f, float im = 0.0f){ + _re = re; _im = im; return; } + float_complex(const double_complex&); + float real() const{ return (_re);} + float imag() const{ return (_im);} + + float_complex& operator= (float rhs){ + _re = rhs; _im = 0.0; return *this; } + float_complex& operator+=(float rhs){ _re += rhs; return *this; } + float_complex& operator-=(float rhs){ _re -= rhs; return *this; } + float_complex& operator*=(float rhs){ + _re *= rhs; _im *= rhs; return *this; } + float_complex& operator/=(float rhs){ + _re /= rhs; _im /= rhs; return *this; } + + float_complex& operator=(const float_complex&rhs){ + _re = rhs.real(); _im = rhs.imag(); return *this; } + float_complex& operator+=(const float_complex&rhs){ + _re += rhs.real(); _im += rhs.imag(); return *this; } + float_complex& operator-=(const float_complex&rhs){ + _re -= rhs.real(); _im -= rhs.imag(); return *this; } + float_complex& operator*=(const float_complex&); + float_complex& operator/=(const float_complex&); +private: + float _re, _im; +}; + +class double_complex { +public: + typedef double value_type; + + double_complex(double re = 0.0, double im = 0.0){ + _re = re; _im = im; return; } + double_complex(const float_complex&rhs){ + _re = (double)rhs.real(); _im = (double)rhs.imag(); return; } + double real() const{ return (_re);} + double imag() const{ return (_im);} + + double_complex& operator= (double rhs){ + _re = rhs; _im = 0.0; return *this; } + double_complex& operator+=(double rhs){ _re += rhs; return *this; } + double_complex& operator-=(double rhs){ _re -= rhs; return *this; } + double_complex& operator*=(double rhs){ + _re *= rhs; _im *= rhs; return *this; } + double_complex& operator/=(double rhs){ + _re /= rhs; _im /= rhs; return *this; } + + double_complex& operator=(const double_complex&rhs){ + _re = rhs.real(); _im = rhs.imag(); return *this; } + double_complex& operator+=(const double_complex&rhs){ + _re += rhs.real(); _im += rhs.imag(); return *this; } + double_complex& operator-=(const double_complex&rhs){ + _re -= rhs.real(); _im -= rhs.imag(); return *this; } + double_complex& operator*=(const double_complex&); + double_complex& operator/=(const double_complex&); +private: + double _re, _im; +}; + + +// complex non-member functions +float_complex operator+(const float_complex&); +float_complex operator-(const float_complex&); +float_complex operator+(const float_complex&, const float_complex&); +float_complex operator+(const float_complex&, const float&); +float_complex operator+(const float&, const float_complex&); +float_complex operator-(const float_complex&, const float_complex&); +float_complex operator-(const float_complex&, const float&); +float_complex operator-(const float&, const float_complex&); +float_complex operator*(const float_complex&, const float_complex&); +float_complex operator*(const float_complex&, const float&); +float_complex operator*(const float&, const float_complex&); +float_complex operator/(const float_complex&, const float_complex&); +float_complex operator/(const float_complex&, const float&); +float_complex operator/(const float&, const float_complex&); +bool operator==(const float_complex&, const float_complex&); +bool operator==(const float_complex&, const float&); +bool operator==(const float&, const float_complex&); +bool operator!=(const float_complex&, const float_complex&); +bool operator!=(const float_complex&, const float&); +bool operator!=(const float&, const float_complex&); +istream& operator>>(istream&, float_complex&); +ostream& operator<<(ostream&, const float_complex&); + +double_complex operator+(const double_complex&); +double_complex operator-(const double_complex&); +double_complex operator+(const double_complex&, const double_complex&); +double_complex operator+(const double_complex&, const double&); +double_complex operator+(const double&, const double_complex&); +double_complex operator-(const double_complex&, const double_complex&); +double_complex operator-(const double_complex&, const double&); +double_complex operator-(const double&, const double_complex&); +double_complex operator*(const double_complex&, const double_complex&); +double_complex operator*(const double_complex&, const double&); +double_complex operator*(const double&, const double_complex&); +double_complex operator/(const double_complex&, const double_complex&); +double_complex operator/(const double_complex&, const double&); +double_complex operator/(const double&, const double_complex&); +bool operator==(const double_complex&, const double_complex&); +bool operator==(const double_complex&, const double&); +bool operator==(const double&, const double_complex&); +bool operator!=(const double_complex&, const double_complex&); +bool operator!=(const double_complex&, const double&); +bool operator!=(const double&, const double_complex&); +istream& operator>>(istream&, double_complex&); +ostream& operator<<(ostream&, const double_complex&); + +// complex value operations +float real(const float_complex&); +float imag(const float_complex&); +float abs(const float_complex&); +float arg(const float_complex&); +float norm(const float_complex&); +float_complex conj(const float_complex&); +float_complex polar(const float&, const float&); + +double real(const double_complex&); +double imag(const double_complex&); +double abs(const double_complex&); +double arg(const double_complex&); +double norm(const double_complex&); +double_complex conj(const double_complex&); +double_complex polar(const double&, const double&); + +// complex transcendentals + +#ifdef sqrt +#undef sqrt +extern "C" double sqrt(double); +#endif + +float_complex cos (const float_complex&); +float_complex cosh (const float_complex&); +float_complex exp (const float_complex&); +float_complex log (const float_complex&); +float_complex log10(const float_complex&); + +float_complex pow(const float_complex&, int); +float_complex pow(const float_complex&, const float&); +float_complex pow(const float_complex&, const float_complex&); +float_complex pow(const float&, const float_complex&); +float_complex sin (const float_complex&); +float_complex sinh (const float_complex&); +float_complex sqrt (const float_complex&); +float_complex tan (const float_complex&); +float_complex tanh (const float_complex&); + +double_complex cos (const double_complex&); +double_complex cosh (const double_complex&); +double_complex exp (const double_complex&); +double_complex log (const double_complex&); +double_complex log10(const double_complex&); + +double_complex pow(const double_complex&, int); +double_complex pow(const double_complex&, const double&); +double_complex pow(const double_complex&, const double_complex&); +double_complex pow(const double&, const double_complex&); +double_complex sin (const double_complex&); +double_complex sinh (const double_complex&); +double_complex sqrt (const double_complex&); +double_complex tan (const double_complex&); +double_complex tanh (const double_complex&); + +#endif diff --git a/include/ctype.h b/include/ctype.h new file mode 100644 index 0000000..66bcd87 --- /dev/null +++ b/include/ctype.h @@ -0,0 +1,66 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = ctype : */ +/* FUNC = */ +/* ; */ +/* */ +/* */ +/* */ +/* CLAS = UNIT ; */ +/* END ; */ +/*****************************************************************/ +#ifndef _CTYPE +#define _CTYPE + +#ifdef __cplusplus +extern "C" { +#endif + +extern unsigned char _ctype[]; + +extern int isalnum(int); +extern int isalpha(int); +extern int iscntrl(int); +extern int isdigit(int); +extern int isgraph(int); +extern int islower(int); +extern int isprint(int); +extern int ispunct(int); +extern int isspace(int); +extern int isupper(int); +extern int isxdigit(int); +extern int tolower(int); +extern int toupper(int); +#ifdef __cplusplus +} +#endif + +#define _UPPER 0x01 +#define _LOWER 0x02 +#define _DIGIT 0x04 +#define _SPACE 0x08 +#define _PUNCT 0x10 +#define _CNTRL 0x20 +#define _WHITE 0x40 +#define _HEX 0x80 + +#define isalnum(c) (_ctype[(c) & 0xff] & (_UPPER | _LOWER | _DIGIT)) +#define isalpha(c) (_ctype[(c) & 0xff] & (_UPPER | _LOWER)) +#define iscntrl(c) (_ctype[(c) & 0xff] & _CNTRL) +#define isdigit(c) (_ctype[(c) & 0xff] & _DIGIT) +#define isgraph(c) (_ctype[(c) & 0xff] & (_UPPER | _LOWER | _DIGIT | _PUNCT)) +#define islower(c) (_ctype[(c) & 0xff] & _LOWER) +#define isprint(c) (_ctype[(c) & 0xff] & (_UPPER|_LOWER|_DIGIT|_PUNCT|_SPACE)) +#define ispunct(c) (_ctype[(c) & 0xff] & _PUNCT) +#define isspace(c) (_ctype[(c) & 0xff] & _WHITE) +#define isupper(c) (_ctype[(c) & 0xff] & _UPPER) +#define isxdigit(c) (_ctype[(c) & 0xff] & _HEX) +#define tolower(c) (isupper(c) ? ((c)-'A'+'a') : (c)) +#define toupper(c) (islower(c) ? ((c)-'a'+'A') : (c)) + +#endif diff --git a/include/ensigdsp.h b/include/ensigdsp.h new file mode 100644 index 0000000..a82d9e0 --- /dev/null +++ b/include/ensigdsp.h @@ -0,0 +1,257 @@ +/* +*SHDSP Library +*Copyright (c) Hitachi,Ltd. 1998 +*Licensed material of Hitachi,Ltd +*/ +/*********************************************************** +* File: ensigdsp.h +* Purpose: Common +* Create: 1998.03.20 Rev. 1.0 +***********************************************************/ + +/* +** Copyright Ensigma Ltd. 1995 +** +** Unauthorised copying or distribution of this software is prohibited. +** +** Version 1.0. +** +*/ + +/* +** ENSIGMA DSP Library +*/ + +/* Constants */ +#ifndef _ENSIGDSP +#define _ENSIGDSP + +#define BIQUAD_SIZE 6 /* no. coefficients in an IIR biquad */ + +#define EDSP_OK 0 +#define EDSP_BAD_ARG 1 +#define EDSP_NO_HEAP 2 + +#define EFFTALLSCALE (-1L) +#define EFFTMIDSCALE 0x55555555L +#define EFFTNOSCALE 0x00000000L + +#ifdef __cplusplus /*A-10-014-01*/ +extern"C"{ /*A-10-014-01*/ +#endif /*A-10-014-01*/ + +/* +** Fourier transforms +*/ +int FftComplex(short op_x[], + short op_y[], + const short ip_x[], + const short ip_y[], + long size, + long scale); +int FftInComplex(short data_x[], + short data_y[], + long size, + long scale); +int FftReal(short op_x[], + short op_y[], + const short ip[], + long size, + long scale); + /* int ip_is_x);*/ +int FftInReal(short data_x[], + short data_y[], + long size, + long scale, + int not_sure_about_ip_format); +int IfftComplex(short op_x[], + short op_y[], + const short ip_x[], + const short ip_y[], + long size, + long scale); +int IfftInComplex(short data_x[], + short data_y[], + long size, + long scale); +int IfftReal(short op_x[], + short op_y[], + const short ip_x[], + const short ip_y[], + long size, + long scale, + int op_is_x_scratch_is_y); +int IfftInReal(short data_x[], + short data_y[], + long size, + long scale, + int not_sure_about_op_format); +int InitFft(long max_size); +void FreeFft(void); /*A-10-015-01*/ +int LogMagnitude(short output[], + const short ip_x[], + const short ip_y[], + long no_elements, + float fscale); + +/* +** These three variables are for the internal use of the library FFT +** functions only. They should not be accessed by user programs. +*/ +extern long max_fft_size; +extern short *twtble; + +/* +** Window functions +*/ +int GenBlackman(short data[], long N); +int GenHamming(short data[], long N); +int GenHanning(short data[], long N); +int GenTriangle(short data[], long N); + +/* +** Filters. The coefficients must be supplied in X and the workspace in Y. +** If it is straightforward we can support the opposite, ie Xworkspace and +** Ycoeff. +*/ +int FreeFir(short **Yworkspace, long order); +int InitFir(short **Yworkspace, long order); +int InitIir(short **Yworkspace, long no_sections); +int FreeIir(short **Yworkspace, long no_sections); /*A-10-015-01*/ +int InitDIir(long **Yworkspace, long no_sections); +int FreeDIir(long **Yworkspace, long no_sections); /*A-10-015-01*/ +int InitLms(short **Yworkspace, long order); +int FreeLms(short **Yworkspace, long order); /*A-10-015-01*/ +int Fir(short op[], + const short ip[], + long no_samples, + const short Xcoeff[], + long order, + int res_shift, + short *Yworkspace); +int Fir1(short *op_ptr, + short input, + const short Xcoeff[], + long order, + int res_shift, + short *Yworkspace); +int Iir(short op[], + const short ip[], + long no_samples, + const short Xcoeff[], + long no_sections, + short *Yworkspace); +int Iir1(short *op_ptr, + short input, + const short Xcoeff[], + long no_sections, + short *Yworkspace); +int DIir(short op[], + const short ip[], + long no_samples, + const long Xcoeff[], + long no_sections, + long *Yworkspace); +int DIir1(short *op_ptr, + const short input, /*98.01.09 C-10-005-01 */ +/* short input, 98.01.09 D-10-005-01 */ + const long Xcoeff[], + long no_sections, + long *Yworkspace); +int Lms(short op[], + const short ip[], + const short ref[], + long no_samples, + short Xcoeff[], + long order, + int res_shift, + short mu, + short *Yworkspace); +int Lms1(short *op_ptr, + short input, + short ref_op, + short Xcoeff[], + long order, + int res_shift, + short mu, + short *Yworkspace); + +/* +** Convolution and Correlation +*/ +int ConvComplete(short op[], + const short ix[], + const short iy[], + long ix_size, + long iy_size, + int res_shift); +int ConvCyclic(short op[], + const short ix[], + const short iy[], + long size, + int res_shift); +int ConvPartial(short op[], + const short ix[], + const short iy[], + long ix_size, + long iy_size, + int res_shift); +int Correlate(short op[], + const short ix[], + const short iy[], + long ix_size, + long iy_size, + long no_corr, + int x_is_larger, + int res_shift); +int CorrCyclic(short op[], + const short ix[], + const short iy[], + long size, + int reverse, + int res_shift); + + +/* +** Miscellaneous +*/ +int GenGWnoise(short output[], long no_samples, float variance); + +int MinI(short **min_ptr, short buffer[], long buff_len, int src_is_x); +int MaxI(short **max_ptr, short buffer[], long buff_len, int src_is_x); +int PeakI(short **peak_ptr, short buffer[], long buff_len, int src_is_x); + +int Mean(short *mean_ptr, const short buffer[], long buff_len, int src_is_x); +int Variance(long *variance_ptr, + short *mean_ptr, + const short buffer[], + long buff_len, int src_is_x); + +int VectorMult(short dest[], + const short matrixX[], + const short matrixY[], + long length, + int res_shift); +int MatrixMult(void *matrix3, + const void *matrixX, + const void *matrixY, + long m, + long n, + long p, + int res_shift, int dest_is_x); +int MsPower(long *pow_ptr, const short input[], long buff_size, int src_is_x); + +int CopyXtoY(short y[], const short x[], long n); +int CopyYtoX(short x[], const short y[], long n); +int CopyToX(short x[], const short src[], long n); +int CopyToY(short y[], const short src[], long n); +int CopyFromX(short src[], const short x[], long n); +int CopyFromY(short src[], const short y[], long n); + +int Limit(short data[], long no_elements, int data_is_x); + +#ifdef __cplusplus /*A-10-014-01*/ +} /*A-10-014-01*/ +#endif /*A-10-014-01*/ + +#endif diff --git a/include/errno.h b/include/errno.h new file mode 100644 index 0000000..67daf07 --- /dev/null +++ b/include/errno.h @@ -0,0 +1,114 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = errno : */ +/* FUNC = */ +/* ; */ +/* */ +/* */ +/* */ +/* CLAS = UNIT ; */ +/* END ; */ +/*****************************************************************/ +#ifndef _ERRNO +#define _ERRNO + +#ifndef ERANGE +#define ERANGE 1100 +#endif + +#ifndef EDOM +#define EDOM 1101 +#endif + +#ifndef EDIV +#define EDIV 1102 +#endif + +#ifndef ESTRN +#define ESTRN 1104 +#endif + +#ifndef PTRERR +#define PTRERR 1106 +#endif + +#ifndef SEQERR +#define SEQERR 1108 +#endif + +#ifndef ECBASE +#define ECBASE 1200 +#endif + +#ifndef ETLN +#define ETLN 1202 +#endif + +#ifndef EEXP +#define EEXP 1204 +#endif + +#ifndef EEXPN +#define EEXPN 1206 +#endif + +#ifndef ENUM +#define ENUM 1208 +#endif + +#ifndef EFLOATO +#define EFLOATO 1210 +#endif + +#ifndef EFLOATU +#define EFLOATU 1220 +#endif + +#ifndef EDBLO +#define EDBLO 1250 +#endif + +#ifndef EDBLU +#define EDBLU 1260 +#endif + +#ifndef ELDBLO +#define ELDBLO 1270 +#endif + +#ifndef ELDBLU +#define ELDBLU 1280 +#endif + +#ifndef NOTOPN +#define NOTOPN 1300 +#endif + +#ifndef EBADF +#define EBADF 1302 +#endif + +#ifndef ECSPEC +#define ECSPEC 1304 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +extern volatile int _errno; + +#ifdef __cplusplus +} +#endif + +#ifndef errno +#define errno _errno +#endif + +#endif diff --git a/include/exception.h b/include/exception.h new file mode 100644 index 0000000..c7da5a6 --- /dev/null +++ b/include/exception.h @@ -0,0 +1,74 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/***********************************************************************/ +/* SPEC; */ +/* NAME = exception.h : */ +/* */ +/* FUNC = Include file for exception handling (see 18.6) */ +/* */ +/* CLAS = UNIT; */ +/* */ +/* END; */ +/***********************************************************************/ + +#ifndef _EXCEPTION_H +#define _EXCEPTION_H + +/* This lets users disable the EDG supplied exception classes. */ +#ifndef __NO_EDG_EXCEPTION_CLASSES + +#include + +#ifdef __EDG_RUNTIME_USES_NAMESPACES +namespace std { +#endif /* ifdef __EDG_RUNTIME_USES_NAMESPACES */ + + /* + If bool is not supported, use a typedef for bool. + */ + #ifdef _BOOL + typedef bool __bool; + #else /* ifndef _BOOL */ + typedef int __bool; + #endif /* ifdef _BOOL */ + + class bad_exception : public exception { + public: + bad_exception() throw(); + bad_exception(const bad_exception&) throw(); + bad_exception& operator=(const bad_exception&) throw(); + virtual ~bad_exception() throw(); + virtual const char* what() const throw(); + }; + + typedef void (*terminate_handler)(); + extern terminate_handler set_terminate(terminate_handler); + + typedef void (*unexpected_handler)(); + extern unexpected_handler set_unexpected(unexpected_handler); + + /* unexpected and terminate are in the WP definition of exception.h. + It is not clear why. */ + void terminate(); + void unexpected(); + + extern __bool uncaught_exception(); + +#ifdef __EDG_RUNTIME_USES_NAMESPACES +} /* namespace */ + +#ifdef __EDG_IMPLICIT_USING_STD +/* Implicitly include a using directive for the STD namespace when this + preprocessing flag is TRUE. */ +using namespace std; +#endif /* ifdef __EDG_IMPLICIT_USING_STD */ + +#endif /* ifdef __EDG_RUNTIME_USES_NAMESPACES */ + +#endif /* ifndef __NO_EDG_EXCEPTION_CLASSES */ + +#endif /* _EXCEPTION_H */ + diff --git a/include/filt_ws.h b/include/filt_ws.h new file mode 100644 index 0000000..e9ef4c5 --- /dev/null +++ b/include/filt_ws.h @@ -0,0 +1,26 @@ +/* +*SHDSP Library +*Copyright (c) Hitachi,Ltd. 1998 +*Licensed material of Hitachi,Ltd +*/ +/*********************************************************** +* File: filt_ws.h +* Purpose: Filter +* Create: 1998.03.20 Rev. 1.0 +***********************************************************/ + +#ifndef FILT_WS +#define FILT_WS + +#ifndef WS_SIZE +#define WS_SIZE 1024 /* Set Global workspace buffer size=1024 shorts (2048 bytes) */ +#endif + +#define MEMSIZE WS_SIZE*sizeof(short) +#pragma section Y /*need to equate DYRAM with link.cmd file*/ +short ws_mem[WS_SIZE]; +short * ws_ptr=ws_mem; +long ws_left=MEMSIZE; +#pragma section + +#endif diff --git a/include/float.h b/include/float.h new file mode 100644 index 0000000..cf32062 --- /dev/null +++ b/include/float.h @@ -0,0 +1,208 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = float : */ +/* FUNC = limit about float type and double type ; */ +/* */ +/* */ +/* END ; */ +/*****************************************************************/ +#ifndef _FLOAT +#define _FLOAT + +extern const float _FLT_MAX_VAL; +extern const float _FLT_MIN_VAL; +extern const double _DBL_MAX_VAL; +extern const double _DBL_MIN_VAL; +extern const long double _LDBL_MAX_VAL; +extern const long double _LDBL_MIN_VAL; + +#ifndef _FPD + +#define FLT_RADIX 2 +#if defined(_SH2E)|defined(_SH3E)|(defined(_SH4)&!defined(_RON)) +#define FLT_ROUNDS 0 +#define FLT_GUARD 0 +#else +#define FLT_ROUNDS 1 +#define FLT_GUARD 1 +#endif +#define FLT_NORMALIZE 1 +#define FLT_MAX _FLT_MAX_VAL +#define FLT_MIN _FLT_MIN_VAL +#define FLT_MAX_EXP 127 +#if defined(_SH2E)|defined(_SH3E)|(defined(_SH4)&!defined(_DON)) +#define FLT_MIN_EXP (-126) +#else +#define FLT_MIN_EXP (-149) +#endif +#define FLT_MAX_10_EXP 38 +#if defined(_SH2E)|defined(_SH3E)|(defined(_SH4)&!defined(_DON)) +#define FLT_MIN_10_EXP (-38) +#else +#define FLT_MIN_10_EXP (-44) +#endif +#define FLT_DIG 6 +#define FLT_MANT_DIG 24 +#define FLT_EXP_DIG 8 +#if defined(_SH2E)|defined(_SH3E)|(defined(_SH4)&!defined(_RON)) +#define FLT_POS_EPS 1.1920928955078125e-7f +#if defined(_DON) +#define FLT_NEG_EPS 1.4012984643248171e-45f +#else +#define FLT_NEG_EPS 1.1754943508222876e-38f +#endif +#else +#define FLT_POS_EPS 5.9604648328104311e-8f +#define FLT_NEG_EPS 2.9802324164052156e-8f +#endif +#define FLT_POS_EPS_EXP (-23) +#if defined(_SH2E)|defined(_SH3E)|defined(_SH4) +#define FLT_NEG_EPS_EXP (-126) +#else +#define FLT_NEG_EPS_EXP (-24) +#endif + +#endif + + +#if defined(_FLT)|defined(_FPS) + +#define DBL_RADIX FLT_RADIX +#define DBL_ROUNDS FLT_ROUNDS +#define DBL_GUARD FLT_GUARD +#define DBL_NORMALIZE FLT_NORMALIZE +#define DBL_MAX _FLT_MAX_VAL +#define DBL_MIN _FLT_MIN_VAL +#define DBL_MAX_EXP FLT_MAX_EXP +#define DBL_MIN_EXP FLT_MIN_EXP +#define DBL_MAX_10_EXP FLT_MAX_10_EXP +#define DBL_MIN_10_EXP FLT_MIN_10_EXP +#define DBL_DIG FLT_DIG +#define DBL_MANT_DIG FLT_MANT_DIG +#define DBL_EXP_DIG FLT_EXP_DIG +#define DBL_POS_EPS FLT_POS_EPS +#define DBL_NEG_EPS FLT_NEG_EPS +#define DBL_POS_EPS_EXP FLT_POS_EPS_EXP +#define DBL_NEG_EPS_EXP FLT_NEG_EPS_EXP + +#else + +#define DBL_RADIX 2 +#if defined(_SH4)&!defined(_RON) +#define DBL_ROUNDS 0 +#define DBL_GUARD 0 +#else +#define DBL_ROUNDS 1 +#define DBL_GUARD 1 +#endif +#define DBL_NORMALIZE 1 +#define DBL_MAX _DBL_MAX_VAL +#define DBL_MIN _DBL_MIN_VAL +#define DBL_MAX_EXP 1023 +#if defined(_SH4)&!defined(_DON) +#define DBL_MIN_EXP (-1022) +#else +#define DBL_MIN_EXP (-1074) +#endif +#define DBL_MAX_10_EXP 308 +#if defined(_SH4)&!defined(_DON) +#define DBL_MIN_10_EXP (-308) +#else +#define DBL_MIN_10_EXP (-323) +#endif +#define DBL_DIG 15 +#define DBL_MANT_DIG 53 +#define DBL_EXP_DIG 11 +#if defined(_SH4)&!defined(_RON) +#define DBL_POS_EPS 2.2204460492503131e-16 +#if defined(_DON) +#define DBL_NEG_EPS 4.9406564584124655e-324 +#else +#define DBL_NEG_EPS 2.2250738585072014e-308 +#endif +#else +#define DBL_POS_EPS 1.1102230246251567e-16 +#define DBL_NEG_EPS 5.5511151231257834e-17 +#endif +#define DBL_POS_EPS_EXP (-52) +#ifdef _SH4 +#ifdef _RON +#define DBL_NEG_EPS_EXP (-53) +#else +#ifdef _DON +#define DBL_NEG_EPS_EXP (-1023) +#else +#define DBL_NEG_EPS_EXP (-1022) +#endif +#endif +#else +#define DBL_NEG_EPS_EXP (-53) +#endif + +#ifdef _FPD +#define FLT_RADIX DBL_RADIX +#define FLT_ROUNDS DBL_ROUNDS +#define FLT_GUARD DBL_GUARD +#define FLT_NORMALIZE DBL_NORMALIZE +#define FLT_MAX _DBL_MAX_VAL +#define FLT_MIN _DBL_MIN_VAL +#define FLT_MAX_EXP DBL_MAX_EXP +#define FLT_MIN_EXP DBL_MIN_EXP +#define FLT_MAX_10_EXP DBL_MAX_10_EXP +#define FLT_MIN_10_EXP DBL_MIN_10_EXP +#define FLT_DIG DBL_DIG +#define FLT_MANT_DIG DBL_MANT_DIG +#define FLT_EXP_DIG DBL_EXP_DIG +#define FLT_POS_EPS DBL_POS_EPS +#define FLT_NEG_EPS DBL_NEG_EPS +#define FLT_POS_EPS_EXP DBL_POS_EPS_EXP +#define FLT_NEG_EPS_EXP DBL_NEG_EPS_EXP +#endif + +#endif + + +#ifdef _FLT +#define LDBL_RADIX 2 +#define LDBL_ROUNDS 1 +#define LDBL_GUARD 1 +#define LDBL_NORMALIZE 1 +#define LDBL_MAX _LDBL_MAX_VAL +#define LDBL_MIN _LDBL_MIN_VAL +#define LDBL_MAX_EXP 1023 +#define LDBL_MIN_EXP (-1074) +#define LDBL_MAX_10_EXP 308 +#define LDBL_MIN_10_EXP (-323) +#define LDBL_DIG 15 +#define LDBL_MANT_DIG 53 +#define LDBL_EXP_DIG 11 +#define LDBL_POS_EPS 1.1102230246251567e-16 +#define LDBL_NEG_EPS 5.5511151231257834e-17 +#define LDBL_POS_EPS_EXP (-52) +#define LDBL_NEG_EPS_EXP (-53) +#else +#define LDBL_RADIX DBL_RADIX +#define LDBL_ROUNDS DBL_ROUNDS +#define LDBL_GUARD DBL_GUARD +#define LDBL_NORMALIZE DBL_NORMALIZE +#define LDBL_MAX DBL_MAX +#define LDBL_MIN DBL_MIN +#define LDBL_MAX_EXP DBL_MAX_EXP +#define LDBL_MIN_EXP DBL_MIN_EXP +#define LDBL_MAX_10_EXP DBL_MAX_10_EXP +#define LDBL_MIN_10_EXP DBL_MIN_10_EXP +#define LDBL_DIG DBL_DIG +#define LDBL_MANT_DIG DBL_MANT_DIG +#define LDBL_EXP_DIG DBL_EXP_DIG +#define LDBL_POS_EPS DBL_POS_EPS +#define LDBL_NEG_EPS DBL_NEG_EPS +#define LDBL_POS_EPS_EXP DBL_POS_EPS_EXP +#define LDBL_NEG_EPS_EXP DBL_NEG_EPS_EXP +#endif + +#endif diff --git a/include/iomanip b/include/iomanip new file mode 100644 index 0000000..9dcdb71 --- /dev/null +++ b/include/iomanip @@ -0,0 +1,60 @@ +//Embedded C++ Library +//Copyright (c) Hitachi,Ltd. 1997 +//Licensed material of Hitachi,Ltd + +// +// Embeded C++ Library Header +// + +//==================================================================== +// File: iomanip +// Purpose: Definition of class iomanip +// Create: 1997.09.20 Rev. 1.0 +//==================================================================== + +#ifndef _IOMANIP_ +#define _IOMANIP_ + +#include +#include + +//Class +class smanip{ +private: + union{ + int val_i; + char val_c; + ios_base::fmtflags val_f; + }; + union{ + ios_base& (*pfi)(ios_base&,int); + ios_base& (*pfc)(ios_base&,char); + ios_base& (*pff)(ios_base&,ios_base::fmtflags); + }; + enum _ec2p_smanip_t{ + _ec2p_smanip_i,_ec2p_smanip_c ,_ec2p_smanip_f + }_ec2p_smanip_data; + +public: + smanip(ios_base& (*pf)(ios_base&,int),int arg) + :pfi(pf),val_i(arg),_ec2p_smanip_data(_ec2p_smanip_i){} + + smanip(ios_base& (*pf)(ios_base&,char),char arg) + :pfc(pf),val_c(arg),_ec2p_smanip_data(_ec2p_smanip_c){} + + smanip(ios_base& (*pf)(ios_base&,ios_base::fmtflags),ios_base::fmtflags arg) + :pff(pf),val_f(arg),_ec2p_smanip_data(_ec2p_smanip_f){} + + friend ostream& operator << (ostream&,smanip); + friend istream& operator >> (istream&,smanip); +}; + +//Manipulators +smanip resetiosflags(ios_base::fmtflags); +smanip setiosflags(ios_base::fmtflags); +smanip setbase(int); +smanip setfill(char); +smanip setprecision(int); +smanip setw(int); + +#endif diff --git a/include/ios b/include/ios new file mode 100644 index 0000000..54295ae --- /dev/null +++ b/include/ios @@ -0,0 +1,192 @@ +//Embedded C++ Library +//Copyright (c) Hitachi,Ltd. 1997 +//Licensed material of Hitachi,Ltd +// +// Embeded C++ Class Library Header +// + +//==================================================================== +// File: ios +// Purpose: Definition of class ios +// Create: 1997.09.20 Rev. 1.0 +//==================================================================== + +#ifndef _IOS_ +#define _IOS_ + +class streambuf; +class ostream; + +typedef long POS_T; +typedef long INT_T; +typedef long SZ_T; +typedef long OFF_T; + +typedef OFF_T streamoff; +typedef SZ_T streamsize; +typedef INT_T int_type; +typedef POS_T pos_type; +typedef OFF_T off_type; + +class ios_base { +public: + typedef long fmtflags; + static const fmtflags boolalpha; + static const fmtflags dec; + static const fmtflags fixed; + static const fmtflags hex; + static const fmtflags internal; + static const fmtflags left; + static const fmtflags oct; + static const fmtflags right; + static const fmtflags scientific; + static const fmtflags showbase; + static const fmtflags showpoint; + static const fmtflags showpos; + static const fmtflags skipws; + static const fmtflags unitbuf; + static const fmtflags uppercase; + static const fmtflags adjustfield; + static const fmtflags basefield; + static const fmtflags floatfield; + typedef int iostate; + static const iostate badbit; + static const iostate eofbit; + static const iostate failbit; + static const iostate goodbit; + typedef int openmode; + static const openmode app; + static const openmode ate; + static const openmode binary; + static const openmode in; + static const openmode out; + static const openmode trunc; + typedef int seekdir; + static const seekdir beg; + static const seekdir cur; + static const seekdir end; + + class Init; + + fmtflags flags() const {return (fmtflags)fmtfl;} + fmtflags flags(fmtflags); + fmtflags setf(fmtflags) ; + fmtflags setf(fmtflags, fmtflags); + void unsetf(fmtflags); + char fill() const { + return (char)fillch; + } + char fill(char); + int precision() const { + return prec; + } + streamsize precision(streamsize); + streamsize width() const {return wide;} + streamsize width(streamsize); + +// static int xalloc() {return index++;} // Not implemented +// long & ipword(int); // Not implemented +// long * &pword(int); // Not implemented + + ~ios_base(){} // destructor + + // callbacks -- exposition only + enum event { + erase_event, + imbue_event, + copyfmt_event + }; + typedef void (*event_callback)(event, ios_base&, int index); + void register_callback(event_callback fn, int index); + static bool sync_with_stdio(bool sync = true){ return true; } + + class Init{ + public: + Init(){init_cnt++;} + ~Init(){init_cnt--;} + private: + static int init_cnt; + }; + +protected: + ios_base(){Init::Init();} + void _ec2p_init_base(); + void _ec2p_copy_base(ios_base &); + static const fmtflags _fmtmask; + static const iostate _statemask; +private: + fmtflags fmtfl; // format flag + streamsize prec; // number of after floating point + streamsize wide; // field width + char fillch; // fill charactor + +// static int index; // exposition only +// long *iarray; // exposition only +// void **parray; // exposition only +}; + +class ios : public ios_base { +public: +// Types: +// typedef INT_T int_type; +// typedef POS_T pos_type; +// typedef OFF_T off_type; + + operator void*() const { + return (void*)!fail(); + } + bool operator!() const{return (bool)fail();} + iostate rdstate () const{return (iostate)state;} + void clear(iostate = goodbit); + void setstate(iostate); + bool good() const {return (bool)(state==goodbit);} + bool eof() const {return (bool)(state&eofbit);} + bool fail() const {return (bool)(state&(badbit|failbit));} + bool bad() const {return (bool)(state&badbit);} + + iostate exceptions() const; // exposition only + void exceptions(iostate); // exposition only + + ios(streambuf *sbptr){ // Constructor + init(sbptr); + } + virtual ~ios(){}; // Destructor + ostream *tie() const {return tiestr;} + ostream *tie(ostream*); + streambuf *rdbuf() const{return sb;} + streambuf *rdbuf(streambuf*); + ios & copyfmt(const ios &); + ios(){init(0);} + void init(streambuf*); +private: + streambuf *sb; // pointer to streambuf object + ostream *tiestr; // pointer to ostream object + int state; // status +}; + +//Manipulators +ios_base & boolalpha(ios_base&); +ios_base & noboolalpha(ios_base&); +ios_base & showbase(ios_base&); +ios_base & noshowbase(ios_base&); +ios_base & showpoint(ios_base&); +ios_base & noshowpoint(ios_base&); +ios_base & showpos(ios_base&); +ios_base & noshowpos(ios_base&); +ios_base & skipws(ios_base&); +ios_base & noskipws(ios_base&); +ios_base & uppercase(ios_base&); +ios_base & nouppercase(ios_base&); +//Adjustfield +ios_base & internal(ios_base&); +ios_base & left(ios_base&); +ios_base & right(ios_base&); +//Basefield +ios_base & dec(ios_base&); +ios_base & hex(ios_base&); +ios_base & oct(ios_base&); +//floatfield +ios_base & fixed(ios_base&); +ios_base & scientific(ios_base&); + +#endif diff --git a/include/iostream b/include/iostream new file mode 100644 index 0000000..b4a5120 --- /dev/null +++ b/include/iostream @@ -0,0 +1,27 @@ +//Embedded C++ Library +//Copyright (c) Hitachi,Ltd. 1997 +//Licensed material of Hitachi,Ltd + +// +// Standard iostream objects +// Embeded C++ Library Header +// + +//==================================================================== +// File: iostream +// Purpose: Definition of class iostream +// Create: 1997.09.20 Rev. 1.0 +//==================================================================== + +#ifndef _IOSTREAM_ +#define _IOSTREAM_ + +#include +#include +#include + +extern istream cin; +extern ostream cout; +// extern ostream cerr; // EC++, not implemented + +#endif diff --git a/include/istream b/include/istream new file mode 100644 index 0000000..fdbd58b --- /dev/null +++ b/include/istream @@ -0,0 +1,112 @@ +//Embedded C++ Library +//Copyright (c) Hitachi,Ltd. 1997 +//Licensed material of Hitachi,Ltd + +//==================================================================== +// File: istream +// Purpose: Definition of class istream +// Create: 1997.09.20 Rev. 1.0 +//==================================================================== + +#ifndef _ISTREAM_ +#define _ISTREAM_ + +#include + +class istream : public ios { +public: + // Types (inherited from ios): + // typedef INT_T int_type; + // typedef POS_T pos_type; + // typedef OFF_T off_type; + + istream(streambuf *sb) + :chcount(0),ios(sb){} // Constructor + virtual ~istream(){} // Destructor + class sentry; // Prefix/Suffix + + // Formatted input + istream& operator >>(istream& (*pf)(istream&)){ + return ((*pf)(*this)); } + istream& operator >>(ios& (*pf)(ios&)){ + (*pf)(* (ios *)this); return (*this); } + istream& operator>> (ios_base& (*pf)(ios_base&)){ + (*pf)(* (ios*)this); return (*this); } + istream & operator >>(bool &n); + istream & operator >>(short &n); + istream & operator >>(unsigned short &n); + istream & operator >>(int &n); + istream & operator >>(unsigned int &n); + istream & operator >>(long &n); + istream & operator >>(unsigned long &n); + istream & operator >>(float &f); + istream & operator >>(double &f); + istream & operator >>(long double &f); + istream & operator >>(void * &p); + istream & operator >>(streambuf *sb); + + // Unformatted input + streamsize gcount() const{return chcount;} + int_type get(); + istream & get( char& c ); + istream & get( signed char& c ); + istream & get( unsigned char& c ); + istream & get( char* s, streamsize n); + istream & get( char* s, streamsize n, char delim ); + istream & get( signed char* s, streamsize n); + istream & get( signed char* s, streamsize n, char delim ); + istream & get( unsigned char* s, streamsize n); + istream & get( unsigned char* s, streamsize n, char delim ); + istream & get( streambuf& sb); + istream & get( streambuf& sb, char delim ); + istream & getline( char* s, streamsize n); + istream & getline( char* s, streamsize n, char delim ); + istream & getline( signed char* s, streamsize n ); + istream & getline( signed char* s, streamsize n, char delim ); + istream & getline( unsigned char* s, streamsize n ); + istream & getline( unsigned char* s, streamsize n, char delim ); + istream & ignore( streamsize n=1, int_type delim=streambuf::eof ); + int_type peek(); + istream & read( char* s, streamsize n ); + istream & read( signed char* s, streamsize n ); + istream & read( unsigned char* s, streamsize n ); + streamsize readsome( char* s, streamsize n ); + streamsize readsome( signed char* s, streamsize n ); + streamsize readsome( unsigned char* s, streamsize n ); + istream & putback( char c ); + istream & unget(); + int sync(); + pos_type tellg(); + istream & seekg( pos_type pos ); + istream & seekg( off_type off, ios_base::seekdir dir ); + +private: + streamsize chcount; + streamsize _ec2p_gets( char* s, streamsize n, char delim, int mode ); + int _ec2p_getistr(char* str, unsigned int dig, int mode); + int _ec2p_getfstr(char* str, unsigned int dig); + unsigned long _ec2p_strtoul(char *nptr, char **endptr, int base); + long _ec2p_extlong(); + unsigned long _ec2p_extulong(); +}; + +class istream::sentry { +public: + sentry(istream& is, bool noskipws = false); + ~sentry(){} + operator bool() { return ok_; } +private: + bool ok_; +}; + +// character extraction templates: +istream& operator>>(istream&, char&); +istream& operator>>(istream&, unsigned char&); +istream& operator>>(istream&, signed char&); +istream& operator>>(istream&, char*); +istream& operator>>(istream&, unsigned char*); +istream& operator>>(istream&, signed char*); + +// Manipulator +istream& ws(istream& is ); +#endif diff --git a/include/libfx.h b/include/libfx.h new file mode 100644 index 0000000..7563af9 --- /dev/null +++ b/include/libfx.h @@ -0,0 +1,97 @@ +/*****************************************************************/ +/* */ +/* CASIO fx-9860G SDK Library */ +/* */ +/* File name : fxlib.h */ +/* */ +/* Copyright (c) 2006 CASIO COMPUTER CO., LTD. */ +/* */ +/*****************************************************************/ +#ifndef __FXLIB_H__ +#define __FXLIB_H__ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Prototypes + +void Bdisp_AllClr_DD(void); +void Bdisp_AllClr_VRAM(void); +void Bdisp_AllClr_DDVRAM(void); +void Bdisp_AreaClr_DD(const DISPBOX *pArea); +void Bdisp_AreaClr_VRAM(const DISPBOX *pArea); +void Bdisp_AreaClr_DDVRAM(const DISPBOX *pArea); +void Bdisp_AreaReverseVRAM(int x1, int y1, int x2, int y2); +void Bdisp_GetDisp_DD(unsigned char *pData); +void Bdisp_GetDisp_VRAM(unsigned char *pData); +void Bdisp_PutDisp_DD(void); +void Bdisp_PutDispArea_DD(const DISPBOX *PutDispArea); +void Bdisp_SetPoint_DD(int x, int y, unsigned char point); +void Bdisp_SetPoint_VRAM(int x, int y, unsigned char point); +void Bdisp_SetPoint_DDVRAM(int x, int y, unsigned char point); +int Bdisp_GetPoint_VRAM(int x, int y); +void Bdisp_WriteGraph_DD(const DISPGRAPH *WriteGraph); +void Bdisp_WriteGraph_VRAM(const DISPGRAPH *WriteGraph); +void Bdisp_WriteGraph_DDVRAM(const DISPGRAPH *WriteGraph); +void Bdisp_ReadArea_DD(const DISPBOX *ReadArea, unsigned char *ReadData); +void Bdisp_ReadArea_VRAM(const DISPBOX *ReadArea, unsigned char *ReadData); +void Bdisp_DrawLineVRAM(int x1, int y1, int x2, int y2); +void Bdisp_ClearLineVRAM(int x1, int y1, int x2, int y2); + +void locate(int x, int y); +void Print(const unsigned char *str); +void PrintRev(const unsigned char *str); +void PrintC(const unsigned char *c); +void PrintRevC(const unsigned char *str); +void PrintLine(const unsigned char *str, int max); +void PrintRLine(const unsigned char *str, int max); +void PrintXY(int x, int y, const unsigned char *str, int type); +int PrintMini(int x, int y, const unsigned char *str, int type); +void SaveDisp(unsigned char num); +void RestoreDisp(unsigned char num); +void PopUpWin(int n); + +int Bfile_OpenFile(const FONTCHARACTER *filename, int mode); +int Bfile_OpenMainMemory(const unsigned char *name); +int Bfile_ReadFile(int HANDLE, void *buf, int size, int readpos); +int Bfile_WriteFile(int HANDLE, const void *buf, int size); +int Bfile_SeekFile(int HANDLE, int pos); +int Bfile_CloseFile(int HANDLE); +int Bfile_GetMediaFree(enum DEVICE_TYPE devicetype, int *freebytes); +int Bfile_GetFileSize(int HANDLE); +int Bfile_CreateFile(const FONTCHARACTER *filename, int size); +int Bfile_CreateDirectory(const FONTCHARACTER *pathname); +int Bfile_CreateMainMemory(const unsigned char *name); +int Bfile_RenameMainMemory(const unsigned char *oldname, const unsigned char *newname); +int Bfile_DeleteFile(const FONTCHARACTER *filename); +int Bfile_DeleteDirectory(const FONTCHARACTER *pathname); +int Bfile_DeleteMainMemory(const unsigned char *name); +int Bfile_FindFirst(const FONTCHARACTER *pathname, int *FindHandle, FONTCHARACTER *foundfile, FILE_INFO *fileinfo); +int Bfile_FindNext(int FindHandle, FONTCHARACTER *foundfile, FILE_INFO *fileinfo); +int Bfile_FindClose(int FindHandle); + +void Bkey_Set_RepeatTime(long FirstCount, long NextCount); +void Bkey_Get_RepeatTime(long *FirstCount, long *NextCount); +void Bkey_Set_RepeatTime_Default(void); +int GetKeyWait(int sel, int time, int menu, unsigned int *keycode); +int IsKeyDown(int keycode); +int IsKeyUp(int keycode); +int GetKey(unsigned int *keycode); + +int SetTimer(int ID, int elapse, void (*hander)(void)); +int KillTimer(int ID); +void Sleep(int millisecond); + +void SetQuitHandler(void (*callback)(void)); +int INIT_ADDIN_APPLICATION(int isAppli, unsigned short OptionNum); + +# ifdef __cplusplus +} +# endif + +#endif diff --git a/include/libfx/dispbios.h b/include/libfx/dispbios.h new file mode 100644 index 0000000..03bdbfc --- /dev/null +++ b/include/libfx/dispbios.h @@ -0,0 +1,94 @@ +/*****************************************************************/ +/* */ +/* CASIO fx-9860G SDK Library */ +/* */ +/* File name : dispbios.h */ +/* */ +/* Copyright (c) 2006 CASIO COMPUTER CO., LTD. */ +/* */ +/*****************************************************************/ +#ifndef __DISPBIOS_H__ +#define __DISPBIOS_H__ + + +// Defines + +#define IM_VRAM_WIDTH 128 +#define IM_VRAM_HEIGHT 64 + +#define IM_VRAM_SIZE 1024 + +#define IM_CHARACTERS_MAX_LINE 21 +#define IM_BYTES_MAX_LINE (IM_CHARACTERS_MAX_LINE*2) + +#define SAVEDISP_PAGE1 1 +#define SAVEDISP_PAGE2 5 +#define SAVEDISP_PAGE3 6 + +#define MINI_OVER 0x10 +#define MINI_OR 0x11 +#define MINI_REV 0x12 +#define MINI_REVOR 0x13 + +#define IM_BIOS_DD_WIDTH IM_VRAM_WIDTH +#define IM_BIOS_DD_HEIGHT IM_VRAM_HEIGHT + +#define WRITEKIND unsigned char +#define IMB_WRITEKIND_OVER 0x01 +#define IMB_WRITEKIND_OR 0x02 +#define IMB_WRITEKIND_AND 0x03 +#define IMB_WRITEKIND_XOR 0x04 + +#define WRITEMODIFY unsigned char +#define IMB_WRITEMODIFY_NORMAL 0x01 +#define IMB_WRITEMODIFY_REVERCE 0x02 +#define IMB_WRITEMODIFY_MESH 0x03 + +#define AREAKIND unsigned char +#define IMB_AREAKIND_OVER 0x01 +#define IMB_AREAKIND_MESH 0x02 +#define IMB_AREAKIND_CLR 0x03 +#define IMB_AREAKIND_REVERSE 0x04 + +#define EFFECTWIN unsigned char +#define IMB_EFFECTWIN_OK 0x01 +#define IMB_EFFECTWIN_NG 0x02 + +#ifdef __cplusplus +extern "C" { +#endif + +// Structs + +typedef struct tag_DISPBOX{ + int left; + int top; + int right; + int bottom; +} DISPBOX; + +typedef struct tag_GRAPHDATA{ + int width; + int height; + unsigned char *pBitmap; +} GRAPHDATA; + +typedef struct tag_RECTANGLE{ + DISPBOX LineArea; + AREAKIND AreaKind; + EFFECTWIN EffectWin; +} RECTANGLE; + +typedef struct tag_DISPGRAPH{ + int x; + int y; + GRAPHDATA GraphData; + WRITEMODIFY WriteModify; + WRITEKIND WriteKind; +} DISPGRAPH; + +# ifdef __cplusplus +} +# endif + +#endif diff --git a/include/libfx/endian.h b/include/libfx/endian.h new file mode 100644 index 0000000..84ce3d2 --- /dev/null +++ b/include/libfx/endian.h @@ -0,0 +1,22 @@ +/*****************************************************************/ +/* */ +/* CASIO fx-9860G SDK Library */ +/* */ +/* File name : endian.h */ +/* */ +/* Copyright (c) 2006 CASIO COMPUTER CO., LTD. */ +/* */ +/*****************************************************************/ +#ifndef __ENDIAN_H__ +#define __ENDIAN_H__ + + +// Macros + +#define UtlSwapWord(w) (unsigned short)((((w) & 0x00ff) << 8) | (((w) & 0xff00) >> 8)) +#define UtlSwapDword(l) (unsigned long)((((l) & 0x000000ff) << 24) | (((l) & 0x0000ff00) << 8) | (((l) & 0xff000000) >> 24) | (((l) & 0x00ff0000) >> 8)) +#define UtlSwapInteger(i) UtlSwapDword(i) +#define UtlSwapPointer(p) (void*)((((unsigned long)(p) & 0x000000ff) << 24) | (((unsigned long)(p) & 0x0000ff00) << 8) | (((unsigned long)(p) & 0xff000000) >> 24) | (((unsigned long)(p) & 0x00ff0000) >> 8)) + + +#endif diff --git a/include/libfx/filebios.h b/include/libfx/filebios.h new file mode 100644 index 0000000..f6fe263 --- /dev/null +++ b/include/libfx/filebios.h @@ -0,0 +1,113 @@ +/*****************************************************************/ +/* */ +/* CASIO fx-9860G SDK Library */ +/* */ +/* File name : filebios.h */ +/* */ +/* Copyright (c) 2006 CASIO COMPUTER CO., LTD. */ +/* */ +/*****************************************************************/ +#ifndef __FILEBIOS_H__ +#define __FILEBIOS_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +// Defines + +#define FONTCHARACTER unsigned short + +#define _OPENMODE_READ 0x01 +#define _OPENMODE_READ_SHARE 0x80 +#define _OPENMODE_WRITE 0x02 +#define _OPENMODE_READWRITE 0x03 +#define _OPENMODE_READWRITE_SHARE 0x83 + +#define _CREATEMODE_BINARY 1 +#define _CREATEMODE_DIRECTORY 5 + +enum DEVICE_TYPE{ + DEVICE_MAIN_MEMORY, + DEVICE_STORAGE, + DEVICE_SD_CARD, // only fx-9860G SD model +}; + + +// File system standard error code +#define IML_FILEERR_NOERROR 0 +#define IML_FILEERR_ENTRYNOTFOUND -1 +#define IML_FILEERR_ILLEGALPARAM -2 +#define IML_FILEERR_ILLEGALPATH -3 +#define IML_FILEERR_DEVICEFULL -4 +#define IML_FILEERR_ILLEGALDEVICE -5 +#define IML_FILEERR_ILLEGALFILESYS -6 +#define IML_FILEERR_ILLEGALSYSTEM -7 +#define IML_FILEERR_ACCESSDENYED -8 +#define IML_FILEERR_ALREADYLOCKED -9 +#define IML_FILEERR_ILLEGALTASKID -10 +#define IML_FILEERR_PERMISSIONERROR -11 +#define IML_FILEERR_ENTRYFULL -12 +#define IML_FILEERR_ALREADYEXISTENTRY -13 +#define IML_FILEERR_READONLYFILE -14 +#define IML_FILEERR_ILLEGALFILTER -15 +#define IML_FILEERR_ENUMRATEEND -16 +#define IML_FILEERR_DEVICECHANGED -17 +//#define IML_FILEERR_NOTRECORDFILE -18 // Not used +#define IML_FILEERR_ILLEGALSEEKPOS -19 +#define IML_FILEERR_ILLEGALBLOCKFILE -20 +//#define IML_FILEERR_DEVICENOTEXIST -21 // Not used +//#define IML_FILEERR_ENDOFFILE -22 // Not used +#define IML_FILEERR_NOTMOUNTDEVICE -23 +#define IML_FILEERR_NOTUNMOUNTDEVICE -24 +#define IML_FILEERR_CANNOTLOCKSYSTEM -25 +#define IML_FILEERR_RECORDNOTFOUND -26 +//#define IML_FILEERR_NOTDUALRECORDFILE -27 // Not used +#define IML_FILEERR_NOTALARMSUPPORT -28 +#define IML_FILEERR_CANNOTADDALARM -29 +#define IML_FILEERR_FILEFINDUSED -30 +#define IML_FILEERR_DEVICEERROR -31 +#define IML_FILEERR_SYSTEMNOTLOCKED -32 +#define IML_FILEERR_DEVICENOTFOUND -33 +#define IML_FILEERR_FILETYPEMISMATCH -34 +#define IML_FILEERR_NOTEMPTY -35 +#define IML_FILEERR_BROKENSYSTEMDATA -36 +#define IML_FILEERR_MEDIANOTREADY -37 +#define IML_FILEERR_TOOMANYALARMITEM -38 +#define IML_FILEERR_SAMEALARMEXIST -39 +#define IML_FILEERR_ACCESSSWAPAREA -40 +#define IML_FILEERR_MULTIMEDIACARD -41 +#define IML_FILEERR_COPYPROTECTION -42 +#define IML_FILEERR_ILLEGALFILEDATA -43 + +// FILE_INFO.type +#define DT_DIRECTORY 0x0000 // Directory +#define DT_FILE 0x0001 // File +#define DT_ADDIN_APP 0x0002 // Add-In application +#define DT_EACT 0x0003 // eActivity +#define DT_LANGUAGE 0x0004 // Language +#define DT_BITMAP 0x0005 // Bitmap +#define DT_MAINMEM 0x0006 // Main Memory data +#define DT_TEMP 0x0007 // Temporary data +#define DT_DOT 0x0008 // . (Current directory) +#define DT_DOTDOT 0x0009 // .. (Parent directory) +#define DT_VOLUME 0x000A // Volume label + + +// Structs + +typedef struct tag_FILE_INFO +{ + unsigned short id; + unsigned short type; + unsigned long fsize; // File size + unsigned long dsize; // Data size + unsigned int property; // The file has not been completed, except when property is 0. + unsigned long address; +} FILE_INFO; + +# ifdef __cplusplus +} +# endif + +#endif diff --git a/include/libfx/keybios.h b/include/libfx/keybios.h new file mode 100644 index 0000000..a57e1e1 --- /dev/null +++ b/include/libfx/keybios.h @@ -0,0 +1,155 @@ +/*****************************************************************/ +/* */ +/* CASIO fx-9860G SDK Library */ +/* */ +/* File name : keybios.h */ +/* */ +/* Copyright (c) 2006 CASIO COMPUTER CO., LTD. */ +/* */ +/*****************************************************************/ +#ifndef __KEYBIOS_H__ +#define __KEYBIOS_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +// Defines + +// Character codes +#define KEY_CHAR_0 0x30 +#define KEY_CHAR_1 0x31 +#define KEY_CHAR_2 0x32 +#define KEY_CHAR_3 0x33 +#define KEY_CHAR_4 0x34 +#define KEY_CHAR_5 0x35 +#define KEY_CHAR_6 0x36 +#define KEY_CHAR_7 0x37 +#define KEY_CHAR_8 0x38 +#define KEY_CHAR_9 0x39 +#define KEY_CHAR_DP 0x2e +#define KEY_CHAR_EXP 0x0f +#define KEY_CHAR_PMINUS 0x87 +#define KEY_CHAR_PLUS 0x89 +#define KEY_CHAR_MINUS 0x99 +#define KEY_CHAR_MULT 0xa9 +#define KEY_CHAR_DIV 0xb9 +#define KEY_CHAR_FRAC 0xbb +#define KEY_CHAR_LPAR 0x28 +#define KEY_CHAR_RPAR 0x29 +#define KEY_CHAR_COMMA 0x2c +#define KEY_CHAR_STORE 0x0e +#define KEY_CHAR_LOG 0x95 +#define KEY_CHAR_LN 0x85 +#define KEY_CHAR_SIN 0x81 +#define KEY_CHAR_COS 0x82 +#define KEY_CHAR_TAN 0x83 +#define KEY_CHAR_SQUARE 0x8b +#define KEY_CHAR_POW 0xa8 +#define KEY_CHAR_IMGNRY 0x7f50 +#define KEY_CHAR_LIST 0x7f51 +#define KEY_CHAR_MAT 0x7f40 +#define KEY_CHAR_EQUAL 0x3d +#define KEY_CHAR_PI 0xd0 +#define KEY_CHAR_ANS 0xc0 +#define KEY_CHAR_LBRCKT 0x5b +#define KEY_CHAR_RBRCKT 0x5d +#define KEY_CHAR_LBRACE 0x7b +#define KEY_CHAR_RBRACE 0x7d +#define KEY_CHAR_CR 0x0d +#define KEY_CHAR_CUBEROOT 0x96 +#define KEY_CHAR_RECIP 0x9b +#define KEY_CHAR_ANGLE 0x7f54 +#define KEY_CHAR_EXPN10 0xb5 +#define KEY_CHAR_EXPN 0xa5 +#define KEY_CHAR_ASIN 0x91 +#define KEY_CHAR_ACOS 0x92 +#define KEY_CHAR_ATAN 0x93 +#define KEY_CHAR_ROOT 0x86 +#define KEY_CHAR_POWROOT 0xb8 +#define KEY_CHAR_SPACE 0x20 +#define KEY_CHAR_DQUATE 0x22 +#define KEY_CHAR_VALR 0xcd +#define KEY_CHAR_THETA 0xce +#define KEY_CHAR_A 0x41 +#define KEY_CHAR_B 0x42 +#define KEY_CHAR_C 0x43 +#define KEY_CHAR_D 0x44 +#define KEY_CHAR_E 0x45 +#define KEY_CHAR_F 0x46 +#define KEY_CHAR_G 0x47 +#define KEY_CHAR_H 0x48 +#define KEY_CHAR_I 0x49 +#define KEY_CHAR_J 0x4a +#define KEY_CHAR_K 0x4b +#define KEY_CHAR_L 0x4c +#define KEY_CHAR_M 0x4d +#define KEY_CHAR_N 0x4e +#define KEY_CHAR_O 0x4f +#define KEY_CHAR_P 0x50 +#define KEY_CHAR_Q 0x51 +#define KEY_CHAR_R 0x52 +#define KEY_CHAR_S 0x53 +#define KEY_CHAR_T 0x54 +#define KEY_CHAR_U 0x55 +#define KEY_CHAR_V 0x56 +#define KEY_CHAR_W 0x57 +#define KEY_CHAR_X 0x58 +#define KEY_CHAR_Y 0x59 +#define KEY_CHAR_Z 0x5a + + +// Control codes +#define KEY_CTRL_NOP 0 +#define KEY_CTRL_EXE 30004 +#define KEY_CTRL_DEL 30025 +#define KEY_CTRL_AC 30015 +#define KEY_CTRL_FD 30046 +#define KEY_CTRL_XTT 30001 +#define KEY_CTRL_EXIT 30002 +#define KEY_CTRL_SHIFT 30006 +#define KEY_CTRL_ALPHA 30007 +#define KEY_CTRL_OPTN 30008 +#define KEY_CTRL_VARS 30016 +#define KEY_CTRL_UP 30018 +#define KEY_CTRL_DOWN 30023 +#define KEY_CTRL_LEFT 30020 +#define KEY_CTRL_RIGHT 30021 +#define KEY_CTRL_F1 30009 +#define KEY_CTRL_F2 30010 +#define KEY_CTRL_F3 30011 +#define KEY_CTRL_F4 30012 +#define KEY_CTRL_F5 30013 +#define KEY_CTRL_F6 30014 +#define KEY_CTRL_CATALOG 30100 +#define KEY_CTRL_CAPTURE 30055 +#define KEY_CTRL_CLIP 30050 +#define KEY_CTRL_PASTE 30036 +#define KEY_CTRL_INS 30033 +#define KEY_CTRL_MIXEDFRAC 30054 +#define KEY_CTRL_FRACCNVRT 30026 +#define KEY_CTRL_QUIT 30029 +#define KEY_CTRL_PRGM 30028 +#define KEY_CTRL_SETUP 30037 +#define KEY_CTRL_PAGEUP 30052 +#define KEY_CTRL_PAGEDOWN 30053 +#define KEY_CTRL_MENU 30003 +#define KEY_CTRL_RESERVE1 30060 +#define KEY_CTRL_RESERVE2 30061 +#define KEY_CTRL_RESERVE3 30062 + + +// in Bkey_GetKeyWait function +#define KEYWAIT_HALTON_TIMEROFF 0 +#define KEYWAIT_HALTOFF_TIMEROFF 1 +#define KEYWAIT_HALTON_TIMERON 2 + +#define KEYREP_NOEVENT 0 +#define KEYREP_KEYEVENT 1 +#define KEYREP_TIMEREVENT 2 + +# ifdef __cplusplus +} +# endif + +#endif diff --git a/include/libfx/timer.h b/include/libfx/timer.h new file mode 100644 index 0000000..8dab7b3 --- /dev/null +++ b/include/libfx/timer.h @@ -0,0 +1,23 @@ +/*****************************************************************/ +/* */ +/* CASIO fx-9860G SDK Library */ +/* */ +/* File name : timer.h */ +/* */ +/* Copyright (c) 2006 CASIO COMPUTER CO., LTD. */ +/* */ +/*****************************************************************/ +#ifndef __TIMER_H__ +#define __TIMER_H__ + + +// Defines + +#define ID_USER_TIMER1 1 +#define ID_USER_TIMER2 2 +#define ID_USER_TIMER3 3 +#define ID_USER_TIMER4 4 +#define ID_USER_TIMER5 5 + + +#endif diff --git a/include/limits.h b/include/limits.h new file mode 100644 index 0000000..b4f00ea --- /dev/null +++ b/include/limits.h @@ -0,0 +1,35 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/***********************************************************************/ +/* SPEC; */ +/* NAME = limits.h : */ +/* */ +/* FUNC = this module do the following functions */ +/* */ +/* CLAS = UNIT; */ +/* */ +/* END; */ +/***********************************************************************/ +#ifndef _LIMITS +#define _LIMITS + +#define CHAR_BIT 8 +#define CHAR_MAX 127 +#define CHAR_MIN (-128) +#define SCHAR_MAX 127 +#define SCHAR_MIN (-128) +#define UCHAR_MAX 255 +#define SHRT_MAX 32767 +#define SHRT_MIN (-32768) +#define USHRT_MAX 65535 +#define INT_MAX 2147483647 +#define INT_MIN (-2147483647-1) +#define UINT_MAX 4294967295u +#define LONG_MAX 2147483647 +#define LONG_MIN (-2147483647L-1L) +#define ULONG_MAX 4294967295u + +#endif diff --git a/include/machine.h b/include/machine.h new file mode 100644 index 0000000..d2386d3 --- /dev/null +++ b/include/machine.h @@ -0,0 +1,23 @@ +/*------------------------------------------------------*/ +/* SH C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = machine.h : */ +/* FUNC = */ +/* ; */ +/* */ +/* */ +/* */ +/* CLAS = UNIT ; */ +/* END ; */ +/*****************************************************************/ +#ifndef _MACHINE +#define _MACHINE + +#include +#include + +#endif diff --git a/include/math.h b/include/math.h new file mode 100644 index 0000000..17b43be --- /dev/null +++ b/include/math.h @@ -0,0 +1,111 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = math : */ +/* FUNC = */ +/* ; */ +/* */ +/* */ +/* */ +/* CLAS = UNIT ; */ +/* END ; */ +/*****************************************************************/ +#ifndef _MATH +#define _MATH + +#ifdef __cplusplus +#include +#endif + +#ifndef ERANGE +#define ERANGE 1100 +#endif + +#ifndef EDOM +#define EDOM 1101 +#endif + +#ifndef ENUM +#define ENUM 1208 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +extern volatile int _errno; +extern const double _HUGE_VAL; +#define HUGE_VAL _HUGE_VAL + +extern double frexp(double, int *); +extern double ldexp(double, int ); +extern double modf(double, double *); +extern double ceil(double); + +#ifdef _SH4 +#ifdef _FPS +#define fabs _builtin_fabsf +#else +#define fabs _builtin_fabs +#endif +#else +#if defined(_SH2E)|defined(_SH3E) +#ifdef _FLT +#define fabs _builtin_fabsf +#else +extern double fabs(double); +#endif +#else +extern double fabs(double); +#endif +#endif + +extern double floor(double); +extern double fmod(double, double); + +extern double acos(double); +extern double asin(double); +extern double atan(double); +extern double atan2(double,double); +extern double cos(double); +extern double sin(double); +extern double tan(double); +extern double cosh(double); +extern double tanh(double); +extern double sinh(double); +extern double exp(double); +extern double log(double); +extern double log10(double); +extern double pow(double,double); + +#ifdef _COMPLEX_ +extern double sqrt(double); +#else +#ifdef _SH4 +#ifdef _FPS +#define sqrt _builtin_sqrtf +#else +#define sqrt _builtin_sqrt +#endif +#else +#ifdef _SH3E +#ifdef _FLT +#define sqrt _builtin_sqrtf +#else +extern double sqrt(double); +#endif +#else +extern double sqrt(double); +#endif +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/mathf.h b/include/mathf.h new file mode 100644 index 0000000..ba1505d --- /dev/null +++ b/include/mathf.h @@ -0,0 +1,66 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.1 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = mathf */ +/* FUNC = */ +/* ; */ +/* */ +/* */ +/* */ +/* CLAS = UNIT ; */ +/* END ; */ +/*****************************************************************/ +#ifndef _MATHF +#define _MATHF + +#ifdef __cplusplus +extern "C" { +#include +#endif +extern float frexpf(float, int *); +extern float ldexpf(float, int); +extern float modff(float, float *); +extern float ceilf(float); +#if defined(_SH2E)|defined(_SH3E)|defined(_SH4) +#ifdef _FPD +#define fabsf _builtin_fabs +#else +#define fabsf _builtin_fabsf +#endif +#else +extern float fabsf(float); +#endif +extern float floorf(float); +extern float fmodf(float, float); +extern float acosf(float); +extern float asinf(float); +extern float atanf(float); +extern float atan2f(float,float); +extern float cosf(float); +extern float sinf(float); +extern float tanf(float); +extern float coshf(float); +extern float tanhf(float); +extern float sinhf(float); +extern float expf(float); +extern float logf(float); +extern float log10f(float); +extern float powf(float,float); +#if defined(_SH3E)|defined(_SH4) +#ifdef _FPD +#define sqrtf _builtin_sqrt +#else +#define sqrtf _builtin_sqrtf +#endif +#else +extern float sqrtf(float); +#endif +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/mystrbuf b/include/mystrbuf new file mode 100644 index 0000000..f780d4b --- /dev/null +++ b/include/mystrbuf @@ -0,0 +1,53 @@ +//Embedded C++ Library +//Copyright (c) Hitachi,Ltd. 1997 +//Licensed material of Hitachi,Ltd +// +// Embeded C++ Library +// + +//==================================================================== +// File: mystrbuf +// Purpose: Definition of class mystrbuf +// Create: 1997.09.20 Rev. 1.0 +//==================================================================== + +#ifndef _MYSTRBUF_ +#define _MYSTRBUF_ + +#ifdef _EC2P_GPP +#define _bufbase _base +#define _bufptr _ptr +#define _bufcnt _cnt +// #define _buflen _bufsiz +#define _ioflag1 _flag +#endif + +#include +struct _f_type; +class mystrbuf : public streambuf { +public: + mystrbuf(){_file_Ptr = 0;} + mystrbuf(void *_fp){_Init((_f_type*)_fp);} + virtual ~mystrbuf(){close();} + void *myfptr() const{return _file_Ptr;} + mystrbuf *open(const char *, int); + mystrbuf *close(); +protected: + virtual streambuf *setbuf(char *, streamsize); + virtual pos_type seekoff(off_type, ios_base::seekdir, + ios_base::openmode=(ios_base::openmode)(ios_base::in|ios_base::out)); + virtual pos_type seekpos(pos_type sp, + ios_base::openmode=(ios_base::openmode)(ios_base::in|ios_base::out)); + virtual int sync(); + virtual int showmanyc(){return 0;} + virtual int_type underflow(); + virtual int_type pbackfail(int_type=streambuf::eof); + virtual int_type overflow(int_type=streambuf::eof); +private: + void _Init(_f_type *); + _f_type *_file_Ptr; +#ifdef _EC2P_GPP + long _buflen_wk; +#endif +}; +#endif diff --git a/include/new b/include/new new file mode 100644 index 0000000..6e8c596 --- /dev/null +++ b/include/new @@ -0,0 +1,31 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 6.0 */ +/* Copyright (c) 1992, 2000 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ + +/***********************************************************************/ +/* SPEC; */ +/* NAME = new : */ +/* */ +/* FUNC = Include file for C++ default operator new . */ +/* */ +/* CLAS = UNIT; */ +/* */ +/* END; */ +/***********************************************************************/ + +#ifndef __NEW__ +#define __NEW__ + +#ifdef __embedded_cplusplus + +#include // include Embeded C++ Library Header + +#else + +#include // include ANSI C++ Library Header + +#endif /* ifdef __embedded_cplusplus */ + +#endif /* ifndef __NEW__ */ diff --git a/include/new_ecpp.h b/include/new_ecpp.h new file mode 100644 index 0000000..77f33cb --- /dev/null +++ b/include/new_ecpp.h @@ -0,0 +1,41 @@ +//Embedded C++ Library +//Copyright (c) Hitachi,Ltd. 1997 +//Licensed material of Hitachi,Ltd + +// +// Dynamic memory management +// Embeded C++ Library Header +// + +//==================================================================== +// File: new +// Purpose: Definition of class new +// Create: 1997.09.20 Rev. 1.0 +//==================================================================== + +#ifndef _NEW_ +#define _NEW_ + +#include + +// Storage allocation and deallocation +void *operator new(size_t); +void *operator new[] (size_t); +void *operator new(size_t,void *); +void *operator new[](size_t,void *); + +void operator delete(void *); +void operator delete[](void *); +// void operator delete(void *, void *); // Not implemented +// void operator delete[](void *, void *); // Not implemented + +// Type new_handler +typedef void (*new_handler)(); + +// set_new_handler +new_handler set_new_handler(new_handler new_P); + +// new_handler +extern new_handler _ec2p_new_handler; + +#endif diff --git a/include/new_edg.h b/include/new_edg.h new file mode 100644 index 0000000..4bf1a6d --- /dev/null +++ b/include/new_edg.h @@ -0,0 +1,122 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 6.0 */ +/* Copyright (c) 1992, 2000 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/***********************************************************************/ +/* SPEC; */ +/* NAME = new_edg.h : */ +/* */ +/* FUNC = Include file for C++ default operator new . */ +/* */ +/* CLAS = UNIT; */ +/* */ +/* END; */ +/***********************************************************************/ + +#ifndef __NEW_H +#define __NEW_H + +#ifndef _STDDEF +#include +#endif /* ifndef _STDDEF */ +#ifndef _EXCEPTION_H +#include +#endif /* _EXCEPTION_H */ + +#ifndef __EDG_STD_NAMESPACE +/* If not already defined, define a macro that expands to the namespace + containing the standard library. */ +#ifdef __EDG_RUNTIME_USES_NAMESPACES +#define __EDG_STD_NAMESPACE std +#else /* ifndef __EDG_RUNTIME_USES_NAMESPACES */ +#define __EDG_STD_NAMESPACE /* nothing */ +#endif /* ifdef __EDG_RUNTIME_USES_NAMESPACES */ +#endif /* ifdef __EDG_STD_NAMESPACE */ + + +#ifdef __EDG_RUNTIME_USES_NAMESPACES +namespace std { +#endif /* ifdef __EDG_RUNTIME_USES_NAMESPACES */ + +/* This lets users disable the EDG supplied exception classes. */ +#ifndef __NO_EDG_EXCEPTION_CLASSES + + class bad_alloc : public exception { + public: + bad_alloc() throw(); + bad_alloc(const bad_alloc&) throw(); + bad_alloc& operator=(const bad_alloc&) throw(); + virtual ~bad_alloc() throw(); + virtual const char* what() const throw(); + }; + +#endif /* ifndef __NO_EDG_EXCEPTION_CLASSES */ + + typedef void (*new_handler)(); + new_handler set_new_handler(new_handler); + struct nothrow_t { }; + // Declaration of object nothrow to permit the use of the placement new + // syntax: new (nothrow) T; + const nothrow_t nothrow = {}; + +#ifdef __EDG_RUNTIME_USES_NAMESPACES +} /* namespace std */ + +#ifdef __EDG_IMPLICIT_USING_STD +/* Implicitly include a using directive for the STD namespace when this + preprocessing flag is TRUE. */ +using namespace std; +#endif /* ifdef __EDG_IMPLICIT_USING_STD */ + +#endif /* ifdef __EDG_RUNTIME_USES_NAMESPACES */ + +/* Normal operator new. */ +void *operator new(size_t) throw(__EDG_STD_NAMESPACE::bad_alloc); + +/* Normal operator delete. */ +void operator delete(void*) throw (); + +/* Nothrow version of operator new. */ +void *operator new(size_t, const __EDG_STD_NAMESPACE::nothrow_t&) throw(); + +/* Nothrow version of operator delete. */ +void operator delete(void*, const __EDG_STD_NAMESPACE::nothrow_t&) throw(); + +/* Placement new. */ +void *operator new(size_t, void*) throw(); + +/* Placement delete. */ +#ifdef __PLACEMENT_DELETE +void operator delete(void*, void*) throw(); +#endif /* ifdef __PLACEMENT_DELETE */ + +#ifdef __ARRAY_OPERATORS + +/* Array new. */ +void *operator new[](size_t) throw(__EDG_STD_NAMESPACE::bad_alloc); + +/* Array delete. */ +void operator delete[](void*) throw (); + +/* Placement array new. */ +void *operator new[](size_t, void*) throw(); + +/* Placement array delete. */ +#ifdef __PLACEMENT_DELETE +void operator delete[](void*, void*) throw(); +#endif /* ifdef __PLACEMENT_DELETE */ + +/* Nothrow version of array new. */ +void *operator new[](size_t, + const __EDG_STD_NAMESPACE::nothrow_t&) throw(); + +/* Nothrow version of array delete. */ +void operator delete[](void*, + const __EDG_STD_NAMESPACE::nothrow_t&) throw(); +#endif /* __ARRAY_OPERATORS */ + +// EC++ use new_handler +extern __EDG_STD_NAMESPACE::new_handler _ec2p_new_handler; + +#endif /* ifndef __NEW_H */ diff --git a/include/ostream b/include/ostream new file mode 100644 index 0000000..e81af01 --- /dev/null +++ b/include/ostream @@ -0,0 +1,87 @@ +//Embedded C++ Library +//Copyright (c) Hitachi,Ltd. 1997 +//Licensed material of Hitachi,Ltd + +//==================================================================== +// File: ostream +// Purpose: Definition of class ostream +// Create: 1997.09.20 Rev. 1.0 +//==================================================================== + +#ifndef _OSTREAM_ +#define _OSTREAM_ + +#include + +class ostream : public ios { +public: + // Types (inherited from ios): + // typedef INT_T int_type; + // typedef POS_T pos_type; + // typedef OFF_T off_type; + + ostream(streambuf *sbptr) : ios(sbptr){} + virtual ~ostream(){} + class sentry; // Prefix/Suffix + ostream& operator <<(ostream& (*pf)(ostream&)){ + return (*pf)(*this); } + ostream& operator <<(ios& (*pf)(ios&)){ + (*pf)(*(ios*)this); return *this; } + ostream& operator<< (ios_base& (*pf)(ios_base&)){ + (*pf)(*(ios*)this); return *this; } + ostream & operator <<(bool n){ + *this<<(int)n; return *this; } + ostream & operator <<(short); + ostream & operator <<(unsigned short); + ostream & operator <<(int); + ostream & operator <<(unsigned int); + ostream & operator <<(long); + ostream & operator <<(unsigned long); + ostream & operator <<(float); + ostream & operator <<(double); + ostream & operator <<(long double); + ostream & operator <<(void *); + ostream & operator <<(streambuf *); + ostream & put(char); + ostream & write(const char *, streamsize); + ostream & write(const signed char *, streamsize); + ostream & write(const unsigned char *, streamsize); + ostream & flush(); + pos_type tellp(); + ostream& seekp( pos_type ); + ostream& seekp( off_type , ios_base::seekdir ); + + int _ec2p_strput(const char*); +private: + void _ec2p_IntPrint(const char*, short); + void _ec2p_FloatPrint(const char*, short); + void _ec2p_DataPut(const char*, int, int, int, int); + void _ec2p_int_fmtparam(const char*, char*); + void _ec2p_flt_fmtparam(const char*, char*); +}; + +// Class ostream::sentry +class ostream::sentry { +public: + sentry(ostream& os); + ~sentry(); + operator bool() { return ok_; } +private: + bool ok_; + ostream* __ec2p_os; +}; + +// character inserters +ostream& operator<<(ostream&, char); +ostream& operator<<(ostream&, const char*); +// signed and unsigned +ostream& operator<<(ostream&, signed char); +ostream& operator<<(ostream&, unsigned char); +// signed and unsigned +ostream& operator<<(ostream&, const signed char*); +ostream& operator<<(ostream&, const unsigned char*); + +ostream & endl( ostream & ); +ostream & ends( ostream & ); +ostream & flush( ostream & ); +#endif diff --git a/include/setjmp.h b/include/setjmp.h new file mode 100644 index 0000000..fa770db --- /dev/null +++ b/include/setjmp.h @@ -0,0 +1,48 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/***********************************************************************/ +/* SPEC; */ +/* NAME = setjmp.h : ; */ +/* */ +/* FUNC = this module do the following functions ; */ +/* */ +/* CLAS = UNIT; */ +/* */ +/* END; */ +/***********************************************************************/ +#ifndef _SETJMP +#define _SETJMP + +#if defined(_SH2E)|defined(_SH3E)||defined(_SH4) +typedef int jmp_buf[38]; +#else +typedef int jmp_buf[20]; +#endif +#ifdef _SH4 +typedef int jmp_buf_a[54]; +#endif + +#ifdef __cplusplus +extern "C" { +#endif +extern int setjmp(jmp_buf); +extern void longjmp(jmp_buf, int); +#ifdef _SH4 +extern int setjmp_a(jmp_buf); +extern void longjmp_a(jmp_buf, int); +#endif + +extern volatile int _errno; + +#ifdef __cplusplus +} +#endif + +#ifndef SEQERR +#define SEQERR 1108 +#endif + +#endif diff --git a/include/smachine.h b/include/smachine.h new file mode 100644 index 0000000..03c7ae2 --- /dev/null +++ b/include/smachine.h @@ -0,0 +1,28 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 3.0 */ +/* Copyright (c) 1992,1995 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = smachine.h : */ +/* FUNC = ; */ +/* CLAS = UNIT ; */ +/* END ; */ +/*****************************************************************/ +#ifndef _SMACHINE +#define _SMACHINE + +#ifdef __cplusplus +#include +#endif + +#define set_imask(mask) _builtin_set_imask(mask) +#define get_imask() _builtin_get_imask() +#define set_cr(cr) _builtin_set_cr(cr) +#define get_cr() _builtin_get_cr() +#define set_vbr(base) _builtin_set_vbr(base) +#define get_vbr() _builtin_get_vbr() +#define sleep() _builtin_sleep() + +#endif diff --git a/include/stdarg.h b/include/stdarg.h new file mode 100644 index 0000000..48dfd16 --- /dev/null +++ b/include/stdarg.h @@ -0,0 +1,36 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = stdarg : */ +/* FUNC = this module do the following finctions ; */ +/* */ +/* (1) initialize parameter pointer */ +/* (2) set parameter pointer to next parameter */ +/* */ +/* */ +/* END ; */ +/*****************************************************************/ +#ifndef _STDARG +#define _STDARG + +typedef char *va_list ; + +#define va_start(ap,param) (void)((ap)=(int)\ +((char *) &(param)+sizeof(param))%4u?\ +(char *) &(param)+sizeof(param)+(4u-(sizeof(param)%4u)):\ +(char *) &(param)+sizeof(param)) + +#define va_arg(ap,type) (*((ap)=((int)((ap)+sizeof(type))%4u?\ +(ap)+sizeof(type)+(4u-(sizeof(type)%4u)):\ +(ap)+sizeof(type)),\ +(type *)((int)((ap)-sizeof(type))%4u?\ +(ap)-sizeof(type)-(4u-(sizeof(type)%4u)):\ +(ap)-sizeof(type)))) + +#define va_end(ap) + +#endif diff --git a/include/stddef.h b/include/stddef.h new file mode 100644 index 0000000..f453ce4 --- /dev/null +++ b/include/stddef.h @@ -0,0 +1,46 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/***********************************************************************/ +/* SPEC; */ +/* NAME = stddef : */ +/* */ +/* FUNC = this module do the following functions */ +/* */ +/* CLAS = UNIT; */ +/* */ +/* END; */ +/***********************************************************************/ +#ifndef _STDDEF +#define _STDDEF + +#ifndef _PTRDIFF_T +#define _PTRDIFF_T +typedef int ptrdiff_t; +#endif + +#ifndef _SIZE_T +#define _SIZE_T +typedef unsigned long size_t; +#endif + +#ifndef NULL +#ifdef __cplusplus +#define NULL (0) +#else +#define NULL ((void *)0) +#endif +#endif + +#ifndef offsetof +#define offsetof(type,id) ((char *)(&(((type *)NULL)->id)) - \ + (char *)((type *)NULL)) +#endif + +#ifndef errno +#define errno _errno +#endif + +#endif diff --git a/include/stdexcept.h b/include/stdexcept.h new file mode 100644 index 0000000..6fe3879 --- /dev/null +++ b/include/stdexcept.h @@ -0,0 +1,47 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/***********************************************************************/ +/* SPEC; */ +/* NAME = stdexcept.h : */ +/* */ +/* FUNC = Include file for exception handling (see 19.1.1) */ +/* */ +/* CLAS = UNIT; */ +/* */ +/* END; */ +/***********************************************************************/ + +#ifndef _STDEXCEPT_H +#define _STDEXCEPT_H + +/* This lets users disable the EDG supplied exception classes. */ +#ifndef __NO_EDG_EXCEPTION_CLASSES + +#ifdef __EDG_RUNTIME_USES_NAMESPACES +namespace std { +#endif /* ifdef __EDG_RUNTIME_USES_NAMESPACES */ + class exception { + public: + exception() throw(); + exception& operator=(const exception&) throw(); + virtual ~exception() throw(); + virtual const char* what() const throw(); + }; +#ifdef __EDG_RUNTIME_USES_NAMESPACES +} /* namespace std */ + +#ifdef __EDG_IMPLICIT_USING_STD +/* Implicitly include a using directive for the STD namespace when this + preprocessing flag is TRUE. */ +using namespace std; +#endif /* ifdef __EDG_IMPLICIT_USING_STD */ + +#endif /* ifdef __EDG_RUNTIME_USES_NAMESPACES */ + +#endif /* ifndef __NO_EDG_EXCEPTION_CLASSES */ + +#endif /* _STDEXCEPT_H */ + diff --git a/include/stdio.h b/include/stdio.h new file mode 100644 index 0000000..4c87959 --- /dev/null +++ b/include/stdio.h @@ -0,0 +1,146 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/***********************************************************************/ +/* SPEC; */ +/* NAME = stdio : header file for standard I/O function ; */ +/* */ +/* FUNC = this header file do the following functions; */ +/* (1) file entry table define; */ +/* (2) I/O macro define; */ +/* (3) symbol define; */ +/* CLAS = UNIT; */ +/* */ +/* END; */ +/***********************************************************************/ +#ifndef _STDIO +#define _STDIO + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define _NFILE 20 +#define SYS_OPEN 20 +extern struct _iobuf { + unsigned char *_bufptr; /* buffer pointer */ + long _bufcnt; /* buffer count */ + unsigned char *_bufbase; /* buffer base pointer */ + long _buflen; /* buffer length */ + char _ioflag1; /* I/O control flag 1 */ + char _ioflag2; /* I/O control flag 2 */ + char _iofd; +} _iob[_NFILE]; + +extern volatile int _errno; + +typedef struct _iobuf FILE; /* define FILE of file-stream */ + + /* define function of prototype */ +extern int _fillbuf(FILE*); +extern int _flshbuf(int,FILE*); +extern void _putcsub(FILE*); +extern int fclose(FILE *); +extern int fflush(FILE *); +extern FILE *fopen(const char *, const char *); +extern FILE *freopen(const char *, const char *, FILE *); +extern void setbuf(FILE *, char *); +extern int setvbuf(FILE *, char *, int, size_t); +extern int fprintf(FILE *, const char *, ...); +extern int fscanf(FILE *, const char *, ...); +extern int printf(const char * ,...); +extern int scanf(const char * ,...); +extern int sprintf(char *, const char * ,...); +extern int sscanf(const char *, const char * ,...); +extern int vfprintf(FILE *, const char *, char *); +extern int vprintf(const char *, char *); +extern int vsprintf(char *, const char *, char *); +extern int fgetc(FILE *); +extern char *fgets(char *, int, FILE *); +extern int fputc(int , FILE *); +extern int fputs(const char *, FILE *); +extern int getc(FILE *); +extern int getchar(void); +extern char *gets(char *); +extern int putc(int, FILE *); +extern int putchar(int); +extern int puts(const char *); +extern int ungetc(int, FILE *); +extern size_t fread(void *, size_t, size_t, FILE *); +extern size_t fwrite(const void *, size_t, size_t, FILE *); +extern int fseek(FILE *, long int, int); +extern long ftell(FILE *); +extern void rewind(FILE *); +extern void clearerr(FILE *); +extern int feof(FILE *); +extern int ferror(FILE *); +extern void perror(const char *); +#ifdef __cplusplus +} +#endif + +#define _IOFBF 1 /* define _IOFBF of full buffering */ +#define _IOLBF 2 /* define _IOLBF of line buffering */ +#define _IONBF 3 /* define _IONBF of non buffering */ + +#define SEEK_SET 0 /* allocate top position */ +#define SEEK_CUR 1 /* allocate current position */ +#define SEEK_END 2 /* allocate bottom position */ + +#define BUFSIZ 512 /* default buffer size */ + + /* error number define */ +#ifndef EBADF +#define EBADF 1302 /* I/O operation error */ +#endif + +#ifndef PTRERR +#define PTRERR 1106 /* fp null */ +#endif + +#ifndef ECSPEC +#define ECSPEC 1304 /* format err */ +#endif + +#ifndef NOTOPN +#define NOTOPN 1300 /* file not open */ +#endif + + /* I/O flags for _ioflag1 */ +#define _IOREAD 1 /* only read or update read */ +#define _IOWRITE 2 /* only write or update write */ +#define _IORW 4 /* update file */ +#define _IOUNBUF 8 /* unbffering I/O */ +#define _IOBGBUF 16 /* automatic buffer allocate */ +#define _IOEOF 32 /* end of file */ +#define _IOERR 64 /* I/O error */ +#define _IOBIN 128 /* binaly file */ +#define _UNGTC 1 /* ungetc issued (_ioflag2) */ +#define _IOLINBUF 2 /* line buffering */ + +#define EOF (-1) +#define _EOL (0X0A) /* end of line */ + +#define stdin (&_iob[0]) /* standard input file */ +#define stdout (&_iob[1]) /* standard output file */ +#define stderr (&_iob[2]) /* standard error output file */ + +#define getc(fp) ((fp)->_ioflag2&=~_UNGTC,(((fp)->_ioflag1&(_IORW|_IOWRITE))==\ + (_IORW|_IOWRITE))&&(fp)->_bufcnt==(fp)->_buflen?(_fillbuf(fp)):\ + --(fp)->_bufcnt>=0 ?((int)*(fp)->_bufptr++):_fillbuf(fp)) +#define putc(x,fp) (((((fp)->_ioflag1&_IORW)!=0&&((fp)->_ioflag1&_IOWRITE)==0)\ + ?_putcsub(fp):(void)0),((((fp)->_bufcnt==0)||((((fp)->_ioflag2&_IOLINBUF)!=0)\ + && ((fp)->_bufbase!=(fp)->_bufptr)&&(*((fp)->_bufptr-1)==_EOL)))\ + ?_flshbuf((int)(x),(fp)):\ + (((fp)->_bufcnt--),((int)(*(fp)->_bufptr++=(unsigned char)(x)))))) +#define getchar() getc(stdin) +#define putchar(x) putc(x,stdout) +#define feof(fp) ((fp)->_ioflag1&_IOEOF) +#define ferror(fp) ((fp)->_ioflag1&_IOERR) +#define clearerr(fp) ((void)((fp)->_ioflag1&=~(_IOEOF|_IOERR))) + +#endif diff --git a/include/stdlib.h b/include/stdlib.h new file mode 100644 index 0000000..5facbd0 --- /dev/null +++ b/include/stdlib.h @@ -0,0 +1,127 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = stdlib : */ +/* FUNC = */ +/* ; */ +/* */ +/* */ +/* */ +/* CLAS = UNIT ; */ +/* END ; */ +/*****************************************************************/ +#ifndef _STDLIB +#define _STDLIB + +#include + +struct _DIV_T_TAG { /* tag define for div_t */ + int quot; /* quotient */ + int rem; /* remainder */ +}; /* */ +struct _LDIV_T_TAG { /* tag define for ldiv_t */ + long quot; /* quotient */ + long rem; /* remainder */ +}; /* */ + +typedef struct _DIV_T_TAG div_t ; +/* int quot; int rem */ +typedef struct _LDIV_T_TAG ldiv_t ; +/* long quot; long rem; */ + +#ifndef RAND_MAX +#define RAND_MAX 32767 +#endif + +#ifndef ERANGE +#define ERANGE 1100 +#endif + +#ifndef EDOM +#define EDOM 1101 +#endif + +#ifndef EDIV +#define EDIV 1102 +#endif + +#ifndef ESTRN +#define ESTRN 1104 +#endif + +#ifndef ECBASE +#define ECBASE 1200 +#endif + +#ifndef ETLN +#define ETLN 1202 +#endif + +#ifndef EEXP +#define EEXP 1204 +#endif + +#ifndef EEXPN +#define EEXPN 1206 +#endif + +#ifndef EFLOATO +#define EFLOATO 1210 +#endif + +#ifndef EFLOATU +#define EFLOATU 1220 +#endif + +#ifndef EDBLO +#define EDBLO 1250 +#endif + +#ifndef EDBLU +#define EDBLU 1260 +#endif + +#ifndef ELDBLO +#define ELDBLO 1270 +#endif + +#ifndef ELDBLU +#define ELDBLU 1280 +#endif + +#ifdef __cplusplus +extern "C" { +#endif +extern volatile int _errno; +extern const double _HUGE_VAL; +#define HUGE_VAL _HUGE_VAL + +extern double atof(const char *) ; +extern int atoi(const char *) ; +extern long int atol(const char *) ; +extern double strtod(const char *, char **) ; +extern long int strtol(const char *, char **, int); +extern int rand(void) ; +extern void srand(unsigned int); +extern void *calloc(size_t, size_t); +extern void free(void *) ; +extern void *malloc(size_t); +extern void *realloc(void *, size_t) ; +extern void *bsearch(const void *, const void *, size_t, size_t, + int(*)(const void*,const void*) ) ; +extern void qsort(void *, size_t, size_t, + int(*)(const void*,const void*) ); + +extern int abs(int); +extern div_t div(int, int); +extern long int labs(long int); +extern ldiv_t ldiv(long int, long int); +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/streambuf b/include/streambuf new file mode 100644 index 0000000..9c631bd --- /dev/null +++ b/include/streambuf @@ -0,0 +1,97 @@ +//Embedded C++ Library +//Copyright (c) Hitachi,Ltd. 1997 +//Licensed material of Hitachi,Ltd +// +// Embeded C++ Library +// + +//==================================================================== +// File: streambuf +// Purpose: Definition of class streambuf +// Create: 1997.09.20 Rev. 1.0 +//==================================================================== + +#ifndef _STREAMBUF_ +#define _STREAMBUF_ + +#include +class streambuf { +public: + virtual ~streambuf(){} + streambuf *pubsetbuf(char *cptr, streamsize nnum){ + return setbuf(cptr, nnum); + } + pos_type pubseekoff(off_type off,ios_base::seekdir way, + ios_base::openmode which + =(ios_base::openmode) + (ios_base::in|ios_base::out)){ + return seekoff(off, way, which); + } + pos_type pubseekpos(pos_type sp, + ios_base::openmode which + =(ios_base::openmode) + (ios_base::in|ios_base::out)){ + return seekpos(sp, which); + } + int pubsync(){ + return sync(); + } + streamsize in_avail(){ + return ((gptr()!=0)&&(gptr() +// + +//==================================================================== +// File: string +// Purpose: Definition of class string +// Create: 1997.09.20 Rev. 1.0 +//==================================================================== + +#ifndef _STRING_ +#define _STRING_ + +#include +#include + + +#include +#include +#include + +class string; + +string operator + (const string &lhs,const string &rhs); +string operator + (const char *lhs,const string &rhs); +string operator + (char lhs,const string &rhs); +string operator + (const string &lhs,const char *rhs); +string operator + (const string &lhs,char rhs); + +bool operator == (const string &lhs,const string &rhs); +bool operator == (const char *lhs,const string &rhs); +bool operator == (const string &lhs,const char *rhs); +bool operator != (const string &lhs,const string &rhs); +bool operator != (const char *lhs,const string &rhs); +bool operator != (const string &lhs,const char *rhs); + +bool operator < (const string &lhs,const string &rhs); +bool operator < (const char *lhs,const string &rhs); +bool operator < (const string &lhs,const char *rhs); +bool operator > (const string &lhs,const string &rhs); +bool operator > (const char *lhs,const string &rhs); +bool operator > (const string &lhs,const char *rhs); + +bool operator <= (const string &lhs,const string &rhs); +bool operator <= (const char *lhs,const string &rhs); +bool operator <= (const string &lhs,const char *rhs); +bool operator >= (const string &lhs,const string &rhs); +bool operator >= (const char *lhs,const string &rhs); +bool operator >= (const string &lhs,const char *rhs); + +void swap(string &lhs, string &rhs); + +istream & operator >> (istream &is,string &str); +ostream & operator << (ostream &os,const string &str); +istream & getline (istream &is,string &str,char delim); +istream & getline (istream &is,string &str); + +class string { +public: + typedef char* iterator; + typedef const char* const_iterator; + + static const size_t npos; + + string(void) { + _ec2p_getmem(NULL, 0, NULL, false); + } + string(const string& str, size_t pos = 0, size_t n = npos) { + size_t wkpos = pos > str.size() ? str.size() : pos; + size_t rlen = (n > (str.size() - wkpos)) ? str.size() - wkpos : n; + _ec2p_getmem(&str.c_str()[wkpos], rlen, NULL, false); + } + string(const char* s, size_t n) { + _ec2p_getmem(s, n, NULL, false); + } + string(const char* s) { + _ec2p_getmem(s, strlen(s), NULL, false); + } + string(size_t n, char c) { + _ec2p_getmem(NULL, n, c, true); + } +#ifdef _EC2P_GPP + string(char c) { + _ec2p_getmem(NULL, 1, c, true); + } +#endif + ~string() { + if (s_ptr != NULL) { + delete [] s_ptr; + s_ptr = NULL; + } + } + string& operator=(const string& str); + string& operator=(const char* s); + string& operator=(char c); + + iterator begin() { return((iterator)s_ptr); } + const_iterator begin() const { return((const_iterator)s_ptr); } + iterator end() { return((iterator)&s_ptr[s_len]); } + const_iterator end() const { return((const_iterator)&s_ptr[s_len]);} + + size_t size() const { return(s_len); } + size_t length() const { return(s_len); } + size_t max_size() const { return(s_res); } + void resize(size_t n, char c); + void resize(size_t n); + size_t capacity() const { return(s_res); } + void reserve(size_t res_arg = 0); + void clear(); + bool empty() const { return( s_len == 0 ? true : false ); } + + const char & operator[](size_t pos) const; + char & operator[](size_t pos); + const char & at(size_t n) const; + char & at(size_t n); + + string& operator+=(const string& str); + string& operator+=(const char* s); + string& operator+=(char c); + string& append(const string& str); + string& append(const string& str, size_t pos, size_t n); + string& append(const char* s, size_t n); + string& append(const char* s); + string& append(size_t n, char c); + + string& assign(const string&); + string& assign(const string& str, size_t pos, size_t n); + string& assign(const char* s, size_t n); + string& assign(const char* s); + string& assign(size_t n, char c); + + string& insert(size_t pos1, const string& str); + string& insert(size_t pos1, const string& str, + size_t pos2, size_t n); + string& insert(size_t pos, const char* s, size_t n); + string& insert(size_t pos, const char* s); + string& insert(size_t pos, size_t n, char c); + iterator insert(iterator p, char c = char()); + void insert(iterator p, size_t n, char c); + + string& erase(size_t pos = 0, size_t n = npos); + iterator erase(iterator position); + iterator erase(iterator first, iterator last); + + string& replace(size_t pos1, size_t n1, const string& str); + string& replace(size_t pos1, size_t n1, const string& str, + size_t pos2, size_t n2); + string& replace(size_t pos, size_t n1, const char* s, size_t n2); + string& replace(size_t pos, size_t n1, const char* s); + string& replace(size_t pos, size_t n1, size_t n2, char c); + string& replace(iterator i1, iterator i2, const string& str); + string& replace(iterator i1, iterator i2, const char* s, size_t n); + string& replace(iterator i1, iterator i2, const char* s); + string& replace(iterator i1, iterator i2, size_t n, char c); + + size_t copy(char* s, size_t n, size_t pos = 0) const; + void swap(string&); + const char* c_str() const { return(s_ptr); } + const char* data() const { + if (s_len == 0) { + s_ptr[0] = '\0'; + } + return(s_ptr); + } + + size_t find (const string& str, size_t pos = 0) const; + size_t find (const char* s, size_t pos, size_t n) const; + size_t find (const char* s, size_t pos = 0) const; + size_t find (char c, size_t pos = 0) const; + size_t rfind(const string& str, size_t pos = npos) const; + size_t rfind(const char* s, size_t pos, size_t n) const; + size_t rfind(const char* s, size_t pos = npos) const; + size_t rfind(char c, size_t pos = npos) const; + + size_t find_first_of(const string& str, size_t pos = 0) const; + size_t find_first_of(const char* s, size_t pos, size_t n) const; + size_t find_first_of(const char* s, size_t pos = 0) const; + size_t find_first_of(char c, size_t pos = 0) const; + size_t find_last_of (const string& str, size_t pos = npos) const; + size_t find_last_of (const char* s, size_t pos, size_t n) const; + size_t find_last_of (const char* s, size_t pos = npos) const; + size_t find_last_of (char c, size_t pos = npos) const; + + size_t find_first_not_of(const string& str, size_t pos = 0) const; + size_t find_first_not_of(const char* s, size_t pos, size_t n) const; + size_t find_first_not_of(const char* s, size_t pos = 0) const; + size_t find_first_not_of(char c, size_t pos = 0) const; + size_t find_last_not_of (const string& str, size_t pos = npos) const; + size_t find_last_not_of (const char* s, size_t pos, size_t n) const; + size_t find_last_not_of (const char* s, size_t pos = npos) const; + size_t find_last_not_of (char c, size_t pos = npos) const; + + string substr(size_t pos = 0, size_t n = npos) const; + int compare(const string& str) const; + int compare(size_t pos1, size_t n1, const string& str) const; + int compare(size_t pos1, size_t n1, const string& str, + size_t pos2, size_t n2) const; + int compare(const char* s) const; + int compare(size_t pos1, size_t n1, + const char* s, size_t n2 = npos) const; +private: + char *s_ptr; + size_t s_len, s_res; + void _ec2p_getmem(const char *s, size_t n, char c, bool flg=false); + char *_ec2p_extmem(size_t n); + static const char _ec2p_at; + }; +#endif diff --git a/include/string.h b/include/string.h new file mode 100644 index 0000000..6ce197f --- /dev/null +++ b/include/string.h @@ -0,0 +1,57 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = string : */ +/* FUNC = */ +/* ; */ +/* */ +/* */ +/* */ +/* CLAS = UNIT ; */ +/* LINK = */ +/* NOTE = */ +/* ; */ +/* */ +/* END ; */ +/*****************************************************************/ +#ifndef _STRING +#define _STRING + +#include + +#ifdef __cplusplus +extern "C" { +#include +#endif +extern void *memcpy(void *, const void *, size_t); +extern void *memmove(void *, const void *, size_t); +extern char *strcpy(char *, const char *); +extern char *strncpy(char *, const char *, size_t); +extern char *strcat(char *, const char *); +extern char *strncat(char *, const char *,size_t); +extern int memcmp(const void *, const void *,size_t); +extern int strcmp(const char *, const char *); +extern int strncmp(const char *, const char *, size_t); +extern void *memchr(const void *, int, size_t); +extern char *strchr(const char *, int); +extern size_t strcspn(const char *, const char *); +extern char *strpbrk(const char *, const char *); +extern char *strrchr(const char *, int); +extern size_t strspn(const char *, const char *); +extern char *strstr(const char *, const char *); +extern char *strtok(char *, const char *); +extern void *memset(void *, int, size_t); +extern char *strerror(int); +extern size_t strlen(const char *); +#ifdef __cplusplus +} +#endif + +#define strcpy(s1,s2) _builtin_strcpy(s1,s2) +#define strcmp(s1,s2) _builtin_strcmp(s1,s2) + +#endif diff --git a/include/syscall.h b/include/syscall.h new file mode 100644 index 0000000..e888960 --- /dev/null +++ b/include/syscall.h @@ -0,0 +1,68 @@ +#ifndef _SYSCALL +#define _SYSCALL + +/**********************************************************/ +/** Les syscall suivants servent à l'acces au port série **/ +/** Le buffer de réception fait 1ko, **/ +/** et le buffer d'envoi fait 256 octets. **/ +/**********************************************************/ + +//Lit un caractère du buffer de réception et le copie a l'adresse pointée par 'dest' +//Retourne 0 en cas de succes, 1 si le buffer est vide, 3 si la connexion n'est pas établie +int Serial_ReadByte(unsigned char *dest); + +//Lit 'max' octets du buffer de réception et les écrit dans 'dest' +//'size' donne le nombre d'octets lu +//Retourne 0 en cas de succes, 1 si le buffer est vide, 3 si la connexion n'est pas établie +int Serial_ReadBytes(unsigned char *dest, int max, short *size); + +//Ecrit 'byte' dans le buffer d'envoi +//Retourne 0 +int Serial_WriteByte(unsigned char byte); + +//Ecrit 'size' octets dans le buffer d'envoi depuis l'adresse 'scr' +//Retourne 0 en cas de succes, 2 si le buffer est trop plein, 3 si la connexion n'est pas établie +int Serial_WriteBytes(unsigned char *src, int size); + +//FIFO = first in first out +int Serial_WriteByteFIFO(unsigned char byte); + +//Retourne la taille des données du buffer de réception +int Serial_GetRxBufferSize(void); + +//Retourne l'espace disponible dans le buffer d'envoi +int Serial_GetTxBufferFreeCapacity(void); + +//Vide le buffer de réception +//Retourne 0 en cas de succes, 3 si la connexion n'est pas établie +int Serial_ClearReceiveBuffer(void); + +//Vide le buffer d'envoi +//Retourne 0 +int Serial_ClearTransmitBuffer(void); + +//Ouvre et prépare l'interface de communication +//Pour plus de détails, consulter fxreverse-doc-1.pdf ci joint +int Serial_Open(unsigned char *conf); + +//Ferme l'interface de communication et vide les buffers d'envoi et de réception +//Si 'mode'==1, la communication est coupée sans regarder s'il reste des données a transmettre +//Si 'mode'!=1, la fonction ne ferme pas l'interface de communication s'il reste des données a transmettre +//et retourne 5 +//Retourne 0 en cas de succes (communication terminée) et 5 s'il reste des données a transmettre +int Serial_Close(int mode); + +//Copie l'octet numéro 'index' du buffer de réception vers 'dest' si 'index' ne dépasse pas les données du buffer +//Retourne 0 en cas de succes, 1 si 'index' dépasse les données du buffer, 3 si la communication n'est pas établie +int Serial_Peek(int index, unsigned char *dest); + +//Récupère le statut de la connexion +//Retourne 1 si la connexion est établie, 3 sinon +int Serial_IsOpen(void); + +int Timer_Start(int TimerID); +int Timer_Stop(int TimerID); +int Timer_Install(int TimerID, void (*handler)(void), int delay); +int RTC_GetTicks(); + +#endif diff --git a/include/typeinfo.h b/include/typeinfo.h new file mode 100644 index 0000000..adafb5b --- /dev/null +++ b/include/typeinfo.h @@ -0,0 +1,82 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 1.0 */ +/* Copyright (c) 1992 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/***********************************************************************/ +/* SPEC; */ +/* NAME = typeinfo.h : */ +/* */ +/* FUNC = Include file for type information (18.5.1) */ +/* */ +/* CLAS = UNIT; */ +/* */ +/* END; */ +/***********************************************************************/ + +#ifndef _TYPEINFO_H +#define _TYPEINFO_H + +#include + +#ifdef __EDG_RUNTIME_USES_NAMESPACES +namespace std { +#endif /* ifdef __EDG_RUNTIME_USES_NAMESPACES */ + + /* + If bool is not supported, use a typedef for bool. + */ + #ifdef _BOOL + typedef bool __bool; + #else /* ifndef _BOOL */ + typedef int __bool; + #endif /* ifdef _BOOL */ + +/* The following pragma is used so that the compiler knows that this definition + of type_info is the one that corresponds to the type returned by typeid. */ +#pragma define_type_info + class type_info { + public: + virtual ~type_info(); + __bool operator==(const type_info&) const; + __bool operator!=(const type_info&) const; + __bool before(const type_info&) const; + const char* name() const; + private: + type_info& operator=(const type_info&); // Not actually defined + protected: + // Protected instead of private to suppress the "no accessible + // constructor" warning + type_info(const type_info&); // Not actually defined + }; + + class bad_cast : public exception { + public: + bad_cast() throw(); + bad_cast(const bad_cast&) throw(); + bad_cast& operator=(const bad_cast&) throw(); + virtual ~bad_cast() throw(); + virtual const char* what() const throw(); + }; + + class bad_typeid : public exception { + public: + bad_typeid() throw(); + bad_typeid(const bad_typeid&) throw(); + bad_typeid& operator=(const bad_typeid&) throw(); + virtual ~bad_typeid() throw(); + virtual const char* what() const throw(); + }; + +#ifdef __EDG_RUNTIME_USES_NAMESPACES +} /* namespace std */ + +#ifdef __EDG_IMPLICIT_USING_STD +/* Implicitly include a using directive for the STD namespace when this + preprocessing flag is TRUE. */ +using namespace std; +#endif /* ifdef __EDG_IMPLICIT_USING_STD */ + +#endif /* ifdef __EDG_RUNTIME_USES_NAMESPACES */ + +#endif /* _TYPEINFO_H */ diff --git a/include/umachine.h b/include/umachine.h new file mode 100644 index 0000000..56b3be2 --- /dev/null +++ b/include/umachine.h @@ -0,0 +1,55 @@ +/*------------------------------------------------------*/ +/* SH SERIES C Compiler Ver. 3.0 */ +/* Copyright (c) 1992, 1995 Hitachi,Ltd. */ +/* Licensed material of Hitachi,Ltd. */ +/*------------------------------------------------------*/ +/*****************************************************************/ +/* SPEC ; */ +/* NAME = umachine.h : */ +/* FUNC = ; */ +/* CLAS = UNIT ; */ +/* END ; */ +/*****************************************************************/ +#ifndef _UMACHINE +#define _UMACHINE + +#ifdef __cplusplus +#include +#endif + +#define set_gbr(base) _builtin_set_gbr(base) +#define get_gbr() _builtin_get_gbr() +#define gbr_read_byte(offset) _builtin_gbr_read_byte(offset) +#define gbr_read_word(offset) _builtin_gbr_read_word(offset) +#define gbr_read_long(offset) _builtin_gbr_read_long(offset) +#define gbr_write_byte(offset,data) _builtin_gbr_write_byte(offset,data) +#define gbr_write_word(offset,data) _builtin_gbr_write_word(offset,data) +#define gbr_write_long(offset,data) _builtin_gbr_write_long(offset,data) +#define gbr_and_byte(offset,mask) _builtin_gbr_and_byte(offset,mask) +#define gbr_or_byte(offset,mask) _builtin_gbr_or_byte(offset,mask) +#define gbr_xor_byte(offset,mask) _builtin_gbr_xor_byte(offset,mask) +#define gbr_tst_byte(offset,mask) _builtin_gbr_tst_byte(offset,mask) +#define tas(addr) _builtin_tas(addr) +#define trapa(trap_no) _builtin_trapa(trap_no) +#define macw(ptr1, ptr2, count) _builtin_macw(ptr1, ptr2, count) +#define macwl(ptr1, ptr2, count, mask) _builtin_macwl(ptr1, ptr2, count, mask) +#define macl(ptr1, ptr2, count) _builtin_macl(ptr1, ptr2, count) +#define macll(ptr1, ptr2, count, mask) _builtin_macll(ptr1, ptr2, count, mask) +#define trapa_svc _builtin_trapa_svc +#define prefetch _builtin_prefetch +#define set_fpscr(cr) _builtin_set_fpscr(cr) +#define get_fpscr() _builtin_get_fpscr() +#define fipr(vec1, vec2) _builtin_fipr(vec1, vec2) +#define ftrv(vec1, vec2) _builtin_ftrv(vec1, vec2) +#define ftrvadd(vec1, vec2, vec3) _builtin_ftrvadd(vec1, vec2, vec3) +#define ftrvsub(vec1, vec2, vec3) _builtin_ftrvsub(vec1, vec2, vec3) +#define mtrx4mul(mx1, mx2) _builtin_mtrx4mul(mx1, mx2) +#define mtrx4muladd(mx1, mx2, mx3) _builtin_mtrx4muladd(mx1, mx2, mx3) +#define mtrx4mulsub(mx1, mx2, mx3) _builtin_mtrx4mulsub(mx1, mx2, mx3) +#define ld_ext(mx) _builtin_ld_ext(mx) +#define st_ext(mx) _builtin_st_ext(mx) +#define add4(vec1, vec2, vec3) _builtin_add4(vec1, vec2, vec3) +#define sub4(vec1, vec2, vec3) _builtin_sub4(vec1, vec2, vec3) +#define trace(tv) _builtin_trace(tv) + +#endif diff --git a/libfx.a b/libfx.a new file mode 100644 index 0000000000000000000000000000000000000000..5ef92aaf7eaf3afca041f8f64511d0caf86c42e8 GIT binary patch literal 410910 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 z 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 O-Jj39B3#tP_4vPN4ekyA literal 0 HcmV?d00001 diff --git a/opti b/opti new file mode 100755 index 0000000..f28c2ab --- /dev/null +++ b/opti @@ -0,0 +1 @@ +sh3eb-elf-objcopy -R .comment -R .bss -O binary addin.elf addin.bin diff --git a/wrapper b/wrapper new file mode 100755 index 0000000..78aa885 --- /dev/null +++ b/wrapper @@ -0,0 +1 @@ +g1a-wrapper addin.bin -o addin.g1a -i icon.bmp