Compare commits
No commits in common. "main" and "v1.0.20" have entirely different histories.
|
|
@ -335,22 +335,3 @@ ASALocalRun/
|
|||
*.asm
|
||||
*.map
|
||||
*.prg
|
||||
*.d
|
||||
*.d.*
|
||||
*.o
|
||||
*.lbl
|
||||
make/oscar64
|
||||
*.int
|
||||
*.bcs
|
||||
*.crt
|
||||
**/*.d64
|
||||
*.tlog
|
||||
*.res
|
||||
*.recipe
|
||||
*.exe
|
||||
*.dbj
|
||||
*.json
|
||||
*.mapd
|
||||
*.idb
|
||||
oscar64/Releasex64/oscar64.vcxproj.FileListAbsolute.txt
|
||||
/oscar64/Debugx64
|
||||
|
|
|
|||
|
|
@ -1,67 +0,0 @@
|
|||
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
|
||||
)
|
||||
|
||||
115
README.md
115
README.md
|
|
@ -1,40 +1,115 @@
|
|||
# oscar64
|
||||
Optimizing small space C Compiler Assembler and Runtime for C64
|
||||
|
||||
Oscar64 is a C/C++ cross compiler running on a modern system (such as a Windows PC, Mac or Linux machine) and targets the classic 6502 family of processors. It is mainly focused on Commodore systems such as the C64, PET or VIC20. The compiler supports C99 and many C++ features up to variadic templates and lambda functions.
|
||||
## History and motivation
|
||||
|
||||
The purpose of this compiler is to eliminate the need to write 6502 assembler code to achieve high code density and fast execution speed. It continues to improve with all the games, demos and tools written by it. It supports disk overlays and banked cartridges for larger projects.
|
||||
It is a sad fact that the 6502 used in the Commodore64 and other home computers of the 80s has a poor code density when it comes to 16 bit code. The C standard requires computations to be made with ints which work best if they have the same size as a pointer.
|
||||
|
||||
The C64 executes 442 dhrystone V2.2 iteration per second, when compiled with Oscar64 and -O3 (which shows that the ancient dhrystone benchmark is no match to an optimizing compiler).
|
||||
The 6502 also has a very small stack of 256 bytes which cannot be easily addressed and thus cannot be used for local variables. Therefore a second stack for variables has to be maintained, resulting in costly indexing operations.
|
||||
|
||||
[Full reference manual](oscar64.md)
|
||||
[Additional samples and tutorials](https://github.com/drmortalwombat/OscarTutorials)
|
||||
A C compiler for the 6502 thus generates large binaries if it translates to native machine code. The idea for the **oscar64** compiler is to translate the C source to an intermediate 16 bit byte code with the option to use native machine code for crucial functions. Using embedded assembly for runtime libraries or critical code should also be possible.
|
||||
|
||||
# References
|
||||
The resulting compiler is a frankenstein constructed from a converted javascript parser a intermediate code optimizer based on a 15 year old compiler for 64bit x86 code and some new components for the backend.
|
||||
|
||||
This is a list of the games written with Oscar64, have a look if you are not convinced that fast paced action games can be written in C/C++ on a C64 (they are all free).
|
||||
The performance of interpreted code is clearly not as good as native machine code but the penalty for 16bit code is around 40-50% and less than 10% for floating point. Code that can use 8bit my suffer up to a factor of 10 to 20.
|
||||
|
||||
[Ball and Chain](https://drmortalwombat.itch.io/ball-and-chain)
|
||||
## Limits and Errors
|
||||
|
||||
[Balls like a Frog](https://drmortalwombat.itch.io/balls-like-a-frog)
|
||||
The first release of the compiler is severely limited considering it is only two weeks old, so there is quite a lot missing or broken. I hope to cross out most of the problems in the coming weeks.
|
||||
|
||||
|
||||
[Corescape](https://drmortalwombat.itch.io/corescape)
|
||||
### Language
|
||||
|
||||
[MetalMayhem](https://drmortalwombat.itch.io/metal-mayhem)
|
||||
* No union type
|
||||
* No long integer
|
||||
* No struct function return
|
||||
* Missing const checks for structs and enums
|
||||
* No static variables in functions
|
||||
* Missing warnings for all kind of abuses
|
||||
* no #if in preprocessor
|
||||
|
||||
[Mineshaft Gap](https://drmortalwombat.itch.io/mineshaft-gap)
|
||||
### Linker
|
||||
|
||||
[Minotrace](https://drmortalwombat.itch.io/minotrace)
|
||||
* No explicit sections for code, data bss or stack
|
||||
* No media file import
|
||||
|
||||
[Missile Defence](https://drmortalwombat.itch.io/missile-defence)
|
||||
### Standard Libraries
|
||||
|
||||
|
||||
[Portal Buster](https://drmortalwombat.itch.io/portal-buster)
|
||||
* Limited formatting in printf
|
||||
* No file functions
|
||||
|
||||
### Runtime
|
||||
|
||||
* No INF and NaN support for floats
|
||||
* Underflow in float multiply and divide not checked
|
||||
* Basic zero page variables not restored on stop/restore
|
||||
|
||||
### Optimizing
|
||||
|
||||
* All global variables are considered volatile
|
||||
* No loop opmtimization
|
||||
* Poor bookeeping of callee saved registers
|
||||
* Missing livetime reduction of intermediates
|
||||
* No block domination analysis
|
||||
* No register use for arguments
|
||||
|
||||
### Intermediate code generation
|
||||
|
||||
* No check for running out of temporary registers
|
||||
* Wasted 7 codes for far jumps
|
||||
|
||||
### Native code generation
|
||||
|
||||
* Missing
|
||||
|
||||
## Implementation Details
|
||||
|
||||
The compiler does a full program compile, the linker step is part of the compilation. It knows all functions during the compilation run and includes only reachable code in the output. Source files are added to the build with the help of a pragma:
|
||||
|
||||
#pragma compile("stdio.c")
|
||||
|
||||
|
||||
The byte code interpreter is compiled by the compiler itself and placed in the source file "crt.c". Functions implementing byte codes are marked with a pragma:
|
||||
|
||||
#pragma bytecode(BC_CONST_P8, inp_const_p8)
|
||||
|
||||
The functions are written in 6502 assembly with the __asm keyword
|
||||
|
||||
__asm inp_const_p8
|
||||
{
|
||||
lda (ip), y
|
||||
tax
|
||||
iny
|
||||
lda (ip), y
|
||||
sta $00, x
|
||||
lda #0
|
||||
sta $01, x
|
||||
iny
|
||||
jmp startup.exec
|
||||
}
|
||||
|
||||
The current byte code program counter is (ip),y. The interpreter loop guarantees that y is always <= 128 and can thus be used to index the additional byte code arguments without the need to check the 16 bit pointer. The interpreter loop itself is quite compact and takes 21 cycles (including the final jump of the byte code function itself). Moving it to zero page would reduce this by another two cycles but is most likely not worth the waste of temporary space.
|
||||
|
||||
exec:
|
||||
lda (ip), y
|
||||
sta execjmp + 1
|
||||
iny
|
||||
bmi incip
|
||||
execjmp:
|
||||
jmp (0x0900)
|
||||
|
||||
The intermediate code generator assumes a large number of registers so the zero page is used for this purpose. The allocation is not yet final:
|
||||
|
||||
* **0x02-0x02** spilling of y register
|
||||
* **0x03-0x09** workspace for mul/div and floating point routines
|
||||
* **0x19-0x1a** instruction pointer
|
||||
* **0x1b-0x1e** integer and floating point accumulator
|
||||
* **0x1f-0x22** pointers for indirect addressing
|
||||
* **0x23-0x24** stack pointer
|
||||
* **0x25-0x26** frame pointer
|
||||
* **0x43-0x52** caller saved registers
|
||||
* **0x53-0x8f** callee saved registers
|
||||
|
||||
[Roguebot](https://drmortalwombat.itch.io/roguebot)
|
||||
|
||||
[Shallow Domains](https://drmortalwombat.itch.io/shallow-domains)
|
||||
|
||||
[Veggies vs Undead](https://drmortalwombat.itch.io/veggies-vs-undead)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,48 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
|
||||
char s[25][41] = {"Q QQ QQQQQ QQQQQQQQQQQQQ",
|
||||
" QQQQQQQQQQQQQQQQQQQQQQQQQQ",
|
||||
"QQQQQQQQ",
|
||||
" QQQQQQQQQQQQQQQQQ",
|
||||
"QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
|
||||
"QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
" QQQQQQQQQQQQQQQQQQQQQQQQ",
|
||||
"QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
|
||||
"QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
|
||||
"QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
|
||||
"QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
|
||||
"QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ",
|
||||
"QQQQQQQQQ",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
" QQQQQQQQQQQQQQ"};
|
||||
|
||||
int main()
|
||||
{
|
||||
int i=0, sum = 0;
|
||||
for (unsigned char i = 0; i < 25; i++)
|
||||
{
|
||||
int j = 0;
|
||||
while (s[i][j])
|
||||
{
|
||||
sum += s[i][j] & 3;
|
||||
j++;
|
||||
}
|
||||
}
|
||||
|
||||
assert(sum == 391);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,152 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
int t, n, m, k;
|
||||
|
||||
struct C1
|
||||
{
|
||||
int a;
|
||||
|
||||
C1(void);
|
||||
~C1(void);
|
||||
C1(const C1 & c);
|
||||
C1 & operator=(const C1 & c);
|
||||
};
|
||||
|
||||
struct C2
|
||||
{
|
||||
C1 nc[10], mc[20];
|
||||
};
|
||||
|
||||
C1::C1(void)
|
||||
{
|
||||
a = 1;
|
||||
n++;
|
||||
t++;
|
||||
}
|
||||
|
||||
C1::C1(const C1 & c)
|
||||
{
|
||||
a = c.a;
|
||||
k++;
|
||||
t++;
|
||||
}
|
||||
|
||||
C1 & C1::operator=(const C1 & c)
|
||||
{
|
||||
a = c.a;
|
||||
m++;
|
||||
return *this;
|
||||
}
|
||||
|
||||
C1::~C1(void)
|
||||
{
|
||||
t--;
|
||||
}
|
||||
|
||||
void test_local_init(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C1 c[10];
|
||||
}
|
||||
|
||||
assert(n == 10 && t == 0);
|
||||
}
|
||||
|
||||
void test_member_init(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C2 d;
|
||||
}
|
||||
|
||||
assert(n == 30 && t == 0);
|
||||
}
|
||||
|
||||
void test_member_array_init(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C2 d[5];
|
||||
}
|
||||
|
||||
assert(n == 150 && t == 0);
|
||||
}
|
||||
|
||||
void test_local_copy(void)
|
||||
{
|
||||
n = 0;
|
||||
k = 0;
|
||||
|
||||
{
|
||||
C1 c[10];
|
||||
C1 d(c[4]);
|
||||
}
|
||||
|
||||
assert(n == 10 && k == 1 && t == 0);
|
||||
}
|
||||
|
||||
void test_member_copy(void)
|
||||
{
|
||||
n = 0;
|
||||
k = 0;
|
||||
|
||||
{
|
||||
C2 d;
|
||||
C2 e(d);
|
||||
}
|
||||
|
||||
assert(n == 30 && k == 30 && t == 0);
|
||||
}
|
||||
|
||||
void test_local_assign(void)
|
||||
{
|
||||
n = 0;
|
||||
k = 0;
|
||||
m = 0;
|
||||
|
||||
{
|
||||
C1 c[10];
|
||||
C1 d[5];
|
||||
|
||||
d[4] = c[2];
|
||||
}
|
||||
|
||||
assert(n == 15 && k == 0 && m == 1 && t == 0);
|
||||
}
|
||||
|
||||
void test_member_assign(void)
|
||||
{
|
||||
n = 0;
|
||||
k = 0;
|
||||
m = 0;
|
||||
|
||||
{
|
||||
C2 d;
|
||||
C2 e;
|
||||
e = d;
|
||||
}
|
||||
|
||||
assert(n == 60 && k == 0 && m == 30 && t == 0);
|
||||
}
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
test_local_init();
|
||||
test_member_init();
|
||||
|
||||
test_member_array_init();
|
||||
|
||||
test_local_copy();
|
||||
test_member_copy();
|
||||
|
||||
test_local_assign();
|
||||
test_member_assign();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
int a[10];
|
||||
|
||||
int get(int i)
|
||||
{
|
||||
return a[i];
|
||||
}
|
||||
|
||||
void put(int i, int x)
|
||||
{
|
||||
a[i] = x;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
for(int j=0; j<10; j++)
|
||||
put(j, j);
|
||||
int s = -45;
|
||||
for(int j=0; j<10; j++)
|
||||
s += get(j);
|
||||
return s;
|
||||
}
|
||||
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
int fg[15] = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610};
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int fl[15] = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610};
|
||||
|
||||
int sg = 0, sl = 0;
|
||||
|
||||
for(int i=0; i<15; i++)
|
||||
{
|
||||
sl += fl[i];
|
||||
sg += fg[i];
|
||||
}
|
||||
|
||||
assert(sl == 1596);
|
||||
assert(sg == 1596);
|
||||
|
||||
printf("%d %d\n", sl, sg);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
|
||||
|
||||
int a(int * p, int x)
|
||||
{
|
||||
int y = x + 3;
|
||||
|
||||
p[y] = 1;
|
||||
p[y + 1] = 2;
|
||||
p[y + 2] = 3;
|
||||
p[y + 3] = 4;
|
||||
|
||||
return p[y] + p[y + 1] + p[y + 2] + p[y + 3];
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int t[16];
|
||||
|
||||
return a(t, 4) - 10;
|
||||
}
|
||||
|
|
@ -11,93 +11,13 @@ int sum(int * a, int s)
|
|||
return sum;
|
||||
}
|
||||
|
||||
void copy(int * d, const int * s, int n)
|
||||
{
|
||||
for(int i=0; i<n ; i++)
|
||||
d[i] = s[i];
|
||||
}
|
||||
|
||||
void reverse(int * d, const int * s, int n)
|
||||
{
|
||||
for(int i=0; i<n ; i++)
|
||||
d[i] = s[n - i - 1];
|
||||
}
|
||||
|
||||
int sumb(int * a, char s)
|
||||
{
|
||||
int sum = 0;
|
||||
for(char i=0; i<s; i++)
|
||||
{
|
||||
sum += a[i];
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
void copyb(int * d, const int * s, char n)
|
||||
{
|
||||
for(char i=0; i<n ; i++)
|
||||
d[i] = s[i];
|
||||
}
|
||||
|
||||
void reverseb(int * d, const int * s, char n)
|
||||
{
|
||||
for(char i=0; i<n ; i++)
|
||||
d[i] = s[n - i - 1];
|
||||
}
|
||||
|
||||
long suml(long * a, char s)
|
||||
{
|
||||
long sum = 0;
|
||||
for(char i=0; i<s; i++)
|
||||
{
|
||||
sum += a[i];
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
void copyl(long * d, const long * s, char n)
|
||||
{
|
||||
for(char i=0; i<n ; i++)
|
||||
d[i] = s[i];
|
||||
}
|
||||
|
||||
void reversel(long * d, const long * s, char n)
|
||||
{
|
||||
for(char i=0; i<n ; i++)
|
||||
d[i] = s[n - i - 1];
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int a[100], b[100], c[100];
|
||||
long al[100], bl[100], cl[100];
|
||||
|
||||
int a[100];
|
||||
for(int i=0; i<100; i++)
|
||||
{
|
||||
a[i] = i % 10;
|
||||
al[i] = i % 10;
|
||||
}
|
||||
|
||||
assert(sum(a, 100) == 450);
|
||||
|
||||
copy(b, a, 100);
|
||||
assert(sum(b, 100) == 450);
|
||||
reverse(c, a, 100);
|
||||
assert(sum(c, 100) == 450);
|
||||
assert(sumb(a, 100) == 450);
|
||||
copyb(b, a, 100);
|
||||
assert(sumb(b, 100) == 450);
|
||||
|
||||
reverseb(c, a, 100);
|
||||
assert(sumb(c, 100) == 450);
|
||||
|
||||
assert(suml(al, 100) == 450);
|
||||
|
||||
copyl(bl, al, 100);
|
||||
assert(suml(bl, 100) == 450);
|
||||
|
||||
reversel(cl, al, 100);
|
||||
assert(suml(cl, 100) == 450);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,6 @@ float sum(float * a, int s)
|
|||
{
|
||||
sum += a[i];
|
||||
}
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
|
|
@ -19,7 +18,6 @@ int main(void)
|
|||
{
|
||||
a[i] = i % 10;
|
||||
}
|
||||
|
||||
assert(sum(a, 100) == 450);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,16 +0,0 @@
|
|||
|
||||
int a(char p[100])
|
||||
{
|
||||
int s = 0;
|
||||
for(int i=0; i<100; i++)
|
||||
s += p[i];
|
||||
return s;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
char c[100];
|
||||
for(int i=0; i<100; i++)
|
||||
c[i] = i;
|
||||
return a(c) - 4950;
|
||||
}
|
||||
|
|
@ -1,76 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
int asum(int a, int b)
|
||||
{
|
||||
return __asm
|
||||
{
|
||||
clc
|
||||
lda a
|
||||
adc b
|
||||
sta accu
|
||||
lda a + 1
|
||||
adc b + 1
|
||||
sta accu + 1
|
||||
};
|
||||
}
|
||||
|
||||
int bsum(int a, int b)
|
||||
{
|
||||
puts("Hello\n");
|
||||
|
||||
return __asm
|
||||
{
|
||||
clc
|
||||
lda a
|
||||
adc b
|
||||
sta accu
|
||||
lda a + 1
|
||||
adc b + 1
|
||||
sta accu + 1
|
||||
};
|
||||
}
|
||||
|
||||
int b, t[10];
|
||||
|
||||
int bsome(int x)
|
||||
{
|
||||
return x;
|
||||
}
|
||||
|
||||
|
||||
int qsum(int a, int (* c)(int))
|
||||
{
|
||||
char n = 0;
|
||||
b = 0;
|
||||
for(int i=0; i<a; i++)
|
||||
{
|
||||
int j = c((char)i);
|
||||
__asm
|
||||
{
|
||||
clc
|
||||
lda j
|
||||
adc b
|
||||
sta b
|
||||
lda j + 1
|
||||
adc b + 1
|
||||
sta b + 1
|
||||
}
|
||||
t[n] += i;
|
||||
n = (n + 1) & 7;
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int x = asum(7007, 8008);
|
||||
int y = bsum(4004, 9009);
|
||||
|
||||
assert(x == 7007 + 8008 && y == 4004 + 9009);
|
||||
assert(qsum(10, bsome) == 45);
|
||||
assert(qsum(200, bsome) == 19900);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,400 +1,36 @@
|
|||
rem @echo off
|
||||
@echo off
|
||||
|
||||
@call :test rolrortest.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
..\release\oscar64 -i=../include -rt=../include/crt.c -e stdlibtest.c
|
||||
if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test bitfields.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
..\release\oscar64 -i=../include -rt=../include/crt.c -e testint16.c
|
||||
if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testn autorefreturn.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
..\release\oscar64 -i=../include -rt=../include/crt.c -e recursiontest.c
|
||||
if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_string.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
..\release\oscar64 -i=../include -rt=../include/crt.c -e strcmptest.c
|
||||
if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_array.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
..\release\oscar64 -i=../include -rt=../include/crt.c -e arraytest.c
|
||||
if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_vector.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
..\release\oscar64 -i=../include -rt=../include/crt.c -e arraytestfloat.c
|
||||
if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_static_vector.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
..\release\oscar64 -i=../include -rt=../include/crt.c -e optiontest.c
|
||||
if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_vector_string.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
..\release\oscar64 -i=../include -rt=../include/crt.c -e floatcmptest.c
|
||||
if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_string_init.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
..\release\oscar64 -i=../include -rt=../include/crt.c -e floatmultest.c
|
||||
if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_streamtest.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_pairtest.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_parts.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh opp_list.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testn opp_functional.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh operatoroverload.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh virtualdestruct.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh vcalltest.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh vcalltree.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh constructortest.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testn copyconstructor.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh copyassign.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh arrayconstruct.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testh stdlibtest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test mathtest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test testint16.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test testint32.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test testint16mul.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test testsigned16mul.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test testsigned16div.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test recursiontest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test copyinitmove.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test fastcalltest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test strlen.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test strcmptest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test strcmptest2.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test memmovetest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test arraytest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test arraytestfloat.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test optiontest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test floatcmptest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test floatmultest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test floatinttest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test staticconsttest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test arrayinittest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test arrayindexintrangecheck.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test array2stringinittest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test testint16cmp.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test testint8cmp.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test testint32cmp.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test mixsigncmptest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test testinterval.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test cmprangeshortcuttest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test floatstringtest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test sprintftest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test qsorttest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testn plasma.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test loopdomtest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test loopboundtest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test byteindextest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test asmtest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testb bitshifttest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test arrparam.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test bsstest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test copyintvec.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test divmodtest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test divmod32test.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test fixmathtest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test enumswitch.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test incvector.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test structoffsettest2.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test funcvartest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test funcarraycall.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test structassigntest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test structmembertest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test structarraycopy.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test randsumtest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test longcodetest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test scrolltest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test charwintest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test linetest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test ptrinittest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test ptrarraycmptest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test cplxstructtest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testn stripedarraytest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :testn mmultest.c
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@call :test tileexpand.cpp
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@exit /b 0
|
||||
..\release\oscar64 -i=../include -rt=../include/crt.c -e staticconsttest.c
|
||||
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
|
||||
..\bin\oscar64 -e -bc %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -bc %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O0 -bc %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O0 -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -Os -bc %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -Os -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O3 -bc %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O3 -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -xz -Oz -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -Oo -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -Ox -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@exit /b 0
|
||||
|
||||
:testb
|
||||
..\bin\oscar64 -e -bc %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -bc -O2 %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -bc -O0 %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -bc -Os %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -bc -O3 %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@exit /b 0
|
||||
|
||||
:testn
|
||||
..\bin\oscar64 -e -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O0 -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -Os -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O3 -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -xz -Oz -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -Oo -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
..\bin\oscar64 -e -O2 -Ox -n %~1
|
||||
@if %errorlevel% neq 0 goto :error
|
||||
|
||||
@exit /b 0
|
||||
|
|
|
|||
|
|
@ -1,354 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,414 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
#pragma region( main, 0x0a00, 0xd000, , , {code, data, bss, heap, stack} )
|
||||
|
||||
unsigned shl1b(int n)
|
||||
{
|
||||
return 1 << n;
|
||||
}
|
||||
|
||||
unsigned shl1n(int n)
|
||||
{
|
||||
return 1 << n;
|
||||
}
|
||||
|
||||
#pragma native(shl1n)
|
||||
|
||||
unsigned shr1b(int n)
|
||||
{
|
||||
return 0x8000 >> n;
|
||||
}
|
||||
|
||||
unsigned shr1n(int n)
|
||||
{
|
||||
return 0x8000 >> n;
|
||||
}
|
||||
|
||||
#pragma native(shr1n)
|
||||
|
||||
unsigned shl4b(int n)
|
||||
{
|
||||
return 0x0010 << n;
|
||||
}
|
||||
|
||||
unsigned shl4n(int n)
|
||||
{
|
||||
return 0x0010 << n;
|
||||
}
|
||||
|
||||
#pragma native(shl4n)
|
||||
|
||||
unsigned shr4b(int n)
|
||||
{
|
||||
return 0x0800 >> n;
|
||||
}
|
||||
|
||||
unsigned shr4n(int n)
|
||||
{
|
||||
return 0x0800 >> n;
|
||||
}
|
||||
|
||||
#pragma native(shr4n)
|
||||
|
||||
|
||||
unsigned shl8b(int n)
|
||||
{
|
||||
return 0x0100 << n;
|
||||
}
|
||||
|
||||
unsigned shl8n(int n)
|
||||
{
|
||||
return 0x0100 << n;
|
||||
}
|
||||
|
||||
#pragma native(shl8n)
|
||||
|
||||
unsigned shr8b(int n)
|
||||
{
|
||||
return 0x0080 >> n;
|
||||
}
|
||||
|
||||
unsigned shr8n(int n)
|
||||
{
|
||||
return 0x0080 >> n;
|
||||
}
|
||||
|
||||
#pragma native(shr8n)
|
||||
|
||||
|
||||
void shl8xb(unsigned char xu, signed char xi)
|
||||
{
|
||||
unsigned char ua[16];
|
||||
signed char ia[16];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu << s;
|
||||
ia[s] = xi << s;
|
||||
#assign s s + 1
|
||||
#until s == 16
|
||||
|
||||
for(int i=0; i<16; i++)
|
||||
{
|
||||
assert(ua[i] == (unsigned char)(xu << i));
|
||||
assert(ia[i] == (signed char)(xi << i));
|
||||
}
|
||||
}
|
||||
|
||||
void shr8xb(unsigned char xu, signed char xi)
|
||||
{
|
||||
unsigned char ua[16];
|
||||
signed char ia[16];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu >> s;
|
||||
ia[s] = xi >> s;
|
||||
#assign s s + 1
|
||||
#until s == 16
|
||||
|
||||
for(int i=0; i<16; i++)
|
||||
{
|
||||
assert(ua[i] == (unsigned char)(xu >> i));
|
||||
assert(ia[i] == (signed char)(xi >> i));
|
||||
}
|
||||
}
|
||||
|
||||
void shl8xn(unsigned char xu, signed char xi)
|
||||
{
|
||||
unsigned char ua[16];
|
||||
signed char ia[16];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu << s;
|
||||
ia[s] = xi << s;
|
||||
#assign s s + 1
|
||||
#until s == 16
|
||||
|
||||
for(int i=0; i<16; i++)
|
||||
{
|
||||
assert(ua[i] == (unsigned char)(xu << i));
|
||||
assert(ia[i] == (signed char)(xi << i));
|
||||
}
|
||||
}
|
||||
|
||||
void shr8xn(unsigned char xu, signed char xi)
|
||||
{
|
||||
unsigned char ua[16];
|
||||
signed char ia[16];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu >> s;
|
||||
ia[s] = xi >> s;
|
||||
#assign s s + 1
|
||||
#until s == 16
|
||||
|
||||
for(int i=0; i<16; i++)
|
||||
{
|
||||
assert(ua[i] == (unsigned char)(xu >> i));
|
||||
assert(ia[i] == (signed char)(xi >> i));
|
||||
}
|
||||
}
|
||||
|
||||
#pragma native(shl8xn)
|
||||
#pragma native(shr8xn)
|
||||
|
||||
|
||||
|
||||
|
||||
void shl16b(unsigned xu, int xi)
|
||||
{
|
||||
unsigned ua[16];
|
||||
int ia[16];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu << s;
|
||||
ia[s] = xi << s;
|
||||
#assign s s + 1
|
||||
#until s == 16
|
||||
|
||||
for(int i=0; i<16; i++)
|
||||
{
|
||||
assert(ua[i] == xu << i);
|
||||
assert(ia[i] == xi << i);
|
||||
}
|
||||
}
|
||||
|
||||
void shr16b(unsigned xu, int xi)
|
||||
{
|
||||
unsigned ua[16];
|
||||
int ia[16];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu >> s;
|
||||
ia[s] = xi >> s;
|
||||
#assign s s + 1
|
||||
#until s == 16
|
||||
|
||||
for(int i=0; i<16; i++)
|
||||
{
|
||||
assert(ua[i] == xu >> i);
|
||||
assert(ia[i] == xi >> i);
|
||||
}
|
||||
}
|
||||
|
||||
void shl16n(unsigned xu, int xi)
|
||||
{
|
||||
unsigned ua[16];
|
||||
int ia[16];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu << s;
|
||||
ia[s] = xi << s;
|
||||
#assign s s + 1
|
||||
#until s == 16
|
||||
|
||||
for(int i=0; i<16; i++)
|
||||
{
|
||||
assert(ua[i] == xu << i);
|
||||
assert(ia[i] == xi << i);
|
||||
}
|
||||
}
|
||||
|
||||
void shr16n(unsigned xu, int xi)
|
||||
{
|
||||
unsigned ua[16];
|
||||
int ia[16];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu >> s;
|
||||
ia[s] = xi >> s;
|
||||
#assign s s + 1
|
||||
#until s == 16
|
||||
|
||||
for(int i=0; i<16; i++)
|
||||
{
|
||||
assert(ua[i] == xu >> i);
|
||||
assert(ia[i] == xi >> i);
|
||||
}
|
||||
}
|
||||
|
||||
#pragma native(shl16n)
|
||||
#pragma native(shr16n)
|
||||
|
||||
|
||||
void shl32b(unsigned long xu, long xi)
|
||||
{
|
||||
unsigned long ua[32];
|
||||
long ia[32];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu << s;
|
||||
ia[s] = xi << s;
|
||||
#assign s s + 1
|
||||
#until s == 32
|
||||
|
||||
for(int i=0; i<32; i++)
|
||||
{
|
||||
assert(ua[i] == xu << i);
|
||||
assert(ia[i] == xi << i);
|
||||
}
|
||||
}
|
||||
|
||||
void shr32b(unsigned long xu, long xi)
|
||||
{
|
||||
unsigned long ua[32];
|
||||
long ia[32];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu >> s;
|
||||
ia[s] = xi >> s;
|
||||
#assign s s + 1
|
||||
#until s == 32
|
||||
|
||||
for(int i=0; i<32; i++)
|
||||
{
|
||||
assert(ua[i] == xu >> i);
|
||||
assert(ia[i] == xi >> i);
|
||||
}
|
||||
}
|
||||
|
||||
void shl32n(unsigned long xu, long xi)
|
||||
{
|
||||
unsigned long ua[32];
|
||||
long ia[32];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu << s;
|
||||
ia[s] = xi << s;
|
||||
#assign s s + 1
|
||||
#until s == 32
|
||||
|
||||
for(int i=0; i<32; i++)
|
||||
{
|
||||
assert(ua[i] == xu << i);
|
||||
assert(ia[i] == xi << i);
|
||||
}
|
||||
}
|
||||
|
||||
void shr32n(unsigned long xu, long xi)
|
||||
{
|
||||
unsigned long ua[32];
|
||||
long ia[32];
|
||||
#assign s 0
|
||||
#repeat
|
||||
ua[s] = xu >> s;
|
||||
ia[s] = xi >> s;
|
||||
#assign s s + 1
|
||||
#until s == 32
|
||||
|
||||
for(int i=0; i<32; i++)
|
||||
{
|
||||
assert(ua[i] == xu >> i);
|
||||
assert(ia[i] == xi >> i);
|
||||
}
|
||||
}
|
||||
|
||||
void shl1_32n(void)
|
||||
{
|
||||
static const unsigned long m[] = {
|
||||
#for(i, 32) 1ul << i,
|
||||
};
|
||||
|
||||
for(int i=0; i<32; i++)
|
||||
{
|
||||
assert(1ul << i == m[i]);
|
||||
}
|
||||
}
|
||||
|
||||
#pragma native(shl32n)
|
||||
#pragma native(shr32n)
|
||||
|
||||
int main(void)
|
||||
{
|
||||
*(volatile char *)0x01 = 0x36;
|
||||
|
||||
for(int i=0; i<32; i++)
|
||||
{
|
||||
printf("1: %.4x : %.4x | %.4x : %.4x\n", shl1b(i), shl1n(i), shr1b(i), shr1n(i));
|
||||
assert(shl1b(i) == shl1n(i));
|
||||
assert(shr1b(i) == shr1n(i));
|
||||
}
|
||||
|
||||
for(int i=0; i<32; i++)
|
||||
{
|
||||
printf("4: %.4x : %.4x | %.4x : %.4x\n", shl4b(i), shl4n(i), shr4b(i), shr4n(i));
|
||||
assert(shl4b(i) == shl4n(i));
|
||||
assert(shr4b(i) == shr4n(i));
|
||||
}
|
||||
|
||||
for(int i=0; i<32; i++)
|
||||
{
|
||||
printf("8: %.4x : %.4x | %.4x : %.4x\n", shl8b(i), shl8n(i), shr8b(i), shr8n(i));
|
||||
assert(shl8b(i) == shl8n(i));
|
||||
assert(shr8b(i) == shr8n(i));
|
||||
}
|
||||
|
||||
shl8xb(0x00, 0x00);
|
||||
shl8xb(0xff, 0xff);
|
||||
shl8xb(0x34, 0x34);
|
||||
shl8xb(0xdc, 0xdc);
|
||||
|
||||
shr8xb(0x00, 0x00);
|
||||
shr8xb(0xff, 0xff);
|
||||
shr8xb(0x34, 0x34);
|
||||
shr8xb(0xdc, 0xdc);
|
||||
|
||||
shl8xn(0x00, 0x00);
|
||||
shl8xn(0xff, 0xff);
|
||||
shl8xn(0x34, 0x34);
|
||||
shl8xn(0xdc, 0xdc);
|
||||
|
||||
shr8xn(0x00, 0x00);
|
||||
shr8xn(0xff, 0xff);
|
||||
shr8xn(0x34, 0x34);
|
||||
shr8xn(0xdc, 0xdc);
|
||||
|
||||
shl16b(0x0000, 0x0000);
|
||||
shl16b(0xffff, 0xffff);
|
||||
shl16b(0x1234, 0x1234);
|
||||
shl16b(0xfedc, 0xfedc);
|
||||
|
||||
shr16b(0x0000, 0x0000);
|
||||
shr16b(0xffff, 0xffff);
|
||||
shr16b(0x1234, 0x1234);
|
||||
shr16b(0xfedc, 0xfedc);
|
||||
|
||||
shl16n(0x0000, 0x0000);
|
||||
|
||||
shl16n(0xffff, 0xffff);
|
||||
shl16n(0x1234, 0x1234);
|
||||
shl16n(0xfedc, 0xfedc);
|
||||
|
||||
shr16n(0x0000, 0x0000);
|
||||
shr16n(0xffff, 0xffff);
|
||||
shr16n(0x1234, 0x1234);
|
||||
shr16n(0xfedc, 0xfedc);
|
||||
|
||||
shl32b(0x00000000UL, 0x00000000L);
|
||||
shl32b(0x00000001UL, 0x00000001L);
|
||||
shl32b(0xffffffffUL, 0xffffffffL);
|
||||
shl32b(0x12345678UL, 0x12345678L);
|
||||
shl32b(0xfedcba98UL, 0xfedcba98L);
|
||||
|
||||
shr32b(0x00000000UL, 0x00000000L);
|
||||
shr32b(0x00000001UL, 0x00000001L);
|
||||
shr32b(0xffffffffUL, 0xffffffffL);
|
||||
shr32b(0x12345678UL, 0x12345678L);
|
||||
shr32b(0xfedcba98UL, 0xfedcba98L);
|
||||
|
||||
shl32n(0x00000000UL, 0x00000000L);
|
||||
shl32n(0x00000001UL, 0x00000001L);
|
||||
shl32n(0xffffffffUL, 0xffffffffL);
|
||||
shl32n(0x12345678UL, 0x12345678L);
|
||||
shl32n(0xfedcba98UL, 0xfedcba98L);
|
||||
|
||||
shr32n(0x00000000UL, 0x00000000L);
|
||||
shr32n(0x00000001UL, 0x00000001L);
|
||||
shr32n(0xffffffffUL, 0xffffffffL);
|
||||
shr32n(0x12345678UL, 0x12345678L);
|
||||
shr32n(0xfedcba98UL, 0xfedcba98L);
|
||||
|
||||
shl1_32n();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
|
||||
#include <string.h>
|
||||
|
||||
char ch[100];
|
||||
char p[] = "HELLO";
|
||||
int v[10];
|
||||
int w[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
||||
|
||||
int sum(int * k)
|
||||
{
|
||||
int s = 0;
|
||||
for(int i=0; i<10; i++)
|
||||
s += k[i];
|
||||
return s;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
strcpy(ch, p);
|
||||
strcat(ch, " WORLD");
|
||||
|
||||
for(int i=0; i<10; i++)
|
||||
v[i] = w[i];
|
||||
|
||||
return strcmp(ch, "HELLO WORLD") + sum(v) - 55;
|
||||
}
|
||||
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
char a[20];
|
||||
|
||||
int main(void)
|
||||
{
|
||||
for(char i=0; i<20; i++)
|
||||
a[i] = i;
|
||||
char x = 0;
|
||||
for(char i=0; i<20; i++)
|
||||
x += a[i];
|
||||
|
||||
assert(x == 190);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
#include <c64/charwin.h>
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
CharWin cw;
|
||||
|
||||
cwin_init(&cw, (char *)0x0400, 2, 2, 32, 20);
|
||||
|
||||
cwin_clear(&cw);
|
||||
|
||||
for(int y=0; y<20; y++)
|
||||
{
|
||||
for(int x=0; x<32; x++)
|
||||
{
|
||||
assert(cwin_getat_char_raw(&cw, x, y) == ' ');
|
||||
}
|
||||
}
|
||||
|
||||
for(int y=0; y<20; y++)
|
||||
{
|
||||
for(int x=0; x<32; x++)
|
||||
{
|
||||
cwin_putat_char(&cw, x, y, p'a' - 1 + x, 7);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for(int y=0; y<20; y++)
|
||||
{
|
||||
for(int x=0; x<32; x++)
|
||||
{
|
||||
assert(cwin_getat_char(&cw, x, y) == p'a' -1 + x);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for(int y=0; y<20; y++)
|
||||
{
|
||||
for(int x=0; x<32; x++)
|
||||
{
|
||||
cwin_putat_char(&cw, x, y, p'A' - 1 + x, 8);
|
||||
}
|
||||
}
|
||||
|
||||
for(int y=0; y<20; y++)
|
||||
{
|
||||
for(int x=0; x<32; x++)
|
||||
{
|
||||
cwin_putat_char_raw(&cw, x, y, x + 32 * y, 8);
|
||||
}
|
||||
}
|
||||
|
||||
for(int y=0; y<8; y++)
|
||||
{
|
||||
for(int x=0; x<32; x++)
|
||||
{
|
||||
assert(cwin_getat_char_raw(&cw, x, y) == x + 32 * y);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,298 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
void check_s_lt(void)
|
||||
{
|
||||
int a5 = 0, a10 = 0, a15 = 0;
|
||||
|
||||
for(int i=5; i<15; i++)
|
||||
{
|
||||
if (i < 5)
|
||||
a5++;
|
||||
if (i < 10)
|
||||
a10++;
|
||||
if (i < 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a5 == 0);
|
||||
assert(a10 == 5);
|
||||
assert(a15 == 10);
|
||||
}
|
||||
|
||||
void check_s_le(void)
|
||||
{
|
||||
int a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
|
||||
|
||||
for(int i=5; i<15; i++)
|
||||
{
|
||||
if (i <= 4)
|
||||
a4++;
|
||||
if (i <= 5)
|
||||
a5++;
|
||||
if (i <= 10)
|
||||
a10++;
|
||||
if (i <= 14)
|
||||
a14++;
|
||||
if (i <= 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a4 == 0);
|
||||
assert(a5 == 1);
|
||||
assert(a10 == 6);
|
||||
assert(a14 == 10);
|
||||
assert(a15 == 10);
|
||||
}
|
||||
|
||||
void check_s_ge(void)
|
||||
{
|
||||
int a5 = 0, a10 = 0, a15 = 0;
|
||||
|
||||
for(int i=5; i<15; i++)
|
||||
{
|
||||
if (i >= 5)
|
||||
a5++;
|
||||
if (i >= 10)
|
||||
a10++;
|
||||
if (i >= 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a5 == 10);
|
||||
assert(a10 == 5);
|
||||
assert(a15 == 0);
|
||||
}
|
||||
|
||||
void check_s_gt(void)
|
||||
{
|
||||
int a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
|
||||
|
||||
for(int i=5; i<15; i++)
|
||||
{
|
||||
if (i > 4)
|
||||
a4++;
|
||||
if (i > 5)
|
||||
a5++;
|
||||
if (i > 10)
|
||||
a10++;
|
||||
if (i > 14)
|
||||
a14++;
|
||||
if (i > 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a4 == 10);
|
||||
assert(a5 == 9);
|
||||
assert(a10 == 4);
|
||||
assert(a14 == 0);
|
||||
assert(a15 == 0);
|
||||
}
|
||||
|
||||
void check_s_eq(void)
|
||||
{
|
||||
int a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
|
||||
|
||||
for(int i=5; i<15; i++)
|
||||
{
|
||||
if (i == 4)
|
||||
a4++;
|
||||
if (i == 5)
|
||||
a5++;
|
||||
if (i == 10)
|
||||
a10++;
|
||||
if (i == 14)
|
||||
a14++;
|
||||
if (i == 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a4 == 0);
|
||||
assert(a5 == 1);
|
||||
assert(a10 == 1);
|
||||
assert(a14 == 1);
|
||||
assert(a15 == 0);
|
||||
}
|
||||
|
||||
void check_s_ne(void)
|
||||
{
|
||||
int a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
|
||||
|
||||
for(int i=5; i<15; i++)
|
||||
{
|
||||
if (i != 4)
|
||||
a4++;
|
||||
if (i != 5)
|
||||
a5++;
|
||||
if (i != 10)
|
||||
a10++;
|
||||
if (i != 14)
|
||||
a14++;
|
||||
if (i != 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a4 == 10);
|
||||
assert(a5 == 9);
|
||||
assert(a10 == 9);
|
||||
assert(a14 == 9);
|
||||
assert(a15 == 10);
|
||||
}
|
||||
|
||||
void check_u_lt(void)
|
||||
{
|
||||
int a5 = 0, a10 = 0, a15 = 0;
|
||||
|
||||
for(unsigned i=5; i<15; i++)
|
||||
{
|
||||
if (i < 5)
|
||||
a5++;
|
||||
if (i < 10)
|
||||
a10++;
|
||||
if (i < 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a5 == 0);
|
||||
assert(a10 == 5);
|
||||
assert(a15 == 10);
|
||||
}
|
||||
|
||||
void check_u_le(void)
|
||||
{
|
||||
int a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
|
||||
|
||||
for(unsigned i=5; i<15; i++)
|
||||
{
|
||||
if (i <= 4)
|
||||
a4++;
|
||||
if (i <= 5)
|
||||
a5++;
|
||||
if (i <= 10)
|
||||
a10++;
|
||||
if (i <= 14)
|
||||
a14++;
|
||||
if (i <= 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a4 == 0);
|
||||
assert(a5 == 1);
|
||||
assert(a10 == 6);
|
||||
assert(a14 == 10);
|
||||
assert(a15 == 10);
|
||||
}
|
||||
|
||||
void check_u_ge(void)
|
||||
{
|
||||
int a5 = 0, a10 = 0, a15 = 0;
|
||||
|
||||
for(unsigned i=5; i<15; i++)
|
||||
{
|
||||
if (i >= 5)
|
||||
a5++;
|
||||
if (i >= 10)
|
||||
a10++;
|
||||
if (i >= 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a5 == 10);
|
||||
assert(a10 == 5);
|
||||
assert(a15 == 0);
|
||||
}
|
||||
|
||||
void check_u_gt(void)
|
||||
{
|
||||
int a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
|
||||
|
||||
for(unsigned i=5; i<15; i++)
|
||||
{
|
||||
if (i > 4)
|
||||
a4++;
|
||||
if (i > 5)
|
||||
a5++;
|
||||
if (i > 10)
|
||||
a10++;
|
||||
if (i > 14)
|
||||
a14++;
|
||||
if (i > 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a4 == 10);
|
||||
assert(a5 == 9);
|
||||
assert(a10 == 4);
|
||||
assert(a14 == 0);
|
||||
assert(a15 == 0);
|
||||
}
|
||||
|
||||
void check_u_eq(void)
|
||||
{
|
||||
int a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
|
||||
|
||||
for(unsigned i=5; i<15; i++)
|
||||
{
|
||||
if (i == 4)
|
||||
a4++;
|
||||
if (i == 5)
|
||||
a5++;
|
||||
if (i == 10)
|
||||
a10++;
|
||||
if (i == 14)
|
||||
a14++;
|
||||
if (i == 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a4 == 0);
|
||||
assert(a5 == 1);
|
||||
assert(a10 == 1);
|
||||
assert(a14 == 1);
|
||||
assert(a15 == 0);
|
||||
}
|
||||
|
||||
void check_u_ne(void)
|
||||
{
|
||||
int a4 = 0, a5 = 0, a10 = 0, a14 = 0, a15 = 0;
|
||||
|
||||
for(unsigned i=5; i<15; i++)
|
||||
{
|
||||
if (i != 4)
|
||||
a4++;
|
||||
if (i != 5)
|
||||
a5++;
|
||||
if (i != 10)
|
||||
a10++;
|
||||
if (i != 14)
|
||||
a14++;
|
||||
if (i != 15)
|
||||
a15++;
|
||||
}
|
||||
|
||||
assert(a4 == 10);
|
||||
assert(a5 == 9);
|
||||
assert(a10 == 9);
|
||||
assert(a14 == 9);
|
||||
assert(a15 == 10);
|
||||
}
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
check_s_ne();
|
||||
check_s_eq();
|
||||
check_s_lt();
|
||||
check_s_le();
|
||||
check_s_gt();
|
||||
check_s_ge();
|
||||
|
||||
check_u_ne();
|
||||
check_u_eq();
|
||||
check_u_lt();
|
||||
check_u_le();
|
||||
check_u_gt();
|
||||
check_u_ge();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1,165 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
int t, n;
|
||||
|
||||
struct C1
|
||||
{
|
||||
int a;
|
||||
|
||||
C1(int x);
|
||||
~C1(void);
|
||||
};
|
||||
|
||||
C1::C1(int x) : a(x)
|
||||
{
|
||||
t += a;
|
||||
n++;
|
||||
}
|
||||
|
||||
C1::~C1(void)
|
||||
{
|
||||
t -= a;
|
||||
}
|
||||
|
||||
void test_base(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C1 x(2);
|
||||
C1 y(1);
|
||||
}
|
||||
|
||||
assert(t == 0 && n == 2);
|
||||
}
|
||||
|
||||
void test_base_loop(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
for(int i=0; i<10; i++)
|
||||
{
|
||||
C1 x(2);
|
||||
C1 y(1);
|
||||
}
|
||||
|
||||
assert(t == 0 && n == 20);
|
||||
}
|
||||
|
||||
struct C2
|
||||
{
|
||||
C1 c, d;
|
||||
|
||||
C2(void);
|
||||
};
|
||||
|
||||
C2::C2(void)
|
||||
: c(7), d(11)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void test_member(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C2 x();
|
||||
C2 y();
|
||||
}
|
||||
|
||||
assert(t == 0 && n == 4);
|
||||
}
|
||||
|
||||
void test_member_loop(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
for(int i=0; i<10; i++)
|
||||
{
|
||||
C2 x();
|
||||
C2 y();
|
||||
}
|
||||
|
||||
assert(t == 0 && n == 40);
|
||||
}
|
||||
|
||||
struct C3
|
||||
{
|
||||
C2 x, y;
|
||||
};
|
||||
|
||||
void test_default(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C3 x();
|
||||
C3 y();
|
||||
}
|
||||
|
||||
assert(t == 0 && n == 8);
|
||||
}
|
||||
|
||||
void test_default_loop(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
for(int i=0; i<10; i++)
|
||||
{
|
||||
C3 x();
|
||||
C3 y();
|
||||
}
|
||||
|
||||
assert(t == 0 && n == 80);
|
||||
}
|
||||
|
||||
inline void test_inline_x(void)
|
||||
{
|
||||
C1 x(1), y(2);
|
||||
}
|
||||
|
||||
void test_inline(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
test_inline_x();
|
||||
|
||||
assert(t == 0 && n == 2);
|
||||
}
|
||||
|
||||
inline void test_inline_xr(void)
|
||||
{
|
||||
C1 x(1), y(2);
|
||||
|
||||
{
|
||||
C1 x(3);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void test_inline_return(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
test_inline_xr();
|
||||
|
||||
assert(t == 0 && n == 3);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
test_base();
|
||||
test_base_loop();
|
||||
|
||||
test_member();
|
||||
test_member_loop();
|
||||
|
||||
test_default();
|
||||
test_default_loop();
|
||||
|
||||
test_inline();
|
||||
test_inline_return();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,126 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
int t, n;
|
||||
|
||||
struct C0
|
||||
{
|
||||
int u;
|
||||
|
||||
C0(int a);
|
||||
~C0(void);
|
||||
};
|
||||
|
||||
C0::C0(int a) : u(a)
|
||||
{
|
||||
t += u;
|
||||
n++;
|
||||
}
|
||||
|
||||
C0::~C0(void)
|
||||
{
|
||||
t -= u;
|
||||
}
|
||||
|
||||
struct C1
|
||||
{
|
||||
int u;
|
||||
|
||||
C1(int a);
|
||||
~C1(void);
|
||||
C1(const C1 & c);
|
||||
C1 & operator=(const C1 & c);
|
||||
};
|
||||
|
||||
C1::C1(int a) : u(a)
|
||||
{
|
||||
t += u;
|
||||
n++;
|
||||
}
|
||||
|
||||
C1::~C1(void)
|
||||
{
|
||||
t -= u;
|
||||
}
|
||||
|
||||
C1::C1(const C1 & c) : u(c.u)
|
||||
{
|
||||
t += u;
|
||||
n++;
|
||||
}
|
||||
|
||||
C1 & C1::operator=(const C1 & c)
|
||||
{
|
||||
t -= u;
|
||||
u = c.u;
|
||||
t += u;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void test_assign(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C1 c(4);
|
||||
C1 d(5);
|
||||
c = d;
|
||||
}
|
||||
|
||||
assert(n == 2 && t == 0);
|
||||
}
|
||||
|
||||
struct C2
|
||||
{
|
||||
C1 a, b;
|
||||
|
||||
C2(int x, int y) : a(x), b(y)
|
||||
{}
|
||||
};
|
||||
|
||||
void test_assign_deflt(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C2 c(2, 3);
|
||||
C2 d(5, 10);
|
||||
c = d;
|
||||
}
|
||||
|
||||
assert(n == 4 && t == 0);
|
||||
}
|
||||
|
||||
int k;
|
||||
|
||||
C2 test_ret_v(void)
|
||||
{
|
||||
C2 c(5, 10);
|
||||
return c;
|
||||
}
|
||||
|
||||
C2 & test_ret_r(C2 & r)
|
||||
{
|
||||
return r;
|
||||
}
|
||||
|
||||
void test_assign_return_value(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C2 c(2, 3);
|
||||
c = test_ret_v();
|
||||
}
|
||||
|
||||
assert(n == 6 && t == 0);
|
||||
}
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
test_assign();
|
||||
test_assign_deflt();
|
||||
test_assign_return_value();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,215 +0,0 @@
|
|||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int t, n;
|
||||
|
||||
struct C0
|
||||
{
|
||||
int u;
|
||||
|
||||
C0(int a);
|
||||
~C0(void);
|
||||
};
|
||||
|
||||
C0::C0(int a) : u(a)
|
||||
{
|
||||
t += u;
|
||||
n++;
|
||||
}
|
||||
|
||||
C0::~C0(void)
|
||||
{
|
||||
t -= u;
|
||||
}
|
||||
|
||||
struct C1
|
||||
{
|
||||
int u;
|
||||
|
||||
C1(int a);
|
||||
~C1(void);
|
||||
C1(const C1 & c);
|
||||
};
|
||||
|
||||
C1::C1(int a) : u(a)
|
||||
{
|
||||
t += u;
|
||||
n++;
|
||||
}
|
||||
|
||||
C1::~C1(void)
|
||||
{
|
||||
t -= u;
|
||||
}
|
||||
|
||||
C1::C1(const C1 & c) : u(c.u)
|
||||
{
|
||||
t += u;
|
||||
n++;
|
||||
}
|
||||
|
||||
void test_dcopy_init(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C0 x(4);
|
||||
C0 y(x);
|
||||
}
|
||||
|
||||
assert(n == 1 && t == -4);
|
||||
|
||||
t = 0;
|
||||
}
|
||||
|
||||
void test_copy_init(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C1 x(4);
|
||||
C1 y(x);
|
||||
}
|
||||
|
||||
assert(n == 2 && t == 0);
|
||||
}
|
||||
|
||||
struct C2
|
||||
{
|
||||
C1 a, b;
|
||||
|
||||
C2(void);
|
||||
};
|
||||
|
||||
C2::C2(void) : a(1), b(3)
|
||||
{}
|
||||
|
||||
void test_minit(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C2 x;
|
||||
}
|
||||
|
||||
assert(n == 2 && t == 0);
|
||||
}
|
||||
|
||||
void test_minit_copy(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C2 x;
|
||||
C2 y(x);
|
||||
}
|
||||
|
||||
assert(n == 4 && t == 0);
|
||||
}
|
||||
|
||||
int k;
|
||||
|
||||
void test_param_fv(C2 c)
|
||||
{
|
||||
k += c.a.u;
|
||||
}
|
||||
|
||||
void test_param_fr(C2 & c)
|
||||
{
|
||||
k += c.a.u;
|
||||
}
|
||||
|
||||
void test_param_value(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C2 x;
|
||||
test_param_fv(x);
|
||||
}
|
||||
|
||||
assert(n == 4 && t == 0);
|
||||
}
|
||||
|
||||
void test_param_ref(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C2 x;
|
||||
test_param_fr(x);
|
||||
}
|
||||
|
||||
assert(n == 2 && t == 0);
|
||||
}
|
||||
|
||||
C2 test_ret_v(void)
|
||||
{
|
||||
C2 c;
|
||||
return c;
|
||||
}
|
||||
|
||||
C2 & test_ret_r(C2 & r)
|
||||
{
|
||||
return r;
|
||||
}
|
||||
|
||||
void test_return_value(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C2 c(test_ret_v());
|
||||
}
|
||||
|
||||
assert(n == 6 && t == 0);
|
||||
}
|
||||
|
||||
void test_return_reference(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
C2 d;
|
||||
C2 c(test_ret_r(d));
|
||||
}
|
||||
|
||||
assert(n == 2 && t == 0);
|
||||
}
|
||||
|
||||
void test_retparam_value(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
test_param_fv(test_ret_v());
|
||||
}
|
||||
|
||||
assert(n == 6 && t == 0);
|
||||
}
|
||||
|
||||
void test_retparam_reference(void)
|
||||
{
|
||||
n = 0;
|
||||
|
||||
{
|
||||
test_param_fr(test_ret_v());
|
||||
}
|
||||
|
||||
assert(n == 4 && t == 0);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
test_dcopy_init();
|
||||
test_copy_init();
|
||||
test_minit();
|
||||
test_minit_copy();
|
||||
test_param_value();
|
||||
test_param_ref();
|
||||
test_return_value();
|
||||
test_retparam_value();
|
||||
test_retparam_reference();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
|
||||
int val(char * c)
|
||||
{
|
||||
return c[0];
|
||||
}
|
||||
|
||||
void set(char * c, int a)
|
||||
{
|
||||
c[0] = a;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
|
||||
|
||||
for(int i=0; i<10; i++)
|
||||
{
|
||||
char t[10] = {1};
|
||||
sum0 += val(t);
|
||||
sum2 += t[0];
|
||||
set(t, i);
|
||||
sum1 += val(t);
|
||||
sum3 += t[0];
|
||||
}
|
||||
|
||||
return (sum1 - 45) | (sum0 - 10) | (sum3 - 45) | (sum2 - 10);
|
||||
}
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
|
||||
|
||||
void copyi(int * a, int * b, int n)
|
||||
{
|
||||
for(int i=0; i<n; i++)
|
||||
b[i] = a[i];
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int t[100], s[100];
|
||||
for(int i=0; i<100; i++)
|
||||
s[i] = i;
|
||||
copyi(s, t, 100);
|
||||
int sum = 0;
|
||||
for(int i=0; i<100; i++)
|
||||
sum += t[i];
|
||||
|
||||
return sum - 4950;
|
||||
}
|
||||
|
|
@ -1,97 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <assert.h>
|
||||
|
||||
struct cplx
|
||||
{
|
||||
float r, i;
|
||||
};
|
||||
|
||||
cplx cplx_add(cplx a, cplx b)
|
||||
{
|
||||
cplx c;
|
||||
c.r = a.r + b.r;
|
||||
c.i = a.i + b.i;
|
||||
return c;
|
||||
}
|
||||
|
||||
cplx cplx_sub(cplx a, cplx b)
|
||||
{
|
||||
cplx c;
|
||||
c.r = a.r - b.r;
|
||||
c.i = a.i - b.i;
|
||||
return c;
|
||||
}
|
||||
|
||||
cplx cplx_mul(cplx a, cplx b)
|
||||
{
|
||||
cplx c;
|
||||
c.r = a.r * b.r - a.i * b.i;
|
||||
c.i = a.i * b.r + a.r * b.i;
|
||||
return c;
|
||||
}
|
||||
|
||||
float cplx_abs(cplx a)
|
||||
{
|
||||
return sqrt(a.r * a.r + a.i * a.i);
|
||||
}
|
||||
|
||||
cplx cplx_sum(cplx p, const cplx * a, int n)
|
||||
{
|
||||
cplx s = {0.0, 0.0};
|
||||
cplx c = {1.0, 0.0};
|
||||
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
s = cplx_add(s, cplx_mul(a[i], c));
|
||||
c = cplx_mul(c, p);
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
cplx sig[100];
|
||||
|
||||
for(int i=0; i<100; i++)
|
||||
{
|
||||
sig[i].r = cos(i * 1.3);
|
||||
sig[i].i = sin(i * 1.3);
|
||||
}
|
||||
|
||||
cplx c = {1.0, 0.0};
|
||||
float phi = 0.1 * PI;
|
||||
cplx t;
|
||||
t.r = cos(phi); t.i = sin(phi);
|
||||
|
||||
float p[20], q[20];
|
||||
|
||||
for(int i=0; i<20; i++)
|
||||
{
|
||||
p[i] = cplx_abs(cplx_sum(c, sig, 100));
|
||||
c = cplx_mul(c, t);
|
||||
}
|
||||
|
||||
for(int i=0; i<20; i++)
|
||||
{
|
||||
float sumr = 0.0, sumi = 0.0;
|
||||
for(int j=0; j<100; j++)
|
||||
{
|
||||
float co = cos(i * j * 0.1 * PI), si = sin(i * j * 0.1 * PI);
|
||||
sumr += co * sig[j].r - si * sig[j].i;
|
||||
sumi += si * sig[j].r + co * sig[j].i;
|
||||
}
|
||||
q[i] = sqrt(sumr * sumr + sumi * sumi);
|
||||
}
|
||||
#if 1
|
||||
for(int i=0; i<20; i++)
|
||||
{
|
||||
printf("%d, %f - %f\n", i, p[i], q[i]);
|
||||
}
|
||||
#endif
|
||||
for(int i=0; i<20; i++)
|
||||
assert(fabs(p[i] - q[i]) < 1.0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
for(unsigned i=0; i<256; i+=11)
|
||||
{
|
||||
for(unsigned j=1; j<256; j++)
|
||||
{
|
||||
unsigned q = i / j, r = i % j;
|
||||
|
||||
assert(q * j + r == i);
|
||||
assert(r >= 0 && r < j);
|
||||
}
|
||||
}
|
||||
|
||||
for(unsigned i=0; i<7000; i+=11)
|
||||
{
|
||||
for(unsigned j=1; j<i; j*=3)
|
||||
{
|
||||
unsigned q = i / j, r = i % j;
|
||||
|
||||
assert(q * j + r == i);
|
||||
assert(r >= 0 && r < j);
|
||||
}
|
||||
}
|
||||
|
||||
for(unsigned i=0; i<64000; i+=121)
|
||||
{
|
||||
for(unsigned j=1; j<i; j*=3)
|
||||
{
|
||||
unsigned q = i / j, r = i % j;
|
||||
|
||||
assert(q * j + r == i);
|
||||
assert(r >= 0 && r < j);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
enum E {
|
||||
e1, e2, e3, e4
|
||||
};
|
||||
|
||||
int check(E e)
|
||||
{
|
||||
switch(e)
|
||||
{
|
||||
case e1:
|
||||
return 10;
|
||||
case e2:
|
||||
return 20;
|
||||
case e3:
|
||||
return 30;
|
||||
default:
|
||||
return 100;
|
||||
}
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
return check(e1) + check(e2) + check(e3) + check(e4) - 160;
|
||||
}
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int p1(int a, int b)
|
||||
{
|
||||
return a + b;
|
||||
}
|
||||
|
||||
int p2(int a, int b)
|
||||
{
|
||||
return a * b;
|
||||
}
|
||||
|
||||
int c1(int x)
|
||||
{
|
||||
return x;
|
||||
}
|
||||
|
||||
int c2(int x)
|
||||
{
|
||||
return c1(x);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
return p1(5, p2(c2(2), c2(4))) - 13;
|
||||
}
|
||||
|
||||
|
|
@ -1,90 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -12,50 +12,16 @@ bool flt(float a, float b)
|
|||
return a < b;
|
||||
}
|
||||
|
||||
bool fle(float a, float b)
|
||||
{
|
||||
return a <= b;
|
||||
}
|
||||
|
||||
bool fgt(float a, float b)
|
||||
{
|
||||
return a > b;
|
||||
}
|
||||
|
||||
bool fge(float a, float b)
|
||||
void cmpflt(float a, float b, bool eq, bool lt, bool gt)
|
||||
{
|
||||
return a >= b;
|
||||
}
|
||||
|
||||
|
||||
volatile float f;
|
||||
|
||||
inline void cmpflt(float a, float b, bool eq, bool lt, bool gt)
|
||||
{
|
||||
bool le = eq || lt;
|
||||
bool ge = eq || gt;
|
||||
|
||||
assert(feq(a, b) == eq);
|
||||
assert(flt(a, b) == lt);
|
||||
assert(fgt(a, b) == gt);
|
||||
assert(fle(a, b) == le);
|
||||
assert(fge(a, b) == ge);
|
||||
|
||||
f = a;
|
||||
|
||||
assert(feq(f, b) == eq);
|
||||
assert(flt(f, b) == lt);
|
||||
assert(fgt(f, b) == gt);
|
||||
assert(fle(f, b) == le);
|
||||
assert(fge(f, b) == ge);
|
||||
|
||||
f = b;
|
||||
|
||||
assert(feq(a, f) == eq);
|
||||
assert(flt(a, f) == lt);
|
||||
assert(fgt(a, f) == gt);
|
||||
assert(fle(a, f) == le);
|
||||
assert(fge(a, f) == ge);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
|
|
|
|||
|
|
@ -1,75 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -12,7 +12,7 @@ int main(void)
|
|||
|
||||
for(i=0; i<50; i++)
|
||||
{
|
||||
printf("%d %f %f %f\n", i, i * c, a, i * c - a);
|
||||
// printf("%d %f %f %f\n", i, i * c, a, i * c - a);
|
||||
assert(i * c == a);
|
||||
a += c;
|
||||
}
|
||||
|
|
@ -21,7 +21,7 @@ int main(void)
|
|||
|
||||
for(i=1; i<50; i++)
|
||||
{
|
||||
printf("%d %f %f %f\n", i, i * d, a, fabs(i * d - a) / i);
|
||||
// printf("%d %f %f %f\n", i, i * d, a, fabs(i * d - a) / i);
|
||||
assert(fabs(i * d - a) < i * 1.0e-6);
|
||||
a += d;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,32 +0,0 @@
|
|||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
printf("%f\n", 0.0);
|
||||
|
||||
|
||||
float x = 1.0, y = 1.0;
|
||||
|
||||
char xb[20], yb[20];
|
||||
for(int i=0; i<40; i++)
|
||||
{
|
||||
ftoa(x, xb); float xr = atof(xb);
|
||||
ftoa(y, yb); float yr = atof(yb);
|
||||
|
||||
printf("%20g (%s) %20g : %20g (%s) %20g : %10f %10f \n", x, xb, xr, y, yb, yr, fabs(x - xr) / x, fabs(y - yr) / y);
|
||||
|
||||
if (fabs(x - xr) / x > 0.00001 || fabs(y - yr) / y > 0.00001)
|
||||
return -1;
|
||||
|
||||
x *= 2.5;
|
||||
y *= 0.8;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
for(int y=1; y<100; y++)
|
||||
{
|
||||
float fz = 100.0 / (float)y;
|
||||
printf("%d %f %f\n", y, floor(fz * 100.0), fz * 100.0);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
|
||||
int (*funcs[10])(int);
|
||||
|
||||
#assign x 0
|
||||
#repeat
|
||||
int f##x(int i)
|
||||
{
|
||||
return i + x;
|
||||
}
|
||||
#assign x x + 1
|
||||
#until x == 10
|
||||
|
||||
int test(int k)
|
||||
{
|
||||
for(char i=0; i<10; i++)
|
||||
k = funcs[i](k);
|
||||
return k;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
#assign x 0
|
||||
#repeat
|
||||
funcs[x] = f##x;
|
||||
#assign x x + 1
|
||||
#until x == 10
|
||||
|
||||
int k = test(-45);
|
||||
return k;
|
||||
}
|
||||
|
|
@ -1,72 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
|
||||
|
||||
typedef float (*fop)(float a, float b);
|
||||
|
||||
float fadd(float a, float b)
|
||||
{
|
||||
return a + b;
|
||||
}
|
||||
|
||||
float fmul(float a, float b)
|
||||
{
|
||||
return a * b;
|
||||
}
|
||||
|
||||
|
||||
struct FNode
|
||||
{
|
||||
FNode * left, * right;
|
||||
float value;
|
||||
fop call;
|
||||
};
|
||||
|
||||
FNode * root;
|
||||
|
||||
float fevalB(FNode * f)
|
||||
{
|
||||
if (f->call)
|
||||
return f->call(fevalB(f->left), fevalB(f->right));
|
||||
else
|
||||
return f->value;
|
||||
}
|
||||
|
||||
float fevalN(FNode * f)
|
||||
{
|
||||
if (f->call)
|
||||
return f->call(fevalN(f->left), fevalN(f->right));
|
||||
else
|
||||
return f->value;
|
||||
}
|
||||
|
||||
#pragma native(fevalN)
|
||||
|
||||
FNode * bop(fop call, FNode * left, FNode * right)
|
||||
{
|
||||
FNode * f = (FNode *)malloc(sizeof(FNode));
|
||||
f->call = call;
|
||||
f->left = left;
|
||||
f->right = right;
|
||||
return f;
|
||||
}
|
||||
|
||||
FNode * bc(float value)
|
||||
{
|
||||
FNode * f = (FNode *)malloc(sizeof(FNode));
|
||||
f->value = value;
|
||||
return f;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
FNode * tree = bop(fadd, bop(fmul, bc(3), bc(5)), bc(6));
|
||||
|
||||
printf("Eval %f, %d\n", fevalB(tree), fevalN(tree));
|
||||
|
||||
assert(fevalB(tree) == 3 * 5 + 6);
|
||||
assert(fevalN(tree) == 3 * 5 + 6);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
|
||||
|
||||
void incv(int * a, int n)
|
||||
{
|
||||
for(int i=0; i<n; i++)
|
||||
a[i] ++;
|
||||
}
|
||||
|
||||
int t[100];
|
||||
|
||||
int main(void)
|
||||
{
|
||||
for(int i=0; i<100; i++)
|
||||
t[i] = i;
|
||||
incv(t, 100);
|
||||
int s = 0;
|
||||
for(int i=0; i<100; i++)
|
||||
s += t[i];
|
||||
|
||||
return s - 5050;
|
||||
}
|
||||
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
#include <gfx/bitmap.h>
|
||||
#include <assert.h>
|
||||
|
||||
|
||||
char * const Hires = (char *)0x4000;
|
||||
Bitmap Screen;
|
||||
ClipRect cr = {0, 0, 320, 200};
|
||||
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
bm_init(&Screen, Hires, 40, 25);
|
||||
|
||||
bmu_rect_clear(&Screen, 0, 0, 320, 200);
|
||||
|
||||
bm_line(&Screen, &cr, 0, 0, 199, 199, 0xff, LINOP_SET);
|
||||
|
||||
for(int i=0; i<200; i++)
|
||||
{
|
||||
assert(Hires[(i & 7) + 320 * (i >> 3) + (i & ~7)] == 0x80 >> (i & 7));
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
char a[200], b[200];
|
||||
bool ok = true;
|
||||
|
||||
int main(void)
|
||||
{
|
||||
#assign ni 0
|
||||
#repeat
|
||||
a[ni] = ni & 255;
|
||||
#assign ni ni + 1
|
||||
#until ni == 200
|
||||
|
||||
#assign ni 0
|
||||
#repeat
|
||||
if (ok)
|
||||
b[ni] = ni & 255;
|
||||
#assign ni ni + 1
|
||||
#until ni == 200
|
||||
|
||||
int asum = 0, bsum = 0, csum = 0;
|
||||
for(int i=0; i<200; i++)
|
||||
{
|
||||
asum += a[i];
|
||||
bsum += b[i];
|
||||
csum += i & 255;
|
||||
}
|
||||
|
||||
return asum + bsum - 2 * csum;
|
||||
}
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
struct S
|
||||
{
|
||||
int a[100];
|
||||
};
|
||||
|
||||
int lts(S * s)
|
||||
{
|
||||
int x = 0;
|
||||
for(int i=0; i<100; i++)
|
||||
x += s->a[i];
|
||||
return x;
|
||||
}
|
||||
|
||||
int les(S * s)
|
||||
{
|
||||
int x = 0;
|
||||
for(int i=0; i<=99; i++)
|
||||
x += s->a[i];
|
||||
return x;
|
||||
}
|
||||
|
||||
int gts(S * s)
|
||||
{
|
||||
int x = 0;
|
||||
for(int i=100; i>0; i--)
|
||||
x += s->a[i-1];
|
||||
return x;
|
||||
}
|
||||
|
||||
int ges(S * s)
|
||||
{
|
||||
int x = 0;
|
||||
for(int i=99; i>=0; i--)
|
||||
x += s->a[i];
|
||||
return x;
|
||||
}
|
||||
|
||||
int ltu(S * s)
|
||||
{
|
||||
unsigned x = 0;
|
||||
for(int i=0; i<100; i++)
|
||||
x += s->a[i];
|
||||
return x;
|
||||
}
|
||||
|
||||
int leu(S * s)
|
||||
{
|
||||
unsigned x = 0;
|
||||
for(int i=0; i<=99; i++)
|
||||
x += s->a[i];
|
||||
return x;
|
||||
}
|
||||
|
||||
int gtu(S * s)
|
||||
{
|
||||
unsigned x = 0;
|
||||
for(int i=100; i>0; i--)
|
||||
x += s->a[i-1];
|
||||
return x;
|
||||
}
|
||||
|
||||
int geu(S * s)
|
||||
{
|
||||
unsigned x = 0;
|
||||
for(int i=100; i>=1; i--)
|
||||
x += s->a[i-1];
|
||||
return x;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
S s;
|
||||
|
||||
int k = 0;
|
||||
for(int i=0; i<100; i++)
|
||||
{
|
||||
int t = (i & 15) + 3;
|
||||
s.a[i] = t;
|
||||
k += t;
|
||||
}
|
||||
|
||||
assert(lts(&s) == k);
|
||||
assert(les(&s) == k);
|
||||
assert(gts(&s) == k);
|
||||
assert(ges(&s) == k);
|
||||
assert(ltu(&s) == k);
|
||||
assert(leu(&s) == k);
|
||||
assert(gtu(&s) == k);
|
||||
assert(geu(&s) == k);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int a[10][10];
|
||||
|
||||
for(int i=0; i<10; i++)
|
||||
{
|
||||
for(int j=0; j<10; j++)
|
||||
{
|
||||
a[i][j] = i + j;
|
||||
}
|
||||
}
|
||||
|
||||
int s = 0;
|
||||
|
||||
for(int i=0; i<10; i++)
|
||||
{
|
||||
s += a[i][i];
|
||||
}
|
||||
|
||||
|
||||
assert(s == 90);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,60 +0,0 @@
|
|||
SRCS=$(filter-out opp_part1.cpp opp_part2.cpp, $(wildcard *.c *.cpp))
|
||||
EXES=$(patsubst %.c,%,$(SRCS))
|
||||
EXES:=$(patsubst %.cpp,%,$(EXES))
|
||||
|
||||
all: $(EXES)
|
||||
|
||||
%: %.c
|
||||
$(OSCAR64_CC) -e -bc $<
|
||||
$(OSCAR64_CC) -e -n $<
|
||||
$(OSCAR64_CC) -e -O2 -bc $<
|
||||
$(OSCAR64_CC) -e -O2 -n $<
|
||||
$(OSCAR64_CC) -e -O0 -bc $<
|
||||
$(OSCAR64_CC) -e -O0 -n $<
|
||||
$(OSCAR64_CC) -e -Os -bc $<
|
||||
$(OSCAR64_CC) -e -Os -n $<
|
||||
$(OSCAR64_CC) -e -O3 -bc $<
|
||||
$(OSCAR64_CC) -e -O3 -n $<
|
||||
|
||||
%: %.cpp
|
||||
$(OSCAR64_CXX) -e -bc $<
|
||||
$(OSCAR64_CXX) -e -n $<
|
||||
$(OSCAR64_CXX) -e -O2 -bc $<
|
||||
$(OSCAR64_CXX) -e -O2 -n $<
|
||||
$(OSCAR64_CXX) -e -O0 -bc $<
|
||||
$(OSCAR64_CXX) -e -O0 -n $<
|
||||
$(OSCAR64_CXX) -e -Os -bc $<
|
||||
$(OSCAR64_CXX) -e -Os -n $<
|
||||
$(OSCAR64_CXX) -e -O3 -bc $<
|
||||
$(OSCAR64_CXX) -e -O3 -n $<
|
||||
|
||||
# testb
|
||||
bitshifttest: bitshifttest.c
|
||||
$(OSCAR64_CC) -e -bc $<
|
||||
$(OSCAR64_CC) -e -bc -O2 $<
|
||||
$(OSCAR64_CC) -e -bc -O0 $<
|
||||
$(OSCAR64_CC) -e -bc -Os $<
|
||||
$(OSCAR64_CC) -e -bc -O3 $<
|
||||
$(OSCAR64_CC) -e -n $<
|
||||
|
||||
# testn
|
||||
stripedarraytest: stripedarraytest.c
|
||||
$(OSCAR64_CC) -e -O2 -n $<
|
||||
$(OSCAR64_CC) -e -O0 -n $<
|
||||
$(OSCAR64_CC) -e -Os -n $<
|
||||
$(OSCAR64_CC) -e -O3 -n $<
|
||||
|
||||
autorefreturn: autorefreturn.cpp
|
||||
$(OSCAR64_CC) -e -O2 -n $<
|
||||
$(OSCAR64_CC) -e -O0 -n $<
|
||||
$(OSCAR64_CC) -e -Os -n $<
|
||||
$(OSCAR64_CC) -e -O3 -n $<
|
||||
|
||||
copyconstructor: copyconstructor.cpp
|
||||
$(OSCAR64_CC) -e -O2 -n $<
|
||||
$(OSCAR64_CC) -e -O0 -n $<
|
||||
$(OSCAR64_CC) -e -Os -n $<
|
||||
$(OSCAR64_CC) -e -O3 -n $<
|
||||
|
||||
clean:
|
||||
@$(RM) *.asm *.bcs *.int *.lbl *.map *.prg
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
for(int i=0; i<1000; i++)
|
||||
{
|
||||
float w = 0.0123 * i;
|
||||
float co = cos(w), si = sin(w);
|
||||
|
||||
float r = co * co + si * si;
|
||||
|
||||
assert(fabs(r - 1) < 0.001);
|
||||
|
||||
assert(fabs(sqrt(w * w) - w) < 0.001);
|
||||
|
||||
float aw = atan2(si, co);
|
||||
|
||||
float co2 = cos(aw), si2 = sin(aw);
|
||||
|
||||
assert(fabs(co2 - co) < 0.001);
|
||||
assert(fabs(si2 - si) < 0.001);
|
||||
|
||||
float ex = exp(w), em = exp(-w);
|
||||
|
||||
assert(fabs(log(ex) - w) < 0.001);
|
||||
assert(fabs(log(em) + w) < 0.001);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
#include <string.h>
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
unsigned b[4096];
|
||||
|
||||
void testfwd(unsigned sz)
|
||||
{
|
||||
for(unsigned i=0; i<4096; i++)
|
||||
b[i] = i;
|
||||
|
||||
memmove(b + 100, b + 101, 2 * sz);
|
||||
|
||||
for(unsigned i=0; i<100; i++)
|
||||
assert(b[i] == i);
|
||||
for(unsigned i=100; i<100 + sz; i++)
|
||||
assert(b[i] == i + 1);
|
||||
for(unsigned i=100 + sz; i<4096; i++)
|
||||
assert(b[i] == i);
|
||||
}
|
||||
|
||||
void testback(unsigned sz)
|
||||
{
|
||||
for(unsigned i=0; i<4096; i++)
|
||||
b[i] = i;
|
||||
|
||||
memmove(b + 101, b + 100, 2 * sz);
|
||||
|
||||
for(unsigned i=0; i<101; i++)
|
||||
assert(b[i] == i);
|
||||
for(unsigned i=101; i<101 + sz; i++)
|
||||
assert(b[i] == i - 1);
|
||||
for(unsigned i=101 + sz; i<4096; i++)
|
||||
assert(b[i] == i);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
for(unsigned i=1; i<2048; i *= 2)
|
||||
{
|
||||
testfwd(i - 1);
|
||||
testfwd(i);
|
||||
testback(i);
|
||||
testback(i - 1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
unsigned n1, n0;
|
||||
|
||||
n1 = 0; n0 = 0;
|
||||
for(int i=-1000; i<2000; i+=37)
|
||||
{
|
||||
for(char j=0; j<255; j++)
|
||||
{
|
||||
if (i < j)
|
||||
n1++;
|
||||
else
|
||||
n0++;
|
||||
}
|
||||
}
|
||||
|
||||
assert(n1 == 7893 && n0 == 13017);
|
||||
|
||||
n1 = 0; n0 = 0;
|
||||
for(int i=-1000; i<2000; i+=37)
|
||||
{
|
||||
for(char j=0; j<255; j++)
|
||||
{
|
||||
if (i <= j)
|
||||
n1++;
|
||||
else
|
||||
n0++;
|
||||
}
|
||||
}
|
||||
|
||||
assert(n1 == 7899 && n0 == 13011);
|
||||
|
||||
n1 = 0; n0 = 0;
|
||||
for(int i=-1000; i<2000; i+=37)
|
||||
{
|
||||
for(char j=0; j<255; j++)
|
||||
{
|
||||
if (i >= j)
|
||||
n1++;
|
||||
else
|
||||
n0++;
|
||||
}
|
||||
}
|
||||
|
||||
assert(n0 == 7893 && n1 == 13017);
|
||||
|
||||
n1 = 0; n0 = 0;
|
||||
for(int i=-1000; i<2000; i+=37)
|
||||
{
|
||||
for(char j=0; j<255; j++)
|
||||
{
|
||||
if (i > j)
|
||||
n1++;
|
||||
else
|
||||
n0++;
|
||||
}
|
||||
}
|
||||
|
||||
assert(n0 == 7899 && n1 == 13011);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,43 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,90 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
struct A
|
||||
{
|
||||
int n;
|
||||
|
||||
A(int n_)
|
||||
: n(n_) {}
|
||||
|
||||
A(const A & a)
|
||||
: n(a.n) {}
|
||||
|
||||
A operator+(const A & a) const
|
||||
{
|
||||
return A(n + a.n);
|
||||
}
|
||||
|
||||
A operator-(const A & a) const
|
||||
{
|
||||
return A(n - a.n);
|
||||
}
|
||||
|
||||
A & operator+=(const A & a)
|
||||
{
|
||||
n += a.n;
|
||||
return *this;
|
||||
}
|
||||
|
||||
A & operator-=(const A & a)
|
||||
{
|
||||
n -= a.n;
|
||||
return *this;
|
||||
}
|
||||
|
||||
A operator-(void) const
|
||||
{
|
||||
return A(-n);
|
||||
}
|
||||
|
||||
A & operator++(void)
|
||||
{
|
||||
n++;
|
||||
return *this;
|
||||
}
|
||||
|
||||
A & operator--(void)
|
||||
{
|
||||
n--;
|
||||
return *this;
|
||||
}
|
||||
|
||||
A operator++(int);
|
||||
|
||||
A operator--(int);
|
||||
|
||||
};
|
||||
|
||||
A A::operator++(int)
|
||||
{
|
||||
A a(*this);
|
||||
n++;
|
||||
return a;
|
||||
}
|
||||
|
||||
A A::operator--(int)
|
||||
{
|
||||
A a(*this);
|
||||
n--;
|
||||
return a;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
A a(7), b(8), c(9);
|
||||
|
||||
assert((++a).n == 8);
|
||||
assert(a.n == 8);
|
||||
|
||||
assert((--a).n == 7);
|
||||
assert(a.n == 7);
|
||||
|
||||
assert((a++).n == 7);
|
||||
assert(a.n == 8);
|
||||
assert((a--).n == 8);
|
||||
assert(a.n == 7);
|
||||
|
||||
assert((a + b - c + -a + -b - -c).n == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
#include "opp_part1.h"
|
||||
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
#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")
|
||||
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
#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")
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
#include <opp/string.h>
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
#include <opp/sstream.h>
|
||||
#include <math.h>
|
||||
|
||||
using opp::ostringstream;
|
||||
using opp::istringstream;
|
||||
using opp::endl;
|
||||
|
||||
float fdist(float a, float b)
|
||||
{
|
||||
float d = fabs(a - b);
|
||||
a = fabs(a);
|
||||
b = fabs(b);
|
||||
return d / (a > b ? a : b);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
ostringstream os;
|
||||
|
||||
for(int i=0; i<40; i++)
|
||||
{
|
||||
os << i << endl;
|
||||
}
|
||||
|
||||
istringstream is(os.str());
|
||||
|
||||
int j = 0, k = 47;
|
||||
#if 1
|
||||
|
||||
while (is >> k)
|
||||
{
|
||||
assert(k == j++);
|
||||
}
|
||||
|
||||
assert(j == 40);
|
||||
#endif
|
||||
os.str(opp::string());
|
||||
|
||||
#if 0
|
||||
cout << "[" << os.str() << "]" << endl;
|
||||
os << "HELLO";
|
||||
cout << "[" << os.str() << "]" << endl;
|
||||
#endif
|
||||
#if 1
|
||||
|
||||
float f = 1.0, g = 1.0;
|
||||
|
||||
for(int i=0; i<10; i++)
|
||||
{
|
||||
os << f << " " << g << endl;
|
||||
// cout << os.str();
|
||||
|
||||
f *= 5.1;
|
||||
g *= 0.12;
|
||||
}
|
||||
|
||||
|
||||
is.str(os.str());
|
||||
|
||||
f = 1.0, g = 1.0;
|
||||
|
||||
float fr, gr;
|
||||
|
||||
j = 0;
|
||||
while (is >> fr >> gr)
|
||||
{
|
||||
// cout << f << " " << fr << ", " << g << " " << gr << ", " << fdist(fr, f) << endl;
|
||||
|
||||
assert(fdist(fr, f) < 1.0e-5);
|
||||
assert(fdist(gr, g) < 1.0e-5);
|
||||
|
||||
f *= 5.1;
|
||||
g *= 0.12;
|
||||
j++;
|
||||
}
|
||||
|
||||
assert(j == 10);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,103 +0,0 @@
|
|||
#include <opp/string.h>
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
using opp::string;
|
||||
|
||||
static const char HelloWorld[] = "Hello World";
|
||||
static const char AndBeyond[] = "And Beyond";
|
||||
static const char And[] = "And";
|
||||
static const char HelloWorldAndBeyond[] = "Hello World And Beyond";
|
||||
|
||||
__noinline void test_create(void)
|
||||
{
|
||||
string s1();
|
||||
string s2(HelloWorld);
|
||||
string s3(s2);
|
||||
string s4('a');
|
||||
|
||||
assert(!strcmp(s2.tocstr(), HelloWorld));
|
||||
assert(!strcmp(s3.tocstr(), HelloWorld));
|
||||
assert(s4.size() == 1 && s4[0] == 'a');
|
||||
}
|
||||
|
||||
__noinline void test_concat(void)
|
||||
{
|
||||
string s1();
|
||||
string s2(HelloWorld);
|
||||
string s3(AndBeyond);
|
||||
|
||||
string s4 = s1 + s2;
|
||||
string s5 = s2 + " " + s3;
|
||||
string s6 = s2 + " " + AndBeyond;
|
||||
|
||||
assert(!strcmp(s4.tocstr(), HelloWorld));
|
||||
assert(!strcmp(s5.tocstr(), HelloWorldAndBeyond));
|
||||
assert(!strcmp(s6.tocstr(), HelloWorldAndBeyond));
|
||||
}
|
||||
|
||||
__noinline void test_find(void)
|
||||
{
|
||||
string s1(HelloWorldAndBeyond);
|
||||
string s2(And);
|
||||
|
||||
assert(s1.find(HelloWorld) == 0);
|
||||
assert(s1.find(AndBeyond) == 12);
|
||||
assert(s1.find(And) == 12);
|
||||
assert(s1.find(s2) == 12);
|
||||
|
||||
assert(s1.find(' ') == 5);
|
||||
assert(s1.find(' ', 6) == 11);
|
||||
}
|
||||
|
||||
__noinline void test_assign(void)
|
||||
{
|
||||
string s1(HelloWorld);
|
||||
string s2(AndBeyond);
|
||||
string s3;
|
||||
s3 = s1;
|
||||
s3 = s2;
|
||||
s3 = s1;
|
||||
s3 += " ";
|
||||
s3 += s2;
|
||||
|
||||
assert(!strcmp(s3.tocstr(), HelloWorldAndBeyond));
|
||||
|
||||
s3 <<= 12;
|
||||
|
||||
assert(!strcmp(s3.tocstr(), AndBeyond));
|
||||
|
||||
s3 = HelloWorldAndBeyond;
|
||||
|
||||
assert(!strcmp(s3.tocstr(), HelloWorldAndBeyond));
|
||||
|
||||
s3 >>= 11;
|
||||
|
||||
assert(!strcmp(s3.tocstr(), HelloWorld));
|
||||
}
|
||||
|
||||
static char * test;
|
||||
|
||||
int main(void)
|
||||
{
|
||||
test = new char;
|
||||
|
||||
unsigned avail = heapfree();
|
||||
|
||||
test_create();
|
||||
assert(avail == heapfree());
|
||||
|
||||
test_concat();
|
||||
assert(avail == heapfree());
|
||||
|
||||
test_find();
|
||||
assert(avail == heapfree());
|
||||
|
||||
test_assign();
|
||||
assert(avail == heapfree());
|
||||
|
||||
delete test;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,193 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,145 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
struct X
|
||||
{
|
||||
int a;
|
||||
};
|
||||
|
||||
X x[5] = {
|
||||
{1}, {2}, {3}, {4}, {5}
|
||||
};
|
||||
|
||||
X * y;
|
||||
|
||||
int main(void)
|
||||
{
|
||||
y = x;
|
||||
assert(y == x);
|
||||
y = x + 1;
|
||||
assert(y == x + 1);
|
||||
y = &(x[2]);
|
||||
assert(y == x + 2);
|
||||
y = x + 3;
|
||||
assert(y == &(x[3]));
|
||||
y = x ;
|
||||
assert(y == (struct X*)x);
|
||||
|
||||
y = x;
|
||||
assert(x == y);
|
||||
y = x + 1;
|
||||
assert(x + 1 == y);
|
||||
y = &(x[2]);
|
||||
assert(x + 2 == y);
|
||||
y = x + 3;
|
||||
assert(&(x[3]) == y);
|
||||
y = x ;
|
||||
assert((struct X*)x == y);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
#if 1
|
||||
|
||||
const struct A {
|
||||
char w;
|
||||
int b[5];
|
||||
struct {
|
||||
int c[5];
|
||||
} o;
|
||||
} a = {22,
|
||||
{4, 5, 6, 7, 8},
|
||||
{
|
||||
{4, 5, 6, 7, 8}
|
||||
}
|
||||
};
|
||||
|
||||
const int * t[4] = {
|
||||
a.b + 1 + 1
|
||||
};
|
||||
|
||||
const int * v[4] = {
|
||||
a.o.c + 1 + 1
|
||||
};
|
||||
|
||||
int q[5] = {4, 5, 6, 7, 8};
|
||||
|
||||
const int * u[4] = {
|
||||
q + 2
|
||||
};
|
||||
|
||||
int main(void)
|
||||
{
|
||||
return
|
||||
u[0][0] + (q + 2)[2] - 6 - 8 +
|
||||
v[0][0] + (a.o.c + 2)[2] - 6 - 8 +
|
||||
t[0][0] + (a.b + 2)[2] - 6 - 8;
|
||||
}
|
||||
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
struct Node
|
||||
{
|
||||
int a;
|
||||
char s[10];
|
||||
};
|
||||
|
||||
void qsort(Node * n, int s)
|
||||
{
|
||||
if (s > 1)
|
||||
{
|
||||
Node pn = n[0];
|
||||
int pi = 0;
|
||||
for(int i=1; i<s; i++)
|
||||
{
|
||||
if (strcmp(n[i].s, pn.s) < 0)
|
||||
{
|
||||
n[pi] = n[i];
|
||||
pi++;
|
||||
n[i] = n[pi];
|
||||
}
|
||||
}
|
||||
n[pi] = pn;
|
||||
|
||||
qsort(n, pi);
|
||||
qsort(n + pi + 1, s - pi - 1);
|
||||
}
|
||||
}
|
||||
|
||||
void shuffle(Node * n, int s)
|
||||
{
|
||||
for(int i=0; i<s; i++)
|
||||
{
|
||||
int t = rand() % s;
|
||||
Node nt = n[i]; n[i] = n[t]; n[t] = nt;
|
||||
}
|
||||
}
|
||||
|
||||
void init(Node * n, int s)
|
||||
{
|
||||
for(int i=0; i<s; i++)
|
||||
{
|
||||
n[i].a = i;
|
||||
sprintf(n[i].s, "%.5d", i);
|
||||
}
|
||||
}
|
||||
|
||||
static const int size = 1000;
|
||||
|
||||
Node field[size];
|
||||
|
||||
void show(Node * n, int s)
|
||||
{
|
||||
for(int i=0; i<s; i++)
|
||||
{
|
||||
printf("%3d : %3d, %s\n", i, n[i].a, n[i].s);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
void check(Node * n, int s)
|
||||
{
|
||||
for(int i=0; i<s; i++)
|
||||
{
|
||||
assert(n[i].a == i);
|
||||
}
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
init(field, size);
|
||||
// show(field, size);
|
||||
shuffle(field, size);
|
||||
// show(field, size);
|
||||
qsort(field, size);
|
||||
// show(field, size);
|
||||
check(field, size);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
// randsumtest
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
long lsum = 0;
|
||||
for(unsigned i=0; i<1000; i++)
|
||||
lsum += rand();
|
||||
|
||||
assert(lsum == 32157742L);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1,7 +1,6 @@
|
|||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int fib(int a)
|
||||
{
|
||||
|
|
@ -76,7 +75,7 @@ void btest(void)
|
|||
}
|
||||
|
||||
collect(tree, buff)[0] = 0;
|
||||
|
||||
|
||||
assert(strcmp(buff, " DEHLLLOORW") == 0);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,76 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,107 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
#define Screen ((char *)0x0400)
|
||||
|
||||
void scroll_left(void)
|
||||
{
|
||||
char * dp = Screen;
|
||||
for(char y=0; y<25; y++)
|
||||
{
|
||||
for(char x=0; x<39; x++)
|
||||
{
|
||||
dp[x] = dp[x + 1];
|
||||
}
|
||||
dp += 40;
|
||||
}
|
||||
}
|
||||
|
||||
void scroll_right(void)
|
||||
{
|
||||
char * dp = Screen;
|
||||
for(char y=0; y<25; y++)
|
||||
{
|
||||
for(char x=39; x>0; x--)
|
||||
{
|
||||
dp[x] = dp[x - 1];
|
||||
}
|
||||
dp += 40;
|
||||
}
|
||||
}
|
||||
|
||||
void scroll_up(void)
|
||||
{
|
||||
char * dp = Screen, * sp = dp + 40;
|
||||
for(char y=0; y<24; y++)
|
||||
{
|
||||
for(char x=0; x<40; x++)
|
||||
{
|
||||
dp[x] = sp[x];
|
||||
}
|
||||
dp = sp;
|
||||
sp += 40;
|
||||
}
|
||||
}
|
||||
|
||||
void scroll_down(void)
|
||||
{
|
||||
char * dp = Screen + 24 * 40, * sp = dp - 40;
|
||||
for(char y=0; y<24; y++)
|
||||
{
|
||||
for(char x=0; x<40; x++)
|
||||
{
|
||||
dp[x] = sp[x];
|
||||
}
|
||||
dp = sp;
|
||||
sp -= 40;
|
||||
}
|
||||
}
|
||||
|
||||
void fill_screen(void)
|
||||
{
|
||||
for(char y=0; y<25; y++)
|
||||
{
|
||||
for(char x=0; x<40; x++)
|
||||
{
|
||||
Screen[40 * y + x] = 7 * y + x;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void check_screen(int dy, int dx)
|
||||
{
|
||||
for(int y=0; y<25; y++)
|
||||
{
|
||||
for(int x=0; x<40; x++)
|
||||
{
|
||||
int sy = y + dy;
|
||||
int sx = x + dx;
|
||||
|
||||
char c = 7 * y + x;
|
||||
if (sy >= 0 && sy < 25 && sx >= 0 && sx < 40)
|
||||
c = 7 * sy + sx;
|
||||
|
||||
assert(Screen[40 * y + x] == c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
fill_screen();
|
||||
scroll_left();
|
||||
check_screen(0, 1);
|
||||
|
||||
fill_screen();
|
||||
scroll_right();
|
||||
check_screen(0, -1);
|
||||
|
||||
fill_screen();
|
||||
scroll_up();
|
||||
check_screen(1, 0);
|
||||
|
||||
fill_screen();
|
||||
scroll_down();
|
||||
check_screen(-1, 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,321 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
void testi(const char * fmt, int val, const char * tst)
|
||||
{
|
||||
char buffer[32];
|
||||
|
||||
sprintf(buffer, fmt, val);
|
||||
printf("%s:%s\n", buffer, tst);
|
||||
assert(!strcmp(buffer, tst));
|
||||
}
|
||||
|
||||
void testu(const char * fmt, unsigned val, const char * tst)
|
||||
{
|
||||
char buffer[32];
|
||||
|
||||
sprintf(buffer, fmt, val);
|
||||
printf("%s:%s\n", buffer, tst);
|
||||
assert(!strcmp(buffer, tst));
|
||||
}
|
||||
|
||||
void testil(const char * fmt, long val, const char * tst)
|
||||
{
|
||||
char buffer[32];
|
||||
|
||||
sprintf(buffer, fmt, val);
|
||||
printf("%s:%s\n", buffer, tst);
|
||||
assert(!strcmp(buffer, tst));
|
||||
}
|
||||
|
||||
void testul(const char * fmt, unsigned long val, const char * tst)
|
||||
{
|
||||
char buffer[32];
|
||||
|
||||
sprintf(buffer, fmt, val);
|
||||
printf("%s:%s\n", buffer, tst);
|
||||
assert(!strcmp(buffer, tst));
|
||||
}
|
||||
|
||||
void testf(const char * fmt, float val, const char * tst)
|
||||
{
|
||||
char buffer[32];
|
||||
|
||||
sprintf(buffer, fmt, val);
|
||||
printf("%s:%s\n", buffer, tst);
|
||||
assert(!strcmp(buffer, tst));
|
||||
}
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
testi("%d", 0, "0");
|
||||
testi("%d", 1, "1");
|
||||
testi("%d", -1, "-1");
|
||||
testi("%d", 12, "12");
|
||||
testi("%d", 123, "123");
|
||||
testi("%d", 1234, "1234");
|
||||
testi("%d", 12345, "12345");
|
||||
testi("%d", -12345, "-12345");
|
||||
testi("%d", 32767, "32767");
|
||||
testi("%d", -32768, "-32768");
|
||||
|
||||
testi("%3d", 0, " 0");
|
||||
testi("%3d", 1, " 1");
|
||||
testi("%3d", -1, " -1");
|
||||
testi("%3d", 12, " 12");
|
||||
testi("%3d", 123, "123");
|
||||
testi("%3d", 1234, "1234");
|
||||
testi("%3d", 12345, "12345");
|
||||
testi("%3d", -12345, "-12345");
|
||||
testi("%3d", 32767, "32767");
|
||||
testi("%3d", -32768, "-32768");
|
||||
|
||||
testi("%03d", 0, "000");
|
||||
testi("%03d", 1, "001");
|
||||
// testi("%03d", -1, "-01");
|
||||
testi("%03d", 12, "012");
|
||||
testi("%03d", 123, "123");
|
||||
testi("%03d", 1234, "1234");
|
||||
testi("%03d", 12345, "12345");
|
||||
testi("%03d", -12345, "-12345");
|
||||
testi("%03d", 32767, "32767");
|
||||
testi("%03d", -32768, "-32768");
|
||||
|
||||
testi("%-4d", 0, "0 ");
|
||||
testi("%-4d", 1, "1 ");
|
||||
testi("%-4d", -1, "-1 ");
|
||||
testi("%-4d", 12, "12 ");
|
||||
testi("%-4d", 123, "123 ");
|
||||
testi("%-4d", 1234, "1234");
|
||||
testi("%-4d", 12345, "12345");
|
||||
testi("%-4d", -12345, "-12345");
|
||||
testi("%-4d", 32767, "32767");
|
||||
testi("%-4d", -32768, "-32768");
|
||||
|
||||
testi("%+d", 0, "+0");
|
||||
testi("%+d", 1, "+1");
|
||||
testi("%+d", -1, "-1");
|
||||
testi("%+d", 12, "+12");
|
||||
testi("%+d", 123, "+123");
|
||||
testi("%+d", 1234, "+1234");
|
||||
testi("%+d", 12345, "+12345");
|
||||
testi("%+d", -12345, "-12345");
|
||||
testi("%+d", 32767, "+32767");
|
||||
testi("%+d", -32768, "-32768");
|
||||
|
||||
|
||||
|
||||
testil("%ld", 0l, "0");
|
||||
testil("%ld", 1l, "1");
|
||||
testil("%ld", -1l, "-1");
|
||||
testil("%ld", 12l, "12");
|
||||
testil("%ld", 123l, "123");
|
||||
testil("%ld", 1234l, "1234");
|
||||
testil("%ld", 12345l, "12345");
|
||||
testil("%ld", -12345l, "-12345");
|
||||
testil("%ld", 32767l, "32767");
|
||||
testil("%ld", -32768l, "-32768");
|
||||
testil("%ld", 2147483647l, "2147483647");
|
||||
testil("%ld", -2147483648l, "-2147483648");
|
||||
|
||||
testil("%3ld", 0l, " 0");
|
||||
testil("%3ld", 1l, " 1");
|
||||
testil("%3ld", -1l, " -1");
|
||||
testil("%3ld", 12l, " 12");
|
||||
testil("%3ld", 123l, "123");
|
||||
testil("%3ld", 1234l, "1234");
|
||||
testil("%3ld", 12345l, "12345");
|
||||
testil("%3ld", -12345l, "-12345");
|
||||
testil("%3ld", 32767l, "32767");
|
||||
testil("%3ld", -32768l, "-32768");
|
||||
testil("%3ld", 2147483647l, "2147483647");
|
||||
testil("%3ld", -2147483648l, "-2147483648");
|
||||
|
||||
testil("%03ld", 0l, "000");
|
||||
testil("%03ld", 1l, "001");
|
||||
// testil("%03ld", -1l, "-01");
|
||||
testil("%03ld", 12l, "012");
|
||||
testil("%03ld", 123l, "123");
|
||||
testil("%03ld", 1234l, "1234");
|
||||
testil("%03ld", 12345l, "12345");
|
||||
testil("%03ld", -12345l, "-12345");
|
||||
testil("%03ld", 32767l, "32767");
|
||||
testil("%03ld", -32768l, "-32768");
|
||||
testil("%03ld", 2147483647l, "2147483647");
|
||||
testil("%03ld", -2147483648l, "-2147483648");
|
||||
|
||||
testil("%-4ld", 0l, "0 ");
|
||||
testil("%-4ld", 1l, "1 ");
|
||||
testil("%-4ld", -1l, "-1 ");
|
||||
testil("%-4ld", 12l, "12 ");
|
||||
testil("%-4ld", 123l, "123 ");
|
||||
testil("%-4ld", 1234l, "1234");
|
||||
testil("%-4ld", 12345l, "12345");
|
||||
testil("%-4ld", -12345l, "-12345");
|
||||
testil("%-4ld", 32767l, "32767");
|
||||
testil("%-4ld", -32768l, "-32768");
|
||||
testil("%-4ld", 2147483647l, "2147483647");
|
||||
testil("%-4ld", -2147483648l, "-2147483648");
|
||||
|
||||
testil("%+ld", 0l, "+0");
|
||||
testil("%+ld", 1l, "+1");
|
||||
testil("%+ld", -1l, "-1");
|
||||
testil("%+ld", 12l, "+12");
|
||||
testil("%+ld", 123l, "+123");
|
||||
testil("%+ld", 1234l, "+1234");
|
||||
testil("%+ld", 12345l, "+12345");
|
||||
testil("%+ld", -12345l, "-12345");
|
||||
testil("%+ld", 32767l, "+32767");
|
||||
testil("%+ld", -32768l, "-32768");
|
||||
testil("%+ld", 2147483647l, "+2147483647");
|
||||
testil("%+ld", -2147483648l, "-2147483648");
|
||||
|
||||
testu("%u", 0, "0");
|
||||
testu("%u", 1, "1");
|
||||
testu("%u", 12, "12");
|
||||
testu("%u", 123, "123");
|
||||
testu("%u", 1234, "1234");
|
||||
testu("%u", 12345, "12345");
|
||||
testu("%u", 32767, "32767");
|
||||
testu("%u", 32768, "32768");
|
||||
testu("%u", 65535, "65535");
|
||||
testu("%x", 0, "0");
|
||||
testu("%x", 0x49bf, "49BF");
|
||||
testu("%x", 0xffff, "FFFF");
|
||||
|
||||
testu("%3u", 0, " 0");
|
||||
testu("%3u", 1, " 1");
|
||||
testu("%3u", 12, " 12");
|
||||
testu("%3u", 123, "123");
|
||||
testu("%3u", 1234, "1234");
|
||||
testu("%3u", 12345, "12345");
|
||||
testu("%3u", 32767, "32767");
|
||||
testu("%3u", 32768, "32768");
|
||||
testu("%3u", 65535, "65535");
|
||||
testu("%3x", 0, " 0");
|
||||
testu("%3x", 0x49bf, "49BF");
|
||||
testu("%3x", 0xffff, "FFFF");
|
||||
|
||||
testu("%03u", 0, "000");
|
||||
testu("%03u", 1, "001");
|
||||
testu("%03u", 12, "012");
|
||||
testu("%03u", 123, "123");
|
||||
testu("%03u", 1234, "1234");
|
||||
testu("%03u", 12345, "12345");
|
||||
testu("%03u", 32767, "32767");
|
||||
testu("%03u", 32768, "32768");
|
||||
testu("%03u", 65535, "65535");
|
||||
testu("%03x", 0, "000");
|
||||
testu("%03x", 0x49bf, "49BF");
|
||||
testu("%03x", 0xffff, "FFFF");
|
||||
|
||||
testu("%-4u", 0, "0 ");
|
||||
testu("%-4u", 1, "1 ");
|
||||
testu("%-4u", 12, "12 ");
|
||||
testu("%-4u", 123, "123 ");
|
||||
testu("%-4u", 1234, "1234");
|
||||
testu("%-4u", 12345, "12345");
|
||||
testu("%-4u", 32767, "32767");
|
||||
testu("%-4u", 32768, "32768");
|
||||
testu("%-4u", 65535, "65535");
|
||||
testu("%-4x", 0, "0 ");
|
||||
testu("%-4x", 0x49bf, "49BF");
|
||||
testu("%-4x", 0xffff, "FFFF");
|
||||
|
||||
testul("%3lu", 0l, " 0");
|
||||
testul("%3lu", 1l, " 1");
|
||||
testul("%3lu", 12l, " 12");
|
||||
testul("%3lu", 123l, "123");
|
||||
testul("%3lu", 1234l, "1234");
|
||||
testul("%3lu", 12345l, "12345");
|
||||
testul("%3lu", 32767l, "32767");
|
||||
testul("%3lu", 2147483647l, "2147483647");
|
||||
testul("%3lu", 4294967295l, "4294967295");
|
||||
testul("%3lx", 0, " 0");
|
||||
testul("%3lx", 0x3576fbcdl, "3576FBCD");
|
||||
testul("%3lx", 0xffffffffl, "FFFFFFFF");
|
||||
|
||||
testul("%03lu", 0l, "000");
|
||||
testul("%03lu", 1l, "001");
|
||||
testul("%03lu", 12l, "012");
|
||||
testul("%03lu", 123l, "123");
|
||||
testul("%03lu", 1234l, "1234");
|
||||
testul("%03lu", 12345l, "12345");
|
||||
testul("%03lu", 32767l, "32767");
|
||||
testul("%03lu", 2147483647l, "2147483647");
|
||||
testul("%03lu", 4294967295l, "4294967295");
|
||||
testul("%03lx", 0, "000");
|
||||
testul("%03lx", 0x3576fbcdl, "3576FBCD");
|
||||
testul("%03lx", 0xffffffffl, "FFFFFFFF");
|
||||
|
||||
testul("%-4lu", 0l, "0 ");
|
||||
testul("%-4lu", 1l, "1 ");
|
||||
testul("%-4lu", 12l, "12 ");
|
||||
testul("%-4lu", 123l, "123 ");
|
||||
testul("%-4lu", 1234l, "1234");
|
||||
testul("%-4lu", 12345l, "12345");
|
||||
testul("%-4lu", 32767l, "32767");
|
||||
testul("%-4lu", 2147483647l, "2147483647");
|
||||
testul("%-4lu", 4294967295l, "4294967295");
|
||||
testul("%-4lx", 0, "0 ");
|
||||
testul("%-4lx", 0x3576fbcdl, "3576FBCD");
|
||||
testul("%-4lx", 0xffffffffl, "FFFFFFFF");
|
||||
|
||||
testul("%+lu", 0l, "+0");
|
||||
testul("%+lu", 1l, "+1");
|
||||
testul("%+lu", 12l, "+12");
|
||||
testul("%+lu", 123l, "+123");
|
||||
testul("%+lu", 1234l, "+1234");
|
||||
testul("%+lu", 12345l, "+12345");
|
||||
testul("%+lu", 32767l, "+32767");
|
||||
testul("%+lu", 2147483647l, "+2147483647");
|
||||
testul("%+lu", 4294967295l, "+4294967295");
|
||||
|
||||
testf("%f", 0., "0.000000");
|
||||
testf("%f", 1., "1.000000");
|
||||
testf("%f", -1., "-1.000000");
|
||||
testf("%f", 12., "12.000000");
|
||||
testf("%f", 123., "123.000000");
|
||||
testf("%f", 1234., "1234.000000");
|
||||
testf("%f", 12345., "12345.000000");
|
||||
testf("%f", 123456., "123456.000000");
|
||||
testf("%f", 1234567., "1234567.000000");
|
||||
testf("%f", 0.1, "0.100000");
|
||||
testf("%f", 0.01, "0.010000");
|
||||
testf("%f", 0.001, "0.001000");
|
||||
testf("%f", 0.0001, "0.000100");
|
||||
testf("%f", 0.00001, "0.000010");
|
||||
testf("%f", 0.000001, "0.000001");
|
||||
|
||||
testf("%5.1f", 0, " 0.0");
|
||||
testf("%5.1f", 1, " 1.0");
|
||||
testf("%5.1f", -1, " -1.0");
|
||||
testf("%5.1f", 10, " 10.0");
|
||||
testf("%5.1f", -10, "-10.0");
|
||||
testf("%5.1f", 100, "100.0");
|
||||
testf("%5.1f", -100, "-100.0");
|
||||
testf("%5.1f", 0.1, " 0.1");
|
||||
testf("%5.1f", -0.1, " -0.1");
|
||||
testf("%5.1f", 0.04, " 0.0");
|
||||
testf("%5.1f", -0.04, " -0.0");
|
||||
testf("%5.1f", 0.051, " 0.1");
|
||||
testf("%5.1f", -0.051, " -0.1");
|
||||
|
||||
testf("%+5.1f", 0, " +0.0");
|
||||
testf("%+5.1f", 1, " +1.0");
|
||||
testf("%+5.1f", -1, " -1.0");
|
||||
testf("%+5.1f", 10, "+10.0");
|
||||
testf("%+5.1f", -10, "-10.0");
|
||||
testf("%+5.1f", 100, "+100.0");
|
||||
testf("%+5.1f", -100, "-100.0");
|
||||
testf("%+5.1f", 0.1, " +0.1");
|
||||
testf("%+5.1f", -0.1, " -0.1");
|
||||
testf("%+5.1f", 0.04, " +0.0");
|
||||
testf("%+5.1f", -0.04, " -0.0");
|
||||
testf("%+5.1f", 0.051, " +0.1");
|
||||
testf("%+5.1f", -0.051, " -0.1");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,6 +1,5 @@
|
|||
// stdlibtest
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
|
@ -51,15 +50,16 @@ void heapcheck(void)
|
|||
for(i=0; i<s; i++)
|
||||
{
|
||||
if (p[i] != n)
|
||||
{
|
||||
printf("MemError %d at %d:%d != %d\n", k, i, n, p[i]);
|
||||
exit(-2);
|
||||
}
|
||||
}
|
||||
free(memp[n]);
|
||||
|
||||
s = rand() % 100 + 3;
|
||||
mems[n] = s;
|
||||
memp[n] = malloc(s);
|
||||
if (!memp[n])
|
||||
exit(-3);
|
||||
memset(memp[n], n, s);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,28 +0,0 @@
|
|||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
char aa[2000], ba[2000];
|
||||
|
||||
int main(void)
|
||||
{
|
||||
assert(strcmp("abcdefgh", "abcdefgh") == 0);
|
||||
assert(strcmp("abcdefgh", "abcdemgh") < 0);
|
||||
assert(strcmp("abcdefgh", "abcdefghi") < 0);
|
||||
assert(strcmp("abcdefghi", "abcdefgh") > 0);
|
||||
assert(strcmp("abcdemgh", "abcdefgh") > 0);
|
||||
|
||||
for(int i=0; i<1900; i++)
|
||||
{
|
||||
aa[i] = 'a' + (i & 7);
|
||||
}
|
||||
aa[1900] = 0;
|
||||
|
||||
strcpy(ba, aa);
|
||||
|
||||
assert(strcmp(aa, ba) == 0);
|
||||
ba[1000] = 'z';
|
||||
assert(strcmp(aa, ba) < 0);
|
||||
assert(strcmp(ba, aa) > 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,299 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
|
||||
int a100[100];
|
||||
__striped int b100[100];
|
||||
__striped int c100[100];
|
||||
|
||||
unsigned a256[256];
|
||||
__striped unsigned b256[256];
|
||||
__striped unsigned c256[256];
|
||||
|
||||
#pragma align(c100, 256)
|
||||
#pragma align(c256, 256)
|
||||
|
||||
void test_ab100(void)
|
||||
{
|
||||
for(char i=0; i<100; i++)
|
||||
{
|
||||
a100[i] = i * i;
|
||||
b100[i] = i * i;
|
||||
c100[i] = i * i;
|
||||
}
|
||||
|
||||
a100[31] = 4711;
|
||||
b100[31] = 4711;
|
||||
c100[31] = 4711;
|
||||
|
||||
|
||||
for(char i=0; i<100; i++)
|
||||
{
|
||||
a100[i] += i; a100[i] -= 5; a100[i] = a100[i] + a100[99 - i];
|
||||
b100[i] += i; b100[i] -= 5; b100[i] = b100[i] + b100[99 - i];
|
||||
c100[i] += i; c100[i] -= 5; c100[i] = c100[i] + c100[99 - i];
|
||||
}
|
||||
|
||||
for(char i=0; i<100; i++)
|
||||
{
|
||||
assert(a100[i] == b100[i]);
|
||||
assert(a100[i] == c100[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void test_ab256(void)
|
||||
{
|
||||
for(unsigned i=0; i<256; i++)
|
||||
{
|
||||
a256[i] = i * i;
|
||||
b256[i] = i * i;
|
||||
c256[i] = i * i;
|
||||
}
|
||||
|
||||
a256[31] = 4711;
|
||||
b256[31] = 4711;
|
||||
c256[31] = 4711;
|
||||
|
||||
for(unsigned i=0; i<256; i++)
|
||||
{
|
||||
a256[i] += i; a256[i] -= 5; a256[i] = a256[i] + a256[255 - i];
|
||||
b256[i] += i; b256[i] -= 5; b256[i] = b256[i] + b256[255 - i];
|
||||
c256[i] += i; c256[i] -= 5; c256[i] = c256[i] + c256[255 - i];
|
||||
}
|
||||
|
||||
for(unsigned i=0; i<256; i++)
|
||||
{
|
||||
assert(a256[i] == b256[i]);
|
||||
assert(a256[i] == c256[i]);
|
||||
}
|
||||
}
|
||||
|
||||
long la50[50];
|
||||
__striped long lb50[50];
|
||||
__striped long lc50[50];
|
||||
|
||||
unsigned long la256[256];
|
||||
__striped unsigned long lb256[256];
|
||||
__striped unsigned long lc256[256];
|
||||
|
||||
#pragma align(lc50, 256)
|
||||
#pragma align(lc256, 256)
|
||||
|
||||
void test_lab50(void)
|
||||
{
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
long j = i * i;
|
||||
la50[i] = j * j;
|
||||
lb50[i] = j * j;
|
||||
lc50[i] = j * j;
|
||||
}
|
||||
|
||||
la50[31] = 47110815l;
|
||||
lb50[31] = 47110815l;
|
||||
lc50[31] = 47110815l;
|
||||
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
la50[i] += i; la50[i] -= 12345678l; la50[i] = la50[i] + la50[49 - i];
|
||||
lb50[i] += i; lb50[i] -= 12345678l; lb50[i] = lb50[i] + lb50[49 - i];
|
||||
lc50[i] += i; lc50[i] -= 12345678l; lc50[i] = lc50[i] + lc50[49 - i];
|
||||
}
|
||||
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
assert(la50[i] == lb50[i]);
|
||||
assert(la50[i] == lc50[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void test_lab256(void)
|
||||
{
|
||||
for(unsigned i=0; i<256; i++)
|
||||
{
|
||||
unsigned long j = i * i;
|
||||
la256[i] = j * j;
|
||||
lb256[i] = j * j;
|
||||
lc256[i] = j * j;
|
||||
}
|
||||
|
||||
la256[31] = 47110815ul;
|
||||
lb256[31] = 47110815ul;
|
||||
lc256[31] = 47110815ul;
|
||||
|
||||
for(unsigned i=0; i<256; i++)
|
||||
{
|
||||
la256[i] += i; la256[i] -= 12345678ul; la256[i] = la256[i] + la256[255 - i];
|
||||
lb256[i] += i; lb256[i] -= 12345678ul; lb256[i] = lb256[i] + lb256[255 - i];
|
||||
lc256[i] += i; lc256[i] -= 12345678ul; lc256[i] = lc256[i] + lc256[255 - i];
|
||||
}
|
||||
|
||||
for(unsigned i=0; i<256; i++)
|
||||
{
|
||||
assert(la256[i] == lb256[i]);
|
||||
assert(la256[i] == lc256[i]);
|
||||
}
|
||||
}
|
||||
|
||||
float fa50[50];
|
||||
__striped float fb50[50];
|
||||
__striped float fc50[50];
|
||||
|
||||
float fa256[256];
|
||||
__striped float fb256[256];
|
||||
__striped float fc256[256];
|
||||
|
||||
#pragma align(fc50, 256)
|
||||
#pragma align(fc256, 256)
|
||||
|
||||
void test_fab50(void)
|
||||
{
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
fa50[i] = i * i;
|
||||
fb50[i] = i * i;
|
||||
fc50[i] = i * i;
|
||||
}
|
||||
|
||||
fa50[31] = 4711.0815;
|
||||
fb50[31] = 4711.0815;
|
||||
fc50[31] = 4711.0815;
|
||||
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
fa50[i] += i; fa50[i] -= 1234.5678; fa50[i] = fa50[i] + fa50[49 - i];
|
||||
fb50[i] += i; fb50[i] -= 1234.5678; fb50[i] = fb50[i] + fb50[49 - i];
|
||||
fc50[i] += i; fc50[i] -= 1234.5678; fc50[i] = fc50[i] + fc50[49 - i];
|
||||
}
|
||||
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
assert(fa50[i] == fb50[i]);
|
||||
assert(fa50[i] == fc50[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void test_fab256(void)
|
||||
{
|
||||
for(unsigned i=0; i<256; i++)
|
||||
{
|
||||
fa256[i] = i * i;
|
||||
fb256[i] = i * i;
|
||||
fc256[i] = i * i;
|
||||
}
|
||||
|
||||
fa256[31] = 4711.0815;
|
||||
fb256[31] = 4711.0815;
|
||||
fc256[31] = 4711.0815;
|
||||
|
||||
for(unsigned i=0; i<256; i++)
|
||||
{
|
||||
fa256[i] += i; fa256[i] -= 1234.5678; fa256[i] = fa256[i] + fa256[255 - i];
|
||||
fb256[i] += i; fb256[i] -= 1234.5678; fb256[i] = fb256[i] + fb256[255 - i];
|
||||
fc256[i] += i; fc256[i] -= 1234.5678; fc256[i] = fc256[i] + fc256[255 - i];
|
||||
}
|
||||
|
||||
for(unsigned i=0; i<256; i++)
|
||||
{
|
||||
assert(fa256[i] == fb256[i]);
|
||||
assert(fa256[i] == fc256[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
unsigned da50[50], db50[50], dc50[50];
|
||||
|
||||
unsigned * pa50[50];
|
||||
__striped unsigned * pb50[50];
|
||||
__striped unsigned * pc50[50];
|
||||
|
||||
#pragma align(pc50, 256)
|
||||
|
||||
void test_pab50(void)
|
||||
{
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
pa50[i] = da50 + (i * 17) % 50;
|
||||
pb50[i] = db50 + (i * 17) % 50;
|
||||
pc50[i] = dc50 + (i * 17) % 50;
|
||||
}
|
||||
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
*pa50[i] = i * i;
|
||||
*pb50[i] = i * i;
|
||||
*pc50[i] = i * i;
|
||||
}
|
||||
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
*pa50[i] += i; *pa50[i] -= 5; *pa50[i] = *pa50[i] + *pa50[49 - i];
|
||||
*pb50[i] += i; *pb50[i] -= 5; *pb50[i] = *pb50[i] + *pb50[49 - i];
|
||||
*pc50[i] += i; *pc50[i] -= 5; *pc50[i] = *pc50[i] + *pc50[49 - i];
|
||||
}
|
||||
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
assert(*pa50[i] == *pb50[i]);
|
||||
assert(*pa50[i] == *pc50[i]);
|
||||
assert(da50[i] == db50[i]);
|
||||
assert(da50[i] == dc50[i]);
|
||||
}
|
||||
}
|
||||
|
||||
unsigned da50_4[50][4], db50_4[50][4], dc50_4[50][4];
|
||||
|
||||
void test_pab50_4(void)
|
||||
{
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
pa50[i] = da50_4[(i * 17) % 50];
|
||||
pb50[i] = db50_4[(i * 17) % 50];
|
||||
pc50[i] = dc50_4[(i * 17) % 50];
|
||||
}
|
||||
|
||||
for(char k=0; k<4; k++)
|
||||
{
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
pa50[i][k] = i * i;
|
||||
pb50[i][k] = i * i;
|
||||
pc50[i][k] = i * i;
|
||||
}
|
||||
}
|
||||
|
||||
for(char k=0; k<4; k++)
|
||||
{
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
pa50[i][k] += i; pa50[i][k] -= 5; pa50[i][k] = pa50[i][k] + pa50[49 - i][k];
|
||||
pb50[i][k] += i; pb50[i][k] -= 5; pb50[i][k] = pb50[i][k] + pb50[49 - i][k];
|
||||
pc50[i][k] += i; pc50[i][k] -= 5; pc50[i][k] = pc50[i][k] + pc50[49 - i][k];
|
||||
}
|
||||
}
|
||||
|
||||
for(char k=0; k<4; k++)
|
||||
{
|
||||
for(char i=0; i<50; i++)
|
||||
{
|
||||
assert(pa50[i][k] == pb50[i][k]);
|
||||
assert(pa50[i][k] == pc50[i][k]);
|
||||
assert(da50_4[i][k] == db50_4[i][k]);
|
||||
assert(da50_4[i][k] == dc50_4[i][k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
test_ab100();
|
||||
test_ab256();
|
||||
test_lab50();
|
||||
test_lab256();
|
||||
test_fab50();
|
||||
test_fab256();
|
||||
test_pab50();
|
||||
test_pab50_4();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
|
||||
|
||||
struct Point
|
||||
{
|
||||
int x, y;
|
||||
};
|
||||
|
||||
|
||||
Point tcorners[8], pcorners[8];
|
||||
|
||||
int bm_line(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void drawCube(void)
|
||||
{
|
||||
for(char i=0; i<8; i++)
|
||||
{
|
||||
if (!(i & 1))
|
||||
bm_line();
|
||||
if (!(i & 2))
|
||||
bm_line();
|
||||
if (!(i & 4))
|
||||
bm_line();
|
||||
|
||||
pcorners[i] = tcorners[i];
|
||||
}
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
for(int i=0; i<8; i++)
|
||||
{
|
||||
tcorners[i].x = (i + 1) * 3;
|
||||
tcorners[i].y = (i + 1) * 7;
|
||||
}
|
||||
|
||||
drawCube();
|
||||
|
||||
int sum = 0;
|
||||
for(int i=0; i<8; i++)
|
||||
{
|
||||
sum += pcorners[i].x;
|
||||
sum -= tcorners[i].y;
|
||||
}
|
||||
|
||||
return sum + 144;
|
||||
}
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
#include <stdio.h>
|
||||
|
||||
struct Vec3
|
||||
{
|
||||
float x, y, z;
|
||||
};
|
||||
|
||||
Vec3 v;
|
||||
|
||||
Vec3 vadd(Vec3 s1, Vec3 s2)
|
||||
{
|
||||
Vec3 r;
|
||||
r.x = s1.x + s2.x;
|
||||
r.y = s1.y + s2.y;
|
||||
r.z = s1.z + s2.z;
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
Vec3 m = {1, 2, -3}, u = {4, 5, -9}, t = {7, -2, -5};
|
||||
|
||||
v.x = 99;
|
||||
v.y = 100;
|
||||
v.z = 101;
|
||||
|
||||
v = vadd(m, vadd(u, t));
|
||||
|
||||
return v.x + v.y + v.z;
|
||||
}
|
||||
|
|
@ -1,50 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
struct A
|
||||
{
|
||||
int x[100], y[100];
|
||||
};
|
||||
|
||||
struct V
|
||||
{
|
||||
int x, y, z;
|
||||
};
|
||||
|
||||
|
||||
void copy(A * a)
|
||||
{
|
||||
for(int i=0; i<100; i++)
|
||||
a->x[i] = a->y[i];
|
||||
}
|
||||
|
||||
void shuffle(V * v)
|
||||
{
|
||||
for(int i=0; i<100; i++)
|
||||
v[i].x = v[i].y;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
A a;
|
||||
V v[100];
|
||||
|
||||
for(int i=0; i<100; i++)
|
||||
{
|
||||
a.y[i] = i;
|
||||
v[i].y = i;
|
||||
}
|
||||
|
||||
copy(&a);
|
||||
shuffle(v);
|
||||
|
||||
for(int i=0; i<100; i++)
|
||||
{
|
||||
assert(a.x[i] == i);
|
||||
assert(v[i].x == i);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
struct A
|
||||
{
|
||||
int x;
|
||||
struct B
|
||||
{
|
||||
int m;
|
||||
struct C
|
||||
{
|
||||
int w;
|
||||
} c;
|
||||
} b;
|
||||
} q;
|
||||
|
||||
int test(A * a)
|
||||
{
|
||||
a->b.c.w = 1;
|
||||
return a->b.c.w;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
return test(&q) - 1;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
char text[14];
|
||||
|
||||
for(char i=0; i<12; i++)
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case 0:
|
||||
text[i] = 'H';
|
||||
break;
|
||||
case 1:
|
||||
text[i] = 'E';
|
||||
break;
|
||||
case 2:
|
||||
case 3:
|
||||
case 9:
|
||||
text[i] = 'L';
|
||||
break;
|
||||
case 4:
|
||||
case 7:
|
||||
text[i] = 'O';
|
||||
break;
|
||||
case 5:
|
||||
text[i] = ' ';
|
||||
break;
|
||||
case 6:
|
||||
text[i] = 'W';
|
||||
break;
|
||||
case 8:
|
||||
text[i] = 'R';
|
||||
break;
|
||||
case 10:
|
||||
text[i] = 'D';
|
||||
break;
|
||||
default:
|
||||
text[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
printf("<%s>\n", text);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,426 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
bool beq(int a, int b)
|
||||
{
|
||||
return a == b;
|
||||
}
|
||||
|
||||
bool blt(int a, int b)
|
||||
{
|
||||
return a < b;
|
||||
}
|
||||
|
||||
bool bgt(int a, int b)
|
||||
{
|
||||
return a > b;
|
||||
}
|
||||
|
||||
bool ble(int a, int b)
|
||||
{
|
||||
return a <= b;
|
||||
}
|
||||
|
||||
bool bge(int a, int b)
|
||||
{
|
||||
return a >= b;
|
||||
}
|
||||
|
||||
bool neq(int a, int b)
|
||||
{
|
||||
return a == b;
|
||||
}
|
||||
|
||||
#pragma native(neq)
|
||||
|
||||
bool nlt(int a, int b)
|
||||
{
|
||||
return a < b;
|
||||
}
|
||||
|
||||
#pragma native(nlt)
|
||||
|
||||
bool ngt(int a, int b)
|
||||
{
|
||||
return a > b;
|
||||
}
|
||||
|
||||
#pragma native(ngt)
|
||||
|
||||
bool nle(int a, int b)
|
||||
{
|
||||
return a <= b;
|
||||
}
|
||||
|
||||
#pragma native(nle)
|
||||
|
||||
bool nge(int a, int b)
|
||||
{
|
||||
return a >= b;
|
||||
}
|
||||
|
||||
#pragma native(nge)
|
||||
|
||||
|
||||
|
||||
bool beqz(int a)
|
||||
{
|
||||
return a == 0;
|
||||
}
|
||||
|
||||
bool bltz(int a)
|
||||
{
|
||||
return a < 0;
|
||||
}
|
||||
|
||||
bool bgtz(int a)
|
||||
{
|
||||
return a > 0;
|
||||
}
|
||||
|
||||
bool blez(int a)
|
||||
{
|
||||
return a <= 0;
|
||||
}
|
||||
|
||||
bool bgez(int a)
|
||||
{
|
||||
return a >= 0;
|
||||
}
|
||||
|
||||
bool neqz(int a)
|
||||
{
|
||||
return a == 0;
|
||||
}
|
||||
|
||||
#pragma native(neqz)
|
||||
|
||||
bool nltz(int a)
|
||||
{
|
||||
return a < 0;
|
||||
}
|
||||
|
||||
#pragma native(nltz)
|
||||
|
||||
bool ngtz(int a)
|
||||
{
|
||||
return a > 0;
|
||||
}
|
||||
|
||||
#pragma native(ngtz)
|
||||
|
||||
bool nlez(int a)
|
||||
{
|
||||
return a <= 0;
|
||||
}
|
||||
|
||||
#pragma native(nlez)
|
||||
|
||||
bool ngez(int a)
|
||||
{
|
||||
return a >= 0;
|
||||
}
|
||||
|
||||
#pragma native(ngez)
|
||||
|
||||
|
||||
|
||||
|
||||
bool bequz(unsigned a)
|
||||
{
|
||||
return a == 0;
|
||||
}
|
||||
|
||||
bool bltuz(unsigned a)
|
||||
{
|
||||
return a < 0;
|
||||
}
|
||||
|
||||
bool bgtuz(unsigned a)
|
||||
{
|
||||
return a > 0;
|
||||
}
|
||||
|
||||
bool bleuz(unsigned a)
|
||||
{
|
||||
return a <= 0;
|
||||
}
|
||||
|
||||
bool bgeuz(unsigned a)
|
||||
{
|
||||
return a >= 0;
|
||||
}
|
||||
|
||||
bool nequz(unsigned a)
|
||||
{
|
||||
return a == 0;
|
||||
}
|
||||
|
||||
#pragma native(nequz)
|
||||
|
||||
bool nltuz(unsigned a)
|
||||
{
|
||||
return a < 0;
|
||||
}
|
||||
|
||||
#pragma native(nltuz)
|
||||
|
||||
bool ngtuz(unsigned a)
|
||||
{
|
||||
return a > 0;
|
||||
}
|
||||
|
||||
#pragma native(ngtuz)
|
||||
|
||||
bool nleuz(unsigned a)
|
||||
{
|
||||
return a <= 0;
|
||||
}
|
||||
|
||||
#pragma native(nleuz)
|
||||
|
||||
bool ngeuz(unsigned a)
|
||||
{
|
||||
return a >= 0;
|
||||
}
|
||||
|
||||
#pragma native(ngeuz)
|
||||
|
||||
|
||||
|
||||
|
||||
bool beq1(int a)
|
||||
{
|
||||
return a == 1;
|
||||
}
|
||||
|
||||
bool blt1(int a)
|
||||
{
|
||||
return a < 1;
|
||||
}
|
||||
|
||||
bool bgt1(int a)
|
||||
{
|
||||
return a > 1;
|
||||
}
|
||||
|
||||
bool ble1(int a)
|
||||
{
|
||||
return a <= 1;
|
||||
}
|
||||
|
||||
bool bge1(int a)
|
||||
{
|
||||
return a >= 1;
|
||||
}
|
||||
|
||||
bool neq1(int a)
|
||||
{
|
||||
return a == 1;
|
||||
}
|
||||
|
||||
#pragma native(neq1)
|
||||
|
||||
bool nlt1(int a)
|
||||
{
|
||||
return a < 1;
|
||||
}
|
||||
|
||||
#pragma native(nlt1)
|
||||
|
||||
bool ngt1(int a)
|
||||
{
|
||||
return a > 1;
|
||||
}
|
||||
|
||||
#pragma native(ngt1)
|
||||
|
||||
bool nle1(int a)
|
||||
{
|
||||
return a <= 1;
|
||||
}
|
||||
|
||||
#pragma native(nle1)
|
||||
|
||||
bool nge1(int a)
|
||||
{
|
||||
return a >= 1;
|
||||
}
|
||||
|
||||
#pragma native(nge1)
|
||||
|
||||
|
||||
|
||||
void cmp(int a, int b)
|
||||
{
|
||||
bool beqf = beq(a, b), bltf = blt(a, b), bgtf = bgt(a, b), blef = ble(a, b), bgef = bge(a, b);
|
||||
bool neqf = neq(a, b), nltf = nlt(a, b), ngtf = ngt(a, b), nlef = nle(a, b), ngef = nge(a, b);
|
||||
|
||||
printf("BYTE %d, %d : EQ %d LT %d GT %d\r", a, b, beqf, bltf, bgtf);
|
||||
printf("NATIVE %d, %d : EQ %d LT %d GT %d\r", a, b, neqf, nltf, ngtf);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmpz(int a)
|
||||
{
|
||||
bool beqf = beqz(a), bltf = bltz(a), bgtf = bgtz(a), blef = blez(a), bgef = bgez(a);
|
||||
bool neqf = neqz(a), nltf = nltz(a), ngtf = ngtz(a), nlef = nlez(a), ngef = ngez(a);
|
||||
|
||||
printf("BYTE %d, 0 : EQ %d LT %d GT %d\r", a, beqf, bltf, bgtf);
|
||||
printf("NATIVE %d, 0 : EQ %d LT %d GT %d\r", a, neqf, nltf, ngtf);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmpuz(unsigned a)
|
||||
{
|
||||
bool beqf = bequz(a), bltf = bltuz(a), bgtf = bgtuz(a), blef = bleuz(a), bgef = bgeuz(a);
|
||||
bool neqf = nequz(a), nltf = nltuz(a), ngtf = ngtuz(a), nlef = nleuz(a), ngef = ngeuz(a);
|
||||
|
||||
printf("BYTE %u, 0 : EQ %u LT %d GT %u\r", a, beqf, bltf, bgtf);
|
||||
printf("NATIVE %u, 0 : EQ %u LT %d GT %u\r", a, neqf, nltf, ngtf);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmp1(int a)
|
||||
{
|
||||
bool beqf = beq1(a), bltf = blt1(a), bgtf = bgt1(a), blef = ble1(a), bgef = bge1(a);
|
||||
bool neqf = neq1(a), nltf = nlt1(a), ngtf = ngt1(a), nlef = nle1(a), ngef = nge1(a);
|
||||
|
||||
printf("BYTE %d, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, beqf, bltf, bgtf, blef, bgef);
|
||||
printf("NATIVE %d, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, neqf, nltf, ngtf, nlef, ngef);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
cmp( 0, 1);
|
||||
cmp( 0, -1);
|
||||
cmp( 1, 0);
|
||||
cmp(-1, 0);
|
||||
|
||||
cmp(1, 1);
|
||||
cmp(1, 2);
|
||||
cmp(2, 1);
|
||||
|
||||
cmp(-1, -1);
|
||||
cmp(-1, -2);
|
||||
cmp(-2, -1);
|
||||
|
||||
cmp( 1, -1);
|
||||
cmp( 1, -2);
|
||||
cmp( 2, -1);
|
||||
|
||||
cmp(-1, 1);
|
||||
cmp(-1, 2);
|
||||
cmp(-2, 1);
|
||||
|
||||
|
||||
cmp( 0, 10000);
|
||||
cmp( 0, -10000);
|
||||
cmp( 10000, 0);
|
||||
cmp(-10000, 0);
|
||||
|
||||
cmp(10000, 10000);
|
||||
cmp(10000, 20000);
|
||||
cmp(20000, 10000);
|
||||
|
||||
cmp(-10000, -10000);
|
||||
cmp(-10000, -20000);
|
||||
cmp(-20000, -10000);
|
||||
|
||||
cmp( 10000, -10000);
|
||||
cmp( 10000, -20000);
|
||||
cmp( 20000, -10000);
|
||||
|
||||
cmp(-10000, 10000);
|
||||
cmp(-10000, 20000);
|
||||
cmp(-20000, 10000);
|
||||
|
||||
cmp(-30000, 30000);
|
||||
cmp(-30000, -30000);
|
||||
cmp( 30000, 30000);
|
||||
cmp( 30000, -30000);
|
||||
|
||||
cmp( 0, 1024);
|
||||
cmp( 0, -1024);
|
||||
cmp( 1024, 0);
|
||||
cmp(-1024, 0);
|
||||
|
||||
cmp(1024, 1024);
|
||||
cmp(1024, 1025);
|
||||
cmp(1025, 1024);
|
||||
|
||||
cmp(-1024, -1024);
|
||||
cmp(-1024, -1025);
|
||||
cmp(-1025, -1024);
|
||||
|
||||
cmp( 1024, -1024);
|
||||
cmp( 1024, -1025);
|
||||
cmp( 1025, -1024);
|
||||
|
||||
cmp(-1024, 1024);
|
||||
cmp(-1024, 1025);
|
||||
cmp(-1025, 1024);
|
||||
|
||||
cmpz(0);
|
||||
cmpz(1);
|
||||
cmpz(255);
|
||||
cmpz(256);
|
||||
cmpz(10000);
|
||||
cmpz(20000);
|
||||
cmpz(-1);
|
||||
cmpz(-255);
|
||||
cmpz(-256);
|
||||
cmpz(-10000);
|
||||
cmpz(-20000);
|
||||
|
||||
cmpuz(0);
|
||||
cmpuz(1);
|
||||
cmpuz(255);
|
||||
cmpuz(256);
|
||||
cmpuz(10000);
|
||||
cmpuz(20000);
|
||||
cmpuz(40000);
|
||||
cmpuz(32767);
|
||||
cmpuz(32768);
|
||||
cmpuz(65535);
|
||||
|
||||
cmp1(0);
|
||||
cmp1(1);
|
||||
cmp1(2);
|
||||
cmp1(3);
|
||||
cmp1(255);
|
||||
cmp1(256);
|
||||
cmp1(10000);
|
||||
cmp1(20000);
|
||||
cmp1(-1);
|
||||
cmp1(-2);
|
||||
cmp1(-3);
|
||||
cmp1(-255);
|
||||
cmp1(-256);
|
||||
cmp1(-10000);
|
||||
cmp1(-20000);
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
int mul[32][32];
|
||||
|
||||
int main(void)
|
||||
{
|
||||
for(int i=0; i<32; i++)
|
||||
for(int j=0; j<32; j++)
|
||||
mul[i][j] = i * j;
|
||||
#assign xi 0
|
||||
#repeat
|
||||
|
||||
for(int j=0; j<32; j++)
|
||||
{
|
||||
assert(mul[xi][j] == xi * j);
|
||||
assert(mul[j][xi] == j * xi);
|
||||
}
|
||||
|
||||
#assign xi xi + 1
|
||||
#until xi == 32
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,166 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
void testmuli(long a, long b, long ab)
|
||||
{
|
||||
assert (a * b == ab);
|
||||
}
|
||||
|
||||
void testmulu(unsigned long a, unsigned long b, unsigned long ab)
|
||||
{
|
||||
assert (a * b == ab);
|
||||
}
|
||||
|
||||
void testdivi(long a, long b, long ab)
|
||||
{
|
||||
assert (a / b == ab);
|
||||
}
|
||||
|
||||
void shltesti(long a, long b, long ab)
|
||||
{
|
||||
assert (a << b == ab);
|
||||
}
|
||||
|
||||
void shrtesti(long a, long b, long ab)
|
||||
{
|
||||
assert (a >> b == ab);
|
||||
}
|
||||
|
||||
long sieve(long size)
|
||||
{
|
||||
bool sieve[1000];
|
||||
|
||||
for(long i=0; i<size; i+=2)
|
||||
{
|
||||
sieve[i] = false;
|
||||
sieve[i+1] = true;
|
||||
}
|
||||
sieve[2] = true;
|
||||
|
||||
for (long i = 3; i * i < size;)
|
||||
{
|
||||
long j = i * i;
|
||||
while (j < size)
|
||||
{
|
||||
sieve[j] = false;
|
||||
j += 2 * i;
|
||||
}
|
||||
do {i++;} while (i < size && !sieve[i]);
|
||||
}
|
||||
|
||||
long num = 0;
|
||||
for(long i=0; i<size; i++)
|
||||
{
|
||||
if (sieve[i])
|
||||
num++;
|
||||
}
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
testmuli(0, 0, 0);
|
||||
testmuli(1, 0, 0);
|
||||
testmuli(0, 1, 0);
|
||||
|
||||
testmuli( 1, 1, 1);
|
||||
testmuli(-1, 1, -1);
|
||||
testmuli(-1, -1, 1);
|
||||
testmuli( 1, -1, -1);
|
||||
|
||||
testmuli(5, 5, 25);
|
||||
|
||||
testmuli( 127, 255, 32385);
|
||||
testmuli(-127, 255, -32385);
|
||||
testmuli( 127, -255, -32385);
|
||||
testmuli(-127, -255, 32385);
|
||||
|
||||
testmuli( 1237, 1024, 1266688l);
|
||||
testmuli(-1237, 1024, -1266688l);
|
||||
testmuli( 1237, -1024, -1266688l);
|
||||
testmuli(-1237, -1024, 1266688l);
|
||||
|
||||
testmuli( 1024, 1237, 1266688l);
|
||||
testmuli( 1024,-1237, -1266688l);
|
||||
testmuli( -1024, 1237, -1266688l);
|
||||
testmuli( -1024,-1237, 1266688l);
|
||||
|
||||
testmulu(0x00000001, 0x0000003c, 0x0000003c);
|
||||
testmulu(0x00000100, 0x0000003c, 0x00003c00);
|
||||
testmulu(0x00010000, 0x0000003c, 0x003c0000);
|
||||
testmulu(0x01000000, 0x0000003c, 0x3c000000);
|
||||
|
||||
testmulu(0x0000003c, 0x00000001, 0x0000003c);
|
||||
testmulu(0x0000003c, 0x00000100, 0x00003c00);
|
||||
testmulu(0x0000003c, 0x00010000, 0x003c0000);
|
||||
testmulu(0x0000003c, 0x01000000, 0x3c000000);
|
||||
|
||||
testmulu(0x0000004b, 0x0000003c, 0x00001194);
|
||||
testmulu(0x00004b00, 0x0000003c, 0x00119400);
|
||||
testmulu(0x004b0000, 0x0000003c, 0x11940000);
|
||||
testmulu(0x4b000000, 0x0000003c, 0x94000000);
|
||||
|
||||
testmulu(0x0000003c, 0x0000004b, 0x00001194);
|
||||
testmulu(0x0000003c, 0x00004b00, 0x00119400);
|
||||
testmulu(0x0000003c, 0x004b0000, 0x11940000);
|
||||
testmulu(0x0000003c, 0x4b000000, 0x94000000);
|
||||
|
||||
testdivi( 1, 1, 1);
|
||||
testdivi(-1, 1, -1);
|
||||
testdivi( 1, -1, -1);
|
||||
testdivi(-1, -1, 1);
|
||||
|
||||
testdivi( 11, 4, 2);
|
||||
testdivi(-11, 4, -2);
|
||||
testdivi( 11, -4, -2);
|
||||
testdivi(-11, -4, 2);
|
||||
|
||||
shltesti( 17, 1, 34);
|
||||
shltesti(-17, 1, -34);
|
||||
shltesti( 1700, 1, 3400);
|
||||
shltesti(-1700, 1, -3400);
|
||||
|
||||
shrtesti( 34, 1, 17);
|
||||
shrtesti(-34, 1, -17);
|
||||
shrtesti( 3400, 1, 1700);
|
||||
shrtesti(-3400, 1, -1700);
|
||||
|
||||
shrtesti( -1, 15, -1);
|
||||
shrtesti(32767, 15, 0);
|
||||
shrtesti( -1, 14, -1);
|
||||
shrtesti(32767, 14, 1);
|
||||
|
||||
shltesti( -1, 14, -16384);
|
||||
shltesti( 1, 14, 16384);
|
||||
|
||||
assert(sieve(200) == 47);
|
||||
assert(sieve(1000) == 169);
|
||||
long a = 0, b = 0;
|
||||
for(long i=0; i<10000; i++)
|
||||
{
|
||||
assert( 177 * i == a);
|
||||
assert(-177 * i == b);
|
||||
a += 177;
|
||||
b -= 177;
|
||||
}
|
||||
|
||||
long c = 0, d = 0;
|
||||
for(long i=0; i<177; i++)
|
||||
{
|
||||
assert( 10000 * i == c);
|
||||
assert(-10000 * i == d);
|
||||
c += 10000;
|
||||
d -= 10000;
|
||||
}
|
||||
|
||||
long e = 0, f = 0;
|
||||
for(long i=0; i<177000l; i += 1000)
|
||||
{
|
||||
assert( 1024 * i == e);
|
||||
assert(-1024 * i == f);
|
||||
e += 1024000l;
|
||||
f -= 1024000l;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,499 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
bool beq(long a, long b)
|
||||
{
|
||||
return a == b;
|
||||
}
|
||||
|
||||
bool blt(long a, long b)
|
||||
{
|
||||
return a < b;
|
||||
}
|
||||
|
||||
bool bgt(long a, long b)
|
||||
{
|
||||
return a > b;
|
||||
}
|
||||
|
||||
bool ble(long a, long b)
|
||||
{
|
||||
return a <= b;
|
||||
}
|
||||
|
||||
bool bge(long a, long b)
|
||||
{
|
||||
return a >= b;
|
||||
}
|
||||
|
||||
bool neq(long a, long b)
|
||||
{
|
||||
return a == b;
|
||||
}
|
||||
|
||||
#pragma native(neq)
|
||||
|
||||
bool nlt(long a, long b)
|
||||
{
|
||||
return a < b;
|
||||
}
|
||||
|
||||
#pragma native(nlt)
|
||||
|
||||
bool ngt(long a, long b)
|
||||
{
|
||||
return a > b;
|
||||
}
|
||||
|
||||
#pragma native(ngt)
|
||||
|
||||
bool nle(long a, long b)
|
||||
{
|
||||
return a <= b;
|
||||
}
|
||||
|
||||
#pragma native(nle)
|
||||
|
||||
bool nge(long a, long b)
|
||||
{
|
||||
return a >= b;
|
||||
}
|
||||
|
||||
#pragma native(nge)
|
||||
|
||||
|
||||
|
||||
|
||||
inline bool ieq(long a, long b)
|
||||
{
|
||||
return a == b;
|
||||
}
|
||||
|
||||
inline bool ilt(long a, long b)
|
||||
{
|
||||
return a < b;
|
||||
}
|
||||
|
||||
inline bool igt(long a, long b)
|
||||
{
|
||||
return a > b;
|
||||
}
|
||||
|
||||
inline bool ile(long a, long b)
|
||||
{
|
||||
return a <= b;
|
||||
}
|
||||
|
||||
inline bool ige(long a, long b)
|
||||
{
|
||||
return a >= b;
|
||||
}
|
||||
|
||||
|
||||
bool beqz(long a)
|
||||
{
|
||||
return a == 0;
|
||||
}
|
||||
|
||||
bool bltz(long a)
|
||||
{
|
||||
return a < 0;
|
||||
}
|
||||
|
||||
bool bgtz(long a)
|
||||
{
|
||||
return a > 0;
|
||||
}
|
||||
|
||||
bool blez(long a)
|
||||
{
|
||||
return a <= 0;
|
||||
}
|
||||
|
||||
bool bgez(long a)
|
||||
{
|
||||
return a >= 0;
|
||||
}
|
||||
|
||||
bool neqz(long a)
|
||||
{
|
||||
return a == 0;
|
||||
}
|
||||
|
||||
#pragma native(neqz)
|
||||
|
||||
bool nltz(long a)
|
||||
{
|
||||
return a < 0;
|
||||
}
|
||||
|
||||
#pragma native(nltz)
|
||||
|
||||
bool ngtz(long a)
|
||||
{
|
||||
return a > 0;
|
||||
}
|
||||
|
||||
#pragma native(ngtz)
|
||||
|
||||
bool nlez(long a)
|
||||
{
|
||||
return a <= 0;
|
||||
}
|
||||
|
||||
#pragma native(nlez)
|
||||
|
||||
bool ngez(long a)
|
||||
{
|
||||
return a >= 0;
|
||||
}
|
||||
|
||||
#pragma native(ngez)
|
||||
|
||||
|
||||
|
||||
|
||||
bool beq1(long a)
|
||||
{
|
||||
return a == 1;
|
||||
}
|
||||
|
||||
bool blt1(long a)
|
||||
{
|
||||
return a < 1;
|
||||
}
|
||||
|
||||
bool bgt1(long a)
|
||||
{
|
||||
return a > 1;
|
||||
}
|
||||
|
||||
bool ble1(long a)
|
||||
{
|
||||
return a <= 1;
|
||||
}
|
||||
|
||||
bool bge1(long a)
|
||||
{
|
||||
return a >= 1;
|
||||
}
|
||||
|
||||
bool neq1(long a)
|
||||
{
|
||||
return a == 1;
|
||||
}
|
||||
|
||||
#pragma native(neq1)
|
||||
|
||||
bool nlt1(long a)
|
||||
{
|
||||
return a < 1;
|
||||
}
|
||||
|
||||
#pragma native(nlt1)
|
||||
|
||||
bool ngt1(long a)
|
||||
{
|
||||
return a > 1;
|
||||
}
|
||||
|
||||
#pragma native(ngt1)
|
||||
|
||||
bool nle1(long a)
|
||||
{
|
||||
return a <= 1;
|
||||
}
|
||||
|
||||
#pragma native(nle1)
|
||||
|
||||
bool nge1(long a)
|
||||
{
|
||||
return a >= 1;
|
||||
}
|
||||
|
||||
#pragma native(nge1)
|
||||
|
||||
|
||||
|
||||
bool beqm(long a)
|
||||
{
|
||||
return a == -1;
|
||||
}
|
||||
|
||||
bool bltm(long a)
|
||||
{
|
||||
return a < -1;
|
||||
}
|
||||
|
||||
bool bgtm(long a)
|
||||
{
|
||||
return a > -1;
|
||||
}
|
||||
|
||||
bool blem(long a)
|
||||
{
|
||||
return a <= -1;
|
||||
}
|
||||
|
||||
bool bgem(long a)
|
||||
{
|
||||
return a >= -1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
bool neqm(long a)
|
||||
{
|
||||
return a == -1;
|
||||
}
|
||||
|
||||
#pragma native(neqm)
|
||||
|
||||
bool nltm(long a)
|
||||
{
|
||||
return a < -1;
|
||||
}
|
||||
|
||||
#pragma native(nltm)
|
||||
|
||||
bool ngtm(long a)
|
||||
{
|
||||
return a > -1;
|
||||
}
|
||||
|
||||
#pragma native(ngtm)
|
||||
|
||||
bool nlem(long a)
|
||||
{
|
||||
return a <= -1;
|
||||
}
|
||||
|
||||
#pragma native(nlem)
|
||||
|
||||
bool ngem(long a)
|
||||
{
|
||||
return a >= -1;
|
||||
}
|
||||
|
||||
#pragma native(ngem)
|
||||
|
||||
|
||||
|
||||
void cmpc(long a, long b)
|
||||
{
|
||||
bool beqf = beq(a, b), bltf = blt(a, b), bgtf = bgt(a, b), blef = ble(a, b), bgef = bge(a, b);
|
||||
bool neqf = neq(a, b), nltf = nlt(a, b), ngtf = ngt(a, b), nlef = nle(a, b), ngef = nge(a, b);
|
||||
|
||||
printf("BYTE %ld, %ld : EQ %d LT %d GT %d\r", a, b, beqf, bltf, bgtf);
|
||||
printf("NATIVE %ld, %ld : EQ %d LT %d GT %d\r", a, b, neqf, nltf, ngtf);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmpi(long a, long b)
|
||||
{
|
||||
bool ieqf = ieq(a, b), iltf = ilt(a, b), igtf = igt(a, b), ilef = ile(a, b), igef = ige(a, b);
|
||||
bool neqf = neq(a, b), nltf = nlt(a, b), ngtf = ngt(a, b), nlef = nle(a, b), ngef = nge(a, b);
|
||||
|
||||
printf("INLINE %ld, %ld : EQ %d LT %d GT %d\r", a, b, ieqf, iltf, igtf);
|
||||
printf("NATIVE %ld, %ld : EQ %d LT %d GT %d\r", a, b, neqf, nltf, ngtf);
|
||||
|
||||
assert(ieqf == neqf);
|
||||
assert(iltf == nltf);
|
||||
assert(igtf == ngtf);
|
||||
assert(ilef == nlef);
|
||||
assert(igef == ngef);
|
||||
}
|
||||
|
||||
void cmp(long a, long b)
|
||||
{
|
||||
cmpc(a, b);
|
||||
cmpi(a, b);
|
||||
}
|
||||
|
||||
void cmpz(long a)
|
||||
{
|
||||
bool beqf = beqz(a), bltf = bltz(a), bgtf = bgtz(a), blef = blez(a), bgef = bgez(a);
|
||||
bool neqf = neqz(a), nltf = nltz(a), ngtf = ngtz(a), nlef = nlez(a), ngef = ngez(a);
|
||||
|
||||
printf("BYTE %ld, 0 : EQ %d LT %d GT %d\r", a, beqf, bltf, bgtf);
|
||||
printf("NATIVE %ld, 0 : EQ %d LT %d GT %d\r", a, neqf, nltf, ngtf);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmp1(long a)
|
||||
{
|
||||
bool beqf = beq1(a), bltf = blt1(a), bgtf = bgt1(a), blef = ble1(a), bgef = bge1(a);
|
||||
bool neqf = neq1(a), nltf = nlt1(a), ngtf = ngt1(a), nlef = nle1(a), ngef = nge1(a);
|
||||
|
||||
printf("BYTE %ld, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, beqf, bltf, bgtf, blef, bgef);
|
||||
printf("NATIVE %ld, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, neqf, nltf, ngtf, nlef, ngef);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmpm(long a)
|
||||
{
|
||||
bool beqf = beqm(a), bltf = bltm(a), bgtf = bgtm(a), blef = blem(a), bgef = bgem(a);
|
||||
bool neqf = neqm(a), nltf = nltm(a), ngtf = ngtm(a), nlef = nlem(a), ngef = ngem(a);
|
||||
|
||||
printf("BYTE %ld, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, beqf, bltf, bgtf, blef, bgef);
|
||||
printf("NATIVE %ld, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, neqf, nltf, ngtf, nlef, ngef);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
cmp( 0, 1);
|
||||
cmp( 0, -1);
|
||||
cmp( 1, 0);
|
||||
cmp(-1, 0);
|
||||
|
||||
cmp(1, 1);
|
||||
cmp(1, 2);
|
||||
cmp(2, 1);
|
||||
|
||||
cmp(-1, -1);
|
||||
cmp(-1, -2);
|
||||
cmp(-2, -1);
|
||||
|
||||
cmp( 1, -1);
|
||||
cmp( 1, -2);
|
||||
cmp( 2, -1);
|
||||
|
||||
cmp(-1, 1);
|
||||
cmp(-1, 2);
|
||||
cmp(-2, 1);
|
||||
|
||||
|
||||
cmp( 0, 10000);
|
||||
cmp( 0, -10000);
|
||||
cmp( 10000, 0);
|
||||
cmp(-10000, 0);
|
||||
|
||||
cmp(10000, 10000);
|
||||
cmp(10000, 20000);
|
||||
cmp(20000, 10000);
|
||||
|
||||
cmp(-10000, -10000);
|
||||
cmp(-10000, -20000);
|
||||
cmp(-20000, -10000);
|
||||
|
||||
cmp( 10000, -10000);
|
||||
cmp( 10000, -20000);
|
||||
cmp( 20000, -10000);
|
||||
|
||||
cmp(-10000, 10000);
|
||||
cmp(-10000, 20000);
|
||||
cmp(-20000, 10000);
|
||||
|
||||
cmp( 10000000L, -10000000L);
|
||||
cmp( 10000000L, -20000000L);
|
||||
cmp( 20000000L, -10000000L);
|
||||
|
||||
cmp(-10000000L, 10000000L);
|
||||
cmp(-10000000L, 20000000L);
|
||||
cmp(-20000000L, 10000000L);
|
||||
|
||||
cmp( 0, 1024);
|
||||
cmp( 0, -1024);
|
||||
cmp( 1024, 0);
|
||||
cmp(-1024, 0);
|
||||
|
||||
cmp(1024, 1024);
|
||||
cmp(1024, 1025);
|
||||
cmp(1025, 1024);
|
||||
|
||||
cmp(-1024, -1024);
|
||||
cmp(-1024, -1025);
|
||||
cmp(-1025, -1024);
|
||||
|
||||
cmp( 1024, -1024);
|
||||
cmp( 1024, -1025);
|
||||
cmp( 1025, -1024);
|
||||
|
||||
cmp(-1024, 1024);
|
||||
cmp(-1024, 1025);
|
||||
cmp(-1025, 1024);
|
||||
|
||||
cmpz(0);
|
||||
cmpz(1);
|
||||
cmpz(255);
|
||||
cmpz(256);
|
||||
cmpz(10000);
|
||||
cmpz(20000);
|
||||
cmpz(-1);
|
||||
cmpz(-255);
|
||||
cmpz(-256);
|
||||
cmpz(-10000);
|
||||
cmpz(-20000);
|
||||
|
||||
cmp1(0);
|
||||
cmp1(1);
|
||||
cmp1(2);
|
||||
cmp1(3);
|
||||
cmp1(255);
|
||||
cmp1(256);
|
||||
cmp1(10000);
|
||||
cmp1(20000);
|
||||
cmp1(1000000l);
|
||||
cmp1(2000000l);
|
||||
cmp1(100000000l);
|
||||
cmp1(200000000l);
|
||||
cmp1(-1);
|
||||
cmp1(-2);
|
||||
cmp1(-3);
|
||||
cmp1(-255);
|
||||
cmp1(-256);
|
||||
cmp1(-10000);
|
||||
cmp1(-20000);
|
||||
cmp1(-1000000l);
|
||||
cmp1(-2000000l);
|
||||
cmp1(-100000000l);
|
||||
cmp1(-200000000l);
|
||||
|
||||
cmpm(0);
|
||||
cmpm(1);
|
||||
cmpm(2);
|
||||
cmpm(3);
|
||||
cmpm(255);
|
||||
cmpm(256);
|
||||
cmpm(10000);
|
||||
cmpm(20000);
|
||||
cmpm(1000000l);
|
||||
cmpm(2000000l);
|
||||
cmpm(100000000l);
|
||||
cmpm(200000000l);
|
||||
cmpm(-1);
|
||||
cmpm(-2);
|
||||
cmpm(-3);
|
||||
cmpm(-255);
|
||||
cmpm(-256);
|
||||
cmpm(-10000);
|
||||
cmpm(-20000);
|
||||
cmpm(-1000000l);
|
||||
cmpm(-2000000l);
|
||||
cmpm(-100000000l);
|
||||
cmpm(-200000000l);
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
|
@ -1,555 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
typedef signed char int8;
|
||||
typedef unsigned char uint8;
|
||||
|
||||
bool beq(int8 a, int8 b)
|
||||
{
|
||||
return a == b;
|
||||
}
|
||||
|
||||
bool blt(int8 a, int8 b)
|
||||
{
|
||||
return a < b;
|
||||
}
|
||||
|
||||
bool bgt(int8 a, int8 b)
|
||||
{
|
||||
return a > b;
|
||||
}
|
||||
|
||||
bool ble(int8 a, int8 b)
|
||||
{
|
||||
return a <= b;
|
||||
}
|
||||
|
||||
bool bge(int8 a, int8 b)
|
||||
{
|
||||
return a >= b;
|
||||
}
|
||||
|
||||
bool neq(int8 a, int8 b)
|
||||
{
|
||||
return a == b;
|
||||
}
|
||||
|
||||
#pragma native(neq)
|
||||
|
||||
bool nlt(int8 a, int8 b)
|
||||
{
|
||||
return a < b;
|
||||
}
|
||||
|
||||
#pragma native(nlt)
|
||||
|
||||
bool ngt(int8 a, int8 b)
|
||||
{
|
||||
return a > b;
|
||||
}
|
||||
|
||||
#pragma native(ngt)
|
||||
|
||||
bool nle(int8 a, int8 b)
|
||||
{
|
||||
return a <= b;
|
||||
}
|
||||
|
||||
#pragma native(nle)
|
||||
|
||||
bool nge(int8 a, int8 b)
|
||||
{
|
||||
return a >= b;
|
||||
}
|
||||
|
||||
#pragma native(nge)
|
||||
|
||||
|
||||
|
||||
bool beqz(int8 a)
|
||||
{
|
||||
return a == 0;
|
||||
}
|
||||
|
||||
bool bltz(int8 a)
|
||||
{
|
||||
return a < 0;
|
||||
}
|
||||
|
||||
bool bgtz(int8 a)
|
||||
{
|
||||
return a > 0;
|
||||
}
|
||||
|
||||
bool blez(int8 a)
|
||||
{
|
||||
return a <= 0;
|
||||
}
|
||||
|
||||
bool bgez(int8 a)
|
||||
{
|
||||
return a >= 0;
|
||||
}
|
||||
|
||||
bool neqz(int8 a)
|
||||
{
|
||||
return a == 0;
|
||||
}
|
||||
|
||||
#pragma native(neqz)
|
||||
|
||||
bool nltz(int8 a)
|
||||
{
|
||||
return a < 0;
|
||||
}
|
||||
|
||||
#pragma native(nltz)
|
||||
|
||||
bool ngtz(int8 a)
|
||||
{
|
||||
return a > 0;
|
||||
}
|
||||
|
||||
#pragma native(ngtz)
|
||||
|
||||
bool nlez(int8 a)
|
||||
{
|
||||
return a <= 0;
|
||||
}
|
||||
|
||||
#pragma native(nlez)
|
||||
|
||||
bool ngez(int8 a)
|
||||
{
|
||||
return a >= 0;
|
||||
}
|
||||
|
||||
#pragma native(ngez)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
bool bequz(uint8 a)
|
||||
{
|
||||
return a == 0;
|
||||
}
|
||||
|
||||
bool bltuz(uint8 a)
|
||||
{
|
||||
return a < 0;
|
||||
}
|
||||
|
||||
bool bgtuz(uint8 a)
|
||||
{
|
||||
return a > 0;
|
||||
}
|
||||
|
||||
bool bleuz(uint8 a)
|
||||
{
|
||||
return a <= 0;
|
||||
}
|
||||
|
||||
bool bgeuz(uint8 a)
|
||||
{
|
||||
return a >= 0;
|
||||
}
|
||||
|
||||
bool nequz(uint8 a)
|
||||
{
|
||||
return a == 0;
|
||||
}
|
||||
|
||||
#pragma native(nequz)
|
||||
|
||||
bool nltuz(uint8 a)
|
||||
{
|
||||
return a < 0;
|
||||
}
|
||||
|
||||
#pragma native(nltuz)
|
||||
|
||||
bool ngtuz(uint8 a)
|
||||
{
|
||||
return a > 0;
|
||||
}
|
||||
|
||||
#pragma native(ngtuz)
|
||||
|
||||
bool nleuz(uint8 a)
|
||||
{
|
||||
return a <= 0;
|
||||
}
|
||||
|
||||
#pragma native(nleuz)
|
||||
|
||||
bool ngeuz(uint8 a)
|
||||
{
|
||||
return a >= 0;
|
||||
}
|
||||
|
||||
#pragma native(ngeuz)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
bool beq1(int8 a)
|
||||
{
|
||||
return a == 1;
|
||||
}
|
||||
|
||||
bool blt1(int8 a)
|
||||
{
|
||||
return a < 1;
|
||||
}
|
||||
|
||||
bool bgt1(int8 a)
|
||||
{
|
||||
return a > 1;
|
||||
}
|
||||
|
||||
bool ble1(int8 a)
|
||||
{
|
||||
return a <= 1;
|
||||
}
|
||||
|
||||
bool bge1(int8 a)
|
||||
{
|
||||
return a >= 1;
|
||||
}
|
||||
|
||||
bool neq1(int8 a)
|
||||
{
|
||||
return a == 1;
|
||||
}
|
||||
|
||||
#pragma native(neq1)
|
||||
|
||||
bool nlt1(int8 a)
|
||||
{
|
||||
return a < 1;
|
||||
}
|
||||
|
||||
#pragma native(nlt1)
|
||||
|
||||
bool ngt1(int8 a)
|
||||
{
|
||||
return a > 1;
|
||||
}
|
||||
|
||||
#pragma native(ngt1)
|
||||
|
||||
bool nle1(int8 a)
|
||||
{
|
||||
return a <= 1;
|
||||
}
|
||||
|
||||
#pragma native(nle1)
|
||||
|
||||
bool nge1(int8 a)
|
||||
{
|
||||
return a >= 1;
|
||||
}
|
||||
|
||||
#pragma native(nge1)
|
||||
|
||||
|
||||
|
||||
void cmp(int8 a, int8 b)
|
||||
{
|
||||
bool beqf = beq(a, b), bltf = blt(a, b), bgtf = bgt(a, b), blef = ble(a, b), bgef = bge(a, b);
|
||||
bool neqf = neq(a, b), nltf = nlt(a, b), ngtf = ngt(a, b), nlef = nle(a, b), ngef = nge(a, b);
|
||||
|
||||
printf("BYTE %d, %d : EQ %d LT %d GT %d\r", a, b, beqf, bltf, bgtf);
|
||||
printf("NATIVE %d, %d : EQ %d LT %d GT %d\r", a, b, neqf, nltf, ngtf);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmpz(int8 a)
|
||||
{
|
||||
bool beqf = beqz(a), bltf = bltz(a), bgtf = bgtz(a), blef = blez(a), bgef = bgez(a);
|
||||
bool neqf = neqz(a), nltf = nltz(a), ngtf = ngtz(a), nlef = nlez(a), ngef = ngez(a);
|
||||
|
||||
printf("BYTE %d, 0 : EQ %d LT %d GT %d\r", a, beqf, bltf, bgtf);
|
||||
printf("NATIVE %d, 0 : EQ %d LT %d GT %d\r", a, neqf, nltf, ngtf);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmpuz(uint8 a)
|
||||
{
|
||||
bool beqf = bequz(a), bltf = bltuz(a), bgtf = bgtuz(a), blef = bleuz(a), bgef = bgeuz(a);
|
||||
bool neqf = nequz(a), nltf = nltuz(a), ngtf = ngtuz(a), nlef = nleuz(a), ngef = ngeuz(a);
|
||||
|
||||
printf("BYTE %d, 0 : EQ %d LT %d GT %d\r", a, beqf, bltf, bgtf);
|
||||
printf("NATIVE %d, 0 : EQ %d LT %d GT %d\r", a, neqf, nltf, ngtf);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmp1(int8 a)
|
||||
{
|
||||
bool beqf = beq1(a), bltf = blt1(a), bgtf = bgt1(a), blef = ble1(a), bgef = bge1(a);
|
||||
bool neqf = neq1(a), nltf = nlt1(a), ngtf = ngt1(a), nlef = nle1(a), ngef = nge1(a);
|
||||
|
||||
printf("BYTE %d, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, beqf, bltf, bgtf, blef, bgef);
|
||||
printf("NATIVE %d, 1 : EQ %d LT %d GT %d LE %d GE %d\r", a, neqf, nltf, ngtf, nlef, ngef);
|
||||
|
||||
assert(beqf == neqf);
|
||||
assert(bltf == nltf);
|
||||
assert(bgtf == ngtf);
|
||||
assert(blef == nlef);
|
||||
assert(bgef == ngef);
|
||||
}
|
||||
|
||||
void cmpu(char a, char b, bool lt, bool gt, bool eq)
|
||||
{
|
||||
bool clt = a < b, cgt = a > b, ceq = a == b;
|
||||
bool nlt = a >= b, ngt = a <= b, neq = a != b;
|
||||
|
||||
printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", a, b, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
|
||||
|
||||
assert(clt == lt);
|
||||
assert(cgt == gt);
|
||||
assert(ceq == eq);
|
||||
|
||||
assert(nlt != lt);
|
||||
assert(ngt != gt);
|
||||
assert(neq != eq);
|
||||
}
|
||||
|
||||
void cmpu100(char a, bool lt, bool gt, bool eq)
|
||||
{
|
||||
bool clt = a < 100, cgt = a > 100, ceq = a == 100;
|
||||
bool nlt = a >= 100, ngt = a <= 100, neq = a != 100;
|
||||
|
||||
printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", a, 100, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
|
||||
|
||||
assert(clt == lt);
|
||||
assert(cgt == gt);
|
||||
assert(ceq == eq);
|
||||
|
||||
assert(nlt != lt);
|
||||
assert(ngt != gt);
|
||||
assert(neq != eq);
|
||||
}
|
||||
|
||||
void cmpu100r(char b, bool lt, bool gt, bool eq)
|
||||
{
|
||||
bool clt = 100 < b, cgt = 100 > b, ceq = 100 == b;
|
||||
bool nlt = 100 >= b, ngt = 100 <= b, neq = 100 != b;
|
||||
|
||||
printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", 100, b, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
|
||||
|
||||
assert(clt == lt);
|
||||
assert(cgt == gt);
|
||||
assert(ceq == eq);
|
||||
|
||||
assert(nlt != lt);
|
||||
assert(ngt != gt);
|
||||
assert(neq != eq);
|
||||
}
|
||||
|
||||
void cmpu1000(char a, bool lt, bool gt, bool eq)
|
||||
{
|
||||
bool clt = a < 1000, cgt = a > 1000, ceq = a == 1000;
|
||||
bool nlt = a >= 1000, ngt = a <= 1000, neq = a != 1000;
|
||||
|
||||
printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", a, 1000, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
|
||||
|
||||
assert(clt == lt);
|
||||
assert(cgt == gt);
|
||||
assert(ceq == eq);
|
||||
|
||||
assert(nlt != lt);
|
||||
assert(ngt != gt);
|
||||
assert(neq != eq);
|
||||
}
|
||||
|
||||
void cmpu1000r(char b, bool lt, bool gt, bool eq)
|
||||
{
|
||||
bool clt = 1000< b, cgt = 1000 > b, ceq = 1000 == b;
|
||||
bool nlt = 1000 >= b, ngt = 1000 <= b, neq = 1000 != b;
|
||||
|
||||
printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", 1000, b, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
|
||||
|
||||
assert(clt == lt);
|
||||
assert(cgt == gt);
|
||||
assert(ceq == eq);
|
||||
|
||||
assert(nlt != lt);
|
||||
assert(ngt != gt);
|
||||
assert(neq != eq);
|
||||
}
|
||||
|
||||
void cmpum100(char a, bool lt, bool gt, bool eq)
|
||||
{
|
||||
bool clt = a < -100, cgt = a > -100, ceq = a == -100;
|
||||
bool nlt = a >= -100, ngt = a <= -100, neq = a != -100;
|
||||
|
||||
printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", a, -100, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
|
||||
|
||||
assert(clt == lt);
|
||||
assert(cgt == gt);
|
||||
assert(ceq == eq);
|
||||
|
||||
assert(nlt != lt);
|
||||
assert(ngt != gt);
|
||||
assert(neq != eq);
|
||||
}
|
||||
|
||||
void cmpum100r(char b, bool lt, bool gt, bool eq)
|
||||
{
|
||||
bool clt = -100 < b, cgt = -100 > b, ceq = -100 == b;
|
||||
bool nlt = -100 >= b, ngt = -100 <= b, neq = -100 != b;
|
||||
|
||||
printf("CPMPU %d, %d LT %d%d%d GT %d%d%d EQ %d%d%d\n", -100, b, lt, clt, nlt, gt, cgt, ngt, eq, ceq, neq);
|
||||
|
||||
assert(clt == lt);
|
||||
assert(cgt == gt);
|
||||
assert(ceq == eq);
|
||||
|
||||
assert(nlt != lt);
|
||||
assert(ngt != gt);
|
||||
assert(neq != eq);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
cmp( 0, 1);
|
||||
cmp( 0, -1);
|
||||
cmp( 1, 0);
|
||||
cmp(-1, 0);
|
||||
|
||||
cmp(1, 1);
|
||||
cmp(1, 2);
|
||||
cmp(2, 1);
|
||||
|
||||
cmp(-1, -1);
|
||||
cmp(-1, -2);
|
||||
cmp(-2, -1);
|
||||
|
||||
cmp( 1, -1);
|
||||
cmp( 1, -2);
|
||||
cmp( 2, -1);
|
||||
|
||||
cmp(-1, 1);
|
||||
cmp(-1, 2);
|
||||
cmp(-2, 1);
|
||||
|
||||
|
||||
cmp( 0, 100);
|
||||
cmp( 0, -100);
|
||||
cmp( 100, 0);
|
||||
cmp(-100, 0);
|
||||
|
||||
cmp(10, 10);
|
||||
cmp(10, 20);
|
||||
cmp(20, 10);
|
||||
|
||||
cmp(-10, -10);
|
||||
cmp(-10, -20);
|
||||
cmp(-20, -10);
|
||||
|
||||
cmp( 10, -10);
|
||||
cmp( 10, -20);
|
||||
cmp( 20, -10);
|
||||
|
||||
cmp(-10, 10);
|
||||
cmp(-10, 20);
|
||||
cmp(-20, 10);
|
||||
|
||||
cmp(-30, 30);
|
||||
cmp(-30, -30);
|
||||
cmp( 30, 30);
|
||||
cmp( 30, -30);
|
||||
|
||||
cmp( 0, 127);
|
||||
cmp( 0, -128);
|
||||
cmp( 127, 0);
|
||||
cmp(-128, 0);
|
||||
|
||||
cmp( 127, 127);
|
||||
cmp( 127, -128);
|
||||
cmp(-128, 127);
|
||||
cmp(-128, -128);
|
||||
|
||||
cmpz(0);
|
||||
cmpz(1);
|
||||
cmpz(127);
|
||||
cmpz(-1);
|
||||
cmpz(-128);
|
||||
|
||||
cmpuz(0);
|
||||
cmpuz(1);
|
||||
cmpuz(127);
|
||||
cmpuz(128);
|
||||
cmpuz(255);
|
||||
|
||||
cmp1(0);
|
||||
cmp1(1);
|
||||
cmp1(2);
|
||||
cmp1(3);
|
||||
cmp1(127);
|
||||
cmp1(-1);
|
||||
cmp1(-2);
|
||||
cmp1(-3);
|
||||
cmp1(-128);
|
||||
|
||||
cmpu(0, 0, false, false, true);
|
||||
cmpu(0, 1, true, false, false);
|
||||
cmpu(1, 0, false ,true, false);
|
||||
|
||||
cmpu(128, 128, false, false, true);
|
||||
cmpu( 0, 128, true, false, false);
|
||||
cmpu(128, 0, false ,true, false);
|
||||
|
||||
cmpu(255, 255, false, false, true);
|
||||
cmpu( 0, 255, true, false, false);
|
||||
cmpu(255, 0, false ,true, false);
|
||||
|
||||
cmpu(127, 127, false, false, true);
|
||||
cmpu(128, 255, true, false, false);
|
||||
cmpu(255, 128, false ,true, false);
|
||||
|
||||
cmpu100(100, false, false, true);
|
||||
cmpu100( 0, true, false, false);
|
||||
cmpu100(130, false, true, false);
|
||||
|
||||
cmpu100r(100, false, false, true);
|
||||
cmpu100r(130, true, false, false);
|
||||
cmpu100r( 0, false, true, false);
|
||||
|
||||
cmpum100( 0, false, true, false);
|
||||
cmpum100(130, false, true, false);
|
||||
|
||||
cmpum100r(130, true, false, false);
|
||||
cmpum100r( 0, true, false, false);
|
||||
|
||||
cmpu1000(100, true, false, false);
|
||||
cmpu1000( 0, true, false, false);
|
||||
cmpu1000(130, true, false, false);
|
||||
|
||||
cmpu1000r(100, false, true, false);
|
||||
cmpu1000r(130, false, true, false);
|
||||
cmpu1000r( 0, false, true, false);
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,58 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
void testint0(void)
|
||||
{
|
||||
int a0n = 0, an0 = 0;
|
||||
int b0n = 0, bn0 = 0;
|
||||
|
||||
for(int i=-1000; i<1000; i++)
|
||||
{
|
||||
if (i >= 0 && i < 500)
|
||||
a0n += 1;
|
||||
if (i < 500 && i >= 0)
|
||||
an0 += 1;
|
||||
if (i >= 0 && i <= 499)
|
||||
b0n += 1;
|
||||
if (i <= 499 && i >= 0)
|
||||
bn0 += 1;
|
||||
}
|
||||
|
||||
assert(a0n == 500);
|
||||
assert(an0 == 500);
|
||||
assert(b0n == 500);
|
||||
assert(bn0 == 500);
|
||||
}
|
||||
|
||||
typedef signed char int8;
|
||||
|
||||
void testbyte0(void)
|
||||
{
|
||||
int8 a0n = 0, an0 = 0;
|
||||
int8 b0n = 0, bn0 = 0;
|
||||
|
||||
for(int8 i=-100; i<100; i++)
|
||||
{
|
||||
if (i >= 0 && i < 50)
|
||||
a0n += 1;
|
||||
if (i < 50 && i >= 0)
|
||||
an0 += 1;
|
||||
if (i >= 0 && i <= 49)
|
||||
b0n += 1;
|
||||
if (i <= 49 && i >= 0)
|
||||
bn0 += 1;
|
||||
}
|
||||
|
||||
assert(a0n == 50);
|
||||
assert(an0 == 50);
|
||||
assert(b0n == 50);
|
||||
assert(bn0 == 50);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
testint0();
|
||||
testbyte0();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
int multab[32];
|
||||
|
||||
void fill_mulli(int m)
|
||||
{
|
||||
#pragma unroll(full)
|
||||
for(int i=-16; i<16; i++)
|
||||
if (i != 0)
|
||||
multab[i + 16] = m / i;
|
||||
}
|
||||
|
||||
void check_mulli(int m)
|
||||
{
|
||||
for(int i=-16; i<16; i++)
|
||||
if (i != 0)
|
||||
assert(multab[i + 16] == m / i);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
for(int i=-1024; i<=1024; i++)
|
||||
{
|
||||
fill_mulli(i);
|
||||
check_mulli(i);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
int multab[32];
|
||||
|
||||
void fill_mulli(int m)
|
||||
{
|
||||
#pragma unroll(full)
|
||||
for(int i=-16; i<16; i++)
|
||||
multab[i + 16] = m * i;
|
||||
}
|
||||
|
||||
void check_mulli(int m)
|
||||
{
|
||||
for(int i=-16; i<16; i++)
|
||||
assert(multab[i + 16] == m * i);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
for(int i=-1024; i<=1024; i++)
|
||||
{
|
||||
fill_mulli(i);
|
||||
check_mulli(i);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
struct A
|
||||
{
|
||||
virtual int f(int x);
|
||||
};
|
||||
|
||||
struct B : A
|
||||
{
|
||||
virtual int f(int x);
|
||||
};
|
||||
|
||||
struct C : A
|
||||
{
|
||||
virtual int f(int x);
|
||||
virtual int g(int y, int z);
|
||||
};
|
||||
|
||||
struct D : B
|
||||
{
|
||||
virtual int f(int x);
|
||||
};
|
||||
|
||||
struct E : C
|
||||
{
|
||||
virtual int f(int x);
|
||||
virtual int g(int y, int z);
|
||||
};
|
||||
|
||||
struct F : C
|
||||
{
|
||||
virtual int g(int y, int z);
|
||||
};
|
||||
|
||||
int A::f(int x)
|
||||
{
|
||||
return x * 1;
|
||||
}
|
||||
|
||||
int B::f(int x)
|
||||
{
|
||||
return x * 2;
|
||||
}
|
||||
|
||||
int C::f(int x)
|
||||
{
|
||||
return x * 3;
|
||||
}
|
||||
|
||||
int C::g(int y, int z)
|
||||
{
|
||||
return (y + z) * 3;
|
||||
}
|
||||
|
||||
int D::f(int x)
|
||||
{
|
||||
return x * 4;
|
||||
}
|
||||
|
||||
int E::f(int x)
|
||||
{
|
||||
return x * 5;
|
||||
}
|
||||
|
||||
int E::g(int y, int z)
|
||||
{
|
||||
return (y + z) * 5;
|
||||
}
|
||||
|
||||
int F::g(int y, int z)
|
||||
{
|
||||
return (y + z) * 6;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
A a;
|
||||
B b;
|
||||
C c;
|
||||
D d;
|
||||
E e;
|
||||
F f;
|
||||
|
||||
assert(a.f(3) == c.f(1));
|
||||
assert(b.f(4) == d.f(2));
|
||||
assert(e.f(2) == b.f(5));
|
||||
assert(f.f(5) == e.f(3));
|
||||
|
||||
assert(c.g(3, 2) == e.g(1, 2));
|
||||
assert(c.g(1, 5) == f.g(0, 3));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
struct Node
|
||||
{
|
||||
virtual float eval(void)
|
||||
{
|
||||
return 1.0e6;
|
||||
}
|
||||
};
|
||||
|
||||
struct ConstNode : Node
|
||||
{
|
||||
float c;
|
||||
|
||||
ConstNode(float c_)
|
||||
: c(c_) {}
|
||||
|
||||
virtual float eval(void)
|
||||
{
|
||||
return c;
|
||||
}
|
||||
};
|
||||
|
||||
struct BinopNode : Node
|
||||
{
|
||||
Node * left, * right;
|
||||
|
||||
BinopNode(Node * left_, Node * right_)
|
||||
: left(left_), right(right_)
|
||||
{}
|
||||
};
|
||||
|
||||
struct AddNode : BinopNode
|
||||
{
|
||||
AddNode(Node * left_, Node * right_)
|
||||
: BinopNode(left_, right_)
|
||||
{}
|
||||
|
||||
virtual float eval(void)
|
||||
{
|
||||
return left->eval() + right->eval();
|
||||
}
|
||||
};
|
||||
|
||||
struct SubNode : BinopNode
|
||||
{
|
||||
SubNode(Node * left_, Node * right_)
|
||||
: BinopNode(left_, right_)
|
||||
{}
|
||||
|
||||
virtual float eval(void)
|
||||
{
|
||||
return left->eval() - right->eval();
|
||||
}
|
||||
};
|
||||
|
||||
struct MulNode : BinopNode
|
||||
{
|
||||
MulNode(Node * left_, Node * right_)
|
||||
: BinopNode(left_, right_)
|
||||
{}
|
||||
|
||||
virtual float eval(void)
|
||||
{
|
||||
return left->eval() * right->eval();
|
||||
}
|
||||
};
|
||||
|
||||
int main(void)
|
||||
{
|
||||
Node * n =
|
||||
new SubNode(
|
||||
new MulNode(new ConstNode(4), new ConstNode(5)),
|
||||
new AddNode(new ConstNode(12), new ConstNode(7)));
|
||||
|
||||
assert(n->eval() == 1.0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
#include <assert.h>
|
||||
|
||||
int a, b, c;
|
||||
|
||||
struct A
|
||||
{
|
||||
A(void)
|
||||
{
|
||||
a++;
|
||||
}
|
||||
|
||||
virtual ~A(void)
|
||||
{
|
||||
a--;
|
||||
}
|
||||
};
|
||||
|
||||
struct B : A
|
||||
{
|
||||
B(void)
|
||||
{
|
||||
b++;
|
||||
}
|
||||
|
||||
virtual ~B(void)
|
||||
{
|
||||
b--;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
struct C : B
|
||||
{
|
||||
C(void)
|
||||
{
|
||||
c++;
|
||||
}
|
||||
|
||||
virtual ~C(void)
|
||||
{
|
||||
c--;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
int main()
|
||||
{
|
||||
A * t[3];
|
||||
|
||||
t[0] = new A();
|
||||
t[1] = new B();
|
||||
t[2] = new C();
|
||||
|
||||
assert(a == 3 && b == 2 && c == 1);
|
||||
|
||||
delete t[0];
|
||||
delete t[1];
|
||||
delete t[2];
|
||||
|
||||
assert(a == 0 && b == 0 && c == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,201 +0,0 @@
|
|||
#include "sidfx.h"
|
||||
|
||||
enum SIDFXState
|
||||
{
|
||||
SIDFX_IDLE,
|
||||
SIDFX_RESET_0,
|
||||
SIDFX_RESET_1,
|
||||
SIDFX_READY,
|
||||
SIDFX_PLAY,
|
||||
SIDFX_WAIT
|
||||
};
|
||||
|
||||
__striped static struct SIDFXChannel
|
||||
{
|
||||
const SIDFX * volatile com;
|
||||
byte delay, priority;
|
||||
volatile byte cnt;
|
||||
volatile SIDFXState state;
|
||||
unsigned freq, pwm;
|
||||
|
||||
} channels[3];
|
||||
|
||||
void sidfx_init(void)
|
||||
{
|
||||
for(char i=0; i<3; i++)
|
||||
{
|
||||
channels[i].com = nullptr;
|
||||
channels[i].state = SIDFX_IDLE;
|
||||
channels[i].priority = 0;
|
||||
channels[i].delay = 1;
|
||||
}
|
||||
}
|
||||
|
||||
bool sidfx_idle(byte chn)
|
||||
{
|
||||
return channels[chn].state == SIDFX_IDLE;
|
||||
}
|
||||
|
||||
char sidfx_cnt(byte chn)
|
||||
{
|
||||
return channels[chn].cnt;
|
||||
}
|
||||
|
||||
void sidfx_play(byte chn, const SIDFX * fx, byte cnt)
|
||||
{
|
||||
SIDFXState ns = channels[chn].state;
|
||||
|
||||
if (ns == SIDFX_IDLE)
|
||||
ns = SIDFX_READY;
|
||||
else if (channels[chn].priority <= fx->priority)
|
||||
ns = SIDFX_RESET_0;
|
||||
else
|
||||
return;
|
||||
|
||||
channels[chn].state = SIDFX_IDLE;
|
||||
channels[chn].delay = 1;
|
||||
|
||||
channels[chn].com = fx;
|
||||
channels[chn].cnt = cnt - 1;
|
||||
channels[chn].priority = fx->priority;
|
||||
|
||||
channels[chn].state = ns;
|
||||
}
|
||||
|
||||
void sidfx_stop(byte chn)
|
||||
{
|
||||
channels[chn].com = nullptr;
|
||||
if (channels[chn].state != SIDFX_IDLE)
|
||||
{
|
||||
channels[chn].state = SIDFX_RESET_0;
|
||||
channels[chn].delay = 1;
|
||||
}
|
||||
}
|
||||
|
||||
inline void sidfx_loop_ch(byte ch)
|
||||
{
|
||||
if (channels[ch].state)
|
||||
{
|
||||
const SIDFX * com = channels[ch].com;
|
||||
|
||||
channels[ch].delay--;
|
||||
if (channels[ch].delay)
|
||||
{
|
||||
if (com->dfreq)
|
||||
{
|
||||
channels[ch].freq += com->dfreq;
|
||||
sid.voices[ch].freq = channels[ch].freq;
|
||||
}
|
||||
if (com->dpwm)
|
||||
{
|
||||
channels[ch].pwm += com->dpwm;
|
||||
sid.voices[ch].pwm = channels[ch].pwm;
|
||||
}
|
||||
}
|
||||
|
||||
while (!channels[ch].delay)
|
||||
{
|
||||
switch (channels[ch].state)
|
||||
{
|
||||
case SIDFX_IDLE:
|
||||
channels[ch].delay = 1;
|
||||
break;
|
||||
case SIDFX_RESET_0:
|
||||
sid.voices[ch].ctrl = 0;
|
||||
sid.voices[ch].attdec = 0;
|
||||
sid.voices[ch].susrel = 0;
|
||||
if (com)
|
||||
channels[ch].state = SIDFX_READY;
|
||||
else
|
||||
channels[ch].state = SIDFX_IDLE;
|
||||
channels[ch].delay = 1;
|
||||
break;
|
||||
case SIDFX_RESET_1:
|
||||
sid.voices[ch].ctrl = SID_CTRL_TEST;
|
||||
sid.voices[ch].ctrl = 0;
|
||||
sid.voices[ch].attdec = 0;
|
||||
sid.voices[ch].susrel = 0;
|
||||
channels[ch].state = SIDFX_READY;
|
||||
break;
|
||||
case SIDFX_READY:
|
||||
channels[ch].freq = com->freq;
|
||||
channels[ch].pwm = com->pwm;
|
||||
|
||||
sid.voices[ch].freq = com->freq;
|
||||
sid.voices[ch].pwm = com->pwm;
|
||||
sid.voices[ch].attdec = com->attdec;
|
||||
sid.voices[ch].susrel = com->susrel;
|
||||
sid.voices[ch].ctrl = com->ctrl;
|
||||
|
||||
if (com->ctrl & SID_CTRL_GATE)
|
||||
{
|
||||
channels[ch].delay = com->time1;
|
||||
channels[ch].state = SIDFX_PLAY;
|
||||
}
|
||||
else
|
||||
{
|
||||
channels[ch].delay = com->time0;
|
||||
channels[ch].state = SIDFX_PLAY;
|
||||
}
|
||||
break;
|
||||
case SIDFX_PLAY:
|
||||
if (com->time0)
|
||||
{
|
||||
sid.voices[ch].ctrl = com->ctrl & ~SID_CTRL_GATE;
|
||||
channels[ch].delay = com->time0 - 1;
|
||||
channels[ch].state = SIDFX_WAIT;
|
||||
}
|
||||
else if (channels[ch].cnt)
|
||||
{
|
||||
char sr = com->susrel & 0xf0;
|
||||
com++;
|
||||
char ctrl = com->ctrl;
|
||||
if ((com->attdec & 0xef) == 0 && (ctrl & SID_CTRL_GATE) && (com->susrel & 0xf0) > sr)
|
||||
{
|
||||
sid.voices[ch].ctrl = ctrl & ~SID_CTRL_GATE;
|
||||
sid.voices[ch].ctrl = ctrl | SID_CTRL_GATE;
|
||||
}
|
||||
channels[ch].cnt--;
|
||||
channels[ch].com = com;
|
||||
channels[ch].priority = com->priority;
|
||||
channels[ch].state = SIDFX_READY;
|
||||
}
|
||||
else
|
||||
{
|
||||
com = nullptr;
|
||||
channels[ch].state = SIDFX_RESET_0;
|
||||
}
|
||||
break;
|
||||
case SIDFX_WAIT:
|
||||
if (channels[ch].cnt)
|
||||
{
|
||||
com++;
|
||||
channels[ch].cnt--;
|
||||
channels[ch].com = com;
|
||||
channels[ch].priority = com->priority;
|
||||
if (com->ctrl & SID_CTRL_GATE)
|
||||
channels[ch].state = SIDFX_RESET_0;
|
||||
else
|
||||
channels[ch].state = SIDFX_READY;
|
||||
}
|
||||
else
|
||||
{
|
||||
com = nullptr;
|
||||
channels[ch].state = SIDFX_RESET_0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void sidfx_loop_2(void)
|
||||
{
|
||||
sidfx_loop_ch(2);
|
||||
}
|
||||
|
||||
void sidfx_loop(void)
|
||||
{
|
||||
for(byte ch=0; ch<3; ch++)
|
||||
sidfx_loop_ch(ch);
|
||||
}
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
#ifndef SIDFX_H
|
||||
#define SIDFX_H
|
||||
|
||||
#include <c64/sid.h>
|
||||
|
||||
struct SIDFX
|
||||
{
|
||||
unsigned freq, pwm;
|
||||
byte ctrl, attdec, susrel;
|
||||
int dfreq, dpwm;
|
||||
byte time1, time0;
|
||||
byte priority;
|
||||
};
|
||||
|
||||
void sidfx_init(void);
|
||||
|
||||
inline bool sidfx_idle(byte chn);
|
||||
|
||||
inline void sidfx_play(byte chn, const SIDFX * fx, byte cnt);
|
||||
|
||||
void sidfx_stop(byte chn);
|
||||
|
||||
char sidfx_cnt(byte chn);
|
||||
|
||||
void sidfx_loop(void);
|
||||
|
||||
void sidfx_loop_2(void);
|
||||
|
||||
#pragma compile("sidfx.c")
|
||||
|
||||
#endif
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
#include "bank1.h"
|
||||
#include "mmu.h"
|
||||
#include <string.h>
|
||||
|
||||
void bnk1_init(void)
|
||||
{
|
||||
mmu.cr = 0x3e;
|
||||
memcpy((char *)0xfc00, (char *)0xf000, 0x0300);
|
||||
xmmu.rcr |= 0x0c;
|
||||
mmu.cr = 0x3f;
|
||||
}
|
||||
|
||||
#pragma code(bnk1code)
|
||||
|
||||
char bnk1_readb(volatile char * p)
|
||||
{
|
||||
mmu.bank1 = 0;
|
||||
char c = *p;
|
||||
mmu.bank0 = 0;
|
||||
return c;
|
||||
}
|
||||
|
||||
unsigned bnk1_readw(volatile unsigned * p)
|
||||
{
|
||||
mmu.bank1 = 0;
|
||||
unsigned w = *p;
|
||||
mmu.bank0 = 1;
|
||||
return w;
|
||||
}
|
||||
|
||||
unsigned long bnk1_readl(volatile unsigned long * p)
|
||||
{
|
||||
mmu.bank1 = 0;
|
||||
unsigned long l = *p;
|
||||
mmu.bank0 = 3;
|
||||
return l;
|
||||
}
|
||||
|
||||
void bnk1_readm(char * dp, volatile char * sp, unsigned size)
|
||||
{
|
||||
while (size > 0)
|
||||
{
|
||||
mmu.bank1 = 0;
|
||||
char c = * sp++;
|
||||
mmu.bank0 = c;
|
||||
*dp++ = c;
|
||||
size--;
|
||||
}
|
||||
}
|
||||
|
||||
void bnk1_writeb(volatile char * p, char b)
|
||||
{
|
||||
mmu.bank1 = b;
|
||||
*p = b;
|
||||
mmu.bank0 = b;
|
||||
}
|
||||
|
||||
void bnk1_writew(volatile unsigned * p, unsigned w)
|
||||
{
|
||||
mmu.bank1 = w;
|
||||
*p = w;
|
||||
mmu.bank0 = w;
|
||||
}
|
||||
|
||||
void bnk1_writel(volatile unsigned long * p, unsigned long l)
|
||||
{
|
||||
mmu.bank1 = l;
|
||||
*p = l;
|
||||
mmu.bank0 = l;
|
||||
}
|
||||
|
||||
void bnk1_writem(volatile char * dp, const char * sp, unsigned size)
|
||||
{
|
||||
while (size > 0)
|
||||
{
|
||||
char c = * sp++;
|
||||
mmu.bank1 = c;
|
||||
*dp++ = c;
|
||||
mmu.bank0 = c;
|
||||
size--;
|
||||
}
|
||||
}
|
||||
|
||||
#pragma code(code)
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
#ifndef C128_BANK1_H
|
||||
#define C128_BANK1_H
|
||||
|
||||
|
||||
#pragma section( bnk1code, 0)
|
||||
|
||||
#pragma region( bnk1code, 0xf000, 0xf300, , , {bnk1code}, 0xfc00 )
|
||||
|
||||
void bnk1_init(void);
|
||||
|
||||
#pragma code(bnk1code)
|
||||
|
||||
__noinline char bnk1_readb(volatile char * p);
|
||||
|
||||
__noinline unsigned bnk1_readw(volatile unsigned * p);
|
||||
|
||||
__noinline unsigned long bnk1_readl(volatile unsigned long * p);
|
||||
|
||||
__noinline void bnk1_readm(char * dp, volatile char * sp, unsigned size);
|
||||
|
||||
|
||||
__noinline void bnk1_writeb(volatile char * p, char b);
|
||||
|
||||
__noinline void bnk1_writew(volatile unsigned * p, unsigned w);
|
||||
|
||||
__noinline void bnk1_writel(volatile unsigned long * p, unsigned long l);
|
||||
|
||||
__noinline void bnk1_writem(volatile char * dp, const char * sp, unsigned size);
|
||||
|
||||
#pragma code(code)
|
||||
|
||||
#pragma compile("bank1.c")
|
||||
|
||||
#endif
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
#include "mmu.h"
|
||||
|
||||
inline char mmu_set(char cr)
|
||||
{
|
||||
char pcr = mmu.cr;
|
||||
mmu.cr = cr;
|
||||
return pcr;
|
||||
}
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
#ifndef C128_MMU_H
|
||||
#define C128_MMU_H
|
||||
|
||||
#include <c64/types.h>
|
||||
|
||||
struct MMU
|
||||
{
|
||||
volatile byte cr;
|
||||
volatile byte bank0;
|
||||
volatile byte bank1;
|
||||
volatile byte bank14;
|
||||
volatile byte bankx;
|
||||
};
|
||||
|
||||
struct XMMU
|
||||
{
|
||||
volatile byte cr;
|
||||
volatile byte pcr[4];
|
||||
volatile byte mcr;
|
||||
volatile byte rcr;
|
||||
volatile word page0;
|
||||
volatile word page1;
|
||||
volatile byte vr;
|
||||
};
|
||||
|
||||
#define mmu (*((struct MMU *)0xff00))
|
||||
|
||||
#define xmmu (*((struct XMMU *)0xd500))
|
||||
|
||||
inline char mmu_set(char cr);
|
||||
|
||||
#pragma compile("mmu.c")
|
||||
|
||||
#endif
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue