OPtimize signed+unsigned char arithmetic

prepare output directory also to build only the compiler

.gitignore

@@ -349,3 +349,8 @@ make/oscar64
 *.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
+)
+

autotest/arrayconstruct.cpp

@@ -136,19 +136,17 @@ void test_member_assign(void)
 
 int main(void)
 {
-#if 0
 	test_local_init();
 	test_member_init();
-#endif
+
 	test_member_array_init();
-#if 0
 
 	test_local_copy();
 	test_member_copy();
 
 	test_local_assign();
 	test_member_assign();
-#endif	
+
 	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,75 @@
 rem @echo off
 
-@call :test opp_string.cpp
+@call :test rolrortest.cpp
 @if %errorlevel% neq 0 goto :error
 
-@call :test opp_streamtest.cpp
+@call :test bitfields.cpp
 @if %errorlevel% neq 0 goto :error
 
-@call :test operatoroverload.cpp
+@call :testn autorefreturn.cpp
 @if %errorlevel% neq 0 goto :error
 
-@call :test virtualdestruct.cpp
+@call :testh opp_string.cpp
 @if %errorlevel% neq 0 goto :error
 
-@call :test vcalltest.cpp
+@call :testh opp_array.cpp
 @if %errorlevel% neq 0 goto :error
 
-@call :test vcalltree.cpp
+@call :testh opp_vector.cpp
 @if %errorlevel% neq 0 goto :error
 
-@call :test constructortest.cpp
+@call :testh opp_static_vector.cpp
 @if %errorlevel% neq 0 goto :error
 
-@call :test copyconstructor.cpp
+@call :testh opp_vector_string.cpp
 @if %errorlevel% neq 0 goto :error
 
-@call :test copyassign.cpp
+@call :testh opp_string_init.cpp
 @if %errorlevel% neq 0 goto :error
 
-@call :test arrayconstruct.cpp
+@call :testh opp_streamtest.cpp
 @if %errorlevel% neq 0 goto :error
 
-@call :test stdlibtest.c
+@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
@@ -57,6 +96,9 @@ rem @echo off
 @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
 
@@ -81,6 +123,9 @@ rem @echo off
 @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
 
@@ -120,6 +165,9 @@ rem @echo off
 @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
 
@@ -147,6 +195,12 @@ rem @echo off
 @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
 
@@ -198,77 +252,149 @@ rem @echo off
 @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
 
 :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
-..\release\oscar64 -e -bc %~1
+..\bin\oscar64 -e -bc %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -n %~1
+..\bin\oscar64 -e -n %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -O2 -bc %~1
+..\bin\oscar64 -e -O2 -bc %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -O2 -n %~1
+..\bin\oscar64 -e -O2 -n %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -O0 -bc %~1
+..\bin\oscar64 -e -O0 -bc %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -O0 -n %~1
+..\bin\oscar64 -e -O0 -n %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -Os -bc %~1
+..\bin\oscar64 -e -Os -bc %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -Os -n %~1
+..\bin\oscar64 -e -Os -n %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -O3 -bc %~1
+..\bin\oscar64 -e -O3 -bc %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -O3 -n %~1
+..\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
-..\release\oscar64 -e -bc %~1
+..\bin\oscar64 -e -bc %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -bc -O2 %~1
+..\bin\oscar64 -e -bc -O2 %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -bc -O0 %~1
+..\bin\oscar64 -e -bc -O0 %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -bc -Os %~1
+..\bin\oscar64 -e -bc -Os %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -bc -O3 %~1
+..\bin\oscar64 -e -bc -O3 %~1
 @if %errorlevel% neq 0 goto :error
 
 @exit /b 0
 
 :testn
-..\release\oscar64 -e -n %~1
+..\bin\oscar64 -e -n %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -O2 -n %~1
+..\bin\oscar64 -e -O2 -n %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -O0 -n %~1
+..\bin\oscar64 -e -O0 -n %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -Os -n %~1
+..\bin\oscar64 -e -Os -n %~1
 @if %errorlevel% neq 0 goto :error
 
-..\release\oscar64 -e -O3 -n %~1
+..\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

@@ -303,6 +303,18 @@ void shr32n(unsigned long xu, long xi)
 	}
 }
 
+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)
 
@@ -373,24 +385,30 @@ int main(void)
 	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/copyconstructor.cpp

@@ -1,4 +1,5 @@
 #include <assert.h>
+#include <stdio.h>
 
 int t, n;
 
@@ -161,7 +162,7 @@ void test_return_value(void)
 		C2 c(test_ret_v());
 	}
 
-	assert(n == 4 && t == 0);
+	assert(n == 6 && t == 0);
 }
 
 void test_return_reference(void)
@@ -184,7 +185,7 @@ void test_retparam_value(void)
 		test_param_fv(test_ret_v());
 	}
 
-	assert(n == 4 && t == 0);	
+	assert(n == 6 && t == 0);	
 }
 
 void test_retparam_reference(void)
@@ -200,7 +201,6 @@ void test_retparam_reference(void)
 
 int main(void)
 {
-#if 0
 	test_dcopy_init();
 	test_copy_init();
 	test_minit();
@@ -208,9 +208,8 @@ int main(void)
 	test_param_value();
 	test_param_ref();
 	test_return_value();
-#endif
 	test_retparam_value();
-//	test_retparam_reference();
+	test_retparam_reference();
 
 	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/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/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/makefile

@@ -1,50 +1,60 @@
-CC=../bin/oscar64
+SRCS=$(filter-out opp_part1.cpp opp_part2.cpp, $(wildcard *.c *.cpp))
-CXX=$(CC)
-SRCS=$(wildcard *.c *.cpp)
 EXES=$(patsubst %.c,%,$(SRCS))
 EXES:=$(patsubst %.cpp,%,$(EXES))
 
 all: $(EXES)
 
 %: %.c
-	$(CC) -e -bc $<
+	$(OSCAR64_CC) -e -bc $<
-	$(CC) -e -n $<
+	$(OSCAR64_CC) -e -n $<
-	$(CC) -e -O2 -bc $<
+	$(OSCAR64_CC) -e -O2 -bc $<
-	$(CC) -e -O2 -n $<
+	$(OSCAR64_CC) -e -O2 -n $<
-	$(CC) -e -O0 -bc $<
+	$(OSCAR64_CC) -e -O0 -bc $<
-	$(CC) -e -O0 -n $<
+	$(OSCAR64_CC) -e -O0 -n $<
-	$(CC) -e -Os -bc $<
+	$(OSCAR64_CC) -e -Os -bc $<
-	$(CC) -e -Os -n $<
+	$(OSCAR64_CC) -e -Os -n $<
-	$(CC) -e -O3 -bc $<
+	$(OSCAR64_CC) -e -O3 -bc $<
-	$(CC) -e -O3 -n $<
+	$(OSCAR64_CC) -e -O3 -n $<
 
 %: %.cpp
-	$(CXX) -e -bc $<
+	$(OSCAR64_CXX) -e -bc $<
-	$(CXX) -e -n $<
+	$(OSCAR64_CXX) -e -n $<
-	$(CXX) -e -O2 -bc $<
+	$(OSCAR64_CXX) -e -O2 -bc $<
-	$(CXX) -e -O2 -n $<
+	$(OSCAR64_CXX) -e -O2 -n $<
-	$(CXX) -e -O0 -bc $<
+	$(OSCAR64_CXX) -e -O0 -bc $<
-	$(CXX) -e -O0 -n $<
+	$(OSCAR64_CXX) -e -O0 -n $<
-	$(CXX) -e -Os -bc $<
+	$(OSCAR64_CXX) -e -Os -bc $<
-	$(CXX) -e -Os -n $<
+	$(OSCAR64_CXX) -e -Os -n $<
-	$(CXX) -e -O3 -bc $<
+	$(OSCAR64_CXX) -e -O3 -bc $<
-	$(CXX) -e -O3 -n $<
+	$(OSCAR64_CXX) -e -O3 -n $<
 
 # testb
 bitshifttest: bitshifttest.c
-	$(CC) -e -bc $<
+	$(OSCAR64_CC) -e -bc $<
-	$(CC) -e -bc -O2 $<
+	$(OSCAR64_CC) -e -bc -O2 $<
-	$(CC) -e -bc -O0 $<
+	$(OSCAR64_CC) -e -bc -O0 $<
-	$(CC) -e -bc -Os $<
+	$(OSCAR64_CC) -e -bc -Os $<
-	$(CC) -e -bc -O3 $<
+	$(OSCAR64_CC) -e -bc -O3 $<
-	$(CC) -e -n $<
+	$(OSCAR64_CC) -e -n $<
 
 # testn
 stripedarraytest: stripedarraytest.c
-	$(CC) -e -O2 -n $<
+	$(OSCAR64_CC) -e -O2 -n $<
-	$(CC) -e -O0 -n $<
+	$(OSCAR64_CC) -e -O0 -n $<
-	$(CC) -e -Os -n $<
+	$(OSCAR64_CC) -e -Os -n $<
-	$(CC) -e -O3 -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
+	@$(RM) *.asm *.bcs *.int *.lbl *.map *.prg

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/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

@@ -4,6 +4,10 @@
 #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);
@@ -21,8 +25,6 @@ int main(void)
 		os << i << endl;
 	}
 
-	costream	cout;
-
 	istringstream	is(os.str());
 
 	int j = 0, k = 47;
@@ -35,7 +37,7 @@ int main(void)
 
 	assert(j == 40);
 #endif
-	os.str(string());
+	os.str(opp::string());
 
 #if 0
 	cout << "[" << os.str() << "]" << endl;

autotest/opp_string.cpp

@@ -3,12 +3,14 @@
 #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";
 
-void test_create(void)
+__noinline void test_create(void)
 {
 	string	s1();
 	string	s2(HelloWorld);
@@ -20,7 +22,7 @@ void test_create(void)
 	assert(s4.size() == 1 && s4[0] == 'a');
 }
 
-void test_concat(void)
+__noinline void test_concat(void)
 {
 	string	s1();
 	string	s2(HelloWorld);
@@ -49,7 +51,7 @@ __noinline void test_find(void)
 	assert(s1.find(' ', 6) == 11);
 }
 
-void test_assign(void)
+__noinline void test_assign(void)
 {
 	string	s1(HelloWorld);
 	string	s2(AndBeyond);
@@ -75,9 +77,12 @@ void test_assign(void)
 	assert(!strcmp(s3.tocstr(), HelloWorld));
 }
 
+static char * test;
+
 int main(void)
 {
-	char * p = new char;	
+	test = new char;		
+
 	unsigned	avail = heapfree();
 
 	test_create();
@@ -92,5 +97,7 @@ int main(void)
 	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/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/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/testint32.c

@@ -5,6 +5,11 @@ 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);
@@ -80,6 +85,26 @@ int main(void)
 	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);

autotest/testint32cmp.c

@@ -63,6 +63,33 @@ bool nge(long a, long b)
 
 
 
+
+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;
@@ -188,7 +215,71 @@ bool nge1(long a)
 
 
 
-void cmp(long a, long b)
+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);
@@ -203,6 +294,27 @@ void cmp(long a, long b)
 	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);
@@ -233,6 +345,21 @@ void cmp1(long a)
 	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);
@@ -327,6 +454,10 @@ int main(void)
 	cmp1(256);
 	cmp1(10000);
 	cmp1(20000);
+	cmp1(1000000l);
+	cmp1(2000000l);
+	cmp1(100000000l);
+	cmp1(200000000l);
 	cmp1(-1);
 	cmp1(-2);
 	cmp1(-3);
@@ -334,6 +465,34 @@ int main(void)
 	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/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;
+}

include/audio/sidfx.c

@@ -10,12 +10,13 @@ enum SIDFXState
 	SIDFX_WAIT
 };
 
-static struct SIDFXChannel
+__striped static struct SIDFXChannel
 {
-	const SIDFX	*		com;
+	const SIDFX	* volatile 		com;
-	byte				delay, cnt, priority;
+	byte						delay, priority;
-	volatile SIDFXState	state;
+	volatile byte				cnt;
-	unsigned			freq, pwm;
+	volatile SIDFXState			state;
+	unsigned					freq, pwm;
 
 }	channels[3];
 
@@ -26,9 +27,20 @@ void sidfx_init(void)
 		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;
@@ -41,6 +53,7 @@ void sidfx_play(byte chn, const SIDFX * fx, byte cnt)
 		return;
 
 	channels[chn].state = SIDFX_IDLE;
+	channels[chn].delay = 1;
 
 	channels[chn].com = fx;
 	channels[chn].cnt = cnt - 1;
