OPtimize signed+unsigned char arithmetic

prepare output directory also to build only the compiler

.gitignore

@@ -335,3 +335,22 @@ ASALocalRun/
 *.asm
 *.map
 *.prg
+*.d
+*.d.*
+*.o
+*.lbl
+make/oscar64
+*.int
+*.bcs
+*.crt
+**/*.d64
+*.tlog
+*.res
+*.recipe
+*.exe
+*.dbj
+*.json
+*.mapd
+*.idb
+oscar64/Releasex64/oscar64.vcxproj.FileListAbsolute.txt
+/oscar64/Debugx64

CMakeLists.txt

@@ -0,0 +1,67 @@
+cmake_minimum_required(VERSION 3.15)
+
+# Project name and version
+project(oscar64 VERSION 1.0 LANGUAGES CXX)
+
+# Define the executable
+add_executable(oscar64)
+
+
+# Glob all source files in the oscar64/ directory
+file(GLOB OSCAR64_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/oscar64/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/oscar64/*.h")
+
+# Add the sources to the target
+target_sources(${PROJECT_NAME} PRIVATE ${OSCAR64_SOURCES})
+
+
+# Add header files
+target_include_directories(oscar64 PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+# Compiler settings based on configuration
+set_target_properties(oscar64 PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED YES
+    CXX_EXTENSIONS NO
+)
+
+# Set debug and release configurations
+target_compile_definitions(oscar64 PRIVATE $<$<CONFIG:Debug>:_DEBUG;_CONSOLE> $<$<CONFIG:Release>:NDEBUG;_CONSOLE>)
+target_compile_options(oscar64 PRIVATE $<$<CONFIG:Debug>:/W3 /WX> $<$<CONFIG:Release>:/O2 /W3>)
+
+# Post-build steps (only for Release builds)
+if(CMAKE_BUILD_TYPE STREQUAL "Release")
+    add_custom_command(TARGET oscar64 POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:oscar64> ${CMAKE_BINARY_DIR}/bin
+    )
+endif()
+
+if (WIN32)
+    target_link_libraries(oscar64 PRIVATE kernel32 user32 gdi32 winspool comdlg32 advapi32 shell32 ole32 oleaut32 uuid odbc32 odbccp32 version)
+elseif (APPLE)
+    # Add macOS-specific frameworks to replace Windows libraries
+    target_link_libraries(${PROJECT_NAME} 
+        "-framework Cocoa"        # For GUI and application support
+        "-framework CoreFoundation" # For Core Foundation utilities (similar to advapi32 or shell32)
+        "-framework CoreGraphics"  # For graphics and rendering (similar to gdi32)
+        "-framework IOKit"         # For hardware interaction
+        "-framework AppKit"        # For GUI (equivalent to user32)
+    )
+elseif (UNIX)
+    # Add Linux-specific libraries for equivalent functionality
+    target_link_libraries(${PROJECT_NAME} 
+        pthread                    # For threading (similar to kernel32)
+        dl                         # For dynamic library loading (similar to LoadLibrary)
+        m                          # For math library (optional but common on Linux)
+        X11                        # For X Window System (similar to user32 for GUI support)
+    )
+endif()
+
+
+# Output directories
+set_target_properties(oscar64 PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/Debug
+    RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/Release
+)
+

README.md

@@ -1,115 +1,40 @@
 # oscar64
- Optimizing small space C Compiler Assembler and Runtime for C64
 
-## History and motivation
+Oscar64 is a C/C++ cross compiler running on a modern system (such as a Windows PC, Mac or Linux machine) and targets the classic 6502 family of processors.  It is mainly focused on Commodore systems such as the C64, PET or VIC20.  The compiler supports C99 and many C++ features up to variadic templates and lambda functions.
 
-It is a sad fact that the 6502 used in the Commodore64 and other home computers of the 80s has a poor code density when it comes to 16 bit code.  The C standard requires computations to be made with ints which work best if they have the same size as a pointer.  
+The purpose of this compiler is to eliminate the need to write 6502 assembler code to achieve high code density and fast execution speed.  It continues to improve with all the games, demos and tools written by it.  It supports disk overlays and banked cartridges for larger projects.
 
-The 6502 also has a very small stack of 256 bytes which cannot be easily addressed and thus cannot be used for local variables.  Therefore a second stack for variables has to be maintained, resulting in costly indexing operations.
+The C64 executes 442 dhrystone V2.2 iteration per second, when compiled with Oscar64 and -O3 (which shows that the ancient dhrystone benchmark is no match to an optimizing compiler).
 
-A C compiler for the 6502 thus generates large binaries if it translates to native machine code.  The idea for the **oscar64** compiler is to translate the C source to an intermediate 16 bit byte code with the option to use native machine code for crucial functions.  Using embedded assembly for runtime libraries or critical code should also be possible.
+[Full reference manual](oscar64.md)
+[Additional samples and tutorials](https://github.com/drmortalwombat/OscarTutorials)
 
-The resulting compiler is a frankenstein constructed from a converted javascript parser a intermediate code optimizer based on a 15 year old compiler for 64bit x86 code and some new components for the backend.
+# References
 
-The performance of interpreted code is clearly not as good as native machine code but the penalty for 16bit code is around 40-50% and less than 10% for floating point.  Code that can use 8bit my suffer up to a factor of 10 to 20.
+This is a list of the games written with Oscar64, have a look if you are not convinced that fast paced action games can be written in C/C++ on a C64 (they are all free).
 
-## Limits and Errors
+[Ball and Chain](https://drmortalwombat.itch.io/ball-and-chain)
 
-The first release of the compiler is severely limited considering it is only two weeks old, so there is quite a lot missing or broken.  I hope to cross out most of the problems in the coming weeks.
+[Balls like a Frog](https://drmortalwombat.itch.io/balls-like-a-frog)
 
-### Language
+![cores4](https://github.com/user-attachments/assets/15c2bcc7-eafb-44fb-aec2-e5cb101c687b)
+[Corescape](https://drmortalwombat.itch.io/corescape)
 
-* No union type
+[MetalMayhem](https://drmortalwombat.itch.io/metal-mayhem)
-* No long integer
-* No struct function return
-* Missing const checks for structs and enums
-* No static variables in functions
-* Missing warnings for all kind of abuses
-* no #if in preprocessor
 
-### Linker
+[Mineshaft Gap](https://drmortalwombat.itch.io/mineshaft-gap)
 
-* No explicit sections for code, data bss or stack
+[Minotrace](https://drmortalwombat.itch.io/minotrace)
-* No media file import
 
-### Standard Libraries
+[Missile Defence](https://drmortalwombat.itch.io/missile-defence)
 
-* Limited formatting in printf
+![cl1b](https://github.com/user-attachments/assets/0d249274-6dab-4284-89e5-ada07fac1986)
-* No file functions
+[Portal Buster](https://drmortalwombat.itch.io/portal-buster)
-
-### Runtime
-
-* No INF and NaN support for floats
-* Underflow in float multiply and divide not checked
-* Basic zero page variables not restored on stop/restore
-
-### Optimizing
-
-* All global variables are considered volatile
-* No loop opmtimization
-* Poor bookeeping of callee saved registers
-* Missing livetime reduction of intermediates
-* No block domination analysis
-* No register use for arguments
-
-### Intermediate code generation
-
-* No check for running out of temporary registers
-* Wasted 7 codes for far jumps
-
-### Native code generation
-
-* Missing
-
-## Implementation Details
-
-The compiler does a full program compile, the linker step is part of the compilation.  It knows all functions during the compilation run and includes only reachable code in the output.  Source files are added to the build with the help of a pragma:
-		
-    #pragma compile("stdio.c")
-
-
-The byte code interpreter is compiled by the compiler itself and placed in the source file "crt.c".  Functions implementing byte codes are marked with a pragma:
-
-    #pragma	bytecode(BC_CONST_P8, inp_const_p8)
-
-The functions are written in 6502 assembly with the __asm keyword
-
-    __asm inp_const_p8
-    {
-    lda	(ip), y
-    tax
-    iny
-    lda	(ip), y
-    sta	$00, x
-    lda	#0
-    sta	$01, x
-    iny
-    jmp	startup.exec
-    }
-
-The current byte code program counter is (ip),y. The interpreter loop guarantees that y is always <= 128 and can thus be used to index the additional byte code arguments without the need to check the 16 bit pointer.  The interpreter loop itself is quite compact and takes 21 cycles (including the final jump of the byte code function itself).  Moving it to zero page would reduce this by another two cycles but is most likely not worth the waste of temporary space.
-
-    exec:
-        lda	(ip), y
-        sta	execjmp + 1
-        iny		
-        bmi	incip	
-    execjmp:
-        jmp 	(0x0900)
-
-The intermediate code generator assumes a large number of registers so the zero page is used for this purpose.  The allocation is not yet final:
-
-* **0x02-0x02** spilling of y register
-* **0x03-0x09** workspace for mul/div and floating point routines
-* **0x19-0x1a** instruction pointer
-* **0x1b-0x1e** integer and floating point accumulator
-* **0x1f-0x22** pointers for indirect addressing
-* **0x23-0x24** stack pointer
-* **0x25-0x26** frame pointer
-* **0x43-0x52** caller saved registers
-* **0x53-0x8f** callee saved registers
 
+[Roguebot](https://drmortalwombat.itch.io/roguebot)
 
+[Shallow Domains](https://drmortalwombat.itch.io/shallow-domains)
 
+[Veggies vs Undead](https://drmortalwombat.itch.io/veggies-vs-undead)
 
 

autotest/array2stringinittest.c

@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+char s[25][41] = {"Q QQ   QQQQQ        QQQQQQQQQQQQQ",
+				  "              QQQQQQQQQQQQQQQQQQQQQQQQQQ",
+				  "QQQQQQQQ",
+				  "                       QQQQQQQQQQQQQQQQQ",
+				  "QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
+				  "QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
+				  "",
+				  "",
+				  "",
+				  "                QQQQQQQQQQQQQQQQQQQQQQQQ",
+				  "QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
+				  "QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
+				  "QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
+				  "QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
+				  "QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
+				  "QQQQQQQQQ",
+				  "",
+				  "",
+				  "",
+				  "",
+				  "",
+				  "",
+				  "",
+				  "",
+				  "                          QQQQQQQQQQQQQQ"};
+
+int main() 
+{
+	int i=0, sum = 0;
+	for (unsigned char i = 0; i < 25; i++)
+	{
+		int j = 0;
+		while (s[i][j])
+		{
+			sum += s[i][j] & 3;
+			j++;
+		}
+	}
+	
+	assert(sum == 391);
+
+	return 0;
+}

autotest/arrayconstruct.cpp

@@ -0,0 +1,152 @@
+#include <assert.h>
+
+int t, n, m, k;
+
+struct C1
+{	
+	int a;
+
+	C1(void);
+	~C1(void);
+	C1(const C1 & c);
+	C1 & operator=(const C1 & c);
+};
+
+struct C2
+{
+	C1		nc[10], mc[20];
+};
+
+C1::C1(void)
+{
+	a = 1;
+	n++;
+	t++;
+}
+
+C1::C1(const C1 & c)
+{
+	a = c.a;
+	k++;
+	t++;
+}
+
+C1 & C1::operator=(const C1 & c)
+{
+	a = c.a;
+	m++;
+	return *this;
+}
+
+C1::~C1(void)
+{
+	t--;
+}
+
+void test_local_init(void)
+{
+	n = 0;
+
+	{
+		C1	c[10];
+	}
+
+	assert(n == 10 && t == 0);
+}
+
+void test_member_init(void)
+{
+	n = 0;
+
+	{
+		C2		d;
+	}
+
+	assert(n == 30 && t == 0);
+}
+
+void test_member_array_init(void)
+{
+	n = 0;
+
+	{
+		C2		d[5];
+	}
+
+	assert(n == 150 && t == 0);
+}
+
+void test_local_copy(void)
+{
+	n = 0;
+	k = 0;
+
+	{
+		C1	c[10];
+		C1	d(c[4]);
+	}
+
+	assert(n == 10 && k == 1 && t == 0);
+}
+
+void test_member_copy(void)
+{
+	n = 0;
+	k = 0;
+
+	{
+		C2		d;
+		C2		e(d);
+	}
+
+	assert(n == 30 && k == 30 && t == 0);
+}
+
+void test_local_assign(void)
+{
+	n = 0;
+	k = 0;
+	m = 0;
+
+	{
+		C1	c[10];
+		C1	d[5];
+
+		d[4] = c[2];
+	}
+
+	assert(n == 15 && k == 0 && m == 1 && t == 0);
+}
+
+void test_member_assign(void)
+{
+	n = 0;
+	k = 0;
+	m = 0;
+
+	{
+		C2		d;
+		C2		e;
+		e = d;
+	}
+
+	assert(n == 60 && k == 0 && m == 30 && t == 0);
+}
+
+
+int main(void)
+{
+	test_local_init();
+	test_member_init();
+
+	test_member_array_init();
+
+	test_local_copy();
+	test_member_copy();
+
+	test_local_assign();
+	test_member_assign();
+
+	return 0;
+}
+

autotest/arrayindexintrangecheck.c

@@ -0,0 +1,22 @@
+int a[10];
+
+int get(int i)
+{
+	return a[i];
+}
+
+void put(int i, int x)
+{
+	a[i] = x;
+}
+
+int main(void)
+{
+	for(int j=0; j<10; j++)
+		put(j, j);
+	int s = -45;
+	for(int j=0; j<10; j++)
+		s += get(j);
+	return s;
+}
+

autotest/arrayinittest.c

@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <assert.h>
+
+int fg[15] = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610};
+
+int main(void)
+{
+	int fl[15] = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610};
+
+	int	sg = 0, sl = 0;
+
+	for(int i=0; i<15; i++)
+	{
+		sl += fl[i];
+		sg += fg[i];
+	}
+
+	assert(sl == 1596);
+	assert(sg == 1596);
+	
+	printf("%d %d\n", sl, sg);
+	return 0;
+}

autotest/arrayoffsetindex.c

@@ -0,0 +1,20 @@
+
+
+int a(int * p, int x)
+{
+	int y = x + 3;
+	
+	p[y] = 1;
+	p[y + 1] = 2;
+	p[y + 2] = 3;
+	p[y + 3] = 4;
+	
+	return p[y] + p[y + 1] + p[y + 2] + p[y + 3];	
+}
+
+int main(void)
+{
+	int	t[16];
+	
+	return a(t, 4) - 10;
+}

autotest/arraytest.c

@@ -11,13 +11,93 @@ int sum(int * a, int s)
 	return sum;
 }
 
+void copy(int * d, const int * s, int n)
+{
+	for(int i=0; i<n ; i++)
+		d[i] = s[i];
+}
+
+void reverse(int * d, const int * s, int n)
+{
+	for(int i=0; i<n ; i++)
+		d[i] = s[n - i - 1];
+}
+
+int sumb(int * a, char s)
+{
+	int sum = 0;
+	for(char i=0; i<s; i++)
+	{
+		sum += a[i];
+	}
+	return sum;
+}
+
+void copyb(int * d, const int * s, char n)
+{
+	for(char i=0; i<n ; i++)
+		d[i] = s[i];
+}
+
+void reverseb(int * d, const int * s, char n)
+{
+	for(char i=0; i<n ; i++)
+		d[i] = s[n - i - 1];
+}
+
+long suml(long * a, char s)
+{
+	long sum = 0;
+	for(char i=0; i<s; i++)
+	{
+		sum += a[i];
+	}
+	return sum;
+}
+
+void copyl(long * d, const long * s, char n)
+{
+	for(char i=0; i<n ; i++)
+		d[i] = s[i];
+}
+
+void reversel(long * d, const long * s, char n)
+{
+	for(char i=0; i<n ; i++)
+		d[i] = s[n - i - 1];
+}
+
 int main(void)
 {
-	int	a[100];
+	int	a[100], b[100], c[100];
+	long al[100], bl[100], cl[100];
+
 	for(int i=0; i<100; i++)
 	{
 		a[i] = i % 10;
+		al[i] = i % 10;
 	}
+
 	assert(sum(a, 100) == 450);
+
+	copy(b, a, 100);
+	assert(sum(b, 100) == 450);
+	reverse(c, a, 100);
+	assert(sum(c, 100) == 450);
+	assert(sumb(a, 100) == 450);
+	copyb(b, a, 100);
+	assert(sumb(b, 100) == 450);
+
+	reverseb(c, a, 100);
+	assert(sumb(c, 100) == 450);
+
+	assert(suml(al, 100) == 450);
+
+	copyl(bl, al, 100);
+	assert(suml(bl, 100) == 450);
+
+	reversel(cl, al, 100);
+	assert(suml(cl, 100) == 450);
+
 	return 0;
 }

autotest/arraytestfloat.c

@@ -8,6 +8,7 @@ float sum(float * a, int s)
 	{
 		sum += a[i];
 	}
+
 	return sum;
 }
 
@@ -18,6 +19,7 @@ int main(void)
 	{
 		a[i] = i % 10;
 	}
+	
 	assert(sum(a, 100) == 450);
 	return 0;
 }

autotest/arrparam.c

@@ -0,0 +1,16 @@
+
+int a(char p[100])
+{
+	int s = 0;
+	for(int i=0; i<100; i++)
+		s += p[i];
+	return s;
+}
+
+int main(void)
+{
+	char c[100];
+	for(int i=0; i<100; i++)
+		c[i] = i;
+	return a(c) - 4950;
+}

autotest/asmtest.c

@@ -0,0 +1,76 @@
+#include <stdio.h>
+#include <assert.h>
+
+int asum(int a, int b)
+{
+	return __asm 
+	{
+		clc
+		lda	a
+		adc	b
+		sta	accu
+		lda	a + 1
+		adc	b + 1
+		sta	accu + 1
+	};
+}
+
+int bsum(int a, int b)
+{
+	puts("Hello\n");
+
+	return __asm 
+	{
+		clc
+		lda	a
+		adc	b
+		sta	accu
+		lda	a + 1
+		adc	b + 1
+		sta	accu + 1
+	};
+}
+
+int b, t[10];
+
+int bsome(int x)
+{
+	return x;
+}
+
+
+int qsum(int a, int (* c)(int))
+{
+	char n = 0;
+	b = 0;
+	for(int i=0; i<a; i++)
+	{
+		int j = c((char)i);
+		__asm
+		{
+			clc
+			lda	j
+			adc b
+			sta b
+			lda j + 1
+			adc b + 1
+			sta b + 1
+		}
+		t[n] += i;
+		n = (n + 1) & 7;
+	}
+	return b;
+}
+
+int main(void)
+{
+	int	x = asum(7007, 8008);
+	int	y = bsum(4004, 9009);
+
+	assert(x == 7007 + 8008 && y == 4004 + 9009);
+	assert(qsum(10, bsome) == 45);
+	assert(qsum(200, bsome) == 19900);
+
+	return 0;
+}
+

autotest/autorefreturn.cpp

@@ -0,0 +1,77 @@
+#include <stdio.h>
+#include <assert.h>
+
+struct X
+{
+	char	t;
+	long	l;
+};
+
+__striped	X	xs[16];
+X	xf[16];
+char xp;
+
+__noinline long tt(long n)
+{
+	return n;
+}
+
+inline auto & tas(void)
+{
+	return xs[xp].l;
+}
+
+inline auto & taf(void)
+{
+	return xf[xp].l;
+}
+
+long ts(char n)
+{
+	return tt(tas());
+}
+
+long tf(char n)
+{
+	return tt(taf());
+}
+
+inline auto bas(void)
+{
+	return xs[xp].l;
+}
+
+inline auto baf(void)
+{
+	return xs[xp].l;
+}
+
+long bs(char n)
+{
+	return tt(bas());
+}
+
+long bf(char n)
+{
+	return tt(baf());
+}
+
+int main(void)
+{
+	for(char i=0; i<16; i++)
+	{
+		xs[i].l = i * i;
+		xf[i].l = i * i;
+	}
+
+	for(char i=0; i<16; i++)
+	{
+		xp = i;
+		assert(ts(0) == i * i);
+		assert(tf(0) == i * i);
+		assert(bs(0) == i * i);
+		assert(bf(0) == i * i);
+	}
+
+	return 0;
+}

autotest/autotest.bat

@@ -1,36 +1,400 @@
-@echo off
+rem @echo off
 
-..\release\oscar64 -i=../include -rt=../include/crt.c -e stdlibtest.c
+@call :test rolrortest.cpp
-if %errorlevel% neq 0 goto :error
+@if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -i=../include -rt=../include/crt.c -e testint16.c
+@call :test bitfields.cpp
-if %errorlevel% neq 0 goto :error
+@if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -i=../include -rt=../include/crt.c -e recursiontest.c
+@call :testn autorefreturn.cpp
-if %errorlevel% neq 0 goto :error
+@if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -i=../include -rt=../include/crt.c -e strcmptest.c
+@call :testh opp_string.cpp
-if %errorlevel% neq 0 goto :error
+@if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -i=../include -rt=../include/crt.c -e arraytest.c
+@call :testh opp_array.cpp
-if %errorlevel% neq 0 goto :error
+@if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -i=../include -rt=../include/crt.c -e arraytestfloat.c
+@call :testh opp_vector.cpp
-if %errorlevel% neq 0 goto :error
+@if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -i=../include -rt=../include/crt.c -e optiontest.c
+@call :testh opp_static_vector.cpp
-if %errorlevel% neq 0 goto :error
+@if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -i=../include -rt=../include/crt.c -e floatcmptest.c
+@call :testh opp_vector_string.cpp
-if %errorlevel% neq 0 goto :error
+@if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -i=../include -rt=../include/crt.c -e floatmultest.c
+@call :testh opp_string_init.cpp
-if %errorlevel% neq 0 goto :error
+@if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -i=../include -rt=../include/crt.c -e staticconsttest.c
+@call :testh opp_streamtest.cpp
-if %errorlevel% neq 0 goto :error
+@if %errorlevel% neq 0 goto :error
+
+@call :testh opp_pairtest.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testh opp_parts.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testh opp_list.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testn opp_functional.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testh operatoroverload.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testh virtualdestruct.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testh vcalltest.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testh vcalltree.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testh constructortest.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testn copyconstructor.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testh copyassign.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testh arrayconstruct.cpp
+@if %errorlevel% neq 0 goto :error
+
+@call :testh stdlibtest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test mathtest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test testint16.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test testint32.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test testint16mul.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test testsigned16mul.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test testsigned16div.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test recursiontest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test copyinitmove.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test fastcalltest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test strlen.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test strcmptest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test strcmptest2.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test memmovetest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test arraytest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test arraytestfloat.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test optiontest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test floatcmptest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test floatmultest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test floatinttest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test staticconsttest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test arrayinittest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test arrayindexintrangecheck.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test array2stringinittest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test testint16cmp.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test testint8cmp.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test testint32cmp.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test mixsigncmptest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test testinterval.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test cmprangeshortcuttest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test floatstringtest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test sprintftest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test qsorttest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :testn plasma.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test loopdomtest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test loopboundtest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test byteindextest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test asmtest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :testb bitshifttest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test arrparam.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test bsstest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test copyintvec.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test divmodtest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test divmod32test.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test fixmathtest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test enumswitch.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test incvector.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test structoffsettest2.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test funcvartest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test funcarraycall.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test structassigntest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test structmembertest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test structarraycopy.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test randsumtest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test longcodetest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test scrolltest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test charwintest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test linetest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test ptrinittest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test ptrarraycmptest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test cplxstructtest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :testn stripedarraytest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :testn mmultest.c
+@if %errorlevel% neq 0 goto :error
+
+@call :test tileexpand.cpp
+@if %errorlevel% neq 0 goto :error
+
+@exit /b 0
 
-exit /b 0
 :error
 echo Failed with error #%errorlevel%.
 exit /b %errorlevel%
+
+:testh
+..\bin\oscar64 -e -bc %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -bc %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -n -dHEAPCHECK %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -xz -Oz -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -Oo -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -Ox -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O0 -bc %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O0 -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -Os -bc %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -Os -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O3 -bc %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O3 -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O3 -n -dHEAPCHECK %~1
+@if %errorlevel% neq 0 goto :error
+
+@exit /b 0
+
+:test
+..\bin\oscar64 -e -bc %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -bc %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O0 -bc %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O0 -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -Os -bc %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -Os -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O3 -bc %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O3 -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -xz -Oz -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -Oo -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -Ox -n %~1
+@if %errorlevel% neq 0 goto :error
+
+@exit /b 0
+
+:testb
+..\bin\oscar64 -e -bc %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -bc -O2 %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -bc -O0 %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -bc -Os %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -bc -O3 %~1
+@if %errorlevel% neq 0 goto :error
+
+@exit /b 0
+
+:testn
+..\bin\oscar64 -e -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O0 -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -Os -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O3 -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -xz -Oz -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -Oo -n %~1
+@if %errorlevel% neq 0 goto :error
+
+..\bin\oscar64 -e -O2 -Ox -n %~1
+@if %errorlevel% neq 0 goto :error
+
+@exit /b 0

autotest/bitfields.cpp

@@ -0,0 +1,354 @@
+#include <assert.h>
+
+struct A
+{
+	char	x : 4;
+	char	y : 1;
+	char	z : 3;
+};
+
+A a = {7, 1, 2};
+
+void test_char_fit(void)
+{
+	assert(a.x == 7);
+	assert(a.y == 1);
+	assert(a.z == 2);
+	assert(sizeof(A) == 1);
+
+	for(int i=0; i<16; i++)
+	{
+		a.x = i;
+		a.y = 0;
+		a.z = 3;
+		assert(a.x == i);
+		assert(a.y == 0);
+		assert(a.z == 3);		
+	}
+}
+
+struct B
+{
+	char	x : 6;
+	char	y : 6;
+	char	z : 6;
+	char	w : 6;
+};
+
+B 	b = {11, 22, 33, 44};
+
+void test_char_cross(void)
+{
+	assert(b.x == 11);
+	assert(b.y == 22);
+	assert(b.z == 33);
+	assert(b.w == 44);
+	assert(sizeof(B) == 3);
+
+	for(int i=0; i<64; i++)
+	{
+		b.x = i * 1;
+		b.y = i * 3;
+		b.z = i * 5;
+		b.w = i * 7;
+		assert(b.x == ((i * 1) & 0x3f));
+		assert(b.y == ((i * 3) & 0x3f));
+		assert(b.z == ((i * 5) & 0x3f));		
+		assert(b.w == ((i * 7) & 0x3f));		
+	}
+}
+
+struct C
+{
+	unsigned	x : 4;
+	unsigned	y : 1;
+	unsigned	z : 3;
+};
+
+C c = {7, 1, 2};
+
+void test_word_fit(void)
+{
+	assert(c.x == 7);
+	assert(c.y == 1);
+	assert(c.z == 2);
+	assert(sizeof(C) == 1);
+
+	for(int i=0; i<16; i++)
+	{
+		c.x = i;
+		c.y = 0;
+		c.z = 3;
+		assert(c.x == i);
+		assert(c.y == 0);
+		assert(c.z == 3);		
+	}
+}
+
+struct D
+{
+	unsigned	x : 10;
+	unsigned	y : 10;
+	unsigned	z : 10;
+	unsigned	w : 10;
+};
+
+D 	d = {111, 222, 333, 444};
+
+void test_word_cross(void)
+{
+	assert(d.x == 111);
+	assert(d.y == 222);
+	assert(d.z == 333);
+	assert(d.w == 444);
+	assert(sizeof(D) == 5);
+
+	for(int i=0; i<1024; i++)
+	{
+		d.x = i * 1;
+		d.y = i * 3;
+		d.z = i * 5;
+		d.w = i * 7;
+		assert(d.x == ((i * 1) & 0x3ff));
+		assert(d.y == ((i * 3) & 0x3ff));
+		assert(d.z == ((i * 5) & 0x3ff));		
+		assert(d.w == ((i * 7) & 0x3ff));		
+	}
+}
+
+struct E
+{
+	unsigned long	x : 4;
+	unsigned long	y : 1;
+	unsigned long	z : 3;
+};
+
+E e = {7, 1, 2};
+
+void test_dword_fit(void)
+{
+	assert(e.x == 7);
+	assert(e.y == 1);
+	assert(e.z == 2);
+	assert(sizeof(E) == 1);
+
+	for(int i=0; i<16; i++)
+	{
+		e.x = i;
+		e.y = 0;
+		e.z = 3;
+		assert(e.x == i);
+		assert(e.y == 0);
+		assert(e.z == 3);		
+	}
+}
+
+struct F
+{
+	unsigned long	x : 20;
+	unsigned long	y : 20;
+	unsigned long	z : 20;
+	unsigned long	w : 20;
+};
+
+F 	f = {111111UL, 222222UL, 333333UL, 444444UL};
+
+void test_dword_cross(void)
+{
+	assert(f.x == 111111UL);
+	assert(f.y == 222222UL);
+	assert(f.z == 333333UL);
+	assert(f.w == 444444UL);
+	assert(sizeof(F) == 10);
+
+	for(int i=0; i<1024; i++)
+	{
+		f.x = i * 11UL;
+		f.y = i * 33UL;
+		f.z = i * 55UL;
+		f.w = i * 77UL;
+		assert(f.x == ((i * 11UL) & 0xfffffUL));
+		assert(f.y == ((i * 33UL) & 0xfffffUL));
+		assert(f.z == ((i * 55UL) & 0xfffffUL));		
+		assert(f.w == ((i * 77UL) & 0xfffffUL));		
+	}
+}
+
+struct G
+{
+	signed char x : 1;
+	signed char y : 5;
+	signed char z : 2;
+};
+
+G 	g = {0, -1, -2};
+
+void test_char_signed(void)
+{
+	assert(g.x ==  0);
+	assert(g.y == -1);
+	assert(g.z == -2);
+	assert(sizeof(G) == 1);
+
+	for(int i=-16; i<16; i++)
+	{
+		g.x = -1;
+		g.y = i;
+		g.z = 1;
+		assert(g.x == -1);
+		assert(g.y == i);
+		assert(g.z == 1);		
+	}
+}
+
+struct H
+{
+	int	x : 10;
+	int	y : 10;
+	int	z : 10;
+	int	w : 10;
+};
+
+H 	h = {111, -222, -333, 444};
+
+void test_word_signed(void)
+{
+	assert(h.x == 111);
+	assert(h.y == -222);
+	assert(h.z == -333);
+	assert(h.w == 444);
+	assert(sizeof(H) == 5);
+
+	for(int i=-32; i<32; i++)
+	{
+		h.x = i * 1;
+		h.y = i * 3;
+		h.z = i * 5;
+		h.w = i * 7;
+		assert(h.x == i * 1);
+		assert(h.y == i * 3);
+		assert(h.z == i * 5);		
+		assert(h.w == i * 7);		
+	}
+}
+
+void test_inc_char_fit(void)
+{
+	A ai;
+	ai.x = 7;
+	ai.y = 1;
+	ai.z = 2;
+
+	for(int i=0; i<16; i++)
+	{
+		assert(ai.x == ((7 + i) & 15));
+		assert(ai.y == ((1 + i) & 1));
+		assert(ai.z == ((2 + i) & 7));		
+		ai.x++;
+		ai.y++;
+		ai.z++;
+	}
+}
+
+void test_inc_char_cross(void)
+{
+	B bi;
+	bi.x = 11;
+	bi.y = 22;
+	bi.z = 33;
+	bi.w = 44;
+
+	for(int i=0; i<64; i++)
+	{
+		assert(bi.x == ((11 + i) & 0x3f));
+		assert(bi.y == ((22 + i) & 0x3f));
+		assert(bi.z == ((33 + i) & 0x3f));		
+		assert(bi.w == ((44 + i) & 0x3f));		
+		bi.x++;
+		bi.y++;
+		bi.z++;
+		bi.w++;
+	}
+}
+
+void test_add_char_cross(void)
+{
+	B bi= {0};
+	bi.x = 11;
+	bi.y = 22;
+	bi.z = 33;
+	bi.w = 44;
+
+	for(int i=0; i<64; i++)
+	{
+		assert(bi.x == ((11 +  5 * i) & 0x3f));
+		assert(bi.y == ((22 + 21 * i) & 0x3f));
+		assert(bi.z == ((33 -  4 * i) & 0x3f));		
+		assert(bi.w == ((44 - 11 * i) & 0x3f));		
+		bi.x += 5;
+		bi.y += 21;
+		bi.z -= 4;
+		bi.w -= 11;
+	}
+}
+
+void test_add_word_fit(void)
+{
+	C ci = {0};
+
+	ci.x = 7;
+	ci.y = 1;
+	ci.z = 2;
+
+	for(int i=0; i<16; i++)
+	{
+		assert(ci.x == ((7 +  5 * i) & 15));
+		assert(ci.y == ((1 + 21 * i) &  1));
+		assert(ci.z == ((2 -  4 * i) &  7));		
+		ci.x += 5;
+		ci.y += 21;
+		ci.z -= 4;
+	}
+}
+
+void test_add_word_cross(void)
+{
+	D di  = {0};
+
+	di.x = 111;
+	di.y = 222;
+	di.z = 333;
+	di.w = 444;
+
+	for(int i=0; i<1024; i++)
+	{
+		assert(di.x == ((111 +  5 * i) & 0x3ff));
+		assert(di.y == ((222 + 21 * i) & 0x3ff));
+		assert(di.z == ((333 -  4 * i) & 0x3ff));		
+		assert(di.w == ((444 - 11 * i) & 0x3ff));		
+		di.x += 5;
+		di.y += 21;
+		di.z -= 4;
+		di.w -= 11;
+	}
+}
+int main(void)
+{
+	test_char_fit();
+	test_char_cross();
+	test_word_fit();
+	test_word_cross();
+	test_dword_fit();
+	test_dword_cross();
+	test_char_signed();
+	test_word_signed();
+
+	test_inc_char_fit();
+	test_inc_char_cross();
+	test_add_char_cross();
+
+	test_add_word_fit();
+	test_add_word_cross();
+
+	return 0;
+}

autotest/bitshifttest.c

@@ -0,0 +1,414 @@
+#include <stdio.h>
+#include <assert.h>
+
+#pragma region( main, 0x0a00, 0xd000, , , {code, data, bss, heap, stack} )
+
+unsigned shl1b(int n)
+{
+	return 1 << n;
+}
+
+unsigned shl1n(int n)
+{
+	return 1 << n;
+}
+
+#pragma native(shl1n)
+
+unsigned shr1b(int n)
+{
+	return 0x8000 >> n;
+}
+
+unsigned shr1n(int n)
+{
+	return 0x8000 >> n;
+}
+
+#pragma native(shr1n)
+
+unsigned shl4b(int n)
+{
+	return 0x0010 << n;
+}
+
+unsigned shl4n(int n)
+{
+	return 0x0010 << n;
+}
+
+#pragma native(shl4n)
+
+unsigned shr4b(int n)
+{
+	return 0x0800 >> n;
+}
+
+unsigned shr4n(int n)
+{
+	return 0x0800 >> n;
+}
+
+#pragma native(shr4n)
+
+
+unsigned shl8b(int n)
+{
+	return 0x0100 << n;
+}
+
+unsigned shl8n(int n)
+{
+	return 0x0100 << n;
+}
+
+#pragma native(shl8n)
+
+unsigned shr8b(int n)
+{
+	return 0x0080 >> n;
+}
+
+unsigned shr8n(int n)
+{
+	return 0x0080 >> n;
+}
+
+#pragma native(shr8n)
+
+
+void shl8xb(unsigned char xu, signed char xi)
+{
+	unsigned char 	ua[16];
+	signed char 	ia[16];
+#assign s 0
+#repeat
+	ua[s] = xu << s;
+	ia[s] = xi << s;
+#assign s s + 1
+#until s == 16	
+
+	for(int i=0; i<16; i++)
+	{
+		assert(ua[i] == (unsigned char)(xu << i));
+		assert(ia[i] == (signed char)(xi << i));
+	}
+}
+
+void shr8xb(unsigned char xu, signed char xi)
+{
+	unsigned char	ua[16];
+	signed char		ia[16];
+#assign s 0
+#repeat
+	ua[s] = xu >> s;
+	ia[s] = xi >> s;
+#assign s s + 1
+#until s == 16	
+
+	for(int i=0; i<16; i++)
+	{
+		assert(ua[i] == (unsigned char)(xu >> i));
+		assert(ia[i] == (signed char)(xi >> i));
+	}
+}
+
+void shl8xn(unsigned char xu, signed char xi)
+{
+	unsigned char	ua[16];
+	signed char	    ia[16];
+#assign s 0
+#repeat
+	ua[s] = xu << s;
+	ia[s] = xi << s;
+#assign s s + 1
+#until s == 16	
+
+	for(int i=0; i<16; i++)
+	{
+		assert(ua[i] == (unsigned char)(xu << i));
+		assert(ia[i] == (signed char)(xi << i));
+	}
+}
+
+void shr8xn(unsigned char xu, signed char xi)
+{
+	unsigned char	ua[16];
+	signed char		ia[16];
+#assign s 0
+#repeat
+	ua[s] = xu >> s;
+	ia[s] = xi >> s;
+#assign s s + 1
+#until s == 16	
+
+	for(int i=0; i<16; i++)
+	{
+		assert(ua[i] == (unsigned char)(xu >> i));
+		assert(ia[i] == (signed char)(xi >> i));
+	}
+}
+
+#pragma native(shl8xn)
+#pragma native(shr8xn)
+
+
+
+
+void shl16b(unsigned xu, int xi)
+{
+	unsigned	ua[16];
+	int			ia[16];
+#assign s 0
+#repeat
+	ua[s] = xu << s;
+	ia[s] = xi << s;
+#assign s s + 1
+#until s == 16	
+
+	for(int i=0; i<16; i++)
+	{
+		assert(ua[i] == xu << i);
+		assert(ia[i] == xi << i);
+	}
+}
+
+void shr16b(unsigned xu, int xi)
+{
+	unsigned	ua[16];
+	int			ia[16];
+#assign s 0
+#repeat
+	ua[s] = xu >> s;
+	ia[s] = xi >> s;
+#assign s s + 1
+#until s == 16	
+
+	for(int i=0; i<16; i++)
+	{
+		assert(ua[i] == xu >> i);
+		assert(ia[i] == xi >> i);
+	}
+}
+
+void shl16n(unsigned xu, int xi)
+{
+	unsigned	ua[16];
+	int			ia[16];
+#assign s 0
+#repeat
+	ua[s] = xu << s;
+	ia[s] = xi << s;
+#assign s s + 1
+#until s == 16	
+
+	for(int i=0; i<16; i++)
+	{
+		assert(ua[i] == xu << i);
+		assert(ia[i] == xi << i);
+	}
+}
+
+void shr16n(unsigned xu, int xi)
+{
+	unsigned	ua[16];
+	int			ia[16];
+#assign s 0
+#repeat
+	ua[s] = xu >> s;
+	ia[s] = xi >> s;
+#assign s s + 1
+#until s == 16	
+
+	for(int i=0; i<16; i++)
+	{
+		assert(ua[i] == xu >> i);
+		assert(ia[i] == xi >> i);
+	}
+}
+
+#pragma native(shl16n)
+#pragma native(shr16n)
+
+
+void shl32b(unsigned long xu, long xi)
+{
+	unsigned long	ua[32];
+	long			ia[32];
+#assign s 0
+#repeat
+	ua[s] = xu << s;
+	ia[s] = xi << s;
+#assign s s + 1
+#until s == 32
+
+	for(int i=0; i<32; i++)
+	{
+		assert(ua[i] == xu << i);
+		assert(ia[i] == xi << i);
+	}
+}
+
+void shr32b(unsigned long xu, long xi)
+{
+	unsigned long	ua[32];
+	long			ia[32];
+#assign s 0
+#repeat
+	ua[s] = xu >> s;
+	ia[s] = xi >> s;
+#assign s s + 1
+#until s == 32
+
+	for(int i=0; i<32; i++)
+	{
+		assert(ua[i] == xu >> i);
+		assert(ia[i] == xi >> i);
+	}
+}
+
+void shl32n(unsigned long xu, long xi)
+{
+	unsigned long	ua[32];
+	long			ia[32];
+#assign s 0
+#repeat
+	ua[s] = xu << s;
+	ia[s] = xi << s;
+#assign s s + 1
+#until s == 32	
+
+	for(int i=0; i<32; i++)
+	{
+		assert(ua[i] == xu << i);
+		assert(ia[i] == xi << i);
+	}
+}
+
+void shr32n(unsigned long xu, long xi)
+{
+	unsigned long	ua[32];
+	long			ia[32];
+#assign s 0
+#repeat
+	ua[s] = xu >> s;
+	ia[s] = xi >> s;
+#assign s s + 1
+#until s == 32
+
+	for(int i=0; i<32; i++)
+	{
+		assert(ua[i] == xu >> i);
+		assert(ia[i] == xi >> i);
+	}
+}
+
+void shl1_32n(void)
+{
+	static const unsigned long m[] = {
+		#for(i, 32) 1ul << i,
+	};
+
+	for(int i=0; i<32; i++)
+	{
+		assert(1ul << i == m[i]);
+	}
+}
+
+#pragma native(shl32n)
+#pragma native(shr32n)
+
+int main(void)
+{
+	*(volatile char *)0x01 = 0x36;
+
+	for(int i=0; i<32; i++)
+	{
+		printf("1: %.4x : %.4x | %.4x : %.4x\n", shl1b(i), shl1n(i), shr1b(i), shr1n(i));
+		assert(shl1b(i) == shl1n(i));
+		assert(shr1b(i) == shr1n(i));
+	}
+
+	for(int i=0; i<32; i++)
+	{
+		printf("4: %.4x : %.4x | %.4x : %.4x\n", shl4b(i), shl4n(i), shr4b(i), shr4n(i));
+		assert(shl4b(i) == shl4n(i));
+		assert(shr4b(i) == shr4n(i));
+	}
+
+	for(int i=0; i<32; i++)
+	{
+		printf("8: %.4x : %.4x | %.4x : %.4x\n", shl8b(i), shl8n(i), shr8b(i), shr8n(i));
+		assert(shl8b(i) == shl8n(i));
+		assert(shr8b(i) == shr8n(i));
+	}
+
+	shl8xb(0x00, 0x00);
+	shl8xb(0xff, 0xff);
+	shl8xb(0x34, 0x34);
+	shl8xb(0xdc, 0xdc);
+
+	shr8xb(0x00, 0x00);
+	shr8xb(0xff, 0xff);
+	shr8xb(0x34, 0x34);
+	shr8xb(0xdc, 0xdc);
+
+	shl8xn(0x00, 0x00);
+	shl8xn(0xff, 0xff);
+	shl8xn(0x34, 0x34);
+	shl8xn(0xdc, 0xdc);
+
+	shr8xn(0x00, 0x00);
+	shr8xn(0xff, 0xff);
+	shr8xn(0x34, 0x34);
+	shr8xn(0xdc, 0xdc);
+
+	shl16b(0x0000, 0x0000);
+	shl16b(0xffff, 0xffff);
+	shl16b(0x1234, 0x1234);
+	shl16b(0xfedc, 0xfedc);
+
+	shr16b(0x0000, 0x0000);
+	shr16b(0xffff, 0xffff);
+	shr16b(0x1234, 0x1234);
+	shr16b(0xfedc, 0xfedc);
+
+	shl16n(0x0000, 0x0000);
+
+	shl16n(0xffff, 0xffff);
+	shl16n(0x1234, 0x1234);
+	shl16n(0xfedc, 0xfedc);
+
+	shr16n(0x0000, 0x0000);
+	shr16n(0xffff, 0xffff);
+	shr16n(0x1234, 0x1234);
+	shr16n(0xfedc, 0xfedc);
+
+	shl32b(0x00000000UL, 0x00000000L);
+	shl32b(0x00000001UL, 0x00000001L);
+	shl32b(0xffffffffUL, 0xffffffffL);
+	shl32b(0x12345678UL, 0x12345678L);
+	shl32b(0xfedcba98UL, 0xfedcba98L);
+
+	shr32b(0x00000000UL, 0x00000000L);
+	shr32b(0x00000001UL, 0x00000001L);
+	shr32b(0xffffffffUL, 0xffffffffL);
+	shr32b(0x12345678UL, 0x12345678L);
+	shr32b(0xfedcba98UL, 0xfedcba98L);
+
+	shl32n(0x00000000UL, 0x00000000L);
+	shl32n(0x00000001UL, 0x00000001L);
+	shl32n(0xffffffffUL, 0xffffffffL);
+	shl32n(0x12345678UL, 0x12345678L);
+	shl32n(0xfedcba98UL, 0xfedcba98L);
+
+	shr32n(0x00000000UL, 0x00000000L);
+	shr32n(0x00000001UL, 0x00000001L);
+	shr32n(0xffffffffUL, 0xffffffffL);
+	shr32n(0x12345678UL, 0x12345678L);
+	shr32n(0xfedcba98UL, 0xfedcba98L);
+
+	shl1_32n();
+
+	return 0;
+}

autotest/bsstest.c

@@ -0,0 +1,27 @@
+
+#include <string.h>
+
+char ch[100];
+char p[] = "HELLO";
+int v[10];
+int w[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+
+int sum(int * k)
+{
+	int s = 0;
+	for(int i=0; i<10; i++)
+		s += k[i];
+	return s;	
+}
+
+int main(void)
+{
+	strcpy(ch, p);
+	strcat(ch, " WORLD");
+
+	for(int i=0; i<10; i++)
+		v[i] = w[i];
+	
+	return strcmp(ch, "HELLO WORLD") + sum(v) - 55;
+}
+

autotest/byteindextest.c

@@ -0,0 +1,18 @@
+
+#include <stdio.h>
+#include <assert.h>
+
+char a[20];
+
+int main(void)
+{
+	for(char i=0; i<20; i++)
+		a[i] = i;
+	char x = 0;
+	for(char i=0; i<20; i++)
+		x += a[i];
+
+	assert(x == 190);
+
+	return 0;
+}

autotest/charwintest.c

@@ -0,0 +1,64 @@
+#include <c64/charwin.h>
+#include <assert.h>
+#include <stdio.h>
+
+int main(void)
+{
+	CharWin	cw;
+
+	cwin_init(&cw, (char *)0x0400, 2, 2, 32, 20);
+
+	cwin_clear(&cw);
+
+	for(int y=0; y<20; y++)
+	{
+		for(int x=0; x<32; x++)
+		{
+			assert(cwin_getat_char_raw(&cw, x, y) == ' ');
+		}
+	}
+
+	for(int y=0; y<20; y++)
+	{
+		for(int x=0; x<32; x++)
+		{
+			cwin_putat_char(&cw, x, y, p'a' - 1 + x, 7);
+		}		
+	}
+
+
+	for(int y=0; y<20; y++)
+	{
+		for(int x=0; x<32; x++)
+		{
+			assert(cwin_getat_char(&cw, x, y) == p'a' -1 + x);
+		}		
+	}
+
+
+	for(int y=0; y<20; y++)
+	{
+		for(int x=0; x<32; x++)
+		{
+			cwin_putat_char(&cw, x, y, p'A' - 1 +  x, 8);
+		}		
+	}
+
+	for(int y=0; y<20; y++)
+	{
+		for(int x=0; x<32; x++)
+		{
+			cwin_putat_char_raw(&cw, x, y, x + 32 * y, 8);
+		}		
+	}
+
+	for(int y=0; y<8; y++)
+	{
+		for(int x=0; x<32; x++)
+		{
+			assert(cwin_getat_char_raw(&cw, x, y) == x + 32 * y);
+		}		
+	}
+
+	return 0;
+}

autotest/cmprangeshortcuttest.c

@@ -0,0 +1,298 @@
+#include <assert.h>
+
+void check_s_lt(void)
+{
+	int	a5 = 0, a10 = 0, a15 = 0;
+	
+	for(int i=5; i<15; i++)
+	{
+		if (i < 5)
+			a5++;
+		if (i < 10)
+			a10++;
+		if (i < 15)
+			a15++;
+	}
+	
+	assert(a5 == 0);
+	assert(a10 == 5);
+	assert(a15 == 10);
+}
+
+void check_s_le(void)
+{
+	int	a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
+	
+	for(int i=5; i<15; i++)
+	{
+		if (i <= 4)
+			a4++;
+		if (i <= 5)
+			a5++;
+		if (i <= 10)
+			a10++;
+		if (i <= 14)
+			a14++;
+		if (i <= 15)
+			a15++;
+	}
+	
+	assert(a4 == 0);
+	assert(a5 == 1);
+	assert(a10 == 6);
+	assert(a14 == 10);
+	assert(a15 == 10);
+}
+
+void check_s_ge(void)
+{
+	int	a5 = 0, a10 = 0, a15 = 0;
+	
+	for(int i=5; i<15; i++)
+	{
+		if (i >= 5)
+			a5++;
+		if (i >= 10)
+			a10++;
+		if (i >= 15)
+			a15++;
+	}
+	
+	assert(a5 == 10);
+	assert(a10 == 5);
+	assert(a15 == 0);
+}
+
+void check_s_gt(void)
+{
+	int	a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
+	
+	for(int i=5; i<15; i++)
+	{
+		if (i > 4)
+			a4++;
+		if (i > 5)
+			a5++;
+		if (i > 10)
+			a10++;
+		if (i > 14)
+			a14++;
+		if (i > 15)
+			a15++;
+	}
+	
+	assert(a4 == 10);
+	assert(a5 ==  9);
+	assert(a10 == 4);
+	assert(a14 == 0);
+	assert(a15 == 0);
+}
+
+void check_s_eq(void)
+{
+	int	a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
+	
+	for(int i=5; i<15; i++)
+	{
+		if (i == 4)
+			a4++;
+		if (i == 5)
+			a5++;
+		if (i == 10)
+			a10++;
+		if (i == 14)
+			a14++;
+		if (i == 15)
+			a15++;
+	}
+	
+	assert(a4 == 0);
+	assert(a5 ==  1);
+	assert(a10 == 1);
+	assert(a14 == 1);
+	assert(a15 == 0);
+}
+
+void check_s_ne(void)
+{
+	int	a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
+	
+	for(int i=5; i<15; i++)
+	{
+		if (i != 4)
+			a4++;
+		if (i != 5)
+			a5++;
+		if (i != 10)
+			a10++;
+		if (i != 14)
+			a14++;
+		if (i != 15)
+			a15++;
+	}
+	
+	assert(a4 == 10);
+	assert(a5 ==  9);
+	assert(a10 == 9);
+	assert(a14 == 9);
+	assert(a15 == 10);
+}
+
+void check_u_lt(void)
+{
+	int	a5 = 0, a10 = 0, a15 = 0;
+	
+	for(unsigned i=5; i<15; i++)
+	{
+		if (i < 5)
+			a5++;
+		if (i < 10)
+			a10++;
+		if (i < 15)
+			a15++;
+	}
+	
+	assert(a5 == 0);
+	assert(a10 == 5);
+	assert(a15 == 10);
+}
+
+void check_u_le(void)
+{
+	int	a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
+	
+	for(unsigned i=5; i<15; i++)
+	{
+		if (i <= 4)
+			a4++;
+		if (i <= 5)
+			a5++;
+		if (i <= 10)
+			a10++;
+		if (i <= 14)
+			a14++;
+		if (i <= 15)
+			a15++;
+	}
+	
+	assert(a4 == 0);
+	assert(a5 == 1);
+	assert(a10 == 6);
+	assert(a14 == 10);
+	assert(a15 == 10);
+}
+
+void check_u_ge(void)
+{
+	int	a5 = 0, a10 = 0, a15 = 0;
+	
+	for(unsigned i=5; i<15; i++)
+	{
+		if (i >= 5)
+			a5++;
+		if (i >= 10)
+			a10++;
+		if (i >= 15)
+			a15++;
+	}
+	
+	assert(a5 == 10);
+	assert(a10 == 5);
+	assert(a15 == 0);
+}
+
+void check_u_gt(void)
+{
+	int	a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
+	
+	for(unsigned i=5; i<15; i++)
+	{
+		if (i > 4)
+			a4++;
+		if (i > 5)
+			a5++;
+		if (i > 10)
+			a10++;
+		if (i > 14)
+			a14++;
+		if (i > 15)
+			a15++;
+	}
+	
+	assert(a4 == 10);
+	assert(a5 ==  9);
+	assert(a10 == 4);
+	assert(a14 == 0);
+	assert(a15 == 0);
+}
+
+void check_u_eq(void)
+{
+	int	a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
+	
+	for(unsigned i=5; i<15; i++)
+	{
+		if (i == 4)
+			a4++;
+		if (i == 5)
+			a5++;
+		if (i == 10)
+			a10++;
+		if (i == 14)
+			a14++;
+		if (i == 15)
+			a15++;
+	}
+	
+	assert(a4 == 0);
+	assert(a5 ==  1);
+	assert(a10 == 1);
+	assert(a14 == 1);
+	assert(a15 == 0);
+}
+
+void check_u_ne(void)
+{
+	int	a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
+	
+	for(unsigned i=5; i<15; i++)
+	{
+		if (i != 4)
+			a4++;
+		if (i != 5)
+			a5++;
+		if (i != 10)
+			a10++;
+		if (i != 14)
+			a14++;
+		if (i != 15)
+			a15++;
+	}
+	
+	assert(a4 == 10);
+	assert(a5 ==  9);
+	assert(a10 == 9);
+	assert(a14 == 9);
+	assert(a15 == 10);
+}
+
+
+int main(void)
+{
+	check_s_ne();
+	check_s_eq();
+	check_s_lt();
+	check_s_le();
+	check_s_gt();
+	check_s_ge();
+	
+	check_u_ne();
+	check_u_eq();
+	check_u_lt();
+	check_u_le();
+	check_u_gt();
+	check_u_ge();
+	
+	return 0;
+}
+

autotest/constructortest.cpp

@@ -0,0 +1,165 @@
+#include <assert.h>
+
+int t, n;
+
+struct C1
+{
+	int 	a;
+
+	C1(int x);
+	~C1(void);
+};
+
+C1::C1(int x) : a(x)
+{
+	t += a;
+	n++;
+}
+
+C1::~C1(void)
+{
+	t -= a;
+}
+
+void test_base(void)
+{
+	n = 0;
+
+	{
+		C1	x(2);
+		C1	y(1);
+	}
+
+	assert(t == 0 && n == 2);
+}
+
+void test_base_loop(void)
+{
+	n = 0;
+
+	for(int i=0; i<10; i++)
+	{
+		C1	x(2);
+		C1	y(1);
+	}
+
+	assert(t == 0 && n == 20);
+}
+
+struct C2
+{
+	C1	c, d;
+
+	C2(void);
+};
+
+C2::C2(void) 
+	: c(7), d(11)
+{
+
+}
+
+void test_member(void)
+{
+	n = 0;
+
+	{
+		C2	x();
+		C2	y();
+	}
+
+	assert(t == 0 && n == 4);
+}
+
+void test_member_loop(void)
+{
+	n = 0;
+
+	for(int i=0; i<10; i++)
+	{
+		C2	x();
+		C2	y();
+	}
+
+	assert(t == 0 && n == 40);
+}
+
+struct C3
+{
+	C2	x, y;
+};
+
+void test_default(void)
+{
+	n = 0;
+
+	{
+		C3	x();
+		C3	y();
+	}
+
+	assert(t == 0 && n == 8);
+}
+
+void test_default_loop(void)
+{
+	n = 0;
+
+	for(int i=0; i<10; i++)
+	{
+		C3	x();
+		C3	y();
+	}
+
+	assert(t == 0 && n == 80);
+}
+
+inline void test_inline_x(void)
+{
+	C1	x(1), y(2);
+}
+
+void test_inline(void)
+{
+	n = 0;
+
+	test_inline_x();
+
+	assert(t == 0 && n == 2);
+}
+
+inline void test_inline_xr(void)
+{
+	C1	x(1), y(2);
+
+	{
+		C1	x(3);
+		return;
+	}
+}
+
+void test_inline_return(void)
+{
+	n = 0;
+
+	test_inline_xr();
+
+	assert(t == 0 && n == 3);
+}
+
+int main(void)
+{
+	test_base();
+	test_base_loop();
+
+	test_member();
+	test_member_loop();
+
+	test_default();
+	test_default_loop();
+
+	test_inline();
+	test_inline_return();
+
+	return 0;
+}

autotest/copyassign.cpp

@@ -0,0 +1,126 @@
+#include <assert.h>
+
+int t, n;
+
+struct C0
+{
+	int u;
+
+	C0(int a);
+	~C0(void);
+};
+
+C0::C0(int a) : u(a)
+{
+	t += u;
+	n++;
+}
+
+C0::~C0(void)
+{
+	t -= u;
+}
+
+struct C1
+{
+	int u;
+
+	C1(int a);
+	~C1(void);
+	C1(const C1 & c);
+	C1 & operator=(const C1 & c);
+};
+
+C1::C1(int a) : u(a)
+{
+	t += u;
+	n++;
+}
+
+C1::~C1(void)
+{
+	t -= u;
+}
+
+C1::C1(const C1 & c) : u(c.u)
+{
+	t += u;
+	n++;
+}
+
+C1 & C1::operator=(const C1 & c)
+{
+	t -= u;
+	u = c.u;
+	t += u;
+	return *this;
+}
+
+void test_assign(void)
+{
+	n = 0;
+
+	{
+		C1	c(4);
+		C1	d(5);
+		c = d;
+	}
+
+	assert(n == 2 && t == 0);
+}
+
+struct C2
+{
+	C1		a, b;
+
+	C2(int x, int y) : a(x), b(y)
+		{}
+};
+
+void test_assign_deflt(void)
+{
+	n = 0;
+
+	{
+		C2	c(2, 3);
+		C2	d(5, 10);
+		c = d;
+	}
+
+	assert(n == 4 && t == 0);
+}
+
+int k;
+
+C2 test_ret_v(void)
+{
+	C2	c(5, 10);
+	return c;
+}
+
+C2 & test_ret_r(C2 & r)
+{
+	return r;
+}
+
+void test_assign_return_value(void)
+{
+	n = 0;
+
+	{
+		C2	c(2, 3);
+		c = test_ret_v();
+	}
+
+	assert(n == 6 && t == 0);
+}
+
+
+int main(void)
+{
+	test_assign();
+	test_assign_deflt();
+	test_assign_return_value();
+
+	return 0;
+}

autotest/copyconstructor.cpp

@@ -0,0 +1,215 @@
+#include <assert.h>
+#include <stdio.h>
+
+int t, n;
+
+struct C0
+{
+	int u;
+
+	C0(int a);
+	~C0(void);
+};
+
+C0::C0(int a) : u(a)
+{
+	t += u;
+	n++;
+}
+
+C0::~C0(void)
+{
+	t -= u;
+}
+
+struct C1
+{
+	int u;
+
+	C1(int a);
+	~C1(void);
+	C1(const C1 & c);
+};
+
+C1::C1(int a) : u(a)
+{
+	t += u;
+	n++;
+}
+
+C1::~C1(void)
+{
+	t -= u;
+}
+
+C1::C1(const C1 & c) : u(c.u)
+{
+	t += u;
+	n++;
+}
+
+void test_dcopy_init(void)
+{
+	n = 0;
+
+	{
+		C0	x(4);
+		C0	y(x);
+	}
+
+	assert(n == 1 && t == -4);
+
+	t = 0;
+}
+
+void test_copy_init(void)
+{
+	n = 0;
+
+	{
+		C1	x(4);
+		C1	y(x);
+	}
+
+	assert(n == 2 && t == 0);
+}
+
+struct C2
+{
+	C1	a, b;
+
+	C2(void);
+};
+
+C2::C2(void) : a(1), b(3)
+{}
+
+void test_minit(void)
+{	
+	n = 0;
+
+	{
+		C2	x;
+	}
+
+	assert(n == 2 && t == 0);
+}
+
+void test_minit_copy(void)
+{
+	n = 0;
+
+	{
+		C2	x;
+		C2	y(x);
+	}
+
+	assert(n == 4 && t == 0);
+}
+
+int k;
+
+void test_param_fv(C2 c)
+{
+	k += c.a.u;
+}
+
+void test_param_fr(C2 & c)
+{
+	k += c.a.u;
+}
+
+void test_param_value(void)
+{
+	n = 0;
+
+	{
+		C2	x;
+		test_param_fv(x);
+	}
+
+	assert(n == 4 && t == 0);	
+}
+
+void test_param_ref(void)
+{
+	n = 0;
+
+	{
+		C2	x;
+		test_param_fr(x);
+	}
+
+	assert(n == 2 && t == 0);	
+}
+
+C2 test_ret_v(void)
+{
+	C2	c;
+	return c;
+}
+
+C2 & test_ret_r(C2 & r)
+{
+	return r;
+}
+
+void test_return_value(void)
+{
+	n = 0;
+
+	{
+		C2 c(test_ret_v());
+	}
+
+	assert(n == 6 && t == 0);
+}
+
+void test_return_reference(void)
+{
+	n = 0;
+
+	{
+		C2 d;		
+		C2 c(test_ret_r(d));
+	}
+
+	assert(n == 2 && t == 0);
+}
+
+void test_retparam_value(void)
+{
+	n = 0;
+
+	{
+		test_param_fv(test_ret_v());
+	}
+
+	assert(n == 6 && t == 0);	
+}
+
+void test_retparam_reference(void)
+{
+	n = 0;
+
+	{
+		test_param_fr(test_ret_v());
+	}
+
+	assert(n == 4 && t == 0);	
+}
+
+int main(void)
+{
+	test_dcopy_init();
+	test_copy_init();
+	test_minit();
+	test_minit_copy();
+	test_param_value();
+	test_param_ref();
+	test_return_value();
+	test_retparam_value();
+	test_retparam_reference();
+
+	return 0;
+}

autotest/copyinitmove.c

@@ -0,0 +1,27 @@
+
+int val(char * c)
+{
+	return c[0];
+}
+
+void set(char * c, int a)
+{
+	c[0] = a;
+}
+
+int main(void)
+{
+	int	sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+
+	for(int i=0; i<10; i++)
+	{
+		char	t[10] = {1};
+		sum0 += val(t);
+		sum2 += t[0];
+		set(t, i);
+		sum1 += val(t);
+		sum3 += t[0];
+	}
+
+	return (sum1 - 45) | (sum0 - 10) | (sum3 - 45) | (sum2 - 10);
+}

autotest/copyintvec.c

@@ -0,0 +1,20 @@
+
+
+void copyi(int * a, int * b, int n)
+{
+	for(int i=0; i<n; i++)
+		b[i] = a[i];	
+}
+
+int main(void)
+{
+	int	t[100], s[100];
+	for(int i=0; i<100; i++)
+		s[i] = i;
+	copyi(s, t, 100);
+	int	sum = 0;
+	for(int i=0; i<100; i++)
+		sum += t[i];
+		
+	return sum - 4950;
+}

autotest/cplxstructtest.c

@@ -0,0 +1,97 @@
+#include <stdio.h>
+#include <math.h>
+#include <assert.h>
+
+struct cplx
+{
+	float	r, i;
+};
+
+cplx cplx_add(cplx a, cplx b)
+{
+	cplx	c;
+	c.r = a.r + b.r;
+	c.i = a.i + b.i;
+	return c;
+}
+
+cplx cplx_sub(cplx a, cplx b)
+{
+	cplx	c;
+	c.r = a.r - b.r;
+	c.i = a.i - b.i;
+	return c;	
+}
+
+cplx cplx_mul(cplx a, cplx b)
+{
+	cplx	c;
+	c.r = a.r * b.r - a.i * b.i;
+	c.i = a.i * b.r + a.r * b.i;
+	return c;
+}
+
+float cplx_abs(cplx a)
+{
+	return sqrt(a.r * a.r + a.i * a.i);
+}
+
+cplx cplx_sum(cplx p, const cplx * a, int n)
+{
+	cplx	s	=	{0.0, 0.0};
+	cplx	c	=	{1.0, 0.0};
+
+	for(int i=0; i<n; i++)
+	{
+		s = cplx_add(s, cplx_mul(a[i], c));
+		c = cplx_mul(c, p);
+	}
+
+	return s;
+}
+
+int main(void)
+{
+	cplx	sig[100];
+
+	for(int i=0; i<100; i++)
+	{
+		sig[i].r = cos(i * 1.3);
+		sig[i].i = sin(i * 1.3);
+	}
+
+	cplx	c	=	{1.0, 0.0};
+	float	phi = 0.1 * PI;	
+	cplx	t;
+	t.r = cos(phi); t.i = sin(phi);
+
+	float	p[20], q[20];
+
+	for(int i=0; i<20; i++)
+	{
+		p[i] = cplx_abs(cplx_sum(c, sig, 100));
+		c = cplx_mul(c, t);
+	}
+
+	for(int i=0; i<20; i++)
+	{
+		float	sumr = 0.0, sumi = 0.0;
+		for(int j=0; j<100; j++)
+		{
+			float	co = cos(i * j * 0.1 * PI), si = sin(i * j * 0.1 * PI);
+			sumr += co * sig[j].r - si * sig[j].i;
+			sumi += si * sig[j].r + co * sig[j].i;
+		}
+		q[i] = sqrt(sumr * sumr + sumi * sumi);
+	}
+#if 1
+	for(int i=0; i<20; i++)
+	{
+		printf("%d, %f - %f\n", i, p[i], q[i]);
+	}
+#endif
+	for(int i=0; i<20; i++)
+		assert(fabs(p[i] - q[i]) < 1.0);
+
+	return 0;
+}

autotest/divmod32test.c

@@ -0,0 +1,36 @@
+#include <assert.h>
+
+void check(unsigned long l, unsigned long r)
+{
+	unsigned long d = l / r, m = l % r;
+
+	assert(d * r + m == l);
+	assert(m < r);
+}
+
+int main(void)
+{
+	for(char i=0; i<28; i++)
+	{
+		for(char j=0; j<28; j++)
+		{
+			check(0xb3ul << i, 0x2bul << j);
+			check(0xb3ul << i, 0x01ul << j);
+			check(0x01ul << i, 0xc2ul << j);
+			check(0xb31ful << i, 0x2bul << j);
+			check(0xb354ul << i, 0x01ul << j);
+			check(0xb3ul << i, 0x2b1cul << j);
+			check(0xb3ul << i, 0x013ful << j);
+			check(0xb31ful << i, 0x2b23ul << j);
+			check(0xb354ul << i, 0x0145ul << j);
+			check(0xb31f24ul << i, 0x2bul << j);
+			check(0xb35421ul << i, 0x01ul << j);
+			check(0xb31f24ul << i, 0x2b23ul << j);
+			check(0xb35421ul << i, 0x0145ul << j);
+			check(0xb31f24ul << i, 0x2b2356ul << j);
+			check(0xb35421ul << i, 0x0145a7ul << j);
+		}
+	}
+
+	return 0;
+}

autotest/divmodtest.c

@@ -0,0 +1,39 @@
+#include <assert.h>
+
+int main(void)
+{
+	for(unsigned i=0; i<256; i+=11)
+	{
+		for(unsigned j=1; j<256; j++)
+		{
+			unsigned q = i / j, r = i % j;
+			
+			assert(q * j + r == i);
+			assert(r >= 0 && r < j);
+		}
+	}
+
+	for(unsigned i=0; i<7000; i+=11)
+	{
+		for(unsigned j=1; j<i; j*=3)
+		{
+			unsigned q = i / j, r = i % j;
+			
+			assert(q * j + r == i);
+			assert(r >= 0 && r < j);
+		}
+	}
+
+	for(unsigned i=0; i<64000; i+=121)
+	{
+		for(unsigned j=1; j<i; j*=3)
+		{
+			unsigned q = i / j, r = i % j;
+			
+			assert(q * j + r == i);
+			assert(r >= 0 && r < j);
+		}
+	}
+	
+	return 0;
+}

autotest/enumswitch.c

@@ -0,0 +1,23 @@
+enum E {
+	e1, e2, e3, e4
+};
+
+int check(E e)
+{
+	switch(e)
+	{
+	case e1:
+		return 10;
+	case e2:
+		return 20;
+	case e3:
+		return 30;
+	default:
+		return 100;
+	}
+}
+
+int main(void)
+{
+	return check(e1) + check(e2) + check(e3) + check(e4) - 160;
+}

autotest/fastcalltest.c

@@ -0,0 +1,28 @@
+#include <assert.h>
+#include <stdio.h>
+
+int p1(int a, int b)
+{
+	return a + b;
+}
+
+int p2(int a, int b)
+{
+	return a * b;
+}
+
+int c1(int x)
+{
+	return x;
+}
+
+int c2(int x)
+{
+	return c1(x);
+}
+
+int main(void)
+{
+	return p1(5, p2(c2(2), c2(4))) - 13;
+}
+

autotest/fixmathtest.c

@@ -0,0 +1,90 @@
+#include <fixmath.h>
+#include <assert.h>
+#include <stdlib.h>
+
+unsigned	tval[] = {
+	1, 2, 16, 128, 255, 256, 4096, 32768, 65535
+};
+
+void testmuldiv16u(void)
+{
+	for (char i=0; i<9; i++)
+	{
+		assert(lmuldiv16u(tval[i], 0, tval[i]) == 0);
+		assert(lmuldiv16u(0, tval[i], tval[i]) == 0);
+		for(char j=0; j<9; j++)
+		{			
+			assert(lmuldiv16u(tval[i], tval[j], tval[i]) == tval[j]);
+			assert(lmuldiv16u(tval[j], tval[i], tval[i]) == tval[j]);
+		}
+	}
+
+	for(int i=0; i<10000; i++)
+	{
+		unsigned	a = rand();
+		unsigned	b = rand();
+		unsigned	c = rand();
+		if (c > 0)
+		{
+			unsigned long d = (unsigned long)a * (unsigned long) b / c;
+			if (d < 0x10000l)
+				assert(lmuldiv16u(a, b, c) == d);
+		}
+	}
+}
+
+unsigned	ival[] = {
+	1, 2, 16, 128, 255, 256, 4096, 32767, 
+	-1, -2, -16, -128, -255, -256, -4096, -32767
+};
+
+void testmuldiv16s(void)
+{
+	for (char i=0; i<16; i++)
+	{
+		assert(lmuldiv16s(ival[i], 0, ival[i]) == 0);
+		assert(lmuldiv16s(0, ival[i], ival[i]) == 0);
+		for(char j=0; j<16; j++)
+		{			
+			assert(lmuldiv16s(ival[i], ival[j], ival[i]) == ival[j]);
+			assert(lmuldiv16s(ival[j], ival[i], ival[i]) == ival[j]);
+		}
+	}
+
+	for(int i=0; i<10000; i++)
+	{
+		int	a = rand();
+		int	b = rand();
+		int	c = rand();
+
+		if (c > 0)
+		{
+			long d = (long)a * (long)b / c;
+			if (d >= -32768 && d <= 32767)
+				assert(lmuldiv16s(a, b, c) == d);
+		}
+	}
+
+}
+
+void testlmul4f12s(void)
+{
+	for(int i=0; i<20000; i++)
+	{
+		int	a = rand();
+		int	b = rand();
+
+		long d = ((long)a * (long)b) >> 12;
+		if (d >= -32768 && d <= 32767)
+			assert(lmul4f12s(a, b) == d);
+	}
+}
+
+int main(void)
+{
+	testlmul4f12s();
+	testmuldiv16u();
+	testmuldiv16s();
+
+	return 0;
+}

autotest/floatcmptest.c

@@ -12,16 +12,50 @@ bool flt(float a, float b)
 	return a < b;
 }
 
+bool fle(float a, float b)
+{
+	return a <= b;
+}
+
 bool fgt(float a, float b)
 {
 	return a > b;
 }
 
-void cmpflt(float a, float b, bool eq, bool lt, bool gt)
+bool fge(float a, float b)
 {
+	return a >= b;
+}
+
+
+volatile float f;
+
+inline void cmpflt(float a, float b, bool eq, bool lt, bool gt)
+{
+	bool	le = eq || lt;
+	bool	ge = eq || gt;
+
 	assert(feq(a, b) == eq);
 	assert(flt(a, b) == lt);
 	assert(fgt(a, b) == gt);
+	assert(fle(a, b) == le);
+	assert(fge(a, b) == ge);
+
+	f = a;
+
+	assert(feq(f, b) == eq);
+	assert(flt(f, b) == lt);
+	assert(fgt(f, b) == gt);
+	assert(fle(f, b) == le);
+	assert(fge(f, b) == ge);
+
+	f = b;
+
+	assert(feq(a, f) == eq);
+	assert(flt(a, f) == lt);
+	assert(fgt(a, f) == gt);
+	assert(fle(a, f) == le);
+	assert(fge(a, f) == ge);
 }
 
 int main(void)

autotest/floatinttest.c

@@ -0,0 +1,75 @@
+#include <assert.h>
+#include <stdio.h>
+#include <math.h>
+
+
+int main(void)
+{
+	float			a;
+	int 			i;
+	long			li;
+	unsigned		u;
+	unsigned long	lu;
+
+	a = 1.0;
+	i = 1;	
+	for(int j=0; j<15; j++)
+	{
+		assert(i == (int)a);
+		assert(a == (float)i);
+		a *= 2.0;
+		i <<= 1;
+	}
+
+	a = -1.0;
+	i = -1;	
+	for(int j=0; j<15; j++)
+	{
+		assert(i == (int)a);
+		assert(a == (float)i);
+		a *= 2.0;
+		i <<= 1;
+	}
+
+	a = 1.0;
+	u = 1;	
+	for(int j=0; j<16; j++)
+	{
+		assert(u == (unsigned)a);
+		assert(a == (float)u);
+		a *= 2.0;
+		u <<= 1;
+	}
+
+	a = 1.0;
+	li = 1;	
+	for(int j=0; j<31; j++)
+	{
+		assert(li == (long)a);
+		assert(a == (float)li);
+		a *= 2.0;
+		li <<= 1;
+	}
+
+	a = -1.0;
+	li = -1;	
+	for(int j=0; j<31; j++)
+	{
+		assert(li == (long)a);
+		assert(a == (float)li);
+		a *= 2.0;
+		li <<= 1;
+	}
+
+	a = 1.0;
+	lu = 1;	
+	for(int j=0; j<32; j++)
+	{
+		assert(lu == (unsigned long)a);
+		assert(a == (float)lu);
+		a *= 2.0;
+		lu <<= 1;
+	}
+
+	return 0;
+}

autotest/floatmultest.c

@@ -12,7 +12,7 @@ int main(void)
 	
 	for(i=0; i<50; i++)
 	{		
-//		printf("%d %f %f %f\n", i, i * c, a, i * c - a);
+		printf("%d %f %f %f\n", i, i * c, a, i * c - a);
 		assert(i * c == a);
 		a += c;
 	}
@@ -21,7 +21,7 @@ int main(void)
 	
 	for(i=1; i<50; i++)
 	{		
-//		printf("%d %f %f %f\n", i, i * d, a, fabs(i * d - a) / i);
+		printf("%d %f %f %f\n", i, i * d, a, fabs(i * d - a) / i);
 		assert(fabs(i * d - a) < i * 1.0e-6);
 		a += d;
 	}

autotest/floatstringtest.c

@@ -0,0 +1,32 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+int main(void)
+{
+	printf("%f\n", 0.0);
+	
+
+	float	x = 1.0, y = 1.0;
+	
+	char	xb[20], yb[20];
+	for(int i=0; i<40; i++)
+	{
+		ftoa(x, xb); float xr = atof(xb);
+		ftoa(y, yb); float yr = atof(yb);
+		
+		printf("%20g (%s) %20g : %20g (%s) %20g : %10f %10f \n", x, xb, xr, y, yb, yr, fabs(x - xr) / x, fabs(y - yr) / y);
+		
+		if (fabs(x - xr) / x > 0.00001 || fabs(y - yr) / y > 0.00001)
+			return -1;
+
+		x *= 2.5;
+		y *= 0.8;
+	}
+	
+	return 0;
+}
+
+
+
+

autotest/floortest.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <math.h>
+
+int main(void)
+{
+	for(int y=1; y<100; y++)
+	{
+		float fz = 100.0 / (float)y;
+		printf("%d %f %f\n", y, floor(fz * 100.0), fz * 100.0);
+	}
+	
+	return 0;	
+}

autotest/funcarraycall.c

@@ -0,0 +1,30 @@
+
+int (*funcs[10])(int);
+
+#assign x 0
+#repeat
+int f##x(int i)
+{
+	return i + x;
+}
+#assign x x + 1
+#until x == 10
+
+int test(int k)
+{
+	for(char i=0; i<10; i++)
+		k = funcs[i](k);
+	return k;
+}
+
+int main(void)
+{
+#assign x 0
+#repeat
+	funcs[x] = f##x;
+#assign x x + 1
+#until x == 10
+
+	int k = test(-45);
+	return k;
+}

autotest/funcvartest.c

@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+
+typedef float (*fop)(float a, float b);
+
+float fadd(float a, float b)
+{
+	return a + b;	
+}
+
+float fmul(float a, float b)
+{
+	return a * b;	
+}
+
+
+struct FNode
+{
+	FNode	*	left, * right;
+	float		value;
+	fop			call;
+};
+
+FNode	*	root;
+
+float fevalB(FNode * f)
+{
+	if (f->call)
+		return f->call(fevalB(f->left), fevalB(f->right));
+	else
+		return f->value;
+}
+
+float fevalN(FNode * f)
+{
+	if (f->call)
+		return f->call(fevalN(f->left), fevalN(f->right));
+	else
+		return f->value;
+}
+
+#pragma native(fevalN)
+
+FNode * bop(fop call, FNode * left, FNode * right)
+{
+	FNode	*	f = (FNode *)malloc(sizeof(FNode));
+	f->call = call;
+	f->left = left;
+	f->right = right;
+	return f;
+}
+
+FNode * bc(float value)
+{
+	FNode	*	f = (FNode *)malloc(sizeof(FNode));
+	f->value = value;
+	return f;	
+}
+
+int main(void)
+{
+	FNode	*	tree = bop(fadd, bop(fmul, bc(3), bc(5)), bc(6));
+
+	printf("Eval %f, %d\n", fevalB(tree), fevalN(tree));
+
+	assert(fevalB(tree) == 3 * 5 + 6);
+	assert(fevalN(tree) == 3 * 5 + 6);
+
+	return 0;
+}

autotest/incvector.c

@@ -0,0 +1,22 @@
+
+
+void incv(int * a, int n)
+{
+	for(int i=0; i<n; i++)
+		a[i] ++;		
+}
+
+int	t[100];
+
+int main(void)
+{
+	for(int i=0; i<100; i++)
+		t[i] = i;
+	incv(t, 100);
+	int	s = 0;
+	for(int i=0; i<100; i++)
+		s += t[i];
+		
+	return s - 5050;	
+}
+

autotest/linetest.c

@@ -0,0 +1,25 @@
+#include <gfx/bitmap.h>
+#include <assert.h>
+
+
+char 	* const	Hires = (char *)0x4000;
+Bitmap			Screen;
+ClipRect		cr = {0, 0, 320, 200};
+
+
+
+int main(void)
+{
+	bm_init(&Screen, Hires, 40, 25);	
+
+	bmu_rect_clear(&Screen, 0, 0, 320, 200);
+
+	bm_line(&Screen, &cr, 0, 0, 199, 199, 0xff, LINOP_SET);
+
+	for(int i=0; i<200; i++)
+	{
+		assert(Hires[(i & 7) + 320 * (i >> 3) + (i & ~7)] == 0x80 >> (i & 7));
+	}
+
+	return 0;
+}

autotest/longcodetest.c

@@ -0,0 +1,30 @@
+#include <assert.h>
+
+char a[200], b[200];
+bool ok = true;
+
+int main(void)
+{
+#assign ni 0
+#repeat
+	a[ni] = ni & 255;
+#assign ni ni + 1
+#until ni == 200
+
+#assign ni 0
+#repeat
+	if (ok)
+		b[ni] = ni & 255;
+#assign ni ni + 1
+#until ni == 200
+
+	int asum = 0, bsum = 0, csum = 0;
+	for(int i=0; i<200; i++)
+	{
+		asum += a[i];
+		bsum += b[i];
+		csum += i & 255;
+	}
+	
+	return asum + bsum - 2 * csum;		
+}

autotest/loopboundtest.c

@@ -0,0 +1,94 @@
+#include <assert.h>
+
+struct S
+{
+	int a[100];
+};
+
+int lts(S * s)
+{
+	int	x = 0;
+	for(int i=0; i<100; i++)
+		x += s->a[i];
+	return x;
+}
+
+int les(S * s)
+{
+	int	x = 0;
+	for(int i=0; i<=99; i++)
+		x += s->a[i];
+	return x;
+}
+
+int gts(S * s)
+{
+	int	x = 0;
+	for(int i=100; i>0; i--)
+		x += s->a[i-1];
+	return x;
+}
+
+int ges(S * s)
+{
+	int	x = 0;
+	for(int i=99; i>=0; i--)
+		x += s->a[i];
+	return x;
+}
+
+int ltu(S * s)
+{
+	unsigned	x = 0;
+	for(int i=0; i<100; i++)
+		x += s->a[i];
+	return x;
+}
+
+int leu(S * s)
+{
+	unsigned	x = 0;
+	for(int i=0; i<=99; i++)
+		x += s->a[i];
+	return x;
+}
+
+int gtu(S * s)
+{
+	unsigned	x = 0;
+	for(int i=100; i>0; i--)
+		x += s->a[i-1];
+	return x;
+}
+
+int geu(S * s)
+{
+	unsigned	x = 0;
+	for(int i=100; i>=1; i--)
+		x += s->a[i-1];
+	return x;
+}
+
+int main(void)
+{
+	S	s;
+
+	int	k = 0;
+	for(int i=0; i<100; i++)
+	{
+		int	t = (i & 15) + 3;
+		s.a[i] = t;
+		k += t;
+	}
+
+	assert(lts(&s) == k);
+	assert(les(&s) == k);
+	assert(gts(&s) == k);
+	assert(ges(&s) == k);
+	assert(ltu(&s) == k);
+	assert(leu(&s) == k);
+	assert(gtu(&s) == k);
+	assert(geu(&s) == k);
+
+	return 0;
+}

autotest/loopdomtest.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <assert.h>
+
+
+int main(void)
+{
+	int	a[10][10];
+	
+	for(int i=0; i<10; i++)
+	{
+		for(int j=0; j<10; j++)
+		{
+			a[i][j] = i + j;
+		}
+	}
+	
+	int	s = 0;
+	
+	for(int i=0; i<10; i++)
+	{
+		s += a[i][i];
+	}
+	
+	
+	assert(s == 90);
+	
+	return 0;
+}

autotest/makefile

@@ -0,0 +1,60 @@
+SRCS=$(filter-out opp_part1.cpp opp_part2.cpp, $(wildcard *.c *.cpp))
+EXES=$(patsubst %.c,%,$(SRCS))
+EXES:=$(patsubst %.cpp,%,$(EXES))
+
+all: $(EXES)
+
+%: %.c
+	$(OSCAR64_CC) -e -bc $<
+	$(OSCAR64_CC) -e -n $<
+	$(OSCAR64_CC) -e -O2 -bc $<
+	$(OSCAR64_CC) -e -O2 -n $<
+	$(OSCAR64_CC) -e -O0 -bc $<
+	$(OSCAR64_CC) -e -O0 -n $<
+	$(OSCAR64_CC) -e -Os -bc $<
+	$(OSCAR64_CC) -e -Os -n $<
+	$(OSCAR64_CC) -e -O3 -bc $<
+	$(OSCAR64_CC) -e -O3 -n $<
+
+%: %.cpp
+	$(OSCAR64_CXX) -e -bc $<
+	$(OSCAR64_CXX) -e -n $<
+	$(OSCAR64_CXX) -e -O2 -bc $<
+	$(OSCAR64_CXX) -e -O2 -n $<
+	$(OSCAR64_CXX) -e -O0 -bc $<
+	$(OSCAR64_CXX) -e -O0 -n $<
+	$(OSCAR64_CXX) -e -Os -bc $<
+	$(OSCAR64_CXX) -e -Os -n $<
+	$(OSCAR64_CXX) -e -O3 -bc $<
+	$(OSCAR64_CXX) -e -O3 -n $<
+
+# testb
+bitshifttest: bitshifttest.c
+	$(OSCAR64_CC) -e -bc $<
+	$(OSCAR64_CC) -e -bc -O2 $<
+	$(OSCAR64_CC) -e -bc -O0 $<
+	$(OSCAR64_CC) -e -bc -Os $<
+	$(OSCAR64_CC) -e -bc -O3 $<
+	$(OSCAR64_CC) -e -n $<
+
+# testn
+stripedarraytest: stripedarraytest.c
+	$(OSCAR64_CC) -e -O2 -n $<
+	$(OSCAR64_CC) -e -O0 -n $<
+	$(OSCAR64_CC) -e -Os -n $<
+	$(OSCAR64_CC) -e -O3 -n $<
+
+autorefreturn: autorefreturn.cpp
+	$(OSCAR64_CC) -e -O2 -n $<
+	$(OSCAR64_CC) -e -O0 -n $<
+	$(OSCAR64_CC) -e -Os -n $<
+	$(OSCAR64_CC) -e -O3 -n $<
+
+copyconstructor: copyconstructor.cpp
+	$(OSCAR64_CC) -e -O2 -n $<
+	$(OSCAR64_CC) -e -O0 -n $<
+	$(OSCAR64_CC) -e -Os -n $<
+	$(OSCAR64_CC) -e -O3 -n $<
+
+clean:
+	@$(RM) *.asm *.bcs *.int *.lbl *.map *.prg

autotest/mathtest.c

@@ -0,0 +1,32 @@
+#include <math.h>
+#include <stdio.h>
+#include <assert.h>
+
+int main(void)
+{
+	for(int i=0; i<1000; i++)
+	{
+		float	w = 0.0123 * i;
+		float	co = cos(w), si = sin(w);
+
+		float	r = co * co + si * si;
+
+		assert(fabs(r - 1) < 0.001);
+
+		assert(fabs(sqrt(w * w) - w) < 0.001);
+
+		float	aw = atan2(si, co);
+
+		float	co2 = cos(aw), si2 = sin(aw);
+
+		assert(fabs(co2 - co) < 0.001);
+		assert(fabs(si2 - si) < 0.001);
+
+		float	ex = exp(w), em = exp(-w);
+
+		assert(fabs(log(ex) - w) < 0.001);
+		assert(fabs(log(em) + w) < 0.001);
+	}
+
+	return 0;
+}

autotest/memmovetest.c

@@ -0,0 +1,49 @@
+#include <string.h>
+#include <assert.h>
+#include <stdio.h>
+
+unsigned b[4096];
+
+void testfwd(unsigned sz)
+{
+	for(unsigned i=0; i<4096; i++)
+		b[i] = i;
+
+	memmove(b + 100, b + 101, 2 * sz);
+
+	for(unsigned i=0; i<100; i++)
+		assert(b[i] == i);
+	for(unsigned i=100; i<100 + sz; i++)
+		assert(b[i] == i + 1);
+	for(unsigned i=100 + sz; i<4096; i++)
+		assert(b[i] == i);
+}
+
+void testback(unsigned sz)
+{
+	for(unsigned i=0; i<4096; i++)
+		b[i] = i;
+
+	memmove(b + 101, b + 100, 2 * sz);
+
+	for(unsigned i=0; i<101; i++)
+		assert(b[i] == i);
+	for(unsigned i=101; i<101 + sz; i++)
+		assert(b[i] == i - 1);
+	for(unsigned i=101 + sz; i<4096; i++)
+		assert(b[i] == i);
+}
+
+int main(void)
+{
+	for(unsigned i=1; i<2048; i *= 2)
+	{
+		testfwd(i - 1);
+		testfwd(i);
+		testback(i);
+		testback(i - 1);
+	}
+
+	return 0;
+}
+

autotest/mixsigncmptest.c

@@ -0,0 +1,64 @@
+#include <assert.h>
+
+int main(void)
+{
+	unsigned	n1, n0;
+
+	n1 = 0; n0 = 0;
+	for(int i=-1000; i<2000; i+=37)
+	{
+		for(char j=0; j<255; j++)
+		{
+			if (i < j)
+				n1++;
+			else
+				n0++;
+		}
+	}
+
+	assert(n1 == 7893 && n0 == 13017);
+
+	n1 = 0; n0 = 0;
+	for(int i=-1000; i<2000; i+=37)
+	{
+		for(char j=0; j<255; j++)
+		{
+			if (i <= j)
+				n1++;
+			else
+				n0++;
+		}
+	}
+
+	assert(n1 == 7899 && n0 == 13011);
+
+	n1 = 0; n0 = 0;
+	for(int i=-1000; i<2000; i+=37)
+	{
+		for(char j=0; j<255; j++)
+		{
+			if (i >= j)
+				n1++;
+			else
+				n0++;
+		}
+	}
+
+	assert(n0 == 7893 && n1 == 13017);
+
+	n1 = 0; n0 = 0;
+	for(int i=-1000; i<2000; i+=37)
+	{
+		for(char j=0; j<255; j++)
+		{
+			if (i > j)
+				n1++;
+			else
+				n0++;
+		}
+	}
+
+	assert(n0 == 7899 && n1 == 13011);
+
+	return 0;
+}

autotest/mmultest.c

@@ -0,0 +1,43 @@
+#include <gfx/vector3d.h>
+#include <assert.h>
+#include <stdio.h>
+
+Matrix4	ml, mr;
+
+int main(void)
+{
+	for(char i=0; i<16; i++)
+	{
+		for(char j=0; j<16; j++)
+		{
+			for(char k=0; k<16; k++)
+			{
+				ml.m[k] = (i == k) ? 1.0 : 0.0;
+				mr.m[k] = (j == k) ? 1.0 : 0.0;
+			}
+
+			mat4_mmul(&ml, &mr);
+
+#if 0
+			printf("%d, %d\n", i, j);
+			for(char k=0; k<16; k++)
+				printf("%f ", ml.m[k]);
+			printf("\n");
+#endif
+
+			for(char k=0; k<16; k++)
+			{
+				char ix = i & 3, iy = i >> 2;
+				char jx = j & 3, jy = j >> 2;
+				char kx = k & 3, ky = k >> 2;
+
+				if (ky == jy && kx == ix && jx == iy)
+					assert(ml.m[k] == 1.0);
+				else
+					assert(ml.m[k] == 0.0);
+			}
+		}
+	}
+		
+	return 0;
+}

autotest/operatoroverload.cpp

@@ -0,0 +1,90 @@
+#include <assert.h>
+
+struct A
+{
+	int n;
+
+	A(int n_)
+	: n(n_) {}
+
+	A(const A & a)
+	: n(a.n) {}
+
+	A operator+(const A & a) const
+	{
+		return A(n + a.n);
+	}
+
+	A operator-(const A & a) const
+	{
+		return A(n - a.n);
+	}
+
+	A & operator+=(const A & a)
+	{
+		n += a.n;
+		return *this;
+	}
+
+	A & operator-=(const A & a)
+	{
+		n -= a.n;
+		return *this;
+	}
+
+	A operator-(void) const
+	{
+		return A(-n);
+	}
+
+	A & operator++(void)
+	{
+		n++;
+		return *this;
+	}
+
+	A & operator--(void)
+	{
+		n--;
+		return *this;
+	}
+
+	A operator++(int);
+
+	A operator--(int);
+
+};
+
+A A::operator++(int)
+{
+	A a(*this);
+	n++;
+	return a;
+}
+
+A A::operator--(int)
+{
+	A a(*this);
+	n--;
+	return a;
+}
+
+int main(void)
+{
+	A a(7), b(8), c(9);
+
+	assert((++a).n == 8);
+	assert(a.n == 8);
+
+	assert((--a).n == 7);
+	assert(a.n == 7);
+
+	assert((a++).n == 7);
+	assert(a.n == 8);
+	assert((a--).n == 8);
+	assert(a.n == 7);
+
+	assert((a + b - c + -a + -b - -c).n == 0);
+
+	return 0;
+}

autotest/opp_array.cpp

@@ -0,0 +1,23 @@
+#include <opp/array.h>
+#include <assert.h>
+
+int main(void)
+{
+	opp::array<int, 10>	a10;
+	opp::array<int, 20>	a20;
+
+	for(int i=0; i<10; i++)
+		a10[i] = i;
+	for(int i=0; i<20; i++)
+		a20[i] = i;
+
+	int s = 0;
+	for(int i=0; i<10; i++)
+		s += a10[i];
+	for(int i=10; i<20; i++)
+		s -= a20[i];
+
+	assert(s == -100);
+
+	return 0;
+}

autotest/opp_functional.cpp

@@ -0,0 +1,46 @@
+#include <opp/functional.h>
+
+class Node
+{
+public:
+	virtual int eval(void) const = 0;
+};
+
+class ConstNode : public Node
+{
+private:
+	int 	v;
+public:
+	ConstNode(int v_) : v(v_) {}
+	virtual int eval(void) const
+	{
+		return v;
+	}
+};
+
+class BinaryNode : public Node
+{
+private:
+	opp::function<int(int, int)>	op;
+	Node	*	left, * right;
+public:
+	BinaryNode(opp::function<int(int, int)> op_, Node * left_, Node * right_);
+
+	virtual int eval(void) const
+	{
+		return op(left->eval(), right->eval());
+	}
+};
+
+inline BinaryNode::BinaryNode(opp::function<int(int, int)> op_, Node * left_, Node * right_)
+	: op(op_), left(left_), right(right_) {}
+
+int main(void)
+{
+	Node	*	s1 = 
+		new BinaryNode([=](int a, int b){return a + b;},
+			new ConstNode(7), new ConstNode(11)
+		);
+
+	return s1->eval() - 18;
+}

autotest/opp_list.cpp

@@ -0,0 +1,57 @@
+#include <opp/list.h>
+#include <opp/algorithm.h>
+#include <assert.h>
+#include <opp/iostream.h>
+
+int main(void)
+{
+	opp::list<int>		a;
+
+	for(int i=0; i<10; i++)
+		a.push_back(i);
+
+	int s = 0;
+	for(auto i : a)
+		s += i;
+
+	assert(s == 45);
+
+	auto li = a.begin();
+	for(int i=0; i<5; i++)
+	{
+		li = a.erase(li);
+		li++;
+	}
+
+	s = 0;
+	for(auto i : a)
+		s += i;
+
+	assert(s == 1 + 3 + 5 + 7 + 9);
+
+	opp::list<int>		b;
+
+	b = a;
+
+	s = 0;
+	for(auto i : b)
+		s += i;
+
+	assert(s == 1 + 3 + 5 + 7 + 9);
+
+	opp::list<int>		c = opp::list<int>(b);
+
+	s = 0;
+	for(auto i : c)
+		s += i;
+
+	assert(s == 1 + 3 + 5 + 7 + 9);
+
+	s = 0;
+	for(auto i : b)
+		s += i;
+
+	assert(s == 1 + 3 + 5 + 7 + 9);
+
+	return 0;
+}

autotest/opp_pairtest.cpp

@@ -0,0 +1,28 @@
+#include <assert.h>
+#include <opp/vector.h>
+#include <opp/utility.h>
+#include <opp/iostream.h>
+
+using namespace opp;
+
+int main(void)
+{
+	vector<pair<int, int> >	vii;
+
+	for(int i=0; i<100; i++)
+		vii.push_back(make_pair(i, i * i));
+
+	int 	sum1 = 0;
+	long	sum2 = 0;
+	for(const auto & v : vii)
+	{
+		sum1 += v.first;
+		sum2 += v.second;
+	}
+
+
+	assert(sum1 ==   4950);
+	assert(sum2 == 328350l);
+
+	return 0;
+}

autotest/opp_part1.cpp

@@ -0,0 +1,2 @@
+#include "opp_part1.h"
+

autotest/opp_part1.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <opp/vector.h>
+
+class A
+{
+protected:
+	int 	a, b;
+
+public:
+	A(int a_, int b_)
+		: a(a_), b(b_)
+		{}
+
+	int sum(void) const
+	{
+		return a * b;
+	}
+};
+
+class AS
+{
+protected:
+	opp::vector<A>	va;
+public:
+	AS(const opp::vector<A> & v)
+		: va(v)
+		{}
+
+	int sum(void)
+	{
+		int s = 0;
+		for(const auto & a : va)
+			s += a.sum();
+		return s;
+	}
+};
+
+#pragma compile("opp_part1.cpp")
+

autotest/opp_part2.cpp

@@ -0,0 +1,13 @@
+#include "opp_part2.h"
+
+BS::BS(const opp::vector<A> & v)
+		: va(v)
+		{}
+
+int BS::sum(void)
+{
+	int s = 0;
+	for(const auto & a : va)
+		s += a.sum();
+	return s;
+}

autotest/opp_part2.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "opp_part1.h"
+
+class BS
+{
+protected:
+	opp::vector<A>	va;
+public:
+	BS(const opp::vector<A> & v);
+	int sum(void);
+};
+
+
+
+#pragma compile("opp_part2.cpp")

autotest/opp_parts.cpp

@@ -0,0 +1,25 @@
+#include <assert.h>
+
+#include "opp_part1.h"
+#include "opp_part2.h"
+
+
+int main(void)
+{
+	opp::vector<A>	va;
+	va.push_back(A(1, 2));
+	va.push_back(A(3, 4));
+	va.push_back(A(6, 4));
+	va.push_back(A(0, 9));
+
+	AS	as(va);
+
+	va.push_back(A(7, 1));
+
+	BS 	bs(va);
+
+	assert(bs.sum() == 2 + 12 + 24 + 7);
+	assert(as.sum() == 2 + 12 + 24);
+
+	return 0;
+}

autotest/opp_static_vector.cpp

@@ -0,0 +1,78 @@
+#include <opp/static_vector.h>
+#include <opp/algorithm.h>
+#include <assert.h>
+#include <opp/iostream.h>
+
+int main(void)
+{
+	opp::static_vector<int, 20>		a;
+
+	for(int i=0; i<10; i++)
+		a.push_back(i);
+
+	int s = 0;
+	for(int i=0; i<a.size(); i++)
+		s += a[i];
+
+	assert(s == 45);
+
+	for(int i=0; i<5; i++)
+		a.erase(i);
+
+	s = 0;
+	for(int i=0; i<a.size(); i++)
+		s += a[i];
+
+	assert(s == 1 + 3 + 5 + 7 + 9);
+
+	opp::static_vector<int, 100>	v;
+
+	for(int i=0; i<10; i++)
+		v.push_back(i);
+
+	assert(v.size() == 10);
+	v.insert(0, 20);
+	assert(v.size() == 11);
+	v.insert(6, 21);
+	assert(v.size() == 12);
+	v.insert(12, 22);
+
+	int * fi = opp::find(v.begin(), v.end(), 21);
+
+	fi = v.insert(fi, 30);
+	fi = v.insert(fi, 31);
+	fi = v.insert(fi, 32);
+
+	assert(v.size() == 16);
+	assert(v[0] == 20);
+	assert(v[15] == 22);
+	assert(v[8] == 32);
+
+	fi = opp::find(v.begin(), v.end(), 32);
+
+	for(int i=0; i<30; i++)
+	{
+		fi = v.insert(fi, i + 40);
+	}
+
+	assert(v.size() == 46);
+	assert(v[28] == 60);
+
+	v.erase(10, 10);
+
+	for(int i : v) 
+		opp::cout << i << ", ";
+	opp::cout << "\n";
+
+	assert(v.size() == 36);
+	assert(v[18] == 60);
+
+	v.assign(42, 11);
+
+	assert(v.size() == 42);
+	assert(v[0] == 11);
+	assert(v[15] == 11);
+	assert(v[41] == 11);
+
+	return 0;
+}

autotest/opp_streamtest.cpp

@@ -0,0 +1,83 @@
+#include <opp/string.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <opp/sstream.h>
+#include <math.h>
+
+using opp::ostringstream;
+using opp::istringstream;
+using opp::endl;
+
+float fdist(float a, float b)
+{
+	float d = fabs(a - b);
+	a = fabs(a);
+	b = fabs(b);
+	return d / (a > b ? a : b);
+}
+
+int main(void)
+{
+	ostringstream	os;
+
+	for(int i=0; i<40; i++)
+	{
+		os << i << endl;
+	}
+
+	istringstream	is(os.str());
+
+	int j = 0, k = 47;
+#if 1
+
+	while (is >> k)
+	{
+		assert(k == j++);
+	}
+
+	assert(j == 40);
+#endif
+	os.str(opp::string());
+
+#if 0
+	cout << "[" << os.str() << "]" << endl;
+	os << "HELLO";
+	cout << "[" << os.str() << "]" << endl;
+#endif
+#if 1
+
+	float	f = 1.0, g = 1.0;
+
+	for(int i=0; i<10; i++)
+	{
+		os << f << " " << g << endl;
+//		cout << os.str();
+
+		f *= 5.1;
+		g *= 0.12;
+	}
+
+
+	is.str(os.str());
+
+	f = 1.0, g = 1.0;
+
+	float	 fr, gr;
+
+	j = 0;
+	while (is >> fr >> gr)
+	{
+//		cout << f << " " << fr << ", " << g << " " << gr << ", " << fdist(fr, f) << endl;
+
+		assert(fdist(fr, f) < 1.0e-5);
+		assert(fdist(gr, g) < 1.0e-5);
+
+		f *= 5.1;
+		g *= 0.12;
+		j++;
+	}
+
+	assert(j == 10);
+#endif
+	return 0;
+}

autotest/opp_string.cpp

@@ -0,0 +1,103 @@
+#include <opp/string.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+
+using opp::string;
+
+static const char HelloWorld[] = "Hello World";
+static const char AndBeyond[] = "And Beyond";
+static const char And[] = "And";
+static const char HelloWorldAndBeyond[] = "Hello World And Beyond";
+
+__noinline void test_create(void)
+{
+	string	s1();
+	string	s2(HelloWorld);
+	string	s3(s2);
+	string	s4('a');
+
+	assert(!strcmp(s2.tocstr(), HelloWorld));
+	assert(!strcmp(s3.tocstr(), HelloWorld));
+	assert(s4.size() == 1 && s4[0] == 'a');
+}
+
+__noinline void test_concat(void)
+{
+	string	s1();
+	string	s2(HelloWorld);
+	string	s3(AndBeyond);
+
+	string	s4 = s1 + s2;
+	string	s5 = s2 + " " + s3;
+	string	s6 = s2 + " " + AndBeyond;
+
+	assert(!strcmp(s4.tocstr(), HelloWorld));
+	assert(!strcmp(s5.tocstr(), HelloWorldAndBeyond));
+	assert(!strcmp(s6.tocstr(), HelloWorldAndBeyond));	
+}
+
+__noinline void test_find(void)
+{
+	string s1(HelloWorldAndBeyond);
+	string s2(And);
+
+	assert(s1.find(HelloWorld) == 0);
+	assert(s1.find(AndBeyond) == 12);
+	assert(s1.find(And) == 12);
+	assert(s1.find(s2) == 12);
+
+	assert(s1.find(' ') == 5);
+	assert(s1.find(' ', 6) == 11);
+}
+
+__noinline void test_assign(void)
+{
+	string	s1(HelloWorld);
+	string	s2(AndBeyond);
+	string	s3;
+	s3 = s1;
+	s3 = s2;
+	s3 = s1;
+	s3 += " ";
+	s3 += s2;
+
+	assert(!strcmp(s3.tocstr(), HelloWorldAndBeyond));
+
+	s3 <<= 12;
+
+	assert(!strcmp(s3.tocstr(), AndBeyond));
+
+	s3 = HelloWorldAndBeyond;
+
+	assert(!strcmp(s3.tocstr(), HelloWorldAndBeyond));
+
+	s3 >>= 11;
+
+	assert(!strcmp(s3.tocstr(), HelloWorld));
+}
+
+static char * test;
+
+int main(void)
+{
+	test = new char;		
+
+	unsigned	avail = heapfree();
+
+	test_create();
+	assert(avail == heapfree());
+
+	test_concat();
+	assert(avail == heapfree());
+
+	test_find();
+	assert(avail == heapfree());
+
+	test_assign();
+	assert(avail == heapfree());
+
+	delete test;
+
+	return 0;
+}

autotest/opp_string_init.cpp

@@ -0,0 +1,193 @@
+#include <opp/string.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+
+using opp::string;
+
+
+const string	s1;
+const string	s2 = "Hello";
+const string	s3{"World"};
+
+const string	a1[2];
+const string	a2[2] = {"Hello", "World"};
+const string	a3[2] = {opp::string("Hello"), opp::string("World")};
+
+
+const string	d1[3][2];
+const string	d2[3][2] = {{"Hello", "World"}, {"aaa", "bbb"}, {"ccc", "ddd"}};
+const string	d3[3][2] = 
+	{{opp::string("Hello"), opp::string("World")},
+	 {opp::string("aaa"), opp::string("bbb")},
+	 {opp::string("ccc"), opp::string("ddd")}};
+
+void test_global_init(void)
+{
+	assert(!strcmp(s1.tocstr(), ""));
+	assert(!strcmp(s2.tocstr(), "Hello"));
+	assert(!strcmp(s3.tocstr(), "World"));		
+}
+
+
+void test_global_ainit(void)
+{
+	assert(!strcmp(a1[0].tocstr(), ""));
+	assert(!strcmp(a1[1].tocstr(), ""));
+
+	assert(!strcmp(a2[0].tocstr(), "Hello"));
+	assert(!strcmp(a2[1].tocstr(), "World"));		
+
+	assert(!strcmp(a3[0].tocstr(), "Hello"));
+	assert(!strcmp(a3[1].tocstr(), "World"));		
+}
+
+void test_global_dinit(void)
+{
+	assert(!strcmp(d1[0][0].tocstr(), ""));
+	assert(!strcmp(d1[2][1].tocstr(), ""));
+
+	assert(!strcmp(d2[0][0].tocstr(), "Hello"));
+	assert(!strcmp(d2[2][1].tocstr(), "ddd"));
+
+	assert(!strcmp(d3[0][0].tocstr(), "Hello"));
+	assert(!strcmp(d3[2][1].tocstr(), "ddd"));		
+}
+
+
+void test_local_init(void)
+{
+	const string	s1;
+	const string	s2 = "Hello";
+	const string	s3{"World"};
+
+	assert(!strcmp(s1.tocstr(), ""));
+	assert(!strcmp(s2.tocstr(), "Hello"));
+	assert(!strcmp(s3.tocstr(), "World"));		
+}
+
+
+void test_local_ainit(void)
+{
+	const string	a1[2];
+	const string	a2[2] = {"Hello", "World"};
+	const string	a3[2] = {opp::string("Hello"), opp::string("World")};
+
+	assert(!strcmp(a1[0].tocstr(), ""));
+	assert(!strcmp(a1[1].tocstr(), ""));
+
+	assert(!strcmp(a2[0].tocstr(), "Hello"));
+	assert(!strcmp(a2[1].tocstr(), "World"));		
+
+	assert(!strcmp(a3[0].tocstr(), "Hello"));
+	assert(!strcmp(a3[1].tocstr(), "World"));		
+}
+
+void test_local_dinit(void)
+{
+	const string	d1[3][2];
+	const string	d2[3][2] = {{"Hello", "World"}, {"aaa", "bbb"}, {"ccc", "ddd"}};
+	const string	d3[3][2] = 
+		{{opp::string("Hello"), opp::string("World")},
+		 {opp::string("aaa"), opp::string("bbb")},
+		 {opp::string("ccc"), opp::string("ddd")}};
+
+	assert(!strcmp(d1[0][0].tocstr(), ""));
+	assert(!strcmp(d1[2][1].tocstr(), ""));
+
+	assert(!strcmp(d2[0][0].tocstr(), "Hello"));
+	assert(!strcmp(d2[2][1].tocstr(), "ddd"));
+
+	assert(!strcmp(d3[0][0].tocstr(), "Hello"));
+	assert(!strcmp(d3[2][1].tocstr(), "ddd"));		
+}
+
+class X
+{
+public:
+	const string s1;
+	const string s2 = "Hello";
+	const string s3;
+
+	const string	a1[2];
+	const string	a2[2] = {"Hello", "World"};
+
+	const string	d1[3][2];
+	const string	d2[3][2] = {{"Hello", "World"}, {"aaa", "bbb"}, {"ccc", "ddd"}};
+
+	X() : s3("World") {}
+};
+
+void test_member_init(void)
+{
+	X x;
+
+	assert(!strcmp(x.s1.tocstr(), ""));
+	assert(!strcmp(x.s2.tocstr(), "Hello"));
+	assert(!strcmp(x.s3.tocstr(), "World"));		
+}
+
+void test_member_ainit(void)
+{
+	X x;
+
+	assert(!strcmp(x.a1[0].tocstr(), ""));
+	assert(!strcmp(x.a1[1].tocstr(), ""));
+
+	assert(!strcmp(x.a2[0].tocstr(), "Hello"));
+	assert(!strcmp(x.a2[1].tocstr(), "World"));		
+}
+
+void test_member_dinit(void)
+{
+	X x;
+
+	assert(!strcmp(x.d1[0][0].tocstr(), ""));
+	assert(!strcmp(x.d1[2][1].tocstr(), ""));
+
+	assert(!strcmp(x.d2[0][0].tocstr(), "Hello"));
+	assert(!strcmp(x.d2[2][1].tocstr(), "ddd"));
+}
+
+void test_copy_init(void)
+{
+	X x;
+	X y(x);
+
+	assert(!strcmp(y.s1.tocstr(), ""));
+	assert(!strcmp(y.s2.tocstr(), "Hello"));
+	assert(!strcmp(y.s3.tocstr(), "World"));		
+}
+
+void test_copy_ainit(void)
+{
+	X x;
+	X y(x);
+
+	assert(!strcmp(y.a1[0].tocstr(), ""));
+	assert(!strcmp(y.a1[1].tocstr(), ""));
+
+	assert(!strcmp(y.a2[0].tocstr(), "Hello"));
+	assert(!strcmp(y.a2[1].tocstr(), "World"));		
+}
+
+int main(void)
+{
+	test_global_init();
+	test_global_ainit();
+	test_global_dinit();
+
+	for(int i=0; i<10000; i++)
+	{
+		test_local_init();
+		test_local_ainit();
+	}
+
+	test_member_init();
+	test_member_ainit();
+
+	test_copy_init();
+	test_copy_ainit();
+
+	return 0;
+}

autotest/opp_vector.cpp

@@ -0,0 +1,78 @@
+#include <opp/vector.h>
+#include <opp/algorithm.h>
+#include <assert.h>
+#include <opp/iostream.h>
+
+int main(void)
+{
+	opp::vector<int>		a;
+
+	for(int i=0; i<10; i++)
+		a.push_back(i);
+
+	int s = 0;
+	for(int i=0; i<a.size(); i++)
+		s += a[i];
+
+	assert(s == 45);
+
+	for(int i=0; i<5; i++)
+		a.erase(i);
+
+	s = 0;
+	for(int i=0; i<a.size(); i++)
+		s += a[i];
+
+	assert(s == 1 + 3 + 5 + 7 + 9);
+
+	opp::vector<int>	v;
+
+	for(int i=0; i<10; i++)
+		v.push_back(i);
+
+	assert(v.size() == 10);
+	v.insert(0, 20);
+	assert(v.size() == 11);
+	v.insert(6, 21);
+	assert(v.size() == 12);
+	v.insert(12, 22);
+
+	int * fi = opp::find(v.begin(), v.end(), 21);
+
+	fi = v.insert(fi, 30);
+	fi = v.insert(fi, 31);
+	fi = v.insert(fi, 32);
+
+	assert(v.size() == 16);
+	assert(v[0] == 20);
+	assert(v[15] == 22);
+	assert(v[8] == 32);
+
+	fi = opp::find(v.begin(), v.end(), 32);
+
+	for(int i=0; i<30; i++)
+	{
+		fi = v.insert(fi, i + 40);
+	}
+
+	assert(v.size() == 46);
+	assert(v[28] == 60);
+
+	v.erase(10, 10);
+
+	for(int i : v) 
+		opp::cout << i << ", ";
+	opp::cout << "\n";
+
+	assert(v.size() == 36);
+	assert(v[18] == 60);
+
+	v.assign(42, 11);
+
+	assert(v.size() == 42);
+	assert(v[0] == 11);
+	assert(v[15] == 11);
+	assert(v[41] == 11);
+
+	return 0;
+}

autotest/opp_vector_string.cpp

@@ -0,0 +1,38 @@
+#include <opp/vector.h>
+#include <opp/string.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <opp/iostream.h>
+
+using opp::string;
+using opp::vector;
+
+string join(const vector<string> & vs)
+{
+	string	sj;
+	for(int i=0; i<vs.size(); i++)
+		sj += vs[i];
+	return sj;
+}
+
+int main(void)
+{
+	vector<string>	vs;
+	string			a;
+
+	for(int i=0; i<10; i++)
+	{
+		vs.push_back(a);
+		a += "x";
+	}
+
+	int s = 0;
+	for(int i=0; i<10; i++)
+		s += vs[i].size();
+
+	assert(s == 45);
+
+	assert(join(vs).size() == 45);
+
+	return 0;
+}

autotest/plasma.c

@@ -0,0 +1,145 @@
+#include <stdlib.h>
+
+static const char sintab[] = {
+	128, 131, 134, 137, 140, 144, 147, 150, 153, 156, 159, 162, 165, 168, 171, 174, 177, 179, 182, 185, 188, 191, 193, 196, 199, 201, 204, 206, 209, 211, 213, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 235, 237, 239, 240, 241, 243, 244, 245, 246, 248, 249, 250, 250, 251, 252, 253, 253, 254, 254, 254, 255, 255, 255, 
+	255, 255, 255, 255, 254, 254, 254, 253, 253, 252, 251, 250, 250, 249, 248, 246, 245, 244, 243, 241, 240, 239, 237, 235, 234, 232, 230, 228, 226, 224, 222, 220, 218, 216, 213, 211, 209, 206, 204, 201, 199, 196, 193, 191, 188, 185, 182, 179, 177, 174, 171, 168, 165, 162, 159, 156, 153, 150, 147, 144, 140, 137, 134, 131, 
+	128, 125, 122, 119, 116, 112, 109, 106, 103, 100, 97, 94, 91, 88, 85, 82, 79, 77, 74, 71, 68, 65, 63, 60, 57, 55, 52, 50, 47, 45, 43, 40, 38, 36, 34, 32, 30, 28, 26, 24, 22, 21, 19, 17, 16, 15, 13, 12, 11, 10, 8, 7, 6, 6, 5, 4, 3, 3, 2, 2, 2, 1, 1, 1, 
+	1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 6, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 19, 21, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 43, 45, 47, 50, 52, 55, 57, 60, 63, 65, 68, 71, 74, 77, 79, 82, 85, 88, 91, 94, 97, 100, 103, 106, 109, 112, 116, 119, 122, 125
+};
+
+char Screen0[1024], Screen1[1024];
+
+char colormap0[256], colormap1[256];
+
+
+char colors0[] = {0, 6, 14, 1, 13, 5, 0};
+char colors1[] = {0, 9, 7, 1, 15, 12, 0};
+
+unsigned c1A, c1B, c2A, c2B, c3A, c3B;
+int d1A, d1B, d2A, d2B, d3A, d3B;
+
+void inithires(void)
+{
+	for(int i=0; i<256; i++)
+	{
+		colormap0[i] = colors0[i / 37];
+		colormap1[i] = colors1[i / 37] << 4;
+	}
+}
+
+inline void doplasma(char * scrn) 
+{
+    char xbuf0[40], xbuf1[40];
+    char ybuf0[25], ybuf1[25];
+
+    char c2a = c2A >> 8;
+    char c2b = c2B >> 8;
+    char c1a = c1A >> 8;
+    char c1b = c1B >> 8;
+
+    for (char i = 0; i < 25; i++) {
+        ybuf0[i] = sintab[(c1a + c2a) & 0xff] + sintab[c1b];
+        c1a += 13;
+        c1b -= 5;
+    }
+
+    for (char i = 0; i < 40; i++) {
+        xbuf0[i] = sintab[(c2a + c1b) & 0xff] + sintab[c2b];
+        c2a += 11;
+        c2b -= 7;
+    }
+
+    c2a = c2B >> 8;
+    c2b = c3A >> 8;
+    c1a = c1B >> 8;
+    c1b = c3B >> 8;
+
+    for (char i = 0; i < 25; i++) {
+        ybuf1[i] = sintab[(c1b + c2a) & 0xff] + sintab[c1a];
+        c1a += 4;
+        c1b -= 6;
+    }
+
+    for (char i = 0; i < 40; i++) {
+        xbuf1[i] = sintab[(c2b + c1a) & 0xff] + sintab[c2a];
+        c2a += 7;
+        c2b -= 9;
+    }
+
+    #pragma unroll(full)
+	for (char k=0; k<5; k++)    
+	{
+    	char tbuf0[5], tbuf1[5];
+	    #pragma unroll(full)
+	    for (char i = 0; i < 4; i++)
+	    {
+	    	tbuf0[i] = ybuf0[5 * k + i + 1] - ybuf0[5 * k + i];
+	    	tbuf1[i] = ybuf1[5 * k + i + 1] - ybuf1[5 * k + i];
+	    }
+
+	    for (signed char i = 39; i >= 0; i--) 
+	    {
+	    	char t = xbuf0[i] + ybuf0[5 * k];
+	    	char u = xbuf1[i] + ybuf1[5 * k];
+
+		    #pragma unroll(full)
+		    for (char j = 0; j < 5; j++) 
+		    {
+	            scrn[40 * j + 200 * k + i] = colormap0[u] | colormap1[u];
+		    	t += tbuf0[j];
+		    	u += tbuf1[j];		    	
+	        }
+	    }
+	}
+
+    c1A += 8 * ((int)sintab[d1A] - 128);
+    c1B += 16 * ((int)sintab[d1B] - 128);
+    c2A += 8 * ((int)sintab[d2A] - 128);
+    c2B += 16 * ((int)sintab[d2B] - 128);
+    c3A += 6 * ((int)sintab[d3A] - 128);
+    c3B += 12 * ((int)sintab[d3B] - 128);
+
+    d1A += 3;
+    d1B += rand() & 3;
+    d2A += 5;
+    d2B += rand() & 3;
+    d3A += 2;
+    d3B += rand() & 3;
+}
+
+void doplasma0(void)
+{
+	doplasma(Screen0);
+}
+
+void doplasma1(void)
+{
+	doplasma(Screen1);
+}
+
+unsigned checksum(const char * scr)
+{
+	unsigned	s = 0x1234;
+	for(int i=0; i<1024; i++)
+	{
+		unsigned	m = s & 1;
+		s >>= 1;
+		if (m)
+			s ^= 0x2152;
+		s ^= scr[i];
+	}
+	return s;
+}
+int main(void)
+{
+	inithires();
+
+	doplasma0();
+	doplasma1();
+	doplasma0();
+	doplasma1();
+	doplasma0();
+	doplasma1();
+
+	return	checksum(Screen0) + checksum(Screen1) - 16337;
+}

autotest/ptrarraycmptest.c

@@ -0,0 +1,39 @@
+#include <assert.h>
+
+struct X
+{
+	int	a;
+};
+
+X	x[5] = {
+	{1}, {2}, {3}, {4}, {5}
+};
+
+X	*	y;
+
+int main(void)
+{
+	y = x;
+	assert(y == x);
+	y = x + 1;
+	assert(y == x + 1);
+	y = &(x[2]);
+	assert(y == x + 2);
+	y = x + 3;
+	assert(y == &(x[3]));
+	y = x ;
+	assert(y == (struct X*)x);
+
+	y = x;
+	assert(x == y);
+	y = x + 1;
+	assert(x + 1 == y);
+	y = &(x[2]);
+	assert(x + 2 == y);
+	y = x + 3;
+	assert(&(x[3]) == y);
+	y = x ;
+	assert((struct X*)x == y);
+
+	return 0;
+}

autotest/ptrinittest.c

@@ -0,0 +1,37 @@
+#if 1
+
+const struct A {
+	char	w;
+	int		b[5];
+	struct {
+		int		c[5];
+	}	o;
+}	a = {22,
+	{4, 5, 6, 7, 8},
+	{
+		{4, 5, 6, 7, 8}
+	}
+};
+
+const int * t[4] = {
+	a.b + 1 + 1
+};
+
+const int * v[4] = {
+	a.o.c + 1 + 1
+};
+
+int q[5] = {4, 5, 6, 7, 8};
+
+const int * u[4] = {
+	q + 2
+};
+
+int main(void)
+{
+	return
+		u[0][0] + (q + 2)[2] - 6 - 8 +
+		v[0][0] + (a.o.c + 2)[2] - 6 - 8 +
+		t[0][0] + (a.b + 2)[2] - 6 - 8;
+}
+

autotest/qsorttest.c

@@ -0,0 +1,83 @@
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+
+struct Node
+{
+	int		a;
+	char	s[10];
+};
+
+void qsort(Node * n, int s)
+{
+	if (s > 1)
+	{
+		Node	pn = n[0];
+		int 	pi = 0;
+		for(int i=1; i<s; i++)
+		{
+			if (strcmp(n[i].s, pn.s) < 0)
+			{
+				n[pi] = n[i];
+				pi++;
+				n[i] = n[pi];
+			}
+		}
+		n[pi] = pn;
+
+		qsort(n, pi);
+		qsort(n + pi + 1, s - pi - 1);
+	}
+}
+
+void shuffle(Node * n, int s)
+{
+	for(int i=0; i<s; i++)
+	{
+		int t = rand() % s;
+		Node	nt = n[i]; n[i] = n[t]; n[t] = nt;
+	}
+}
+
+void init(Node * n, int s)
+{
+	for(int i=0; i<s; i++)
+	{
+		n[i].a = i;
+		sprintf(n[i].s, "%.5d", i);
+	}
+}
+
+static const int size = 1000;
+
+Node	field[size];
+
+void show(Node * n, int s)
+{
+	for(int i=0; i<s; i++)
+	{
+		printf("%3d : %3d, %s\n", i, n[i].a, n[i].s);
+	}
+	printf("\n");
+}
+
+void check(Node * n, int s)
+{
+	for(int i=0; i<s; i++)
+	{
+		assert(n[i].a == i);
+	}
+}
+
+int main(void)
+{
+	init(field, size);
+//	show(field, size);
+	shuffle(field, size);
+//	show(field, size);
+	qsort(field, size);
+//	show(field, size);
+	check(field, size);
+
+	return 0;
+}

autotest/randsumtest.c

@@ -0,0 +1,16 @@
+// randsumtest	
+
+#include <stdlib.h>
+#include <assert.h>
+
+int main(void)
+{
+	long	lsum = 0;
+	for(unsigned i=0; i<1000; i++)
+		lsum += rand();
+	
+	assert(lsum == 32157742L);
+	
+	return 0;
+}
+

autotest/recursiontest.c

@@ -1,6 +1,7 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
 
 int fib(int a) 
 {

autotest/rolrortest.cpp

@@ -0,0 +1,76 @@
+#include <assert.h>
+
+__noinline unsigned long rollright32(unsigned long a) {
+    unsigned long tmp = a & 1;
+    return ( a >> 1) + (tmp << 31);
+}
+
+__noinline unsigned rollright16(unsigned a) {
+    unsigned tmp = a & 1;
+    return ( a >> 1) + (tmp << 15);
+}
+
+__noinline char rollright8(char a) {
+    char tmp = a & 1;
+    return ( a >> 1) + (tmp << 7); 
+}
+
+__noinline unsigned long rollleft32(unsigned long a) {
+    unsigned long tmp = (a >> 31) & 1;
+    return ( a << 1) + tmp; 
+}
+
+__noinline unsigned rollleft16(unsigned a) {
+    unsigned tmp = (a >> 15) & 1;
+    return ( a << 1) + tmp; 
+}
+
+__noinline char rollleft8(char a) {
+    char tmp = (a >> 7) & 1;
+    return ( a << 1) + tmp; 
+}
+
+int main() {
+    unsigned long lv = 0x12345678ul;
+    unsigned val = 0x1234;
+    char c=0x12;
+
+    unsigned long lvt[33];
+    unsigned valt[17];
+    char ct[9];
+
+    lvt[0] = lv;
+    valt[0] = val;
+    ct[0] = c;  
+
+    assert(rollleft8(rollright8(c)) == c);
+    assert(rollleft16(rollright16(val)) == val);
+    assert(rollleft32(rollright32(lv)) == lv);
+     
+    for(int i=0; i<32; i++)
+        lvt[i + 1] = rollright32(lvt[i]);
+    for(int i=0; i<16; i++)
+        valt[i + 1] = rollright16(valt[i]);
+    for(int i=0; i<8; i++)
+        ct[i + 1] = rollright8(ct[i]);
+
+    for(int i=0; i<=32; i++)
+    {        
+        assert(lvt[32 - i] == lv);
+        lv = rollleft32(lv);
+    }
+
+    for(int i=0; i<=16; i++)
+    {        
+        assert(valt[16 - i] == val);
+        val = rollleft16(val);
+    }
+
+    for(int i=0; i<=8; i++)
+    {        
+        assert(ct[8 - i] == c);
+        c = rollleft8(c);
+    }
+
+    return 0;
+}

autotest/scrolltest.c

@@ -0,0 +1,107 @@
+#include <assert.h>
+
+#define Screen ((char *)0x0400)
+
+void scroll_left(void)
+{
+	char	*	dp = Screen;
+	for(char y=0; y<25; y++)
+	{
+		for(char x=0; x<39; x++)
+		{
+			dp[x] = dp[x + 1];
+		}
+		dp += 40;
+	}
+}
+
+void scroll_right(void)
+{
+	char	*	dp = Screen;
+	for(char y=0; y<25; y++)
+	{
+		for(char x=39; x>0; x--)
+		{
+			dp[x] = dp[x - 1];
+		}
+		dp += 40;
+	}
+}
+
+void scroll_up(void)
+{
+	char	*	dp = Screen, * sp = dp + 40;
+	for(char y=0; y<24; y++)
+	{
+		for(char x=0; x<40; x++)
+		{
+			dp[x] = sp[x];
+		}
+		dp = sp;
+		sp += 40;
+	}
+}
+
+void scroll_down(void)
+{
+	char	*	dp = Screen + 24 * 40, * sp = dp - 40;
+	for(char y=0; y<24; y++)
+	{
+		for(char x=0; x<40; x++)
+		{
+			dp[x] = sp[x];
+		}
+		dp = sp;
+		sp -= 40;
+	}
+}
+
+void fill_screen(void)
+{
+	for(char y=0; y<25; y++)
+	{
+		for(char x=0; x<40; x++)
+		{
+			Screen[40 * y + x] = 7 * y + x;
+		}
+	}
+}
+
+void check_screen(int dy, int dx)
+{
+	for(int y=0; y<25; y++)
+	{
+		for(int x=0; x<40; x++)
+		{
+			int sy = y + dy;
+			int sx = x + dx;
+
+			char	c = 7 * y + x;
+			if (sy >= 0 && sy < 25 && sx >= 0 && sx < 40)
+				c = 7 * sy + sx;
+
+			assert(Screen[40 * y + x] == c);
+		}
+	}
+}
+
+int main(void)
+{
+	fill_screen();
+	scroll_left();
+	check_screen(0, 1);
+
+	fill_screen();
+	scroll_right();
+	check_screen(0, -1);
+
+	fill_screen();
+	scroll_up();
+	check_screen(1, 0);
+
+	fill_screen();
+	scroll_down();
+	check_screen(-1, 0);
+
+	return 0;
+}

autotest/sprintftest.c

@@ -0,0 +1,321 @@
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+void testi(const char * fmt, int val, const char * tst)
+{
+	char	buffer[32];
+
+	sprintf(buffer, fmt, val);
+	printf("%s:%s\n", buffer, tst);
+	assert(!strcmp(buffer, tst));
+}
+
+void testu(const char * fmt, unsigned val, const char * tst)
+{
+	char	buffer[32];
+
+	sprintf(buffer, fmt, val);
+	printf("%s:%s\n", buffer, tst);
+	assert(!strcmp(buffer, tst));
+}
+
+void testil(const char * fmt, long val, const char * tst)
+{
+	char	buffer[32];
+
+	sprintf(buffer, fmt, val);
+	printf("%s:%s\n", buffer, tst);
+	assert(!strcmp(buffer, tst));
+}
+
+void testul(const char * fmt, unsigned long val, const char * tst)
+{
+	char	buffer[32];
+
+	sprintf(buffer, fmt, val);
+	printf("%s:%s\n", buffer, tst);
+	assert(!strcmp(buffer, tst));
+}
+
+void testf(const char * fmt, float val, const char * tst)
+{
+	char	buffer[32];
+
+	sprintf(buffer, fmt, val);
+	printf("%s:%s\n", buffer, tst);
+	assert(!strcmp(buffer, tst));
+}
+
+
+int main(void)
+{
+	testi("%d",  0, "0");
+	testi("%d",  1, "1");
+	testi("%d", -1, "-1");
+	testi("%d", 12, "12");
+	testi("%d", 123, "123");
+	testi("%d", 1234, "1234");
+	testi("%d", 12345, "12345");
+	testi("%d", -12345, "-12345");
+	testi("%d", 32767, "32767");
+	testi("%d", -32768, "-32768");
+
+	testi("%3d",  0, "  0");
+	testi("%3d",  1, "  1");
+	testi("%3d", -1, " -1");
+	testi("%3d", 12, " 12");
+	testi("%3d", 123, "123");
+	testi("%3d", 1234, "1234");
+	testi("%3d", 12345, "12345");
+	testi("%3d", -12345, "-12345");
+	testi("%3d", 32767, "32767");
+	testi("%3d", -32768, "-32768");
+
+	testi("%03d",  0, "000");
+	testi("%03d",  1, "001");
+//	testi("%03d", -1, "-01");
+	testi("%03d", 12, "012");
+	testi("%03d", 123, "123");
+	testi("%03d", 1234, "1234");
+	testi("%03d", 12345, "12345");
+	testi("%03d", -12345, "-12345");
+	testi("%03d", 32767, "32767");
+	testi("%03d", -32768, "-32768");
+
+	testi("%-4d",  0, "0   ");
+	testi("%-4d",  1, "1   ");
+	testi("%-4d", -1, "-1  ");
+	testi("%-4d", 12, "12  ");
+	testi("%-4d", 123, "123 ");
+	testi("%-4d", 1234, "1234");
+	testi("%-4d", 12345, "12345");
+	testi("%-4d", -12345, "-12345");
+	testi("%-4d", 32767, "32767");
+	testi("%-4d", -32768, "-32768");
+
+	testi("%+d",  0, "+0");
+	testi("%+d",  1, "+1");
+	testi("%+d", -1, "-1");
+	testi("%+d", 12, "+12");
+	testi("%+d", 123, "+123");
+	testi("%+d", 1234, "+1234");
+	testi("%+d", 12345, "+12345");
+	testi("%+d", -12345, "-12345");
+	testi("%+d", 32767, "+32767");
+	testi("%+d", -32768, "-32768");
+
+
+
+	testil("%ld",  0l, "0");
+	testil("%ld",  1l, "1");
+	testil("%ld", -1l, "-1");
+	testil("%ld", 12l, "12");
+	testil("%ld", 123l, "123");
+	testil("%ld", 1234l, "1234");
+	testil("%ld", 12345l, "12345");
+	testil("%ld", -12345l, "-12345");
+	testil("%ld", 32767l, "32767");
+	testil("%ld", -32768l, "-32768");
+	testil("%ld", 2147483647l, "2147483647");
+	testil("%ld", -2147483648l, "-2147483648");
+
+	testil("%3ld",  0l, "  0");
+	testil("%3ld",  1l, "  1");
+	testil("%3ld", -1l, " -1");
+	testil("%3ld", 12l, " 12");
+	testil("%3ld", 123l, "123");
+	testil("%3ld", 1234l, "1234");
+	testil("%3ld", 12345l, "12345");
+	testil("%3ld", -12345l, "-12345");
+	testil("%3ld", 32767l, "32767");
+	testil("%3ld", -32768l, "-32768");
+	testil("%3ld", 2147483647l, "2147483647");
+	testil("%3ld", -2147483648l, "-2147483648");
+
+	testil("%03ld",  0l, "000");
+	testil("%03ld",  1l, "001");
+//	testil("%03ld", -1l, "-01");
+	testil("%03ld", 12l, "012");
+	testil("%03ld", 123l, "123");
+	testil("%03ld", 1234l, "1234");
+	testil("%03ld", 12345l, "12345");
+	testil("%03ld", -12345l, "-12345");
+	testil("%03ld", 32767l, "32767");
+	testil("%03ld", -32768l, "-32768");
+	testil("%03ld", 2147483647l, "2147483647");
+	testil("%03ld", -2147483648l, "-2147483648");
+
+	testil("%-4ld",  0l, "0   ");
+	testil("%-4ld",  1l, "1   ");
+	testil("%-4ld", -1l, "-1  ");
+	testil("%-4ld", 12l, "12  ");
+	testil("%-4ld", 123l, "123 ");
+	testil("%-4ld", 1234l, "1234");
+	testil("%-4ld", 12345l, "12345");
+	testil("%-4ld", -12345l, "-12345");
+	testil("%-4ld", 32767l, "32767");
+	testil("%-4ld", -32768l, "-32768");
+	testil("%-4ld", 2147483647l, "2147483647");
+	testil("%-4ld", -2147483648l, "-2147483648");
+
+	testil("%+ld",  0l, "+0");
+	testil("%+ld",  1l, "+1");
+	testil("%+ld", -1l, "-1");
+	testil("%+ld", 12l, "+12");
+	testil("%+ld", 123l, "+123");
+	testil("%+ld", 1234l, "+1234");
+	testil("%+ld", 12345l, "+12345");
+	testil("%+ld", -12345l, "-12345");
+	testil("%+ld", 32767l, "+32767");
+	testil("%+ld", -32768l, "-32768");
+	testil("%+ld", 2147483647l, "+2147483647");
+	testil("%+ld", -2147483648l, "-2147483648");
+
+	testu("%u",  0, "0");
+	testu("%u",  1, "1");
+	testu("%u", 12, "12");
+	testu("%u", 123, "123");
+	testu("%u", 1234, "1234");
+	testu("%u", 12345, "12345");
+	testu("%u", 32767, "32767");
+	testu("%u", 32768, "32768");
+	testu("%u", 65535, "65535");
+	testu("%x", 0, "0");
+	testu("%x", 0x49bf, "49BF");
+	testu("%x", 0xffff, "FFFF");
+
+	testu("%3u",  0, "  0");
+	testu("%3u",  1, "  1");
+	testu("%3u", 12, " 12");
+	testu("%3u", 123, "123");
+	testu("%3u", 1234, "1234");
+	testu("%3u", 12345, "12345");
+	testu("%3u", 32767, "32767");
+	testu("%3u", 32768, "32768");
+	testu("%3u", 65535, "65535");
+	testu("%3x", 0, "  0");
+	testu("%3x", 0x49bf, "49BF");
+	testu("%3x", 0xffff, "FFFF");
+
+	testu("%03u",  0, "000");
+	testu("%03u",  1, "001");
+	testu("%03u", 12, "012");
+	testu("%03u", 123, "123");
+	testu("%03u", 1234, "1234");
+	testu("%03u", 12345, "12345");
+	testu("%03u", 32767, "32767");
+	testu("%03u", 32768, "32768");
+	testu("%03u", 65535, "65535");
+	testu("%03x", 0, "000");
+	testu("%03x", 0x49bf, "49BF");
+	testu("%03x", 0xffff, "FFFF");
+
+	testu("%-4u",  0, "0   ");
+	testu("%-4u",  1, "1   ");
+	testu("%-4u", 12, "12  ");
+	testu("%-4u", 123, "123 ");
+	testu("%-4u", 1234, "1234");
+	testu("%-4u", 12345, "12345");
+	testu("%-4u", 32767, "32767");
+	testu("%-4u", 32768, "32768");
+	testu("%-4u", 65535, "65535");
+	testu("%-4x", 0, "0   ");
+	testu("%-4x", 0x49bf, "49BF");
+	testu("%-4x", 0xffff, "FFFF");
+
+	testul("%3lu",  0l, "  0");
+	testul("%3lu",  1l, "  1");
+	testul("%3lu", 12l, " 12");
+	testul("%3lu", 123l, "123");
+	testul("%3lu", 1234l, "1234");
+	testul("%3lu", 12345l, "12345");
+	testul("%3lu", 32767l, "32767");
+	testul("%3lu", 2147483647l, "2147483647");
+	testul("%3lu", 4294967295l, "4294967295");
+	testul("%3lx", 0, "  0");
+	testul("%3lx", 0x3576fbcdl, "3576FBCD");
+	testul("%3lx", 0xffffffffl, "FFFFFFFF");
+
+	testul("%03lu",  0l, "000");
+	testul("%03lu",  1l, "001");
+	testul("%03lu", 12l, "012");
+	testul("%03lu", 123l, "123");
+	testul("%03lu", 1234l, "1234");
+	testul("%03lu", 12345l, "12345");
+	testul("%03lu", 32767l, "32767");
+	testul("%03lu", 2147483647l, "2147483647");
+	testul("%03lu", 4294967295l, "4294967295");
+	testul("%03lx", 0, "000");
+	testul("%03lx", 0x3576fbcdl, "3576FBCD");
+	testul("%03lx", 0xffffffffl, "FFFFFFFF");
+
+	testul("%-4lu",  0l, "0   ");
+	testul("%-4lu",  1l, "1   ");
+	testul("%-4lu", 12l, "12  ");
+	testul("%-4lu", 123l, "123 ");
+	testul("%-4lu", 1234l, "1234");
+	testul("%-4lu", 12345l, "12345");
+	testul("%-4lu", 32767l, "32767");
+	testul("%-4lu", 2147483647l, "2147483647");
+	testul("%-4lu", 4294967295l, "4294967295");
+	testul("%-4lx", 0, "0   ");
+	testul("%-4lx", 0x3576fbcdl, "3576FBCD");
+	testul("%-4lx", 0xffffffffl, "FFFFFFFF");
+
+	testul("%+lu",  0l, "+0");
+	testul("%+lu",  1l, "+1");
+	testul("%+lu", 12l, "+12");
+	testul("%+lu", 123l, "+123");
+	testul("%+lu", 1234l, "+1234");
+	testul("%+lu", 12345l, "+12345");
+	testul("%+lu", 32767l, "+32767");
+	testul("%+lu", 2147483647l, "+2147483647");
+	testul("%+lu", 4294967295l, "+4294967295");
+
+	testf("%f",  0., "0.000000");
+	testf("%f",  1., "1.000000");
+	testf("%f", -1., "-1.000000");
+	testf("%f", 12., "12.000000");
+	testf("%f", 123., "123.000000");
+	testf("%f", 1234., "1234.000000");
+	testf("%f", 12345., "12345.000000");
+	testf("%f", 123456., "123456.000000");
+	testf("%f", 1234567., "1234567.000000");
+	testf("%f",  0.1, "0.100000");
+	testf("%f",  0.01, "0.010000");
+	testf("%f",  0.001, "0.001000");
+	testf("%f",  0.0001, "0.000100");
+	testf("%f",  0.00001, "0.000010");
+	testf("%f",  0.000001, "0.000001");
+
+	testf("%5.1f",  0, "  0.0");
+	testf("%5.1f",  1, "  1.0");
+	testf("%5.1f", -1, " -1.0");
+	testf("%5.1f",  10, " 10.0");
+	testf("%5.1f", -10, "-10.0");
+	testf("%5.1f",  100, "100.0");
+	testf("%5.1f", -100, "-100.0");
+	testf("%5.1f",  0.1, "  0.1");
+	testf("%5.1f", -0.1, " -0.1");
+	testf("%5.1f",  0.04, "  0.0");
+	testf("%5.1f", -0.04, " -0.0");
+	testf("%5.1f",  0.051, "  0.1");
+	testf("%5.1f", -0.051, " -0.1");
+
+	testf("%+5.1f",  0, " +0.0");
+	testf("%+5.1f",  1, " +1.0");
+	testf("%+5.1f", -1, " -1.0");
+	testf("%+5.1f",  10, "+10.0");
+	testf("%+5.1f", -10, "-10.0");
+	testf("%+5.1f",  100, "+100.0");
+	testf("%+5.1f", -100, "-100.0");
+	testf("%+5.1f",  0.1, " +0.1");
+	testf("%+5.1f", -0.1, " -0.1");
+	testf("%+5.1f",  0.04, " +0.0");
+	testf("%+5.1f", -0.04, " -0.0");
+	testf("%+5.1f",  0.051, " +0.1");
+	testf("%+5.1f", -0.051, " -0.1");
+
+	return 0;
+}

autotest/stdlibtest.c

@@ -1,5 +1,6 @@
 // stdlibtest
 
+
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
@@ -50,16 +51,15 @@ void heapcheck(void)
 		for(i=0; i<s; i++)
 		{
 			if (p[i] != n)
-			{
-				printf("MemError %d at %d:%d != %d\n", k, i, n, p[i]);
 				exit(-2);
 		}
-		}
 		free(memp[n]);
 		
 		s = rand() % 100 + 3;
 		mems[n] = s;
 		memp[n] = malloc(s);
+		if (!memp[n])
+			exit(-3);
 		memset(memp[n], n, s);
 	}
 }

autotest/strcmptest2.c

@@ -0,0 +1,28 @@
+#include <string.h>
+#include <assert.h>
+
+char	aa[2000], ba[2000];
+
+int main(void)
+{
+	assert(strcmp("abcdefgh", "abcdefgh") == 0);
+	assert(strcmp("abcdefgh", "abcdemgh") < 0);
+	assert(strcmp("abcdefgh", "abcdefghi") < 0);
+	assert(strcmp("abcdefghi", "abcdefgh") > 0);
+	assert(strcmp("abcdemgh", "abcdefgh") > 0);
+
+	for(int i=0; i<1900; i++)
+	{
+		aa[i] = 'a' + (i & 7);
+	}
+	aa[1900] = 0;
+	
+	strcpy(ba, aa);
+	
+	assert(strcmp(aa, ba) == 0);
+	ba[1000] = 'z';
+	assert(strcmp(aa, ba) < 0);
+	assert(strcmp(ba, aa) > 0);
+	
+	return 0;
+}

autotest/stripedarraytest.c

@@ -0,0 +1,299 @@
+#include <assert.h>
+
+
+int a100[100];
+__striped int b100[100];
+__striped int c100[100];
+
+unsigned a256[256];
+__striped unsigned b256[256];
+__striped unsigned c256[256];
+
+#pragma align(c100, 256)
+#pragma align(c256, 256)
+
+void test_ab100(void)
+{
+	for(char i=0; i<100; i++)
+	{
+		a100[i] = i * i;
+		b100[i] = i * i;
+		c100[i] = i * i;
+	}
+
+	a100[31] = 4711;
+	b100[31] = 4711;
+	c100[31] = 4711;
+
+
+	for(char i=0; i<100; i++)
+	{
+		a100[i] += i; a100[i] -= 5; a100[i] = a100[i] + a100[99 - i];
+		b100[i] += i; b100[i] -= 5; b100[i] = b100[i] + b100[99 - i];
+		c100[i] += i; c100[i] -= 5; c100[i] = c100[i] + c100[99 - i];
+	}
+
+	for(char i=0; i<100; i++)
+	{
+		assert(a100[i] == b100[i]);
+		assert(a100[i] == c100[i]);
+	}
+}
+
+void test_ab256(void)
+{
+	for(unsigned i=0; i<256; i++)
+	{
+		a256[i] = i * i;
+		b256[i] = i * i;
+		c256[i] = i * i;
+	}
+
+	a256[31] = 4711;
+	b256[31] = 4711;
+	c256[31] = 4711;
+
+	for(unsigned i=0; i<256; i++)
+	{
+		a256[i] += i; a256[i] -= 5; a256[i] = a256[i] + a256[255 - i];
+		b256[i] += i; b256[i] -= 5; b256[i] = b256[i] + b256[255 - i];
+		c256[i] += i; c256[i] -= 5; c256[i] = c256[i] + c256[255 - i];
+	}
+
+	for(unsigned i=0; i<256; i++)
+	{
+		assert(a256[i] == b256[i]);
+		assert(a256[i] == c256[i]);
+	}
+}
+
+long la50[50];
+__striped long lb50[50];
+__striped long lc50[50];
+
+unsigned long la256[256];
+__striped unsigned long lb256[256];
+__striped unsigned long lc256[256];
+
+#pragma align(lc50, 256)
+#pragma align(lc256, 256)
+
+void test_lab50(void)
+{
+	for(char i=0; i<50; i++)
+	{
+		long j = i * i;
+		la50[i] = j * j;
+		lb50[i] = j * j;
+		lc50[i] = j * j;
+	}
+
+	la50[31] = 47110815l;
+	lb50[31] = 47110815l;
+	lc50[31] = 47110815l;
+
+	for(char i=0; i<50; i++)
+	{
+		la50[i] += i; la50[i] -= 12345678l; la50[i] = la50[i] + la50[49 - i];
+		lb50[i] += i; lb50[i] -= 12345678l; lb50[i] = lb50[i] + lb50[49 - i];
+		lc50[i] += i; lc50[i] -= 12345678l; lc50[i] = lc50[i] + lc50[49 - i];
+	}
+
+	for(char i=0; i<50; i++)
+	{
+		assert(la50[i] == lb50[i]);
+		assert(la50[i] == lc50[i]);
+	}
+}
+
+void test_lab256(void)
+{
+	for(unsigned i=0; i<256; i++)
+	{
+		unsigned long j = i * i;
+		la256[i] = j * j;
+		lb256[i] = j * j;
+		lc256[i] = j * j;
+	}
+
+	la256[31] = 47110815ul;
+	lb256[31] = 47110815ul;
+	lc256[31] = 47110815ul;
+
+	for(unsigned i=0; i<256; i++)
+	{
+		la256[i] += i; la256[i] -= 12345678ul; la256[i] = la256[i] + la256[255 - i];
+		lb256[i] += i; lb256[i] -= 12345678ul; lb256[i] = lb256[i] + lb256[255 - i];
+		lc256[i] += i; lc256[i] -= 12345678ul; lc256[i] = lc256[i] + lc256[255 - i];
+	}
+
+	for(unsigned i=0; i<256; i++)
+	{
+		assert(la256[i] == lb256[i]);
+		assert(la256[i] == lc256[i]);
+	}
+}
+
+float fa50[50];
+__striped float fb50[50];
+__striped float fc50[50];
+
+float fa256[256];
+__striped float fb256[256];
+__striped float fc256[256];
+
+#pragma align(fc50, 256)
+#pragma align(fc256, 256)
+
+void test_fab50(void)
+{
+	for(char i=0; i<50; i++)
+	{
+		fa50[i] = i * i;
+		fb50[i] = i * i;
+		fc50[i] = i * i;
+	}
+
+	fa50[31] = 4711.0815;
+	fb50[31] = 4711.0815;
+	fc50[31] = 4711.0815;
+
+	for(char i=0; i<50; i++)
+	{
+		fa50[i] += i; fa50[i] -= 1234.5678; fa50[i] = fa50[i] + fa50[49 - i];
+		fb50[i] += i; fb50[i] -= 1234.5678; fb50[i] = fb50[i] + fb50[49 - i];
+		fc50[i] += i; fc50[i] -= 1234.5678; fc50[i] = fc50[i] + fc50[49 - i];
+	}
+
+	for(char i=0; i<50; i++)
+	{
+		assert(fa50[i] == fb50[i]);
+		assert(fa50[i] == fc50[i]);
+	}
+}
+
+void test_fab256(void)
+{
+	for(unsigned i=0; i<256; i++)
+	{
+		fa256[i] = i * i;
+		fb256[i] = i * i;
+		fc256[i] = i * i;
+	}
+
+	fa256[31] = 4711.0815;
+	fb256[31] = 4711.0815;
+	fc256[31] = 4711.0815;
+
+	for(unsigned i=0; i<256; i++)
+	{
+		fa256[i] += i; fa256[i] -= 1234.5678; fa256[i] = fa256[i] + fa256[255 - i];
+		fb256[i] += i; fb256[i] -= 1234.5678; fb256[i] = fb256[i] + fb256[255 - i];
+		fc256[i] += i; fc256[i] -= 1234.5678; fc256[i] = fc256[i] + fc256[255 - i];
+	}
+
+	for(unsigned i=0; i<256; i++)
+	{
+		assert(fa256[i] == fb256[i]);
+		assert(fa256[i] == fc256[i]);
+	}
+}
+
+
+unsigned	da50[50], db50[50], dc50[50];
+
+unsigned * pa50[50];
+__striped unsigned * pb50[50];
+__striped unsigned * pc50[50];
+
+#pragma align(pc50, 256)
+
+void test_pab50(void)
+{
+	for(char i=0; i<50; i++)
+	{
+		pa50[i] = da50 + (i * 17) % 50;
+		pb50[i] = db50 + (i * 17) % 50;
+		pc50[i] = dc50 + (i * 17) % 50;
+	}
+
+	for(char i=0; i<50; i++)
+	{
+		*pa50[i] = i * i;
+		*pb50[i] = i * i;
+		*pc50[i] = i * i;
+	}
+
+	for(char i=0; i<50; i++)
+	{
+		*pa50[i] += i; *pa50[i] -= 5; *pa50[i] = *pa50[i] + *pa50[49 - i];
+		*pb50[i] += i; *pb50[i] -= 5; *pb50[i] = *pb50[i] + *pb50[49 - i];
+		*pc50[i] += i; *pc50[i] -= 5; *pc50[i] = *pc50[i] + *pc50[49 - i];
+	}
+
+	for(char i=0; i<50; i++)
+	{
+		assert(*pa50[i] == *pb50[i]);
+		assert(*pa50[i] == *pc50[i]);
+		assert(da50[i] == db50[i]);
+		assert(da50[i] == dc50[i]);
+	}
+}
+
+unsigned	da50_4[50][4], db50_4[50][4], dc50_4[50][4];
+
+void test_pab50_4(void)
+{
+	for(char i=0; i<50; i++)
+	{
+		pa50[i] = da50_4[(i * 17) % 50];
+		pb50[i] = db50_4[(i * 17) % 50];
+		pc50[i] = dc50_4[(i * 17) % 50];
+	}
+
+	for(char k=0; k<4; k++)
+	{
+		for(char i=0; i<50; i++)
+		{
+			pa50[i][k] = i * i;
+			pb50[i][k] = i * i;
+			pc50[i][k] = i * i;
+		}
+	}
+
+	for(char k=0; k<4; k++)
+	{
+		for(char i=0; i<50; i++)
+		{
+			pa50[i][k] += i; pa50[i][k] -= 5; pa50[i][k] = pa50[i][k] + pa50[49 - i][k];
+			pb50[i][k] += i; pb50[i][k] -= 5; pb50[i][k] = pb50[i][k] + pb50[49 - i][k];
+			pc50[i][k] += i; pc50[i][k] -= 5; pc50[i][k] = pc50[i][k] + pc50[49 - i][k];
+		}
+	}
+
+	for(char k=0; k<4; k++)
+	{
+		for(char i=0; i<50; i++)
+		{
+			assert(pa50[i][k] == pb50[i][k]);
+			assert(pa50[i][k] == pc50[i][k]);
+			assert(da50_4[i][k] == db50_4[i][k]);
+			assert(da50_4[i][k] == dc50_4[i][k]);
+		}
+	}
+}
+
+
+int main(void)
+{
+	test_ab100();
+	test_ab256();
+	test_lab50();
+	test_lab256();
+	test_fab50();
+	test_fab256();
+	test_pab50();
+	test_pab50_4();
+
+	return 0;
+}

autotest/strlen.c

@@ -0,0 +1,27 @@
+#include <string.h>
+#include <assert.h>
+
+char lstr[1025];
+
+int main(void)
+{
+#if 1
+	assert(strlen("") == 0);
+	assert(strlen("1") == 1);
+	assert(strlen("12") == 2);
+	assert(strlen("123") == 3);
+	assert(strlen("1234") == 4);
+	assert(strlen("12345") == 5);
+	assert(strlen("123456") == 6);
+#endif
+#if 1
+	char * dp = lstr;
+	for(int i=0; i<1024; i++)
+	{
+		*dp = 0;
+		assert(strlen(lstr) == i);
+		*dp++ = 'a';
+	}
+#endif
+	return 0;
+}

autotest/structarraycopy.c

@@ -0,0 +1,49 @@
+
+
+struct Point
+{
+	int x, y;	
+};
+
+
+Point	tcorners[8], pcorners[8];
+
+int bm_line(void)
+{
+	return 0;
+}
+
+void drawCube(void)
+{
+	for(char i=0; i<8; i++)
+	{
+		if (!(i & 1))
+			bm_line();
+		if (!(i & 2))
+			bm_line();
+		if (!(i & 4))
+			bm_line();
+
+		pcorners[i] = tcorners[i];
+	}
+}
+
+int main(void)
+{
+	for(int i=0; i<8; i++)
+	{
+		tcorners[i].x = (i + 1) * 3;
+		tcorners[i].y = (i + 1) * 7;
+	}
+
+	drawCube();
+
+	int	sum = 0;
+	for(int i=0; i<8; i++)
+	{
+		sum += pcorners[i].x;
+		sum -= tcorners[i].y;
+	}
+
+	return sum + 144;
+}

autotest/structassigntest.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+
+struct Vec3
+{
+	float	x, y, z;
+};
+
+Vec3	v;
+
+Vec3 vadd(Vec3 s1, Vec3 s2)
+{
+	Vec3	r;
+	r.x = s1.x + s2.x;
+	r.y = s1.y + s2.y;
+	r.z = s1.z + s2.z;
+	return r;
+}
+
+	
+int main(void)
+{
+	Vec3	m = {1, 2, -3}, u = {4, 5, -9}, t = {7, -2, -5};
+	
+	v.x = 99;
+	v.y = 100;
+	v.z = 101;
+	
+	v = vadd(m, vadd(u, t));
+	
+	return v.x + v.y + v.z;
+}

autotest/structmembertest.c

@@ -0,0 +1,50 @@
+#include <assert.h>
+
+struct A
+{
+	int	x[100], y[100];
+};
+
+struct V
+{
+	int	x, y, z;
+};
+
+
+void copy(A * a)
+{
+	for(int i=0; i<100; i++)
+		a->x[i] = a->y[i];
+}
+
+void shuffle(V * v)
+{
+	for(int i=0; i<100; i++)
+		v[i].x = v[i].y;
+}
+
+int main(void)
+{
+	A	a;
+	V	v[100];
+	
+	for(int i=0; i<100; i++)
+	{
+		a.y[i] = i;
+		v[i].y = i;
+	}
+	
+	copy(&a);
+	shuffle(v);
+
+	for(int i=0; i<100; i++)
+	{
+		assert(a.x[i] == i);
+		assert(v[i].x == i);
+	}
+	
+	return 0;
+}
+
+
+

autotest/structoffsettest2.c

@@ -0,0 +1,25 @@
+struct A
+{
+	int x;
+	struct B
+	{
+		int m;
+		struct C
+		{
+			int w;
+		}	c;
+	}	b;
+}	q;
+
+int test(A * a)
+{
+	a->b.c.w = 1;
+	return a->b.c.w;
+}
+
+int main(void)
+{
+	return test(&q) - 1;
+}
+
+	

autotest/switchlooptest.c

@@ -0,0 +1,48 @@
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+	char	text[14];
+	
+	for(char i=0; i<12; i++)
+	{
+		switch (i)
+		{
+		case 0:
+			text[i] = 'H';
+			break;
+		case 1:
+			text[i] = 'E';
+			break;
+		case 2:
+		case 3:
+		case 9:
+			text[i] = 'L';
+			break;
+		case 4:
+		case 7:
+			text[i] = 'O';
+			break;
+		case 5:
+			text[i] = ' ';
+			break;
+		case 6:
+			text[i] = 'W';
+			break;
+		case 8:
+			text[i] = 'R';
+			break;
+		case 10:
+			text[i] = 'D';
+			break;
+		default:
+			text[i] = 0;
+		}
+	}
+
+	printf("<%s>\n", text);
+	
+	return 0;
+}

autotest/testint16cmp.c

@@ -0,0 +1,426 @@
+#include <stdio.h>
+#include <assert.h>
+
+bool beq(int a, int b)
+{
+	return a == b;
+}
+
+bool blt(int a, int b)
+{
+	return a < b;
+}
+
+bool bgt(int a, int b)
+{
+	return a > b;
+}
+
+bool ble(int a, int b)
+{
+	return a <= b;
+}
+
+bool bge(int a, int b)
+{
+	return a >= b;
+}
+
+bool neq(int a, int b)
+{
+	return a == b;
+}
+
+#pragma native(neq)
+
+bool nlt(int a, int b)
+{
+	return a < b;
+}
+
+#pragma native(nlt)
+
+bool ngt(int a, int b)
+{
+	return a > b;
+}
+
+#pragma native(ngt)
+
+bool nle(int a, int b)
+{
+	return a <= b;
+}
+
+#pragma native(nle)
+
+bool nge(int a, int b)
+{
+	return a >= b;
+}
+
+#pragma native(nge)
+
+
+
+bool beqz(int a)
+{
+	return a == 0;
+}
+
+bool bltz(int a)
+{
+	return a < 0;
+}
+
+bool bgtz(int a)
+{
+	return a > 0;
+}
+
+bool blez(int a)
+{
+	return a <= 0;
+}
+
+bool bgez(int a)
+{
+	return a >= 0;
+}
+
+bool neqz(int a)
+{
+	return a == 0;
+}
+
+#pragma native(neqz)
+
+bool nltz(int a)
+{
+	return a < 0;
+}
+
+#pragma native(nltz)
+
+bool ngtz(int a)
+{
+	return a > 0;
+}
+
+#pragma native(ngtz)
+
+bool nlez(int a)
+{
+	return a <= 0;
+}
+
+#pragma native(nlez)
+
+bool ngez(int a)
+{
+	return a >= 0;
+}
+
+#pragma native(ngez)
+
+
+
+
+bool bequz(unsigned a)
+{
+	return a == 0;
+}
+
+bool bltuz(unsigned a)
+{
+	return a < 0;
+}
+
+bool bgtuz(unsigned a)
+{
+	return a > 0;
+}
+
+bool bleuz(unsigned a)
+{
+	return a <= 0;
+}
+
+bool bgeuz(unsigned a)
+{
+	return a >= 0;
+}
+
+bool nequz(unsigned a)
+{
+	return a == 0;
+}
+
+#pragma native(nequz)
+
+bool nltuz(unsigned a)
+{
+	return a < 0;
+}
+
+#pragma native(nltuz)
+
+bool ngtuz(unsigned a)
+{
+	return a > 0;
+}
+
+#pragma native(ngtuz)
+
+bool nleuz(unsigned a)
+{
+	return a <= 0;
+}
+
+#pragma native(nleuz)
+
+bool ngeuz(unsigned a)
+{
+	return a >= 0;
+}
+
+#pragma native(ngeuz)
+
+
+
+
+bool beq1(int a)
+{
+	return a == 1;
+}
+
+bool blt1(int a)
+{
+	return a < 1;
+}
+
+bool bgt1(int a)
+{
+	return a > 1;
+}
+
+bool ble1(int a)
+{
+	return a <= 1;
+}
+
+bool bge1(int a)
+{
+	return a >= 1;
+}
+
+bool neq1(int a)
+{
+	return a == 1;
+}
+
+#pragma native(neq1)
+
+bool nlt1(int a)
+{
+	return a < 1;
+}
+
+#pragma native(nlt1)
+
+bool ngt1(int a)
+{
+	return a > 1;
+}
+
+#pragma native(ngt1)
+
+bool nle1(int a)
+{
+	return a <= 1;
+}
+
+#pragma native(nle1)
+
+bool nge1(int a)
+{
+	return a >= 1;
+}
+
+#pragma native(nge1)
+
+
+
+void cmp(int a, int b)
+{
+	bool	beqf = beq(a, b), bltf = blt(a, b), bgtf = bgt(a, b), blef = ble(a, b), bgef = bge(a, b);
+	bool	neqf = neq(a, b), nltf = nlt(a, b), ngtf = ngt(a, b), nlef = nle(a, b), ngef = nge(a, b);
+	
+	printf("BYTE   %d, %d : EQ %d LT %d GT %d\r", a, b, beqf, bltf, bgtf);
+	printf("NATIVE %d, %d : EQ %d LT %d GT %d\r", a, b, neqf, nltf, ngtf);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+void cmpz(int a)
+{
+	bool	beqf = beqz(a), bltf = bltz(a), bgtf = bgtz(a), blef = blez(a), bgef = bgez(a);
+	bool	neqf = neqz(a), nltf = nltz(a), ngtf = ngtz(a), nlef = nlez(a), ngef = ngez(a);
+	
+	printf("BYTE   %d, 0 : EQ %d LT %d GT %d\r", a, beqf, bltf, bgtf);
+	printf("NATIVE %d, 0 : EQ %d LT %d GT %d\r", a, neqf, nltf, ngtf);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+void cmpuz(unsigned a)
+{
+	bool	beqf = bequz(a), bltf = bltuz(a), bgtf = bgtuz(a), blef = bleuz(a), bgef = bgeuz(a);
+	bool	neqf = nequz(a), nltf = nltuz(a), ngtf = ngtuz(a), nlef = nleuz(a), ngef = ngeuz(a);
+	
+	printf("BYTE   %u, 0 : EQ %u LT %d GT %u\r", a, beqf, bltf, bgtf);
+	printf("NATIVE %u, 0 : EQ %u LT %d GT %u\r", a, neqf, nltf, ngtf);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+void cmp1(int a)
+{
+	bool	beqf = beq1(a), bltf = blt1(a), bgtf = bgt1(a), blef = ble1(a), bgef = bge1(a);
+	bool	neqf = neq1(a), nltf = nlt1(a), ngtf = ngt1(a), nlef = nle1(a), ngef = nge1(a);
+	
+	printf("BYTE   %d, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, beqf, bltf, bgtf, blef, bgef);
+	printf("NATIVE %d, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, neqf, nltf, ngtf, nlef, ngef);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+int main(void)
+{
+	cmp( 0,  1);
+	cmp( 0, -1);
+	cmp( 1,  0);
+	cmp(-1,  0);
+
+	cmp(1, 1);
+	cmp(1, 2);
+	cmp(2, 1);
+
+	cmp(-1, -1);
+	cmp(-1, -2);
+	cmp(-2, -1);
+	
+	cmp( 1, -1);
+	cmp( 1, -2);
+	cmp( 2, -1);
+
+	cmp(-1,  1);
+	cmp(-1,  2);
+	cmp(-2,  1);
+
+
+	cmp( 0,  10000);
+	cmp( 0, -10000);
+	cmp( 10000,  0);
+	cmp(-10000,  0);
+
+	cmp(10000, 10000);
+	cmp(10000, 20000);
+	cmp(20000, 10000);
+
+	cmp(-10000, -10000);
+	cmp(-10000, -20000);
+	cmp(-20000, -10000);
+	
+	cmp( 10000, -10000);
+	cmp( 10000, -20000);
+	cmp( 20000, -10000);
+
+	cmp(-10000,  10000);
+	cmp(-10000,  20000);
+	cmp(-20000,  10000);
+
+	cmp(-30000,  30000);
+	cmp(-30000, -30000);
+	cmp( 30000,  30000);
+	cmp( 30000, -30000);
+	
+	cmp( 0,  1024);
+	cmp( 0, -1024);
+	cmp( 1024,  0);
+	cmp(-1024,  0);
+
+	cmp(1024, 1024);
+	cmp(1024, 1025);
+	cmp(1025, 1024);
+
+	cmp(-1024, -1024);
+	cmp(-1024, -1025);
+	cmp(-1025, -1024);
+	
+	cmp( 1024, -1024);
+	cmp( 1024, -1025);
+	cmp( 1025, -1024);
+
+	cmp(-1024,  1024);
+	cmp(-1024,  1025);
+	cmp(-1025,  1024);
+
+	cmpz(0);
+	cmpz(1);
+	cmpz(255);
+	cmpz(256);
+	cmpz(10000);
+	cmpz(20000);
+	cmpz(-1);
+	cmpz(-255);
+	cmpz(-256);
+	cmpz(-10000);
+	cmpz(-20000);
+
+	cmpuz(0);
+	cmpuz(1);
+	cmpuz(255);
+	cmpuz(256);
+	cmpuz(10000);
+	cmpuz(20000);
+	cmpuz(40000);
+	cmpuz(32767);
+	cmpuz(32768);
+	cmpuz(65535);
+
+	cmp1(0);
+	cmp1(1);
+	cmp1(2);
+	cmp1(3);
+	cmp1(255);
+	cmp1(256);
+	cmp1(10000);
+	cmp1(20000);
+	cmp1(-1);
+	cmp1(-2);
+	cmp1(-3);
+	cmp1(-255);
+	cmp1(-256);
+	cmp1(-10000);
+	cmp1(-20000);
+
+	return 0;
+	
+}

autotest/testint16mul.c

@@ -0,0 +1,23 @@
+#include <assert.h>
+
+int mul[32][32];
+
+int main(void)
+{
+	for(int i=0; i<32; i++)
+		for(int j=0; j<32; j++)
+			mul[i][j] = i * j;
+#assign xi 0
+#repeat
+
+	for(int j=0; j<32; j++)
+	{
+		assert(mul[xi][j] == xi * j);
+		assert(mul[j][xi] == j * xi);
+	}
+	
+#assign xi xi + 1
+#until xi == 32
+
+	return 0;
+}

autotest/testint32.c

@@ -0,0 +1,166 @@
+#include <assert.h>
+
+void testmuli(long a, long b, long ab)
+{
+	assert (a * b == ab);
+}
+
+void testmulu(unsigned long a, unsigned long b, unsigned long ab)
+{
+	assert (a * b == ab);
+}
+
+void testdivi(long a, long b, long ab)
+{
+	assert (a / b == ab);
+}
+
+void shltesti(long a, long b, long ab)
+{
+	assert (a << b == ab);
+}
+
+void shrtesti(long a, long b, long ab)
+{
+	assert (a >> b == ab);
+}
+
+long sieve(long size)
+{
+	bool	sieve[1000];
+	
+	for(long i=0; i<size; i+=2)
+	{
+		sieve[i] = false;
+		sieve[i+1] = true;
+	}
+	sieve[2] = true;
+	
+	for (long i = 3; i * i < size;)
+	{
+		long j = i * i;
+		while (j < size)
+		{
+			sieve[j] = false;
+			j += 2 * i;
+		}
+		do {i++;} while (i < size && !sieve[i]);
+	}	
+	
+	long	num = 0;
+	for(long i=0; i<size; i++)
+	{
+		if (sieve[i])
+			num++;			
+	}
+	
+	return num;
+}
+
+int main(void)
+{	
+	testmuli(0, 0, 0);
+	testmuli(1, 0, 0);
+	testmuli(0, 1, 0);
+
+	testmuli( 1,  1,  1);
+	testmuli(-1,  1, -1);
+	testmuli(-1, -1,  1);
+	testmuli( 1, -1, -1);
+	
+	testmuli(5, 5, 25);
+
+	testmuli( 127,  255, 32385);
+	testmuli(-127,  255, -32385);
+	testmuli( 127, -255, -32385);
+	testmuli(-127, -255, 32385);
+
+	testmuli( 1237,  1024, 1266688l);
+	testmuli(-1237,  1024, -1266688l);
+	testmuli( 1237, -1024, -1266688l);
+	testmuli(-1237, -1024, 1266688l);
+
+	testmuli(  1024, 1237, 1266688l);
+	testmuli(  1024,-1237, -1266688l);
+	testmuli( -1024, 1237, -1266688l);
+	testmuli( -1024,-1237, 1266688l);
+
+	testmulu(0x00000001, 0x0000003c, 0x0000003c);
+	testmulu(0x00000100, 0x0000003c, 0x00003c00);
+	testmulu(0x00010000, 0x0000003c, 0x003c0000);
+	testmulu(0x01000000, 0x0000003c, 0x3c000000);
+
+	testmulu(0x0000003c, 0x00000001, 0x0000003c);
+	testmulu(0x0000003c, 0x00000100, 0x00003c00);
+	testmulu(0x0000003c, 0x00010000, 0x003c0000);
+	testmulu(0x0000003c, 0x01000000, 0x3c000000);
+
+	testmulu(0x0000004b, 0x0000003c, 0x00001194);
+	testmulu(0x00004b00, 0x0000003c, 0x00119400);
+	testmulu(0x004b0000, 0x0000003c, 0x11940000);
+	testmulu(0x4b000000, 0x0000003c, 0x94000000);
+
+	testmulu(0x0000003c, 0x0000004b, 0x00001194);
+	testmulu(0x0000003c, 0x00004b00, 0x00119400);
+	testmulu(0x0000003c, 0x004b0000, 0x11940000);
+	testmulu(0x0000003c, 0x4b000000, 0x94000000);
+
+	testdivi( 1,  1,  1);
+	testdivi(-1,  1, -1);
+	testdivi( 1, -1, -1);
+	testdivi(-1, -1,  1);
+	
+	testdivi( 11,  4,  2);
+	testdivi(-11,  4, -2);
+	testdivi( 11, -4, -2);
+	testdivi(-11, -4,  2);
+
+	shltesti( 17, 1, 34);
+	shltesti(-17, 1, -34);
+	shltesti( 1700, 1, 3400);
+	shltesti(-1700, 1, -3400);
+
+	shrtesti( 34, 1, 17);
+	shrtesti(-34, 1, -17);
+	shrtesti( 3400, 1, 1700);
+	shrtesti(-3400, 1, -1700);
+
+	shrtesti( -1, 15, -1);
+	shrtesti(32767, 15, 0);
+	shrtesti( -1, 14, -1);
+	shrtesti(32767, 14, 1);
+
+	shltesti( -1, 14, -16384);
+	shltesti(  1, 14,  16384);
+
+	assert(sieve(200) == 47);
+	assert(sieve(1000) == 169);
+	long	a = 0, b = 0;
+	for(long i=0; i<10000; i++)
+	{
+		assert( 177 * i == a);
+		assert(-177 * i == b);
+		a += 177;
+		b -= 177;
+	}
+
+	long	c = 0, d = 0;
+	for(long i=0; i<177; i++)
+	{
+		assert( 10000 * i == c);
+		assert(-10000 * i == d);
+		c += 10000;
+		d -= 10000;
+	}
+
+	long	e = 0, f = 0;
+	for(long i=0; i<177000l; i += 1000)
+	{
+		assert( 1024 * i == e);
+		assert(-1024 * i == f);
+		e += 1024000l;
+		f -= 1024000l;
+	}
+
+	return 0;
+}

autotest/testint32cmp.c

@@ -0,0 +1,499 @@
+#include <stdio.h>
+#include <assert.h>
+
+bool beq(long a, long b)
+{
+	return a == b;
+}
+
+bool blt(long a, long b)
+{
+	return a < b;
+}
+
+bool bgt(long a, long b)
+{
+	return a > b;
+}
+
+bool ble(long a, long b)
+{
+	return a <= b;
+}
+
+bool bge(long a, long b)
+{
+	return a >= b;
+}
+
+bool neq(long a, long b)
+{
+	return a == b;
+}
+
+#pragma native(neq)
+
+bool nlt(long a, long b)
+{
+	return a < b;
+}
+
+#pragma native(nlt)
+
+bool ngt(long a, long b)
+{
+	return a > b;
+}
+
+#pragma native(ngt)
+
+bool nle(long a, long b)
+{
+	return a <= b;
+}
+
+#pragma native(nle)
+
+bool nge(long a, long b)
+{
+	return a >= b;
+}
+
+#pragma native(nge)
+
+
+
+
+inline bool ieq(long a, long b)
+{
+	return a == b;
+}
+
+inline bool ilt(long a, long b)
+{
+	return a < b;
+}
+
+inline bool igt(long a, long b)
+{
+	return a > b;
+}
+
+inline bool ile(long a, long b)
+{
+	return a <= b;
+}
+
+inline bool ige(long a, long b)
+{
+	return a >= b;
+}
+
+
+bool beqz(long a)
+{
+	return a == 0;
+}
+
+bool bltz(long a)
+{
+	return a < 0;
+}
+
+bool bgtz(long a)
+{
+	return a > 0;
+}
+
+bool blez(long a)
+{
+	return a <= 0;
+}
+
+bool bgez(long a)
+{
+	return a >= 0;
+}
+
+bool neqz(long a)
+{
+	return a == 0;
+}
+
+#pragma native(neqz)
+
+bool nltz(long a)
+{
+	return a < 0;
+}
+
+#pragma native(nltz)
+
+bool ngtz(long a)
+{
+	return a > 0;
+}
+
+#pragma native(ngtz)
+
+bool nlez(long a)
+{
+	return a <= 0;
+}
+
+#pragma native(nlez)
+
+bool ngez(long a)
+{
+	return a >= 0;
+}
+
+#pragma native(ngez)
+
+
+
+
+bool beq1(long a)
+{
+	return a == 1;
+}
+
+bool blt1(long a)
+{
+	return a < 1;
+}
+
+bool bgt1(long a)
+{
+	return a > 1;
+}
+
+bool ble1(long a)
+{
+	return a <= 1;
+}
+
+bool bge1(long a)
+{
+	return a >= 1;
+}
+
+bool neq1(long a)
+{
+	return a == 1;
+}
+
+#pragma native(neq1)
+
+bool nlt1(long a)
+{
+	return a < 1;
+}
+
+#pragma native(nlt1)
+
+bool ngt1(long a)
+{
+	return a > 1;
+}
+
+#pragma native(ngt1)
+
+bool nle1(long a)
+{
+	return a <= 1;
+}
+
+#pragma native(nle1)
+
+bool nge1(long a)
+{
+	return a >= 1;
+}
+
+#pragma native(nge1)
+
+
+
+bool beqm(long a)
+{
+	return a == -1;
+}
+
+bool bltm(long a)
+{
+	return a < -1;
+}
+
+bool bgtm(long a)
+{
+	return a > -1;
+}
+
+bool blem(long a)
+{
+	return a <= -1;
+}
+
+bool bgem(long a)
+{
+	return a >= -1;
+}
+
+
+
+bool neqm(long a)
+{
+	return a == -1;
+}
+
+#pragma native(neqm)
+
+bool nltm(long a)
+{
+	return a < -1;
+}
+
+#pragma native(nltm)
+
+bool ngtm(long a)
+{
+	return a > -1;
+}
+
+#pragma native(ngtm)
+
+bool nlem(long a)
+{
+	return a <= -1;
+}
+
+#pragma native(nlem)
+
+bool ngem(long a)
+{
+	return a >= -1;
+}
+
+#pragma native(ngem)
+
+
+
+void cmpc(long a, long b)
+{
+	bool	beqf = beq(a, b), bltf = blt(a, b), bgtf = bgt(a, b), blef = ble(a, b), bgef = bge(a, b);
+	bool	neqf = neq(a, b), nltf = nlt(a, b), ngtf = ngt(a, b), nlef = nle(a, b), ngef = nge(a, b);
+	
+	printf("BYTE   %ld, %ld : EQ %d LT %d GT %d\r", a, b, beqf, bltf, bgtf);
+	printf("NATIVE %ld, %ld : EQ %d LT %d GT %d\r", a, b, neqf, nltf, ngtf);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+void cmpi(long a, long b)
+{
+	bool	ieqf = ieq(a, b), iltf = ilt(a, b), igtf = igt(a, b), ilef = ile(a, b), igef = ige(a, b);
+	bool	neqf = neq(a, b), nltf = nlt(a, b), ngtf = ngt(a, b), nlef = nle(a, b), ngef = nge(a, b);
+	
+	printf("INLINE %ld, %ld : EQ %d LT %d GT %d\r", a, b, ieqf, iltf, igtf);
+	printf("NATIVE %ld, %ld : EQ %d LT %d GT %d\r", a, b, neqf, nltf, ngtf);
+	
+	assert(ieqf == neqf);
+	assert(iltf == nltf);
+	assert(igtf == ngtf);	
+	assert(ilef == nlef);
+	assert(igef == ngef);	
+}
+
+void cmp(long a, long b)
+{
+	cmpc(a, b);
+	cmpi(a, b);
+}
+
+void cmpz(long a)
+{
+	bool	beqf = beqz(a), bltf = bltz(a), bgtf = bgtz(a), blef = blez(a), bgef = bgez(a);
+	bool	neqf = neqz(a), nltf = nltz(a), ngtf = ngtz(a), nlef = nlez(a), ngef = ngez(a);
+	
+	printf("BYTE   %ld, 0 : EQ %d LT %d GT %d\r", a, beqf, bltf, bgtf);
+	printf("NATIVE %ld, 0 : EQ %d LT %d GT %d\r", a, neqf, nltf, ngtf);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+void cmp1(long a)
+{
+	bool	beqf = beq1(a), bltf = blt1(a), bgtf = bgt1(a), blef = ble1(a), bgef = bge1(a);
+	bool	neqf = neq1(a), nltf = nlt1(a), ngtf = ngt1(a), nlef = nle1(a), ngef = nge1(a);
+	
+	printf("BYTE   %ld, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, beqf, bltf, bgtf, blef, bgef);
+	printf("NATIVE %ld, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, neqf, nltf, ngtf, nlef, ngef);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+void cmpm(long a)
+{
+	bool	beqf = beqm(a), bltf = bltm(a), bgtf = bgtm(a), blef = blem(a), bgef = bgem(a);
+	bool	neqf = neqm(a), nltf = nltm(a), ngtf = ngtm(a), nlef = nlem(a), ngef = ngem(a);
+	
+	printf("BYTE   %ld, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, beqf, bltf, bgtf, blef, bgef);
+	printf("NATIVE %ld, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, neqf, nltf, ngtf, nlef, ngef);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+int main(void)
+{
+	cmp( 0,  1);
+	cmp( 0, -1);
+	cmp( 1,  0);
+	cmp(-1,  0);
+
+	cmp(1, 1);
+	cmp(1, 2);
+	cmp(2, 1);
+
+	cmp(-1, -1);
+	cmp(-1, -2);
+	cmp(-2, -1);
+	
+	cmp( 1, -1);
+	cmp( 1, -2);
+	cmp( 2, -1);
+
+	cmp(-1,  1);
+	cmp(-1,  2);
+	cmp(-2,  1);
+
+
+	cmp( 0,  10000);
+	cmp( 0, -10000);
+	cmp( 10000,  0);
+	cmp(-10000,  0);
+
+	cmp(10000, 10000);
+	cmp(10000, 20000);
+	cmp(20000, 10000);
+
+	cmp(-10000, -10000);
+	cmp(-10000, -20000);
+	cmp(-20000, -10000);
+	
+	cmp( 10000, -10000);
+	cmp( 10000, -20000);
+	cmp( 20000, -10000);
+
+	cmp(-10000,  10000);
+	cmp(-10000,  20000);
+	cmp(-20000,  10000);
+
+	cmp( 10000000L, -10000000L);
+	cmp( 10000000L, -20000000L);
+	cmp( 20000000L, -10000000L);
+
+	cmp(-10000000L,  10000000L);
+	cmp(-10000000L,  20000000L);
+	cmp(-20000000L,  10000000L);
+	
+	cmp( 0,  1024);
+	cmp( 0, -1024);
+	cmp( 1024,  0);
+	cmp(-1024,  0);
+
+	cmp(1024, 1024);
+	cmp(1024, 1025);
+	cmp(1025, 1024);
+
+	cmp(-1024, -1024);
+	cmp(-1024, -1025);
+	cmp(-1025, -1024);
+	
+	cmp( 1024, -1024);
+	cmp( 1024, -1025);
+	cmp( 1025, -1024);
+
+	cmp(-1024,  1024);
+	cmp(-1024,  1025);
+	cmp(-1025,  1024);
+
+	cmpz(0);
+	cmpz(1);
+	cmpz(255);
+	cmpz(256);
+	cmpz(10000);
+	cmpz(20000);
+	cmpz(-1);
+	cmpz(-255);
+	cmpz(-256);
+	cmpz(-10000);
+	cmpz(-20000);
+
+	cmp1(0);
+	cmp1(1);
+	cmp1(2);
+	cmp1(3);
+	cmp1(255);
+	cmp1(256);
+	cmp1(10000);
+	cmp1(20000);
+	cmp1(1000000l);
+	cmp1(2000000l);
+	cmp1(100000000l);
+	cmp1(200000000l);
+	cmp1(-1);
+	cmp1(-2);
+	cmp1(-3);
+	cmp1(-255);
+	cmp1(-256);
+	cmp1(-10000);
+	cmp1(-20000);
+	cmp1(-1000000l);
+	cmp1(-2000000l);
+	cmp1(-100000000l);
+	cmp1(-200000000l);
+
+	cmpm(0);
+	cmpm(1);
+	cmpm(2);
+	cmpm(3);
+	cmpm(255);
+	cmpm(256);
+	cmpm(10000);
+	cmpm(20000);
+	cmpm(1000000l);
+	cmpm(2000000l);
+	cmpm(100000000l);
+	cmpm(200000000l);
+	cmpm(-1);
+	cmpm(-2);
+	cmpm(-3);
+	cmpm(-255);
+	cmpm(-256);
+	cmpm(-10000);
+	cmpm(-20000);
+	cmpm(-1000000l);
+	cmpm(-2000000l);
+	cmpm(-100000000l);
+	cmpm(-200000000l);
+
+	return 0;
+	
+}

autotest/testint8cmp.c

@@ -0,0 +1,555 @@
+#include <stdio.h>
+#include <assert.h>
+
+typedef signed char int8;
+typedef unsigned char uint8;
+
+bool beq(int8 a, int8 b)
+{
+	return a == b;
+}
+
+bool blt(int8 a, int8 b)
+{
+	return a < b;
+}
+
+bool bgt(int8 a, int8 b)
+{
+	return a > b;
+}
+
+bool ble(int8 a, int8 b)
+{
+	return a <= b;
+}
+
+bool bge(int8 a, int8 b)
+{
+	return a >= b;
+}
+
+bool neq(int8 a, int8 b)
+{
+	return a == b;
+}
+
+#pragma native(neq)
+
+bool nlt(int8 a, int8 b)
+{
+	return a < b;
+}
+
+#pragma native(nlt)
+
+bool ngt(int8 a, int8 b)
+{
+	return a > b;
+}
+
+#pragma native(ngt)
+
+bool nle(int8 a, int8 b)
+{
+	return a <= b;
+}
+
+#pragma native(nle)
+
+bool nge(int8 a, int8 b)
+{
+	return a >= b;
+}
+
+#pragma native(nge)
+
+
+
+bool beqz(int8 a)
+{
+	return a == 0;
+}
+
+bool bltz(int8 a)
+{
+	return a < 0;
+}
+
+bool bgtz(int8 a)
+{
+	return a > 0;
+}
+
+bool blez(int8 a)
+{
+	return a <= 0;
+}
+
+bool bgez(int8 a)
+{
+	return a >= 0;
+}
+
+bool neqz(int8 a)
+{
+	return a == 0;
+}
+
+#pragma native(neqz)
+
+bool nltz(int8 a)
+{
+	return a < 0;
+}
+
+#pragma native(nltz)
+
+bool ngtz(int8 a)
+{
+	return a > 0;
+}
+
+#pragma native(ngtz)
+
+bool nlez(int8 a)
+{
+	return a <= 0;
+}
+
+#pragma native(nlez)
+
+bool ngez(int8 a)
+{
+	return a >= 0;
+}
+
+#pragma native(ngez)
+
+
+
+
+
+
+
+bool bequz(uint8 a)
+{
+	return a == 0;
+}
+
+bool bltuz(uint8 a)
+{
+	return a < 0;
+}
+
+bool bgtuz(uint8 a)
+{
+	return a > 0;
+}
+
+bool bleuz(uint8 a)
+{
+	return a <= 0;
+}
+
+bool bgeuz(uint8 a)
+{
+	return a >= 0;
+}
+
+bool nequz(uint8 a)
+{
+	return a == 0;
+}
+
+#pragma native(nequz)
+
+bool nltuz(uint8 a)
+{
+	return a < 0;
+}
+
+#pragma native(nltuz)
+
+bool ngtuz(uint8 a)
+{
+	return a > 0;
+}
+
+#pragma native(ngtuz)
+
+bool nleuz(uint8 a)
+{
+	return a <= 0;
+}
+
+#pragma native(nleuz)
+
+bool ngeuz(uint8 a)
+{
+	return a >= 0;
+}
+
+#pragma native(ngeuz)
+
+
+
+
+
+bool beq1(int8 a)
+{
+	return a == 1;
+}
+
+bool blt1(int8 a)
+{
+	return a < 1;
+}
+
+bool bgt1(int8 a)
+{
+	return a > 1;
+}
+
+bool ble1(int8 a)
+{
+	return a <= 1;
+}
+
+bool bge1(int8 a)
+{
+	return a >= 1;
+}
+
+bool neq1(int8 a)
+{
+	return a == 1;
+}
+
+#pragma native(neq1)
+
+bool nlt1(int8 a)
+{
+	return a < 1;
+}
+
+#pragma native(nlt1)
+
+bool ngt1(int8 a)
+{
+	return a > 1;
+}
+
+#pragma native(ngt1)
+
+bool nle1(int8 a)
+{
+	return a <= 1;
+}
+
+#pragma native(nle1)
+
+bool nge1(int8 a)
+{
+	return a >= 1;
+}
+
+#pragma native(nge1)
+
+
+
+void cmp(int8 a, int8 b)
+{
+	bool	beqf = beq(a, b), bltf = blt(a, b), bgtf = bgt(a, b), blef = ble(a, b), bgef = bge(a, b);
+	bool	neqf = neq(a, b), nltf = nlt(a, b), ngtf = ngt(a, b), nlef = nle(a, b), ngef = nge(a, b);
+	
+	printf("BYTE   %d, %d : EQ %d LT %d GT %d\r", a, b, beqf, bltf, bgtf);
+	printf("NATIVE %d, %d : EQ %d LT %d GT %d\r", a, b, neqf, nltf, ngtf);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+void cmpz(int8 a)
+{
+	bool	beqf = beqz(a), bltf = bltz(a), bgtf = bgtz(a), blef = blez(a), bgef = bgez(a);
+	bool	neqf = neqz(a), nltf = nltz(a), ngtf = ngtz(a), nlef = nlez(a), ngef = ngez(a);
+	
+	printf("BYTE   %d, 0 : EQ %d LT %d GT %d\r", a, beqf, bltf, bgtf);
+	printf("NATIVE %d, 0 : EQ %d LT %d GT %d\r", a, neqf, nltf, ngtf);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+void cmpuz(uint8 a)
+{
+	bool	beqf = bequz(a), bltf = bltuz(a), bgtf = bgtuz(a), blef = bleuz(a), bgef = bgeuz(a);
+	bool	neqf = nequz(a), nltf = nltuz(a), ngtf = ngtuz(a), nlef = nleuz(a), ngef = ngeuz(a);
+	
+	printf("BYTE   %d, 0 : EQ %d LT %d GT %d\r", a, beqf, bltf, bgtf);
+	printf("NATIVE %d, 0 : EQ %d LT %d GT %d\r", a, neqf, nltf, ngtf);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+void cmp1(int8 a)
+{
+	bool	beqf = beq1(a), bltf = blt1(a), bgtf = bgt1(a), blef = ble1(a), bgef = bge1(a);
+	bool	neqf = neq1(a), nltf = nlt1(a), ngtf = ngt1(a), nlef = nle1(a), ngef = nge1(a);
+	
+	printf("BYTE   %d, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, beqf, bltf, bgtf, blef, bgef);
+	printf("NATIVE %d, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, neqf, nltf, ngtf, nlef, ngef);
+	
+	assert(beqf == neqf);
+	assert(bltf == nltf);
+	assert(bgtf == ngtf);	
+	assert(blef == nlef);
+	assert(bgef == ngef);	
+}
+
+void cmpu(char a, char b, bool lt, bool gt, bool eq)
+{
+	bool clt = a < b, cgt = a > b, ceq = a == b;
+	bool nlt = a >= b, ngt = a <= b, neq = a != b;
+
+	printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", a, b, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
+
+	assert(clt == lt);
+	assert(cgt == gt);
+	assert(ceq == eq);
+
+	assert(nlt != lt);
+	assert(ngt != gt);
+	assert(neq != eq);
+}
+
+void cmpu100(char a, bool lt, bool gt, bool eq)
+{
+	bool clt = a < 100, cgt = a > 100, ceq = a == 100;
+	bool nlt = a >= 100, ngt = a <= 100, neq = a != 100;
+
+	printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", a, 100, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
+
+	assert(clt == lt);
+	assert(cgt == gt);
+	assert(ceq == eq);
+
+	assert(nlt != lt);
+	assert(ngt != gt);
+	assert(neq != eq);
+}
+
+void cmpu100r(char b, bool lt, bool gt, bool eq)
+{
+	bool clt = 100 < b, cgt = 100 > b, ceq = 100 == b;
+	bool nlt = 100 >= b, ngt = 100 <= b, neq = 100 != b;
+
+	printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", 100, b, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
+
+	assert(clt == lt);
+	assert(cgt == gt);
+	assert(ceq == eq);
+
+	assert(nlt != lt);
+	assert(ngt != gt);
+	assert(neq != eq);
+}
+
+void cmpu1000(char a, bool lt, bool gt, bool eq)
+{
+	bool clt = a < 1000, cgt = a > 1000, ceq = a == 1000;
+	bool nlt = a >= 1000, ngt = a <= 1000, neq = a != 1000;
+
+	printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", a, 1000, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
+
+	assert(clt == lt);
+	assert(cgt == gt);
+	assert(ceq == eq);
+
+	assert(nlt != lt);
+	assert(ngt != gt);
+	assert(neq != eq);
+}
+
+void cmpu1000r(char b, bool lt, bool gt, bool eq)
+{
+	bool clt = 1000< b, cgt = 1000 > b, ceq = 1000 == b;
+	bool nlt = 1000 >= b, ngt = 1000 <= b, neq = 1000 != b;
+
+	printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", 1000, b, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
+
+	assert(clt == lt);
+	assert(cgt == gt);
+	assert(ceq == eq);
+
+	assert(nlt != lt);
+	assert(ngt != gt);
+	assert(neq != eq);
+}
+
+void cmpum100(char a, bool lt, bool gt, bool eq)
+{
+	bool clt = a < -100, cgt = a > -100, ceq = a == -100;
+	bool nlt = a >= -100, ngt = a <= -100, neq = a != -100;
+
+	printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", a, -100, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
+
+	assert(clt == lt);
+	assert(cgt == gt);
+	assert(ceq == eq);
+
+	assert(nlt != lt);
+	assert(ngt != gt);
+	assert(neq != eq);
+}
+
+void cmpum100r(char b, bool lt, bool gt, bool eq)
+{
+	bool clt = -100 < b, cgt = -100 > b, ceq = -100 == b;
+	bool nlt = -100 >= b, ngt = -100 <= b, neq = -100 != b;
+
+	printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", -100, b, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
+
+	assert(clt == lt);
+	assert(cgt == gt);
+	assert(ceq == eq);
+
+	assert(nlt != lt);
+	assert(ngt != gt);
+	assert(neq != eq);
+}
+
+int main(void)
+{
+	cmp( 0,  1);
+	cmp( 0, -1);
+	cmp( 1,  0);
+	cmp(-1,  0);
+
+	cmp(1, 1);
+	cmp(1, 2);
+	cmp(2, 1);
+
+	cmp(-1, -1);
+	cmp(-1, -2);
+	cmp(-2, -1);
+	
+	cmp( 1, -1);
+	cmp( 1, -2);
+	cmp( 2, -1);
+
+	cmp(-1,  1);
+	cmp(-1,  2);
+	cmp(-2,  1);
+
+
+	cmp( 0,  100);
+	cmp( 0, -100);
+	cmp( 100,  0);
+	cmp(-100,  0);
+
+	cmp(10, 10);
+	cmp(10, 20);
+	cmp(20, 10);
+
+	cmp(-10, -10);
+	cmp(-10, -20);
+	cmp(-20, -10);
+	
+	cmp( 10, -10);
+	cmp( 10, -20);
+	cmp( 20, -10);
+
+	cmp(-10,  10);
+	cmp(-10,  20);
+	cmp(-20,  10);
+
+	cmp(-30,  30);
+	cmp(-30, -30);
+	cmp( 30,  30);
+	cmp( 30, -30);
+	
+	cmp( 0,  127);
+	cmp( 0, -128);
+	cmp( 127,  0);
+	cmp(-128,  0);
+
+	cmp( 127,  127);
+	cmp( 127, -128);
+	cmp(-128,  127);
+	cmp(-128, -128);
+
+	cmpz(0);
+	cmpz(1);
+	cmpz(127);
+	cmpz(-1);
+	cmpz(-128);
+
+	cmpuz(0);
+	cmpuz(1);
+	cmpuz(127);
+	cmpuz(128);
+	cmpuz(255);
+
+	cmp1(0);
+	cmp1(1);
+	cmp1(2);
+	cmp1(3);
+	cmp1(127);
+	cmp1(-1);
+	cmp1(-2);
+	cmp1(-3);
+	cmp1(-128);
+
+	cmpu(0, 0, false, false, true);
+	cmpu(0, 1, true,  false, false);
+	cmpu(1, 0, false ,true,  false);
+
+	cmpu(128, 128, false, false, true);
+	cmpu(  0, 128, true,  false, false);
+	cmpu(128,   0, false ,true,  false);
+
+	cmpu(255, 255, false, false, true);
+	cmpu(  0, 255, true,  false, false);
+	cmpu(255,   0, false ,true,  false);
+
+	cmpu(127, 127, false, false, true);
+	cmpu(128, 255, true,  false, false);
+	cmpu(255, 128, false ,true,  false);
+
+	cmpu100(100, false, false, true);
+	cmpu100(  0, true,  false, false);
+	cmpu100(130, false, true, false);
+
+	cmpu100r(100, false, false, true);
+	cmpu100r(130, true,  false, false);
+	cmpu100r(  0, false, true, false);
+
+	cmpum100(  0, false, true, false);
+	cmpum100(130, false, true, false);
+
+	cmpum100r(130, true,  false, false);
+	cmpum100r(  0, true,  false, false);
+
+	cmpu1000(100, true,  false, false);
+	cmpu1000(  0, true,  false, false);
+	cmpu1000(130, true,  false, false);
+
+	cmpu1000r(100, false, true, false);
+	cmpu1000r(130, false, true, false);
+	cmpu1000r(  0, false, true, false);
+
+
+	return 0;	
+}

autotest/testinterval.c

@@ -0,0 +1,58 @@
+#include <assert.h>
+
+void testint0(void)
+{
+	int	a0n = 0, an0 = 0;
+	int	b0n = 0, bn0 = 0;
+
+	for(int i=-1000; i<1000; i++)
+	{
+		if (i >= 0 && i < 500)
+			a0n += 1;
+		if (i < 500 && i >= 0)
+			an0 += 1;
+		if (i >= 0 && i <= 499)
+			b0n += 1;
+		if (i <= 499 && i >= 0)
+			bn0 += 1;
+	}
+
+	assert(a0n == 500);
+	assert(an0 == 500);
+	assert(b0n == 500);
+	assert(bn0 == 500);	
+}
+
+typedef signed char 	int8;
+
+void testbyte0(void)
+{
+	int8	a0n = 0, an0 = 0;
+	int8	b0n = 0, bn0 = 0;
+
+	for(int8 i=-100; i<100; i++)
+	{
+		if (i >= 0 && i < 50)
+			a0n += 1;
+		if (i < 50 && i >= 0)
+			an0 += 1;
+		if (i >= 0 && i <= 49)
+			b0n += 1;
+		if (i <= 49 && i >= 0)
+			bn0 += 1;
+	}
+
+	assert(a0n == 50);
+	assert(an0 == 50);
+	assert(b0n == 50);
+	assert(bn0 == 50);	
+}
+
+int main(void)
+{
+	testint0();
+	testbyte0();
+
+	return 0;
+}
+

autotest/testsigned16div.c

@@ -0,0 +1,29 @@
+#include <assert.h>
+
+int multab[32];
+
+void fill_mulli(int m)
+{
+#pragma unroll(full)
+	for(int i=-16; i<16; i++)
+		if (i != 0)
+			multab[i + 16] = m / i;
+}
+
+void check_mulli(int m)
+{
+	for(int i=-16; i<16; i++)
+		if (i != 0)
+			assert(multab[i + 16] == m / i);	
+}
+
+int main(void)
+{
+	for(int i=-1024; i<=1024; i++)
+	{
+		fill_mulli(i);
+		check_mulli(i);
+	}
+
+	return 0;
+}

autotest/testsigned16mul.c

@@ -0,0 +1,27 @@
+#include <assert.h>
+
+int multab[32];
+
+void fill_mulli(int m)
+{
+#pragma unroll(full)
+	for(int i=-16; i<16; i++)
+		multab[i + 16] = m * i;
+}
+
+void check_mulli(int m)
+{
+	for(int i=-16; i<16; i++)
+		assert(multab[i + 16] == m * i);	
+}
+
+int main(void)
+{
+	for(int i=-1024; i<=1024; i++)
+	{
+		fill_mulli(i);
+		check_mulli(i);
+	}
+
+	return 0;
+}

autotest/tileexpand.cpp

@@ -0,0 +1,83 @@
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+
+#define MAP_WIDTH 10
+#define MAP_HEIGHT 2
+
+#define TITLE_TILE_WIDTH            4
+#define TITLE_TILE_HEIGHT           4
+
+#define PTR_SCREEN              ((char *)0xc000)
+#define PTR_BUFFER              ((char *)0xc400)
+#define PTR_COLOR               ((char *)0xd800)
+#define PTR_FONTCHARSET         ((char *)0xd800)
+
+const char TitleMap[1024] = {
+#for(i, 1024) i * 17,
+};
+
+const char TitleTiles[4096] = {
+#for(i, 4096) i * 31,
+};
+
+// Custom screen address
+extern char* const Screen = PTR_SCREEN;
+
+// Color mem address
+extern char* const Color = PTR_COLOR;
+
+void RenderLogo(char screenY)
+{    
+	char * sp = Screen;
+	char * cp = Color;
+	const char * mp = TitleMap;
+
+	for(char ty=0; ty < MAP_HEIGHT; ty++)
+    {
+        for(char tx=0; tx< MAP_WIDTH; tx++)
+        {
+            char ti = mp[tx];
+            const char* tp = TitleTiles + (TITLE_TILE_WIDTH * TITLE_TILE_HEIGHT) * ti;
+
+            for(char y=0; y<TITLE_TILE_HEIGHT; y++)
+            {
+                for(char x=0; x<TITLE_TILE_WIDTH; x++)
+                {	
+                    char c = tp[TITLE_TILE_WIDTH * y + x];
+                    sp[40 * (y + screenY) + x] = c;
+                    cp[40 * (y + screenY) + x] = 1;
+                }    
+            }
+            sp += TITLE_TILE_WIDTH;
+            cp += TITLE_TILE_WIDTH;
+        }
+        sp += 120;
+        cp += 120;
+	    mp += MAP_WIDTH;
+    }
+}
+
+void VerifyLogo(char screenY)
+{
+	for(char dy=0; dy<MAP_HEIGHT * TITLE_TILE_HEIGHT; dy++)
+	{
+		for(char dx=0; dx<MAP_WIDTH * TITLE_TILE_WIDTH; dx++)
+		{
+			char ty = dy / TITLE_TILE_HEIGHT, iy = dy % TITLE_TILE_HEIGHT;
+			char tx = dx / TITLE_TILE_WIDTH, ix = dx % TITLE_TILE_WIDTH;
+
+			int si = TitleMap[MAP_WIDTH * ty + tx] * TITLE_TILE_WIDTH * TITLE_TILE_HEIGHT + TITLE_TILE_WIDTH * iy + ix;
+			int di = 40 * (dy + screenY) + dx;
+
+			assert(Screen[di] == TitleTiles[si]);
+		}
+	}
+}
+
+int main(void)
+{
+    RenderLogo(1);
+    VerifyLogo(1);
+    return 0;
+}

autotest/vcalltest.cpp

@@ -0,0 +1,93 @@
+#include <assert.h>
+
+struct A
+{
+	virtual int f(int x);
+};
+
+struct B : A
+{
+	virtual int f(int x);
+};
+
+struct C : A
+{
+	virtual int f(int x);
+	virtual int g(int y, int z);
+};
+
+struct D : B
+{
+	virtual int f(int x);	
+};
+
+struct E : C
+{
+	virtual int f(int x);	
+	virtual int g(int y, int z);
+};
+
+struct F : C
+{
+	virtual int g(int y, int z);
+};
+
+int A::f(int x)
+{
+	return x * 1;
+}
+
+int B::f(int x)
+{
+	return x * 2;
+}
+
+int C::f(int x)
+{
+	return x * 3;
+}
+
+int C::g(int y, int z)
+{
+	return (y + z) * 3;
+}
+
+int D::f(int x)
+{
+	return x * 4;
+}
+
+int E::f(int x)
+{
+	return x * 5;
+}
+
+int E::g(int y, int z)
+{
+	return (y + z) * 5;
+}
+
+int F::g(int y, int z)
+{
+	return (y + z) * 6;
+}
+
+int main(void)
+{
+	A 	a;
+	B 	b;
+	C 	c;
+	D 	d;
+	E 	e;
+	F 	f;
+
+	assert(a.f(3) == c.f(1));
+	assert(b.f(4) == d.f(2));
+	assert(e.f(2) == b.f(5));
+	assert(f.f(5) == e.f(3));
+
+	assert(c.g(3, 2) == e.g(1, 2));
+	assert(c.g(1, 5) == f.g(0, 3));
+
+	return 0;
+}

autotest/vcalltree.cpp

@@ -0,0 +1,79 @@
+#include <assert.h>
+
+struct Node
+{
+	virtual float eval(void)
+		{
+			return 1.0e6;
+		}
+};
+
+struct ConstNode : Node
+{
+	float	c;
+
+	ConstNode(float c_)
+		: c(c_) {}
+
+	virtual float eval(void)
+	{
+		return c;
+	}
+};
+
+struct BinopNode : Node
+{
+	Node	*	left, * right;
+
+	BinopNode(Node * left_, Node * right_)
+		: left(left_), right(right_)
+		{}
+};
+
+struct AddNode : BinopNode
+{
+	AddNode(Node * left_, Node * right_)
+		: BinopNode(left_, right_)
+		{}
+
+	virtual float eval(void)
+	{
+		return left->eval() + right->eval();
+	}
+};
+
+struct SubNode : BinopNode
+{
+	SubNode(Node * left_, Node * right_)
+		: BinopNode(left_, right_)
+		{}
+
+	virtual float eval(void)
+	{
+		return left->eval() - right->eval();
+	}
+};
+
+struct MulNode : BinopNode
+{
+	MulNode(Node * left_, Node * right_)
+		: BinopNode(left_, right_)
+		{}
+
+	virtual float eval(void)
+	{
+		return left->eval() * right->eval();
+	}
+};
+
+int main(void)
+{
+	Node	*	n = 
+		new SubNode(
+			new MulNode(new ConstNode(4), new ConstNode(5)),
+			new AddNode(new ConstNode(12), new ConstNode(7)));
+
+	assert(n->eval() == 1.0);
+
+	return 0;
+}

autotest/virtualdestruct.cpp

@@ -0,0 +1,63 @@
+#include <assert.h>
+
+int a, b, c;
+
+struct A
+{	
+	A(void)
+	{
+		a++;
+	}
+
+	virtual ~A(void)
+	{
+		a--;
+	}
+};
+
+struct B : A
+{	
+	B(void)
+	{
+		b++;
+	}
+
+	virtual ~B(void)
+	{
+		b--;
+	}
+};
+
+
+struct C : B
+{	
+	C(void)
+	{
+		c++;
+	}
+
+	virtual ~C(void)
+	{
+		c--;
+	}
+};
+
+
+int main()
+{
+	A *	t[3];
+
+	t[0] = new A();
+	t[1] = new B();
+	t[2] = new C();
+
+	assert(a == 3 && b == 2 && c == 1);
+
+	delete t[0];
+	delete t[1];
+	delete t[2];
+
+	assert(a == 0 && b == 0 && c == 0);
+
+	return 0;
+}

include/audio/sidfx.c

@@ -0,0 +1,201 @@
+#include "sidfx.h"
+
+enum SIDFXState
+{
+	SIDFX_IDLE,
+	SIDFX_RESET_0,
+	SIDFX_RESET_1,
+	SIDFX_READY,
+	SIDFX_PLAY,
+	SIDFX_WAIT
+};
+
+__striped static struct SIDFXChannel
+{
+	const SIDFX	* volatile 		com;
+	byte						delay, priority;
+	volatile byte				cnt;
+	volatile SIDFXState			state;
+	unsigned					freq, pwm;
+
+}	channels[3];
+
+void sidfx_init(void)
+{
+	for(char i=0; i<3; i++)
+	{
+		channels[i].com = nullptr;
+		channels[i].state = SIDFX_IDLE;
+		channels[i].priority = 0;
+		channels[i].delay = 1;
+	}
+}
+
+bool sidfx_idle(byte chn)
+{
+	return channels[chn].state == SIDFX_IDLE;
+}
+
+char sidfx_cnt(byte chn)
+{
+	return channels[chn].cnt;	
+}
+
+void sidfx_play(byte chn, const SIDFX * fx, byte cnt)
+{
+	SIDFXState		ns = channels[chn].state;
+
+	if (ns == SIDFX_IDLE)
+		ns = SIDFX_READY;
+	else if (channels[chn].priority <= fx->priority)
+		ns = SIDFX_RESET_0;
+	else
+		return;
+
+	channels[chn].state = SIDFX_IDLE;
+	channels[chn].delay = 1;
+
+	channels[chn].com = fx;
+	channels[chn].cnt = cnt - 1;
+	channels[chn].priority = fx->priority;
+
+	channels[chn].state = ns;
+}
+
+void sidfx_stop(byte chn)
+{
+	channels[chn].com = nullptr;
+	if (channels[chn].state != SIDFX_IDLE)
+	{
+		channels[chn].state = SIDFX_RESET_0;
+		channels[chn].delay = 1;
+	}
+}
+
+inline void sidfx_loop_ch(byte ch)
+{
+	if (channels[ch].state)
+	{
+		const SIDFX	*	com = channels[ch].com;
+
+		channels[ch].delay--;
+		if (channels[ch].delay)
+		{
+			if (com->dfreq)
+			{
+				channels[ch].freq += com->dfreq;
+				sid.voices[ch].freq = channels[ch].freq;
+			}
+			if (com->dpwm)
+			{
+				channels[ch].pwm += com->dpwm;
+				sid.voices[ch].pwm = channels[ch].pwm;
+			}
+		}
+
+		while (!channels[ch].delay)
+		{
+			switch (channels[ch].state)
+			{
+			case SIDFX_IDLE:
+				channels[ch].delay = 1;
+				break;
+			case SIDFX_RESET_0:
+				sid.voices[ch].ctrl = 0;
+				sid.voices[ch].attdec = 0;
+				sid.voices[ch].susrel = 0;
+				if (com)
+					channels[ch].state = SIDFX_READY;
+				else
+					channels[ch].state = SIDFX_IDLE;
+				channels[ch].delay = 1;
+				break;
+			case SIDFX_RESET_1:
+				sid.voices[ch].ctrl = SID_CTRL_TEST;
+				sid.voices[ch].ctrl = 0;
+				sid.voices[ch].attdec = 0;
+				sid.voices[ch].susrel = 0;
+				channels[ch].state = SIDFX_READY;
+				break;
+			case SIDFX_READY:
+				channels[ch].freq = com->freq;
+				channels[ch].pwm = com->pwm;
+
+				sid.voices[ch].freq = com->freq;
+				sid.voices[ch].pwm = com->pwm;
+				sid.voices[ch].attdec = com->attdec;
+				sid.voices[ch].susrel = com->susrel;
+				sid.voices[ch].ctrl = com->ctrl;
+
+				if (com->ctrl & SID_CTRL_GATE)
+				{
+					channels[ch].delay = com->time1;
+					channels[ch].state = SIDFX_PLAY;
+				}
+				else
+				{
+					channels[ch].delay = com->time0;
+					channels[ch].state = SIDFX_PLAY;
+				}
+				break;
+			case SIDFX_PLAY:
+				if (com->time0)
+				{
+					sid.voices[ch].ctrl = com->ctrl & ~SID_CTRL_GATE;
+					channels[ch].delay = com->time0 - 1;
+					channels[ch].state = SIDFX_WAIT;
+				}
+				else if (channels[ch].cnt)
+				{
+					char sr = com->susrel & 0xf0;
+					com++;
+					char ctrl = com->ctrl;
+					if ((com->attdec & 0xef) == 0 && (ctrl & SID_CTRL_GATE) && (com->susrel & 0xf0) > sr)
+					{
+						sid.voices[ch].ctrl = ctrl & ~SID_CTRL_GATE;
+						sid.voices[ch].ctrl = ctrl |  SID_CTRL_GATE;
+					}
+					channels[ch].cnt--;
+					channels[ch].com = com;
+					channels[ch].priority = com->priority;
+					channels[ch].state = SIDFX_READY;
+				}
+				else
+				{
+					com = nullptr;
+					channels[ch].state = SIDFX_RESET_0;					
+				}
+				break;
+			case SIDFX_WAIT:
+				if (channels[ch].cnt)
+				{
+					com++;
+					channels[ch].cnt--;
+					channels[ch].com = com;
+					channels[ch].priority = com->priority;
+					if (com->ctrl & SID_CTRL_GATE)
+						channels[ch].state = SIDFX_RESET_0;
+					else
+						channels[ch].state = SIDFX_READY;
+				}
+				else
+				{
+					com = nullptr;
+					channels[ch].state = SIDFX_RESET_0;					
+				}
+				break;
+			}
+		}
+	}
+}
+
+void sidfx_loop_2(void)
+{
+	sidfx_loop_ch(2);	
+}
+
+void sidfx_loop(void)
+{
+	for(byte ch=0; ch<3; ch++)
+		sidfx_loop_ch(ch);
+}	

include/audio/sidfx.h

@@ -0,0 +1,31 @@
+#ifndef SIDFX_H
+#define SIDFX_H
+
+#include <c64/sid.h>
+
+struct SIDFX
+{
+	unsigned	freq, pwm;
+	byte		ctrl, attdec, susrel;
+	int			dfreq, dpwm;
+	byte		time1, time0;
+	byte		priority;
+};
+
+void sidfx_init(void);
+
+inline bool sidfx_idle(byte chn);
+
+inline void sidfx_play(byte chn, const SIDFX * fx, byte cnt);
+
+void sidfx_stop(byte chn);
+
+char sidfx_cnt(byte chn);
+
+void sidfx_loop(void);
+
+void sidfx_loop_2(void);
+
+#pragma compile("sidfx.c")
+
+#endif

include/c128/bank1.c

@@ -0,0 +1,84 @@
+#include "bank1.h"
+#include "mmu.h"
+#include <string.h>
+
+void bnk1_init(void)
+{
+	mmu.cr = 0x3e;
+	memcpy((char *)0xfc00, (char *)0xf000, 0x0300);
+	xmmu.rcr |= 0x0c;
+	mmu.cr = 0x3f;
+}
+
+#pragma code(bnk1code)
+
+char bnk1_readb(volatile char * p)
+{
+	mmu.bank1 = 0;
+	char c = *p;
+	mmu.bank0 = 0;
+	return c;
+}
+
+unsigned bnk1_readw(volatile unsigned * p)
+{
+	mmu.bank1 = 0;
+	unsigned w = *p;
+	mmu.bank0 = 1;
+	return w;
+}
+
+unsigned long bnk1_readl(volatile unsigned long * p)
+{
+	mmu.bank1 = 0;
+	unsigned long l = *p;
+	mmu.bank0 = 3;
+	return l;
+}
+
+void bnk1_readm(char * dp, volatile char * sp, unsigned size)
+{
+	while (size > 0)
+	{
+		mmu.bank1 = 0;
+		char c = * sp++;
+		mmu.bank0 = c;
+		*dp++ = c;
+		size--;
+	}
+}
+
+void bnk1_writeb(volatile char * p, char b)
+{
+	mmu.bank1 = b;
+	*p = b;
+	mmu.bank0 = b;
+}
+
+void bnk1_writew(volatile unsigned * p, unsigned w)
+{
+	mmu.bank1 = w;
+	*p = w;
+	mmu.bank0 = w;
+}
+
+void bnk1_writel(volatile unsigned long * p, unsigned long l)
+{
+	mmu.bank1 = l;
+	*p = l;
+	mmu.bank0 = l;
+}
+
+void bnk1_writem(volatile char * dp, const char * sp, unsigned size)
+{
+	while (size > 0)
+	{
+		char c = * sp++;
+		mmu.bank1 = c;
+		*dp++ = c;
+		mmu.bank0 = c;
+		size--;
+	}	
+}
+
+#pragma code(code)

include/c128/bank1.h

@@ -0,0 +1,34 @@
+#ifndef C128_BANK1_H
+#define C128_BANK1_H
+
+
+#pragma section( bnk1code, 0)
+
+#pragma region( bnk1code, 0xf000, 0xf300, , , {bnk1code}, 0xfc00 )
+
+void bnk1_init(void);
+
+#pragma code(bnk1code)
+
+__noinline char bnk1_readb(volatile char * p);
+
+__noinline unsigned bnk1_readw(volatile unsigned * p);
+
+__noinline unsigned long bnk1_readl(volatile unsigned long * p);
+
+__noinline void bnk1_readm(char * dp, volatile char * sp, unsigned size);
+
+
+__noinline void bnk1_writeb(volatile char * p, char b);
+
+__noinline void bnk1_writew(volatile unsigned * p, unsigned w);
+
+__noinline void bnk1_writel(volatile unsigned long * p, unsigned long l);
+
+__noinline void bnk1_writem(volatile char * dp, const char * sp, unsigned size);
+
+#pragma code(code)
+
+#pragma compile("bank1.c")
+
+#endif

include/c128/mmu.c

@@ -0,0 +1,8 @@
+#include "mmu.h"
+
+inline char mmu_set(char cr)
+{
+	char pcr = mmu.cr;
+	mmu.cr = cr;
+	return pcr;	
+}

include/c128/mmu.h

@@ -0,0 +1,35 @@
+#ifndef C128_MMU_H
+#define C128_MMU_H
+
+#include <c64/types.h>
+
+struct MMU
+{
+	volatile byte	cr;
+	volatile byte	bank0;
+	volatile byte	bank1;
+	volatile byte	bank14;
+	volatile byte	bankx;
+};
+
+struct XMMU
+{
+	volatile byte	cr;
+	volatile byte	pcr[4];
+	volatile byte	mcr;
+	volatile byte	rcr;
+	volatile word	page0;
+	volatile word	page1;
+	volatile byte	vr;
+};
+
+#define mmu		(*((struct MMU *)0xff00))
+
+#define xmmu	(*((struct XMMU *)0xd500))
+
+inline char mmu_set(char cr);
+
+#pragma compile("mmu.c")
+
+#endif
+