forked from KolibriOS/kolibrios
Added git source kolibri-libc and
Configured autobuild git-svn-id: svn://kolibrios.org@8687 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
turbocat
@@ -0,0 +1,23 @@
|
||||
|
||||
CC=kos32-gcc
|
||||
|
||||
KPACK=kpack
|
||||
FASM=fasm
|
||||
|
||||
CFLAGS = -c -nostdinc -I../include -DGNUC -D_KOLIBRI_LIBC_OBJ -Os -fno-common -fno-builtin -fno-leading-underscore -fno-pie
|
||||
|
||||
SRC=libc.c
|
||||
LIB=libc.obj
|
||||
|
||||
all:
|
||||
$(MAKE) -C ../linuxtools/src
|
||||
mkdir -p exports ../lib
|
||||
../linuxtools/ExportGen symbols.txt exports/exports.c
|
||||
$(FASM) crt/crt0.asm ../lib/crt0.o
|
||||
$(CC) $(CFLAGS) $(SRC) -o $(LIB)
|
||||
$(KPACK) $(LIB)
|
||||
install:
|
||||
cp -f ../lib/libc.obj ~/.kex/root/RD/1/LIB
|
||||
|
||||
clean:
|
||||
rm ../lib/libc.obj
|
||||
@@ -0,0 +1,16 @@
|
||||
if tup.getconfig("NO_GCC") ~= "" then return end
|
||||
HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../../../" or tup.getconfig("HELPERDIR")
|
||||
tup.include(HELPERDIR .. "/use_gcc.lua")
|
||||
|
||||
CFLAGS = " -c -w -nostdinc -DGNUC -D_KOLIBRI_LIBC_OBJ -Os -fno-common -fno-builtin -fno-leading-underscore -fno-pie"
|
||||
INCLUDES = " -I../include"
|
||||
|
||||
tup.rule("../linuxtools/src/ExportGen.c", "gcc %f -o %o" , "../linuxtools/ExportGen")
|
||||
tup.rule("../linuxtools/src/LoaderGen.c", "gcc %f -o %o" , "../linuxtools/LoaderGen")
|
||||
|
||||
tup.rule({"symbols.txt",extra_inputs = {"../linuxtools/ExportGen"}}, "../linuxtools/ExportGen %f %o" , "exports/exports.c")
|
||||
|
||||
tup.rule({"libc.c",extra_inputs = {"exports/exports.c"}} , "kos32-gcc" .. CFLAGS .. INCLUDES .. " -o %o %f " .. tup.getconfig("KPACK_CMD"), "../lib/libc.obj")
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
__CPU_type fix p5
|
||||
@@ -0,0 +1,253 @@
|
||||
format ELF
|
||||
section '.text' executable
|
||||
public start
|
||||
public start as '_start'
|
||||
;extrn mf_init
|
||||
extrn main
|
||||
;include 'debug2.inc'
|
||||
include 'proc32.inc'
|
||||
include 'macros.inc'
|
||||
include 'dll.inc'
|
||||
__DEBUG__=0
|
||||
|
||||
;start_:
|
||||
virtual at 0
|
||||
db 'MENUET01' ; 1. Magic number (8 bytes)
|
||||
dd 0x01 ; 2. Version of executable file
|
||||
dd start ; 3. Start address
|
||||
imgsz dd 0x0 ; 4. Size of image
|
||||
dd 0x100000 ; 5. Size of needed memory
|
||||
dd 0x100000 ; 6. Pointer to stack
|
||||
hparams dd 0x0 ; 7. Pointer to program arguments
|
||||
hpath dd 0x0 ; 8. Pointer to program path
|
||||
end virtual
|
||||
|
||||
start:
|
||||
;DEBUGF 'Start programm\n'
|
||||
;init heap of memory
|
||||
mov eax,68
|
||||
mov ebx,11
|
||||
int 0x40
|
||||
|
||||
mov [argc], 0
|
||||
mov eax, [hparams]
|
||||
test eax, eax
|
||||
jz .without_path
|
||||
mov eax, path
|
||||
cmp word ptr eax, 32fh ; '/#3' UTF8
|
||||
jne .without_path
|
||||
mov word ptr eax, 12fh ; '/#1' fix to CP866
|
||||
.without_path:
|
||||
mov esi, eax
|
||||
call push_param
|
||||
; retrieving parameters
|
||||
mov esi, params
|
||||
xor edx, edx ; dl - èä¸ò ïàðàìåòð(1) èëè ðàçäåëèòåëè(0)
|
||||
; dh - ñèìâîë ñ êîòîðîãî íà÷àëñÿ ïàðàìåòð (1 êàâû÷êè, 0 îñòàëüíîå)
|
||||
mov ecx, 1 ; cl = 1
|
||||
; ch = 0 ïðîñòî íîëü
|
||||
.parse:
|
||||
lodsb
|
||||
test al, al
|
||||
jz .run
|
||||
test dl, dl
|
||||
jnz .findendparam
|
||||
;{åñëè áûë ðàçäåëèòåëü
|
||||
cmp al, ' '
|
||||
jz .parse ;çàãðóæåí ïðîáåë, ãðóçèì ñëåäóþùèé ñèìâîë
|
||||
mov dl, cl ;íà÷èíàåòñÿ ïàðàìåòð
|
||||
cmp al, '"'
|
||||
jz @f ;çàãðóæåíû êàâû÷êè
|
||||
mov dh, ch ;ïàðàìåòð áåç êàâû÷åê
|
||||
dec esi
|
||||
call push_param
|
||||
inc esi
|
||||
jmp .parse
|
||||
|
||||
@@:
|
||||
mov dh, cl ;ïàðàìåòð â êàâû÷åêàõ
|
||||
call push_param ;åñëè íå ïðîáåë çíà÷èò íà÷èíàåòñÿ êàêîé òî ïàðàìåòð
|
||||
jmp .parse ;åñëè áûë ðàçäåëèòåëü}
|
||||
|
||||
.findendparam:
|
||||
test dh, dh
|
||||
jz @f ; áåç êàâû÷åê
|
||||
cmp al, '"'
|
||||
jz .clear
|
||||
jmp .parse
|
||||
@@:
|
||||
cmp al, ' '
|
||||
jnz .parse
|
||||
|
||||
.clear:
|
||||
lea ebx, [esi - 1]
|
||||
mov [ebx], ch
|
||||
mov dl, ch
|
||||
jmp .parse
|
||||
|
||||
.run:
|
||||
call load_imports
|
||||
push argv
|
||||
push [argc]
|
||||
call main
|
||||
.exit:
|
||||
xor eax,eax
|
||||
dec eax
|
||||
int 0x40
|
||||
dd -1
|
||||
.crash:
|
||||
jmp .exit
|
||||
;============================
|
||||
push_param:
|
||||
;============================
|
||||
;parameters
|
||||
; esi - pointer
|
||||
;description
|
||||
; procedure increase argc
|
||||
; and add pointer to array argv
|
||||
; procedure changes ebx
|
||||
mov ebx, [argc]
|
||||
cmp ebx, max_parameters
|
||||
jae .dont_add
|
||||
mov [argv+4*ebx], esi
|
||||
inc [argc]
|
||||
.dont_add:
|
||||
ret
|
||||
;==============================
|
||||
|
||||
;==============================
|
||||
load_imports:
|
||||
;==============================
|
||||
;parameters
|
||||
; none
|
||||
;description
|
||||
; imports must be located at end of image (but before BSS sections)
|
||||
; the address of end of imports (next byte after imports) is located in imgsz
|
||||
; look at each import from that address up to illegal import
|
||||
; legal import is such that:
|
||||
; first pointer points to procedure name
|
||||
; and is smaller than imgsz
|
||||
; second pointer points lo library name, starting with 0x55, 0xAA
|
||||
; and is smaller than imgsz
|
||||
; each library should be initialized as appropriate, once
|
||||
; so as library is initialized, its name will be replaced 0x00
|
||||
mov ebx, [imgsz] ; byte after imports
|
||||
.handle_next_import:
|
||||
sub ebx, 4 ; ebx = pointer to pointer to library name
|
||||
mov esi, dword[ebx] ; esi = pointer to library name
|
||||
push ebx
|
||||
push esi
|
||||
call load_library ; eax = pointer to library exports
|
||||
pop esi
|
||||
pop ebx
|
||||
test eax, eax
|
||||
jz .done
|
||||
sub ebx, 4 ; ebx = pointer to pointer to symbol name
|
||||
push ebx
|
||||
stdcall dll.GetProcAddress, eax, dword[ebx]
|
||||
pop ebx
|
||||
test eax, eax
|
||||
jz .fail
|
||||
mov dword[ebx], eax
|
||||
jmp .handle_next_import
|
||||
.done:
|
||||
ret
|
||||
.fail:
|
||||
ret
|
||||
;==============================
|
||||
|
||||
;==============================
|
||||
load_library:
|
||||
;==============================
|
||||
;parameters
|
||||
; ebx: library name address
|
||||
;description
|
||||
; each library should be initialized as appropriate, once
|
||||
; so as library is initialized, its name will be replaced 0x00
|
||||
; and 4 next bytes will be set to address of library
|
||||
; first two bytes of library name must be 0x55, 0xAA (is like a magic)
|
||||
cld ; move esi further, not back
|
||||
cmp esi, [imgsz]
|
||||
ja .fail
|
||||
lodsb ; al = first byte of library name
|
||||
cmp al, 0x55
|
||||
jne .fail
|
||||
lodsb ; al = second byte of library name
|
||||
cmp al, 0xAA
|
||||
jne .fail
|
||||
lodsb ; al = third byte of library name (0x00 if the library is already loaded)
|
||||
test al, al
|
||||
jnz .load
|
||||
lodsd ; if we here, then third byte is 0x00 => address of library is in next 4 bytes
|
||||
; now eax contains address of library
|
||||
ret
|
||||
.load:
|
||||
dec esi ; we checked on 0 before, let's go back
|
||||
mov eax, 68
|
||||
mov ebx, 19
|
||||
mov ecx, esi
|
||||
int 0x40 ; eax = address of exports
|
||||
mov byte[esi], 0 ; library is loaded, let's place 0 in first byte of name
|
||||
mov [esi + 1], eax ; now next 4 bytes of library name are replaced by address of library
|
||||
; call lib_init
|
||||
stdcall dll.GetProcAddress, eax, lib_init_str ; eax = address of lib_init
|
||||
test eax, eax
|
||||
jz .ret
|
||||
stdcall dll.Init, eax
|
||||
.ret:
|
||||
mov eax, [esi + 1] ; put address of library into eax
|
||||
ret
|
||||
.fail:
|
||||
mov eax, 0
|
||||
ret
|
||||
|
||||
; ==== memmove for tcc ======
|
||||
|
||||
proc memmove c, to:dword,from:dword,count:dword
|
||||
|
||||
push esi
|
||||
push edi
|
||||
mov ecx,[count]
|
||||
test ecx,ecx
|
||||
jz no_copy_block_
|
||||
mov esi,[from]
|
||||
mov edi,[to]
|
||||
cmp esi, edi
|
||||
je no_copy_block_
|
||||
jg copy_
|
||||
add esi, ecx
|
||||
add edi, ecx
|
||||
dec esi
|
||||
dec edi
|
||||
std
|
||||
copy_:
|
||||
rep movsb
|
||||
cld
|
||||
no_copy_block_:
|
||||
|
||||
pop edi
|
||||
pop esi
|
||||
mov eax,[to]
|
||||
ret
|
||||
endp
|
||||
|
||||
|
||||
;==============================
|
||||
|
||||
lib_init_str db 'lib_init', 0
|
||||
|
||||
public argc as '__argc'
|
||||
public params as '__argv'
|
||||
public path as '__path'
|
||||
public memmove
|
||||
|
||||
section '.bss'
|
||||
buf_len = 0x400
|
||||
max_parameters=0x20
|
||||
argc rd 1
|
||||
argv rd max_parameters
|
||||
path rb buf_len
|
||||
params rb buf_len
|
||||
|
||||
;section '.data'
|
||||
;include_debug_strings ; ALWAYS present in data section
|
||||
@@ -0,0 +1,193 @@
|
||||
format ELF
|
||||
section '.text' executable
|
||||
public start
|
||||
public start as '_start'
|
||||
;extrn mf_init
|
||||
extrn main
|
||||
include '../../../../programs/proc32.inc'
|
||||
;include 'debug2.inc'
|
||||
__DEBUG__=0
|
||||
|
||||
;start_:
|
||||
virtual at 0
|
||||
db 'MENUET01' ; 1. Magic number (8 bytes)
|
||||
dd 0x01 ; 2. Version of executable file
|
||||
dd start ; 3. Start address
|
||||
dd 0x0 ; 4. Size of image
|
||||
dd 0x100000 ; 5. Size of needed memory
|
||||
dd 0x100000 ; 6. Pointer to stack
|
||||
hparams dd 0x0 ; 7. Pointer to program arguments
|
||||
hpath dd 0x0 ; 8. Pointer to program path
|
||||
end virtual
|
||||
|
||||
start:
|
||||
;DEBUGF 'Start programm\n'
|
||||
;init heap of memory
|
||||
mov eax,68
|
||||
mov ebx,11
|
||||
int 0x40
|
||||
|
||||
;DEBUGF ' path "%s"\n params "%s"\n', .path, .params
|
||||
; check for overflow
|
||||
;; that not work
|
||||
; mov al, [path+buf_len-1]
|
||||
; or al, [params+buf_len-1]
|
||||
; jnz .crash
|
||||
; check if path written by OS
|
||||
mov [argc], 0
|
||||
mov eax, [hparams]
|
||||
test eax, eax
|
||||
jz .without_path
|
||||
mov eax, path
|
||||
cmp word ptr eax, 32fh ; '/#3' UTF8
|
||||
jne .without_path
|
||||
mov word ptr eax, 12fh ; '/#1' fix to CP866
|
||||
.without_path:
|
||||
mov esi, eax
|
||||
call push_param
|
||||
; retrieving parameters
|
||||
mov esi, params
|
||||
xor edx, edx ; dl - èä¸ò ïàðàìåòð(1) èëè ðàçäåëèòåëè(0)
|
||||
; dh - ñèìâîë ñ êîòîðîãî íà÷àëñÿ ïàðàìåòð (1 êàâû÷êè, 0 îñòàëüíîå)
|
||||
mov ecx, 1 ; cl = 1
|
||||
; ch = 0 ïðîñòî íîëü
|
||||
.parse:
|
||||
lodsb
|
||||
test al, al
|
||||
jz .run
|
||||
test dl, dl
|
||||
jnz .findendparam
|
||||
;{åñëè áûë ðàçäåëèòåëü
|
||||
cmp al, ' '
|
||||
jz .parse ;çàãðóæåí ïðîáåë, ãðóçèì ñëåäóþùèé ñèìâîë
|
||||
mov dl, cl ;íà÷èíàåòñÿ ïàðàìåòð
|
||||
cmp al, '"'
|
||||
jz @f ;çàãðóæåíû êàâû÷êè
|
||||
mov dh, ch ;ïàðàìåòð áåç êàâû÷åê
|
||||
dec esi
|
||||
call push_param
|
||||
inc esi
|
||||
jmp .parse
|
||||
|
||||
@@:
|
||||
mov dh, cl ;ïàðàìåòð â êàâû÷åêàõ
|
||||
call push_param ;åñëè íå ïðîáåë çíà÷èò íà÷èíàåòñÿ êàêîé òî ïàðàìåòð
|
||||
jmp .parse ;åñëè áûë ðàçäåëèòåëü}
|
||||
|
||||
.findendparam:
|
||||
test dh, dh
|
||||
jz @f ; áåç êàâû÷åê
|
||||
cmp al, '"'
|
||||
jz .clear
|
||||
jmp .parse
|
||||
@@:
|
||||
cmp al, ' '
|
||||
jnz .parse
|
||||
|
||||
.clear:
|
||||
lea ebx, [esi - 1]
|
||||
mov [ebx], ch
|
||||
mov dl, ch
|
||||
jmp .parse
|
||||
|
||||
.run:
|
||||
;DEBUGF 'call main(%x, %x) with params:\n', [argc], argv
|
||||
if __DEBUG__ = 1
|
||||
mov ecx, [argc]
|
||||
@@:
|
||||
lea esi, [ecx * 4 + argv-4]
|
||||
DEBUGF '0x%x) "%s"\n', cx, [esi]
|
||||
loop @b
|
||||
end if
|
||||
push argv
|
||||
push [argc]
|
||||
call main
|
||||
.exit:
|
||||
;DEBUGF 'Exit from prog\n';
|
||||
xor eax,eax
|
||||
dec eax
|
||||
int 0x40
|
||||
dd -1
|
||||
.crash:
|
||||
;DEBUGF 'E:buffer overflowed\n'
|
||||
jmp .exit
|
||||
;============================
|
||||
push_param:
|
||||
;============================
|
||||
;parameters
|
||||
; esi - pointer
|
||||
;description
|
||||
; procedure increase argc
|
||||
; and add pointer to array argv
|
||||
; procedure changes ebx
|
||||
mov ebx, [argc]
|
||||
cmp ebx, max_parameters
|
||||
jae .dont_add
|
||||
mov [argv+4*ebx], esi
|
||||
inc [argc]
|
||||
.dont_add:
|
||||
ret
|
||||
|
||||
proc memcpy c, to:dword,from:dword,count:dword
|
||||
push esi
|
||||
push edi
|
||||
mov ecx,[count]
|
||||
test ecx,ecx
|
||||
jz no_copy_block
|
||||
mov esi,[from]
|
||||
mov edi,[to]
|
||||
cld
|
||||
rep movsb
|
||||
no_copy_block:
|
||||
|
||||
pop edi
|
||||
pop esi
|
||||
mov eax, [to]
|
||||
ret
|
||||
endp
|
||||
|
||||
proc memmove c, to:dword,from:dword,count:dword
|
||||
|
||||
push esi
|
||||
push edi
|
||||
mov ecx,[count]
|
||||
test ecx,ecx
|
||||
jz no_copy_block_
|
||||
mov esi,[from]
|
||||
mov edi,[to]
|
||||
cmp esi, edi
|
||||
je no_copy_block_
|
||||
jg copy_
|
||||
add esi, ecx
|
||||
add edi, ecx
|
||||
dec esi
|
||||
dec edi
|
||||
std
|
||||
copy_:
|
||||
rep movsb
|
||||
cld
|
||||
no_copy_block_:
|
||||
|
||||
pop edi
|
||||
pop esi
|
||||
mov eax,[to]
|
||||
ret
|
||||
endp
|
||||
|
||||
;==============================
|
||||
public argc as '__argc'
|
||||
public params as '__argv'
|
||||
public path as '__path'
|
||||
public memcpy
|
||||
public memmove
|
||||
|
||||
section '.bss'
|
||||
buf_len = 0x400
|
||||
max_parameters=0x20
|
||||
argc rd 1
|
||||
argv rd max_parameters
|
||||
path rb buf_len
|
||||
params rb buf_len
|
||||
|
||||
;section '.data'
|
||||
;include_debug_strings ; ALWAYS present in data section
|
||||
@@ -0,0 +1,158 @@
|
||||
;-----------------------------------------------------------------------------
|
||||
; load one or more DLL file in COFF format and try to import functions by our list
|
||||
; if first function in import list begins with 'lib_', call it as DLL initialization
|
||||
; return eax = 1 as fail, if anyone of .obj file not found in /sys/lib
|
||||
; return 0 if all fine, but 0 not garantees in succesfull import - see dll.Link comment
|
||||
; dirties all registers! eax, ebx, ecx, edx, esi, edi
|
||||
proc dll.Load, import_table:dword
|
||||
mov esi, [import_table]
|
||||
.next_lib:
|
||||
mov edx, [esi]
|
||||
or edx, edx
|
||||
jz .exit
|
||||
push esi
|
||||
mov esi, [esi + 4]
|
||||
mov edi, s_libdir.fname
|
||||
@@:
|
||||
lodsb
|
||||
stosb
|
||||
or al, al
|
||||
jnz @b
|
||||
mcall 68, 19, s_libdir
|
||||
or eax, eax
|
||||
jz .fail
|
||||
stdcall dll.Link, eax, edx
|
||||
push eax
|
||||
mov eax, [eax]
|
||||
cmp dword[eax], 'lib_'
|
||||
pop eax
|
||||
jnz @f
|
||||
stdcall dll.Init, [eax + 4]
|
||||
@@:
|
||||
pop esi
|
||||
add esi, 8
|
||||
jmp .next_lib
|
||||
.exit:
|
||||
xor eax, eax
|
||||
ret
|
||||
.fail:
|
||||
add esp, 4
|
||||
xor eax, eax
|
||||
inc eax
|
||||
ret
|
||||
endp
|
||||
;-----------------------------------------------------------------------------
|
||||
; scans dll export table for a functions we want to import
|
||||
; break scan on first unresolved import
|
||||
; no return value
|
||||
proc dll.Link, exp:dword, imp:dword
|
||||
push eax
|
||||
mov esi, [imp]
|
||||
test esi, esi
|
||||
jz .done
|
||||
.next:
|
||||
lodsd
|
||||
test eax, eax
|
||||
jz .done
|
||||
stdcall dll.GetProcAddress, [exp], eax
|
||||
or eax, eax
|
||||
jz @f
|
||||
mov [esi - 4], eax
|
||||
jmp .next
|
||||
@@:
|
||||
mov dword[esp], 0
|
||||
.done:
|
||||
pop eax
|
||||
ret
|
||||
endp
|
||||
;-----------------------------------------------------------------------------
|
||||
; calls lib_init with predefined parameters
|
||||
; no return value
|
||||
proc dll.Init, dllentry:dword
|
||||
pushad
|
||||
mov eax, mem.Alloc
|
||||
mov ebx, mem.Free
|
||||
mov ecx, mem.ReAlloc
|
||||
mov edx, dll.Load
|
||||
stdcall [dllentry]
|
||||
popad
|
||||
ret
|
||||
endp
|
||||
;-----------------------------------------------------------------------------
|
||||
; scans export table for a sz_name function
|
||||
; returns in eax function address or 0 if not found
|
||||
proc dll.GetProcAddress, exp:dword, sz_name:dword
|
||||
mov edx, [exp]
|
||||
xor eax, eax
|
||||
.next:
|
||||
or edx, edx
|
||||
jz .end
|
||||
cmp dword[edx], 0
|
||||
jz .end
|
||||
stdcall strcmp, [edx], [sz_name]
|
||||
test eax, eax
|
||||
jz .ok
|
||||
add edx, 8
|
||||
jmp .next
|
||||
.ok:
|
||||
mov eax, [edx + 4]
|
||||
.end:
|
||||
cmp eax, -1
|
||||
jnz @f
|
||||
xor eax, eax
|
||||
@@:
|
||||
ret
|
||||
endp
|
||||
;-----------------------------------------------------------------------------
|
||||
; compares strings
|
||||
; returns eax = 0 if equal, -1 otherwise
|
||||
proc strcmp, str1:dword, str2:dword
|
||||
push esi edi
|
||||
mov esi, [str1]
|
||||
mov edi, [str2]
|
||||
xor eax, eax
|
||||
@@:
|
||||
lodsb
|
||||
scasb
|
||||
jne .fail
|
||||
or al, al
|
||||
jnz @b
|
||||
jmp .ok
|
||||
.fail:
|
||||
or eax, -1
|
||||
.ok:
|
||||
pop edi esi
|
||||
ret
|
||||
endp
|
||||
;-----------------------------------------------------------------------------
|
||||
if defined dll.Load
|
||||
s_libdir:
|
||||
db '/sys/lib/'
|
||||
.fname rb 32
|
||||
end if
|
||||
;-----------------------------------------------------------------------------
|
||||
proc mem.Alloc, size
|
||||
push ebx ecx
|
||||
mov ecx, [size]
|
||||
mcall 68, 12
|
||||
pop ecx ebx
|
||||
ret
|
||||
endp
|
||||
;-----------------------------------------------------------------------------
|
||||
proc mem.ReAlloc, mptr, size
|
||||
push ebx ecx edx
|
||||
mov ecx, [size]
|
||||
mov edx, [mptr]
|
||||
mcall 68, 20
|
||||
pop edx ecx ebx
|
||||
ret
|
||||
endp
|
||||
;-----------------------------------------------------------------------------
|
||||
proc mem.Free, mptr
|
||||
push ebx ecx
|
||||
mov ecx,[mptr]
|
||||
mcall 68, 13
|
||||
pop ecx ebx
|
||||
ret
|
||||
endp
|
||||
;-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,597 @@
|
||||
@^ fix macro comment {
|
||||
^@ fix }
|
||||
|
||||
; --------------------------
|
||||
macro library [lname,fname]
|
||||
{
|
||||
forward
|
||||
dd __#lname#_library_table__,__#lname#_library_name__
|
||||
common
|
||||
dd 0
|
||||
forward
|
||||
align 4
|
||||
__#lname#_library_name__ db fname,0
|
||||
}
|
||||
|
||||
macro import lname,[name,sname]
|
||||
{
|
||||
common
|
||||
align 4
|
||||
__#lname#_library_table__:
|
||||
forward
|
||||
if used name
|
||||
name dd __#name#_import_name__
|
||||
end if
|
||||
common
|
||||
dd 0
|
||||
forward
|
||||
if used name
|
||||
align 4
|
||||
__#name#_import_name__ db sname,0
|
||||
end if
|
||||
}
|
||||
|
||||
macro export [name,sname]
|
||||
{
|
||||
forward
|
||||
dd __#name#_export_name__,name
|
||||
common
|
||||
dd 0
|
||||
forward
|
||||
align 4
|
||||
__#name#_export_name__ db sname,0
|
||||
}
|
||||
; -------------------------
|
||||
|
||||
macro m2m dest,src {
|
||||
push src
|
||||
pop dest
|
||||
}
|
||||
|
||||
|
||||
macro iglobal {
|
||||
IGlobals equ IGlobals,
|
||||
macro __IGlobalBlock { }
|
||||
|
||||
macro uglobal {
|
||||
UGlobals equ UGlobals,
|
||||
macro __UGlobalBlock { }
|
||||
|
||||
endg fix } ; Use endg for ending iglobal and uglobal blocks.
|
||||
|
||||
|
||||
macro IncludeIGlobals{
|
||||
macro IGlobals dummy,[n] \{ __IGlobalBlock
|
||||
purge __IGlobalBlock \}
|
||||
match I, IGlobals \{ I \} }
|
||||
|
||||
macro IncludeUGlobals{
|
||||
macro UGlobals dummy,[n] \{
|
||||
\common
|
||||
\local begin, size
|
||||
begin = $
|
||||
virtual at $
|
||||
\forward
|
||||
__UGlobalBlock
|
||||
purge __UGlobalBlock
|
||||
\common
|
||||
size = $ - begin
|
||||
end virtual
|
||||
rb size
|
||||
\}
|
||||
match U, UGlobals \{ U \} }
|
||||
|
||||
uglobal
|
||||
endg
|
||||
|
||||
iglobal
|
||||
endg
|
||||
|
||||
|
||||
; new application structure
|
||||
macro meos_app_start
|
||||
{
|
||||
use32
|
||||
org 0x0
|
||||
|
||||
db 'MENUET01'
|
||||
dd 0x01
|
||||
dd __start
|
||||
dd __end
|
||||
dd __memory
|
||||
dd __stack
|
||||
|
||||
if used __params & ~defined __params
|
||||
dd __params
|
||||
else
|
||||
dd 0x0
|
||||
end if
|
||||
|
||||
dd 0x0
|
||||
}
|
||||
MEOS_APP_START fix meos_app_start
|
||||
KOS_APP_START fix meos_app_start
|
||||
|
||||
macro code
|
||||
{
|
||||
__start:
|
||||
}
|
||||
CODE fix code
|
||||
|
||||
macro data
|
||||
{
|
||||
__data:
|
||||
IncludeIGlobals
|
||||
}
|
||||
DATA fix data
|
||||
|
||||
macro udata
|
||||
{
|
||||
if used __params & ~defined __params
|
||||
__params:
|
||||
db 0
|
||||
__end:
|
||||
rb 255
|
||||
else
|
||||
__end:
|
||||
end if
|
||||
__udata:
|
||||
IncludeUGlobals
|
||||
}
|
||||
UDATA fix udata
|
||||
|
||||
macro meos_app_end
|
||||
{
|
||||
align 32
|
||||
rb 2048
|
||||
__stack:
|
||||
__memory:
|
||||
}
|
||||
MEOS_APP_END fix meos_app_end
|
||||
KOS_APP_END fix meos_app_end
|
||||
|
||||
|
||||
; macro for defining multiline text data
|
||||
struc mstr [sstring]
|
||||
{
|
||||
forward
|
||||
local ssize
|
||||
virtual at 0
|
||||
db sstring
|
||||
ssize = $
|
||||
end virtual
|
||||
dd ssize
|
||||
db sstring
|
||||
common
|
||||
dd -1
|
||||
}
|
||||
|
||||
; macro for defining multiline text data
|
||||
struc mls [sstring]
|
||||
{
|
||||
forward
|
||||
local ssize
|
||||
virtual at 0
|
||||
db sstring ; mod
|
||||
ssize = $
|
||||
end virtual
|
||||
db ssize
|
||||
db sstring
|
||||
common
|
||||
db -1 ; mod
|
||||
}
|
||||
|
||||
|
||||
|
||||
; strings
|
||||
macro sz name,[data] { ; [mike.dld]
|
||||
common
|
||||
if used name
|
||||
name db data
|
||||
.size = $-name
|
||||
end if
|
||||
}
|
||||
|
||||
macro szZ name,[data] { ; same as sz, but for zero terminated string [dunkaist]
|
||||
common
|
||||
if used name
|
||||
name db data,0
|
||||
.size = $-name-1
|
||||
end if
|
||||
}
|
||||
sz0 fix szZ
|
||||
|
||||
macro lsz name,[lng,data] { ; [mike.dld]
|
||||
common
|
||||
if used name
|
||||
label name
|
||||
forward
|
||||
if lang eq lng
|
||||
db data
|
||||
end if
|
||||
common
|
||||
.size = $-name
|
||||
end if
|
||||
}
|
||||
|
||||
macro szc name,elsz,[data] { ; [mike.dld]
|
||||
common
|
||||
local s,m
|
||||
m = 0
|
||||
if used name
|
||||
label name
|
||||
forward
|
||||
virtual at 0
|
||||
db data
|
||||
s = $
|
||||
end virtual
|
||||
d#elsz s
|
||||
if m < s
|
||||
m = s
|
||||
end if
|
||||
db data
|
||||
common
|
||||
.size = $-name
|
||||
.maxl = m
|
||||
end if
|
||||
}
|
||||
|
||||
macro lszc name,elsz,[lng,data] { ; [mike.dld]
|
||||
common
|
||||
local s,m,c
|
||||
m = 0
|
||||
c = 0
|
||||
if used name
|
||||
label name
|
||||
forward
|
||||
if lang eq lng
|
||||
virtual at 0
|
||||
db data
|
||||
s = $
|
||||
end virtual
|
||||
d#elsz s
|
||||
if m < s
|
||||
m = s
|
||||
end if
|
||||
db data
|
||||
c = c+1
|
||||
end if
|
||||
common
|
||||
.size = $-name
|
||||
.maxl = m
|
||||
.count = c
|
||||
end if
|
||||
}
|
||||
|
||||
|
||||
; easy system call macro
|
||||
macro mpack dest, hsrc, lsrc
|
||||
{
|
||||
if (hsrc eqtype 0) & (lsrc eqtype 0)
|
||||
mov dest, (hsrc) shl 16 + lsrc
|
||||
else
|
||||
if (hsrc eqtype 0) & (~lsrc eqtype 0)
|
||||
mov dest, (hsrc) shl 16
|
||||
add dest, lsrc
|
||||
else
|
||||
mov dest, hsrc
|
||||
shl dest, 16
|
||||
add dest, lsrc
|
||||
end if
|
||||
end if
|
||||
}
|
||||
|
||||
macro __mov reg,a,b { ; mike.dld
|
||||
if (~a eq)&(~b eq)
|
||||
mpack reg,a,b
|
||||
else if (~a eq)&(b eq)
|
||||
mov reg,a
|
||||
end if
|
||||
}
|
||||
|
||||
|
||||
include 'config.inc'
|
||||
;__CPU_type equ p5
|
||||
SYSENTER_VAR equ 0
|
||||
|
||||
macro mcall a,b,c,d,e,f,g { ; [mike.dld], [Ghost]
|
||||
local ..ret_point
|
||||
__mov eax,a
|
||||
__mov ebx,b
|
||||
__mov ecx,c
|
||||
__mov edx,d
|
||||
__mov esi,e
|
||||
__mov edi,f
|
||||
__mov ebp,g
|
||||
|
||||
if __CPU_type eq p5
|
||||
int 0x40
|
||||
else
|
||||
if __CPU_type eq p6
|
||||
push ebp
|
||||
mov ebp, esp
|
||||
push ..ret_point ; it may be 2 or 5 byte
|
||||
sysenter
|
||||
..ret_point:
|
||||
pop edx
|
||||
pop ecx
|
||||
|
||||
else
|
||||
if __CPU_type eq k6
|
||||
push ecx
|
||||
syscall
|
||||
pop ecx
|
||||
else
|
||||
display 'ERROR : unknown CPU type (set to p5)', 10, 13
|
||||
__CPU_type equ p5
|
||||
int 0x40
|
||||
end if
|
||||
end if
|
||||
end if
|
||||
}
|
||||
|
||||
|
||||
; -------------------------
|
||||
macro __header a,[b] {
|
||||
common
|
||||
use32
|
||||
org 0
|
||||
db 'MENUET',a
|
||||
forward
|
||||
if b eq
|
||||
dd 0
|
||||
else
|
||||
dd b
|
||||
end if
|
||||
}
|
||||
|
||||
macro __section name {
|
||||
align 16
|
||||
label name
|
||||
}
|
||||
|
||||
macro __func name {
|
||||
if ~used name
|
||||
display 'FUNC NOT USED: ',`name,13,10
|
||||
else
|
||||
align 4
|
||||
name:
|
||||
;diff16 `name,0,name
|
||||
}
|
||||
|
||||
macro endf { end if }
|
||||
|
||||
macro diff16 title,l1,l2
|
||||
{
|
||||
local s,d
|
||||
s = l2-l1
|
||||
display title,': 0x'
|
||||
repeat 8
|
||||
d = '0' + s shr ((8-%) shl 2) and $0F
|
||||
if d > '9'
|
||||
d = d + 'A'-'9'-1
|
||||
end if
|
||||
display d
|
||||
end repeat
|
||||
display 13,10
|
||||
}
|
||||
|
||||
macro diff10 title,l1,l2
|
||||
{
|
||||
local s,d,z,m
|
||||
s = l2-l1
|
||||
z = 0
|
||||
m = 1000000000
|
||||
display title,': '
|
||||
repeat 10
|
||||
d = '0' + s / m
|
||||
s = s - (s/m)*m
|
||||
m = m / 10
|
||||
if d <> '0'
|
||||
z = 1
|
||||
end if
|
||||
if z <> 0
|
||||
display d
|
||||
end if
|
||||
end repeat
|
||||
display 13,10
|
||||
}
|
||||
|
||||
|
||||
macro movi arg1,arg2
|
||||
{
|
||||
if (arg1 in <eax,ebx,ecx,edx,esi,edi,ebp,esp>) & ((arg2 eqtype 0) | (arg2 eqtype '0'))
|
||||
if (arg2) = 0
|
||||
xor arg1,arg1
|
||||
else if (arg2) = 1
|
||||
xor arg1,arg1
|
||||
inc arg1
|
||||
else if (arg2) = -1
|
||||
or arg1,-1
|
||||
else if (arg2) >= -128 & (arg2) <= 127
|
||||
push arg2
|
||||
pop arg1
|
||||
else
|
||||
mov arg1,arg2
|
||||
end if
|
||||
else
|
||||
mov arg1,arg2
|
||||
end if
|
||||
}
|
||||
|
||||
|
||||
macro RGB [a] {
|
||||
common
|
||||
match (r=,g=,b),a \{
|
||||
\dd ((r) shl 16) or ((g) shl 8) or (b)
|
||||
\}
|
||||
}
|
||||
|
||||
|
||||
struc POINT _t,_dx,_dy {
|
||||
.x _t _dx
|
||||
.y _t _dy
|
||||
}
|
||||
|
||||
; structure definition helper
|
||||
include 'struct.inc'
|
||||
|
||||
struct RECT
|
||||
left dd ?
|
||||
top dd ?
|
||||
right dd ?
|
||||
bottom dd ?
|
||||
ends
|
||||
|
||||
struct BOX
|
||||
left dd ?
|
||||
top dd ?
|
||||
width dd ?
|
||||
height dd ?
|
||||
ends
|
||||
|
||||
; structures used in KolibriOS
|
||||
struct process_information
|
||||
cpu_usage dd ? ; +0
|
||||
window_stack_position dw ? ; +4
|
||||
window_stack_value dw ? ; +6
|
||||
dw ? ; +8
|
||||
process_name rb 12 ; +10
|
||||
memory_start dd ? ; +22
|
||||
used_memory dd ? ; +26
|
||||
PID dd ? ; +30
|
||||
box BOX ; +34
|
||||
slot_state dw ? ; +50
|
||||
dw ? ; +52
|
||||
client_box BOX ; +54
|
||||
wnd_state db ? ; +70
|
||||
rb (1024-71)
|
||||
ends
|
||||
|
||||
struct system_colors
|
||||
frame dd ? ;nonset1
|
||||
grab dd ? ;nonset2
|
||||
work_dark dd ?
|
||||
work_light dd ?
|
||||
grab_text dd ? ;window_title
|
||||
work dd ?
|
||||
work_button dd ?
|
||||
work_button_text dd ?
|
||||
work_text dd ?
|
||||
work_graph dd ?
|
||||
ends
|
||||
|
||||
struct FILEDATE
|
||||
Second db ?
|
||||
Minute db ?
|
||||
Hour db ?
|
||||
db ?
|
||||
Day db ?
|
||||
Month db ?
|
||||
Year dw ?
|
||||
ends
|
||||
|
||||
struct FILEINFO
|
||||
Attributes dd ?
|
||||
IsUnicode db ?
|
||||
db 3 dup(?)
|
||||
DateCreate FILEDATE
|
||||
DateAccess FILEDATE
|
||||
DateModify FILEDATE
|
||||
Size dq ?
|
||||
ends
|
||||
|
||||
cmove fix cmovz
|
||||
|
||||
macro cmovz reg1, reg2 {
|
||||
|
||||
local ..jumpaddr
|
||||
|
||||
if __CPU_type eq p5 ; CMOVcc isnt supported on the P5
|
||||
jnz ..jumpaddr
|
||||
mov reg1, reg2
|
||||
..jumpaddr:
|
||||
else
|
||||
cmovz reg1, reg2
|
||||
end if
|
||||
|
||||
}
|
||||
|
||||
cmovne fix cmovnz
|
||||
|
||||
macro cmovnz reg1, reg2 {
|
||||
|
||||
local ..jumpaddr
|
||||
|
||||
if __CPU_type eq p5 ; CMOVcc isnt supported on the P5
|
||||
jz ..jumpaddr
|
||||
mov reg1, reg2
|
||||
..jumpaddr:
|
||||
else
|
||||
cmovnz reg1, reg2
|
||||
end if
|
||||
|
||||
}
|
||||
|
||||
macro cmovg reg1, reg2 {
|
||||
|
||||
local ..jumpaddr
|
||||
|
||||
if __CPU_type eq p5 ; CMOVcc isnt supported on the P5
|
||||
jle ..jumpaddr
|
||||
mov reg1, reg2
|
||||
..jumpaddr:
|
||||
else
|
||||
cmovg reg1, reg2
|
||||
end if
|
||||
}
|
||||
|
||||
macro cmovl reg1, reg2 {
|
||||
|
||||
local ..jumpaddr
|
||||
|
||||
if __CPU_type eq p5 ; CMOVcc isnt supported on the P5
|
||||
jge ..jumpaddr
|
||||
mov reg1, reg2
|
||||
..jumpaddr:
|
||||
else
|
||||
cmovl reg1, reg2
|
||||
end if
|
||||
}
|
||||
|
||||
; replaces /programs/cmp.inc
|
||||
irp cond, e, ne, g, ng, l, nl, ge, le {
|
||||
macro cmp#cond a, b, c\{
|
||||
cmp a, b
|
||||
j#cond c
|
||||
\}
|
||||
}
|
||||
|
||||
; constants
|
||||
|
||||
; events
|
||||
EV_IDLE = 0
|
||||
EV_TIMER = 0
|
||||
EV_REDRAW = 1
|
||||
EV_KEY = 2
|
||||
EV_BUTTON = 3
|
||||
EV_EXIT = 4
|
||||
EV_BACKGROUND = 5
|
||||
EV_MOUSE = 6
|
||||
EV_IPC = 7
|
||||
EV_STACK = 8
|
||||
|
||||
; event mask bits for function 40
|
||||
EVM_REDRAW = 1b
|
||||
EVM_KEY = 10b
|
||||
EVM_BUTTON = 100b
|
||||
EVM_EXIT = 1000b
|
||||
EVM_BACKGROUND = 10000b
|
||||
EVM_MOUSE = 100000b
|
||||
EVM_IPC = 1000000b
|
||||
EVM_STACK = 10000000b
|
||||
EVM_DEBUG = 100000000b
|
||||
EVM_STACK2 = 1000000000b
|
||||
|
||||
EVM_MOUSE_FILTER = 0x80000000
|
||||
EVM_CURSOR_FILTER = 0x40000000
|
||||
@@ -0,0 +1,301 @@
|
||||
|
||||
; Macroinstructions for defining and calling procedures
|
||||
|
||||
macro stdcall proc,[arg] ; directly call STDCALL procedure
|
||||
{ common
|
||||
if ~ arg eq
|
||||
reverse
|
||||
pushd arg
|
||||
common
|
||||
end if
|
||||
call proc }
|
||||
|
||||
macro invoke proc,[arg] ; indirectly call STDCALL procedure
|
||||
{ common
|
||||
if ~ arg eq
|
||||
reverse
|
||||
pushd arg
|
||||
common
|
||||
end if
|
||||
call [proc] }
|
||||
|
||||
macro ccall proc,[arg] ; directly call CDECL procedure
|
||||
{ common
|
||||
size@ccall = 0
|
||||
if ~ arg eq
|
||||
reverse
|
||||
pushd arg
|
||||
size@ccall = size@ccall+4
|
||||
common
|
||||
end if
|
||||
call proc
|
||||
if size@ccall
|
||||
add esp,size@ccall
|
||||
end if }
|
||||
|
||||
macro cinvoke proc,[arg] ; indirectly call CDECL procedure
|
||||
{ common
|
||||
size@ccall = 0
|
||||
if ~ arg eq
|
||||
reverse
|
||||
pushd arg
|
||||
size@ccall = size@ccall+4
|
||||
common
|
||||
end if
|
||||
call [proc]
|
||||
if size@ccall
|
||||
add esp,size@ccall
|
||||
end if }
|
||||
|
||||
macro proc [args] ; define procedure
|
||||
{ common
|
||||
match name params, args>
|
||||
\{ define@proc name,<params \} }
|
||||
|
||||
prologue@proc equ prologuedef
|
||||
|
||||
macro prologuedef procname,flag,parmbytes,localbytes,reglist
|
||||
{ local loc
|
||||
loc = (localbytes+3) and (not 3)
|
||||
parmbase@proc equ ebp+8
|
||||
localbase@proc equ ebp-loc
|
||||
if parmbytes | localbytes
|
||||
push ebp
|
||||
mov ebp,esp
|
||||
if localbytes
|
||||
sub esp,loc
|
||||
end if
|
||||
end if
|
||||
irps reg, reglist \{ push reg \} }
|
||||
|
||||
epilogue@proc equ epiloguedef
|
||||
|
||||
macro epiloguedef procname,flag,parmbytes,localbytes,reglist
|
||||
{ irps reg, reglist \{ reverse pop reg \}
|
||||
if parmbytes | localbytes
|
||||
leave
|
||||
end if
|
||||
if flag and 10000b
|
||||
retn
|
||||
else
|
||||
retn parmbytes
|
||||
end if }
|
||||
|
||||
close@proc equ
|
||||
|
||||
macro define@proc name,statement
|
||||
{ local params,flag,regs,parmbytes,localbytes,current
|
||||
if used name
|
||||
name:
|
||||
match =stdcall args, statement \{ params equ args
|
||||
flag = 11b \}
|
||||
match =stdcall, statement \{ params equ
|
||||
flag = 11b \}
|
||||
match =c args, statement \{ params equ args
|
||||
flag = 10001b \}
|
||||
match =c, statement \{ params equ
|
||||
flag = 10001b \}
|
||||
match =params, params \{ params equ statement
|
||||
flag = 0 \}
|
||||
match =uses reglist=,args, params \{ regs equ reglist
|
||||
params equ args \}
|
||||
match =regs =uses reglist, regs params \{ regs equ reglist
|
||||
params equ \}
|
||||
match =regs, regs \{ regs equ \}
|
||||
match prologue:reglist, prologue@proc:<regs> \{ prologue name,flag,parmbytes,localbytes,reglist \}
|
||||
virtual at parmbase@proc
|
||||
match =,args, params \{ defargs@proc args \}
|
||||
match =args@proc args, args@proc params \{ defargs@proc args \}
|
||||
parmbytes = $-(parmbase@proc)
|
||||
end virtual
|
||||
name # % = parmbytes/4
|
||||
all@vars equ
|
||||
current = 0
|
||||
macro locals
|
||||
\{ virtual at localbase@proc+current
|
||||
macro label def \\{ match . type,def> \\\{ deflocal@proc .,label,<type \\\} \\}
|
||||
struc db [val] \\{ \common deflocal@proc .,db,val \\}
|
||||
struc du [val] \\{ \common deflocal@proc .,du,val \\}
|
||||
struc dw [val] \\{ \common deflocal@proc .,dw,val \\}
|
||||
struc dp [val] \\{ \common deflocal@proc .,dp,val \\}
|
||||
struc dd [val] \\{ \common deflocal@proc .,dd,val \\}
|
||||
struc dt [val] \\{ \common deflocal@proc .,dt,val \\}
|
||||
struc dq [val] \\{ \common deflocal@proc .,dq,val \\}
|
||||
struc rb cnt \\{ deflocal@proc .,rb cnt, \\}
|
||||
struc rw cnt \\{ deflocal@proc .,rw cnt, \\}
|
||||
struc rp cnt \\{ deflocal@proc .,rp cnt, \\}
|
||||
struc rd cnt \\{ deflocal@proc .,rd cnt, \\}
|
||||
struc rt cnt \\{ deflocal@proc .,rt cnt, \\}
|
||||
struc rq cnt \\{ deflocal@proc .,rq cnt, \\} \}
|
||||
macro endl
|
||||
\{ purge label
|
||||
restruc db,du,dw,dp,dd,dt,dq
|
||||
restruc rb,rw,rp,rd,rt,rq
|
||||
current = $-(localbase@proc)
|
||||
end virtual \}
|
||||
macro ret operand
|
||||
\{ match any, operand \\{ retn operand \\}
|
||||
match , operand \\{ match epilogue:reglist, epilogue@proc:<regs> \\\{ epilogue name,flag,parmbytes,localbytes,reglist \\\} \\} \}
|
||||
macro finish@proc
|
||||
\{ localbytes = current
|
||||
match close:reglist, close@proc:<regs> \\{ close name,flag,parmbytes,localbytes,reglist \\}
|
||||
end if \} }
|
||||
|
||||
macro defargs@proc [arg]
|
||||
{ common
|
||||
if ~ arg eq
|
||||
forward
|
||||
local ..arg,current@arg
|
||||
match argname:type, arg
|
||||
\{ current@arg equ argname
|
||||
label ..arg type
|
||||
argname equ ..arg
|
||||
if qqword eq type
|
||||
dd ?,?,?,?,?,?,?,?
|
||||
else if dqword eq type
|
||||
dd ?,?,?,?
|
||||
else if tbyte eq type
|
||||
dd ?,?,?
|
||||
else if qword eq type | pword eq type
|
||||
dd ?,?
|
||||
else
|
||||
dd ?
|
||||
end if \}
|
||||
match =current@arg,current@arg
|
||||
\{ current@arg equ arg
|
||||
arg equ ..arg
|
||||
..arg dd ? \}
|
||||
common
|
||||
args@proc equ current@arg
|
||||
forward
|
||||
restore current@arg
|
||||
common
|
||||
end if }
|
||||
|
||||
macro deflocal@proc name,def,[val] { name def val }
|
||||
|
||||
macro deflocal@proc name,def,[val]
|
||||
{ common
|
||||
match vars, all@vars \{ all@vars equ all@vars, \}
|
||||
all@vars equ all@vars name
|
||||
forward
|
||||
local ..var,..tmp
|
||||
..var def val
|
||||
match =?, val \{ ..tmp equ \}
|
||||
match any =?, val \{ ..tmp equ \}
|
||||
match any (=?), val \{ ..tmp equ \}
|
||||
match =label, def \{ ..tmp equ \}
|
||||
match tmp : value, ..tmp : val
|
||||
\{ tmp: end virtual
|
||||
initlocal@proc ..var,def value
|
||||
virtual at tmp\}
|
||||
common
|
||||
match first rest, ..var, \{ name equ first \} }
|
||||
|
||||
struc label type { label . type }
|
||||
|
||||
macro initlocal@proc name,def
|
||||
{ virtual at name
|
||||
def
|
||||
size@initlocal = $ - name
|
||||
end virtual
|
||||
position@initlocal = 0
|
||||
while size@initlocal > position@initlocal
|
||||
virtual at name
|
||||
def
|
||||
if size@initlocal - position@initlocal < 2
|
||||
current@initlocal = 1
|
||||
load byte@initlocal byte from name+position@initlocal
|
||||
else if size@initlocal - position@initlocal < 4
|
||||
current@initlocal = 2
|
||||
load word@initlocal word from name+position@initlocal
|
||||
else
|
||||
current@initlocal = 4
|
||||
load dword@initlocal dword from name+position@initlocal
|
||||
end if
|
||||
end virtual
|
||||
if current@initlocal = 1
|
||||
mov byte [name+position@initlocal],byte@initlocal
|
||||
else if current@initlocal = 2
|
||||
mov word [name+position@initlocal],word@initlocal
|
||||
else
|
||||
mov dword [name+position@initlocal],dword@initlocal
|
||||
end if
|
||||
position@initlocal = position@initlocal + current@initlocal
|
||||
end while }
|
||||
|
||||
macro endp
|
||||
{ purge ret,locals,endl
|
||||
finish@proc
|
||||
purge finish@proc
|
||||
restore regs@proc
|
||||
match all,args@proc \{ restore all \}
|
||||
restore args@proc
|
||||
match all,all@vars \{ restore all \} }
|
||||
|
||||
macro local [var]
|
||||
{ common
|
||||
locals
|
||||
forward done@local equ
|
||||
match varname[count]:vartype, var
|
||||
\{ match =BYTE, vartype \\{ varname rb count
|
||||
restore done@local \\}
|
||||
match =WORD, vartype \\{ varname rw count
|
||||
restore done@local \\}
|
||||
match =DWORD, vartype \\{ varname rd count
|
||||
restore done@local \\}
|
||||
match =PWORD, vartype \\{ varname rp count
|
||||
restore done@local \\}
|
||||
match =QWORD, vartype \\{ varname rq count
|
||||
restore done@local \\}
|
||||
match =TBYTE, vartype \\{ varname rt count
|
||||
restore done@local \\}
|
||||
match =DQWORD, vartype \\{ label varname dqword
|
||||
rq count*2
|
||||
restore done@local \\}
|
||||
match =QQWORD, vartype \\{ label varname qqword
|
||||
rq count*4
|
||||
restore done@local \\}
|
||||
match =XWORD, vartype \\{ label varname xword
|
||||
rq count*2
|
||||
restore done@local \\}
|
||||
match =YWORD, vartype \\{ label varname yword
|
||||
rq count*4
|
||||
restore done@local \\}
|
||||
match , done@local \\{ virtual
|
||||
varname vartype
|
||||
end virtual
|
||||
rb count*sizeof.\#vartype
|
||||
restore done@local \\} \}
|
||||
match :varname:vartype, done@local:var
|
||||
\{ match =BYTE, vartype \\{ varname db ?
|
||||
restore done@local \\}
|
||||
match =WORD, vartype \\{ varname dw ?
|
||||
restore done@local \\}
|
||||
match =DWORD, vartype \\{ varname dd ?
|
||||
restore done@local \\}
|
||||
match =PWORD, vartype \\{ varname dp ?
|
||||
restore done@local \\}
|
||||
match =QWORD, vartype \\{ varname dq ?
|
||||
restore done@local \\}
|
||||
match =TBYTE, vartype \\{ varname dt ?
|
||||
restore done@local \\}
|
||||
match =DQWORD, vartype \\{ label varname dqword
|
||||
dq ?,?
|
||||
restore done@local \\}
|
||||
match =QQWORD, vartype \\{ label varname qqword
|
||||
dq ?,?,?,?
|
||||
restore done@local \\}
|
||||
match =XWORD, vartype \\{ label varname xword
|
||||
dq ?,?
|
||||
restore done@local \\}
|
||||
match =YWORD, vartype \\{ label varname yword
|
||||
dq ?,?,?,?
|
||||
restore done@local \\}
|
||||
match , done@local \\{ varname vartype
|
||||
restore done@local \\} \}
|
||||
match ,done@local
|
||||
\{ var
|
||||
restore done@local \}
|
||||
common
|
||||
endl }
|
||||
@@ -0,0 +1,240 @@
|
||||
|
||||
; Macroinstructions for defining data structures
|
||||
|
||||
macro struct name
|
||||
{ virtual at 0
|
||||
fields@struct equ name
|
||||
match child parent, name \{ fields@struct equ child,fields@\#parent \}
|
||||
sub@struct equ
|
||||
struc db [val] \{ \common define field@struct .,db,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc dw [val] \{ \common define field@struct .,dw,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc du [val] \{ \common define field@struct .,du,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc dd [val] \{ \common define field@struct .,dd,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc dp [val] \{ \common define field@struct .,dp,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc dq [val] \{ \common define field@struct .,dq,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc dt [val] \{ \common define field@struct .,dt,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc rb count \{ define field@struct .,db,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc rw count \{ define field@struct .,dw,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc rd count \{ define field@struct .,dd,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc rp count \{ define field@struct .,dp,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc rq count \{ define field@struct .,dq,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
struc rt count \{ define field@struct .,dt,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro db [val] \{ \common \local anonymous
|
||||
define field@struct anonymous,db,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro dw [val] \{ \common \local anonymous
|
||||
define field@struct anonymous,dw,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro du [val] \{ \common \local anonymous
|
||||
define field@struct anonymous,du,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro dd [val] \{ \common \local anonymous
|
||||
define field@struct anonymous,dd,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro dp [val] \{ \common \local anonymous
|
||||
define field@struct anonymous,dp,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro dq [val] \{ \common \local anonymous
|
||||
define field@struct anonymous,dq,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro dt [val] \{ \common \local anonymous
|
||||
define field@struct anonymous,dt,<val>
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro rb count \{ \local anonymous
|
||||
define field@struct anonymous,db,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro rw count \{ \local anonymous
|
||||
define field@struct anonymous,dw,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro rd count \{ \local anonymous
|
||||
define field@struct anonymous,dd,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro rp count \{ \local anonymous
|
||||
define field@struct anonymous,dp,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro rq count \{ \local anonymous
|
||||
define field@struct anonymous,dq,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro rt count \{ \local anonymous
|
||||
define field@struct anonymous,dt,count dup (?)
|
||||
fields@struct equ fields@struct,field@struct \}
|
||||
macro union \{ fields@struct equ fields@struct,,union,<
|
||||
sub@struct equ union \}
|
||||
macro struct \{ fields@struct equ fields@struct,,substruct,<
|
||||
sub@struct equ substruct \} }
|
||||
|
||||
macro ends
|
||||
{ match , sub@struct \{ restruc db,dw,du,dd,dp,dq,dt
|
||||
restruc rb,rw,rd,rp,rq,rt
|
||||
purge db,dw,du,dd,dp,dq,dt
|
||||
purge rb,rw,rd,rp,rq,rt
|
||||
purge union,struct
|
||||
match name tail,fields@struct, \\{ if $
|
||||
display 'Error: definition of ',\\`name,' contains illegal instructions.',0Dh,0Ah
|
||||
err
|
||||
end if \\}
|
||||
match name=,fields,fields@struct \\{ fields@struct equ
|
||||
make@struct name,fields
|
||||
define fields@\\#name fields \\}
|
||||
end virtual \}
|
||||
match any, sub@struct \{ fields@struct equ fields@struct> \}
|
||||
restore sub@struct }
|
||||
|
||||
macro make@struct name,[field,type,def]
|
||||
{ common
|
||||
local define
|
||||
define equ name
|
||||
forward
|
||||
local sub
|
||||
match , field \{ make@substruct type,name,sub def
|
||||
define equ define,.,sub, \}
|
||||
match any, field \{ define equ define,.#field,type,<def> \}
|
||||
common
|
||||
match fields, define \{ define@struct fields \} }
|
||||
|
||||
macro define@struct name,[field,type,def]
|
||||
{ common
|
||||
virtual
|
||||
db `name
|
||||
load initial@struct byte from 0
|
||||
if initial@struct = '.'
|
||||
display 'Error: name of structure should not begin with a dot.',0Dh,0Ah
|
||||
err
|
||||
end if
|
||||
end virtual
|
||||
local list
|
||||
list equ
|
||||
forward
|
||||
if ~ field eq .
|
||||
name#field type def
|
||||
sizeof.#name#field = $ - name#field
|
||||
else
|
||||
label name#.#type
|
||||
rb sizeof.#type
|
||||
end if
|
||||
local value
|
||||
match any, list \{ list equ list, \}
|
||||
list equ list <value>
|
||||
common
|
||||
sizeof.#name = $
|
||||
restruc name
|
||||
match values, list \{
|
||||
struc name value \\{ \\local \\..base
|
||||
match any, fields@struct \\\{ fields@struct equ fields@struct,.,name,<values> \\\}
|
||||
match , fields@struct \\\{ label \\..base
|
||||
forward
|
||||
match , value \\\\{ field type def \\\\}
|
||||
match any, value \\\\{ field type value
|
||||
if ~ field eq .
|
||||
rb sizeof.#name#field - ($-field)
|
||||
end if \\\\}
|
||||
common label . at \\..base \\\}
|
||||
\\}
|
||||
macro name value \\{
|
||||
match any, fields@struct \\\{ \\\local anonymous
|
||||
fields@struct equ fields@struct,anonymous,name,<values> \\\}
|
||||
match , fields@struct \\\{
|
||||
forward
|
||||
match , value \\\\{ type def \\\\}
|
||||
match any, value \\\\{ \\\\local ..field
|
||||
..field = $
|
||||
type value
|
||||
if ~ field eq .
|
||||
rb sizeof.#name#field - ($-..field)
|
||||
end if \\\\}
|
||||
common \\\} \\} \} }
|
||||
|
||||
macro enable@substruct
|
||||
{ macro make@substruct substruct,parent,name,[field,type,def]
|
||||
\{ \common
|
||||
\local define
|
||||
define equ parent,name
|
||||
\forward
|
||||
\local sub
|
||||
match , field \\{ match any, type \\\{ enable@substruct
|
||||
make@substruct type,parent,sub def
|
||||
purge make@substruct
|
||||
define equ define,.,sub, \\\} \\}
|
||||
match any, field \\{ define equ define,.\#field,type,<def> \\}
|
||||
\common
|
||||
match fields, define \\{ define@\#substruct fields \\} \} }
|
||||
|
||||
enable@substruct
|
||||
|
||||
macro define@union parent,name,[field,type,def]
|
||||
{ common
|
||||
virtual at parent#.#name
|
||||
forward
|
||||
if ~ field eq .
|
||||
virtual at parent#.#name
|
||||
parent#field type def
|
||||
sizeof.#parent#field = $ - parent#field
|
||||
end virtual
|
||||
if sizeof.#parent#field > $ - parent#.#name
|
||||
rb sizeof.#parent#field - ($ - parent#.#name)
|
||||
end if
|
||||
else
|
||||
virtual at parent#.#name
|
||||
label parent#.#type
|
||||
type def
|
||||
end virtual
|
||||
label name#.#type at parent#.#name
|
||||
if sizeof.#type > $ - parent#.#name
|
||||
rb sizeof.#type - ($ - parent#.#name)
|
||||
end if
|
||||
end if
|
||||
common
|
||||
sizeof.#name = $ - parent#.#name
|
||||
end virtual
|
||||
struc name [value] \{ \common
|
||||
label .\#name
|
||||
last@union equ
|
||||
forward
|
||||
match any, last@union \\{ virtual at .\#name
|
||||
field type def
|
||||
end virtual \\}
|
||||
match , last@union \\{ match , value \\\{ field type def \\\}
|
||||
match any, value \\\{ field type value \\\} \\}
|
||||
last@union equ field
|
||||
common rb sizeof.#name - ($ - .\#name) \}
|
||||
macro name [value] \{ \common \local ..anonymous
|
||||
..anonymous name value \} }
|
||||
|
||||
macro define@substruct parent,name,[field,type,def]
|
||||
{ common
|
||||
virtual at parent#.#name
|
||||
forward
|
||||
if ~ field eq .
|
||||
parent#field type def
|
||||
sizeof.#parent#field = $ - parent#field
|
||||
else
|
||||
label parent#.#type
|
||||
rb sizeof.#type
|
||||
end if
|
||||
common
|
||||
sizeof.#name = $ - parent#.#name
|
||||
end virtual
|
||||
struc name value \{
|
||||
label .\#name
|
||||
forward
|
||||
match , value \\{ field type def \\}
|
||||
match any, value \\{ field type value
|
||||
if ~ field eq .
|
||||
rb sizeof.#parent#field - ($-field)
|
||||
end if \\}
|
||||
common \}
|
||||
macro name value \{ \local ..anonymous
|
||||
..anonymous name \} }
|
||||
@@ -0,0 +1,21 @@
|
||||
#include <ctype.h>
|
||||
|
||||
unsigned short __is[129] = {
|
||||
0, /* EOF */
|
||||
0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
|
||||
0x004, 0x104, 0x104, 0x104, 0x104, 0x104, 0x004, 0x004,
|
||||
0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
|
||||
0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
|
||||
0x140, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
|
||||
0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
|
||||
0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459,
|
||||
0x459, 0x459, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
|
||||
0x0D0, 0x653, 0x653, 0x653, 0x653, 0x653, 0x653, 0x253,
|
||||
0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
|
||||
0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
|
||||
0x253, 0x253, 0x253, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
|
||||
0x0D0, 0x473, 0x473, 0x473, 0x473, 0x473, 0x473, 0x073,
|
||||
0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
|
||||
0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
|
||||
0x073, 0x073, 0x073, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x004
|
||||
};
|
||||
@@ -0,0 +1,133 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
#include <sys/dirent.h>
|
||||
#include <sys/ksys.h>
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#include <setjmp.h>
|
||||
|
||||
ksys_coff_etable_t EXPORTS[] = {
|
||||
{"clearerr", &clearerr},
|
||||
{"debug_printf", &debug_printf},
|
||||
{"fclose", &fclose},
|
||||
{"feof", &feof},
|
||||
{"ferror", &ferror},
|
||||
{"fflush", &fflush},
|
||||
{"fgetc", &fgetc},
|
||||
{"fgetpos", &fgetpos},
|
||||
{"fgets", &fgets},
|
||||
{"fopen", &fopen},
|
||||
{"fprintf", &fprintf},
|
||||
{"fputc", &fputc},
|
||||
{"fputs", &fputs},
|
||||
{"fread", &fread},
|
||||
{"freopen", &freopen},
|
||||
{"fscanf", &fscanf},
|
||||
{"fseek", &fseek},
|
||||
{"fsetpos", &fsetpos},
|
||||
{"ftell", &ftell},
|
||||
{"fwrite", &fwrite},
|
||||
{"getchar", &getchar},
|
||||
{"gets", &gets},
|
||||
{"perror", &perror},
|
||||
{"printf", &printf},
|
||||
{"puts", &puts},
|
||||
{"remove", &remove},
|
||||
{"rename", &rename},
|
||||
{"rewind", &rewind},
|
||||
{"scanf", &scanf},
|
||||
{"setbuf", &setbuf},
|
||||
{"setvbuf", &setvbuf},
|
||||
{"snprintf", &snprintf},
|
||||
{"sprintf", &sprintf},
|
||||
{"sscanf", &sscanf},
|
||||
{"tmpfile", &tmpfile},
|
||||
{"tmpnam", &tmpnam},
|
||||
{"vfscanf", &vfscanf},
|
||||
{"vprintf", &vprintf},
|
||||
{"vfscanf", &vfscanf},
|
||||
{"vsnprintf", &vsnprintf},
|
||||
{"vsscanf", &vsscanf},
|
||||
{"abs", &abs},
|
||||
{"atoi", &atoi},
|
||||
{"atol", &atol},
|
||||
{"atoll", &atoll},
|
||||
{"calloc", &calloc},
|
||||
{"difftime", &difftime},
|
||||
{"div", &div},
|
||||
{"exit", &exit},
|
||||
{"free", &free},
|
||||
{"itoa", &itoa},
|
||||
{"labs", &labs},
|
||||
{"ldiv", &ldiv},
|
||||
{"llabs", &llabs},
|
||||
{"lldiv", &lldiv},
|
||||
{"localtime", &localtime},
|
||||
{"malloc", &malloc},
|
||||
{"mktime", &mktime},
|
||||
{"realloc", &realloc},
|
||||
{"strtol", &strtol},
|
||||
{"time", &time},
|
||||
{"memcpy", &memcpy},
|
||||
{"memchr", &memchr},
|
||||
{"memcmp", &memcmp},
|
||||
{"memmove", &memmove},
|
||||
{"memset", &memset},
|
||||
{"strncat", &strncat},
|
||||
{"strchr", &strchr},
|
||||
{"strcmp", &strcmp},
|
||||
{"strcoll", &strcoll},
|
||||
{"strcpy", &strcpy},
|
||||
{"strcspn", &strcspn},
|
||||
{"strdup", &strdup},
|
||||
{"strerror", &strerror},
|
||||
{"strlen", &strlen},
|
||||
{"strncat", &strncat},
|
||||
{"strncmp", &strncmp},
|
||||
{"strncpy", &strncpy},
|
||||
{"strrchr", &strrchr},
|
||||
{"strrev", &strrev},
|
||||
{"strspn", &strspn},
|
||||
{"strstr", &strstr},
|
||||
{"strtok", &strtok},
|
||||
{"strxfrm", &strxfrm},
|
||||
{"closedir", &closedir},
|
||||
{"opendir", &opendir},
|
||||
{"readdir", &readdir},
|
||||
{"rewinddir", &rewinddir},
|
||||
{"seekdir", &seekdir},
|
||||
{"telldir", &telldir},
|
||||
{"acosh", &acosh},
|
||||
{"asinh", &asinh},
|
||||
{"atanh", &atanh},
|
||||
{"acosh", &acosh},
|
||||
{"frexp", &frexp},
|
||||
{"hypot", &hypot},
|
||||
{"ldexp", &ldexp},
|
||||
{"sinh", &sinh},
|
||||
{"tanh", &tanh},
|
||||
{"acos", &acos},
|
||||
{"asin", &asin},
|
||||
{"atan", &atan},
|
||||
{"atan2", &atan2},
|
||||
{"ceil", &ceil},
|
||||
{"cos", &cos},
|
||||
{"exp", &exp},
|
||||
{"fabs", &fabs},
|
||||
{"floor", &floor},
|
||||
{"fmod", &fmod},
|
||||
{"log", &log},
|
||||
{"modf", &modf},
|
||||
{"modfl", &modfl},
|
||||
{"pow", &pow},
|
||||
{"pow2", &pow2},
|
||||
{"pow10", &pow10},
|
||||
{"longjmp", &longjmp},
|
||||
{"setjmp", &setjmp},
|
||||
{"__is", &__is},
|
||||
{"con_set_title", &con_set_title},
|
||||
NULL,
|
||||
};
|
||||
@@ -0,0 +1,141 @@
|
||||
#include "ctype/is.c"
|
||||
|
||||
#include "sys/rewinddir.c"
|
||||
#include "sys/readdir.c"
|
||||
#include "sys/seekdir.c"
|
||||
#include "sys/opendir.c"
|
||||
#include "sys/telldir.c"
|
||||
#include "sys/closedir.c"
|
||||
|
||||
#include "stdio/clearerr.c"
|
||||
#include "stdio/vscanf.c"
|
||||
#include "stdio/gets.c"
|
||||
#include "stdio/setbuf.c"
|
||||
#include "stdio/fgetc.c"
|
||||
#include "stdio/fopen.c"
|
||||
#include "stdio/format_print.c"
|
||||
#include "stdio/vprintf.c"
|
||||
#include "stdio/feof.c"
|
||||
#include "stdio/fwrite.c"
|
||||
#include "stdio/fread.c"
|
||||
#include "stdio/fseek.c"
|
||||
#include "stdio/fgetpos.c"
|
||||
#include "stdio/fclose.c"
|
||||
#include "stdio/vsscanf.c"
|
||||
#include "stdio/snprintf.c"
|
||||
#include "stdio/rename.c"
|
||||
#include "stdio/getchar.c"
|
||||
#include "stdio/remove.c"
|
||||
#include "stdio/ferror.c"
|
||||
#include "stdio/tmpfile.c"
|
||||
#include "stdio/fputs.c"
|
||||
#include "stdio/fputc.c"
|
||||
#include "stdio/fgets.c"
|
||||
#include "stdio/vfscanf.c"
|
||||
#include "stdio/fflush.c"
|
||||
#include "stdio/format_scan.c"
|
||||
#include "stdio/printf.c"
|
||||
#include "stdio/fscanf.c"
|
||||
#include "stdio/debug_printf.c"
|
||||
#include "stdio/fsetpos.c"
|
||||
#include "stdio/setvbuf.c"
|
||||
#include "stdio/sscanf.c"
|
||||
#include "stdio/scanf.c"
|
||||
#include "stdio/freopen.c"
|
||||
#include "stdio/puts.c"
|
||||
#include "stdio/sprintf.c"
|
||||
#include "stdio/vsnprintf.c"
|
||||
#include "stdio/conio.c"
|
||||
#include "stdio/perror.c"
|
||||
#include "stdio/ftell.c"
|
||||
#include "stdio/tmpnam.c"
|
||||
#include "stdio/rewind.c"
|
||||
#include "stdio/vfprintf.c"
|
||||
#include "stdio/fprintf.c"
|
||||
|
||||
#include "string/strerror.c"
|
||||
#include "string/strxfrm.c"
|
||||
#include "string/strrchr.c"
|
||||
#include "string/strcspn.c"
|
||||
#include "string/strlen.c"
|
||||
#include "string/strrev.c"
|
||||
#include "string/memccpy.c"
|
||||
#include "string/strchr.c"
|
||||
#include "string/strcoll.c"
|
||||
#include "string/strpbrk.c"
|
||||
#include "string/strstr.c"
|
||||
#include "string/memcmp.c"
|
||||
#include "string/strspn.c"
|
||||
#include "string/strcpy.c"
|
||||
#include "string/strncpy.c"
|
||||
#include "string/strdup.c"
|
||||
#include "string/strcat.c"
|
||||
#include "string/memchr.c"
|
||||
#include "string/strncmp.c"
|
||||
#include "string/strncat.c"
|
||||
#include "string/strtok.c"
|
||||
#include "string/strcmp.c"
|
||||
#include "string/memset.c"
|
||||
#include "string/memcpy.c"
|
||||
#include "string/memmove.c"
|
||||
|
||||
#include "stdlib/calloc.c"
|
||||
#include "stdlib/lldiv.c"
|
||||
#include "stdlib/malloc.c"
|
||||
#include "stdlib/atoll.c"
|
||||
#include "stdlib/free.c"
|
||||
#include "stdlib/llabs.c"
|
||||
#include "stdlib/exit.c"
|
||||
#include "stdlib/mktime.c"
|
||||
#include "stdlib/atoi.c"
|
||||
#include "stdlib/localtime.c"
|
||||
#include "stdlib/labs.c"
|
||||
#include "stdlib/difftime.c"
|
||||
#include "stdlib/realloc.c"
|
||||
#include "stdlib/ldiv.c"
|
||||
#include "stdlib/libtcc1.c"
|
||||
#include "stdlib/abs.c"
|
||||
#include "stdlib/div.c"
|
||||
#include "stdlib/atol.c"
|
||||
#include "stdlib/itoa.c"
|
||||
#include "stdlib/time.c"
|
||||
#include "stdlib/strtol.c"
|
||||
|
||||
#include "math/acosh.c"
|
||||
#include "math/asinh.c"
|
||||
#include "math/atanh.c"
|
||||
#include "math/cosh.c"
|
||||
#include "math/frexp.c"
|
||||
#include "math/hypot.c"
|
||||
#include "math/ldexp.c"
|
||||
#include "math/sinh.c"
|
||||
#include "math/tanh.c"
|
||||
|
||||
|
||||
__asm__(
|
||||
".include \"math/acos.s\"\n\t"
|
||||
".include \"math/asin.s\"\n\t"
|
||||
".include \"math/atan.s\"\n\t"
|
||||
".include \"math/atan2.s\"\n\t"
|
||||
".include \"math/ceil.s\"\n\t"
|
||||
".include \"math/cos.s\"\n\t"
|
||||
".include \"math/exp.s\"\n\t"
|
||||
".include \"math/fabs.s\"\n\t"
|
||||
".include \"math/floor.s\"\n\t"
|
||||
".include \"math/fmod.s\"\n\t"
|
||||
".include \"math/log.s\"\n\t"
|
||||
".include \"math/modf.s\"\n\t"
|
||||
".include \"math/modfl.s\"\n\t"
|
||||
".include \"math/pow.s\"\n\t"
|
||||
".include \"math/pow2.s\"\n\t"
|
||||
".include \"math/pow10.s\"\n\t"
|
||||
);
|
||||
|
||||
__asm__(
|
||||
".include \"setjmp/longjmp.s\"\n\t"
|
||||
".include \"setjmp/setjmp.s\""
|
||||
);
|
||||
|
||||
#include "stdlib/___chkstk_ms.c"
|
||||
|
||||
#include "exports/exports.c"
|
||||
Binary file not shown.
@@ -0,0 +1,23 @@
|
||||
.text
|
||||
|
||||
acos.LC0:
|
||||
.double 0d1.00000000000000000000e+00
|
||||
|
||||
.global acos;
|
||||
|
||||
acos:
|
||||
fldl 4(%esp)
|
||||
fld1
|
||||
fsubp %st(0),%st(1)
|
||||
fsqrt
|
||||
|
||||
fldl 4(%esp)
|
||||
fld1
|
||||
faddp %st(0),%st(1)
|
||||
fsqrt
|
||||
|
||||
fpatan
|
||||
|
||||
fld %st(0)
|
||||
faddp
|
||||
ret
|
||||
@@ -0,0 +1,8 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
#include <math.h>
|
||||
|
||||
double
|
||||
acosh(double x)
|
||||
{
|
||||
return log(x + sqrt(x*x - 1));
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.global asin;
|
||||
|
||||
asin:
|
||||
fldl 4(%esp)
|
||||
fld %st(0)
|
||||
fmulp
|
||||
fld1
|
||||
fsubp
|
||||
fsqrt
|
||||
fldl 4(%esp)
|
||||
fxch %st(1)
|
||||
fpatan
|
||||
ret
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
#include <math.h>
|
||||
|
||||
double
|
||||
asinh(double x)
|
||||
{
|
||||
return x>0 ? log(x + sqrt(x*x + 1)) : -log(sqrt(x*x+1)-x);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.global atan;
|
||||
|
||||
atan:
|
||||
fldl 4(%esp)
|
||||
fld1
|
||||
fpatan
|
||||
ret
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.data
|
||||
.align 2
|
||||
nan:
|
||||
.long 0xffffffff
|
||||
.byte 0xff
|
||||
.byte 0xff
|
||||
.byte 0xff
|
||||
.byte 0x7f
|
||||
|
||||
.text
|
||||
|
||||
.global atan2;
|
||||
|
||||
atan2:
|
||||
fldl 4(%esp)
|
||||
fldl 12(%esp)
|
||||
ftst
|
||||
fnstsw %ax
|
||||
sahf
|
||||
jne doit
|
||||
fxch %st(1)
|
||||
ftst
|
||||
fnstsw %ax
|
||||
sahf
|
||||
je isanan
|
||||
fxch %st(1)
|
||||
doit:
|
||||
fpatan
|
||||
ret
|
||||
isanan:
|
||||
movl $1, errno
|
||||
fstp %st(0)
|
||||
fstp %st(0)
|
||||
fldl nan
|
||||
ret
|
||||
@@ -0,0 +1,8 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
#include <math.h>
|
||||
|
||||
double
|
||||
atanh(double x)
|
||||
{
|
||||
return log((1+x)/(1-x)) / 2.0;
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.global ceil;
|
||||
|
||||
ceil:
|
||||
pushl %ebp
|
||||
movl %esp,%ebp
|
||||
subl $8,%esp
|
||||
|
||||
fstcw -4(%ebp)
|
||||
fwait
|
||||
movw -4(%ebp),%ax
|
||||
andw $0xf3ff,%ax
|
||||
orw $0x0800,%ax
|
||||
movw %ax,-2(%ebp)
|
||||
fldcw -2(%ebp)
|
||||
|
||||
fldl 8(%ebp)
|
||||
frndint
|
||||
|
||||
fldcw -4(%ebp)
|
||||
|
||||
movl %ebp,%esp
|
||||
popl %ebp
|
||||
ret
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
cos.L0:
|
||||
.quad 0xffffffffffffffff
|
||||
|
||||
.global cos;
|
||||
|
||||
cos:
|
||||
fldl 4(%esp)
|
||||
fcos
|
||||
fstsw
|
||||
sahf
|
||||
jnp cos.L1
|
||||
fstp %st(0)
|
||||
fldl cos.L0
|
||||
|
||||
cos.L1:
|
||||
ret
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
#include <math.h>
|
||||
|
||||
double cosh(double x)
|
||||
{
|
||||
const double ebig = exp(fabs(x));
|
||||
return (ebig + 1.0/ebig) / 2.0;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
|
||||
.data
|
||||
exp.LCW1:
|
||||
.word 0
|
||||
exp.LCW2:
|
||||
.word 0
|
||||
exp.LC0:
|
||||
.double 0d1.0e+00
|
||||
|
||||
.text
|
||||
|
||||
.global exp;
|
||||
|
||||
exp:
|
||||
fldl 4(%esp)
|
||||
fldl2e
|
||||
fmulp
|
||||
fstcw exp.LCW1
|
||||
fstcw exp.LCW2
|
||||
fwait
|
||||
andw $0xf3ff, exp.LCW2
|
||||
orw $0x0400, exp.LCW2
|
||||
fldcw exp.LCW2
|
||||
fldl %st(0)
|
||||
frndint
|
||||
fldcw exp.LCW1
|
||||
fxch %st(1)
|
||||
fsub %st(1),%st
|
||||
f2xm1
|
||||
faddl exp.LC0
|
||||
fscale
|
||||
fstp %st(1)
|
||||
ret
|
||||
@@ -0,0 +1,8 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.global fabs;
|
||||
|
||||
fabs:
|
||||
fldl 4(%esp)
|
||||
fabs
|
||||
ret
|
||||
@@ -0,0 +1,26 @@
|
||||
/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.global floor;
|
||||
|
||||
floor:
|
||||
pushl %ebp
|
||||
movl %esp,%ebp
|
||||
subl $8,%esp
|
||||
|
||||
fstcw -4(%ebp)
|
||||
fwait
|
||||
movw -4(%ebp),%ax
|
||||
andw $0xf3ff,%ax
|
||||
orw $0x0400,%ax
|
||||
movw %ax,-2(%ebp)
|
||||
fldcw -2(%ebp)
|
||||
|
||||
fldl 8(%ebp)
|
||||
frndint
|
||||
|
||||
fldcw -4(%ebp)
|
||||
|
||||
movl %ebp,%esp
|
||||
popl %ebp
|
||||
ret
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.text
|
||||
|
||||
.global fmod;
|
||||
|
||||
fmod:
|
||||
fldl 4(%esp)
|
||||
fldl 12(%esp)
|
||||
ftst
|
||||
fnstsw %ax
|
||||
fxch %st(1)
|
||||
sahf
|
||||
jnz next
|
||||
fstpl %st(0)
|
||||
jmp out
|
||||
next:
|
||||
fprem
|
||||
fnstsw %ax
|
||||
sahf
|
||||
jpe next
|
||||
fstpl %st(1)
|
||||
out:
|
||||
ret
|
||||
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
#include <math.h>
|
||||
|
||||
double
|
||||
frexp(double x, int *exptr)
|
||||
{
|
||||
union {
|
||||
double d;
|
||||
unsigned char c[8];
|
||||
} u;
|
||||
|
||||
u.d = x;
|
||||
/*
|
||||
* The format of the number is:
|
||||
* Sign, 12 exponent bits, 51 mantissa bits
|
||||
* The exponent is 1023 biased and there is an implicit zero.
|
||||
* We get the exponent from the upper bits and set the exponent
|
||||
* to 0x3fe (1022).
|
||||
*/
|
||||
*exptr = (int)(((u.c[7] & 0x7f) << 4) | (u.c[6] >> 4)) - 1022;
|
||||
u.c[7] &= 0x80;
|
||||
u.c[7] |= 0x3f;
|
||||
u.c[6] &= 0x0f;
|
||||
u.c[6] |= 0xe0;
|
||||
return u.d;
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
|
||||
/*
|
||||
* hypot() function for DJGPP.
|
||||
*
|
||||
* hypot() computes sqrt(x^2 + y^2). The problem with the obvious
|
||||
* naive implementation is that it might fail for very large or
|
||||
* very small arguments. For instance, for large x or y the result
|
||||
* might overflow even if the value of the function should not,
|
||||
* because squaring a large number might trigger an overflow. For
|
||||
* very small numbers, their square might underflow and will be
|
||||
* silently replaced by zero; this won't cause an exception, but might
|
||||
* have an adverse effect on the accuracy of the result.
|
||||
*
|
||||
* This implementation tries to avoid the above pitfals, without
|
||||
* inflicting too much of a performance hit.
|
||||
*
|
||||
*/
|
||||
|
||||
/// #include <float.h>
|
||||
#include <math.h>
|
||||
#include <errno.h>
|
||||
|
||||
/* Approximate square roots of DBL_MAX and DBL_MIN. Numbers
|
||||
between these two shouldn't neither overflow nor underflow
|
||||
when squared. */
|
||||
#define __SQRT_DBL_MAX 1.3e+154
|
||||
#define __SQRT_DBL_MIN 2.3e-162
|
||||
|
||||
double
|
||||
hypot(double x, double y)
|
||||
{
|
||||
double abig = fabs(x), asmall = fabs(y);
|
||||
double ratio;
|
||||
|
||||
/* Make abig = max(|x|, |y|), asmall = min(|x|, |y|). */
|
||||
if (abig < asmall)
|
||||
{
|
||||
double temp = abig;
|
||||
|
||||
abig = asmall;
|
||||
asmall = temp;
|
||||
}
|
||||
|
||||
/* Trivial case. */
|
||||
if (asmall == 0.)
|
||||
return abig;
|
||||
|
||||
/* Scale the numbers as much as possible by using its ratio.
|
||||
For example, if both ABIG and ASMALL are VERY small, then
|
||||
X^2 + Y^2 might be VERY inaccurate due to loss of
|
||||
significant digits. Dividing ASMALL by ABIG scales them
|
||||
to a certain degree, so that accuracy is better. */
|
||||
|
||||
if ((ratio = asmall / abig) > __SQRT_DBL_MIN && abig < __SQRT_DBL_MAX)
|
||||
return abig * sqrt(1.0 + ratio*ratio);
|
||||
else
|
||||
{
|
||||
/* Slower but safer algorithm due to Moler and Morrison. Never
|
||||
produces any intermediate result greater than roughly the
|
||||
larger of X and Y. Should converge to machine-precision
|
||||
accuracy in 3 iterations. */
|
||||
|
||||
double r = ratio*ratio, t, s, p = abig, q = asmall;
|
||||
|
||||
do {
|
||||
t = 4. + r;
|
||||
if (t == 4.)
|
||||
break;
|
||||
s = r / t;
|
||||
p += 2. * s * p;
|
||||
q *= s;
|
||||
r = (q / p) * (q / p);
|
||||
} while (1);
|
||||
|
||||
return p;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef TEST
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
printf("hypot(3, 4) =\t\t\t %25.17e\n", hypot(3., 4.));
|
||||
printf("hypot(3*10^150, 4*10^150) =\t %25.17g\n", hypot(3.e+150, 4.e+150));
|
||||
printf("hypot(3*10^306, 4*10^306) =\t %25.17g\n", hypot(3.e+306, 4.e+306));
|
||||
printf("hypot(3*10^-320, 4*10^-320) =\t %25.17g\n",
|
||||
hypot(3.e-320, 4.e-320));
|
||||
printf("hypot(0.7*DBL_MAX, 0.7*DBL_MAX) =%25.17g\n",
|
||||
hypot(0.7*DBL_MAX, 0.7*DBL_MAX));
|
||||
printf("hypot(DBL_MAX, 1.0) =\t\t %25.17g\n", hypot(DBL_MAX, 1.0));
|
||||
printf("hypot(1.0, DBL_MAX) =\t\t %25.17g\n", hypot(1.0, DBL_MAX));
|
||||
printf("hypot(0.0, DBL_MAX) =\t\t %25.17g\n", hypot(0.0, DBL_MAX));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,32 @@
|
||||
/* Copyright (C) 1996 DJ Delorie, see COPYING.DJ for details */
|
||||
/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
|
||||
#include <math.h>
|
||||
|
||||
double
|
||||
ldexp(double v, int e)
|
||||
{
|
||||
double two = 2.0;
|
||||
|
||||
if (e < 0)
|
||||
{
|
||||
e = -e; /* This just might overflow on two-complement machines. */
|
||||
if (e < 0) return 0.0;
|
||||
while (e > 0)
|
||||
{
|
||||
if (e & 1) v /= two;
|
||||
two *= two;
|
||||
e >>= 1;
|
||||
}
|
||||
}
|
||||
else if (e > 0)
|
||||
{
|
||||
while (e > 0)
|
||||
{
|
||||
if (e & 1) v *= two;
|
||||
two *= two;
|
||||
e >>= 1;
|
||||
}
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.global log;
|
||||
|
||||
log:
|
||||
fldln2
|
||||
fldl 4(%esp)
|
||||
fyl2x
|
||||
ret
|
||||
@@ -0,0 +1,35 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
.text
|
||||
|
||||
.global modf;
|
||||
|
||||
modf:
|
||||
pushl %ebp
|
||||
movl %esp,%ebp
|
||||
subl $16,%esp
|
||||
pushl %ebx
|
||||
fnstcw -4(%ebp)
|
||||
fwait
|
||||
movw -4(%ebp),%ax
|
||||
orw $0x0c3f,%ax
|
||||
movw %ax,-8(%ebp)
|
||||
fldcw -8(%ebp)
|
||||
fwait
|
||||
fldl 8(%ebp)
|
||||
frndint
|
||||
fstpl -16(%ebp)
|
||||
fwait
|
||||
movl -16(%ebp),%edx
|
||||
movl -12(%ebp),%ecx
|
||||
movl 16(%ebp),%ebx
|
||||
movl %edx,(%ebx)
|
||||
movl %ecx,4(%ebx)
|
||||
fldl 8(%ebp)
|
||||
fsubl -16(%ebp)
|
||||
leal -20(%ebp),%esp
|
||||
fclex
|
||||
fldcw -4(%ebp)
|
||||
fwait
|
||||
popl %ebx
|
||||
leave
|
||||
ret
|
||||
@@ -0,0 +1,23 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.global modfl;
|
||||
|
||||
modfl:
|
||||
pushl %ebp
|
||||
movl %esp,%ebp
|
||||
subl $4,%esp
|
||||
fldt 8(%ebp)
|
||||
movl 20(%ebp),%eax
|
||||
fnstcw -2(%ebp)
|
||||
movw -2(%ebp),%dx
|
||||
orb $0x0c,%dh
|
||||
movw %dx,-4(%ebp)
|
||||
fldcw -4(%ebp)
|
||||
fld %st(0)
|
||||
frndint
|
||||
fldcw -2(%ebp)
|
||||
fld %st(0)
|
||||
fstpt (%eax)
|
||||
fsubrp %st,%st(1)
|
||||
leave
|
||||
ret
|
||||
@@ -0,0 +1,87 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
.data
|
||||
yint:
|
||||
.word 0,0
|
||||
pow.LCW1:
|
||||
.word 0
|
||||
pow.LCW2:
|
||||
.word 0
|
||||
|
||||
.text
|
||||
pow.LC0:
|
||||
.double 0d1.0e+00
|
||||
|
||||
.global pow;
|
||||
|
||||
frac:
|
||||
fstcw pow.LCW1
|
||||
fstcw pow.LCW2
|
||||
fwait
|
||||
andw $0xf3ff,pow.LCW2
|
||||
orw $0x0400,pow.LCW2
|
||||
fldcw pow.LCW2
|
||||
fldl %st(0)
|
||||
frndint
|
||||
fldcw pow.LCW1
|
||||
fxch %st(1)
|
||||
fsub %st(1),%st
|
||||
ret
|
||||
|
||||
Lpow2:
|
||||
call frac
|
||||
f2xm1
|
||||
faddl pow.LC0
|
||||
fscale
|
||||
fstp %st(1)
|
||||
ret
|
||||
|
||||
pow:
|
||||
fldl 12(%esp)
|
||||
fldl 4(%esp)
|
||||
ftst
|
||||
fnstsw %ax
|
||||
sahf
|
||||
jbe xltez
|
||||
fyl2x
|
||||
jmp Lpow2
|
||||
xltez:
|
||||
jb xltz
|
||||
fstp %st(0)
|
||||
ftst
|
||||
fnstsw %ax
|
||||
sahf
|
||||
ja ygtz
|
||||
jb error
|
||||
fstp %st(0)
|
||||
fld1
|
||||
fchs
|
||||
error:
|
||||
fsqrt
|
||||
ret
|
||||
ygtz:
|
||||
fstp %st(0)
|
||||
fldz
|
||||
ret
|
||||
xltz:
|
||||
fabs
|
||||
fxch %st(1)
|
||||
call frac
|
||||
ftst
|
||||
fnstsw %ax
|
||||
fstp %st(0)
|
||||
sahf
|
||||
je yisint
|
||||
fstp %st(0)
|
||||
fchs
|
||||
jmp error
|
||||
yisint:
|
||||
fistl yint
|
||||
fxch %st(1)
|
||||
fyl2x
|
||||
call Lpow2
|
||||
andl $1,yint
|
||||
jz yeven
|
||||
fchs
|
||||
yeven:
|
||||
ret
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.data
|
||||
pow10.LCW1:
|
||||
.word 0
|
||||
pow10.LCW2:
|
||||
.word 0
|
||||
pow10.LC0:
|
||||
.double 0d1.0e+00
|
||||
|
||||
.text
|
||||
|
||||
.global pow10;
|
||||
|
||||
pow10:
|
||||
fldl 4(%esp)
|
||||
fldl2t
|
||||
fmulp
|
||||
fstcw pow10.LCW1
|
||||
fstcw pow10.LCW2
|
||||
fwait
|
||||
andw $0xf3ff,pow10.LCW2
|
||||
orw $0x0400,pow10.LCW2
|
||||
fldcw pow10.LCW2
|
||||
fldl %st(0)
|
||||
frndint
|
||||
fldcw pow10.LCW1
|
||||
fxch %st(1)
|
||||
fsub %st(1),%st
|
||||
f2xm1
|
||||
faddl pow10.LC0
|
||||
fscale
|
||||
fstp %st(1)
|
||||
ret
|
||||
@@ -0,0 +1,32 @@
|
||||
/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.data
|
||||
pow2.LCW1:
|
||||
.word 0
|
||||
pow2.LCW2:
|
||||
.word 0
|
||||
pow2.LC0:
|
||||
.double 0d1.0e+00
|
||||
|
||||
.text
|
||||
|
||||
.global pow2;
|
||||
|
||||
pow2:
|
||||
fldl 4(%esp)
|
||||
fstcw pow2.LCW1
|
||||
fstcw pow2.LCW2
|
||||
fwait
|
||||
andw $0xf3ff,pow2.LCW2
|
||||
orw $0x0400,pow2.LCW2
|
||||
fldcw pow2.LCW2
|
||||
fldl %st(0)
|
||||
frndint
|
||||
fldcw pow2.LCW1
|
||||
fxch %st(1)
|
||||
fsub %st(1),%st
|
||||
f2xm1
|
||||
faddl pow2.LC0
|
||||
fscale
|
||||
fstp %st(1)
|
||||
ret
|
||||
@@ -0,0 +1,18 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.global sin;
|
||||
|
||||
sin.L0:
|
||||
.quad 0xffffffffffffffff
|
||||
|
||||
sin:
|
||||
fldl 4(%esp)
|
||||
fsin
|
||||
fstsw
|
||||
sahf
|
||||
jnp sin.L1
|
||||
fstp %st(0)
|
||||
fldl L0
|
||||
sin.L1:
|
||||
ret
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
#include <math.h>
|
||||
|
||||
double sinh(double x)
|
||||
{
|
||||
if(x >= 0.0)
|
||||
{
|
||||
const double epos = exp(x);
|
||||
return (epos - 1.0/epos) / 2.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
const double eneg = exp(-x);
|
||||
return (1.0/eneg - eneg) / 2.0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
.global sqrt;
|
||||
|
||||
sqrt:
|
||||
fldl 4(%esp)
|
||||
fsqrt
|
||||
ret
|
||||
@@ -0,0 +1,16 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
|
||||
tan.L0:
|
||||
.quad 0xffffffffffffffff
|
||||
|
||||
tan:
|
||||
fldl 4(%esp)
|
||||
fptan
|
||||
fstsw
|
||||
fstp %st(0)
|
||||
sahf
|
||||
jnp tan.L1
|
||||
/* fstp %st(0) - if exception, there is nothing on the stack */
|
||||
fldl tan.L0
|
||||
tan.L1:
|
||||
ret
|
||||
@@ -0,0 +1,17 @@
|
||||
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
|
||||
#include <math.h>
|
||||
|
||||
double tanh(double x)
|
||||
{
|
||||
if (x > 50)
|
||||
return 1;
|
||||
else if (x < -50)
|
||||
return -1;
|
||||
else
|
||||
{
|
||||
const double ebig = exp(x);
|
||||
const double esmall = 1.0/ebig;
|
||||
return (ebig - esmall) / (ebig + esmall);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
.global longjmp
|
||||
|
||||
longjmp:
|
||||
mov 4(%esp),%edx
|
||||
mov 8(%esp),%eax
|
||||
cmp $1,%eax
|
||||
adc $0, %al
|
||||
mov (%edx),%ebx
|
||||
mov 4(%edx),%esi
|
||||
mov 8(%edx),%edi
|
||||
mov 12(%edx),%ebp
|
||||
mov 16(%edx),%esp
|
||||
jmp *20(%edx)
|
||||
@@ -0,0 +1,15 @@
|
||||
|
||||
.global setjmp
|
||||
|
||||
setjmp:
|
||||
mov 4(%esp), %eax
|
||||
mov %ebx, (%eax)
|
||||
mov %esi, 4(%eax)
|
||||
mov %edi, 8(%eax)
|
||||
mov %ebp, 12(%eax)
|
||||
lea 4(%esp), %ecx
|
||||
mov %ecx, 16(%eax)
|
||||
mov (%esp), %ecx
|
||||
mov %ecx, 20(%eax)
|
||||
xor %eax, %eax
|
||||
ret
|
||||
@@ -0,0 +1,6 @@
|
||||
#include <stdio.h>
|
||||
|
||||
void clearerr(FILE *stream) {
|
||||
stream->error = 0;
|
||||
stream->eof = 0;
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
#include <sys/ksys.h>
|
||||
#include "conio.h"
|
||||
|
||||
static char* __con_caption = "Console application";
|
||||
static char* __con_dllname = "/sys/lib/console.obj";
|
||||
|
||||
int __con_is_load = 0;
|
||||
|
||||
void stdcall (*__con_init_hidden)(int wnd_width, int wnd_height,int scr_width, int scr_height, const char* title);
|
||||
void stdcall (*__con_write_asciiz)(const char* str);
|
||||
void stdcall (*__con_write_string)(const char* str, unsigned length);
|
||||
int stdcall (*__con_getch)(void);
|
||||
short stdcall (*__con_getch2)(void);
|
||||
int stdcall (*__con_kbhit)(void);
|
||||
char* stdcall (*__con_gets)(char* str, int n);
|
||||
char* stdcall (*__con_gets2)(__con_gets2_callback callback, char* str, int n);
|
||||
void stdcall (*__con_exit)(int status);
|
||||
void stdcall (*__con_set_title)(const char* title);
|
||||
|
||||
static void __con_panic(char* func_name)
|
||||
{
|
||||
_ksys_debug_puts("libc.obj: ");
|
||||
_ksys_debug_puts(func_name);
|
||||
_ksys_debug_puts(" = NULL\n");
|
||||
_ksys_exit();
|
||||
}
|
||||
|
||||
static void __con_lib_link(ksys_coff_etable_t *exp)
|
||||
{
|
||||
__con_init_hidden = _ksys_get_coff_func(exp, "con_init", __con_panic);
|
||||
__con_write_asciiz = _ksys_get_coff_func(exp, "con_write_asciiz", __con_panic);
|
||||
__con_write_string = _ksys_get_coff_func(exp, "con_write_string", __con_panic);
|
||||
__con_getch = _ksys_get_coff_func(exp, "con_getch", __con_panic);
|
||||
__con_getch2 = _ksys_get_coff_func(exp, "con_getch2", __con_panic);
|
||||
__con_kbhit = _ksys_get_coff_func(exp, "con_kbhit", __con_panic);
|
||||
__con_gets = _ksys_get_coff_func(exp, "con_gets", __con_panic);
|
||||
__con_gets2 = _ksys_get_coff_func(exp, "con_gets2", __con_panic);
|
||||
__con_exit = _ksys_get_coff_func(exp, "con_exit", __con_panic);
|
||||
__con_set_title = _ksys_get_coff_func(exp, "con_set_title", __con_panic);
|
||||
}
|
||||
|
||||
|
||||
int __con_init(void)
|
||||
{
|
||||
return __con_init_opt(-1, -1, -1, -1, __con_caption);
|
||||
}
|
||||
|
||||
void con_set_title(const char* title){
|
||||
__con_init();
|
||||
__con_set_title(title);
|
||||
}
|
||||
|
||||
int __con_init_opt(int wnd_width, int wnd_height,int scr_width, int scr_height, const char* title)
|
||||
{
|
||||
if(!__con_is_load){
|
||||
ksys_coff_etable_t *__con_lib;
|
||||
__con_lib = _ksys_load_coff(__con_dllname);
|
||||
if(__con_lib==NULL){
|
||||
_ksys_debug_puts("Error! Can't load console.obj lib\n");
|
||||
return 1;
|
||||
}
|
||||
__con_lib_link(__con_lib);
|
||||
__con_init_hidden(wnd_width, wnd_height, scr_width, scr_height, title);
|
||||
__con_is_load= 1;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
|
||||
This is adapded thunk for console.obj sys library
|
||||
Only for internal use in stdio.h
|
||||
|
||||
Adapted for tcc by Siemargl, 2016
|
||||
|
||||
*/
|
||||
#ifndef _CONIO_H_
|
||||
#define _CONIO_H_
|
||||
|
||||
#define cdecl __attribute__ ((cdecl))
|
||||
#define stdcall __attribute__ ((stdcall))
|
||||
|
||||
void stdcall (*__con_write_asciiz)(const char* str);
|
||||
/* Display ASCIIZ-string to the console at the current position, shifting
|
||||
the current position. */
|
||||
|
||||
void stdcall (*__con_write_string)(const char* str, unsigned length);
|
||||
/* Similar to __con_write_asciiz, but length of the string must be given as a
|
||||
separate parameter */
|
||||
|
||||
int stdcall (*__con_getch)(void);
|
||||
/* Get one character from the keyboard.
|
||||
|
||||
For normal characters function returns ASCII-code. For extended
|
||||
characters (eg, Fx, and arrows), first function call returns 0
|
||||
and second call returns the extended code (similar to the DOS-function
|
||||
input). Starting from version 7, after closing the console window,
|
||||
this function returns 0. */
|
||||
|
||||
short stdcall (*__con_getch2)(void);
|
||||
/* Reads a character from the keyboard. Low byte contains the ASCII-code
|
||||
(0 for extended characters), high byte - advanced code (like in BIOS
|
||||
input functions). Starting from version 7, after closing the console
|
||||
window, this function returns 0. */
|
||||
|
||||
int stdcall (*__con_kbhit)(void);
|
||||
/* Returns 1 if a key was pressed, 0 otherwise. To read pressed keys use
|
||||
__con_getch and __con_getch2. Starting from version 6, after closing
|
||||
the console window, this function returns 1. */
|
||||
|
||||
char* stdcall (*__con_gets)(char* str, int n);
|
||||
/* Reads a string from the keyboard. Reading is interrupted when got
|
||||
"new line" character, or after reading the (n-1) characters (depending on
|
||||
what comes first). In the first case the newline is also recorded in the
|
||||
str. The acquired line is complemented by a null character.
|
||||
Starting from version 6, the function returns a pointer to the entered
|
||||
line if reading was successful, and NULL if the console window was closed. */
|
||||
|
||||
typedef int (stdcall * __con_gets2_callback)(int keycode, char** pstr, int* pn,
|
||||
int* ppos);
|
||||
|
||||
char* stdcall (*__con_gets2)(__con_gets2_callback callback, char* str, int n);
|
||||
/* Con_gets completely analogous, except that when the user
|
||||
press unrecognized key, it calls the specified callback-procedure
|
||||
(which may, for example, handle up / down for history and tab to enter
|
||||
autocompletion). You should pass to the procedure: key code and three pointers
|
||||
- to the string, to the maximum length and to the current position.
|
||||
function may change the contents of string and may change the string
|
||||
itself (for example, to reallocate memory for increase the limit),
|
||||
maximum length, and position of the line - pointers are passed for it.
|
||||
Return value: 0 = line wasn't changed 1 = line changed, you should
|
||||
remove old string and display new, 2 = line changed, it is necessary
|
||||
to display it; 3 = immediately exit the function.
|
||||
Starting from version 6, the function returns a pointer to the entered
|
||||
line with the successful reading, and NULL if the console window was closed. */
|
||||
|
||||
int __con_is_load;
|
||||
unsigned *__con_dll_ver;
|
||||
|
||||
int __con_init(void);
|
||||
int __con_init_opt(int wnd_width, int wnd_height, int scr_width, int scr_height, const char* title);
|
||||
void stdcall (*__con_exit)(int status);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,15 @@
|
||||
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <limits.h>
|
||||
|
||||
void debug_printf(const char *format,...)
|
||||
{
|
||||
va_list ap;
|
||||
static char log_board[STDIO_MAX_MEM];
|
||||
va_start (ap, format);
|
||||
vsnprintf(log_board, STDIO_MAX_MEM, format, ap);
|
||||
va_end(ap);
|
||||
_ksys_debug_puts(log_board);
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int fclose(FILE *stream) {
|
||||
free(stream);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
#include <stdio.h>
|
||||
|
||||
int feof(FILE *stream) {
|
||||
return stream->eof;
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
#include <stdio.h>
|
||||
|
||||
int ferror(FILE *stream) {
|
||||
return stream->error;
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
#include <stdio.h>
|
||||
|
||||
int fflush(FILE *stream) {
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <sys/ksys.h>
|
||||
|
||||
int fgetc(FILE* stream)
|
||||
{
|
||||
unsigned bytes_read;
|
||||
char c;
|
||||
|
||||
unsigned status = _ksys_file_read_file(stream->name, stream->position, 1, &c, &bytes_read);
|
||||
|
||||
if (status != KSYS_FS_ERR_SUCCESS) {
|
||||
switch (status) {
|
||||
case KSYS_FS_ERR_EOF:
|
||||
stream->eof = 1;
|
||||
break;
|
||||
case KSYS_FS_ERR_1:
|
||||
case KSYS_FS_ERR_2:
|
||||
case KSYS_FS_ERR_3:
|
||||
case KSYS_FS_ERR_4:
|
||||
case KSYS_FS_ERR_5:
|
||||
case KSYS_FS_ERR_7:
|
||||
case KSYS_FS_ERR_8:
|
||||
case KSYS_FS_ERR_9:
|
||||
case KSYS_FS_ERR_10:
|
||||
case KSYS_FS_ERR_11:
|
||||
default:
|
||||
// Just some IO error, who knows what exactly happened
|
||||
errno = EIO;
|
||||
stream->error = errno;
|
||||
break;
|
||||
}
|
||||
return EOF;
|
||||
}
|
||||
|
||||
stream->position++;
|
||||
return c;
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
#include <stdio.h>
|
||||
|
||||
int fgetpos(FILE *restrict stream, fpos_t *restrict pos) {
|
||||
*pos = stream->position;
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
#include <stdio.h>
|
||||
#include "conio.h"
|
||||
#include <errno.h>
|
||||
|
||||
char *fgets(char *str, int n, FILE *stream)
|
||||
{
|
||||
int i=0, sym_code;
|
||||
|
||||
if(!stream || !str){
|
||||
errno = EINVAL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
while (i<n-1){
|
||||
sym_code = fgetc(stream);
|
||||
if(sym_code =='\n' || sym_code == EOF){ break; }
|
||||
str[i]=(char)sym_code;
|
||||
i++;
|
||||
}
|
||||
|
||||
if(i<1){ return NULL; }
|
||||
return str;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
FILE *fopen(const char *restrict _name, const char *restrict _mode) {
|
||||
FILE *out = malloc(sizeof(FILE));
|
||||
return freopen(_name, _mode, out);
|
||||
}
|
||||
@@ -0,0 +1,817 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// \author (c) Marco Paland (info@paland.com)
|
||||
// 2014-2019, PALANDesign Hannover, Germany
|
||||
//
|
||||
// \license The MIT License (MIT)
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
// THE SOFTWARE.
|
||||
//
|
||||
// \brief Tiny printf, sprintf and (v)snprintf implementation, optimized for speed on
|
||||
// embedded systems with a very limited resources. These routines are thread
|
||||
// safe and reentrant!
|
||||
// Use this instead of the bloated standard/newlib printf cause these use
|
||||
// malloc for printf (and may not be thread safe).
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include "format_print.h"
|
||||
#include <math.h>
|
||||
|
||||
// 'ntoa' conversion buffer size, this must be big enough to hold one converted
|
||||
// numeric number including padded zeros (dynamically created on stack)
|
||||
// default: 32 byte
|
||||
#ifndef PRINTF_NTOA_BUFFER_SIZE
|
||||
#define PRINTF_NTOA_BUFFER_SIZE 32U
|
||||
#endif
|
||||
|
||||
// 'ftoa' conversion buffer size, this must be big enough to hold one converted
|
||||
// float number including padded zeros (dynamically created on stack)
|
||||
// default: 32 byte
|
||||
#ifndef PRINTF_FTOA_BUFFER_SIZE
|
||||
#define PRINTF_FTOA_BUFFER_SIZE 32U
|
||||
#endif
|
||||
|
||||
// support for the floating point type (%f)
|
||||
// default: activated
|
||||
#ifndef PRINTF_DISABLE_SUPPORT_FLOAT
|
||||
#define PRINTF_SUPPORT_FLOAT
|
||||
#endif
|
||||
|
||||
// support for exponential floating point notation (%e/%g)
|
||||
// default: activated
|
||||
#ifndef PRINTF_DISABLE_SUPPORT_EXPONENTIAL
|
||||
#define PRINTF_SUPPORT_EXPONENTIAL
|
||||
#endif
|
||||
|
||||
// define the default floating point precision
|
||||
// default: 6 digits
|
||||
#ifndef PRINTF_DEFAULT_FLOAT_PRECISION
|
||||
#define PRINTF_DEFAULT_FLOAT_PRECISION 6U
|
||||
#endif
|
||||
|
||||
// define the largest float suitable to print with %f
|
||||
// default: 1e9
|
||||
#ifndef PRINTF_MAX_FLOAT
|
||||
#define PRINTF_MAX_FLOAT 1e9
|
||||
#endif
|
||||
|
||||
// support for the long long types (%llu or %p)
|
||||
// default: activated
|
||||
#ifndef PRINTF_DISABLE_SUPPORT_LONG_LONG
|
||||
#define PRINTF_SUPPORT_LONG_LONG
|
||||
#endif
|
||||
|
||||
// support for the ptrdiff_t type (%t)
|
||||
// ptrdiff_t is normally defined in <stddef.h> as long or long long type
|
||||
// default: activated
|
||||
#ifndef PRINTF_DISABLE_SUPPORT_PTRDIFF_T
|
||||
#define PRINTF_SUPPORT_PTRDIFF_T
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// internal flag definitions
|
||||
#define FLAGS_ZEROPAD (1U << 0U)
|
||||
#define FLAGS_LEFT (1U << 1U)
|
||||
#define FLAGS_PLUS (1U << 2U)
|
||||
#define FLAGS_SPACE (1U << 3U)
|
||||
#define FLAGS_HASH (1U << 4U)
|
||||
#define FLAGS_UPPERCASE (1U << 5U)
|
||||
#define FLAGS_CHAR (1U << 6U)
|
||||
#define FLAGS_SHORT (1U << 7U)
|
||||
#define FLAGS_LONG (1U << 8U)
|
||||
#define FLAGS_LONG_LONG (1U << 9U)
|
||||
#define FLAGS_PRECISION (1U << 10U)
|
||||
#define FLAGS_ADAPT_EXP (1U << 11U)
|
||||
|
||||
|
||||
// import float.h for DBL_MAX
|
||||
#if defined(PRINTF_SUPPORT_FLOAT)
|
||||
#include <float.h>
|
||||
#endif
|
||||
|
||||
|
||||
// internal buffer output
|
||||
void _out_buffer(char character, void* buffer, size_t idx, size_t maxlen)
|
||||
{
|
||||
if (idx < maxlen) {
|
||||
((char*)buffer)[idx] = character;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// internal null output
|
||||
void _out_null(char character, void* buffer, size_t idx, size_t maxlen)
|
||||
{
|
||||
(void)character; (void)buffer; (void)idx; (void)maxlen;
|
||||
}
|
||||
|
||||
|
||||
// internal secure strlen
|
||||
// \return The length of the string (excluding the terminating 0) limited by 'maxsize'
|
||||
static inline unsigned int _strnlen_s(const char* str, size_t maxsize)
|
||||
{
|
||||
const char* s;
|
||||
for (s = str; *s && maxsize--; ++s);
|
||||
return (unsigned int)(s - str);
|
||||
}
|
||||
|
||||
|
||||
// internal test if char is a digit (0-9)
|
||||
// \return true if char is a digit
|
||||
static inline bool _is_digit(char ch)
|
||||
{
|
||||
return (ch >= '0') && (ch <= '9');
|
||||
}
|
||||
|
||||
|
||||
// internal ASCII string to unsigned int conversion
|
||||
static unsigned int _atoi(const char** str)
|
||||
{
|
||||
unsigned int i = 0U;
|
||||
while (_is_digit(**str)) {
|
||||
i = i * 10U + (unsigned int)(*((*str)++) - '0');
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
// output the specified string in reverse, taking care of any zero-padding
|
||||
static size_t _out_rev(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width, unsigned int flags)
|
||||
{
|
||||
const size_t start_idx = idx;
|
||||
|
||||
// pad spaces up to given width
|
||||
if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
|
||||
for (size_t i = len; i < width; i++) {
|
||||
out(' ', buffer, idx++, maxlen);
|
||||
}
|
||||
}
|
||||
|
||||
// reverse string
|
||||
while (len) {
|
||||
out(buf[--len], buffer, idx++, maxlen);
|
||||
}
|
||||
|
||||
// append pad spaces up to given width
|
||||
if (flags & FLAGS_LEFT) {
|
||||
while (idx - start_idx < width) {
|
||||
out(' ', buffer, idx++, maxlen);
|
||||
}
|
||||
}
|
||||
|
||||
return idx;
|
||||
}
|
||||
|
||||
|
||||
// internal itoa format
|
||||
static size_t _ntoa_format(out_fct_type out, char* buffer, size_t idx, size_t maxlen, char* buf, size_t len, bool negative, unsigned int base, unsigned int prec, unsigned int width, unsigned int flags)
|
||||
{
|
||||
// pad leading zeros
|
||||
if (!(flags & FLAGS_LEFT)) {
|
||||
if (width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
|
||||
width--;
|
||||
}
|
||||
while ((len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
|
||||
buf[len++] = '0';
|
||||
}
|
||||
while ((flags & FLAGS_ZEROPAD) && (len < width) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
|
||||
buf[len++] = '0';
|
||||
}
|
||||
}
|
||||
|
||||
// handle hash
|
||||
if (flags & FLAGS_HASH) {
|
||||
if (!(flags & FLAGS_PRECISION) && len && ((len == prec) || (len == width))) {
|
||||
len--;
|
||||
if (len && (base == 16U)) {
|
||||
len--;
|
||||
}
|
||||
}
|
||||
if ((base == 16U) && !(flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
|
||||
buf[len++] = 'x';
|
||||
}
|
||||
else if ((base == 16U) && (flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
|
||||
buf[len++] = 'X';
|
||||
}
|
||||
else if ((base == 2U) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
|
||||
buf[len++] = 'b';
|
||||
}
|
||||
if (len < PRINTF_NTOA_BUFFER_SIZE) {
|
||||
buf[len++] = '0';
|
||||
}
|
||||
}
|
||||
|
||||
if (len < PRINTF_NTOA_BUFFER_SIZE) {
|
||||
if (negative) {
|
||||
buf[len++] = '-';
|
||||
}
|
||||
else if (flags & FLAGS_PLUS) {
|
||||
buf[len++] = '+'; // ignore the space if the '+' exists
|
||||
}
|
||||
else if (flags & FLAGS_SPACE) {
|
||||
buf[len++] = ' ';
|
||||
}
|
||||
}
|
||||
|
||||
return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
|
||||
}
|
||||
|
||||
|
||||
// internal itoa for 'long' type
|
||||
static size_t _ntoa_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long value, bool negative, unsigned long base, unsigned int prec, unsigned int width, unsigned int flags)
|
||||
{
|
||||
char buf[PRINTF_NTOA_BUFFER_SIZE];
|
||||
size_t len = 0U;
|
||||
|
||||
// no hash for 0 values
|
||||
if (!value) {
|
||||
flags &= ~FLAGS_HASH;
|
||||
}
|
||||
|
||||
// write if precision != 0 and value is != 0
|
||||
if (!(flags & FLAGS_PRECISION) || value) {
|
||||
do {
|
||||
const char digit = (char)(value % base);
|
||||
buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
|
||||
value /= base;
|
||||
} while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
|
||||
}
|
||||
|
||||
return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
|
||||
}
|
||||
|
||||
|
||||
// internal itoa for 'long long' type
|
||||
#if defined(PRINTF_SUPPORT_LONG_LONG)
|
||||
static size_t _ntoa_long_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long long value, bool negative, unsigned long long base, unsigned int prec, unsigned int width, unsigned int flags)
|
||||
{
|
||||
char buf[PRINTF_NTOA_BUFFER_SIZE];
|
||||
size_t len = 0U;
|
||||
|
||||
// no hash for 0 values
|
||||
if (!value) {
|
||||
flags &= ~FLAGS_HASH;
|
||||
}
|
||||
|
||||
// write if precision != 0 and value is != 0
|
||||
if (!(flags & FLAGS_PRECISION) || value) {
|
||||
do {
|
||||
const char digit = (char)(value % base);
|
||||
buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
|
||||
value /= base;
|
||||
} while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
|
||||
}
|
||||
|
||||
return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
|
||||
}
|
||||
#endif // PRINTF_SUPPORT_LONG_LONG
|
||||
|
||||
|
||||
#if defined(PRINTF_SUPPORT_FLOAT)
|
||||
|
||||
#if defined(PRINTF_SUPPORT_EXPONENTIAL)
|
||||
// forward declaration so that _ftoa can switch to exp notation for values > PRINTF_MAX_FLOAT
|
||||
static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags);
|
||||
#endif
|
||||
|
||||
|
||||
// internal ftoa for fixed decimal floating point
|
||||
static size_t _ftoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags)
|
||||
{
|
||||
char buf[PRINTF_FTOA_BUFFER_SIZE];
|
||||
size_t len = 0U;
|
||||
double diff = 0.0;
|
||||
|
||||
// powers of 10
|
||||
static const double pow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
|
||||
|
||||
// test for special values
|
||||
if (value != value)
|
||||
return _out_rev(out, buffer, idx, maxlen, "nan", 3, width, flags);
|
||||
if (value < -DBL_MAX)
|
||||
return _out_rev(out, buffer, idx, maxlen, "fni-", 4, width, flags);
|
||||
if (value > DBL_MAX)
|
||||
return _out_rev(out, buffer, idx, maxlen, (flags & FLAGS_PLUS) ? "fni+" : "fni", (flags & FLAGS_PLUS) ? 4U : 3U, width, flags);
|
||||
|
||||
// test for very large values
|
||||
// standard printf behavior is to print EVERY whole number digit -- which could be 100s of characters overflowing your buffers == bad
|
||||
if ((value > PRINTF_MAX_FLOAT) || (value < -PRINTF_MAX_FLOAT)) {
|
||||
#if defined(PRINTF_SUPPORT_EXPONENTIAL)
|
||||
return _etoa(out, buffer, idx, maxlen, value, prec, width, flags);
|
||||
#else
|
||||
return 0U;
|
||||
#endif
|
||||
}
|
||||
|
||||
// test for negative
|
||||
bool negative = false;
|
||||
if (value < 0) {
|
||||
negative = true;
|
||||
value = 0 - value;
|
||||
}
|
||||
|
||||
// set default precision, if not set explicitly
|
||||
if (!(flags & FLAGS_PRECISION)) {
|
||||
prec = PRINTF_DEFAULT_FLOAT_PRECISION;
|
||||
}
|
||||
// limit precision to 9, cause a prec >= 10 can lead to overflow errors
|
||||
while ((len < PRINTF_FTOA_BUFFER_SIZE) && (prec > 9U)) {
|
||||
buf[len++] = '0';
|
||||
prec--;
|
||||
}
|
||||
|
||||
int whole = (int)value;
|
||||
double tmp = (value - whole) * pow10[prec];
|
||||
unsigned long frac = (unsigned long)tmp;
|
||||
diff = tmp - frac;
|
||||
|
||||
if (diff > 0.5) {
|
||||
++frac;
|
||||
// handle rollover, e.g. case 0.99 with prec 1 is 1.0
|
||||
if (frac >= pow10[prec]) {
|
||||
frac = 0;
|
||||
++whole;
|
||||
}
|
||||
}
|
||||
else if (diff < 0.5) {
|
||||
}
|
||||
else if ((frac == 0U) || (frac & 1U)) {
|
||||
// if halfway, round up if odd OR if last digit is 0
|
||||
++frac;
|
||||
}
|
||||
|
||||
if (prec == 0U) {
|
||||
diff = value - (double)whole;
|
||||
if ((!(diff < 0.5) || (diff > 0.5)) && (whole & 1)) {
|
||||
// exactly 0.5 and ODD, then round up
|
||||
// 1.5 -> 2, but 2.5 -> 2
|
||||
++whole;
|
||||
}
|
||||
}
|
||||
else {
|
||||
unsigned int count = prec;
|
||||
// now do fractional part, as an unsigned number
|
||||
while (len < PRINTF_FTOA_BUFFER_SIZE) {
|
||||
--count;
|
||||
buf[len++] = (char)(48U + (frac % 10U));
|
||||
if (!(frac /= 10U)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// add extra 0s
|
||||
while ((len < PRINTF_FTOA_BUFFER_SIZE) && (count-- > 0U)) {
|
||||
buf[len++] = '0';
|
||||
}
|
||||
if (len < PRINTF_FTOA_BUFFER_SIZE) {
|
||||
// add decimal
|
||||
buf[len++] = '.';
|
||||
}
|
||||
}
|
||||
|
||||
// do whole part, number is reversed
|
||||
while (len < PRINTF_FTOA_BUFFER_SIZE) {
|
||||
buf[len++] = (char)(48 + (whole % 10));
|
||||
if (!(whole /= 10)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// pad leading zeros
|
||||
if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) {
|
||||
if (width && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
|
||||
width--;
|
||||
}
|
||||
while ((len < width) && (len < PRINTF_FTOA_BUFFER_SIZE)) {
|
||||
buf[len++] = '0';
|
||||
}
|
||||
}
|
||||
|
||||
if (len < PRINTF_FTOA_BUFFER_SIZE) {
|
||||
if (negative) {
|
||||
buf[len++] = '-';
|
||||
}
|
||||
else if (flags & FLAGS_PLUS) {
|
||||
buf[len++] = '+'; // ignore the space if the '+' exists
|
||||
}
|
||||
else if (flags & FLAGS_SPACE) {
|
||||
buf[len++] = ' ';
|
||||
}
|
||||
}
|
||||
|
||||
return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
|
||||
}
|
||||
|
||||
|
||||
#if defined(PRINTF_SUPPORT_EXPONENTIAL)
|
||||
// internal ftoa variant for exponential floating-point type, contributed by Martijn Jasperse <m.jasperse@gmail.com>
|
||||
static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags)
|
||||
{
|
||||
// check for NaN and special values
|
||||
if ((value != value) || (value > DBL_MAX) || (value < -DBL_MAX)) {
|
||||
return _ftoa(out, buffer, idx, maxlen, value, prec, width, flags);
|
||||
}
|
||||
|
||||
// determine the sign
|
||||
const bool negative = value < 0;
|
||||
if (negative) {
|
||||
value = -value;
|
||||
}
|
||||
|
||||
// default precision
|
||||
if (!(flags & FLAGS_PRECISION)) {
|
||||
prec = PRINTF_DEFAULT_FLOAT_PRECISION;
|
||||
}
|
||||
|
||||
// determine the decimal exponent
|
||||
// based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c)
|
||||
union {
|
||||
uint64_t U;
|
||||
double F;
|
||||
} conv;
|
||||
|
||||
conv.F = value;
|
||||
int exp2 = (int)((conv.U >> 52U) & 0x07FFU) - 1023; // effectively log2
|
||||
conv.U = (conv.U & ((1ULL << 52U) - 1U)) | (1023ULL << 52U); // drop the exponent so conv.F is now in [1,2)
|
||||
// now approximate log10 from the log2 integer part and an expansion of ln around 1.5
|
||||
int expval = (int)(0.1760912590558 + exp2 * 0.301029995663981 + (conv.F - 1.5) * 0.289529654602168);
|
||||
// now we want to compute 10^expval but we want to be sure it won't overflow
|
||||
exp2 = (int)(expval * 3.321928094887362 + 0.5);
|
||||
const double z = expval * 2.302585092994046 - exp2 * 0.6931471805599453;
|
||||
const double z2 = z * z;
|
||||
conv.U = (uint64_t)(exp2 + 1023) << 52U;
|
||||
// compute exp(z) using continued fractions, see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex
|
||||
conv.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14)))));
|
||||
// correct for rounding errors
|
||||
if (value < conv.F) {
|
||||
expval--;
|
||||
conv.F /= 10;
|
||||
}
|
||||
|
||||
// the exponent format is "%+03d" and largest value is "307", so set aside 4-5 characters
|
||||
unsigned int minwidth = ((expval < 100) && (expval > -100)) ? 4U : 5U;
|
||||
|
||||
// in "%g" mode, "prec" is the number of *significant figures* not decimals
|
||||
if (flags & FLAGS_ADAPT_EXP) {
|
||||
// do we want to fall-back to "%f" mode?
|
||||
if ((value >= 1e-4) && (value < 1e6)) {
|
||||
if ((int)prec > expval) {
|
||||
prec = (unsigned)((int)prec - expval - 1);
|
||||
}
|
||||
else {
|
||||
prec = 0;
|
||||
}
|
||||
flags |= FLAGS_PRECISION; // make sure _ftoa respects precision
|
||||
// no characters in exponent
|
||||
minwidth = 0U;
|
||||
expval = 0;
|
||||
}
|
||||
else {
|
||||
// we use one sigfig for the whole part
|
||||
if ((prec > 0) && (flags & FLAGS_PRECISION)) {
|
||||
--prec;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// will everything fit?
|
||||
unsigned int fwidth = width;
|
||||
if (width > minwidth) {
|
||||
// we didn't fall-back so subtract the characters required for the exponent
|
||||
fwidth -= minwidth;
|
||||
} else {
|
||||
// not enough characters, so go back to default sizing
|
||||
fwidth = 0U;
|
||||
}
|
||||
if ((flags & FLAGS_LEFT) && minwidth) {
|
||||
// if we're padding on the right, DON'T pad the floating part
|
||||
fwidth = 0U;
|
||||
}
|
||||
|
||||
// rescale the float value
|
||||
if (expval) {
|
||||
value /= conv.F;
|
||||
}
|
||||
|
||||
// output the floating part
|
||||
const size_t start_idx = idx;
|
||||
idx = _ftoa(out, buffer, idx, maxlen, negative ? -value : value, prec, fwidth, flags & ~FLAGS_ADAPT_EXP);
|
||||
|
||||
// output the exponent part
|
||||
if (minwidth) {
|
||||
// output the exponential symbol
|
||||
out((flags & FLAGS_UPPERCASE) ? 'E' : 'e', buffer, idx++, maxlen);
|
||||
// output the exponent value
|
||||
idx = _ntoa_long(out, buffer, idx, maxlen, (expval < 0) ? -expval : expval, expval < 0, 10, 0, minwidth-1, FLAGS_ZEROPAD | FLAGS_PLUS);
|
||||
// might need to right-pad spaces
|
||||
if (flags & FLAGS_LEFT) {
|
||||
while (idx - start_idx < width) out(' ', buffer, idx++, maxlen);
|
||||
}
|
||||
}
|
||||
return idx;
|
||||
}
|
||||
#endif // PRINTF_SUPPORT_EXPONENTIAL
|
||||
#endif // PRINTF_SUPPORT_FLOAT
|
||||
|
||||
|
||||
// internal vsnprintf
|
||||
int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const char* format, va_list va)
|
||||
{
|
||||
unsigned int flags, width, precision, n;
|
||||
size_t idx = 0U;
|
||||
|
||||
if (!buffer) {
|
||||
// use null output function
|
||||
out = _out_null;
|
||||
}
|
||||
|
||||
while (*format)
|
||||
{
|
||||
// format specifier? %[flags][width][.precision][length]
|
||||
if (*format != '%') {
|
||||
// no
|
||||
out(*format, buffer, idx++, maxlen);
|
||||
format++;
|
||||
continue;
|
||||
}
|
||||
else {
|
||||
// yes, evaluate it
|
||||
format++;
|
||||
}
|
||||
|
||||
// evaluate flags
|
||||
flags = 0U;
|
||||
do {
|
||||
switch (*format) {
|
||||
case '0': flags |= FLAGS_ZEROPAD; format++; n = 1U; break;
|
||||
case '-': flags |= FLAGS_LEFT; format++; n = 1U; break;
|
||||
case '+': flags |= FLAGS_PLUS; format++; n = 1U; break;
|
||||
case ' ': flags |= FLAGS_SPACE; format++; n = 1U; break;
|
||||
case '#': flags |= FLAGS_HASH; format++; n = 1U; break;
|
||||
default : n = 0U; break;
|
||||
}
|
||||
} while (n);
|
||||
|
||||
// evaluate width field
|
||||
width = 0U;
|
||||
if (_is_digit(*format)) {
|
||||
width = _atoi(&format);
|
||||
}
|
||||
else if (*format == '*') {
|
||||
const int w = va_arg(va, int);
|
||||
if (w < 0) {
|
||||
flags |= FLAGS_LEFT; // reverse padding
|
||||
width = (unsigned int)-w;
|
||||
}
|
||||
else {
|
||||
width = (unsigned int)w;
|
||||
}
|
||||
format++;
|
||||
}
|
||||
|
||||
// evaluate precision field
|
||||
precision = 0U;
|
||||
if (*format == '.') {
|
||||
flags |= FLAGS_PRECISION;
|
||||
format++;
|
||||
if (_is_digit(*format)) {
|
||||
precision = _atoi(&format);
|
||||
}
|
||||
else if (*format == '*') {
|
||||
const int prec = (int)va_arg(va, int);
|
||||
precision = prec > 0 ? (unsigned int)prec : 0U;
|
||||
format++;
|
||||
}
|
||||
}
|
||||
|
||||
// evaluate length field
|
||||
switch (*format) {
|
||||
case 'l' :
|
||||
flags |= FLAGS_LONG;
|
||||
format++;
|
||||
if (*format == 'l') {
|
||||
flags |= FLAGS_LONG_LONG;
|
||||
format++;
|
||||
}
|
||||
break;
|
||||
case 'h' :
|
||||
flags |= FLAGS_SHORT;
|
||||
format++;
|
||||
if (*format == 'h') {
|
||||
flags |= FLAGS_CHAR;
|
||||
format++;
|
||||
}
|
||||
break;
|
||||
#if defined(PRINTF_SUPPORT_PTRDIFF_T)
|
||||
case 't' :
|
||||
flags |= (sizeof(ptrdiff_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
|
||||
format++;
|
||||
break;
|
||||
#endif
|
||||
case 'j' :
|
||||
flags |= (sizeof(intmax_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
|
||||
format++;
|
||||
break;
|
||||
case 'z' :
|
||||
flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
|
||||
format++;
|
||||
break;
|
||||
default :
|
||||
break;
|
||||
}
|
||||
|
||||
// evaluate specifier
|
||||
switch (*format) {
|
||||
case 'd' :
|
||||
case 'i' :
|
||||
case 'u' :
|
||||
case 'x' :
|
||||
case 'X' :
|
||||
case 'o' :
|
||||
case 'b' : {
|
||||
// set the base
|
||||
unsigned int base;
|
||||
if (*format == 'x' || *format == 'X') {
|
||||
base = 16U;
|
||||
}
|
||||
else if (*format == 'o') {
|
||||
base = 8U;
|
||||
}
|
||||
else if (*format == 'b') {
|
||||
base = 2U;
|
||||
}
|
||||
else {
|
||||
base = 10U;
|
||||
flags &= ~FLAGS_HASH; // no hash for dec format
|
||||
}
|
||||
// uppercase
|
||||
if (*format == 'X') {
|
||||
flags |= FLAGS_UPPERCASE;
|
||||
}
|
||||
|
||||
// no plus or space flag for u, x, X, o, b
|
||||
if ((*format != 'i') && (*format != 'd')) {
|
||||
flags &= ~(FLAGS_PLUS | FLAGS_SPACE);
|
||||
}
|
||||
|
||||
// ignore '0' flag when precision is given
|
||||
if (flags & FLAGS_PRECISION) {
|
||||
flags &= ~FLAGS_ZEROPAD;
|
||||
}
|
||||
|
||||
// convert the integer
|
||||
if ((*format == 'i') || (*format == 'd')) {
|
||||
// signed
|
||||
if (flags & FLAGS_LONG_LONG) {
|
||||
#if defined(PRINTF_SUPPORT_LONG_LONG)
|
||||
const long long value = va_arg(va, long long);
|
||||
idx = _ntoa_long_long(out, buffer, idx, maxlen, (unsigned long long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
|
||||
#endif
|
||||
}
|
||||
else if (flags & FLAGS_LONG) {
|
||||
const long value = va_arg(va, long);
|
||||
idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
|
||||
}
|
||||
else {
|
||||
const int value = (flags & FLAGS_CHAR) ? (char)va_arg(va, int) : (flags & FLAGS_SHORT) ? (short int)va_arg(va, int) : va_arg(va, int);
|
||||
idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned int)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
|
||||
}
|
||||
}
|
||||
else {
|
||||
// unsigned
|
||||
if (flags & FLAGS_LONG_LONG) {
|
||||
#if defined(PRINTF_SUPPORT_LONG_LONG)
|
||||
idx = _ntoa_long_long(out, buffer, idx, maxlen, va_arg(va, unsigned long long), false, base, precision, width, flags);
|
||||
#endif
|
||||
}
|
||||
else if (flags & FLAGS_LONG) {
|
||||
idx = _ntoa_long(out, buffer, idx, maxlen, va_arg(va, unsigned long), false, base, precision, width, flags);
|
||||
}
|
||||
else {
|
||||
const unsigned int value = (flags & FLAGS_CHAR) ? (unsigned char)va_arg(va, unsigned int) : (flags & FLAGS_SHORT) ? (unsigned short int)va_arg(va, unsigned int) : va_arg(va, unsigned int);
|
||||
idx = _ntoa_long(out, buffer, idx, maxlen, value, false, base, precision, width, flags);
|
||||
}
|
||||
}
|
||||
format++;
|
||||
break;
|
||||
}
|
||||
#if defined(PRINTF_SUPPORT_FLOAT)
|
||||
case 'f' :
|
||||
case 'F' :
|
||||
if (*format == 'F') flags |= FLAGS_UPPERCASE;
|
||||
idx = _ftoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
|
||||
format++;
|
||||
break;
|
||||
#if defined(PRINTF_SUPPORT_EXPONENTIAL)
|
||||
case 'e':
|
||||
case 'E':
|
||||
case 'g':
|
||||
case 'G':
|
||||
if ((*format == 'g')||(*format == 'G')) flags |= FLAGS_ADAPT_EXP;
|
||||
if ((*format == 'E')||(*format == 'G')) flags |= FLAGS_UPPERCASE;
|
||||
idx = _etoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
|
||||
format++;
|
||||
break;
|
||||
#endif // PRINTF_SUPPORT_EXPONENTIAL
|
||||
#endif // PRINTF_SUPPORT_FLOAT
|
||||
case 'c' : {
|
||||
unsigned int l = 1U;
|
||||
// pre padding
|
||||
if (!(flags & FLAGS_LEFT)) {
|
||||
while (l++ < width) {
|
||||
out(' ', buffer, idx++, maxlen);
|
||||
}
|
||||
}
|
||||
// char output
|
||||
out((char)va_arg(va, int), buffer, idx++, maxlen);
|
||||
// post padding
|
||||
if (flags & FLAGS_LEFT) {
|
||||
while (l++ < width) {
|
||||
out(' ', buffer, idx++, maxlen);
|
||||
}
|
||||
}
|
||||
format++;
|
||||
break;
|
||||
}
|
||||
|
||||
case 's' : {
|
||||
const char* p = va_arg(va, char*);
|
||||
unsigned int l = _strnlen_s(p, precision ? precision : (size_t)-1);
|
||||
// pre padding
|
||||
if (flags & FLAGS_PRECISION) {
|
||||
l = (l < precision ? l : precision);
|
||||
}
|
||||
if (!(flags & FLAGS_LEFT)) {
|
||||
while (l++ < width) {
|
||||
out(' ', buffer, idx++, maxlen);
|
||||
}
|
||||
}
|
||||
// string output
|
||||
while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision--)) {
|
||||
out(*(p++), buffer, idx++, maxlen);
|
||||
}
|
||||
// post padding
|
||||
if (flags & FLAGS_LEFT) {
|
||||
while (l++ < width) {
|
||||
out(' ', buffer, idx++, maxlen);
|
||||
}
|
||||
}
|
||||
format++;
|
||||
break;
|
||||
}
|
||||
|
||||
case 'p' : {
|
||||
width = sizeof(void*) * 2U;
|
||||
flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE;
|
||||
#if defined(PRINTF_SUPPORT_LONG_LONG)
|
||||
const bool is_ll = sizeof(uintptr_t) == sizeof(long long);
|
||||
if (is_ll) {
|
||||
idx = _ntoa_long_long(out, buffer, idx, maxlen, (uintptr_t)va_arg(va, void*), false, 16U, precision, width, flags);
|
||||
}
|
||||
else {
|
||||
#endif
|
||||
idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)((uintptr_t)va_arg(va, void*)), false, 16U, precision, width, flags);
|
||||
#if defined(PRINTF_SUPPORT_LONG_LONG)
|
||||
}
|
||||
#endif
|
||||
format++;
|
||||
break;
|
||||
}
|
||||
|
||||
case '%' :
|
||||
out('%', buffer, idx++, maxlen);
|
||||
format++;
|
||||
break;
|
||||
|
||||
default :
|
||||
out(*format, buffer, idx++, maxlen);
|
||||
format++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// termination
|
||||
out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
|
||||
|
||||
// return written chars without terminating \0
|
||||
return (int)idx;
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
#include <stddef.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
#pragma pack(push,1)
|
||||
typedef struct {
|
||||
void (*fct)(char character, void* arg);
|
||||
void* arg;
|
||||
} out_fct_wrap_type;
|
||||
#pragma pack(pop)
|
||||
|
||||
typedef void (*out_fct_type)(char character, void* buffer, size_t idx, size_t maxlen);
|
||||
void _out_buffer(char character, void* buffer, size_t idx, size_t maxlen);
|
||||
void _out_null(char character, void* buffer, size_t idx, size_t maxlen);
|
||||
int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const char* format, va_list va);
|
||||
@@ -0,0 +1,403 @@
|
||||
/*
|
||||
function for format read from any source
|
||||
|
||||
Siemargl formats as http://www.cplusplus.com/reference/cstdio/scanf/, no wchar though
|
||||
http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap05.html is used too
|
||||
|
||||
todo:
|
||||
[characters], [^characters]
|
||||
-%n nothing scanned, filled only if good result
|
||||
-%d, i, u, o, x, p read similar - detect base by prefix 0 or 0x
|
||||
-%a
|
||||
-can overflow unsigned as signed
|
||||
-radix point always '.', no LOCALEs
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <math.h>
|
||||
#include <stdarg.h>
|
||||
#include "format_scan.h"
|
||||
|
||||
static int __try_parse_real(long double *real, int ch, const void *src, void *save, virtual_getc vgetc, virtual_ungetc vungetc)
|
||||
// returns 1 if OK, -1 == EOF, -2 parse broken
|
||||
{
|
||||
int sign = 1, have_digits = 0;
|
||||
long long div;
|
||||
|
||||
if (ch == '+')
|
||||
{
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF) return EOF;
|
||||
} else
|
||||
if (ch == '-')
|
||||
{
|
||||
sign = -1;
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF) return EOF;
|
||||
};
|
||||
*real = 0.0;
|
||||
for (;;) // mantissa before point
|
||||
{
|
||||
// test ch is valid
|
||||
if (isdigit(ch))
|
||||
{
|
||||
*real = *real * 10 + ch - '0';
|
||||
have_digits++;
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF || isspace(ch)) break; // ok, just finish num
|
||||
} else
|
||||
if (ch == '.' || ch == 'E' || ch == 'e')
|
||||
{
|
||||
break; // ok
|
||||
}
|
||||
else
|
||||
{
|
||||
vungetc(save, ch, src);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (ch != '.' && ch != 'E' && ch != 'e') // ok, just integer part
|
||||
{
|
||||
*real *= sign;
|
||||
if (have_digits)
|
||||
return 1;
|
||||
else
|
||||
return -2;
|
||||
}
|
||||
|
||||
if(ch == '.')
|
||||
{
|
||||
ch = vgetc(save, src);
|
||||
div = 10; // use as divisor
|
||||
for (;;) // mantissa after point
|
||||
{
|
||||
// test ch is valid
|
||||
if (isdigit(ch))
|
||||
{
|
||||
*real += (double)(ch - '0') / div;
|
||||
div *= 10;
|
||||
have_digits++;
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF || isspace(ch)) break; // ok, just finish num
|
||||
} else
|
||||
if (ch == 'E' || ch == 'e')
|
||||
{
|
||||
break; // ok
|
||||
}
|
||||
else
|
||||
{
|
||||
vungetc(save, ch, src);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (ch != 'E' && ch != 'e') // ok, real as XX.YY
|
||||
{
|
||||
*real *= sign;
|
||||
if (have_digits)
|
||||
return 1;
|
||||
else
|
||||
return -2;
|
||||
}
|
||||
}
|
||||
|
||||
ch = vgetc(save, src);
|
||||
*real *= sign;
|
||||
// exponent
|
||||
sign = 1;
|
||||
if (ch == '+')
|
||||
{
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF) return EOF;
|
||||
} else
|
||||
if (ch == '-')
|
||||
{
|
||||
sign = -1;
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF) return EOF;
|
||||
};
|
||||
div = 0;
|
||||
for (;;)
|
||||
{
|
||||
// test ch is valid
|
||||
if (isdigit(ch))
|
||||
{
|
||||
div = div * 10 + ch - '0';
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF || isspace(ch)) break; // ok, just finish num
|
||||
}
|
||||
else
|
||||
{
|
||||
vungetc(save, ch, src);
|
||||
break;
|
||||
}
|
||||
}
|
||||
div *= sign;
|
||||
*real *= pow(10,div);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int __try_parse_int(long long *digit, int ch, const void *src, void *save, virtual_getc vgetc, virtual_ungetc vungetc)
|
||||
{
|
||||
int sign = 1, base = 10, have_digits = 0;
|
||||
|
||||
if (ch == '+')
|
||||
{
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF) return EOF;
|
||||
} else
|
||||
if (ch == '-')
|
||||
{
|
||||
sign = -1;
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF) return EOF;
|
||||
};
|
||||
|
||||
if (ch == '0') // octal or hex, read next
|
||||
{
|
||||
base = 8;
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF || isspace(ch))
|
||||
have_digits++;
|
||||
else
|
||||
if (ch == 'x' || ch == 'X')
|
||||
{
|
||||
base = 16;
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF) return EOF;
|
||||
}
|
||||
}
|
||||
*digit = 0;
|
||||
for (;;)
|
||||
{
|
||||
// test ch is valid
|
||||
if ((isdigit(ch) && base == 10) ||
|
||||
(isdigit(ch) && base == 8 && ch < '8') ||
|
||||
(isxdigit(ch) && base == 16))
|
||||
{
|
||||
if (base == 16)
|
||||
{
|
||||
if (ch <= '9') ch-= '0';
|
||||
else
|
||||
if (ch <= 'F') ch = 10 + ch - 'A';
|
||||
else
|
||||
ch = 10 + ch - 'a';
|
||||
}
|
||||
else
|
||||
ch -= '0';
|
||||
*digit = *digit * base + ch;
|
||||
have_digits++;
|
||||
ch = vgetc(save, src);
|
||||
if (ch == EOF || isspace(ch)) break; // ok, just finish num
|
||||
}
|
||||
else if (ch == EOF || isspace(ch))
|
||||
break;
|
||||
else
|
||||
{
|
||||
vungetc(save, ch, src);
|
||||
break;
|
||||
}
|
||||
}
|
||||
*digit *= sign;
|
||||
if (have_digits)
|
||||
return 1;
|
||||
else
|
||||
return -2;
|
||||
}
|
||||
|
||||
|
||||
|
||||
int _format_scan(const void *src, const char *fmt, va_list argp, virtual_getc vgetc, virtual_ungetc vungetc)
|
||||
{
|
||||
int i;
|
||||
int length;
|
||||
int fmt1, fmt2; // width, precision
|
||||
size_t pos, posc;
|
||||
const char *fmtc; // first point to %, fmtc points to specifier
|
||||
int ch;
|
||||
int format_flag;
|
||||
int flag_long; // 2 = long double or long long int or wchar
|
||||
int *point_to_n = NULL, nread = 0;
|
||||
int flags; // parsed flags
|
||||
int save = 0;
|
||||
char *arg_str;
|
||||
int *arg_int;
|
||||
long *arg_long;
|
||||
long long *arg_longlong;
|
||||
float *arg_float;
|
||||
double *arg_double;
|
||||
long double *arg_longdouble;
|
||||
long long digit;
|
||||
long double real;
|
||||
|
||||
|
||||
pos = 0;
|
||||
while(*fmt)
|
||||
{
|
||||
while (*fmt && isspace(*fmt)) fmt++; // skip paces in format str
|
||||
|
||||
if (*fmt != '%') // usual char
|
||||
{
|
||||
ch = vgetc(&save, src);
|
||||
if (ch != *fmt++) // char not match format
|
||||
{
|
||||
vungetc(&save, ch, src);
|
||||
break;
|
||||
}
|
||||
pos++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (*(fmt + 1) == '%') // %%
|
||||
{
|
||||
ch = vgetc(&save, src);
|
||||
if (ch != '%') // char not match format
|
||||
{
|
||||
vungetc(&save, ch, src);
|
||||
break;
|
||||
}
|
||||
pos++;
|
||||
fmt += 2;
|
||||
continue;
|
||||
}
|
||||
//checking to containg format in the string
|
||||
fmtc = fmt;
|
||||
posc = pos;
|
||||
|
||||
flags = 0;
|
||||
format_flag = 0;
|
||||
flag_long = 0; // 2 = long double or long long int or wchar
|
||||
|
||||
while(*fmtc != '\0' && !format_flag) // searching end of format
|
||||
{
|
||||
fmtc++; posc++;
|
||||
switch( *fmtc )
|
||||
{
|
||||
case 'a':
|
||||
format_flag = 1;
|
||||
flags |= flag_unsigned;
|
||||
break;
|
||||
case 'c': case 'd': case 'i': case 'e': case 'f': case 'g': case 's': case 'n':
|
||||
format_flag = 1;
|
||||
break;
|
||||
case 'l':
|
||||
flag_long = flag_long ? 2 : 1; // ll.eq.L
|
||||
break;
|
||||
case 'L':
|
||||
flag_long = 2;
|
||||
break;
|
||||
case 'o': case 'u': case 'x': case 'p':
|
||||
format_flag = 1;
|
||||
flags |= flag_unsigned;
|
||||
break;
|
||||
case '*': case '.': // just skip
|
||||
break;
|
||||
default:
|
||||
if(isdigit(*fmtc)) break;
|
||||
goto exit_me; // non format char found - user error
|
||||
}
|
||||
}
|
||||
|
||||
if (format_flag == 0)
|
||||
{
|
||||
goto exit_me; // format char not found - user error
|
||||
}
|
||||
|
||||
fmt1 = 0;
|
||||
fmt2 = 0;
|
||||
if (posc - pos > 1) // try to read width, precision
|
||||
{
|
||||
fmt++;
|
||||
for(i = pos + 1; i < posc; i++)
|
||||
{
|
||||
switch(*fmt)
|
||||
{
|
||||
case '0':
|
||||
if(fmt1 == 0 && (flags & flag_point) == 0) flags |= flag_lead_zeros;
|
||||
case '1': case '2': case '3': case '4':
|
||||
case '5': case '6': case '7': case '8': case '9':
|
||||
if ((flags & flag_point) == 0)
|
||||
fmt1 = fmt1 * 10 + (*fmt -'0');
|
||||
else
|
||||
fmt2 = fmt2 * 10 + (*fmt -'0');
|
||||
break;
|
||||
case '*': // ignoring
|
||||
break;
|
||||
case '.':
|
||||
flags |= flag_point;
|
||||
break;
|
||||
case 'l': case 'L': // valid chars - skip
|
||||
break;
|
||||
default: // must be error
|
||||
goto exit_me; // format char not found - user error
|
||||
}
|
||||
fmt++;
|
||||
}
|
||||
}
|
||||
|
||||
// do real work - format arguments values
|
||||
// skip input spaces
|
||||
do {
|
||||
ch = vgetc(&save, src);
|
||||
if (ch == EOF) goto exit_me;
|
||||
} while (isspace(ch));
|
||||
|
||||
switch(*fmtc)
|
||||
{
|
||||
case 'n':
|
||||
point_to_n = va_arg(argp, int*);
|
||||
vungetc(&save, ch, src);
|
||||
break;
|
||||
case 'c': // read width chars, ever spaces
|
||||
arg_str = va_arg(argp, char*);
|
||||
if (fmt1 == 0) length = 1;
|
||||
else length = fmt1;
|
||||
for (i = 0; i < length;)
|
||||
{
|
||||
*arg_str++ = ch; i++;
|
||||
ch = vgetc(&save, src);
|
||||
if (ch == EOF) break;
|
||||
}
|
||||
if (i < length) goto exit_me; // not enough chars
|
||||
break;
|
||||
case 's':
|
||||
arg_str = va_arg(argp, char*);
|
||||
if (fmt1 == 0) length = STDIO_MAX_MEM; // max string scan 4096
|
||||
else length = fmt1;
|
||||
for (i = 0; i < length; i++)
|
||||
{
|
||||
*arg_str++ = ch;
|
||||
ch = vgetc(&save, src);
|
||||
if (ch == EOF || isspace(ch)) break; // ok, just finish string
|
||||
}
|
||||
*arg_str++ = '\0';
|
||||
break;
|
||||
case 'd': case 'i': case 'u':
|
||||
case 'o': case 'p': case 'x':
|
||||
i = __try_parse_int(&digit, ch, src, &save, vgetc, vungetc);
|
||||
if (i < 0) goto exit_me;
|
||||
|
||||
if (flag_long == 0) { arg_int = va_arg(argp, int*); *arg_int = (int)digit; } else
|
||||
if (flag_long == 1) { arg_long = va_arg(argp, long*); *arg_long = (long)digit; } else
|
||||
if (flag_long == 2) { arg_longlong = va_arg(argp, long long*); *arg_longlong = digit; }
|
||||
break;
|
||||
case 'a': case 'A': case 'f': case 'F':
|
||||
case 'e': case 'E':
|
||||
case 'g': case 'G':
|
||||
i = __try_parse_real(&real, ch, src, &save, vgetc, vungetc);
|
||||
if (i < 0) goto exit_me;
|
||||
|
||||
if (flag_long == 0) { arg_float = va_arg(argp, float*); *arg_float = (float)real; } else
|
||||
if (flag_long == 1) { arg_double = va_arg(argp, double*); *arg_double = (double)real; } else
|
||||
if (flag_long == 2) { arg_longdouble = va_arg(argp, long double*); *arg_longdouble = real; }
|
||||
break;
|
||||
}
|
||||
|
||||
fmt = fmtc + 1;
|
||||
nread++;
|
||||
}
|
||||
exit_me:
|
||||
if (point_to_n) *point_to_n = nread;
|
||||
return nread;
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
#include <stdio.h>
|
||||
|
||||
typedef int (*virtual_getc)(void *sp, const void *obj);
|
||||
typedef void (*virtual_ungetc)(void *sp, int c, const void *obj);
|
||||
|
||||
enum flags_t
|
||||
{
|
||||
flag_unsigned = 0x02,
|
||||
flag_register = 0x04,
|
||||
flag_plus = 0x08,
|
||||
flag_left_just = 0x10,
|
||||
flag_lead_zeros = 0x20,
|
||||
flag_space_plus = 0x40,
|
||||
flag_hash_sign = 0x80,
|
||||
flag_point = 0x100
|
||||
};
|
||||
|
||||
char *__scanf_buffer;
|
||||
|
||||
extern int _format_scan(const void *src, const char *fmt, va_list argp, virtual_getc vgetc, virtual_ungetc vungetc);
|
||||
@@ -0,0 +1,14 @@
|
||||
|
||||
#include "sys/ksys.h"
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
int fprintf(FILE *restrict f, const char *restrict fmt, ...)
|
||||
{
|
||||
int ret;
|
||||
va_list ap;
|
||||
va_start(ap, fmt);
|
||||
ret = vfprintf(f, fmt, ap);
|
||||
va_end(ap);
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <sys/ksys.h>
|
||||
|
||||
int fputc(int c, FILE *stream)
|
||||
{
|
||||
if(fwrite(&c, sizeof(int), 1, stream)==1){
|
||||
return c;
|
||||
}else{
|
||||
return EOF;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
int fputs(const char *str, FILE *stream){
|
||||
return fwrite(str, sizeof(char), strlen(str), stream);
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
#include <stdio.h>
|
||||
|
||||
size_t fread(void *restrict ptr, size_t size, size_t nmemb, FILE *restrict stream) {
|
||||
unsigned bytes_read = 0;
|
||||
unsigned bytes_count = size * nmemb;
|
||||
|
||||
for (size_t i = 0; i < bytes_count; i++) {
|
||||
char c = fgetc(stream);
|
||||
|
||||
if (c == EOF) {
|
||||
break;
|
||||
}
|
||||
|
||||
*(char*)(ptr+i) = c;
|
||||
|
||||
bytes_read++;
|
||||
}
|
||||
|
||||
return bytes_read / size;
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
#include "sys/ksys.h"
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
FILE *freopen(const char *restrict _name, const char *restrict _mode, FILE *restrict out) {
|
||||
static ksys_bdfe_t info;
|
||||
info.size=0;
|
||||
if (!out) {
|
||||
errno = ENOMEM;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
_ksys_file_get_info(_name, &info);
|
||||
|
||||
out->name = strdup(_name);
|
||||
out->position = 0;
|
||||
out->error = 0;
|
||||
out->eof = 0;
|
||||
out->kind = 0;
|
||||
out->orientation = 0;
|
||||
out->mode = 0;
|
||||
out->start_size = info.size;
|
||||
|
||||
if (strchr(_mode, 'b')) { out->mode |= _STDIO_F_B; }
|
||||
if (strchr(_mode, 'x')) { out->mode |= _STDIO_F_X; }
|
||||
if (strchr(_mode, 'a')) { out->mode |= _STDIO_F_A; }
|
||||
if (strchr(_mode, 'r')) { out->mode |= _STDIO_F_R; }
|
||||
if (strchr(_mode, 'w')) { out->mode |= _STDIO_F_W; }
|
||||
if (strchr(_mode, '+')) { out->mode |= _STDIO_F_R | _STDIO_F_W; }
|
||||
|
||||
if (out->mode & _STDIO_F_A) {
|
||||
out->position = info.size;
|
||||
out->append_offset = info.size;
|
||||
} else if(out->mode & _STDIO_F_W){
|
||||
if(_ksys_file_create(_name)){
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
#include <stdio.h>
|
||||
|
||||
int fscanf(FILE* stream, const char* format, ...)
|
||||
{
|
||||
va_list arg;
|
||||
int n;
|
||||
va_start(arg, format);
|
||||
n = vfscanf(stream, format, arg);
|
||||
va_end(arg);
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
#include <stdio.h>
|
||||
#include <sys/ksys.h>
|
||||
|
||||
int fseek(FILE *stream, long int offset, int whence) {
|
||||
if (whence == SEEK_SET) {
|
||||
stream->position = offset;
|
||||
} else if (whence == SEEK_CUR) {
|
||||
stream->position += offset;
|
||||
} else if (whence == SEEK_END) {
|
||||
ksys_bdfe_t info;
|
||||
if (_ksys_file_get_info(stream->name, &info)) {
|
||||
return -1;
|
||||
}
|
||||
stream->position = info.size + offset;
|
||||
}
|
||||
stream->eof = 0;
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
#include <stdio.h>
|
||||
|
||||
int fsetpos(FILE *stream, const fpos_t *pos) {
|
||||
stream->position = *pos;
|
||||
stream->eof = 0;
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
#include <stdio.h>
|
||||
|
||||
long int ftell(FILE *stream) {
|
||||
return stream->position;
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
#include <stdio.h>
|
||||
#include "conio.h"
|
||||
#include <sys/ksys.h>
|
||||
#include <errno.h>
|
||||
|
||||
|
||||
size_t fwrite(const void *restrict ptr, size_t size, size_t nmemb, FILE *restrict stream) {
|
||||
unsigned bytes_written = 0;
|
||||
unsigned bytes_count = size * nmemb;
|
||||
|
||||
if(!stream){
|
||||
errno = EINVAL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if(stream==stdout){
|
||||
__con_init();
|
||||
__con_write_string((char*)ptr, bytes_count);
|
||||
return nmemb;
|
||||
}
|
||||
else if(stream==stderr){
|
||||
for (size_t i = 0; i < bytes_count; i++) {
|
||||
char c = *(char*)(ptr+i);
|
||||
_ksys_debug_putc(c);
|
||||
}
|
||||
}
|
||||
else{
|
||||
if(stream->mode != _STDIO_F_R){
|
||||
unsigned status = _ksys_file_write_file(stream->name, stream->position, bytes_count, ptr, &bytes_written);
|
||||
if (status != KSYS_FS_ERR_SUCCESS) {
|
||||
errno = EIO;
|
||||
stream->error = errno;
|
||||
return 0;
|
||||
}else {
|
||||
stream->position+=bytes_written;
|
||||
}
|
||||
}
|
||||
}
|
||||
return bytes_written;
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
#include <stdio.h>
|
||||
#include "conio.h"
|
||||
|
||||
int getchar(void) {
|
||||
int c = __con_getch();
|
||||
if (c == 0) {
|
||||
c = EOF;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "conio.h"
|
||||
#include <errno.h>
|
||||
#include <limits.h>
|
||||
|
||||
char *gets(char* str)
|
||||
{
|
||||
__con_init();
|
||||
if(__con_gets(str, STDIO_MAX_MEM)==NULL){
|
||||
errno = EIO;
|
||||
return NULL;
|
||||
}
|
||||
str[strlen(str)-1]='\0';
|
||||
return str;
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
#include <stdio.h>
|
||||
|
||||
void perror(const char *s) {
|
||||
debug_printf("%s: It's some error, maybe...\n", s);
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
//#include "format_print.h"
|
||||
|
||||
int printf(const char *format, ...)
|
||||
{
|
||||
va_list arg;
|
||||
va_start(arg, format);
|
||||
return vprintf(format, arg);
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "conio.h"
|
||||
#include "sys/ksys.h"
|
||||
|
||||
int puts(const char *str)
|
||||
{
|
||||
__con_init();
|
||||
__con_write_asciiz(str);
|
||||
__con_write_asciiz("\n");
|
||||
return strlen(str);
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
#include <stdio.h>
|
||||
#include <sys/ksys.h>
|
||||
|
||||
int remove(const char *name) {
|
||||
return _ksys_file_delete(name);
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
#include <stdio.h>
|
||||
#include <sys/ksys.h>
|
||||
|
||||
int rename(const char *name, const char *new_name) {
|
||||
return _ksys_file_rename(name, new_name);
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
#include <stdio.h>
|
||||
|
||||
void rewind(FILE *stream) {
|
||||
stream->position = 0;
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
//#include "format_scan.h"
|
||||
#include <stdlib.h>
|
||||
#include <errno.h>
|
||||
|
||||
int scanf ( const char * format, ...)
|
||||
{
|
||||
va_list arg;
|
||||
int n;
|
||||
va_start(arg, format);
|
||||
|
||||
if(__scanf_buffer == NULL) __scanf_buffer = malloc(STDIO_MAX_MEM);
|
||||
if(__scanf_buffer == NULL) errno = ENOMEM; return ENOMEM;
|
||||
|
||||
*__scanf_buffer = 0;
|
||||
n = vscanf(format, arg);
|
||||
|
||||
va_end(arg);
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
#include <stdio.h>
|
||||
|
||||
void setbuf(FILE *restrict stream, char *restrict buf) {
|
||||
return;
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
#include <stdio.h>
|
||||
|
||||
int setvbuf(FILE *restrict stream, char *restrict buf, int mode, size_t size) {
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
|
||||
|
||||
//#include "format_print.h"
|
||||
#include <stdio.h>
|
||||
|
||||
int snprintf(char* buffer, size_t count, const char* format, ...)
|
||||
{
|
||||
va_list va;
|
||||
va_start(va, format);
|
||||
const int ret = _vsnprintf(_out_buffer, buffer, count, format, va);
|
||||
va_end(va);
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
|
||||
|
||||
//#include "format_print.h"
|
||||
#include <stdio.h>
|
||||
|
||||
int sprintf(char* buffer, const char* format, ...)
|
||||
{
|
||||
va_list va;
|
||||
va_start(va, format);
|
||||
const int ret = _vsnprintf(_out_buffer, buffer, (size_t)-1, format, va);
|
||||
va_end(va);
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
#include <stdio.h>
|
||||
|
||||
int sscanf(const char * s, const char * format, ...)
|
||||
{
|
||||
va_list arg;
|
||||
int n;
|
||||
va_start(arg, format);
|
||||
n = vsscanf(s, format, arg);
|
||||
va_end(arg);
|
||||
return n;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
#include <stdio.h>
|
||||
|
||||
FILE *tmpfile(void) {
|
||||
char name[FILENAME_MAX + 1];
|
||||
|
||||
if (!tmpnam(name)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return fopen(name, "wb+");
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
#include <stdio.h>
|
||||
#include <sys/ksys.h>
|
||||
#include <string.h>
|
||||
|
||||
static char buf[FILENAME_MAX + 1];
|
||||
static int static_index = 0;
|
||||
|
||||
char *tmpnam(char *name) {
|
||||
ksys_proc_table_t table;
|
||||
_ksys_process_info(&table, -1);
|
||||
|
||||
char *out = name ? name : buf;
|
||||
// PID is also unique for each thread
|
||||
sprintf(out, "/tmp0/1/%x_%x.tmp", table.pid, static_index++);
|
||||
return out;
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <limits.h>
|
||||
|
||||
int vfprintf(FILE * file, const char *format, va_list arg)
|
||||
{
|
||||
static char *buf=NULL;
|
||||
int printed=0, rc = 0;
|
||||
|
||||
if(!file){
|
||||
errno = EBADF;
|
||||
return errno;
|
||||
}
|
||||
if(!format){
|
||||
errno = EINVAL;
|
||||
return errno;
|
||||
}
|
||||
|
||||
buf = malloc(STDIO_MAX_MEM);
|
||||
|
||||
if(!buf){
|
||||
errno = ENOMEM;
|
||||
return errno;
|
||||
}
|
||||
|
||||
printed = vsnprintf(buf, STDIO_MAX_MEM, format,arg);
|
||||
rc = fwrite(buf, sizeof(char), printed, file);
|
||||
free(buf);
|
||||
return rc;
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
//#include "format_scan.h"
|
||||
#include <errno.h>
|
||||
|
||||
// non standard realization - support for virtually change ONLY ONE char
|
||||
|
||||
static int __ungetc_emu(int c, FILE* stream)
|
||||
{
|
||||
unsigned res;
|
||||
if(stream){
|
||||
errno = EINVAL;
|
||||
return EOF;
|
||||
}
|
||||
if ((stream->mode & 3) != _STDIO_F_R && (stream->mode & _STDIO_F_A) == 0){
|
||||
errno = EACCES;
|
||||
return EOF;
|
||||
}
|
||||
ksys_bdfe_t *file_info = malloc(sizeof(ksys_bdfe_t));
|
||||
if(file_info==NULL){
|
||||
errno = ENOMEM;
|
||||
return EOF;
|
||||
}
|
||||
if(!_ksys_file_get_info(stream->name, file_info)){
|
||||
errno = ENFILE;
|
||||
return EOF;
|
||||
}
|
||||
if (stream->position > file_info->size || stream->position == 0 || c == EOF || stream->__ungetc_emu_buff != EOF){
|
||||
errno = EOF;
|
||||
return EOF;
|
||||
}
|
||||
|
||||
stream->__ungetc_emu_buff = c;
|
||||
stream->position --;
|
||||
return c;
|
||||
}
|
||||
|
||||
static int __virtual_getc_file(void *sp, const void *obj)
|
||||
{
|
||||
FILE *f = (FILE *)obj;
|
||||
int ch = fgetc(f);
|
||||
return ch;
|
||||
}
|
||||
|
||||
static void __virtual_ungetc_file(void *sp, int c, const void *obj)
|
||||
{
|
||||
FILE *f = (FILE *)obj;
|
||||
if (f) __ungetc_emu(c, f);
|
||||
}
|
||||
|
||||
int vfscanf(FILE * stream, const char * format, va_list arg)
|
||||
{
|
||||
return _format_scan(stream, format, arg, &__virtual_getc_file, &__virtual_ungetc_file);
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "conio.h"
|
||||
#include <sys/ksys.h>
|
||||
#include <errno.h>
|
||||
#include <limits.h>
|
||||
//#include "format_print.h"
|
||||
|
||||
int vprintf ( const char * format, va_list arg )
|
||||
{
|
||||
int len = 0;
|
||||
char *s = malloc(STDIO_MAX_MEM);
|
||||
if(!s){
|
||||
errno = ENOMEM;
|
||||
return errno;
|
||||
}
|
||||
__con_init();
|
||||
len = vsnprintf(s, STDIO_MAX_MEM, format, arg);
|
||||
__con_write_string(s, len);
|
||||
free(s);
|
||||
return(len);
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
#include <string.h>
|
||||
|
||||
char *__scanf_buffer=NULL;
|
||||
typedef int (*virtual_getc)(void *sp, const void *obj);
|
||||
typedef void (*virtual_ungetc)(void *sp, int c, const void *obj);
|
||||
|
||||
char *__scanf_buffer;
|
||||
|
||||
extern int _format_scan(const void *src, const char *fmt, va_list argp, virtual_getc vgetc, virtual_ungetc vungetc);
|
||||
|
||||
static int __virtual_getc_con(void *sp, const void *obj)
|
||||
// get next chat from string obj, save point is ptr to string char ptr
|
||||
{
|
||||
int ch;
|
||||
const char**spc= (const char**)sp;
|
||||
if (!spc) return EOF; // error
|
||||
if (!*spc) *spc = __scanf_buffer; // first call, init savepoint
|
||||
|
||||
while (!**spc) // need to read more
|
||||
{
|
||||
if(!gets(__scanf_buffer)) return EOF;
|
||||
*spc = __scanf_buffer;
|
||||
strcat(__scanf_buffer,"\n"); // imitate delimiter
|
||||
}
|
||||
if (**spc == 26 || **spc == 3) // ^C ^Z end of scan, clear buffer
|
||||
{
|
||||
*spc = __scanf_buffer;
|
||||
*__scanf_buffer = 0;
|
||||
return EOF; // ^C ^Z
|
||||
}
|
||||
|
||||
ch = **spc; (*spc)++ ;
|
||||
return ch;
|
||||
}
|
||||
|
||||
static void __virtual_ungetc_con(void *sp, int c, const void *obj)
|
||||
// if can, one step back savepoint in s
|
||||
{
|
||||
const char**spc= (const char**)sp;
|
||||
|
||||
if (spc && *spc > __scanf_buffer) (*spc)--;
|
||||
//printf("Ungetc '%c'[%d];", c, c);
|
||||
}
|
||||
|
||||
|
||||
int vscanf(const char * format, va_list arg)
|
||||
{
|
||||
return _format_scan(NULL, format, arg, &__virtual_getc_con, &__virtual_ungetc_con);
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
//#include "format_print.h"
|
||||
|
||||
int vsnprintf(char* buffer, size_t count, const char* format, va_list va)
|
||||
{
|
||||
return _vsnprintf(_out_buffer, buffer, count, format, va);
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
//#include "format_scan.h"
|
||||
|
||||
static int __virtual_getc_str(void *sp, const void *obj)
|
||||
// get next chat from string obj, save point is ptr to string char ptr
|
||||
{
|
||||
int ch;
|
||||
const char *s = (const char *)obj;
|
||||
const char**spc= (const char**)sp;
|
||||
if (!s || !spc) return EOF; // error
|
||||
|
||||
if (!*spc) *spc = s; // first call, init savepoint
|
||||
|
||||
if (!**spc) return EOF; // EOS
|
||||
|
||||
ch = **spc; (*spc)++ ;
|
||||
|
||||
return ch;
|
||||
}
|
||||
|
||||
void __virtual_ungetc_str(void *sp, int c, const void *obj)
|
||||
// if can, one step back savepoint in s
|
||||
{
|
||||
const char *s = (const char *)obj;
|
||||
const char**spc= (const char**)sp;
|
||||
|
||||
if (s && spc && *spc > s) (*spc)--;
|
||||
}
|
||||
|
||||
int vsscanf(const char * s, const char * format, va_list arg)
|
||||
{
|
||||
return _format_scan(s, format, arg, &__virtual_getc_str, &__virtual_ungetc_str);
|
||||
};
|
||||
@@ -0,0 +1 @@
|
||||
void ___chkstk_ms() {}
|
||||
@@ -0,0 +1,6 @@
|
||||
#include <stdlib.h>
|
||||
|
||||
int abs(int a)
|
||||
{
|
||||
return a>0 ? a : -a;
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
|
||||
/*
|
||||
** atoi(s) - convert s to integer.
|
||||
*/
|
||||
int atoi(const char *s)
|
||||
{
|
||||
int sign, n;
|
||||
while(isspace(*s)) ++s;
|
||||
sign = 1;
|
||||
|
||||
switch(*s) {
|
||||
case '-': sign = -1;
|
||||
case '+': ++s;
|
||||
}
|
||||
|
||||
n = 0;
|
||||
while(isdigit(*s)) n = 10 * n + *s++ - '0';
|
||||
return (sign * n);
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
|
||||
long atol(const char *s)
|
||||
{
|
||||
long n=0;
|
||||
int neg=0;
|
||||
while (isspace(*s)) s++;
|
||||
switch (*s) {
|
||||
case '-': neg=1;
|
||||
case '+': s++;
|
||||
}
|
||||
/* Compute n as a negative number to avoid overflow on LONG_MIN */
|
||||
while (isdigit(*s))
|
||||
n = 10*n - (*s++ - '0');
|
||||
return neg ? n : -n;
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
|
||||
long long atoll(const char *s)
|
||||
{
|
||||
long long n=0;
|
||||
int neg=0;
|
||||
while (isspace(*s)) s++;
|
||||
switch (*s) {
|
||||
case '-': neg=1;
|
||||
case '+': s++;
|
||||
}
|
||||
/* Compute n as a negative number to avoid overflow on LLONG_MIN */
|
||||
while (isdigit(*s))
|
||||
n = 10*n - (*s++ - '0');
|
||||
return neg ? n : -n;
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
#include <stdlib.h>
|
||||
#include <sys/ksys.h>
|
||||
|
||||
void *calloc(size_t num, size_t size) {
|
||||
return _ksys_alloc(num*size);
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
#include <time.h>
|
||||
|
||||
double difftime (time_t end, time_t beginning)
|
||||
{
|
||||
return end - beginning;
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
#include <stdlib.h>
|
||||
|
||||
div_t div(int num, int den)
|
||||
{
|
||||
return (div_t){ num/den, num%den };
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
|
||||
|
||||
#include "../stdio/conio.h"
|
||||
#include <sys/ksys.h>
|
||||
|
||||
void exit(int status)
|
||||
{
|
||||
if(__con_is_load){
|
||||
__con_exit(status);
|
||||
}
|
||||
_ksys_exit();
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user