@@ -53,103 +66,126 @@ 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)
 {
-	switch (channels[ch].state)
+	if (channels[ch].state)
 	{
-		case SIDFX_IDLE:
+		const SIDFX	*	com = channels[ch].com;
-			break;
-		case SIDFX_RESET_0:
-			sid.voices[ch].ctrl = 0;
-			sid.voices[ch].attdec = 0;
-			sid.voices[ch].susrel = 0;
-			channels[ch].state = SIDFX_RESET_1;
-			break;
-		case SIDFX_RESET_1:
-			sid.voices[ch].ctrl = SID_CTRL_TEST;
-			channels[ch].state = SIDFX_READY;
-			break;
-		case SIDFX_READY:
-			if (channels[ch].com)
-			{
-				channels[ch].freq = channels[ch].com->freq;
-				channels[ch].pwm = channels[ch].com->pwm;
 
-				sid.voices[ch].freq = channels[ch].com->freq;
+		channels[ch].delay--;
-				sid.voices[ch].pwm = channels[ch].com->pwm;
+		if (channels[ch].delay)
-				sid.voices[ch].attdec = channels[ch].com->attdec;
+		{
-				sid.voices[ch].susrel = channels[ch].com->susrel;
+			if (com->dfreq)
-				sid.voices[ch].ctrl = channels[ch].com->ctrl;
-
-				channels[ch].delay = channels[ch].com->time1;
-				channels[ch].state = SIDFX_PLAY;
-			}
-			else
-				channels[ch].state = SIDFX_IDLE;
-			break;
-		case SIDFX_PLAY:
-			if (channels[ch].com->dfreq)
 			{
-				channels[ch].freq += channels[ch].com->dfreq;
+				channels[ch].freq += com->dfreq;
 				sid.voices[ch].freq = channels[ch].freq;
 			}
-			if (channels[ch].com->dpwm)
+			if (com->dpwm)
 			{
-				channels[ch].pwm += channels[ch].com->dpwm;
+				channels[ch].pwm += com->dpwm;
 				sid.voices[ch].pwm = channels[ch].pwm;
 			}
+		}
 
-			if (channels[ch].delay)
+		while (!channels[ch].delay)
-				channels[ch].delay--;
+		{
-			else if (channels[ch].com->time0)
+			switch (channels[ch].state)
 			{
-				sid.voices[ch].ctrl = channels[ch].com->ctrl & ~SID_CTRL_GATE;
+			case SIDFX_IDLE:
-				channels[ch].delay = channels[ch].com->time0;
+				channels[ch].delay = 1;
-				channels[ch].state = SIDFX_WAIT;
+				break;
-			}
+			case SIDFX_RESET_0:
-			else if (channels[ch].cnt)
+				sid.voices[ch].ctrl = 0;
-			{
+				sid.voices[ch].attdec = 0;
-				channels[ch].cnt--;
+				sid.voices[ch].susrel = 0;
-				channels[ch].com++;
+				if (com)
-				channels[ch].priority = channels[ch].com->priority;
+					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;
-			else
+			case SIDFX_READY:
-			{
+				channels[ch].freq = com->freq;
-				channels[ch].com = nullptr;
+				channels[ch].pwm = com->pwm;
-				channels[ch].state = SIDFX_RESET_0;						
-			}
-			break;
-		case SIDFX_WAIT:
-			if (channels[ch].com->dfreq)
-			{
-				channels[ch].freq += channels[ch].com->dfreq;
-				sid.voices[ch].freq = channels[ch].freq;
-			}
-			if (channels[ch].com->dpwm)
-			{
-				channels[ch].pwm += channels[ch].com->dpwm;
-				sid.voices[ch].pwm = channels[ch].pwm;
-			}
 
-			if (channels[ch].delay)
+				sid.voices[ch].freq = com->freq;
-				channels[ch].delay--;
+				sid.voices[ch].pwm = com->pwm;
-			else if (channels[ch].cnt)
+				sid.voices[ch].attdec = com->attdec;
-			{
+				sid.voices[ch].susrel = com->susrel;
-				channels[ch].cnt--;
+				sid.voices[ch].ctrl = com->ctrl;
-				channels[ch].com++;
+
-				channels[ch].priority = channels[ch].com->priority;
+				if (com->ctrl & SID_CTRL_GATE)
-				channels[ch].state = SIDFX_RESET_0;
+				{
+					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;
 			}
-			else
+		}
-			{
-				channels[ch].com = nullptr;
-				channels[ch].state = SIDFX_RESET_0;					
-			}
-			break;
 	}
 }
 

include/audio/sidfx.h

@@ -14,10 +14,14 @@ struct SIDFX
 
 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);

include/c128/bank1.h

@@ -10,22 +10,22 @@ void bnk1_init(void);
 
 #pragma code(bnk1code)
 
-char bnk1_readb(volatile char * p);
+__noinline char bnk1_readb(volatile char * p);
 
-unsigned bnk1_readw(volatile unsigned * p);
+__noinline unsigned bnk1_readw(volatile unsigned * p);
 
-unsigned long bnk1_readl(volatile unsigned long * p);
+__noinline unsigned long bnk1_readl(volatile unsigned long * p);
 
-void bnk1_readm(char * dp, volatile char * sp, unsigned size);
+__noinline void bnk1_readm(char * dp, volatile char * sp, unsigned size);
 
 
-void bnk1_writeb(volatile char * p, char b);
+__noinline void bnk1_writeb(volatile char * p, char b);
 
-void bnk1_writew(volatile unsigned * p, unsigned w);
+__noinline void bnk1_writew(volatile unsigned * p, unsigned w);
 
-void bnk1_writel(volatile unsigned long * p, unsigned long l);
+__noinline void bnk1_writel(volatile unsigned long * p, unsigned long l);
 
-void bnk1_writem(volatile char * dp, const char * sp, unsigned size);
+__noinline void bnk1_writem(volatile char * dp, const char * sp, unsigned size);
 
 #pragma code(code)
 

include/c128/mmu.c

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

include/c128/mmu.h

@@ -27,6 +27,7 @@ struct XMMU
 
 #define xmmu	(*((struct XMMU *)0xd500))
 
+inline char mmu_set(char cr);
 
 #pragma compile("mmu.c")
 

include/c128/vdc.c

@@ -4,16 +4,17 @@
 inline void vdc_reg(VDCRegister reg)
 {
 	vdc.addr = reg;
-	do {} while (vdc.addr < 128);
 }
 
 inline void vdc_write(byte data)
 {
+	do {} while (vdc.addr < 128);
 	vdc.data = data;
 }
 
 inline byte vdc_read(void)
 {
+	do {} while (vdc.addr < 128);
 	return vdc.data;
 }
 
@@ -33,8 +34,11 @@ byte vdc_reg_read(VDCRegister reg)
 
 void vdc_mem_addr(unsigned addr)
 {
+	#pragma callinline()
 	vdc_reg_write(VDCR_ADDRH, addr >> 8);
+	#pragma callinline()
 	vdc_reg_write(VDCR_ADDRL, addr);
+	#pragma callinline()
 	vdc_reg(VDCR_DATA);
 }
 
@@ -51,12 +55,14 @@ inline char vdc_mem_read(void)
 
 void vdc_mem_write_at(unsigned addr, char data)
 {
+	#pragma callinline()
 	vdc_mem_addr(addr);
 	vdc_write(data);
 }
 
 char vdc_mem_read_at(unsigned addr)
 {
+	#pragma callinline()
 	vdc_mem_addr(addr);
 	return vdc_read();
 }

include/c64/cia.c

@@ -16,7 +16,7 @@ void cia_init(void)
 	cia2.ddrb = 0x00;
 	cia1.ddra = 0xff;
 	
-	cia2.prb = 0x07;
+	cia2.pra = 0x07;
 	cia2.ddra = 0x3f;
 
 	char i0 = cia1.icr;

include/c64/easyflash.h

@@ -18,6 +18,46 @@ struct EasyFlash
 
 #define eflash	(*(EasyFlash *)0xde00)
 
+#ifdef __cplusplus
+
+#ifdef EFPROX_SECTION
+#pragma code(EFPROX_SECTION)
+#endif
+
+template<int back, class fn, class ... P>
+__noinline auto ef_call_p(P... p)
+{
+	if (back != __bankof(fn))
+		eflash.bank = __bankof(fn);
+	auto r = fn(p...);
+	if (back != 0xff && back != __bankof(fn))
+		eflash.bank = back;
+	return r;
+}
+
+#ifdef EFPROX_SECTION
+#pragma code(code)
+#endif
+
+template<class fn>
+class EFlashCall
+{
+public:
+	template<class ... P>
+	__forceinline auto operator()(P ... p) const
+	{
+		switch(__bankof(0))
+		{
+#for(i,64) case i: return ef_call_p<i, fn, P...>(p...);
+		default:
+			return ef_call_p<0xff, fn, P...>(p...);
+		}			
+	}
+};
+
+#define EF_CALL(fn)	EFlashCall<fn##_p>	fn
+
+#endif
 
 #endif
 

include/c64/flossiec.c

@@ -0,0 +1,608 @@
+#include "flossiec.h"
+#include <c64/iecbus.h>
+#include <c64/vic.h>
+#include <c64/cia.h>
+#include <c64/kernalio.h>
+
+#ifndef FLOSSIEC_NODISPLAY
+#define FLOSSIEC_NODISPLAY	0
+#endif
+#ifndef FLOSSIEC_NOIRQ
+#define FLOSSIEC_NOIRQ	0
+#endif
+#ifndef FLOSSIEC_BORDER
+#define FLOSSIEC_BORDER	0
+#endif
+
+
+#define VIA_ATNIN	0x80
+#define VIA_ATNOUT	0x10
+
+#define VIA_CLKOUT	0x08
+#define VIA_DATAOUT	0x02
+
+#define VIA_CLKIN	0x04
+#define VIA_DATAIN	0x01
+
+#define PORTB1		0x1800
+#define PORTB2		0x1c00
+
+#define WR			0x1d
+
+#ifdef FLOSSIEC_CODE
+#pragma code(FLOSSIEC_CODE)
+#endif
+#ifdef FLOSSIEC_BSS
+#pragma bss(FLOSSIEC_BSS)
+#endif
+
+__asm diskcode
+{
+	nop
+	nop
+
+	lda #VIA_CLKOUT
+	sta PORTB1
+
+	lda 0x0202
+	sta 0x0c
+	lda 0x0203
+	sta 0x0d
+	lda #$80
+	sta 0x03
+
+	ldx #0
+l0:
+	txa
+	lsr
+	lsr
+	lsr
+	lsr
+	sta 0x0700,x
+	inx
+	bne l0
+
+lr:
+	lda 0x03
+	bmi lr
+
+	sei
+
+	ldx #0
+l2:
+	lda #0
+	sta PORTB1
+	lda	0x0600, x
+	tay
+	and #0x0f
+	ora #VIA_DATAIN
+l1:
+	bit PORTB1
+	bne l1
+
+l3:
+	sta PORTB1
+
+	tya
+	asl
+	and #0x0a
+	sta PORTB1
+
+	lda 0x0700,y
+	nop
+	sta PORTB1
+
+	asl
+	nop
+	and #0x0a
+	sta PORTB1
+
+	inx
+	bne	l2
+
+	lda #VIA_CLKOUT
+	sta PORTB1
+
+
+	lda 0x0600
+	beq w1
+	sta 0x0c
+	lda 0x0601
+	sta 0x0d
+	lda #$80
+	sta 0x03
+	cli
+	bne lr
+w1:
+	sta PORTB1
+
+	cli
+	rts
+}
+
+#define CIA2B_ATNOUT	0x08
+#define CIA2B_CLKOUT	0x10
+#define CIA2B_DATAOUT	0x20
+
+#define CIA2B_CLKIN		0x40
+#define CIA2B_DATAIN	0x80
+
+#define CIA2PRA			0xdd00
+
+static char remap[256];
+static char rbuffer[256];
+static char xbuffer[256];
+static char flpos;
+static char xcmd;
+static char xi, xj;
+static char fldrive;
+static char flvxor;
+
+__noinline void fl_read_buf(void)
+{
+	__asm
+	{
+#if FLOSSIEC_NOIRQ
+		php
+		sei
+#endif
+
+		lda CIA2PRA
+		and #~CIA2B_CLKOUT
+		sta accu
+		sta CIA2PRA
+		and #~CIA2B_DATAOUT
+		sta accu + 1
+
+	l0:
+		lda CIA2PRA
+		and #CIA2B_CLKIN
+		beq l0
+#if !FLOSSIEC_NOIRQ
+		php
+		pla
+		and #$04
+		beq iq
+#endif
+		ldy #0
+		sec
+	l1:
+		ldx accu + 1
+#if !FLOSSIEC_NODISPLAY
+	l2:
+		lda 0xd012
+		sbc #50
+		bcc w1
+		and #7
+		beq l2
+#endif
+	w1:
+		stx CIA2PRA
+
+#if FLOSSIEC_BORDER
+		inc 0xd020
+#else
+		nop
+		nop
+		nop
+#endif
+		ldx accu
+		nop
+
+		lda CIA2PRA
+		lsr
+		lsr
+		nop
+		eor CIA2PRA
+		lsr
+		lsr
+		nop
+		eor CIA2PRA
+		lsr
+		lsr
+		sec
+		eor CIA2PRA
+		stx CIA2PRA
+
+		sta rbuffer, y
+		iny
+		bne l1
+		jmp done
+#if !FLOSSIEC_NOIRQ
+	iq:
+		ldy #0
+		sec
+	l1i:
+		ldx accu + 1		
+	l2i:
+		cli
+		sei
+#if !FLOSSIEC_NODISPLAY
+		lda 0xd012
+		sbc #50
+		bcc w1i
+		and #7
+		beq l2i
+	w1i:
+#endif
+		stx CIA2PRA
+
+#if FLOSSIEC_BORDER
+		inc 0xd020
+#else
+		nop
+		nop
+		nop
+#endif
+		ldx accu
+		nop
+
+		lda CIA2PRA
+		lsr
+		lsr
+		nop
+		eor CIA2PRA
+		lsr
+		lsr
+		nop
+		eor CIA2PRA
+		lsr
+		lsr
+		sec
+		eor CIA2PRA
+		stx CIA2PRA
+
+		sta rbuffer, y
+		iny
+		bne l1i
+		cli
+#endif
+	done:	
+
+#if FLOSSIEC_NOIRQ
+		plp		
+#endif
+	}
+}
+
+
+
+inline char flossiec_get(void)
+{
+	if (!flpos)
+	{
+		fl_read_buf();
+		flpos = 2;
+	}
+	return remap[rbuffer[flpos++]];
+}
+
+void flossiec_decompress(void)
+{
+	char i  = 0, j = xj, cmd = xcmd;
+	xi = 0;
+
+	for(;;)
+	{
+		if (cmd & 0x80)
+		{
+			if (i < cmd)
+			{
+				char t = i - cmd;
+				do {
+					char ch = xbuffer[j++];
+					xbuffer[i++] = ch;
+				} while (i != t);
+				cmd = 0;
+			}
+			else
+			{
+				cmd -= i;
+				do {
+					char ch = xbuffer[j++];
+					xbuffer[i++] = ch;
+				} while (i);
+				break;
+			}
+		}
+		else 
+		{
+			char ch = flossiec_get();
+			if (cmd)
+			{
+				xbuffer[i++] = ch;
+				cmd--;
+				if (!i)
+					break;
+			}
+			else
+			{
+				cmd = ch;
+				if (!cmd)
+					break;
+				if (cmd & 0x80)
+				{
+					cmd ^= 0x7f;
+					cmd++;
+					j = i - flossiec_get();
+				}
+			}
+		}
+	}
+	xj = j;
+	xcmd = cmd;	
+}
+
+inline char flossiec_get_lzo(void)
+{
+	if (!xi)
+		flossiec_decompress();
+	return xbuffer[xi++];
+}
+
+inline bool flossiec_eof(void)
+{
+	return !remap[rbuffer[0]] && flpos >= remap[rbuffer[1]];
+}
+
+char * flossiec_read(char * dp, unsigned size)
+{
+	while (size)
+	{
+		*dp++ = flossiec_get();
+		size--;
+	}
+
+	return dp;
+}
+
+char * flossiec_read_lzo(char * dp, unsigned size)
+{
+	char i = xi;
+
+	dp -= i;
+	size += i;
+
+	while (size)
+	{
+		if (!i)
+			flossiec_decompress();
+		
+		if (size >= 256)
+		{
+			do {
+				dp[i] = xbuffer[i];
+				i++;
+			} while (i);
+			dp += 256;
+			size -= 256;
+		}
+		else
+		{
+			do {
+				dp[i] = xbuffer[i];
+				i++;
+			} while (i != (char)size);
+			dp += i;
+			break;
+		}
+	}
+
+	xi = i;
+
+	return dp;
+}
+
+static void vxorcheck(void)
+{
+	char vxor = cia2.pra & 7;
+	vxor ^= vxor >> 2;
+	vxor ^= 0xff;
+
+	if (vxor != flvxor)
+	{
+		flvxor = vxor;
+
+		for(int i=0; i<256; i++)
+		{
+			char j = i ^ vxor;
+			char d = ((j & 0x11) << 3) |
+			          (j & 0x66) |
+			         ((j & 0x88) >> 3);
+			remap[i] = d;
+		}
+	}
+}
+
+bool flossiec_init(char drive)
+{
+	fldrive = drive;
+	flvxor = 0;
+
+	iec_open(drive, 2, "#2");
+	iec_listen(drive, 2);
+	for(char j=0; j<127; j++)
+		iec_write(((char *)diskcode)[j]);
+	iec_unlisten();		
+
+	iec_close(drive, 2);
+
+	iec_open(drive, 15, "");
+
+	return true;	
+}
+
+void flossiec_shutdown(void)
+{
+	iec_close(fldrive, 15);
+}
+
+
+bool flossiec_open(char track, char sector)
+{
+	iec_listen(fldrive, 15);
+	iec_write(P'U');
+	iec_write(P'4');
+	iec_write(track);
+	iec_write(sector);
+	iec_unlisten();	
+
+	cia2.pra |= CIA2B_DATAOUT;
+
+
+#if FLOSSIEC_NODISPLAY
+	vic.ctrl1 &= ~VIC_CTRL1_DEN;
+#endif
+
+	vic_waitFrame();
+	vxorcheck();
+	vic_waitFrame();
+
+	flpos = 0;
+	xi = 0;
+
+	return true;
+}
+
+void flossiec_close(void)
+{
+	cia2.pra |= CIA2B_DATAOUT;
+
+#if FLOSSIEC_NODISPLAY
+	vic.ctrl1 |= VIC_CTRL1_DEN;
+#endif	
+}
+
+bool flosskio_init(char drive)
+{
+	fldrive = drive;
+	flvxor = 0;
+
+	krnio_setnam_n("#2", 2);
+	krnio_open(2, drive, 2);
+	krnio_write(2, (char *)diskcode, 128);
+	krnio_close(2);
+
+	krnio_setnam_n(nullptr, 0);
+	krnio_open(15, drive, 15);
+
+	return true;	
+}
+
+void flosskio_shutdown(void)
+{
+	krnio_close(15);
+}
+
+
+bool flosskio_open(char track, char sector)
+{
+	krnio_chkout(15);
+	krnio_chrout(P'U');
+	krnio_chrout(P'4');
+	krnio_chrout(track);
+	krnio_chrout(sector);
+	krnio_clrchn();
+
+	cia2.pra |= CIA2B_DATAOUT;
+
+#if FLOSSIEC_NODISPLAY
+	vic.ctrl1 &= ~VIC_CTRL1_DEN;
+#endif
+
+	vic_waitFrame();
+	vxorcheck();
+	vic_waitFrame();
+
+	flpos = 0;
+	xi = 0;
+
+	return true;
+}
+
+void flosskio_close(void)
+{
+	cia2.pra |= CIA2B_DATAOUT;
+
+#if FLOSSIEC_NODISPLAY
+	vic.ctrl1 |= VIC_CTRL1_DEN;
+#endif	
+}
+
+static bool mapdir(const char * fnames, floss_blk * blks)
+{
+	do {
+		fl_read_buf();
+
+		char si = 0;
+		do
+		{
+			if (remap[rbuffer[si + 2]] == 0x82)
+			{
+				char fname[17];
+				char j = 0;
+				while (j < 16 && remap[rbuffer[si + j + 5]] != 0xa0)
+				{
+					fname[j] = remap[rbuffer[si + j + 5]];
+					j++;
+				}
+				fname[j] = 0;
+
+				char sj = 0;
+				char k = 0;
+				while (fnames[sj])
+				{
+					j = 0;
+					while (fname[j] && fname[j] == fnames[sj])
+					{
+						j++;
+						sj++;
+					}
+					if (!fname[j] && (!fnames[sj] || fnames[sj] == ','))
+					{
+						__assume(k < 128);
+						blks[k].track = remap[rbuffer[si + 3]];
+						blks[k].sector = remap[rbuffer[si + 4]];
+						break;
+					}
+
+					while (fnames[sj] && fnames[sj++] != ',')
+						;
+					k++;
+				}
+			}
+
+			si += 32;
+		} while (si);
+
+	}	while (remap[rbuffer[0]]);
+
+	return true;
+}
+
+bool flosskio_mapdir(const char * fnames, floss_blk * blks)
+{
+	if (flosskio_open(18, 1))
+	{
+		mapdir(fnames, blks);
+
+		flosskio_close();
+		return true;
+	}
+
+	return false;
+}
+
+bool flossiec_mapdir(const char * fnames, floss_blk * blks)
+{
+	if (flossiec_open(18, 1))
+	{
+		mapdir(fnames, blks);
+
+		flossiec_close();
+		return true;
+	}
+
+	return false;
+}
+

include/c64/flossiec.h

@@ -0,0 +1,79 @@
+#ifndef FLOSSIEC_H
+#define FLOSSIEC_H
+
+// When building you can use various defines to change the behaviour
+
+// FLOSSIEC_BORDER=1		Enable border flashing while loading
+// FLOSSIEC_NODISPLAY=1		Disable the display while loading
+// FLOSSIEC_NOIRQ=1			Disable IRQ during load	
+// FLOSSIEC_CODE=cseg		Code segment to be used, when defined
+// FLOSSIEC_BSS=bseg		BSS segment to be used, when defined
+
+// Initialize the fastloader to be used without the kernal
+bool flossiec_init(char drive);
+
+// Shutdown the fastloader when used without the kernal
+void flossiec_shutdown(void);
+
+// Open a file for read with the fastloader without the kernal.
+// The file has to be read to completion before you can close
+// it again,
+bool flossiec_open(char track, char sector);
+
+// Close a file after reading
+void flossiec_close(void);
+
+
+// Initialize the fastloader to be used with the kernal
+bool flosskio_init(char drive);
+
+// Shutdown the fastloader when used with the kernal
+void flosskio_shutdown(void);
+
+
+// Open a file for read with the fastloader with the kernal
+// The file has to be read to completion before you can close
+// it again,
+bool flosskio_open(char track, char sector);
+
+// Close a file after reading
+void flosskio_close(void);
+
+
+// Track and sector start of a file
+struct floss_blk
+{
+	char	track, sector;
+};
+
+// Map a comma separated list of filenames to an array of
+// block start positions by reading the directory, using the
+// kernal.
+bool flosskio_mapdir(const char * fnames, floss_blk * blks);
+
+// Map a comma separated list of filenames to an array of
+// block start positions by reading the directory, without the
+// kernal.
+bool flossiec_mapdir(const char * fnames, floss_blk * blks);
+
+// Check for end of file while reading
+inline bool flossiec_eof(void);
+
+// Get one char from uncompressed file
+inline char flossiec_get(void);
+
+// Get one char from compressed file
+inline char flossiec_get_lzo(void);
+
+// Read a section of a file into memory up to size bytes,
+// returns the first address after the read
+char * flossiec_read(char * dp, unsigned size);
+
+// Read and expand section of a file into memory up to size 
+// bytes, returns the first address after the read
+char * flossiec_read_lzo(char * dp, unsigned size);
+
+
+#pragma compile("flossiec.c")
+
+#endif

include/c64/iecbus.c

@@ -2,7 +2,8 @@
 #include <c64/cia.h>
 #include <c64/vic.h>
 
-IEC_STATUS iec_status;
+IEC_STATUS 	iec_status;
+char		iec_queue;
 
 #define CIA2B_ATNOUT	0x08
 #define CIA2B_CLKOUT	0x10
@@ -14,139 +15,180 @@ IEC_STATUS iec_status;
 #pragma optimize(push)
 #pragma optimize(1)
 
+// multiples of 5us
 static void delay(char n)
 {
-	while (n)
+	__asm {
-	{
+		ldx n
-		__asm {
+	l1:
-			nop
+		dex
-		}
+		bne	l1
-		n--;		
 	}
 }
 
-static inline void data_low(void)
+static inline void data_true(void)
 {
 	cia2.pra &= ~CIA2B_DATAOUT;
 }
 
-static inline void data_high(void)
+static inline void data_false(void)
 {
 	cia2.pra |= CIA2B_DATAOUT;
 }
 
-static inline void clock_low(void)
+static inline void clock_true(void)
 {
 	cia2.pra &= ~CIA2B_CLKOUT;
 }
 
-static inline void cdata_low(void)
+static inline void cdata_true(void)
 {
 	cia2.pra &= ~(CIA2B_CLKOUT | CIA2B_DATAOUT);
 }
 
-static inline void clock_high(void)
+static inline void clock_false(void)
 {
 	cia2.pra |= CIA2B_CLKOUT;
 }
 
-static inline void atn_low(void)
+static inline void atn_true(void)
 {
 	cia2.pra &= ~CIA2B_ATNOUT;
 }
 
-static inline void atn_high(void)
+static inline void atn_false(void)
 {
 	cia2.pra |= CIA2B_ATNOUT;
 }
 
+static inline bool data_in(void)
+{
+	return (cia2.pra & CIA2B_DATAIN) != 0;
+}
+
+static inline bool clock_in(void)
+{
+	return (cia2.pra & CIA2B_CLKIN) != 0;
+}
+
 static bool data_check(void)
 {
- 	char cnt = 100;
+ 	char cnt = 200;
-	while (cnt > 0 && (cia2.pra & CIA2B_DATAIN))
+	while (cnt > 0 && data_in())
+	{
+		delay(5);
 		cnt--;
+	}
 
 	if (cnt)
 		return true;
 	else
 	{
-		iec_status = IEC_TIMEOUT;
+		iec_status = IEC_DATA_CHECK;
 		return false;
 	}	
 }
 
-bool iec_eoi(void)
+static bool iec_eoib(void)
 {
-	cdata_low();
+	clock_true();
 
-	while (!(cia2.pra & CIA2B_DATAIN))
+	while (!data_in());
-		;
+
-	delay(50);
+	delay(40);
 
 	return data_check();
 }
 
+static void iec_writeb(char b)
+{
+	clock_true();
+
+	while (!data_in());
+
+	delay(5);
+	for(char i=0; i<8; i++)
+	{
+		clock_false();
+		delay(5);
+		if (b & 1)
+			data_true();
+		else
+			data_false();		
+		clock_true();
+		b >>= 1;
+		delay(5);
+	}
+	clock_false();
+	data_true();
+}
+
 bool iec_write(char b)
 {
-	cdata_low();
+	if (iec_status == IEC_QUEUED)
-
-	while (!(cia2.pra & CIA2B_DATAIN))
-		;
-
-	for(char i=0; i<8; i++)
 	{
-		clock_high();
-		if (b & 1)
-			data_low();
-		else
-			data_high();		
-		clock_low();
-		b >>= 1;
 		__asm
 		{
-			nop
+			php
-			nop
+			sei
-			nop
-			nop
 		}
-	}
-	data_low();
-	clock_high();
 
-	return data_check();
+		iec_status = IEC_OK;
+		iec_writeb(iec_queue);
+
+	 	__asm
+		{
+			plp
+		}
+
+		data_check();
+	}
+	if (iec_status < IEC_ERROR)
+	{
+		iec_queue = b;
+		iec_status = IEC_QUEUED;
+		return true;
+	}
+
+	return false;
 }
 
 char iec_read(void)
 {
-	while (!(cia2.pra & CIA2B_CLKIN))
+	while (!clock_in());
-		;
 
- 	data_low();
+	__asm
+	{
+		php
+		sei
+	}
+
+ 	data_true();
 
  	char cnt = 100;
-	while (cnt > 0 && (cia2.pra & CIA2B_CLKIN))
+	while (cnt > 0 && clock_in())
 		cnt--;
 
 	if (cnt == 0)
 	{
 		iec_status = IEC_EOF;
- 		data_high();
+ 		data_false();
-		__asm
+		delay(10);
-		{
+		data_true();
-			nop
-			nop
-			nop
-			nop
-		}
-		data_low();
 
 		cnt = 200;
-		while (cnt > 0 && (cia2.pra & CIA2B_CLKIN))
+		while (cnt > 0 && clock_in())
 			cnt--;
 
 		if (cnt == 0)
 		{
 			iec_status = IEC_TIMEOUT;
+
+		 	__asm
+			{
+				plp
+			}
+			
 			return 0;
 		}
  	}
@@ -165,24 +207,36 @@ char iec_read(void)
 			;
  	}
 
- 	data_high();
+ 	data_false();
+ 	
+ 	__asm
+	{
+		plp
+	}
 
  	return b;
 }
 
 void iec_atn(char dev, char sec)
 {	
-	atn_high();
+	clock_true();
- 	clock_high();
+	data_true();
+	atn_false();
+	clock_false();
 
- 	delay(100);
+ 	delay(200);
 
-	iec_write(dev);
+ 	while (data_in());
+
+	iec_writeb(dev);
+	data_check();
 	if (sec != 0xff)
-		iec_write(sec);
+	{
+		iec_writeb(sec);
+		data_check();
+	}
 
-	data_high();
+	atn_true();	
-	atn_low();	
 }
 
 
@@ -190,8 +244,26 @@ void iec_talk(char dev, char sec)
 {
 	iec_status = IEC_OK;
 
-	iec_atn(dev | 0x40, sec);
+	iec_atn(dev | 0x40, sec | 0x60);
-	clock_low();	
+	data_false();
+
+	__asm
+	{
+		php
+		sei
+	}
+
+	clock_true();
+	char cnt = 200;
+	while (cnt > 0 && clock_in())
+		cnt--;
+
+ 	__asm
+	{
+		plp
+	}
+
+	delay(10);	
 }
 
 void iec_untalk(void)
@@ -203,12 +275,32 @@ void iec_listen(char dev, char sec)
 {
 	iec_status = IEC_OK;
 
-	iec_atn(dev | 0x20, sec);
+	iec_atn(dev | 0x20, sec | 0x60);
 }
 
 void iec_unlisten(void)
 {
+	__asm
+	{
+		php
+		sei
+	}
+
+	if (iec_status == IEC_QUEUED)
+	{
+		iec_status = IEC_OK;
+		iec_eoib();
+		iec_writeb(iec_queue);
+		data_check();
+	}
+
 	iec_atn(0x3f, 0xff);
+	clock_true();
+
+ 	__asm
+	{
+		plp
+	}
 }
 
 void iec_open(char dev, char sec, const char * fname)
@@ -216,11 +308,10 @@ void iec_open(char dev, char sec, const char * fname)
 	iec_status = IEC_OK;
 
 	iec_atn(dev | 0x20, sec | 0xf0);
+
 	char i = 0;
 	while (fname[i])
 	{
-		if (!fname[i + 1])
-			iec_eoi();
 		iec_write(fname[i]);
 		i++;
 	}
@@ -233,6 +324,30 @@ void iec_close(char dev, char sec)
 	iec_unlisten();
 }
 
+int iec_write_bytes(const char * data, int num)
+{
+	for(int i=0; i<num; i++)
+	{
+		if (!iec_write(data[i]))
+			return i;
+	}
+	return num;
+}
+
+int iec_read_bytes(char * data, int num)
+{
+	int i = 0;
+	while (i < num)
+	{
+		char ch = iec_read();
+		if (iec_status < IEC_ERROR)
+			data[i++] = ch;
+		if (iec_status != IEC_OK)
+			return i;
+	}
+	return num;
+}
+
 
 #pragma optimize(pop)
 

include/c64/iecbus.h

@@ -5,15 +5,15 @@ enum IEC_STATUS
 {
 	IEC_OK = 0x00,
 	IEC_EOF = 0x01,
+	IEC_QUEUED = 0x02,
 
 	IEC_ERROR = 0x80,
-	IEC_TIMEOUT
+	IEC_TIMEOUT,
+	IEC_DATA_CHECK,
 };
 
 extern IEC_STATUS iec_status;
 
-bool iec_eoi(void);
-
 bool iec_write(char b);
 
 char iec_read(void);
@@ -32,6 +32,11 @@ void iec_open(char dev, char sec, const char * fname);
 
 void iec_close(char dev, char sec);
 
+int iec_write_bytes(const char * data, int num);
+
+int iec_read_bytes(char * data, int num);
+
+
 #pragma compile("iecbus.c")
 
 #endif

include/c64/kernalio.c

@@ -2,7 +2,32 @@
 
 krnioerr krnio_pstatus[16];
 
-void krnio_setnam(const char * name)
+#if defined(__C128__) || defined(__C128B__) || defined(__C128E__)
+void krnio_setbnk(char filebank, char namebank)
+{
+	__asm
+	{
+		lda filebank
+		ldx namebank
+		jsr $ff68			// setbnk
+	}
+}
+
+#pragma native(krnio_setbnk)
+#endif
+
+#if defined(__PLUS4__)
+#pragma code(lowcode)
+#define BANKIN	sta 0xff3e
+#define BANKOUT	sta 0xff3f
+#define BANKINLINE	__noinline
+#else
+#define BANKIN
+#define BANKOUT
+#define BANKINLINE
+#endif
+
+BANKINLINE void krnio_setnam(const char * name)
 {
 	__asm
 	{
@@ -17,22 +42,41 @@ void krnio_setnam(const char * name)
 		tya
 	W1: ldx name
 		ldy	name + 1
+		BANKIN
 		jsr	$ffbd			// setnam
+		BANKOUT
 	}
 }
 
 #pragma native(krnio_setnam)
 
-bool krnio_open(char fnum, char device, char channel)
+BANKINLINE void krnio_setnam_n(const char * name, char len)
+{
+	__asm
+	{
+		lda len
+		ldx name
+		ldy	name + 1
+		BANKIN
+		jsr	$ffbd			// setnam
+		BANKOUT
+	}	
+}
+
+#pragma native(krnio_setnam_n)
+
+BANKINLINE bool krnio_open(char fnum, char device, char channel)
 {
 	krnio_pstatus[fnum] = KRNIO_OK;
 
-	__asm
+	return char(__asm
 	{
 		lda	#0
 		sta accu
 		sta	accu + 1
 
+		BANKIN
+
 		lda	fnum
 		ldx	device
 		ldy channel		
@@ -47,46 +91,48 @@ bool krnio_open(char fnum, char device, char channel)
 	W1:
 		lda	#1
 		sta	accu
-	E2:
-	}
 
+		BANKOUT
+	E2:
+	});
 }
 
 #pragma native(krnio_open)
 
-void krnio_close(char fnum)
+BANKINLINE void krnio_close(char fnum)
 {
 	__asm
 	{
+		BANKIN
 		lda	fnum
 		jsr	$ffc3			// close
+		BANKOUT
 	}	
 }
 
 #pragma native(krnio_close)
 
-krnioerr krnio_status(void)
+BANKINLINE krnioerr krnio_status(void)
 {
-	__asm
+	return __asm
 	{
+		BANKIN
 		jsr $ffb7			// readst
+		BANKOUT
 		sta accu
 		lda #0
 		sta accu + 1
-	}
+	};
 }
 
 #pragma native(krnio_status)
 
 
-bool krnio_load(char fnum, char device, char channel)
+BANKINLINE bool krnio_load(char fnum, char device, char channel)
 {
-	__asm
+	return char(__asm
 	{
-		lda	#0
+		BANKIN
-		sta accu
-		sta	accu + 1
-
 		lda	fnum
 		ldx	device
 		ldy channel		
@@ -95,89 +141,123 @@ bool krnio_load(char fnum, char device, char channel)
 		lda #0
 		ldx #0
 		ldy #0
-		jsr	$FFD5			// open
+		jsr	$FFD5			// load
-		bcc	W1
+		BANKOUT
 
 		lda #0
-		jmp	E2
+		rol
-	W1:
+		eor #1
-		lda	#1
+		sta accu
-		sta	accu
+	});
-	E2:
-	}
 }
 
 #pragma native(krnio_load)
 
-bool krnio_chkout(char fnum)
+BANKINLINE bool krnio_save(char device, const char* start, const char* end)
 {
-	__asm
+	return char(__asm
 	{
+		BANKIN
+		lda	#0
+		ldx	device
+		ldy #0		
+		jsr	$ffba			// setlfs
+		
+		lda #start
+		ldx end
+		ldy end+1
+		jsr	$FFD8			// save
+
+		BANKOUT
+
+		lda #0
+		rol
+		eor #1
+		sta accu
+	});
+}
+
+#pragma native(krnio_save)
+
+BANKINLINE bool krnio_chkout(char fnum)
+{
+	return char(__asm
+	{
+		BANKIN
 		ldx fnum
 		jsr	$ffc9			// chkout
+		BANKOUT
+
 		lda #0
-		sta accu + 1
+		rol
-		bcs W1
+		eor #1
-		lda #1
+		sta accu
-	W1: sta accu
+	});
-	}
 }
 
 #pragma native(krnio_chkout)
 
-bool krnio_chkin(char fnum)
+BANKINLINE bool krnio_chkin(char fnum)
 {
-	__asm
+	return char(__asm
 	{
+		BANKIN
 		ldx fnum
 		jsr	$ffc6			// chkin
+		BANKOUT
+
 		lda #0
-		sta accu + 1
+		rol
-		bcs W1
+		eor #1
-		lda #1
+		sta accu
-	W1: sta accu
+	});
-	}
 }
 
 #pragma native(krnio_chkin)
 
-void krnio_clrchn(void)
+BANKINLINE void krnio_clrchn(void)
 {
 	__asm
 	{
+		BANKIN
 		jsr $ffcc		// clrchn
+		BANKOUT
 	}
 }
 
 #pragma native(krnio_clrchn)
 
-bool krnio_chrout(char ch)
+BANKINLINE bool krnio_chrout(char ch)
 {
-		__asm
+	return char(__asm
 	{
+		BANKIN
 		lda ch
 		jsr $ffd2		// chrout
 		sta accu
-		lda #0
+		BANKOUT
-		sta accu + 1
+	});
-	}
 }
 
 #pragma native(krnio_chrout)
 
-int krnio_chrin(void)
+BANKINLINE char krnio_chrin(void)
 {
-	__asm
+	return __asm
 	{
+		BANKIN
 		jsr $ffcf		// chrin
 		sta accu
-		lda #0
+		BANKOUT
-		sta accu + 1
+	};
-	}
 }
 
 #pragma native(krnio_chrin)
 
+#if defined(__PLUS4__)
+#pragma code(code)
+#endif
+
 int krnio_getch(char fnum)
 {
 	if (krnio_pstatus[fnum] == KRNIO_EOF)
@@ -341,7 +421,7 @@ int krnio_gets(char fnum, char * data, int num)
 
 	if (krnio_chkin(fnum))
 	{
-		krnioerr err;
+		krnioerr err = KRNIO_OK;
 		int i = 0;
 		int ch;
 		while (i + 1 < num)

include/c64/kernalio.h

@@ -1,5 +1,5 @@
 #ifndef C64_KERNALIO_H
-#ifndef C64_KERNALIO_H
+#define C64_KERNALIO_H
 
 // Error and status codes returned by krnio_status
 
@@ -18,11 +18,18 @@ enum krnioerr
 
 extern krnioerr krnio_pstatus[16];
 
+#if defined(__C128__) || defined(__C128B__) || defined(__C128E__)
+// C128: Set bank for load/save and filename for next file operations
+void krnio_setbnk(char filebank, char namebank);
+#endif
+
 // Set filename for next krnio_open operation, make sure
 // that the string is still valid when calling krnio_open
 
 void krnio_setnam(const char * name);
 
+void krnio_setnam_n(const char * name, char len);
+
 // open a kernal file/stream/io channel, returns true on success
 
 bool krnio_open(char fnum, char device, char channel);
@@ -37,6 +44,8 @@ krnioerr krnio_status(void);
 
 bool krnio_load(char fnum, char device, char channel);
 
+bool krnio_save(char device, const char* start, const char* end);
+
 // select the given file for stream output
 
 bool krnio_chkout(char fnum);
@@ -55,7 +64,7 @@ bool krnio_chrout(char ch);
 
 // read a single byte from the current input channel
 
-int krnio_chrin(void);
+char krnio_chrin(void);
 
 // read a single byte from the given file/channel, returns
 // a negative result on failure.  If this was the last byte

include/c64/rasterirq.c

@@ -5,39 +5,42 @@
 #include <c64/asm6502.h>
 #include <stdlib.h>
 
-volatile char npos = 1, tpos = 0;
 volatile byte rirq_count;
+static byte rirq_pcount;
 
-byte		rasterIRQRows[NUM_IRQS];
+byte		rasterIRQRows[NUM_IRQS + 1];	
-byte		rasterIRQIndex[NUM_IRQS];
+byte		rasterIRQIndex[NUM_IRQS + 1];	// Sort order of interrupt index, offset by one
-byte		rasterIRQNext[NUM_IRQS + 1];
+#ifdef ZPAGE_IRQS
-byte		rasterIRQLow[NUM_IRQS];
+__zeropage
+#endif
+byte		rasterIRQNext[NUM_IRQS + 1];	// Rasterline of interrupt, terminated by 0xff
+byte		rasterIRQLow[NUM_IRQS];			// Address of interrupt code
 byte		rasterIRQHigh[NUM_IRQS];
 
+#ifdef ZPAGE_IRQS
+__zeropage
+#endif
 byte		nextIRQ;
 
-__asm irq0
+// nextIRQ is the index of the next expected IRQ, or $ff if no IRQ is scheduled
-{	
-    pha
-    txa
-    pha
-    tya
-    pha
 
-	asl $d019
+__asm rirq_isr_ram_io
+{	
+	stx plrx + 1
 
 	ldx	nextIRQ
+	bmi	exi
+
+	sta plra + 1
+	sty plry + 1
+
 l1:	
 	lda	rasterIRQNext, x
-	cmp	#$ff
+	ldy rasterIRQIndex + 1, x
-	beq	e1
+	ldx	rasterIRQLow, y
-
+	stx ji + 1
-	ldy rasterIRQIndex, x
+	ldx	rasterIRQHigh, y
-	tax
+	stx ji + 2
-	lda	rasterIRQLow, y
-	sta ji + 1
-	lda	rasterIRQHigh, y
-	sta ji + 2
 
 ji:	
 	jsr $0000
@@ -45,21 +48,82 @@ ji:
 	inc	nextIRQ
 	ldx nextIRQ
 
-	lda	rasterIRQNext, x
+	ldy	rasterIRQNext, x
-	cmp #$ff
+
+	asl $d019
+
+	cpy #$ff
 	beq e2
-	// carry is cleared at this point
 
-	tay
 	dey
-	sbc #2
-	cmp $d012
-	bcc	l1
-
 	sty	$d012
+	dey
+	cpy $d012
+	bcc l1
 
-ex:
+plry:
+	ldy #0
+plra:
+	lda #0
+plrx:
+	ldx #0
+    rti
 
+exi:
+	asl $d019
+	jmp plrx
+
+    // No more interrupts to service
+e2:
+	inc rirq_count
+
+	ldy	rasterIRQNext
+	dey
+	sty	$d012
+	ldx	#0
+	stx nextIRQ
+	beq	plry
+}
+
+__asm rirq_isr_io
+{	
+    pha
+    txa
+    pha
+    tya
+    pha
+kentry:
+
+	ldx	nextIRQ
+	bmi	exi
+l1:
+	lda	rasterIRQNext, x
+	ldy rasterIRQIndex + 1, x
+	ldx	rasterIRQLow, y
+	stx ji + 1
+	ldx	rasterIRQHigh, y
+	stx ji + 2
+
+ji:	
+	jsr $0000
+
+	inc	nextIRQ
+	ldx nextIRQ
+
+	ldy	rasterIRQNext, x
+
+	asl $d019
+
+	cpy #$ff
+	beq e2
+
+	dey
+	sty	$d012
+	dey
+	cpy $d012
+	bcc l1
+
+exd:
     pla
     tay
     pla
@@ -67,56 +131,44 @@ ex:
     pla
     rti
 
-e2:
+exi:
+	asl $d019
+	jmp exd
 
-	ldx npos
+e2:
-	stx tpos
 	inc rirq_count
 
-	bit	$d011
-	bmi e1
-
-	sta	$d012
-	jmp ex
-
-e1:
-	ldx	#0
-	stx nextIRQ
 	ldy	rasterIRQNext
 	dey
 	sty	$d012
-	jmp	ex
+	ldx	#0
-
+	stx nextIRQ
+	beq	exd
 }
 
-__asm irq2
+__asm rirq_isr_noio
 {	
     pha
     txa
     pha
     tya
     pha
-
+kentry:
     lda $01
     pha
 
     lda #$35
     sta $01
 
-	asl $d019
-
 	ldx	nextIRQ
+	bmi	exi
 l1:
 	lda	rasterIRQNext, x
-	cmp	#$ff
+	ldy rasterIRQIndex + 1, x
-	beq	e1
+	ldx	rasterIRQLow, y
-
+	stx ji + 1
-	ldy rasterIRQIndex, x
+	ldx	rasterIRQHigh, y
-	tax
+	stx ji + 2
-	lda	rasterIRQLow, y
-	sta ji + 1
-	lda	rasterIRQHigh, y
-	sta ji + 2
 
 ji:	
 	jsr $0000
@@ -124,21 +176,20 @@ ji:
 	inc	nextIRQ
 	ldx nextIRQ
 
-	lda	rasterIRQNext, x
+	ldy	rasterIRQNext, x
-	cmp #$ff
+
+	asl $d019
+
+	cpy #$ff
 	beq e2
-	// carry is cleared at this point
 
-	tay
 	dey
-	sbc #2
-	cmp $d012
-	bcc	l1
-
 	sty	$d012
+	dey
+	cpy $d012
+	bcc l1
 
-ex:
+exd:
-
 	pla
 	sta $01
 
@@ -149,45 +200,35 @@ ex:
     pla
     rti
 
-e2:
+exi:
+	asl $d019
+	jmp exd
 
-	ldx npos
+e2:
-	stx tpos
 	inc rirq_count
 
-	bit	$d011
-	bmi e1
-
-	sta	$d012
-	jmp ex
-
-e1:
-	ldx	#0
-	stx nextIRQ
 	ldy	rasterIRQNext
 	dey
 	sty	$d012
-	jmp	ex
+	ldx	#0
-
+	stx nextIRQ
+	beq	exd
 }
 
-__asm irq1
+__asm rirq_isr_kernal_io
 {	
 	lda $d019
 	bpl ex2
 	
 	ldx	nextIRQ
+	bmi exi
 l1:
 	lda	rasterIRQNext, x
-	cmp	#$ff
+	ldy rasterIRQIndex + 1, x
-	beq	e1
+	ldx	rasterIRQLow, y
-
+	stx ji + 1
-	ldy rasterIRQIndex, x
+	ldx	rasterIRQHigh, y
-	tax
+	stx ji + 2
-	lda	rasterIRQLow, y
-	sta ji + 1
-	lda	rasterIRQHigh, y
-	sta ji + 2
 
 ji:	
 	jsr $0000
@@ -196,45 +237,36 @@ jx:
 	inc	nextIRQ
 	ldx nextIRQ
 
-	lda	rasterIRQNext, x
+	ldy	rasterIRQNext, x
-	cmp #$ff
-	beq e2
 
-	tay
-
-	sec
-	sbc	#4
-	cmp	$d012
-	bcc l1
-
-	dey
-	sty	$d012
-w1:
-	jmp ex
-
-e2:
-	ldx npos
-	stx tpos
-	inc rirq_count
-
-	bit	$d011
-	bmi e1
-
-	sta $d012
-
-	jmp ex
-
-e1:
-	ldx	#0
-	stx nextIRQ
-	lda	rasterIRQNext, x
-	sec
-	sbc	#1
-	sta $d012
-	
-ex:
 	asl $d019
 
+	cpy #$ff
+	beq e2
+
+	dey
+	dey
+	sty	$d012
+	dey
+	cpy $d012
+	bcc l1
+
+exd:
+	jmp $ea81
+
+exi:
+	asl $d019
+	jmp $ea81
+
+e2:
+	inc rirq_count
+
+	ldy	rasterIRQNext
+	dey
+	dey
+	sty	$d012
+	ldx	#0
+	stx nextIRQ
 	jmp $ea81
 
 ex2:
@@ -243,6 +275,76 @@ ex2:
 	jmp $ea31
 }
 
+__asm rirq_isr_kernal_noio
+{	
+	lda $01
+	pha
+	lda #$36
+	sta $01
+
+	lda $d019
+	bpl ex2
+	
+	ldx	nextIRQ
+	bmi exi
+l1:
+	lda	rasterIRQNext, x
+	ldy rasterIRQIndex + 1, x
+	ldx	rasterIRQLow, y
+	stx ji + 1
+	ldx	rasterIRQHigh, y
+	stx ji + 2
+
+ji:	
+	jsr $0000
+jx:
+
+	inc	nextIRQ
+	ldx nextIRQ
+
+	ldy	rasterIRQNext, x
+
+	asl $d019
+
+	cpy #$ff
+	beq e2
+
+	dey
+	dey
+	sty	$d012
+	dey
+	cpy $d012
+	bcc l1
+exd:
+	pla
+	sta $01
+
+	jmp $ea81
+
+exi:
+	asl $d019
+	jmp exd
+
+e2:
+	inc rirq_count
+
+	ldy	rasterIRQNext
+	dey
+	dey
+	sty	$d012
+	ldx	#0
+	stx nextIRQ
+	beq	exd
+
+ex2:
+	LDA $DC0D
+	cli
+	pla
+	sta $01
+
+	jmp $ea31
+}
+
 //  0 lda #data0
 //  2 ldy #data1
 //  4 cpx $d012
@@ -263,8 +365,8 @@ void rirq_build(RIRQCode * ic, byte size)
 	ic->size = size;
 
 	asm_im(ic->code + 0, ASM_LDY, 0);
-	asm_im(ic->code + 2, ASM_LDA, 0);
+	asm_im(ic->code + 2, ASM_LDX, 0);
-	asm_ab(ic->code + 4, ASM_CPX, 0xd012);
+	asm_ab(ic->code + 4, ASM_CMP, 0xd012);
 	asm_rl(ic->code + 7, ASM_BCS, -5);
 	asm_ab(ic->code + 9, ASM_STY, 0x0000);
 
@@ -278,7 +380,7 @@ void rirq_build(RIRQCode * ic, byte size)
 	}
 	else
 	{
-		asm_ab(ic->code + 12, ASM_STA, 0x0000);
+		asm_ab(ic->code + 12, ASM_STX, 0x0000);
 
 		byte p = 15;
 		for(byte i=2; i<size; i++)
@@ -328,10 +430,17 @@ void rirq_addr(RIRQCode * ic, byte n, void * addr)
 	ic->code[p + 1] = (unsigned)addr >> 8;
 }
 
+void rirq_addrhi(RIRQCode * ic, byte n, byte hi)
+{
+	byte p = irqai[n];
+	ic->code[p + 1] = hi;	
+}
+
 void rirq_data(RIRQCode * ic, byte n, byte data)
 {
 	byte p = irqdi[n];
-	ic->code[p] = data;
+//	ic->code[p] = data;	
+	(volatile char *)(ic->code)[p] = data;
 }
 
 void rirq_write(RIRQCode * ic, byte n, void * addr, byte data)
@@ -370,21 +479,81 @@ void rirq_clear(byte n)
 	rasterIRQRows[n] = 255;
 }
 
-void rirq_init_kernal(void)
+void rirq_init_tables(void)
 {
 	for(byte i=0; i<NUM_IRQS; i++)
 	{
 		rasterIRQRows[i] = 255;
-		rasterIRQIndex[i] = i;
+		rasterIRQIndex[i + 1] = i;
 	}
+	rasterIRQIndex[0] = NUM_IRQS;
+	rasterIRQRows[NUM_IRQS] = 0;
 	rasterIRQNext[NUM_IRQS] = 255;
+}
+
+void rirq_init_kernal(void)
+{
+	rirq_init_tables();
 
     __asm 
     {
         sei
     }
 
-   	*(void **)0x0314 = irq1;
+   	*(void **)0x0314 = rirq_isr_kernal_io;
+
+	vic.intr_enable = 1;
+	vic.ctrl1 &= 0x7f;
+	vic.raster = 255;
+
+}
+
+void rirq_init_kernal_noio(void)
+{
+	rirq_init_tables();
+
+    __asm 
+    {
+        sei
+    }
+
+   	*(void **)0x0314 = rirq_isr_kernal_noio;
+
+	vic.intr_enable = 1;
+	vic.ctrl1 &= 0x7f;
+	vic.raster = 255;
+
+}
+
+void rirq_init_crt(void)
+{
+	rirq_init_tables();
+
+    __asm 
+    {
+        sei
+    }
+
+   	*(void **)0x0314 = rirq_isr_io.kentry;
+   	*(void **)0xfffe = rirq_isr_io;
+
+	vic.intr_enable = 1;
+	vic.ctrl1 &= 0x7f;
+	vic.raster = 255;
+
+}
+
+void rirq_init_crt_noio(void)
+{
+	rirq_init_tables();
+
+    __asm 
+    {
+        sei
+    }
+
+   	*(void **)0x0314 = rirq_isr_noio.kentry;
+   	*(void **)0xfffe = rirq_isr_noio;
 
 	vic.intr_enable = 1;
 	vic.ctrl1 &= 0x7f;
@@ -394,19 +563,14 @@ void rirq_init_kernal(void)
 
 void rirq_init_io(void)
 {
-	for(byte i=0; i<NUM_IRQS; i++)
+	rirq_init_tables();
-	{
-		rasterIRQRows[i] = 255;
-		rasterIRQIndex[i] = i;
-	}
-	rasterIRQNext[NUM_IRQS] = 255;
 
     __asm 
     {
         sei
     }
 
-   	*(void **)0xfffe = irq0;
+   	*(void **)0xfffe = rirq_isr_ram_io;
 
 	vic.intr_enable = 1;
 	vic.ctrl1 &= 0x7f;
@@ -416,19 +580,14 @@ void rirq_init_io(void)
 
 void rirq_init_memmap(void)
 {
-	for(byte i=0; i<NUM_IRQS; i++)
+	rirq_init_tables();
-	{
-		rasterIRQRows[i] = 255;
-		rasterIRQIndex[i] = i;
-	}
-	rasterIRQNext[NUM_IRQS] = 255;
 
     __asm 
     {
         sei
     }
 
-   	*(void **)0xfffe = irq2;
+   	*(void **)0xfffe = rirq_isr_noio;
 
 	vic.intr_enable = 1;
 	vic.ctrl1 &= 0x7f;
@@ -446,12 +605,39 @@ void rirq_init(bool kernalIRQ)
 
 void rirq_wait(void)
 {
-	while (tpos != npos) ;
+	char i0 = rirq_pcount;
-	npos++;
+	char i1;
+	do {
+		i1 = rirq_count;
+	} while (i0 == i1);
+	rirq_pcount = i1;
 }
 
-void rirq_sort(void)
+void rirq_sort(bool inirq)
 {
+	// disable raster interrupts while sorting
+	nextIRQ = 0xff;
+#if 1
+	byte maxr = rasterIRQRows[rasterIRQIndex[1]];
+	for(byte i = 2; i<NUM_IRQS + 1; i++)
+	{
+		byte ri = rasterIRQIndex[i];
+		byte rr = rasterIRQRows[ri];
+		if (rr < maxr)
+		{
+			rasterIRQIndex[i] = rasterIRQIndex[i - 1];
+			byte j = i, rj;
+			while (rr < rasterIRQRows[(rj = rasterIRQIndex[j - 2])])
+			{
+				rasterIRQIndex[j - 1] = rj;
+				j--;
+			}
+			rasterIRQIndex[j - 1] = ri;
+		}
+		else
+			maxr = rr;
+	}
+#else
 	for(byte i = 1; i<NUM_IRQS; i++)
 	{
 		byte ri = rasterIRQIndex[i];
@@ -464,14 +650,32 @@ void rirq_sort(void)
 		}
 		rasterIRQIndex[j] = ri;
 	}
+#endif
 
-	for(byte i=0; i<NUM_IRQS; i++)
+#if NUM_IRQS & 3
-		rasterIRQNext[i] = rasterIRQRows[rasterIRQIndex[i]];
+	for(sbyte i=NUM_IRQS-1; i>=0; i--)
+		rasterIRQNext[i] = rasterIRQRows[rasterIRQIndex[i + 1]];
+#else
+	for(sbyte i=NUM_IRQS/4-1; i>=0; i--)
+	{
+		#pragma unroll(full)
+		for(int j=0; j<4; j++)
+			rasterIRQNext[i + j * NUM_IRQS / 4] = rasterIRQRows[rasterIRQIndex[i + j * NUM_IRQS / 4 + 1]];
+	}
+#endif
 
-	npos++;
+	rirq_pcount = rirq_count;
-	byte	yp = rasterIRQNext[nextIRQ];
+	if (inirq)
-	if (yp != 0xff)
+		nextIRQ = NUM_IRQS - 1;
-		vic.raster = yp - 1;
+	else
+	{
+		byte	yp = rasterIRQNext[0];
+		if (yp != 0xff)
+		{
+			vic.raster = yp - 1;
+			nextIRQ = 0;
+		}
+	}
 }
 
 void rirq_start(void)
@@ -485,6 +689,7 @@ void rirq_start(void)
         lda #100
         sta $d012
 
+        asl $d019
         cli
     }
 }

include/c64/rasterirq.h

@@ -123,13 +123,17 @@ inline void rirq_call(RIRQCode * ic, byte n, void * addr);
 // Change the address of a raster IRQ write command
 inline void rirq_addr(RIRQCode * ic, byte n, void * addr);
 
+// Change the high byte of the address of a raster IRQ write command
+inline void rirq_addrhi(RIRQCode * ic, byte n, byte hi);
+
 // Change the data of a raster IRQ write command
 inline void rirq_data(RIRQCode * ic, byte n, byte data);
 
 // Add a delay of 5 * cycles to a raster IRQ
 inline void rirq_delay(RIRQCode * ic, byte cycles);
 
-// Place a raster IRQ into one of the 16 slots
+// Place a raster IRQ into one of the 16 slots, the interrupt will fire
+// one line below the given row
 inline void rirq_set(byte n, byte row, RIRQCode * write);
 
 // Remove a raster IRQ from one of the 16 slots
@@ -144,10 +148,28 @@ inline void rirq_move(byte n, byte row);
 // the less resource hungry option)
 inline void rirq_init(bool kernalIRQ);
 
+// Raster IRQ through kernal, with IO range always enabled
+// calls kernal continuation
 void rirq_init_kernal(void);
 
+// Raster IRQ through kernal, with IO range not always enabled
+// calls kernal continuation
+void rirq_init_kernal_noio(void);
+
+// Raster IRQ through RAM and ROM vector, with ROM disabled or not and IO range always enabled
+// does not call kernal continuation
+void rirq_init_crt(void);
+
+// Raster IRQ through RAM and ROM vector, with ROM disabled or not and IO range not always enabled
+// does not call kernal continuation
+void rirq_init_crt_noio(void);
+
+// Raster IRQ through RAM vector, with ROM disabled and IO range always enabled
+// does not call kernal continuation
 void rirq_init_io(void);
 
+// Raster IRQ through RAM vector, with ROM disabled and IO range not always enabled
+// does not call kernal continuation
 void rirq_init_memmap(void);
 
 // Start raster IRQ
@@ -157,8 +179,9 @@ void rirq_start(void);
 void rirq_stop(void);
 
 // Sort the raster IRQ, must be performed at the end of the frame after changing 
-// the vertical position of one of the interrupt operatins.
+// the vertical position of one of the interrupt operations.
-void rirq_sort(void);
+// Set the inirq flag to true when calling this from an interrupt
+void rirq_sort(bool inirq = false);
 
 // Wait for the last raster IRQ op to have completed.  Must be called before a
 // sort if the raster IRQ system is active

include/c64/sprites.c

@@ -1,8 +1,11 @@
 #include "sprites.h"
 #include "rasterirq.h"
 
-static char * vspriteScreen;
+static volatile char * vspriteScreen;
 
+#ifdef VSPRITE_BSS
+#pragma bss(VSPRITE_BSS)
+#endif
 
 void spr_init(char * screen)
 {
@@ -108,6 +111,22 @@ void spr_color(char sp, char color)
 	vic.spr_color[sp] = color;
 }
 
+void spr_expand(char sp, bool xexpand, bool yexpand)
+{
+	__assume (sp < 8);
+
+	char	m = 1 << sp;
+
+	if (xexpand)
+		vic.spr_expand_x |= m;
+	else
+		vic.spr_expand_x &= ~m;
+
+	if (yexpand)
+		vic.spr_expand_y |= m;
+	else
+		vic.spr_expand_y &= ~m;
+}
 
 static char	vspriteYLow[VSPRITES_MAX], vspriteXLow[VSPRITES_MAX], vspriteXHigh[VSPRITES_MAX];
 static char	vspriteImage[VSPRITES_MAX], vspriteColor[VSPRITES_MAX];
@@ -127,7 +146,11 @@ void vspr_init(char * screen)
 
 	for(int i=0; i<VSPRITES_MAX - 8; i++)
 	{
+#ifdef VSPRITE_REVERSE
+		int j = (i & 7) ^ 7;
+#else
 		int j = i & 7;
+#endif
 
 		rirq_build(spirq + i, 5);
 		rirq_write(spirq + i, 0, &vic.spr_color[j], 0);
@@ -148,6 +171,21 @@ void vspr_init(char * screen)
 	}
 }
 
+void vspr_shutdown(void)
+{
+	for(int i=0; i<VSPRITES_MAX - 7; i++)
+		rirq_clear(i);
+}
+
+void vspr_screen(char * screen)
+{	
+	vspriteScreen = screen + 0x3f8;	
+	char hi = (unsigned)vspriteScreen >> 8;
+	#pragma unroll(8)
+	for(int i=0; i<VSPRITES_MAX - 8; i++)
+		rirq_addrhi(spirq + i, 3, hi);
+}
+
 #pragma native(vspr_init)
 
 void vspr_set(char sp, int xpos, int ypos, char image, char color)
@@ -176,6 +214,21 @@ void vspr_move(char sp, int xpos, int ypos)
 	vspriteXHigh[sp] = (char)(xpos >> 8);
 }
 
+void vspr_movex(char sp, int xpos)
+{
+	vspriteXLow[sp] = (char)xpos;
+	vspriteXHigh[sp] = (char)(xpos >> 8);
+}
+
+void vspr_movey(char sp, int ypos)
+{
+	char	yp = (char)ypos;
+	if (ypos & 0xff00)
+		yp = 0xff;
+
+	vspriteYLow[sp] = yp;
+}
+
 void vspr_image(char sp, char image)
 {
 	vspriteImage[sp] = image;
@@ -193,22 +246,30 @@ void vspr_hide(char sp)
 
 void vspr_sort(void)
 {
-	spriteYPos[1] = vspriteYLow[spriteOrder[0]];
+	byte rm = vspriteYLow[spriteOrder[0]];
+	spriteYPos[1] = rm;
 
 	for(char i = 1; i<VSPRITES_MAX; i++)
 	{
 		byte ri = spriteOrder[i];
 		byte rr = vspriteYLow[ri];
-		byte j = i, rj = spriteYPos[j];
+		if (rr < rm)
-		while (rr < rj)
 		{
-			spriteYPos[j + 1] = rj;
+			byte j = i, rj = rm;
-			spriteOrder[j] = spriteOrder[j - 1];
+			do 	{
-			rj = spriteYPos[j - 1];
+				spriteYPos[j + 1] = rj;
-			j--;
+				spriteOrder[j] = spriteOrder[j - 1];
+				rj = spriteYPos[j - 1];
+				j--;
+			} while (rr < rj);
+			spriteOrder[j] = ri;
+			spriteYPos[j + 1] = rr;
+		}
+		else
+		{
+			spriteYPos[i + 1] = rr;
+			rm = rr;
 		}
-		spriteOrder[j] = ri;
-		spriteYPos[j + 1] = rr;
 	}
 }
 
@@ -217,45 +278,68 @@ void vspr_sort(void)
 void vspr_update(void)
 {
 	char	xymask = 0;
-	char	*	vsprs = vspriteScreen;
+	volatile char	*	vsprs = vspriteScreen;
+//	char	sypos[VSPRITES_MAX];
 
 #pragma unroll(full)
+
 	for(char ui=0; ui<8; ui++)
 	{
 		byte ri = spriteOrder[ui];		
+#ifdef VSPRITE_REVERSE
+		char uj = ui ^ 7;
+#else
+		char uj = ui;
+#endif
 
-		vic.spr_color[ui] = vspriteColor[ri];
+		vic.spr_color[uj] = vspriteColor[ri];
-		vsprs[ui] = vspriteImage[ri];
+		vsprs[uj] = vspriteImage[ri];
+#ifdef VSPRITE_REVERSE
+		xymask = (xymask << 1) | (vspriteXHigh[ri] & 1);
+#else
 		xymask = ((unsigned)xymask | (vspriteXHigh[ri] << 8)) >> 1;
-		vic.spr_pos[ui].x = vspriteXLow[ri];
+#endif
-		vic.spr_pos[ui].y = vspriteYLow[ri];
+		vic.spr_pos[uj].x = vspriteXLow[ri];
+		vic.spr_pos[uj].y = spriteYPos[ui + 1];
+
+//		sypos[ui] = vspriteYLow[ri];
 	}
 
 	vic.spr_msbx = xymask;
 
 #pragma unroll(full)
+	bool	done = false;
+
 	for(char ti=0; ti<VSPRITES_MAX - 8; ti++)
 	{
-		if (spriteYPos[ti + 8] < 250)
+		if (!done && spriteYPos[ti + 9] < 250)
 		{
-			char	m = 1 << (ti & 7);
-
 			byte ri = spriteOrder[ti + 8];
+			rirq_move(ti, spriteYPos[ti + 1] + 23);
+
+#ifdef VSPRITE_REVERSE
+			char	m = 0x80 >> (ti & 7);
+#else
+			char	m = 1 << (ti & 7);
+#endif
 
 			xymask |= m;
-			if (!vspriteXHigh[ri])
+			if (!(vspriteXHigh[ri] & 1))
 				xymask ^= m;
 
+			rirq_data(spirq + ti, 2, spriteYPos[ti + 9]);
 			rirq_data(spirq + ti, 0, vspriteColor[ri]);
 			rirq_data(spirq + ti, 1, vspriteXLow[ri]);
-			rirq_data(spirq + ti, 2, vspriteYLow[ri]);
 			rirq_data(spirq + ti, 3, vspriteImage[ri]);
 
 			rirq_data(spirq + ti, 4, xymask);
-			rirq_move(ti, spriteYPos[ti + 1] + 23);
+//			spriteYPos[ti + 9] = vspriteYLow[ri];
 		}
 		else
+		{
 			rirq_clear(ti);
+			done = true;
+		}
 	}
 }
 

include/c64/sprites.h

@@ -39,6 +39,10 @@ inline void spr_image(char sp, char image);
 
 inline void spr_color(char sp, char color);
 
+// change the image of a sprite
+
+inline void spr_expand(char sp, bool xexpand, bool yexpand);
+
 // The virtual sprite system works with the rasterirq library to multiplex
 // 16 virtual sprites onto the actual eight hardware sprites.  It uses the slots
 // 0 to 8 of the rasterirq library to switch the sprites mid screen.  The
@@ -64,6 +68,10 @@ inline void spr_color(char sp, char color);
 
 void vspr_init(char * screen);
 
+void vspr_shutdown(void);
+
+void vspr_screen(char * screen);
+
 // set one sprite with the given attribute
 
 void vspr_set(char sp, int xpos, int ypos, char image, char color);
@@ -72,6 +80,11 @@ void vspr_set(char sp, int xpos, int ypos, char image, char color);
 
 inline void vspr_move(char sp, int xpos, int ypos);
 
+inline void vspr_movex(char sp, int xpos);
+
+inline void vspr_movey(char sp, int ypos);
+
+
 // change the image of a virtual sprite
 
 inline void vspr_image(char sp, char image);

include/c64/vic.c

@@ -21,7 +21,7 @@ int vic_sprgetx(byte s)
 	return vic.spr_pos[s].x | ((vic.spr_msbx & (1 << s)) ? 256 : 0);
 }
 
-void vic_setmode(VicMode mode, char * text, char * font)
+void vic_setmode(VicMode mode, const char * text, const char * font)
 {
 	switch (mode)
 	{
@@ -73,6 +73,15 @@ void vic_waitFrame(void)
 		;	
 }
 
+void vic_waitFrames(char n)
+{
+	while (n > 0)
+	{
+		vic_waitFrame();
+		n--;
+	}
+}
+
 void vic_waitLine(int line)
 {
 	char	upper = (char)(line >> 1) & VIC_CTRL1_RST8;
@@ -85,4 +94,41 @@ void vic_waitLine(int line)
 	} while ((vic.ctrl1 & VIC_CTRL1_RST8) != upper);
 }
 
+void vic_waitBelow(int line)
+{
+	char	upper = (char)(line >> 1) & VIC_CTRL1_RST8;
+	char	lower = (char)line;
+
+	if (upper)
+	{
+		do
+		{
+			while (vic.raster <= lower)
+				;
+		} while (!(vic.ctrl1 & VIC_CTRL1_RST8));
+	}
+	else
+	{
+		while (vic.raster <= lower)
+			;
+	}
+}
+
+void vic_waitRange(char below, char above)
+{
+	while (vic.ctrl1 & VIC_CTRL1_RST8)
+		;
+
+	if (vic.raster >= above)
+	{
+		while (!(vic.ctrl1 & VIC_CTRL1_RST8))					
+			;
+		while (vic.ctrl1 & VIC_CTRL1_RST8)
+			;
+	}
+
+	while (vic.raster < below)
+		;
+}
+
 #pragma native(vic_waitLine)

include/c64/vic.h

@@ -91,7 +91,7 @@ enum VicMode
 
 // set the display mode and base address. This will also
 // adapt the bank.
-void vic_setmode(VicMode mode, char * text, char * font);
+void vic_setmode(VicMode mode, const char * text, const char * font);
 
 // put a sprite at the given x/y location, taking care of the
 // x MSB
@@ -109,9 +109,18 @@ inline void vic_waitTop(void);
 // wait for the top of the frame and then for the bottom of the visual area
 inline void vic_waitFrame(void);
 
+// wait for n frames
+void vic_waitFrames(char n);
+
 // wait for a specific raster line
 void vic_waitLine(int line);
 
+// wait for beam to be below a line
+void vic_waitBelow(int line);
+
+// wait for beam to be in a given range on screen
+void vic_waitRange(char below, char above);
+
 // reference to the VIC chip
 #define vic	(*((struct VIC *)0xd000))
 

include/conio.c

@@ -18,6 +18,13 @@ __asm bsin
 		jsr 0xffe4
 		sta 0xff01	
 }
+__asm bsget
+{
+		lda #0
+		sta 0xff00
+		jsr 0xffcf
+		sta 0xff01		
+}
 __asm bsplot
 {	
 		lda #0
@@ -39,6 +46,13 @@ __asm dswap
 		sta 0xff01
 }
 #pragma code(code)
+#elif defined(__C128B__) || defined(__C128E__)
+#define dswap 	0xff5f
+#define bsout	0xffd2
+#define bsin	0xffe4
+#define bsget	0xffcf
+#define bsplot	0xfff0
+#define bsinit	0xff81
 #elif defined(__PLUS4__)
 #pragma code(lowcode)
 __asm bsout
@@ -53,6 +67,12 @@ __asm bsin
 		jsr 0xffe4
 		sta 0xff3f
 }
+__asm bsget
+{
+		sta 0xff3e
+		jsr 0xffcf
+		sta 0xff3f
+}
 __asm bsplot
 {	
 		sta 0xff3e
@@ -85,6 +105,14 @@ __asm bsin
 		pha
 }
 
+__asm bsget
+{
+		lda	0xe405
+		pha
+		lda 0xe404
+		pha
+}
+
 __asm bsplot
 {
 
@@ -93,14 +121,37 @@ __asm bsinit
 {
 
 }
+#elif defined(__VIC20__)
+#define bsout	0xffd2
+#define bsin	0xffe4
+#define bsplot	0xfff0
+#define bsget	0xffcf
+__asm bsinit
+{
+	lda #147
+	jmp $ffd2	
+}
+#elif defined(__CBMPET__)
+#define bsout	0xffd2
+#define bsin	0xffe4
+__asm bsplot
+{
+    /* no equivalent on PET */
+}
+__asm bsinit
+{
+    /* no equivalent on PET */
+}
+#define bsget	0xffcf
 #else
 #define bsout	0xffd2
 #define bsin	0xffe4
 #define bsplot	0xfff0
 #define bsinit	0xff81
+#define bsget	0xffcf
 #endif
 
-#if defined(__C128__)
+#if defined(__C128__) || defined(__C128B__) || defined(__C128E__)
 void dispmode40col(void)
 {
 	if (*(volatile char *)0xd7 >= 128)
@@ -130,168 +181,195 @@ void iocharmap(IOCharMap chmap)
 	giocharmap = chmap;	
 #if !defined(__ATARI__)
 	if (chmap == IOCHM_PETSCII_1)
-		putch(128 + 14);
+		putrch(128 + 14);
 	else if (chmap == IOCHM_PETSCII_2)
-		putch(14);
+		putrch(14);
 #endif
 }
 
-__asm putpch
+void putrch(char c)
 {
-		ldx	giocharmap
+	__asm {
-		cpx	#IOCHM_ASCII
+		lda 	c
-		bcc	w3
+		jsr		bsout
-
+	}
-		cmp #10
+}
-		bne	w1
-		lda #13
-	w1:
-		cpx	#IOCHM_PETSCII_1
-		bcc	w3
-
-		cmp #65
-		bcc w3
-		cmp	#123
-		bcs	w3
-
-#if defined(__CBMPET__)
-		cmp	#97
-		bcs	w4
-		cmp #91
-		bcs	w3
-	w2:
-		eor	#$a0
-	w4:
-		eor #$20
 
+void putpch(char c)
+{
+#if defined(__ATARI__)
+	if (c == 10)
+		c = 0x9b;
 #else
-		cmp	#97
+	if (giocharmap >= IOCHM_ASCII)
-		bcs	w2
+	{
-		cmp #91
+		if (c == '\n')
-		bcs	w3
+			c = 13;
-	w2:
+		else if (c == '\t')
-		eor	#$20
+		{
+			char n = wherex() & 3;
+			do {
+				putrch(' ');
+			} while (++n < 4);
+			return;
+		}
+		else if (giocharmap >= IOCHM_PETSCII_1)
+		{
+			if (c >= 65 && c < 123)
+			{
+				if (c >= 97 || c < 91)
+				{
+#if defined(__CBMPET__)
+					if (c >= 97)
+						c ^= 0xa0;
+					c ^= 0x20;
+#else
+					c ^= 0x20;
 #endif				
-		cpx #IOCHM_PETSCII_2
+
-		beq	w3
+					if (giocharmap == IOCHM_PETSCII_1)
-		and #$df
+						c &= 0xdf;
-	w3:
+				}
-		jmp	bsout	
+			}
+		}
+	}
+
+#endif
+
+	putrch(c);
 }
 
-__asm getpch
+static char convch(char ch)
 {
-		jsr	bsin
+#if !defined(__ATARI__)
 
-		ldx	giocharmap
+	if (giocharmap >= IOCHM_ASCII)
-		cpx	#IOCHM_ASCII
+	{
-		bcc	w3
+		if (ch == 13)
+			ch = 10;
+		else if (giocharmap >= IOCHM_PETSCII_1)
+		{
+			if (ch >= 65 && ch < 219)
+			{
+				if (ch >= 193)
+					ch ^= 0xa0;
+				if (ch < 123 && (ch >= 97 || ch < 91))
+					ch ^= 0x20;
+			}
+		}
+	}
 
-		cmp	#13
+#endif
-		bne	w1
+	return ch;	
-		lda #10
+}
-	w1:
-		cpx	#IOCHM_PETSCII_1
-		bcc	w3
 
-		cmp #219
+char getrch(void)
-		bcs w3
+{
-		cmp #65
+	return __asm {
-		bcc w3
+		jsr bsget
+		sta accu
+	};
+}
 
-		cmp #193
+char getpch(void)
-		bcc w4
+{
-		eor #$a0
+	return convch(getrch());
-	w4:
-		cmp	#123
-		bcs	w3
-		cmp	#97
-		bcs	w2
-		cmp #91
-		bcs	w3
-	w2:
-		eor	#$20
-	w3:
 }
 
 
-int kbhit(void)
+char kbhit(void)
 {
-	__asm
+#if defined(__CBMPET__)
+	return __asm
+	{
+		lda $9e
+		sta	accu
+	};
+#else
+	return __asm
 	{
 		lda $c6
 		sta	accu
-		lda	#0
+	};
-		sta	accu + 1		
+#endif
-	}
 }
 
-int getche(void)
+char getche(void)
 {
-	__asm
+	char ch;
-	{
+	do {
-	L1:
+		ch = __asm {
-		jsr	getpch
+			jsr	bsin
-		cmp	#0
+			sta accu
-		beq	L1
+		};		
+	} while (!ch);
 
-		sta	accu
-		jsr putpch
-		lda	#0
-		sta	accu + 1		
-	}
-
-}
-
-int getch(void)
-{
-	__asm
-	{
-	L1:
-		jsr	getpch
-		cmp	#0
-		beq	L1
-
-		sta	accu
-		lda	#0
-		sta	accu + 1		
-	}
-}
-
-int getchx(void)
-{
-	__asm
-	{
-		jsr	getpch
-		sta	accu
-		lda	#0
-		sta	accu + 1		
-	}
-}
-
-void putch(int c)
-{
 	__asm {
-		lda	c
+		lda ch
 		jsr	bsout
 	}
+
+	return convch(ch);
+}
+
+char getch(void)
+{
+	char ch;
+	do {
+		ch = __asm {
+			jsr	bsin
+			sta accu
+		};
+	} while (!ch);
+
+	return convch(ch);
+}
+
+char getchx(void)
+{
+	char ch = __asm {
+		jsr	bsin
+		sta accu
+	};
+
+	return convch(ch);
+}
+
+void putch(char c)
+{
+	putpch(c);
 }
 
 void clrscr(void)
 {
-	__asm
+	putrch(147);
-	{
-		jsr	bsinit
-	}
 }
 
 void textcursor(bool show)
 {
-	*(char *)0xcc = show ? 0 : 1;
+	*(volatile char *)0xcc = show ? 0 : 1;
 }
 
-void gotoxy(int cx, int cy)
+void gotoxy(char cx, char cy)
 {
+#if defined(__CBMPET__)
+#define CURS_X 0xc6
+#define CURS_Y 0xd8
+#define SCREEN_PTR 0xc4
+#define SCR_LINELEN 0xd5
+
+	__assume(cy < 25);
+
+	*(volatile char *)CURS_X = cx;
+	*(volatile char *)CURS_Y = cy;
+
+	if (*(volatile char *)SCR_LINELEN > 40)
+		cy <<= 1;
+
+	const unsigned	off = cy * 40;
+
+	* (volatile unsigned *)SCREEN_PTR = off + 0x8000;
+#else
 	__asm
 	{
 		ldx	cy
@@ -299,35 +377,50 @@ void gotoxy(int cx, int cy)
 		clc
 		jsr bsplot
 	}
+#endif
 }
 
-void textcolor(int c)
+void textcolor(char c)
 {
-	__asm
+	*(volatile char *)0x0286 = c;
-	{
-		lda	c
-		sta $0286
-	}
 }
 
-int wherex(void)
+void bgcolor(char c)
 {
-	__asm
+	*(volatile char *)0xd021 = c;
-	{
-		lda $d3
-		sta	accu
-		lda	#0
-		sta	accu + 1		
-	}
 }
 
-int wherey(void)
+void bordercolor(char c)
 {
-	__asm
+	*(volatile char *)0xd020 = c;
-	{
+}
-		lda $d6
+
-		sta	accu
+void revers(char r)
-		lda	#0
+{
-		sta	accu + 1		
+	if (r) 
-	}
+		putrch(18);
+	else
+		putrch(18 + 128);
+}
+
+char wherex(void)
+{
+#if defined(__C128__) || defined(__C128B__) || defined(__C128E__)
+	return *(volatile char *)0xec;
+#elif defined(__PLUS4__)
+	return *(volatile char *)0xca;	
+#else
+	return *(volatile char *)0xd3;
+#endif
+}
+
+char wherey(void)
+{
+#if defined(__C128__) || defined(__C128B__) || defined(__C128E__)
+	return *(volatile char *)0xeb;
+#elif defined(__PLUS4__)
+	return *(volatile char *)0xcd;	
+#else
+	return *(volatile char *)0xd6;
+#endif
 }

include/conio.h

@@ -18,36 +18,95 @@ extern IOCharMap	giocharmap;
 
 void iocharmap(IOCharMap chmap);
 
-#if defined(__C128__)
+#if defined(__C128__) || defined(__C128B__) || defined(__C128E__)
 void dispmode40col(void);
 void dispmode80col(void);
 #endif
 
-int kbhit(void);
+#define PETSCII_CURSOR_LEFT		0x9d
+#define PETSCII_CURSOR_RIGHT	0x1d
+#define PETSCII_CURSOR_UP		0x91
+#define PETSCII_CURSOR_DOWN		0x11
+#define PETSCII_HOME			0x13
+#define PETSCII_CLEAR			0x94
+#define PETSCII_DEL				0x14
+#define PETSCII_INSERT			0x94
+#define PETSCII_STOP			0x03
+#define PETSCII_RETURN			0x0d
 
-int getche(void);
+#define PETSCII_F1				0x85
+#define PETSCII_F2				0x89
+#define PETSCII_F3				0x86
+#define PETSCII_F4				0x8a
+#define PETSCII_F5				0x87
+#define PETSCII_F6				0x8b
+#define PETSCII_F7				0x88
+#define PETSCII_F8				0x8c
 
-int getch(void);
+enum ConioColors
+{
+	COLOR_BLACK,
+	COLOR_WHITE,
+	COLOR_RED,
+	COLOR_CYAN,
+	COLOR_PURPLE,
+	COLOR_GREEN,
+	COLOR_BLUE,
+	COLOR_YELLOW,
+
+	COLOR_ORANGE,
+	COLOR_BROWN,
+	COLOR_LT_RED,
+	COLOR_DARK_GREY,
+	COLOR_MED_GREY,
+	COLOR_LT_GREEN,
+	COLOR_LT_BLUE,
+	COLOR_LT_GREY
+};
+// Lowlevel console in/out
+
+// using petscii translation
+void putpch(char c);
+char getpch(void);
+
+// using no translation
+inline void putrch(char c);
+inline char getrch(void);
+
+
+// Standard console in/out
+
+char kbhit(void);
+
+char getche(void);
+
+char getch(void);
 
 // like getch but does not wait, returns zero if no
 // key is pressed
-int getchx(void);
+char getchx(void);
 
-void putch(int c);
+void putch(char c);
 
 void clrscr(void);
 
-void gotoxy(int x, int y);
+void gotoxy(char x, char y);
 
-void textcolor(int c);
+inline void textcolor(char c);
 
-int wherex(void);
+inline void bgcolor(char c);
 
-int wherey(void);
+inline void bordercolor(char c);
+
+inline void revers(char r);
+
+inline char wherex(void);
+
+inline char wherey(void);
 
 // show or hide the text cursor
 
-void textcursor(bool show);
+inline void textcursor(bool show);
 
 #pragma compile("conio.c")
 

include/crt.h

@@ -144,8 +144,8 @@ enum ByteCode
 	BC_LOOP_U8,
 	BC_MALLOC,
 	BC_FREE,
-	BC_UNUSED_4,
+	BC_FILL,
-	BC_UNUSED_5,
+	BC_FILL_LONG,
 	BC_UNUSED_6,
 
 	BC_JSR,
@@ -186,6 +186,11 @@ enum ByteCode
 	BC_BINOP_SHR_I32,
 	BC_BINOP_CMP_U32,
 	BC_BINOP_CMP_S32,
+
+	BC_CONV_U32_F32,
+	BC_CONV_I32_F32,
+	BC_CONV_F32_U32,
+	BC_CONV_F32_I32,
 };
 
 #endif

include/ctype.c

@@ -1,4 +1,5 @@
 #include "ctype.h"
+#include "conio.h"
 
 #define CC_CTRL		0x00
 #define CC_BREAK	0x01
@@ -86,3 +87,19 @@ bool isxdigit(char c)
 {
 	return (c < 128) && (_cinfo[c] & CC_HEX);
 }
+
+char tolower(char c)
+{
+	if (c >= 'A' && c <= 'Z')
+		return c + ('a' - 'A');
+	else
+		return c;
+}
+
+char toupper(char c)
+{
+	if (c >= 'a' && c <= 'z')
+		return c + ('A' - 'a');
+	else
+		return c;
+}

include/ctype.h

@@ -25,6 +25,9 @@ inline bool isdigit(char c);
 
 inline bool isxdigit(char c);
 
+char tolower(char c);
+
+char toupper(char c);
 
 #pragma compile("ctype.c")
 

include/fixmath.c

@@ -116,31 +116,38 @@ int lmul4f12s(int x, int y)
 {
 	__asm
 	{
-		bit y + 1
-		bpl W0
-
 		sec
-		lda #0
+		lda x
-		sbc y
+		ror
-		sta y
+		sta accu
-		lda #0
-		sbc y + 1
-		sta y + 1
 
-		sec
-		lda #0
-		sbc x
-		sta x
-		lda #0
-		sbc x + 1
-		sta x + 1
-W0:
-		ldx	#15
 		lda #0
 		sta	accu + 1
 
-L1:		lsr	x + 1
+		bcc	W4
-		ror	x
+L2:		
+		tay
+		clc
+		lda	accu + 1
+		adc	y
+		sta accu + 1
+		tya
+		adc y + 1
+W4:
+		ror
+		ror accu + 1
+		
+		lsr accu
+		bcc W4
+		bne	L2
+
+		ldx x + 1
+		stx accu
+
+		ldx	#7
+		lsr	accu
+
+L1:		
 		bcc	W1
 		tay
 		clc
@@ -156,23 +163,31 @@ W1:
 		dex
 		bne	L1
 
-		lsr x
 		bcc W2
 
 		tay
-		sec
+//		sec 		; we know it is set here
 		lda accu + 1
 		sbc y
 		sta accu + 1
 		tya
 		sbc y + 1
-
-		sec
 W2:
 		ror
 		ror accu + 1
 		ror accu
 
+		bit y + 1
+		bpl W3
+
+		tax
+		sec
+		lda accu + 1
+		sbc x
+		sta accu + 1
+		txa
+		sbc x + 1
+W3:
 		lsr
 		ror accu + 1
 		ror accu
@@ -270,15 +285,17 @@ unsigned lmuldiv16u(unsigned a, unsigned b, unsigned c)
 	__asm
 	{
 			lda	#0
-			sta	__tmp + 0
-			sta	__tmp + 1
 			sta	__tmp + 2
 			sta	__tmp + 3
 
-			ldx	#16
+			lda a
-	L1:		lsr	a + 1
+			sec
-			ror	a
+	T1:
+			ldy #8
+	L1:		
+			ror
 			bcc	W1
+			tax
 			clc
 			lda	__tmp + 2
 			adc	b
@@ -286,20 +303,38 @@ unsigned lmuldiv16u(unsigned a, unsigned b, unsigned c)
 			lda	__tmp + 3
 			adc b + 1
 			sta	__tmp + 3
+			txa
 	W1:
 			ror __tmp + 3
 			ror __tmp + 2
-			ror __tmp + 1
+			dey
-			ror __tmp
-			dex
 			bne	L1
+			ror
+			bcc T2
 
-			lda	#0
+			sta __tmp + 0
-			sta accu
+			lda a + 1
-			sta accu + 1
+			clc
+			bcc T1
 
-			ldx #17
+	T2:
+			sec
+	L3:
+			sta __tmp + 1
+			ldx #8
 	L2:
+			rol __tmp + 1
+			rol __tmp + 2
+			rol __tmp + 3
+			bcc W3
+			lda __tmp + 2
+			sbc c
+			tay
+			lda __tmp + 3
+			sbc c + 1			
+			sec
+			bcs W4
+	W3:
 			sec
 			lda __tmp + 2
 			sbc c
@@ -307,33 +342,23 @@ unsigned lmuldiv16u(unsigned a, unsigned b, unsigned c)
 			lda __tmp + 3
 			sbc c + 1
 			bcc	W2
+	W4:
 			sta __tmp + 3
 			sty __tmp + 2
 	W2:
-			rol accu
-			rol accu + 1
-
-			asl __tmp
-			rol __tmp + 1
-			rol __tmp + 2
-			rol __tmp + 3
-
 			dex
-			beq E2
+			bne L2
-			bcc L2
+			lda __tmp + 1
-
+			rol
-			lda __tmp + 2
+			bcc T3
-			sbc c
-			sta __tmp + 2
-			lda __tmp + 3
-			sbc c + 1
-			sta __tmp + 3
-			sec
-			bcs W2
-	E2:
 
+			sta accu + 1
+			lda __tmp + 0
+			clc
+			bcc L3
+	T3:
+			sta accu
 	}
-
 }
 
 int lmuldiv16s(int a, int b, int c)
@@ -358,15 +383,17 @@ int lmuldiv16s(int a, int b, int c)
 	__asm
 	{
 			lda	#0
-			sta	__tmp + 0
-			sta	__tmp + 1
 			sta	__tmp + 2
 			sta	__tmp + 3
 
-			ldx	#16
+			lda a
-	L1:		lsr	a + 1
+			sec
-			ror	a
+	T1:
+			ldy #8
+	L1:		
+			ror
 			bcc	W1
+			tax
 			clc
 			lda	__tmp + 2
 			adc	b
@@ -374,20 +401,38 @@ int lmuldiv16s(int a, int b, int c)
 			lda	__tmp + 3
 			adc b + 1
 			sta	__tmp + 3
+			txa
 	W1:
 			ror __tmp + 3
 			ror __tmp + 2
-			ror __tmp + 1
+			dey
-			ror __tmp
-			dex
 			bne	L1
+			ror
+			bcc T2
 
-			lda	#0
+			sta __tmp + 0
-			sta accu
+			lda a + 1
-			sta accu + 1
+			clc
+			bcc T1
 
-			ldx #17
+	T2:
+			sec
+	L3:
+			sta __tmp + 1
+			ldx #8
 	L2:
+			rol __tmp + 1
+			rol __tmp + 2
+			rol __tmp + 3
+			bcc W3
+			lda __tmp + 2
+			sbc c
+			tay
+			lda __tmp + 3
+			sbc c + 1			
+			sec
+			bcs W4
+	W3:
 			sec
 			lda __tmp + 2
 			sbc c
@@ -395,30 +440,23 @@ int lmuldiv16s(int a, int b, int c)
 			lda __tmp + 3
 			sbc c + 1
 			bcc	W2
+	W4:
 			sta __tmp + 3
 			sty __tmp + 2
 	W2:
-			rol accu
-			rol accu + 1
-
-			asl __tmp
-			rol __tmp + 1
-			rol __tmp + 2
-			rol __tmp + 3
-
 			dex
-			beq E2
+			bne L2
-			bcc L2
+			lda __tmp + 1
+			rol
+			bcc T3
+
+			sta accu + 1
+			lda __tmp + 0
+			clc
+			bcc L3
+	T3:
+			sta accu
 
-			lda __tmp + 2
-			sbc c
-			sta __tmp + 2
-			lda __tmp + 3
-			sbc c + 1
-			sta __tmp + 3
-			sec
-			bcs W2
-	E2:
 			lda	sign
 			beq	E1
 
@@ -610,3 +648,264 @@ unsigned usqrt(unsigned n)
 
     return p;
 }
+
+unsigned long lmul16f16(unsigned long x, unsigned long y)
+{
+	unsigned long hh = lmul16u(x >> 16, y >> 16);
+	unsigned long lh = lmul16u(x, y >> 16);
+	unsigned long hl = lmul16u(x >> 16, y);
+	unsigned long ll = lmul16u(x, y);
+
+	if (ll & 0x8000)
+		lh++;
+	ll >>= 16;
+	ll |= hh << 16;
+	ll += lh;
+	ll += hl;
+
+	return ll;
+}
+
+#if 1
+long lmul16f16s(long x, long y)
+{
+	__asm
+	{
+		lda	#0
+		// fractional
+		sta	__tmp + 0
+		sta	__tmp + 1
+
+		// result
+		sta __accu + 0
+		sta __accu + 1
+		sta __accu + 2
+		sta __accu + 3
+
+		lda	x + 0
+		ora x + 1
+		ora y + 0
+		ora y + 1
+		bne	w0b
+
+	l2:
+
+		lsr x + 2
+		bcc ws1
+
+		clc
+		lda y + 2
+		adc __accu + 2
+		sta __accu + 2
+		lda y + 3
+		adc __accu + 3
+		sta __accu + 3
+	ws1:
+
+		lsr x + 3
+		bcc ws2
+
+		clc
+		lda y + 2
+		adc __accu + 3
+		sta __accu + 3
+	ws2:
+
+		asl y + 2
+		rol y + 3
+
+		lda x + 2
+		ora x + 3
+		bne l2 
+		rts
+
+	w0b:
+
+		lda y + 3
+		and #$80
+		beq w0
+		lda #$ff
+	w0:		
+		// overflow
+		sta __tmp + 2
+		sta __tmp + 3
+
+		lda	x + 3
+		bpl w0a
+
+		sec
+		lda #0
+		sbc y + 0
+		sta __accu + 2
+		lda #0
+		sbc y + 1
+		sta __accu + 3
+	w0a:
+
+		ldx	#8
+
+	l1:
+		lsr x + 0
+		bcc w1
+
+		clc
+		lda y + 0
+		adc __tmp + 0
+		sta __tmp + 0
+		lda y + 1
+		adc __tmp + 1
+		sta __tmp + 1
+		lda y + 2
+		adc __accu + 0
+		sta __accu + 0
+		lda y + 3
+		adc __accu + 1
+		sta __accu + 1
+		lda __tmp + 2
+		adc __accu + 2
+		sta __accu + 2
+		lda __tmp + 3
+		adc __accu + 3
+		sta __accu + 3
+	w1:
+
+		lsr x + 1
+		bcc w2
+
+		clc
+		lda y + 0
+		adc __tmp + 1
+		sta __tmp + 1
+		lda y + 1
+		adc __accu + 0
+		sta __accu + 0
+		lda y + 2
+		adc __accu + 1
+		sta __accu + 1
+		lda y + 3
+		adc __accu + 2
+		sta __accu + 2
+		lda __tmp + 2
+		adc __accu + 3
+		sta __accu + 3
+	w2:
+
+		lsr x + 2
+		bcc w3
+
+		clc
+		lda y + 0
+		adc __accu + 0
+		sta __accu + 0
+		lda y + 1
+		adc __accu + 1
+		sta __accu + 1
+		lda y + 2
+		adc __accu + 2
+		sta __accu + 2
+		lda y + 3
+		adc __accu + 3
+		sta __accu + 3
+	w3:
+
+		lsr x + 3
+		bcc w4
+
+		clc
+		lda y + 0
+		adc __accu + 1
+		sta __accu + 1
+		lda y + 1
+		adc __accu + 2
+		sta __accu + 2
+		lda y + 2
+		adc __accu + 3
+		sta __accu + 3
+	w4:
+
+		asl y + 0
+		rol y + 1
+		rol y + 2
+		rol y + 3
+		rol __tmp + 2
+		rol __tmp + 3
+
+		dex
+		beq	w5
+		jmp l1
+	w5:
+	}
+}
+
+#else
+__native long lmul16f16s(long x, long y)
+{
+	unsigned lox = x;
+	int hix = x >> 16;
+	unsigned loy = y;
+	int hiy = y >> 16;
+
+	long	r = (long)(hix * hiy) << 16;
+
+	if (lox)
+	{
+		r += lmul16u(lox, hiy);
+		if (hiy < 0)
+			r -= (unsigned long)lox << 16;
+	}
+	if (loy)
+	{
+		r += lmul16u(loy, hix);
+		if (hix < 0)
+			r -= (unsigned long)loy << 16;
+	}
+	if (lox && loy)
+	{
+		r += lmul16u(lox, loy) >> 16;
+	}
+
+	return r;
+}
+#endif
+
+__native unsigned long ldiv16f16(unsigned long x, unsigned long y)
+{
+	unsigned long k = x >> 16, d = 0;	
+	x <<= 16;
+
+	for(char i=0; i<32; i++)
+	{
+		d <<= 1;
+		k <<= 1;
+		k |= (x >> 31);
+		x <<= 1;
+		if (k >= y)
+		{
+			k -= y;
+			d |= 1;
+		}
+	}
+
+	return d;
+}
+
+__native long ldiv16f16s(long x, long y)
+{
+	bool	sign = false;	
+	if (x < 0)
+	{
+		x = -x;
+		sign = true;
+	}
+	if (y < 0)
+	{
+		y = -y;
+		sign = !sign;
+	}
+
+	x = ldiv16f16(x, y);
+	if (sign)
+		return -x;
+	else
+		return x;
+}

include/fixmath.h

@@ -50,6 +50,15 @@ __native unsigned lmuldiv8by8(char a, char b, char c);
 
 __native unsigned usqrt(unsigned n);
 
+__native unsigned long lmul16f16(unsigned long x, unsigned long y);
+
+__native long lmul16f16s(long x, long y);
+
+__native unsigned long ldiv16f16(unsigned long x, unsigned long y);
+
+__native long ldiv16f16s(long x, long y);
+
+
 #pragma compile("fixmath.c")
 
 #endif

include/gfx/bitmap.c

@@ -525,7 +525,7 @@ void bm_polygon_nc_fill(const Bitmap * bm, const ClipRect * clip, int * px, int
 static inline void buildline(char ly, char lx, int dx, int dy, int stride, bool left, bool up, char pattern, LineOp op)
 {
 	char	ip = 0;
-	bool	delta16 = ((dx | dy) & 0xff80) != 0;
+	bool	delta16 =((dx | dy) & 0xff80) != 0;
 
 	// ylow
 	ip += asm_im(BLIT_CODE + ip, ASM_LDY, ly);
@@ -579,59 +579,105 @@ static inline void buildline(char ly, char lx, int dx, int dy, int stride, bool
 		break;
 	}
 
-	// m >= 0
+	if (dy)
-	ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_DP + delta16);
-	ip += asm_rl(BLIT_CODE + ip, ASM_BMI, delta16 ? 5 + 15 + 13 + 2 : 5 + 15 + 7 + 2);
-
-	ip += asm_np(BLIT_CODE + ip, up ? ASM_DEY : ASM_INY);
-	ip += asm_im(BLIT_CODE + ip, ASM_CPY, up ? 0xff : 0x08);
-	ip += asm_rl(BLIT_CODE + ip, ASM_BNE, 15);
-
-	ip += asm_np(BLIT_CODE + ip, ASM_CLC);
-	ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_SP);
-	ip += asm_im(BLIT_CODE + ip, ASM_ADC, stride & 0xff);
-	ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_SP);
-	ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_SP + 1);
-	ip += asm_im(BLIT_CODE + ip, ASM_ADC, stride >> 8);
-	ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_SP + 1);
-	ip += asm_im(BLIT_CODE + ip, ASM_LDY, up ? 0x07 : 0x00);
-
-	ip += asm_np(BLIT_CODE + ip, ASM_SEC);
-	ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_DP);
-	ip += asm_im(BLIT_CODE + ip, ASM_SBC, dx & 0xff);
-	ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_DP);
-
-	if (delta16)
 	{
-		ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_DP + 1);
+		bool	delta8 = false;
-		ip += asm_im(BLIT_CODE + ip, ASM_SBC, dx >> 8);
+
-		ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_DP + 1);
+		if (dx)
+		{
+			// m >= 0
+			ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_DP + delta16);
+			char n = delta16 ? 18 + 13 + 2 : 18 + 7 + 2;
+			if (!up) n++;
+			ip += asm_rl(BLIT_CODE + ip, ASM_BMI, n);
+			delta8 = !delta16;
+		}
+
+		if (up)
+		{
+			ip += asm_np(BLIT_CODE + ip, ASM_DEY);
+			ip += asm_rl(BLIT_CODE + ip, ASM_BPL, delta8 ? 17 : 15);
+			ip += asm_np(BLIT_CODE + ip, ASM_CLC);
+			ip += asm_im(BLIT_CODE + ip, ASM_LDY, 0x07);
+			ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_SP);
+			ip += asm_im(BLIT_CODE + ip, ASM_ADC, stride & 0xff);
+			ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_SP);
+			ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_SP + 1);
+			ip += asm_im(BLIT_CODE + ip, ASM_ADC, stride >> 8);
+			ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_SP + 1);
+		}
+		else
+		{
+			ip += asm_np(BLIT_CODE + ip, ASM_INY);
+			ip += asm_im(BLIT_CODE + ip, ASM_CPY, 0x08);
+			ip += asm_rl(BLIT_CODE + ip, ASM_BNE, delta8 ? 16 : 14);
+			ip += asm_im(BLIT_CODE + ip, ASM_LDY, 0x00);
+			ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_SP);
+			ip += asm_im(BLIT_CODE + ip, ASM_ADC, (stride - 1) & 0xff);
+			ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_SP);
+			ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_SP + 1);
+			ip += asm_im(BLIT_CODE + ip, ASM_ADC, (stride - 1) >> 8);
+			ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_SP + 1);
+		}
+
+		if (dx)
+		{
+			ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_DP);
+			ip += asm_np(BLIT_CODE + ip, ASM_SEC);
+			ip += asm_im(BLIT_CODE + ip, ASM_SBC, dx & 0xff);
+			ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_DP);
+
+			if (delta16)
+			{
+				ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_DP + 1);
+				ip += asm_im(BLIT_CODE + ip, ASM_SBC, dx >> 8);
+				ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_DP + 1);
+				ip += asm_rl(BLIT_CODE + ip, ASM_BPL, 13 + 4 + 12);
+
+				ip += asm_np(BLIT_CODE + ip, ASM_CLC);
+				ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_DP);
+				ip += asm_im(BLIT_CODE + ip, ASM_ADC, dy & 0xff);
+				ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_DP);
+				ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_DP + 1);
+				ip += asm_im(BLIT_CODE + ip, ASM_ADC, dy >> 8);
+				ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_DP + 1);
+			}
+			else
+			{
+				// We know regdp to be in the accu at this point
+				ip += asm_rl(BLIT_CODE + ip, ASM_BPL, 5 + 4 + 12);
+				ip += asm_np(BLIT_CODE + ip, ASM_CLC);
+				ip += asm_im(BLIT_CODE + ip, ASM_ADC, dy & 0xff);
+				ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_DP);
+			}
+		}
+
+		// m < 0
 	}
 
-	// m < 0
+	if (dx)
-	ip += asm_rl(BLIT_CODE + ip, ASM_BPL, delta16 ? 4 + 15 + 13 : 4 + 15 + 7);
-
-	ip += asm_zp(BLIT_CODE + ip, left ? ASM_ASL : ASM_LSR, REG_D0);
-	ip += asm_rl(BLIT_CODE + ip, ASM_BCC, 15);
-
-	ip += asm_zp(BLIT_CODE + ip, left ? ASM_ROL : ASM_ROR, REG_D0);
-	ip += asm_np(BLIT_CODE + ip, ASM_CLC);
-	ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_SP);
-	ip += asm_im(BLIT_CODE + ip, ASM_ADC, left ? 0xf8 : 0x08);
-	ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_SP);
-	ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_SP + 1);
-	ip += asm_im(BLIT_CODE + ip, ASM_ADC, left ? 0xff : 0x00);
-	ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_SP + 1);
-
-	ip += asm_np(BLIT_CODE + ip, ASM_CLC);
-	ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_DP);
-	ip += asm_im(BLIT_CODE + ip, ASM_ADC, dy & 0xff);
-	ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_DP);
-	if (delta16)
 	{
-		ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_DP + 1);
+		ip += asm_zp(BLIT_CODE + ip, left ? ASM_ASL : ASM_LSR, REG_D0);
-		ip += asm_im(BLIT_CODE + ip, ASM_ADC, dy >> 8);
+		ip += asm_rl(BLIT_CODE + ip, ASM_BCC, 12);
-		ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_DP + 1);
+
+		ip += asm_zp(BLIT_CODE + ip, left ? ASM_ROL : ASM_ROR, REG_D0);
+
+		ip += asm_zp(BLIT_CODE + ip, ASM_LDA, REG_SP);
+
+		if (left)
+		{
+			ip += asm_im(BLIT_CODE + ip, ASM_ADC, 0xf8);
+			ip += asm_rl(BLIT_CODE + ip, ASM_BCS, 2);
+			ip += asm_zp(BLIT_CODE + ip, ASM_DEC, REG_SP + 1);
+		}
+		else
+		{
+			ip += asm_im(BLIT_CODE + ip, ASM_ADC, 0x08);
+			ip += asm_rl(BLIT_CODE + ip, ASM_BCC, 2);
+			ip += asm_zp(BLIT_CODE + ip, ASM_INC, REG_SP + 1);
+		}
+
+		ip += asm_zp(BLIT_CODE + ip, ASM_STA, REG_SP);
 	}
 
 	// l --
@@ -649,6 +695,7 @@ static inline void callline(byte * dst, byte bit, int m, char lh, char pattern)
 {
 	__asm
 	{
+
 		lda	dst
 		sta REG_SP
 		lda	dst + 1

include/inttypes.c

@@ -0,0 +1,26 @@
+#include "inttypes.h"
+#include "stdlib.h"
+
+
+intmax_t  imaxabs(intmax_t n)
+{
+	return n < 0 ? -n : n;
+}
+
+imaxdiv_t imaxdiv(intmax_t l, intmax_t r)
+{
+	imaxdiv_t	t;
+	t.quot = l / r;
+	t.rem = l % r;
+	return t;
+}
+
+inline intmax_t strtoimax(const char * s, char ** endp, int base)
+{
+	return strtol(s, endp, base);
+}
+
+inline uintmax_t strtoumax(const char * s, char ** endp, int base)
+{
+	return strtoul(s, endp, base);
+}

include/inttypes.h

@@ -0,0 +1,98 @@
+#ifndef INTTYPES_H
+#define INTTYPES_H
+
+#include <stdint.h>
+
+#define PRId8			"d"
+#define PRId16			"d"
+#define PRId32			"ld"
+
+#define PRIdLEAST8		"d"
+#define PRIdLEAST16		"d"
+#define PRIdLEAST32		"ld"
+
+#define PRIdFAST8		"d"
+#define PRIdFAST16		"d"
+#define PRIdFAST32		"ld"
+
+#define PRIdMAX 		"ld"
+#define PRIdPTR 		"d"
+
+
+#define PRIo8			"o"
+#define PRIo16			"o"
+#define PRIo32			"lo"
+
+#define PRIoLEAST8		"o"
+#define PRIoLEAST16		"o"
+#define PRIoLEAST32		"lo"
+
+#define PRIoFAST8		"o"
+#define PRIoFAST16		"o"
+#define PRIoFAST32		"lo"
+
+#define PRIoMAX 		"lo"
+#define PRIoPTR 		"o"
+
+#define PRIu8			"u"
+#define PRIu16			"u"
+#define PRIu32			"lu"
+
+#define PRIuLEAST8		"u"
+#define PRIuLEAST16		"u"
+#define PRIuLEAST32		"lu"
+
+#define PRIuFAST8		"u"
+#define PRIuFAST16		"u"
+#define PRIuFAST32		"lu"
+
+#define PRIuMAX 		"lu"
+#define PRIuPTR 		"u"
+
+
+#define PRIx8			"x"
+#define PRIx16			"x"
+#define PRIx32			"lx"
+
+#define PRIxLEAST8		"x"
+#define PRIxLEAST16		"x"
+#define PRIxLEAST32		"lx"
+
+#define PRIxFAST8		"x"
+#define PRIxFAST16		"x"
+#define PRIxFAST32		"lx"
+
+#define PRIxMAX 		"lx"
+#define PRIxPTR 		"x"
+
+
+#define PRIX8			"X"
+#define PRIX16			"X"
+#define PRIX32			"lX"
+
+#define PRIXLEAST8		"X"
+#define PRIXLEAST16		"X"
+#define PRIXLEAST32		"lX"
+
+#define PRIXFAST8		"X"
+#define PRIXFAST16		"X"
+#define PRIXFAST32		"lX"
+
+#define PRIXMAX 		"lX"
+#define PRIXPTR 		"X"
+
+
+typedef struct {
+	intmax_t quot;
+	intmax_t rem;
+} imaxdiv_t;
+
+intmax_t  imaxabs(intmax_t n);
+imaxdiv_t imaxdiv(intmax_t l, intmax_t r);
+intmax_t  strtoimax(const char * s, char ** endp, int base);
+uintmax_t strtoumax(const char * s, char ** endp, int base);
+
+
+#pragma compile("inttypes.c")
+
+#endif

include/iso646.h

@@ -0,0 +1,16 @@
+#ifndef ISO646_H
+#define ISO646_H
+
+#define   and      &&
+#define   and_eq   &=
+#define   bitand   &
+#define   bitor    |
+#define   compl    ~
+#define   not      !
+#define   not_eq   !=
+#define   or       ||
+#define   or_eq    |=
+#define   xor      ^
+#define   xor_eq   ^=
+
+#endif

include/limits.h

@@ -11,7 +11,7 @@
 #define	CHAR_MIN	SCHAR_MIN
 #define	CHAR_MAX	SCHAR_MAX
 
-#define INT_MIN		-32767
+#define INT_MIN		(-32767-1)
 #define	INT_MAX		32767
 #define	UINT_MAX	65535
 

include/math.c

@@ -110,12 +110,12 @@ float atan2(float p, float q)
 	return s;
 }
 
-#define F_EXP_0 	1.0000003
+#define F_EXP_0 	1.0
-#define F_EXP_1 	0.693147059
+#define F_EXP_1 	0.69315668
-#define F_EXP_2 	0.240173099
+#define F_EXP_2 	0.240132068
-#define F_EXP_3 	0.055816392
+#define F_EXP_3 	0.055876024
-#define F_EXP_4 	0.008965036
+#define F_EXP_4 	0.008940801
-#define F_EXP_5 	0.001898429
+#define F_EXP_5 	0.001894414
 
 float exp(float f)
 {
@@ -143,12 +143,12 @@ float exp(float f)
 	return s * x.f;
 }
 
-#define F_LOG_0 	-3.78712618	
+#define F_LOG_0 	-3.78717706
-#define F_LOG_1		10.0957081
+#define F_LOG_1 	10.0960498
-#define F_LOG_2		-13.9747486
+#define F_LOG_2 	-13.975654
-#define F_LOG_3		12.7568806
+#define F_LOG_3 	12.7580616
-#define F_LOG_4		-6.48114552
+#define F_LOG_4 	-6.48190725
-#define F_LOG_5		1.39045416
+#define F_LOG_5 	1.39064767
 
 float log(float f)
 {

include/math.h

@@ -30,6 +30,18 @@ bool isfinite(float f);
 #pragma intrinsic(floor)
 #pragma intrinsic(ceil)
 
+#pragma intrinsic(sin)
+#pragma intrinsic(cos)
+#pragma intrinsic(tan)
+#pragma intrinsic(atan)
+#pragma intrinsic(atan2)
+
+#pragma intrinsic(log)
+#pragma intrinsic(exp)
+
+#pragma intrinsic(pow)
+#pragma intrinsic(sqrt)
+
 #pragma compile("math.c")
 
 

include/new

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "stddef.h"
+
+namespace std
+{
+	
+	void * operator new(size_t size);
+	void * operator new(void * ptr, size_t size);
+
+}

include/opp/algorithm.h

@@ -0,0 +1,84 @@
+#ifndef OPP_ALGORITHM_H
+#define OPP_ALGORITHM_H
+
+#include "utility.h"
+namespace opp {
+
+template<class T, class LT>
+void sort(T s, T e)
+{
+	while (s != e)
+	{
+		auto p = s;
+		auto q = s;
+
+		q++;
+		while (q != e)
+		{
+			if (LT(*q, *p))
+			{
+				swap(*q, *p);
+				p++;
+				swap(*q, *p);				
+			}
+			q++;
+		}
+
+		sort<T, LT>(s, p);
+		p++;
+		s = p;
+	}
+}
+
+template<class T, class LF>
+void sort(T s, T e, LF lt)
+{
+	while (s != e)
+	{
+		auto p = s;
+		auto q = s;
+
+		q++;
+		while (q != e)
+		{
+			if (lt(*q, *p))
+			{
+				swap(*q, *p);
+				p++;
+				swap(*q, *p);				
+			}
+			q++;
+		}
+
+		sort(s, p, lt);
+		p++;
+		s = p;
+	}
+}
+
+template<class II, class OI>
+OI copy(II first, II last, OI result)
+{
+	while (first != last)
+	{
+		*result = *first;
+		++result; ++first;
+	}
+	return result;
+}
+
+
+template<class II, class T>
+II find (II first, II last, const T& val)
+{
+	while (first != last) 
+	{
+		if (*first == val) return first;
+			++first;
+	}
+	return last;
+}
+
+}
+
+#endif

include/opp/array.h

@@ -0,0 +1,120 @@
+#ifndef OPP_ARRAY_H
+#define OPP_ARRAY_H
+
+namespace opp {
+
+template <class T, int n>
+class array
+{
+protected:
+	T	_data[n];
+public:
+	typedef T 	element_type;
+
+	int size(void) const
+	{
+		return n;
+	}
+
+	int max_size(void) const
+	{
+		return n;
+	}
+
+	bool empty(void) const
+	{
+		return n == 0;
+	}
+
+	const T & at(int at) const
+	{
+		return _data[at];
+	}
+
+	T & at(int at)
+	{
+		return _data[at];
+	}
+
+	T & operator[] (int at)
+	{
+		return _data[at];
+	}
+
+	const T & operator[] (int at) const
+	{
+		return _data[at];
+	}
+
+	T * begin(void)
+	{
+		return _data;
+	}
+
+	const T * begin(void) const
+	{
+		return _data;
+	}
+
+	const T * cbegin(void) const
+	{
+		return _data;
+	}
+
+	T * end(void)
+	{
+		return _data + n;
+	}
+
+	const T * end(void) const
+	{
+		return _data + n;
+	}
+
+	const T * cend(void) const
+	{
+		return _data + n;
+	}
+
+	T & back(void)
+	{
+		return _data[n - 1];
+	}
+
+	const T & back(void) const
+	{
+		return _data[n - 1];
+	}
+
+	T & front(void)
+	{
+		return _data[0];
+	}
+
+	const T & front(void) const
+	{
+		return _data[0];
+	}
+
+	T * data(void)
+	{
+		return _data;
+	}
+
+	const T * data(void) const
+	{
+		return _data;
+	}
+
+	void fill(const T & t)
+	{
+		for(int i=0; i<n; i++)
+			_data[i] = t;
+	}
+};
+
+}
+
+
+#endif
+

include/opp/bidxlist.h

@@ -0,0 +1,207 @@
+#ifndef OPP_BIDXLIST_H
+#ifndef OPP_BIDXLIST_H
+
+template <class T, int n>
+class bindexlist
+{
+public:
+	char		_free;
+	char		_pred[n], _succ[n];
+	T			_data[n];
+
+	class iterator
+	{
+	public:
+		bindexlist	*	_l;
+		char			_i;
+
+		iterator(void) : _l(nullptr) {}
+		iterator(bindexlist * l, char i)
+			: _l(l), _i(i) {}
+
+		iterator(const iterator & li) : _l(li._l), _i(li._i) {}
+		iterator & operator=(const iterator & li)
+		{
+			_l = li._l;
+			_i = li._i;
+			return *this;
+		}
+
+		T & operator*()
+		{
+			return _l->_data[_i];
+		}
+
+		T * operator->()
+		{
+			return _l->_data + _i;
+		}
+
+		iterator & operator++(void)
+		{
+			_i = _l->_succ[_i];
+			return *this;
+		}
+
+		iterator operator++(int)
+		{
+			char i = _i;
+			_i = _l->_succ[_i];
+			return bindexlist::iterator(_l, i);
+		}
+
+		iterator & operator+=(char n)
+		{
+			while (n--)
+				_i = _l->_succ[_i];
+			return *this;
+		}
+
+		iterator & operator--(void)
+		{
+			_i = _l->_pred[_i];
+			return *this;
+		}
+
+		iterator operator++(int)
+		{
+			char i = _i;
+			_i = _l->_pred[_i];
+			return bindexlist::iterator(_l, i);
+		}
+
+		iterator & operator-=(char n)
+		{
+			while (n--)
+				_i = _l->_pred[_i];
+			return *this;
+		}
+
+		bool operator==(const iterator & li)
+		{
+			return _i == li._i;
+		}
+
+		bool operator!=(const iterator & li)
+		{
+			return _i != li._i;
+		}
+	};
+
+public:
+	typedef T 			element_type;
+	typedef iterator	iterator_type;
+
+	bindexlist(void)
+	{
+		_succ[0] = 0;
+		_pred[0] = 0;
+		for(char i=1; i<n; i++)
+			_succ[i] = i + 1;
+		_free = 1;
+	}
+
+	~bindexlist(void)
+	{
+
+	}
+
+	iterator begin(void)
+	{
+		return iterator(this, _succ[0]);
+	}
+
+	iterator end(void)
+	{
+		return iterator(this, 0);
+	}
+
+	T & front(void)
+	{
+		return _data[_succ[0]];
+	}
+
+	const T & front(void) const
+	{
+		return _data[_succ[0]];
+	}
+
+	T & back(void)
+	{
+		return _data[_pred[0]];
+	}
+
+	const T & back(void) const
+	{
+		return _data[_pred[0]];
+	}
+
+	iterator erase(iterator it)
+	{
+		char s = _succ[it._i];
+		_succ[_pred[it._i]] = _pred[it._i];
+		_pred[_succ[it._i]] = s;
+		_succ[it._i] = _free;
+		_free = it._i;
+		return iterator(this, s);
+	}
+
+	iterator erase(iterator first, iterator last)
+	{
+		char s = _succ[last._i];
+		_succ[_pred[last._i]] = _pred[first._i];
+		_pred[_succ[first._i]] = s;
+		_succ[last._i] = _free;
+		_free = first._i;
+		return iterator(this, s);
+	}
+
+	void pop_front(void)
+	{
+		char i = _succ[0];
+		char s = _succ[i];
+		_pred[s] = 0;
+		_succ[0] = s;
+		_succ[i] = _free;
+		_free = i;
+	}
+
+	void pop_back(void)
+	{
+		char i = _pred[0];
+		char p = _pred[i];
+		_succ[p] = 0;
+		_pred[0] = p;
+		_pred[i] = _free;
+		_free = i;
+	}
+
+	void push_back(const T & t)
+	{
+		char i = _free;
+		_data[i] = t;
+
+		_free = _succ[_free];
+
+		_succ[i] = 0;
+		_pred[i] = _pred[0];
+		_succ[_pred[0]] = i;
+		_pred[0] = i;
+	}
+
+	void push_front(const T & t)
+	{
+		char i = _free;
+		_data[i] = t;
+		
+		_free = _succ[_free];
+		_succ[i] = 0;
+		_succ[i] = _succ[0];
+		_pred[_succ[0]] = i;
+		_succ[0] = i;
+	}
+
+};
+
+
+#endif

include/opp/boundint.h

@@ -0,0 +1,59 @@
+#ifndef OPP_BOUNDINT_H
+#define OPP_BOUNDINT_H
+
+namespace opp {
+	
+	template<int tmin, int tmax>
+	constexpr auto boundinttype(void)
+	{
+		if constexpr (tmin >= 0 && tmax <= 255)
+			return (char)0;
+		else if constexpr (tmin >= -128 && tmax <= 127)
+			return (signed char)0;
+		else
+			return (int)0;
+	}
+
+	template<int tmin, int tmax> 
+	class boundint
+	{
+	protected:
+		decltype(boundinttype<tmin, tmax>()) 	v;
+	public:
+		boundint(int i) 
+			: v(i) 
+		{
+
+		}
+
+		void operator=(int k)
+		{
+			__assume(k >= tmin && k <= tmax);
+			v = k;
+		}
+
+		void operator+=(int k)
+		{
+			k += v;
+			__assume(k >= tmin && k <= tmax);
+			v = k;
+		}
+
+		void operator-=(int k)
+		{
+			k = v - k;
+			__assume(k >= tmin && k <= tmax);
+			v = k;
+		}
+
+		operator int() const
+		{
+			int k = v;
+			__assume(k >= tmin && k <= tmax);
+			return k;
+		}
+	};
+
+}
+
+#endif

include/opp/functional.h

@@ -0,0 +1,93 @@
+#ifndef OPP_FUNCTIONAL_H
+#define OPP_FUNCTIONAL_H
+
+namespace opp
+{
+template <class F>
+class function;
+
+template <class R, class ... P>
+class function<R(P...)>
+{
+private:
+	struct callif
+	{
+		virtual R call(P...) = 0;
+		virtual ~callif() {}
+		virtual callif * clone(void) const = 0;
+	};
+
+	template<class CA>
+	struct callable : callif
+	{
+		CA 	ca;
+
+		callable(CA ca_) : ca(ca_) {}
+
+		R call(P... p) {return ca(p...);}
+
+		callif * clone(void) const
+		{
+			return new callable(ca);
+		}
+	};
+
+   callif	* c;
+public:
+	template <class F> 
+	function(F f)
+	{
+		c = new callable<F>(f);
+	}
+
+	function(const function & f)
+	{
+		c = f.c->clone();
+	}
+
+	function(function && f)
+	{
+		c = f.c;
+		f.c = nullptr;
+	}
+
+	function(void)
+	{
+		c = nullptr;
+	}
+
+	function & operator=(const function & f)
+	{
+		if (c != f.c)
+		{
+			delete c;
+			c = f.c;
+		}
+		return *this;
+	}
+
+	function & operator=(function && f)
+	{
+		if (c != f.c)
+		{
+			c = f.c;
+			f.c = nullptr;
+		}
+		return *this;
+	}
+
+	~function(void)
+	{
+		delete c;
+	}
+
+	R operator()(P ... p) const
+	{ 
+		return c->call(p...); 
+	}
+};
+
+
+}
+
+#endif

include/opp/ifstream.cpp

@@ -1,10 +1,12 @@
 #include "ifstream.h"
 #include <c64/kernalio.h>
 
+namespace opp {
+
 ifstream::ifstream(char fnum, char device, char channel, const string & name)
 {
 	this->fnum = fnum;
-	krnio_setnam(name);
+	krnio_setnam(name.tocstr());
 	krnio_open(fnum, device, channel);
 }
 
@@ -19,3 +21,4 @@ void ifstream::refill(void)
 	mBufferFill = krnio_read(fnum, mBuffer, 32);
 }
 
+}

include/opp/ifstream.h

@@ -4,6 +4,7 @@
 #include "iostream.h"
 #include "string.h"
 
+namespace opp {
 
 class ifstream : public istream
 {
@@ -17,7 +18,7 @@ protected:
 	char fnum;
 };
 
-
+}
 
 #pragma compile("ifstream.cpp")
 

include/opp/iostream.cpp

@@ -2,6 +2,8 @@
 #include <math.h>
 #include <stdio.h>
 
+namespace opp {
+
 ios::ios(void)
 	: mFlags(0), mState(0), mWidth(0), mPrecision(6), mFill(' ')
 {}
@@ -11,7 +13,7 @@ inline ios::~ios(void)
 
 }
 
-char ios::fill(void)
+char ios::fill(void) const
 {
 	return mFill;
 }
@@ -251,10 +253,11 @@ void ostream::numput(unsigned n, char sign)
 	if (mFlags & uppercase)
 		o = 'A' - 10;
 
-	while (n)
+	unsigned	nt = n;
+	while (nt)
 	{
-		char d = n % base;
+		char d = nt % base;
-		n /= base;
+		nt /= base;
 
 		if (d < 10)
 			d += '0';
@@ -287,10 +290,11 @@ void ostream::numput(unsigned long n, char sign)
 	if (mFlags & uppercase)
 		o = 'A' - 10;
 
-	while (n)
+	unsigned long nt = n;
+	while (nt)
 	{
-		char d = n % base;
+		char d = nt % base;
-		n /= base;
+		nt /= base;
 
 		if (d < 10)
 			d += '0';
@@ -318,6 +322,12 @@ ostream & ostream::operator<<(bool val)
 	return *this;
 }
 
+ostream & ostream::operator<<(char val)
+{
+	bput(val);
+	return *this;
+}
+
 ostream & ostream::operator<<(int val)
 {
 	if (val < 0)
@@ -942,6 +952,13 @@ istream & istream::operator>>(float & val)
 	return *this;
 }
 
+istream & istream::operator>>(char & val)
+{
+	doskipws();
+	val = get();
+	return *this;
+}
+
 istream & istream::operator>>(char * p)
 {
 	doskipws();
@@ -955,21 +972,39 @@ istream & istream::operator>>(char * p)
 	return *this;
 }
 
+istream & istream::operator>>(string & s)
+{
+	doskipws();
+	s.clear();
+	char c = get();
+	while (c > ' ')
+	{
+		s += c;
+		c = get();
+	}
+	return *this;	
+}
+
 cistream::cistream(void)
 {}
 
 void cistream::refill(void)
 {
-	mBufferFill = 0;
 	mBufferPos = 0;
 
-	char ch;
+	char fill = 0;
-	while (mBufferFill < 32)
+	while (fill < 32)
 	{
 		char ch = getchar();
-		mBuffer[mBufferFill++] = ch;
+		mBuffer[fill++] = ch;
 		if (ch == '\n')
 			break;
 	}
+
+	mBufferFill = fill;
 }
 
+cistream	cin;
+costream 	cout;
+
+}

include/opp/iostream.h

@@ -3,11 +3,13 @@
 
 #include <opp/string.h>
 
+namespace opp {
+
 class ios
 {
 public:
 
-	ios(void);
+	constexpr ios(void);
 	virtual ~ios(void);
 
 	char fill() const;
@@ -35,7 +37,7 @@ public:
 		showpos		=	0x0800,
 		skipws		=	0x1000,
 		unitbuf		=	0x2000,
-		uppercase	=	0x3000,
+		uppercase	=	0x4000,
 
 		adjustfield	=	0x00b0,
 		basefield	=	0x004a,
@@ -83,12 +85,13 @@ typedef ostream & (* manip)(ostream &);
 class ostream : public ios
 {
 public:
-	ostream(void);
+	constexpr ostream(void);
 
 	ostream & put(char c);
 	ostream & write(const char * s, int n);		
 
 	ostream & operator<<(bool val);
+	ostream & operator<<(char val);
 	ostream & operator<<(int val);
 	ostream & operator<<(unsigned val);
 	ostream & operator<<(long val);
@@ -121,6 +124,7 @@ public:
 	istream & putback(char c);
 	istream & unget(void);
 
+	istream & operator>>(char & val);
 	istream & operator>>(bool & val);
 	istream & operator>>(int & val);
 	istream & operator>>(unsigned & val);
@@ -129,6 +133,7 @@ public:
 	istream & operator>>(float & val);
 
 	istream & operator>>(char * p);
+	istream & operator>>(string & s);
 
 	istream(void);
 protected:
@@ -147,7 +152,7 @@ protected:
 class costream : public ostream
 {
 public:
-	costream(void);
+	constexpr costream(void);
 
 protected:
 	void bput(char ch);
@@ -202,6 +207,10 @@ iosetfill setfill(char fill);
 ostream & operator<<(ostream & os, const iosetfill & s);
 
 
+extern cistream	cin;
+extern costream cout;
+
+}
 
 #pragma compile("iostream.cpp");
 

include/opp/iterator.h

@@ -0,0 +1,137 @@
+#ifndef OPP_ITERATOR_H
+#define OPP_ITERATOR_H
+
+namespace opp
+{
+
+template <class CT>
+class back_insert_iterator
+{
+protected:
+	CT 	*	co;
+
+public:
+	back_insert_iterator (CT & c) : co(&c) {}
+
+	back_insert_iterator & operator= (const CT::element_type & t)
+	{
+		co->push_back(t); 
+		return *this; 
+	}
+
+	back_insert_iterator & operator= (CT::element_type && t)
+	{
+		co->push_back(t); 
+		return *this; 
+	}
+
+	back_insert_iterator & operator* (void)
+	{
+		return *this; 
+	}
+
+	back_insert_iterator & operator++ (void)
+	{
+		return *this;
+	}
+
+	back_insert_iterator operator++ (int)
+	{
+		return *this;
+	}
+};
+
+template <class CT>
+class front_insert_iterator
+{
+protected:
+	CT 	*	co;
+
+public:
+	front_insert_iterator (CT & c) : co(&c) {}
+
+	front_insert_iterator & operator= (const CT::element_type & t)
+	{
+		co->push_front(t); 
+		return *this; 
+	}
+
+	front_insert_iterator & operator= (CT::element_type && t)
+	{
+		co->push_front(t); 
+		return *this; 
+	}
+
+	front_insert_iterator & operator* (void)
+	{
+		return *this; 
+	}
+
+	front_insert_iterator & operator++ (void)
+	{
+		return *this;
+	}
+
+	front_insert_iterator operator++ (int)
+	{
+		return *this;
+	}
+};
+
+template <class CT>
+class insert_iterator
+{
+protected:
+	CT 					*	co;
+	CT::iterator_type		ci;
+
+public:
+	insert_iterator (CT & c, const CT::iterator_type & i) : co(&c), ci(i) {}
+
+	insert_iterator & operator= (const CT::element_type & t)
+	{
+		ci = co->insert(ci, t); ++ci;
+		return *this; 
+	}
+
+	insert_iterator & operator= (CT::element_type && t)
+	{
+		ci = co->insert(ci, t); ++ci;
+		return *this; 
+	}
+
+	insert_iterator & operator* (void)
+	{
+		return *this; 
+	}
+
+	insert_iterator & operator++ (void)
+	{
+		return *this;
+	}
+
+	insert_iterator operator++ (int)
+	{
+		return *this;
+	}
+};
+
+template <class CT>  
+front_insert_iterator<CT> front_inserter (CT & c)
+{
+	return front_insert_iterator<CT>(c);
+}
+
+template <class CT>  
+back_insert_iterator<CT> back_inserter (CT & c)
+{
+	return back_insert_iterator<CT>(c);
+}
+
+template <class CT>  
+insert_iterator<CT> inserter (CT & c, const CT::iterator_type & i)
+{
+	return insert_iterator<CT>(c, i);
+}
+
+}

include/opp/list.h

@@ -0,0 +1,370 @@
+#ifndef OPP_LIST
+#define OPP_LIST
+
+namespace opp 
+{
+
+template <class T>
+class listhead
+{
+public:
+	listnode<T>	*	succ, * pred;	
+
+	listhead()
+	{
+		succ = (listnode<T>	*)this;
+		pred = (listnode<T>	*)this;
+	}
+};
+
+template <class T>
+class listnode : public listhead<T>
+{
+public:
+	T				data;
+
+	listnode(const T & t) : data(t) {}
+	listnode(T && t) : data(t) {}
+};
+
+template <class T>
+class list_iterator
+{
+public:
+	listnode<T>	*	node;
+public:
+	list_iterator(void) : node(nullptr) {}
+	list_iterator(listnode<T> * n) : node(n) {}
+	list_iterator(const list_iterator & li) : node(li.node) {}
+	list_iterator & operator=(const list_iterator & li)
+	{
+		node = li.node;
+		return *this;
+	}
+
+	T & operator*()
+	{
+		return node->data;
+	}
+
+	T * operator->()
+	{
+		return &(node->data);
+	}
+
+	list_iterator & operator++(void)
+	{
+		node = node->succ;
+		return *this;
+	}
+
+	list_iterator operator++(int)
+	{
+		listnode<T>	* n = node;	
+		node = node->succ;
+		return list_iterator(n);
+	}
+
+	list_iterator & operator+=(int n)
+	{
+		while (n--)
+			node = node->succ;	
+		return *this;
+	}
+
+	list_iterator & operator--(void)
+	{
+		node = node->pred;
+		return *this;
+	}
+
+	list_iterator operator++(int)
+	{
+		listnode<T>	* n = node;	
+		node = node->pred;
+		return list_iterator(n);
+	}
+
+	list_iterator & operator-=(int n)
+	{
+		while (n--)
+			node = node->pred;	
+		return *this;
+	}
+
+	bool operator==(const list_iterator & li)
+	{
+		return node == li.node;
+	}
+
+	bool operator!=(const list_iterator & li)
+	{
+		return node != li.node;
+	}
+
+};
+
+
+template <class T>
+class list
+{
+private:
+	typedef listnode<T>	ln;
+	listhead<T>	head;
+public:
+	typedef T 					element_type;
+	typedef list_iterator<T>	iterator_type;
+
+	list(void) 
+	{}
+
+	list(const list & l);
+
+	list(list && l)
+	{
+		head.succ = l.head.succ;
+		head.pred = l.head.pred;
+		head.succ->pred = (listnode<T>	*)&head;
+		head.pred->succ = (listnode<T>	*)&head;
+		l.head.succ = (listnode<T>	*)&(l.head);
+		l.head.pred = (listnode<T>	*)&(l.head);
+	}
+
+	list & operator=(const list & l);
+
+	list & operator=(list && l)
+	{
+		head.succ = l.head.succ;
+		head.pred = l.head.pred;
+		head.succ->pred = (listnode<T>	*)&head;
+		head.pred->succ = (listnode<T>	*)&head;
+		l.head.succ = (listnode<T>	*)&(l.head);
+		l.head.pred = (listnode<T>	*)&(l.head);
+		return *this;
+	}
+
+	~list(void)
+	{
+		listnode<T>	*	n = head.succ;
+		while (n != &head)
+		{
+			listnode<T>	*	m = n->succ;
+			delete n;
+			n = m;
+		}
+	}
+
+	list_iterator<T> begin(void)
+	{
+		return list_iterator<T>(head.succ);
+	}
+
+	list_iterator<T> end(void)
+	{
+		return list_iterator<T>((listnode<T> *)&head);
+	}
+
+	T & front(void)
+	{
+		return head.succ->data;
+	}
+
+	const T & front(void) const
+	{
+		return head.succ->data;
+	}
+
+	T & back(void)
+	{
+		return head.pred->data;
+	}
+
+	const T & back(void) const
+	{
+		return head.pred->data;
+	}
+
+	list_iterator<T> erase(list_iterator<T> it);
+
+	list_iterator<T> erase(list_iterator<T> first, list_iterator<T> last);
+
+	void pop_front(void);
+
+	void pop_back(void);
+
+	void push_front(const T & t);
+
+	void push_front(T && t);
+
+	void push_back(const T & t);
+
+	void push_back(T && t);
+
+	void clear(void);
+
+	void append(const list & l);
+
+	list_iterator<T> insert(list_iterator<T> it, const T & t);
+
+	list_iterator<T> insert(list_iterator<T> it, T && t);
+};
+
+template <class T>
+list<T>::list(const list<T> & l)
+{
+	append(l);
+}
+
+template <class T>
+list<T> & list<T>::operator=(const list<T> & l)
+{
+	if (&l != this)
+	{
+		clear();
+		append(l);
+	}
+	return *this;
+}
+
+template <class T>
+void list<T>::pop_front(void)
+{
+	listnode<T>	*	n = head.succ;
+	head.succ = n->succ;
+	n->succ->pred = (listnode<T> *)&head;
+	delete n;
+}
+
+template <class T>
+void list<T>::pop_back(void)
+{
+	listnode<T>	*	n = head.pred;
+	head.pred = n->pred;
+	n->pred->succ = (listnode<T> *)&head;
+	delete n;
+}
+
+template <class T>
+void list<T>::push_front(const T & t)
+{
+	listnode<T>	*	n = new listnode<T>(t);
+	n->pred = (listnode<T> *)&head;
+	n->succ = head.succ;
+	head.succ->pred = n;
+	head.succ = n;
+}
+
+template <class T>
+void list<T>::push_front(T && t)
+{
+	listnode<T>	*	n = new listnode<T>(t);
+	n->pred = (listnode<T> *)&head;
+	n->succ = head.succ;
+	head.succ->pred = n;
+	head.succ = n;
+}
+
+template <class T>
+void list<T>::push_back(const T & t)
+{
+	listnode<T>	*	n = new listnode<T>(t);
+	n->succ = (listnode<T> *)&head;
+	n->pred = head.pred;
+	head.pred->succ = n;
+	head.pred = n;
+}
+
+template <class T>
+void list<T>::push_back(T && t)
+{
+	listnode<T>	*	n = new listnode<T>(t);
+	n->succ = (listnode<T> *)&head;
+	n->pred = head.pred;
+	head.pred->succ = n;
+	head.pred = n;
+}
+
+
+template <class T>
+list_iterator<T> list<T>::erase(list_iterator<T> it)
+{
+	listnode<T>	*	n = it.node;
+	listnode<T>	*	s = n->succ;
+
+	n->succ->pred = n->pred;
+	n->pred->succ = n->succ;
+	delete n;
+
+	return list_iterator<T>(s);
+}
+
+template <class T>
+list_iterator<T> list<T>::erase(list_iterator<T> first, list_iterator<T> last)
+{
+	listnode<T>	*	n = first.node;
+	listnode<T>	*	s = last.node;
+
+	n->pred->succ = s;
+	s->pred = n->pred;
+
+	while (n != s)
+	{
+		listnode<T>	*	m = n->succ;
+		delete n;
+		n = m;
+	}
+
+	return list_iterator<T>(s);
+}
+
+template <class T>
+list_iterator<T> list<T>::insert(list_iterator<T> it, const T & t)
+{
+	listnode<T>	*	n = new listnode<T>(t);
+	n->succ = it.node;
+	n->pred = it.node->pred;
+	it.node->pred->succ = n;
+	it.node->pred = n;
+	return list_iterator<T>(n);
+}
+
+template <class T>
+list_iterator<T> list<T>::insert(list_iterator<T> it, T && t)
+{
+	listnode<T>	*	n = new listnode<T>(t);
+	n->succ = it.node;
+	n->pred = it.node->pred;
+	it.node->pred->succ = n;
+	it.node->pred = n;
+	return list_iterator<T>(n);
+}
+
+
+template <class T>
+void list<T>::clear(void)
+{
+	listnode<T>	*	n = head.succ;
+	while (n != &head)
+	{
+		listnode<T>	*	m = n->succ;
+		delete n;
+		n = m;
+	}
+	head.succ = (listnode<T> *)&head;
+	head.pred = (listnode<T> *)&head;
+}
+
+template <class T>
+void list<T>::append(const list<T> & l)
+{
+	listnode<T>	*	n = l.head.succ;
+	while (n != &(l.head))
+	{
+		push_back(n->data);
+		n = n->succ;
+	}
+}
+
+}
+
+#endif

include/opp/ofstream.cpp

@@ -1,6 +1,8 @@
 #include "ofstream.h"
 #include <c64/kernalio.h>
 
+namespace opp {
+
 ofstream::ofstream(char fnum, char device, char channel, const string & name)
 {
 	this->fnum = fnum;
@@ -27,3 +29,4 @@ void ofstream::bput(char ch)
 	}
 }
 
+}

include/opp/ofstream.h

@@ -4,6 +4,7 @@
 #include "iostream.h"
 #include "string.h"
 
+namespace opp {
 
 class ofstream : public ostream
 {
@@ -20,7 +21,7 @@ protected:
 	char fnum;
 };
 
-
+}
 
 #pragma compile("ofstream.cpp")
 

include/opp/slab.h

@@ -0,0 +1,80 @@
+#ifndef OPP_SLAB_H
+#define OPP_SLAB_H
+
+template<class T, int N>
+class slabptr
+{
+public:
+	char	index;
+
+	slabptr(void)
+		: index(N)
+		{}
+
+	slabptr(char i)
+		: index(i)
+		{}
+
+	slabptr(const slabptr & i)
+		: index(i.index)
+		{}
+
+	auto operator-> ();
+	auto & operator* ();
+};
+
+template <class T, int N>
+class slab
+{
+protected:
+	static __striped	T	buffer[N];
+	static	char		head;
+	static	char		next[N];
+
+public:
+	typedef slabptr<T, N>	ptr;
+
+	static void init(void);
+	static auto alloc(void);
+	static void free(ptr p);
+};
+
+
+template<class T, int N>
+inline auto slabptr<T, N>::operator-> ()
+{
+	return slab<T, N>::buffer + index;
+}
+
+template<class T, int N>
+inline auto & slabptr<T, N>::operator* ()
+{
+	return slab<T, N>::buffer[index];	
+}
+
+
+template <class T, int N>
+void slab<T, N>::init(void)
+{
+	head = 0;
+	for(char i=0; i<N; i++)
+		next[i] = i + 1;
+}
+
+template <class T, int N>
+auto slab<T, N>::alloc(void)
+{
+	char i = head;
+	head = next[head];	
+	return slabptr<T, N>(i);	
+}
+
+template <class T, int N>
+void slab<T, N>::free(slabptr<T, N> p)
+{
+	next[p.index] = head;
+	head = p.index;
+}
+
+#endif
+

include/opp/sstream.cpp

@@ -1,6 +1,8 @@
 #include "sstream.h"
 #include <stdlib.h>
 
+namespace opp {
+
 ostringstream::ostringstream(void)
 {
 	mBuffer = nullptr;
@@ -18,12 +20,12 @@ void ostringstream::bput(char ch)
 	{
 		mBSize = 15;
 		mBFill = 0;
-		mBuffer = malloc(15);
+		mBuffer = (char *)malloc(15);
 	}
 	else if (mBFill == mBSize)
 	{
 		mBSize *= 2;
-		char * b = malloc(mBSize);
+		char * b = (char *)malloc(mBSize);
 		for(char i=0; i<mBFill; i++)
 			b[i] = mBuffer[i];
 		free(mBuffer);
@@ -44,7 +46,7 @@ void ostringstream::str(const string & str)
 	{
 		free(mBuffer);
 		mBSize = mBFill;
-		mBuffer = malloc(mBSize);
+		mBuffer = (char *)malloc(mBSize);
 	}
 	str.copyseg(mBuffer, 0, mBFill);
 }
@@ -80,3 +82,5 @@ void istringstream::refill(void)
 		mBuffer[mBufferFill++] = mString[mSPos++];
 	}
 }
+
+}

include/opp/sstream.h

@@ -3,6 +3,8 @@
 
 #include "iostream.h"
 
+namespace opp {
+
 class ostringstream : public ostream
 {
 public:
@@ -33,6 +35,7 @@ protected:
 	char		mSPos;
 };
 
+}
 
 #pragma compile("sstream.cpp")
 

include/opp/static_vector.h

@@ -0,0 +1,308 @@
+#ifndef OPP_STATIC_VECTOR_H
+#define OPP_STATIC_VECTOR_H
+
+#include <new>
+#include <stdlib.h>
+#include <opp/utility.h>
+#include <oscar.h>
+
+namespace opp {
+
+template <class T, int N>
+class static_vector
+{
+protected:
+	enum { m = N }	_size;
+	char	_space[N * sizeof(T)];
+public:
+	typedef T 	element_type;
+
+	static_vector(void) : _size(0) {}
+
+	static_vector(size_t n) : _size(n) 
+	{
+#ifdef CAPACITYCHECK
+	if (n > N) debugcrash();
+#endif
+		T *	data = (T*)_space;
+		for(size_t i=0; i<n; i++)
+			new (data + i) T();
+	}
+
+	static_vector(const static_vector & v)
+		: _size(v._size) 
+	{
+		size_t n = _size;
+		T *	data = (T*)_space, * vdata = (T*)(v._space);
+		for(size_t i=0; i<n; i++)
+			new (data + i)T(vdata[i]);
+	}
+
+	~static_vector(void)
+	{
+		T *	data = (T*)_space;
+		size_t n = _size;
+		for(size_t i=0; i<n; i++)
+			data[i].~T();
+	}
+
+	static_vector & operator=(const static_vector & v)
+	{
+		if (this != &v)
+		{
+			T *	data = (T*)_space, * vdata = (T*)(v._space);
+			size_t n = _size;
+			for(size_t i=0; i<n; i++)
+				data[i].~T();
+			_size = v._size; 
+			n = _size;
+			for(size_t i=0; i<n; i++)
+				new (data + i)T(vdata[i]);
+		}
+		return *this;
+	}
+
+	size_t size(void) const
+	{
+		return _size;
+	}
+
+	size_t max_size(void) const
+	{
+		return N;
+	}
+
+	bool empty(void) const
+	{
+		return _size == 0;
+	}
+
+	bool full(void) const
+	{
+		return _size == N;
+	}
+
+	size_t capacity(void) const
+	{
+		return N;
+	}
+
+	void resize(size_t n);
+
+	void clear(void);
+
+	T & at(size_t at)
+	{
+		return ((T*)_space)[at];
+	}
+
+	const T & at(size_t at) const
+	{
+		return ((T*)_space)[at];
+	}
+
+	T & operator[](size_t at)
+	{
+		return ((T*)_space)[at];
+	}
+
+	const T & operator[](size_t at) const
+	{
+		return ((T*)_space)[at];
+	}
+
+	T * begin(void)
+	{
+		return (T*)_space;
+	}
+
+	const T * begin(void) const
+	{
+		return (T*)_space;
+	}
+
+	const T * cbegin(void) const
+	{
+		return (T*)_space;
+	}
+
+	T * end(void)
+	{
+		return (T*)_space + _size;
+	}
+
+	const T * end(void) const
+	{
+		return (T*)_space + _size;
+	}
+
+	const T * cend(void) const
+	{
+		return (T*)_space + _size;
+	}
+
+	T & front(void)
+	{
+		return ((T*)_space)[0];
+	}
+
+	const T & front(void) const
+	{
+		return ((T*)_space)[0];
+	}
+
+	T & back(void)
+	{
+		return ((T*)_space)[_size - 1];
+	}
+
+	const T & back(void) const
+	{
+		return ((T*)_space)[_size - 1];
+	}
+
+	T * data(void)
+	{
+		return (T*)_space;
+	}
+
+	const T * at(void) const
+	{
+		return (T*)_space;
+	}
+
+	void push_back(const T & t);
+
+	void push_back(T && t);
+
+	void pop_back(void)
+	{
+		_size--;
+		((T*)_space)[_size].~T();
+	}
+
+	void assign(size_t count, const T & t);
+
+	void insert(size_t at, const T & t);
+
+	void erase(size_t at, size_t n = 1);
+
+	T * insert(T * at, const T & t);
+
+	template <typename ...P>
+	void emplace_back(const P&... p);
+};
+
+
+template <class T, int N>
+void static_vector<T, N>::clear(void)
+{
+	T *	data = (T*)_space;
+	for(size_t i=0; i<_size; i++)
+		data[i].~T();			
+	_size = 0;
+}
+
+template <class T, int N>
+void static_vector<T, N>::resize(size_t n)
+{
+#ifdef CAPACITYCHECK
+	if (n > N) debugcrash();
+#endif
+	T *	data = (T*)_space;
+	if (n < _size)
+	{
+		for(size_t i=n; i<_size; i++)
+			data[i].~T();			
+	}
+	else if (n > 0)
+	{
+		for(size_t i=_size; i<n; i++)
+			new(data + i)T();
+	}
+	_size = n;
+}
+
+template <class T, int N>
+void static_vector<T, N>::push_back(const T & t)
+{
+#ifdef CAPACITYCHECK
+	if (_size >= N) debugcrash();
+#endif
+	new ((T*)_space + _size++)T(t);
+}
+
+template <class T, int N>
+void static_vector<T, N>::push_back(T && t)
+{
+#ifdef CAPACITYCHECK
+	if (_size >= N) debugcrash();
+#endif
+	new ((T*)_space + _size++)T(t);
+}
+
+template <class T, int N>
+template <typename ...P>
+void static_vector<T, N>::emplace_back(const P&... p)
+{
+#ifdef CAPACITYCHECK
+	if (_size >= N) debugcrash();
+#endif
+	new ((T*)_space + _size++)T(p...);
+}
+
+template <class T, int N>
+void static_vector<T, N>::assign(size_t count, const T & t)
+{
+	T *	data = (T*)_space;
+	for(size_t i=0; i<_size; i++)
+		data[i].~T();
+	for(size_t i=0; i<count; i++)
+		new (data + i)T(t);
+	_size = count;
+}
+
+template <class T, int N>
+void static_vector<T, N>::insert(size_t at, const T & t)
+{
+	T *	data = (T*)_space;
+	new (data + _size)T();
+	for(size_t i=_size; i>at; i--)
+		data[i] = move(data[i - 1]);
+	data[at] = t;
+	_size++;
+}
+
+template <class T, int N>
+void static_vector<T, N>::erase(size_t at, size_t n)
+{
+	T *	data = (T*)_space;
+	_size -= n;
+	for(size_t i=at; i<_size; i++)
+		data[i] = move(data[i + n]);
+	for(size_t i=0; i<n; i++)
+		data[_size + i].~T();
+}
+
+template <class T, int N>
+T * static_vector<T, N>::insert(T * at, const T & t)
+{
+#ifdef CAPACITYCHECK
+	if (_size >= N) debugcrash();
+#endif
+	T *	data = (T*)_space;
+	T * dp = data + _size;
+	new (dp)T();
+	while (dp != at)
+	{
+		dp--;
+		dp[1] = move(dp[0]);
+	}
+	dp[0] = t;
+	_size++;
+	return dp + 1;
+}
+
+}
+#endif
+

include/opp/string.cpp

@@ -1,6 +1,9 @@
 #include "string.h"
 #include <string.h>
 #include <stdlib.h>
+#include <math.h>
+
+namespace opp {
 
 static inline void smemcpy(char * dp, const char * sp, char s)
 {
@@ -16,6 +19,11 @@ static inline char sstrlen(const char * sp)
 	return n;
 }
 
+inline void swap(string & u, string & v)
+{
+	char * p = u.cstr; u.cstr = v.cstr; v.cstr = p;
+}
+
 string::string(void) : cstr(nullptr)
 {}
 
@@ -24,21 +32,32 @@ string::string(const string & s)
 	if (s.cstr)
 	{
 		char l = s.cstr[0];
-		cstr = malloc(char(l + 2));
+		cstr = (char *)malloc(char(l + 2));
 		smemcpy(cstr, s.cstr, l + 2);
 	}
 	else
 		cstr = nullptr;
 }
 
+string::string(string && s)
+	: cstr(s.cstr)
+{
+	s.cstr = nullptr;
+}
+
 string::string(const char * s)
 {
-	char l = sstrlen(s);
+	if (s)
-	if (l)
 	{	
-		cstr = malloc(char(l + 2));
+		char l = sstrlen(s);
-		cstr[0] = l;
+		if (l)
-		smemcpy(cstr + 1, s, l + 1);
+		{
+			cstr = (char *)malloc(char(l + 2));
+			cstr[0] = l;
+			smemcpy(cstr + 1, s, l + 1);
+		}
+		else
+			cstr = nullptr;
 	}
 	else
 		cstr = nullptr;
@@ -48,9 +67,10 @@ string::string(const char * s, char size)
 {
 	if (size)
 	{
-		cstr = malloc(char(size + 2));
+		cstr = (char *)malloc(char(size + 2));
 		cstr[0] = size;
-		smemcpy(cstr + 1, s, size + 1);
+		smemcpy(cstr + 1, s, size);
+		cstr[size + 1] = 0;
 	}
 	else
 		cstr = nullptr;	
@@ -58,7 +78,7 @@ string::string(const char * s, char size)
 
 string::string(char c)
 {
-	cstr = malloc(3);
+	cstr = (char *)malloc(3);
 	cstr[0] = 1;
 	cstr[1] = c;
 	cstr[2] = 0;
@@ -76,6 +96,12 @@ string::~string(void)
 	free(cstr);
 }
 
+void string::clear(void)
+{
+	free(cstr);
+	cstr = nullptr;	
+}
+	
 void string::copyseg(char * p, char at, char num) const
 {
 	smemcpy(p, cstr + 1 + at, num);
@@ -89,7 +115,7 @@ string & string::operator=(const string & s)
 		if (s.cstr)
 		{
 			char l = s.cstr[0];
-			cstr = malloc(char(l + 2));
+			cstr = (char *)malloc(char(l + 2));
 			smemcpy(cstr, s.cstr, l + 2);
 		}
 		else
@@ -99,15 +125,32 @@ string & string::operator=(const string & s)
 	return *this;
 }
 
+string & string::operator=(string && s)
+{
+	if (cstr != s.cstr)	
+	{
+		free(cstr);
+		cstr = s.cstr;
+		s.cstr = nullptr;
+	}
+
+	return *this;
+}
+
 string & string::operator=(const char * s)
 {
 	free(cstr);
-	char l = sstrlen(s);
+	if (s)
-	if (l)
 	{
-		cstr = malloc(char(l + 2));
+		char l = sstrlen(s);
-		cstr[0] = l;		
+		if (l)
-		smemcpy(cstr + 1, s, l + 1);
+		{
+			cstr = (char *)malloc(char(l + 2));
+			cstr[0] = l;		
+			smemcpy(cstr + 1, s, l + 1);
+		}
+		else
+			cstr = nullptr;
 	}
 	else
 		cstr = nullptr;
@@ -119,46 +162,46 @@ string & string::operator+=(const string & s)
 {
 	if (s.cstr)
 	{
+		char d = 0;
 		if (cstr)
-		{
+			d = cstr[0];
-			char l = cstr[0] + s.cstr[0];
+
-			char * c = malloc(char(l + 2));
+		char l = s.cstr[0] + d;
-			c[0] = l;
+		char * c = (char *)malloc(char(l + 2));
-			smemcpy(c + 1, cstr + 1, cstr[0]);
+		c[0] = l;
-			smemcpy(c + 1 + cstr[0], s.cstr + 1, s.cstr[0] + 1);
+
-			free(cstr);
+		if (d)
-			cstr = c;
+			smemcpy(c + 1, cstr + 1, d);
-		}
+		smemcpy(c + 1 + d, s.cstr + 1, s.cstr[0] + 1);
-		else
+		free(cstr);
-		{
+		cstr = c;
-			char l = s.cstr[0];
-			cstr = malloc(char(l + 2));
-			smemcpy(cstr, s.cstr, l + 2);
-		}
 	}
 	return *this;
 }
 
 string & string::operator+=(const char * s)
 {
-	char sl = sstrlen(s);
+	if (s)
-	if (sl)
 	{
-		if (cstr)
+		char sl = sstrlen(s);
+		if (sl)
 		{
-			char l = sl + cstr[0];
+			if (cstr)
-			char * c = malloc(char(l + 2));
+			{
-			c[0] = l;
+				char l = sl + cstr[0];
-			smemcpy(c + 1, cstr + 1, cstr[0]);
+				char * c = (char *)malloc(char(l + 2));
-			smemcpy(c + 1 + cstr[0], s, sl + 1);
+				c[0] = l;
-			free(cstr);
+				smemcpy(c + 1, cstr + 1, cstr[0]);
-			cstr = c;
+				smemcpy(c + 1 + cstr[0], s, sl + 1);
-		}
+				free(cstr);
-		else
+				cstr = c;
-		{
+			}
-			cstr = malloc(char(sl + 2));
+			else
-			cstr[0] = sl;
+			{
-			smemcpy(cstr + 1, s, sl + 1);
+				cstr = (char *)malloc(char(sl + 2));
+				cstr[0] = sl;
+				smemcpy(cstr + 1, s, sl + 1);
+			}
 		}
 	}
 	return *this;
@@ -169,23 +212,28 @@ string & string::operator+=(char c)
 	if (cstr)
 	{
 		char l = cstr[0] + 1;
-		char * p = malloc(char(l + 2));
+		char * p = (char *)malloc(char(l + 2));
 		p[0] = l;
 		smemcpy(p + 1, cstr + 1, cstr[0]);
 		p[l] = c;
 		p[l + 1] = 0;
 		free(cstr);
-		cstr = c;
+		cstr = p;
 	}
 	else
 	{
-		cstr = malloc(3);
+		cstr = (char *)malloc(3);
 		cstr[0] = 1;
 		cstr[1] = c;
 		cstr[2] = 0;
 	}	
+	return *this;
 }
 
+inline const char * string::c_str(void) const
+{
+	return this->tocstr();
+}
 
 inline const char * string::tocstr(void) const
 {
@@ -210,7 +258,7 @@ string string::operator+(const string & s) const
 		if (s.cstr)
 		{
 			char l = cstr[0] + s.cstr[0];
-			char * p = malloc(char(l + 2));
+			char * p = (char *)malloc(char(l + 2));
 			smemcpy(p + 1, cstr + 1, cstr[0]);
 			smemcpy(p + 1 + cstr[0], s.cstr + 1, s.cstr[0]);
 			return string(l, p);
@@ -226,14 +274,19 @@ string string::operator+(const char * s) const
 {
 	if (cstr)
 	{
-		char sl = sstrlen(s);
+		if (s)
-		if (sl)
 		{
-			char l = cstr[0] + sl;
+			char sl = sstrlen(s);
-			char * p = malloc(char(l + 2));
+			if (sl)
-			smemcpy(p + 1, cstr + 1, cstr[0]);
+			{
-			smemcpy(p + 1 + cstr[0], s, sl);
+				char l = cstr[0] + sl;
-			return string(l, p);
+				char * p = (char *)malloc(char(l + 2));
+				smemcpy(p + 1, cstr + 1, cstr[0]);
+				smemcpy(p + 1 + cstr[0], s, sl);
+				return string(l, p);
+			}
+			else
+				return *this;
 		}
 		else
 			return *this;
@@ -247,7 +300,7 @@ string string::operator+(char c) const
 	if (cstr)
 	{
 		char l = cstr[0] + 1;
-		char * p = malloc(char(l + 2));
+		char * p = (char *)malloc(char(l + 2));
 		smemcpy(p + 1, cstr + 1, cstr[0]);
 		p[l] = c;
 		return string(l, p);
@@ -434,17 +487,48 @@ inline char string::operator[](char t) const
 	return cstr[t + 1];
 }
 
+char * string::begin(void)
+{
+	return cstr ? cstr + 1 : nullptr;
+}
+
+const char * string::begin(void) const
+{
+	return cstr ? cstr + 1 : nullptr;
+}
+
+const char * string::cbegin(void) const
+{
+	return cstr ? cstr + 1 : nullptr;
+}
+
+char * string::end(void)
+{
+	return cstr ? cstr + 1 + cstr[0] : nullptr;
+}
+
+const char * string::end(void) const
+{
+	return cstr ? cstr + 1 + cstr[0] : nullptr;
+}
+
+const char * string::cend(void) const
+{
+	return cstr ? cstr + 1 + cstr[0] : nullptr;
+}
+
+
 string string::substr(char pos, char len) const
 {
 	if (!cstr || len == 0 || pos >= cstr[0])
-		return string;
+		return string();
 	else
 	{
 		char l = cstr[0];
 		if (pos + len > l)
 			len = l - pos;
 
-		char * p = malloc(len + 2);
+		char * p = (char *)malloc(len + 2);
 		memcpy(p + 1, cstr + 1 + pos, len);
 		return string(len, p);
 	}
@@ -532,3 +616,522 @@ int string::find(char c, char pos) const
 
 	return -1;
 }
+
+string to_string(int val)
+{
+	char	buffer[10];
+
+	bool sign = false;
+	if (val < 0)
+	{
+		val = -val;
+		sign = true;
+	}
+
+	char i = 10;
+
+	while (val)
+	{
+		char d = val % 10;
+		val /= 10;
+		buffer[--i] = d + '0';
+	}
+
+	if (i == 10)
+		buffer[--i] = '0';
+	if (sign)
+		buffer[--i] = '-';
+
+	return string(buffer + i, 10 - i);
+}
+
+string to_string(long val)
+{
+	char	buffer[12];
+
+	bool sign = false;
+	if (val < 0)
+	{
+		val = -val;
+		sign = true;
+	}
+
+	char i = 12;
+
+	while (val)
+	{
+		char d = val % 10;
+		val /= 10;
+		buffer[--i] = d + '0';
+	}
+
+	if (i == 12)
+		buffer[--i] = '0';
+	if (sign)
+		buffer[--i] = '-';
+
+	return string(buffer + i, 12 - i);
+}
+
+string to_string(unsigned int val)
+{
+	char	buffer[10];
+
+	char i = 10;
+
+	while (val)
+	{
+		char d = val % 10;
+		val /= 10;
+		buffer[--i] = d + '0';
+	}
+
+	if (i == 10)
+		buffer[--i] = '0';
+
+	return string(buffer + i, 10 - i);
+}
+
+string to_string(unsigned long val)
+{
+	char	buffer[12];
+
+	char i = 12;
+
+	while (val)
+	{
+		char d = val % 10;
+		val /= 10;
+		buffer[--i] = d + '0';
+	}
+
+	if (i == 12)
+		buffer[--i] = '0';
+
+	return string(buffer + i, 12 - i);
+}
+
+static float fround5[] = {
+	0.5e-0, 0.5e-1, 0.5e-2, 0.5e-3, 0.5e-4, 0.5e-5, 0.5e-6
+};
+
+string to_string(float val)
+{
+	char	buffer[20];
+
+	char	d = 0;
+
+	float	f = val;
+
+	if (f < 0.0)
+	{
+		f = -f;
+		buffer[d++] = '-';
+	}
+		
+	char prefix = d;
+
+	if (isinf(f))
+	{
+		buffer[d++] = 'I';
+		buffer[d++] = 'N';
+		buffer[d++] = 'F';
+	}
+	else
+	{
+		int	exp = 0;
+
+		char	fdigits = 6;
+
+		if (f != 0.0)
+		{
+			while (f >= 1000.0)
+			{
+				f /= 1000;
+				exp += 3;
+			}
+
+			while (f < 1.0)
+			{
+				f *= 1000;
+				exp -= 3;
+			}
+
+			while (f >= 10.0)
+			{
+				f /= 10;
+				exp ++;
+			}
+			
+		}
+		
+		char digits = fdigits + 1;
+
+		while (exp < 0)
+		{
+			f /= 10.0;
+			exp++;
+		}
+
+		digits = fdigits + exp + 1;
+
+		if (digits < 7)
+			f += fround5[digits - 1];
+		else
+			f += fround5[6];
+
+		if (f >= 10.0)
+		{
+			f /= 10.0;
+			fdigits--;
+		}			
+
+		char	pdigits = digits - fdigits;
+
+		if (digits > 20)
+			digits = 20;
+
+		if (pdigits == 0)
+			buffer[d++] = '0';
+
+		for(char i=0; i<digits; i++)
+		{
+			if (i == pdigits)
+				buffer[d++] = '.';
+			if (i > 6)
+				buffer[d++] = '0';
+			else
+			{
+				int c = (int)f;
+				f -= (float)c;
+				f *= 10.0;
+				buffer[d++] = c + '0';
+			}
+		}
+	}
+
+	return string(buffer, d);
+}
+
+
+int string::to_int(char * idx, char base) const
+{
+	char i = 1;
+	unsigned n = 0;
+	bool sign = false;
+
+	if (cstr)
+	{
+		const char * cp = cstr;
+
+		char ch = cp[i];
+
+		if (ch == '-')
+		{
+			sign = true;
+			ch = cp[++i];
+		}
+		else if (ch == '+')
+			ch = cp[++i];
+
+		if (ch == '0' && base == 0)
+		{
+			ch = cp[++i];
+			if (ch == 'x' || ch == 'X')	
+			{
+				base = 16;
+				ch = cp[++i];
+			}
+			else if (ch == 'b' || ch == 'B')
+			{
+				base = 2;
+				ch = cp[++i];			
+			}
+		}
+
+		for(;;)
+		{
+			char d;
+			if (ch >= '0' && ch <= '9')
+				d = (ch - '0');
+			else if (base > 10 && ch >= 'A' && ch <= 'F')
+				d = (ch - 'A' + 10);
+			else if (base > 10 && ch >= 'a' && ch <= 'f')
+				d = (ch - 'a' + 10);
+			else
+				break;
+
+			n = n * base + d;
+			ch = cp[++i];
+		}
+	}
+
+	if (idx)
+		*idx = i - 1;
+
+	if (sign)
+		return -(int)n;
+	else
+		return n;
+}
+
+long string::to_long(char * idx, char base) const
+{
+	char i = 1;
+	unsigned long n = 0;
+	bool sign = false;
+
+	if (cstr)
+	{
+		const char * cp = cstr;
+
+		char ch = cp[i++];
+
+		if (ch == '-')
+		{
+			sign = true;
+			ch = cp[i++];
+		}
+		else if (ch == '+')
+			ch = cp[i++];
+
+		if (ch == '0' && base == 0)
+		{
+			ch = cp[i++];
+			if (ch == 'x' || ch == 'X')	
+			{
+				base = 16;
+				ch = cp[i++];
+			}
+			else if (ch == 'b' || ch == 'B')
+			{
+				base = 2;
+				ch = cp[i++];			
+			}
+		}
+
+		for(;;)
+		{
+			char d;
+			if (ch >= '0' && ch <= '9')
+				d = (ch - '0');
+			else if (base > 10 && ch >= 'A' && ch <= 'F')
+				d = (ch - 'A' + 10);
+			else if (base > 10 && ch >= 'a' && ch <= 'f')
+				d = (ch - 'a' + 10);
+			else
+				break;
+
+			n = n * base + d;
+			ch = cp[i++];
+		}
+		i--;
+	}
+
+	if (idx)
+		*idx = i - 1;
+
+	if (sign)
+		return -(long)n;
+	else
+		return n;
+}
+
+unsigned string::to_uint(char * idx, char base) const
+{
+	char i = 1;
+	unsigned n = 0;
+
+	if (cstr)
+	{
+		const char * cp = cstr;
+
+		char ch = cp[i];
+
+		if (ch == '0' && base == 0)
+		{
+			ch = cp[++i];
+			if (ch == 'x' || ch == 'X')	
+			{
+				base = 16;
+				ch = cp[++i];
+			}
+			else if (ch == 'b' || ch == 'B')
+			{
+				base = 2;
+				ch = cp[++i];			
+			}
+		}
+
+		for(;;)
+		{
+			char d;
+			if (ch >= '0' && ch <= '9')
+				d = (ch - '0');
+			else if (base > 10 && ch >= 'A' && ch <= 'F')
+				d = (ch - 'A' + 10);
+			else if (base > 10 && ch >= 'a' && ch <= 'f')
+				d = (ch - 'a' + 10);
+			else
+				break;
+
+			n = n * base + d;
+			ch = cp[++i];
+		}
+	}
+
+	if (idx)
+		*idx = i - 1;
+
+	return n;
+}
+
+unsigned long string::to_ulong(char * idx, char base) const
+{
+	char i = 1;
+	unsigned long n = 0;
+
+	if (cstr)
+	{
+		const char * cp = cstr;
+
+		char ch = cp[i++];
+
+		if (ch == '0' && base == 0)
+		{
+			ch = cp[i++];
+			if (ch == 'x' || ch == 'X')	
+			{
+				base = 16;
+				ch = cp[i++];
+			}
+			else if (ch == 'b' || ch == 'B')
+			{
+				base = 2;
+				ch = cp[i++];			
+			}
+		}
+
+		for(;;)
+		{
+			char d;
+			if (ch >= '0' && ch <= '9')
+				d = (ch - '0');
+			else if (base > 10 && ch >= 'A' && ch <= 'F')
+				d = (ch - 'A' + 10);
+			else if (base > 10 && ch >= 'a' && ch <= 'f')
+				d = (ch - 'a' + 10);
+			else
+				break;
+
+			n = n * base + d;
+			ch = cp[i++];
+		}
+		i--;
+	}
+
+	if (idx)
+		*idx = i - 1;
+
+	return n;
+}
+
+float string::to_float(char * idx) const
+{
+	char 	i = 1;
+	float 	vf = 0;
+	bool	sign = false;
+
+	if (cstr)
+	{
+		const char * cp = cstr;
+
+		char ch = cp[i++];
+		if (ch == '-')
+		{
+			sign = true;
+			ch = cp[i++];
+		}
+		else if (ch == '+')
+			ch = cp[i++];
+			
+		if (ch >= '0' && ch <= '9' || ch == '.')
+		{	
+			while (ch >= '0' && ch <= '9')
+			{
+				vf = vf * 10 + (int)(ch - '0');
+				ch = cp[i++];
+			}
+
+			if (ch == '.')
+			{
+				float	digits = 1.0;
+				ch = cp[i++];
+				while (ch >= '0' && ch <= '9')
+				{
+					vf = vf * 10 + (int)(ch - '0');
+					digits *= 10;
+					ch = cp[i++];
+				}
+				vf /= digits;
+			}
+
+			char	e = 0;
+			bool	eneg = false;								
+			
+			if (ch == 'e' || ch == 'E')
+			{
+				ch = cp[i++];
+				if (ch == '-')
+				{
+					eneg = true;
+					ch = cp[i++];
+				}
+				else if (ch == '+')
+				{
+					ch = cp[i++];
+				}
+					
+				while (ch >= '0' && ch <= '9')
+				{
+					e = e * 10 + ch - '0';
+					ch = cp[i++];
+				}
+				
+			}
+			
+			if (e)
+			{
+				if (eneg)
+				{
+					while (e > 6)
+					{
+						vf /= 1000000.0;
+						e -= 6;
+					}
+					vf /= tpow10[e];
+				}
+				else
+				{
+					while (e > 6)
+					{
+						vf *= 1000000.0;
+						e -= 6;
+					}
+					vf *= tpow10[e];
+				}
+			}
+		}	
+		i--;
+	}
+
+	if (idx)
+		*idx = i - 1;
+
+	if (sign)
+		return -vf;
+	else
+		return vf;	
+}
+
+}

include/opp/string.h

@@ -1,14 +1,19 @@
 #ifndef OPP_STRING_H
 #define OPP_STRING_H
 
+namespace opp {
+
 class string
 {
 private:
 	char	*	cstr;
 
+	friend void swap(string & u, string & v);
+
 public:
 	string(void);
 	string(const string & s);
+	string(string && s);
 	string(const char * s);
 	string(const char * s, char size);
 	string(char c);
@@ -16,7 +21,10 @@ public:
 
 	unsigned size(void) const;
 
+	void clear(void);
+
 	string & operator=(const string & s);
+	string & operator=(string && s);
 	string & operator=(const char * s);
 
 	string & operator+=(const string & s);
@@ -51,6 +59,15 @@ public:
 	char & operator[](char t);
 	char operator[](char t) const;
 
+	char * begin(void);
+	const char * begin(void) const;
+	const char * cbegin(void) const;
+
+	char * end(void);
+	const char * end(void) const;
+	const char * cend(void) const;
+
+	const char * c_str(void) const;
 	const char * tocstr(void) const;
 
 	string substr(char pos, char len) const;
@@ -64,10 +81,30 @@ public:
 	int find(char c, char pos) const;
 
 	void copyseg(char * p, char at, char num) const;
+
+	int to_int(char * idx = nullptr, char base = 10) const;
+	long to_long(char * idx = nullptr, char base = 10) const;
+	unsigned to_uint(char * idx = nullptr, char base = 10) const;
+	unsigned long to_ulong(char * idx = nullptr, char base = 10) const;
+	float to_float(char * idx = nullptr) const;
 protected:
 	string(char l, char * b);
 };
 
+void swap(string & u, string & v);
+
+string to_string(int val);
+
+string to_string(long val);
+
+string to_string(unsigned int val);
+
+string to_string(unsigned long val);
+
+string to_string(float val);
+
+}
+
 #pragma compile("string.cpp")
 
 #endif

include/opp/utility.h

@@ -0,0 +1,40 @@
+#ifndef OPP_UTILITY_H
+#define OPP_UTILITY_H
+
+namespace opp {
+
+template <class T>
+inline T && move(T & m)
+{
+	return (T &&)m;
+}
+
+template <class T>
+inline void swap(T & x, T & y)
+{
+	T t(x); x = y; y = move(t);
+}
+
+
+template<class T1, class T2>
+struct pair
+{
+	T1	first;
+	T2	second;
+
+	pair(T1 && t1, T2 && t2)
+		: first(t1), second(t2)
+		{}
+};
+
+template<class T1, class T2>
+constexpr pair<T1, T2> make_pair(T1 && t1, T2 && t2)
+{
+	return pair<T1, T2>(t1, t2);
+}
+
+}
+
+
+
+#endif

include/opp/vector.h

@@ -0,0 +1,363 @@
+#ifndef OPP_VECTOR_H
+#define OPP_VECTOR_H
+
+#include <new>
+#include <stdlib.h>
+#include <opp/utility.h>
+
+namespace opp {
+
+template <class T>
+class vector
+{
+protected:
+	T	*	_data;
+	size_t	_size, _capacity;
+public:
+	typedef T 	element_type;
+
+	vector(void) : _data(nullptr), _size(0), _capacity(0) {}
+
+	vector(size_t n) : _data((T*)malloc(n * sizeof(T))), _size(n), _capacity(n) 
+	{
+		for(size_t i=0; i<n; i++)
+			new (_data + i) T();
+	}
+
+	vector(const vector & v)
+		: _data((T*)malloc(v._size * sizeof(T))), _size(v._size), _capacity(v._size) 
+	{
+		size_t n = _size;
+		for(size_t i=0; i<n; i++)
+			new (_data + i)T(v._data[i]);
+	}
+
+	vector(vector && v)
+		: _data(v._data), _size(v._size), _capacity(v._capacity)
+	{
+		v._data = nullptr;
+		v._size = 0;
+		v._capacity = 0;
+	}
+
+	~vector(void)
+	{
+		for(size_t i=0; i<_size; i++)
+			_data[i].~T();
+		free(_data);
+	}
+
+	vector & operator=(const vector & v)
+	{
+		if (this != &v)
+		{
+			size_t n = _size;
+			for(size_t i=0; i<n; i++)
+				_data[i].~T();
+			free(_data);
+
+			_data = (T*)malloc(v._size * sizeof(T));
+			_size = v._size; 
+			_capacity = v._size; 
+			n = _size;
+			for(size_t i=0; i<n; i++)
+				new (_data + i)T(v._data[i]);		
+		}
+		return *this;
+	}
+
+	vector & operator=(vector && v)
+	{
+		if (this != &v)
+		{
+			swap(_data, v._data);
+			swap(_size, v._size);
+			swap(_capacity, v._capacity);
+		}
+		return *this;
+	}
+
+	int size(void) const
+	{
+		return _size;
+	}
+
+	int max_size(void) const
+	{
+		return 32767;
+	}
+
+	bool empty(void) const
+	{
+		return _size == 0;
+	}
+
+	int capacity(void) const
+	{
+		return _capacity;
+	}
+
+	void clear(void);
+
+	void resize(size_t n);
+
+	void reserve(size_t n);
+
+	void shrink_to_fit(void);
+
+	T & at(size_t at)
+	{
+		return _data[at];
+	}
+
+	const T & at(size_t at) const
+	{
+		return _data[at];
+	}
+
+	T & operator[](size_t at)
+	{
+		return _data[at];
+	}
+
+	const T & operator[](size_t at) const
+	{
+		return _data[at];
+	}
+
+	T * begin(void)
+	{
+		return _data;
+	}
+
+	const T * begin(void) const
+	{
+		return _data;
+	}
+
+	const T * cbegin(void) const
+	{
+		return _data;
+	}
+
+	T * end(void)
+	{
+		return _data + _size;
+	}
+
+	const T * end(void) const
+	{
+		return _data + _size;
+	}
+
+	const T * cend(void) const
+	{
+		return _data + _size;
+	}
+
+	T & front(void)
+	{
+		return _data[0];
+	}
+
+	const T & front(void) const
+	{
+		return _data[0];
+	}
+
+	T & back(void)
+	{
+		return _data[_size - 1];
+	}
+
+	const T & back(void) const
+	{
+		return _data[_size - 1];
+	}
+
+	T * data(void)
+	{
+		return _data;
+	}
+
+	const T * at(void) const
+	{
+		return _data;
+	}
+
+	void push_back(const T & t);
+
+	void push_back(T && t);
+
+	void pop_back(void)
+	{
+		_size--;
+		_data[_size].~T();
+	}
+
+	void assign(size_t count, const T & t);
+
+	void insert(size_t at, const T & t);
+
+	void erase(size_t at, size_t n = 1);
+
+	T * insert(T * at, const T & t);
+
+	template <typename ...P>
+	void emplace_back(const P&... p);
+protected:
+	T * add_back(void);
+};
+
+
+template <class T>
+__noinline void vector<T>::reserve(size_t n)
+{
+	if (n > _capacity)
+	{
+		_capacity = n;
+		T * d = (T *)malloc(_capacity * sizeof(T));
+		for(size_t i=0; i<_size; i++)
+		{
+			new (d + i)T(move(_data[i]));
+			_data[i].~T();
+		}
+		free(_data);
+		_data = d;
+	}
+}
+
+template <class T>
+void vector<T>::clear(void)
+{
+	for(size_t i=0; i<_size; i++)
+		_data[i].~T();			
+	_size = 0;
+}
+
+template <class T>
+__noinline void vector<T>::resize(size_t n)
+{
+	if (n < _size)
+	{
+		for(size_t i=n; i<_size; i++)
+			_data[i].~T();			
+		_size = n;
+	}
+	else if (n < _capacity)
+	{
+		for(size_t i=_size; i<n; i++)
+			new(_data + i)T();
+		_size = n;
+	}
+	else
+	{
+		reserve(n);
+		_size = n;
+	}
+}
+
+template <class T>
+void vector<T>::shrink_to_fit(void)
+{
+	if (_size < _capacity)
+	{
+		_capacity = _size;
+		T * d = (T *)malloc(_capacity * sizeof(T));
+		for(size_t i=0; i<_size; i++)
+		{
+			new (d + i)T(move(_data[i]));
+			_data[i].~T();
+		}
+		free(_data);
+		_data = d;
+	}
+}
+
+template <class T>
+T * vector<T>::add_back(void)
+{
+	if (_size == _capacity)
+		reserve(_size + 1 + (_size >> 1));
+	return _data + _size++;
+}
+
+template <class T>
+void vector<T>::push_back(const T & t)
+{
+	new (add_back())T(t);
+}
+
+template <class T>
+void vector<T>::push_back(T && t)
+{
+	new (add_back())T(t);
+}
+
+template <class T>
+template <typename ...P>
+void vector<T>::emplace_back(const P&... p)
+{
+	new (add_back())T(p...);
+}
+
+template <class T>
+void vector<T>::assign(size_t count, const T & t)
+{
+	for(size_t i=0; i<_size; i++)
+		_data[i].~T();
+	if (count > _capacity)
+	{
+		_size = 0;
+		reserve(count);		
+	}
+	for(size_t i=0; i<count; i++)
+		new (_data + i)T(t);
+	_size = count;
+}
+
+template <class T>
+void vector<T>::insert(size_t at, const T & t)
+{
+	if (_size == _capacity)
+		reserve(_size + 1 + (_size >> 1));
+	new (_data + _size)T();
+	for(size_t i=_size; i>at; i--)
+		_data[i] = move(_data[i - 1]);
+	_data[at] = t;
+	_size++;
+}
+
+template <class T>
+void vector<T>::erase(size_t at, size_t n)
+{
+	_size -= n;
+	for(size_t i=at; i<_size; i++)
+		_data[i] = move(_data[i + n]);
+	for(size_t i=0; i<n; i++)
+		_data[_size + i].~T();
+}
+
+template <class T>
+T * vector<T>::insert(T * at, const T & t)
+{
+	if (_size == _capacity)
+	{
+		unsigned f = unsigned(at) - unsigned(_data);
+		reserve(_size + 1 + (_size >> 1));
+		at = (T *)(f + unsigned(_data));
+	}
+	T * dp = _data + _size;
+	new (dp)T();
+	while (dp != at)
+	{
+		dp--;
+		dp[1] = move(dp[0]);
+	}
+	dp[0] = t;
+	_size++;
+	return dp + 1;
+}
+
+}
+#endif

include/oscar.c

@@ -86,3 +86,53 @@ const char * oscar_expand_rle(char * dp, const char * sp)
 
 	return sp + 1;
 }
+
+__native const char * oscar_expand_lzo_buf(char * dp, const char * sp)
+{
+	char	buf[256];
+	char	b = 0;
+
+	char	cmd = sp[0];
+	do
+	{
+		if (cmd & 0x80)
+		{
+			char i = b - sp[1];
+			cmd &= 0x7f;
+			sp += 2;
+
+			char n = 0;
+			do 	{
+				buf[b] = dp[n] = buf[i];
+				b++;
+				i++;
+				n++;
+			} while (n != cmd);
+		}
+		else
+		{
+			sp += 1;
+
+			char n = 0;
+			do 	{
+				buf[b] = dp[n] = sp[n];
+				b++;
+				n++;
+			} while (n != cmd);
+
+			sp += cmd;
+		}
+		dp += cmd;
+
+		cmd = sp[0];
+	} while (cmd);
+
+	return sp + 1;
+}
+
+void debugcrash(void)
+{
+	__asm volatile {
+		byt $02
+	}
+}

include/oscar.h

@@ -6,6 +6,19 @@ __native const char * oscar_expand_lzo(char * dp, const char * sp);
 
 __native const char * oscar_expand_rle(char * dp, const char * sp);
 
+// Same as oscar_expand_lzo, but does not need read access to the
+// target memory area.  On the downside, it uses 256 bytes of stack
+// memory as buffer
+__native const char * oscar_expand_lzo_buf(char * dp, const char * sp);
+
+// Write a breakpoint instruction into the .lbl file for vice.  This
+// intrinsic function will change the behaviour of the optimizer to ensure 
+// that the breakpoint is not move around into wild places.
+void breakpoint(void);
+
+#pragma intrinsic(breakpoint)
+
+void debugcrash(void);
 
 #pragma compile("oscar.c")
 

include/stdio.c

@@ -2,237 +2,50 @@
 #include "conio.h"
 #include "stdlib.h"
 
-#if defined(__C128__)
-#pragma code(lowcode)
-__asm bsout
-{	
-		ldx #0
-		stx 0xff00
-		jsr 0xffd2
-		sta 0xff01
-}
-__asm bsplot
-{	
-		lda #0
-		sta 0xff00
-		jsr 0xfff0
-		sta 0xff01
-}
-__asm bsin
-{
-		lda #0
-		sta 0xff00
-		jsr 0xffcf
-		sta 0xff01	
-}
-
-#pragma code(code)
-#elif defined(__PLUS4__)
-#pragma code(lowcode)
-__asm bsout
-{	
-		sta 0xff3e
-		jsr 0xffd2
-		sta 0xff3f
-}
-__asm bsin
-{
-		sta 0xff3e
-		jsr 0xffe4
-		sta 0xff3f
-}
-__asm bsplot
-{	
-		sta 0xff3e
-		jsr 0xfff0
-		sta 0xff3f
-}
-#pragma code(code)
-#elif defined(__ATARI__)
-__asm bsout
-{
-		tax
-		lda	0xe407
-		pha
-		lda 0xe406
-		pha
-		txa
-}
-
-__asm bsin
-{
-		lda	0xe405
-		pha
-		lda 0xe404
-		pha
-}
-
-__asm bsplot
-{
-
-}
-
-#else
-#define bsout	0xffd2
-#define bsplot	0xfff0
-#define bsin	0xffcf
-#endif
-
-__asm putpch
-{
-#if defined(__ATARI__)
-		cmp #10
-		bne	w1
-		lda #0x9b
-	w1:
-		jmp	bsout
-#else
-		ldx	giocharmap
-		cpx	#IOCHM_ASCII
-		bcc	w3
-
-		cmp #10
-		bne	w1
-		lda #13
-	w1:
-		cmp #9
-		beq t1
-
-		cpx	#IOCHM_PETSCII_1
-		bcc	w3
-
-		cmp #65
-		bcc w3
-		cmp	#123
-		bcs	w3
-#if defined(__CBMPET__)
-		cmp	#97
-		bcs	w4
-		cmp #91
-		bcs	w3
-	w2:
-		eor	#$a0
-	w4:
-		eor #$20
-
-#else
-		cmp	#97
-		bcs	w2
-		cmp #91
-		bcs	w3
-	w2:
-		eor	#$20
-#endif
-		cpx #IOCHM_PETSCII_2
-		beq	w3
-		and #$df
-	w3:
-		jmp	bsout
-	t1:
-		sec
-		jsr bsplot
-		tya
-		and	#3
-		eor #3
-		tax
-		lda #$20
-	l1:
-		jsr bsout
-		dex
-		bpl l1
-#endif		
-}
-
-__asm getpch
-{
-		jsr	bsin
-#if !defined(__ATARI__)
-		ldx	giocharmap
-		cpx	#IOCHM_ASCII
-		bcc	w3
-
-		cmp	#13
-		bne	w1
-		lda #10
-	w1:
-		cpx	#IOCHM_PETSCII_1
-		bcc	w3
-
-		cmp #219
-		bcs w3
-		cmp #65
-		bcc w3
-
-		cmp #193
-		bcc w4
-		eor #$a0
-	w4:
-		cmp	#123
-		bcs	w3
-		cmp	#97
-		bcs	w2
-		cmp #91
-		bcs	w3
-	w2:
-		eor	#$20
-	w3:
-#endif	
-}
-
 void putchar(char c)
 {
-	__asm {
+	putpch(c);
-		lda c
-		jmp	putpch
-	}
 }
 
 char getchar(void)
 {
-	__asm {
+	return getpch();
-		jsr	getpch
-		sta	accu
-		lda	#0
-		sta	accu + 1
-	}
 }
 
 void puts(const char * str)
 {
-	__asm {
+	while (char ch = *str++)
-	ploop:
+		putpch(ch);
-		ldy	#0
-		lda	(str), y
-		beq	pdone
-	
-		jsr	putpch
-
-		inc	str
-		bne	ploop
-		inc	str + 1
-		bne	ploop
-	pdone:
-	}
 }
 
 char * gets(char * str)
 {
-	__asm {
+	char i = 0;
-	gloop:
+	while ((char ch = getpch()) != '\n')
-		jsr	getpch
+		str[i++] = ch;
-		ldy	#0
+	str[i] = 0;
-		cmp	#10
+	return str;
-		beq	gdone
+}
-		sta	(str), y
-		inc	str
-		bne	gloop
-		inc	str + 1
-		bne	gloop
-	gdone:		
-		lda	#0
-		sta	(str), y
-	}
 
+char * gets_s(char * str, size_t n)
+{
+	if (str == NULL)
+		return NULL;
+
+	if (n < 2)
+		return NULL;
+	char i = 0, t = n - 1;
+
+	while ((char ch = getpch()) != '\n')
+	{
+		if (i < t)
+			str[i] = ch;
+		++i;
+	}
+	str[(i < t) ? i : t] = '\0';
+
+	if (i > t)
+		return NULL;
 	return str;
 }
 
@@ -279,10 +92,7 @@ int nformi(const sinfo * si, char * str, int v, bool s)
 	while (u > 0)
 	{
 		int	c = u % si->base;
-		if (c >= 10)
+		c += c >= 10 ? 'A' - 10 : '0';
-			c += 'A' - 10;
-		else
-			c += '0';
 		buffer[--i] = c;
 		u /= si->base;
 	}
@@ -340,10 +150,7 @@ int nforml(const sinfo * si, char * str, long v, bool s)
 	while (u > 0)
 	{
 		int	c = u % si->base;
-		if (c >= 10)
+		c += c >= 10 ? 'A' - 10 : '0';
-			c += 'A' - 10;
-		else
-			c += '0';
 		buffer[--i] = c;
 		u /= si->base;
 	}
@@ -589,7 +396,7 @@ char * sformat(char * buff, const char * fmt, int * fps, bool print)
 
 			if (c >= '0' && c <='9')
 			{
-				int i = 0;
+				char i = 0;
 				while (c >= '0' && c <='9')
 				{
 					i = i * 10 + c - '0';
@@ -600,7 +407,7 @@ char * sformat(char * buff, const char * fmt, int * fps, bool print)
 
 			if (c == '.')
 			{
-				int	i = 0;
+				char	i = 0;
 				c = *p++;
 				while (c >= '0' && c <='9')
 				{
@@ -610,36 +417,36 @@ char * sformat(char * buff, const char * fmt, int * fps, bool print)
 				si.precision = i;		
 			}
 
-			if (c == 'd')
+			if (c == 'd' || c == p'd' || c == 'i' || c == p'i')
 			{
 				bi = nformi(&si, bp, *fps++, true);
 			}
-			else if (c == 'u')
+			else if (c == 'u' || c == p'u')
 			{
 				bi = nformi(&si, bp, *fps++, false);
 			}
-			else if (c == 'x')
+			else if (c == 'x' || c == p'x')
 			{
 				si.base = 16;
 				bi = nformi(&si, bp, *fps++, false);
 			}
 #ifndef NOLONG
-			else if (c == 'l')
+			else if (c == 'l' || c == p'l')
 			{
 				long l = *(long *)fps;
 				fps ++;
 				fps ++;
 
 				c = *p++;
-				if (c == 'd')
+				if (c == 'd' || c == p'd')
 				{
 					bi = nforml(&si, bp, l, true);
 				}
-				else if (c == 'u')
+				else if (c == 'u' || c == p'u')
 				{
 					bi = nforml(&si, bp, l, false);
 				}
-				else if (c == 'x')
+				else if (c == 'x' || c == p'x')
 				{
 					si.base = 16;
 					bi = nforml(&si, bp, l, false);
@@ -647,14 +454,14 @@ char * sformat(char * buff, const char * fmt, int * fps, bool print)
 			}
 #endif
 #ifndef NOFLOAT
-			else if (c == 'f' || c == 'g' || c == 'e')
+			else if (c == 'f' || c == 'g' || c == 'e' || c == p'f' || c == p'g' || c == p'e')
 			{
 				bi = nformf(&si, bp, *(float *)fps, c);
 				fps ++;
 				fps ++;
 			}
 #endif			
-			else if (c == 's')
+			else if (c == 's' || c == p's')
 			{
 				char * sp = (char *)*fps++;
 
@@ -700,7 +507,7 @@ char * sformat(char * buff, const char * fmt, int * fps, bool print)
 					}						
 				}
 			}
-			else if (c == 'c')
+			else if (c == 'c' || c == p'c')
 			{
 				bp[bi++] = *fps++;
 			}
@@ -749,6 +556,17 @@ int sprintf(char * str, const char * fmt, ...)
 	return d - str;
 }
 
+void vprintf(const char * fmt, va_list vlist)
+{
+	char	buff[50];
+	sformat(buff, fmt, (int *)vlist, true);
+}
+
+int vsprintf(char * str, const char * fmt, va_list vlist)
+{
+	char * d = sformat(str, fmt, (int *)vlist, false);
+	return d - str;
+}
 
 static inline bool isspace(char c)
 {
@@ -862,7 +680,7 @@ int fpscanf(const char * fmt, int (* ffunc)(void * p), void * fparam, void ** pa
 					}
 				}
 				
-				if (fc == 'l')
+				if (fc == 'l' || fc == p'l')
 				{
 					islong = true;
 					fc = *fmt++;
@@ -877,11 +695,15 @@ int fpscanf(const char * fmt, int (* ffunc)(void * p), void * fparam, void ** pa
 						break;
 
 					case 'x':
+					case p'x':
 						base = 16;
 					case 'u':
+					case p'u':
 						issigned = false;
 					case 'i':
 					case 'd':
+					case p'i':
+					case p'd':
 					{
 						bool	sign = false;
 						if (cs == '-')
@@ -962,6 +784,9 @@ int fpscanf(const char * fmt, int (* ffunc)(void * p), void * fparam, void ** pa
 					case 'f':
 					case 'e':
 					case 'g':
+					case p'f':
+					case p'e':
+					case p'g':
 					{
 						bool	sign = false;
 						if (cs == '-')
@@ -1068,6 +893,7 @@ int fpscanf(const char * fmt, int (* ffunc)(void * p), void * fparam, void ** pa
 					} break;
 #endif
 					case 's':
+					case p's':
 					{
 						char	*	pch = (char *)*params;
 						while (width > 0 && cs > 0 && !isspace(cs))
@@ -1110,6 +936,7 @@ int fpscanf(const char * fmt, int (* ffunc)(void * p), void * fparam, void ** pa
 					}	break;
 
 					case 'c':
+					case p'c':
 					{
 						char	*	pch = (char *)*params;
 						if (!ignore)

include/stdio.h

@@ -2,7 +2,8 @@
 #define STDIO_H
 
 #include <stdlib.h>
-
+#include <stddef.h>
+#include <stdarg.h>
 
 void putchar(char c);
 
@@ -12,10 +13,16 @@ void puts(const char * str);
 
 char * gets(char * str);
 
+char * gets_s(char * str, size_t n);
+
 void printf(const char * fmt, ...);
 
 int sprintf(char * str, const char * fmt, ...);
 
+void vprintf(const char * fmt, va_list vlist);
+
+int vsprintf(char * str, const char * fmt, va_list vlist);
+
 int scanf(const char * fmt, ...);
 
 int sscanf(const char * str, const char * fmt, ...);

include/stdlib.c

@@ -7,20 +7,17 @@
 void itoa(int n, char * s, unsigned radix)
 {
 	bool neg = n < 0;
-	if (neg)
+	unsigned un = neg ? -n : n;
-	{
-		n = - n;
-	}
 	
 	char	i = 0;
     do {
-		int	d = n % radix;
+		unsigned	d = un % radix;
 		if (d < 10)
 			d += '0';
 		else
 			d += 'A' - 10;
 		s[i++] = d;
-    } while ((n /= radix) > 0);
+    } while ((un /= radix) > 0);
 
 	if (neg)
 	{
@@ -524,6 +521,12 @@ void exit(int status)
 	}
 }
 
+void abort(void)
+{
+	exit(-1);
+}
+
+
 extern struct Heap {
 	Heap	*	next, * end;
 }	HeapNode;
@@ -541,7 +544,7 @@ unsigned heapfree(void)
 }
 
 #if 0
-struct Heap {
+struct Heap {q
 	unsigned int	size;
 	Heap		*	next;
 }	*	freeHeap;
@@ -664,6 +667,97 @@ void * calloc(int num, int size)
 	return p;
 }
 
+void * realloc(void * ptr, unsigned size)
+{
+	if (ptr)
+	{
+#ifdef HEAPCHECK
+		Heap	*	pheap = (Heap *)((char *)ptr - 6);
+		Heap	*	eheap = pheap->next;
+
+		unsigned	psize = (char *)eheap - (char *)pheap;
+
+		void * nptr = malloc(size);
+		memcpy(nptr, ptr, psize - 6);
+		free(ptr);
+		return nptr;
+#else
+		unsigned	nsize = (size + 5) & ~3;
+
+		// Get heap info
+		Heap	*	pheap = (Heap *)((char *)ptr - 2);
+		Heap	*	eheap = pheap->next;
+
+		unsigned	psize = (char *)eheap - (char *)pheap;
+
+		Heap	*	h = HeapNode.next;
+		Heap	*	hp = &HeapNode;
+		while (h && h < pheap)
+		{
+			hp = h;
+			h = h->next;
+		}		
+
+		if (nsize <= psize)
+		{
+			// check if we should free some memory
+			if (nsize + sizeof(HeapNode) < psize)
+			{
+				Heap	*	nheap = (Heap *)((char *)pheap + nsize);
+				pheap->next = nheap;
+
+				if (h == eheap)
+				{
+					nheap->end = h->end;
+					nheap->next = h->next;
+				}
+				else 
+				{
+					nheap->end = eheap;
+					nheap->next = h;
+				}
+
+				hp->next = nheap;
+			}
+
+			return ptr;
+		}
+		else if (h == eheap)
+		{
+			// Free space after this
+
+			// Check if enough space if extending
+			unsigned	xsize = (char *)h->end - (char *)pheap;
+			if (xsize >= nsize)
+			{
+				if (xsize > nsize + sizeof(HeapNode))
+				{
+					Heap	*	nheap = (Heap *)((char *)pheap + nsize);
+					pheap->next = nheap;
+					nheap->end = h->end;
+					nheap->next = h->next;
+					hp->next = nheap;
+				}
+				else
+				{
+					pheap->next = h->end;
+					hp->next = h->next;
+				}
+
+				return ptr;
+			}
+		}
+
+		void * nptr = malloc(size);
+		memcpy(nptr, ptr, psize - 2);
+		free(ptr);
+		return nptr;
+#endif		
+	}
+	else
+		return malloc(size);
+}
+
 static unsigned seed = 31232;
 
 unsigned int rand(void)

include/stdlib.h

@@ -37,12 +37,16 @@ long labs(long n);
 
 void exit(int status);
 
+void abort(void);
+
 void * malloc(unsigned int size);
 
 void free(void * ptr);
 
 void * calloc(int num, int size);
 
+void * realloc(void * ptr, unsigned size);
+
 unsigned heapfree(void);
 
 unsigned int rand(void);

include/string.c

@@ -130,13 +130,28 @@ char * strcat(char * dst, const char * src)
 
 char * cpycat(char * dst, const char * src)
 {
-	do {} while (*dst++ = *src++);
+	while (*dst = *src++)
+		dst++;
 	
 	return dst;	
 }
 
 #pragma native(cpycat)
 
+char* strchr( const char* str, int ch )
+{
+	char * p = (char *)str;
+
+	while (*p != (char)ch)
+	{
+		if (!*p)
+			return nullptr;
+		p++;
+	}
+	return p;
+}
+
+
 void * memset(void * dst, int value, int size)
 {
 	__asm
@@ -222,8 +237,8 @@ void * memmove(void * dst, const void * src, int size)
 	int	sz = size;
 	if (sz > 0)
 	{
-		char		*	d = dst;
+		char		*	d = (char *)dst;
-		const char	*	s = src;
+		const char	*	s = (const char *)src;
 		if (d < s)
 		{
 			do {
@@ -244,7 +259,7 @@ void * memmove(void * dst, const void * src, int size)
 
 int memcmp(const void * ptr1, const void * ptr2, int size)
 {
-	const char	*	p = ptr1, * q = ptr2;
+	const char	*	p = (const char *)ptr1, * q = (const char *)ptr2;
 	char		c, d;
 
 	while (size--)

include/string.h

@@ -21,10 +21,16 @@ int memcmp(const void * ptr1, const void * ptr2, int size);
 
 void * memmove(void * dst, const void * src, int size);
 
+char* strchr( const char* str, int ch );
+
 #pragma intrinsic(strcpy)
 
 #pragma intrinsic(memcpy)
 
+#pragma intrinsic(memset)
+
+#pragma intrinsic(memclr)
+
 #pragma compile("string.c")
 
 #endif