BlueGreycalmElegant

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /programs/develop/ @ 8792

  → /programs/develop/ @ 8793

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

No changes between revisions

Regard whitespace Rev 8792 → Rev 8793

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fseek.c
0,0 → 1,18
#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;
return 0;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/conio.c
0,0 → 1,81
#include <sys/ksys.h>
#include <conio.h>
#include "stdio.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, unsigned wnd_height, int scr_width, int scr_height, const char* title);
void stdcall (*con_exit)(int);
void stdcall (*con_set_title)(const char* title);
void stdcall (*con_write_asciiz)(const char* str);
void stdcall (*con_write_string)(const char* str, dword length);
int cdecl (*con_printf)(const char* format, ...);
dword stdcall (*con_get_flags)(void);
dword stdcall (*con_set_flags)(dword new_flags);
int stdcall (*con_get_font_height)(void);
int stdcall (*con_get_cursor_height)(void);
int stdcall (*con_set_cursor_height)(int new_height);
int stdcall (*con_getch)(void);
word 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_cls)();
void stdcall (*con_get_cursor_pos)(int* px, int* py);
void stdcall (*con_set_cursor_pos)(int x, int y);
static void __con_panic(char* func_name)
{
debug_printf("In console.obj %s=NULL!\n", func_name);
_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_exit = _ksys_get_coff_func(exp, "con_exit", __con_panic);
con_set_title = _ksys_get_coff_func(exp, "con_set_title", __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_printf = _ksys_get_coff_func(exp, "con_printf", __con_panic);
con_get_flags = _ksys_get_coff_func(exp, "con_get_flags", __con_panic);
con_set_flags = _ksys_get_coff_func(exp, "con_set_flags", __con_panic);
con_get_font_height = _ksys_get_coff_func(exp, "con_get_font_height", __con_panic);
con_get_cursor_height = _ksys_get_coff_func(exp, "con_get_cursor_height", __con_panic);
con_set_cursor_height = _ksys_get_coff_func(exp, "con_set_cursor_height", __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_cls = _ksys_get_coff_func(exp, "con_cls", __con_panic);
con_get_cursor_pos = _ksys_get_coff_func(exp, "con_get_cursor_pos", __con_panic);
con_set_cursor_pos = _ksys_get_coff_func(exp, "con_set_cursor_pos", __con_panic);
}
int con_init_opt(dword wnd_width, dword wnd_height, dword scr_width, dword 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;
}
int con_init(void)
{
return con_init_opt(-1, -1, -1, -1, __con_caption);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fread.c
0,0 → 1,38
#include <stdio.h>
#include <errno.h>
#include "conio.h"
#include "sys/ksys.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;
if(!stream){
errno = EBADF;
return 0;
}
if(stream==stdin){
con_init();
con_gets((char*)ptr, bytes_count+1);
return nmemb;
}
else{
if(stream->mode & _FILEMODE_R){
if(!stream->__ungetc_emu_buff){
((char*) ptr)[0]=(char)stream->__ungetc_emu_buff;
//debug_printf("Ungetc: %x\n", ((char*) ptr)[0]);
}
unsigned status = _ksys_file_read_file(stream->name, stream->position, bytes_count, ptr , &bytes_read);
if (status) {
errno = EIO;
stream->error = errno;
return 0;
}else {
stream->position+=bytes_read;
}
}
}
return bytes_read;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fwrite.c
0,0 → 1,39
#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 = EBADF;
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 != _FILEMODE_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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/getchar.c
0,0 → 1,12
#include <stdio.h>
#include <conio.h>
int getchar(void) {
con_init();
char c = 0;
con_gets(&c, 2);
if (c == 0) {
c = EOF;
}
return c;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/gets.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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/puts.c
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);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/vprintf.c
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);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fgetc.c
0,0 → 1,11
#include <stdio.h>
int fgetc(FILE* stream)
{
int c=0;
if(fread(&c, sizeof(char), 1, stream)==1){
return c;
}else{
return EOF;
}
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fputc.c
0,0 → 1,12
#include <stdio.h>
#include <errno.h>
#include <sys/ksys.h>
int fputc(int c, FILE *stream)
{
if(fwrite(&c, sizeof(char), 1, stream)==1){
return c;
}else{
return EOF;
}
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fputs.c
0,0 → 1,11
#include <stdio.h>
#include <string.h>
int fputs(const char *str, FILE *stream){
size_t str_len = strlen(str);
if(str_len == fwrite(str, sizeof(char), str_len , stream)){
return str[str_len-1];
}else{
return EOF;
}
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/freopen.c
0,0 → 1,53
#include "stddef.h"
#include "sys/ksys.h"
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define CREATE_FILE() if(_ksys_file_create(_name)){ \
errno= EIO; \
free(out); \
out = NULL; \
}
FILE *freopen(const char *restrict _name, const char *restrict _mode, FILE *restrict out) {
if(!_name || !_mode || !out){
errno = EINVAL;
return NULL;
}
if (strchr(_mode, 'r')) { out->mode = _FILEMODE_R; }
if (strchr(_mode, 'a')) { out->mode = _FILEMODE_A; }
if (strchr(_mode, 'w')) { out->mode = _FILEMODE_W; }
ksys_bdfe_t info;
int no_file = _ksys_file_get_info(_name, &info);
out->eof=0;
out->error=0;
out->position=0;
out->name = strdup(_name);
switch (out->mode) {
case _FILEMODE_A :
if(no_file){
CREATE_FILE();
}
out->position = info.size;
break;
case _FILEMODE_W :
CREATE_FILE();
break;
case _FILEMODE_R :
if(no_file){
free(out);
out = NULL;
}
break;
default:
free(out);
out = NULL;
break;
}
return out;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/ungetc.c
0,0 → 1,28
#include <stdio.h>
#include <errno.h>
// non standard realization - support for virtually change ONLY ONE char
int ungetc(int c, FILE* file)
{
int res;
if(!file){
errno = EBADF;
return EOF;
}
if (file->mode != _FILEMODE_R){
errno = EACCES;
return EOF;
}
if (file->position == 0 || c == EOF)
{
errno = EOF;
return EOF;
}
file->__ungetc_emu_buff = c;
file->position--;
return c;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/format_scan.c
0,0 → 1,418
/*
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>
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
};
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;
}
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 = 4095; // 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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fscanf.c
0,0 → 1,42
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
int virtual_getc_file(void *sp, const void *obj)
// get next chat from file obj, save point is ptr to string char ptr
{
FILE *f = (FILE *)obj;
int ch = fgetc(f);
//printf("getc '%c'[%d];", ch, ch);
return ch;
}
void virtual_ungetc_file(void *sp, int c, const void *obj)
// if can, one step back savepoint in s
{
FILE *f = (FILE *)obj;
if (f) ungetc(c, f);
}
int vfscanf ( FILE * stream, const char * format, va_list arg )
{
return format_scan(stream, format, arg, &virtual_getc_file, &virtual_ungetc_file);
};
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/scanf.c
0,0 → 1,65
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
char *__scanf_buffer = 0;
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)++ ;
//printf("getc '%c'[%d];", ch, ch);
return ch;
}
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);
};
int scanf ( const char * format, ...)
{
va_list arg;
int n;
va_start(arg, format);
if(__scanf_buffer == NULL) __scanf_buffer = malloc(4096);
if(__scanf_buffer == NULL) return -3;
*__scanf_buffer = 0;
n = vscanf(format, arg);
va_end(arg);
return n;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/sscanf.c
0,0 → 1,46
#include <stdio.h>
#include <stdarg.h>
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);
};
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/clearerr.c
0,0 → 1,6
#include <stdio.h>
void clearerr(FILE *stream) {
stream->error = 0;
stream->eof = 0;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/debug_printf.c
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);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fclose.c
0,0 → 1,7
#include <stdio.h>
#include <stdlib.h>
int fclose(FILE *stream) {
free(stream);
return 0;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/feof.c
0,0 → 1,5
#include <stdio.h>
int feof(FILE *stream) {
return stream->eof;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/ferror.c
0,0 → 1,5
#include <stdio.h>
int ferror(FILE *stream) {
return stream->error;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fflush.c
0,0 → 1,5
#include <stdio.h>
int fflush(FILE *stream) {
return 0;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fgetpos.c
0,0 → 1,6
#include <stdio.h>
int fgetpos(FILE *restrict stream, fpos_t *restrict pos) {
*pos = stream->position;
return 0;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fgets.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fopen.c
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);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/format_print.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/format_print.h
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);

/programs/develop/ktcc/trunk/libc.obj/source/stdio/format_scan.h
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);

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fprintf.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/fsetpos.c
0,0 → 1,7
#include <stdio.h>
int fsetpos(FILE *stream, const fpos_t *pos) {
stream->position = *pos;
stream->eof = 0;
return 0;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/ftell.c
0,0 → 1,5
#include <stdio.h>
long int ftell(FILE *stream) {
return stream->position;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/perror.c
0,0 → 1,5
#include <stdio.h>
void perror(const char *s) {
debug_printf("%s: It's some error, maybe...\n", s);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/printf.c
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);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/remove.c
0,0 → 1,6
#include <stdio.h>
#include <sys/ksys.h>
int remove(const char *name) {
return _ksys_file_delete(name);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/rename.c
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);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/rewind.c
0,0 → 1,5
#include <stdio.h>
void rewind(FILE *stream) {
stream->position = 0;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/setbuf.c
0,0 → 1,5
#include <stdio.h>
void setbuf(FILE *restrict stream, char *restrict buf) {
return;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/setvbuf.c
0,0 → 1,5
#include <stdio.h>
int setvbuf(FILE *restrict stream, char *restrict buf, int mode, size_t size) {
return 0;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/snprintf.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/sprintf.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/tmpfile.c
0,0 → 1,11
#include <stdio.h>
FILE *tmpfile(void) {
char name[FILENAME_MAX + 1];
if (!tmpnam(name)) {
return NULL;
}
return fopen(name, "wb+");
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/tmpnam.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/vfprintf.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdio/vsnprintf.c
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);
}

/programs/develop/ktcc/trunk/libc.obj/source/Makefile
0,0 → 1,28
ifndef GCC
GCC=kos32-gcc
endif
KPACK=kpack
FASM=fasm
CFLAGS = -c -nostdinc -I../include -DGNUC -D_BUILD_LIBC -fno-common -Os -fno-builtin -fno-leading-underscore -fno-pie
SRC=libc.c
LIB=../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
$(GCC) $(CFLAGS) $(SRC) -o $(LIB)
$(KPACK) $(LIB)
../linuxtools/LoaderGen symbols.txt ../loader
../linuxtools/LoaderBuild ../loader
$(MAKE) -C libtcc
rm -rf exports
install:
cp -f ../lib/libc.obj ~/.kex/root/RD/1/LIB
clean:
rm ../lib/*

/programs/develop/ktcc/trunk/libc.obj/source/Tupfile.lua
0,0 → 1,13
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_BUILD_LIBC -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"), "libc.obj")
Property changes:
Added: svn:executable
+*
\ No newline at end of property

/programs/develop/ktcc/trunk/libc.obj/source/libc.c
0,0 → 1,145
#include "ctype/is.c"
#include "ctype/tolower.c"
#include "ctype/toupper.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 "sys/dir.c"
#include "sys/socket.c"
#include "stdio/clearerr.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/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/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 "stdio/ungetc.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/atoi.c"
#include "stdlib/labs.c"
#include "stdlib/realloc.c"
#include "stdlib/ldiv.c"
#include "stdlib/abs.c"
#include "stdlib/div.c"
#include "stdlib/atol.c"
#include "stdlib/itoa.c"
#include "stdlib/strtol.c"
#include "stdlib/rand.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"
#include "time/difftime.c"
#include "time/localtime.c"
#include "time/mktime.c"
#include "time/time.c"
#include "time/asctime.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"
".include \"math/sqrt.s\"\n\t"
);
__asm__(
".include \"setjmp/longjmp.s\"\n\t"
".include \"setjmp/setjmp.s\""
);
#include "libtcc/libtcc1.c"
#include "stdlib/___chkstk_ms.c"
#include "exports/exports.c"

/programs/develop/ktcc/trunk/libc.obj/source/math/atan2.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/acos.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/acosh.c
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));
}

/programs/develop/ktcc/trunk/libc.obj/source/math/asin.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/asinh.c
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);
}

/programs/develop/ktcc/trunk/libc.obj/source/math/atan.s
0,0 → 1,10
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
.global atan;
atan:
fldl 4(%esp)
fld1
fpatan
ret

/programs/develop/ktcc/trunk/libc.obj/source/math/atanh.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/math/ceil.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/cos.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/cosh.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/math/exp.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/fabs.s
0,0 → 1,8
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
.global fabs;
fabs:
fldl 4(%esp)
fabs
ret

/programs/develop/ktcc/trunk/libc.obj/source/math/floor.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/fmod.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/frexp.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/math/hypot.c
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

/programs/develop/ktcc/trunk/libc.obj/source/math/ldexp.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/math/log.s
0,0 → 1,9
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
.global log;
log:
fldln2
fldl 4(%esp)
fyl2x
ret

/programs/develop/ktcc/trunk/libc.obj/source/math/modf.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/modfl.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/pow.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/pow10.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/pow2.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/sin.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/sinh.c
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;
}
}

/programs/develop/ktcc/trunk/libc.obj/source/math/sqrt.s
0,0 → 1,8
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
.global sqrt;
sqrt:
fldl 4(%esp)
fsqrt
ret

/programs/develop/ktcc/trunk/libc.obj/source/math/tan.s
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

/programs/develop/ktcc/trunk/libc.obj/source/math/tanh.c
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);
}
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/exit.c
0,0 → 1,12
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
#include <conio.h>
#include <sys/ksys.h>
void exit(int status)
{
if(__con_is_load){
con_exit(status);
}
_ksys_exit();
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/rand.c
0,0 → 1,15
#include <stdlib.h>
#include <stdint.h>
static uint64_t seed;
void srand(unsigned s)
{
seed = s-1;
}
int rand(void)
{
seed = 6364136223846793005ULL*seed + 1;
return seed>>33;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/___chkstk_ms.c
0,0 → 1,0
void ___chkstk_ms() {}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/abs.c
0,0 → 1,6
#include <stdlib.h>
int abs(int a)
{
return a>0 ? a : -a;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/atoi.c
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);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/atol.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/atoll.c
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;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/calloc.c
0,0 → 1,6
#include <stdlib.h>
#include <sys/ksys.h>
void *calloc(size_t num, size_t size) {
return _ksys_alloc(num*size);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/div.c
0,0 → 1,6
#include <stdlib.h>
div_t div(int num, int den)
{
return (div_t){ num/den, num%den };
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/free.c
0,0 → 1,6
#include <stdlib.h>
#include <sys/ksys.h>
void free(void *ptr) {
_ksys_free(ptr);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/itoa.c
0,0 → 1,42
#include <string.h>
#include <sys/ksys.h>
char *__reverse(char *str)
{
char tmp, *src, *dst;
size_t len;
if (str != NULL){
len = strlen (str);
if (len > 1) {
src = str;
dst = src + len - 1;
while (src < dst) {
tmp = *src;
*src++ = *dst;
*dst-- = tmp;
}
}
}
return str;
}
/* itoa from K&R */
void itoa(int n, char s[])
{
int i, sign;
if ((sign = n) < 0) /* record sign */
n = -n; /* make n positive */
i = 0;
do { /* generate digits in reverse order */
s[i++] = n % 10 + '0'; /* get next digit */
} while ((n /= 10) > 0); /* delete it */
if (sign < 0)
s[i++] = '-';
__reverse(s);
s[i] = '\0';
return;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/labs.c
0,0 → 1,6
#include <stdlib.h>
long labs(long a)
{
return a>0 ? a : -a;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/ldiv.c
0,0 → 1,6
#include <stdlib.h>
ldiv_t ldiv(long num, long den)
{
return (ldiv_t){ num/den, num%den };
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/llabs.c
0,0 → 1,6
#include <stdlib.h>
long long llabs(long long a)
{
return a>0 ? a : -a;
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/lldiv.c
0,0 → 1,6
#include <stdlib.h>
lldiv_t lldiv(long long num, long long den)
{
return (lldiv_t){ num/den, num%den };
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/malloc.c
0,0 → 1,6
#include <stdlib.h>
#include <sys/ksys.h>
void *malloc(size_t size) {
return _ksys_alloc(size);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/realloc.c
0,0 → 1,6
#include <stdlib.h>
#include <sys/ksys.h>
void *realloc(void *ptr, size_t newsize) {
return _ksys_realloc(ptr, newsize);
}

/programs/develop/ktcc/trunk/libc.obj/source/stdlib/strtol.c
0,0 → 1,78
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#define LONG_MIN (-2147483647L-1)
#define LONG_MAX (2147483647L)
#define ULONG_MAX (4294967295UL)
int getdigit(char ch, int base)
{
if (isdigit(ch)) ch-= '0';
else
if (isalpha(ch) && ch <= 'Z') ch = 10 + ch - 'A';
else
if (isalpha(ch)) ch = 10 + ch - 'a';
else
return -1;
if (ch / base != 0) return -1;
return ch;
}
long int strtol (const char* str, char** endptr, int base)
{
long int res = 0;
int sign = 1;
if (base > 36)
{
errno = EINVAL;
goto bye;
}
while (isspace(*str)) str++;
if (*str == '-') { sign = -1; str++; }
else
if (*str == '+') str++;
if (base == 0 || base == 16)
{
if (*str == '0' && (str[1] == 'x' || str[1] == 'X'))
{
base = 16;
str += 2;
}
}
if (base == 0 && *str == '0') base = 8;
if (base == 0) base = 10;
int digit;
while ((digit = getdigit(*str, base)) >= 0)
{
res = base * res + digit;
str++;
if (res < 0)
{
errno = ERANGE;
if (sign > 0)
res = LONG_MAX;
else
res = LONG_MIN;
}
}
bye:
if (endptr)
*endptr = (char*)str;
return res * sign;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strerror.c
0,0 → 1,82
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
#include <string.h>
#include <errno.h>
int _errno;
char* strerror(int err)
{
char *msg;
switch(err){
case 0: msg = "No errors"; break;
case EPERM: msg = "Operation not permitted"; break;
case ENOENT: msg = "No such file or directory"; break;
case ESRCH: msg = "No such process"; break;
case EINTR: msg = "Interrupted system call"; break;
case EIO: msg = "Input/output error"; break;
case ENXIO: msg = "Device not configured"; break;
case E2BIG: msg = "Argument list too long"; break;
case ENOEXEC: msg = "Exec format error"; break;
case EBADF: msg = "Bad file descriptor"; break;
case ECHILD: msg = "No child processes"; break;
case EDEADLK: msg = "Resource deadlock avoided"; break;
case ENOMEM: msg = "Cannot allocate memory"; break;
case EACCES: msg = "Permission denied"; break;
case EFAULT: msg = "Bad address"; break;
case ENOTBLK: msg = "Block device required"; break;
case EBUSY: msg = "Device / Resource busy"; break;
case EEXIST: msg = "File exists"; break;
case EXDEV: msg = "Cross-device link"; break;
case ENODEV: msg = "Operation not supported by device"; break;
case ENOTDIR: msg = "Not a directory"; break;
case EISDIR: msg = "Is a directory"; break;
case EINVAL: msg = "Invalid argument"; break;
case ENFILE: msg = "Too many open files in system"; break;
case EMFILE: msg = "Too many open files"; break;
case ENOTTY: msg = "Inappropriate ioctl for device"; break;
case ETXTBSY: msg = "Text file busy"; break;
case EFBIG: msg = "File too large"; break;
case ENOSPC: msg = "No space left on device"; break;
case ESPIPE: msg = "Illegal seek"; break;
case EROFS: msg = "Read-only file system"; break;
case EMLINK: msg = "Too many links"; break;
case EPIPE: msg = "Broken pipe"; break;
// math software
case EDOM: msg = "Numerical argument out of domain"; break;
case ERANGE: msg = "Result too large"; break;
// should be rearranged
case EHOSTDOWN: msg = "Host is down"; break;
case EHOSTUNREACH: msg = "No route to host"; break;
case ENOTEMPTY: msg = "Directory not empty"; break;
// quotas & mush
case EPROCLIM: msg = "Too many processes"; break;
case EUSERS: msg = "Too many users"; break;
case EDQUOT: msg = "Disc quota exceeded"; break;
// Intelligent device errors
case EPWROFF: msg = "Device power is off"; break;
case EDEVERR: msg = "Device error, e.g. paper out"; break;
case EOVERFLOW: msg = "Value too large to be stored in data type"; break;
// Socket errors
case ENOBUFS: msg = "Broken buffer"; break;
case EINPROGRESS: msg = "Operation now in progress"; break;
case EOPNOTSUPP: msg = "Operation not supported on transport endpoint"; break;
case EWOULDBLOCK: msg = "Operation would block"; break;
case ENOTCONN: msg = "Transport endpoint is not connected"; break;
case EALREADY: msg = "Operation already in progress"; break;
case EMSGSIZE: msg = "Message too long"; break;
case EADDRINUSE: msg = "Address already in use"; break;
case ECONNREFUSED: msg = "Connection refused"; break;
case ECONNRESET: msg = "Connection reset by peer"; break;
case EISCONN: msg = "Transport endpoint is already connected"; break;
case ETIMEDOUT: msg = "Connection timed out"; break;
case ECONNABORTED: msg = "Software caused connection abort"; break;
default: msg = "Unknown error"; break;
}
return msg;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/memccpy.c
0,0 → 1,14
#include <string.h>
void *memccpy(void *restrict dest, const void *restrict src, int c, size_t n)
{
unsigned char *d = dest;
const unsigned char *s = src;
c = (unsigned char)c;
for (; n && (*d=*s)!=c; n--, s++, d++);
tail:
if (n) return d+1;
return 0;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/memchr.c
0,0 → 1,24
/* memchr( const void *, int, size_t )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
void * memchr( const void * s, int c, size_t n )
{
const unsigned char * p = ( const unsigned char * ) s;
while ( n-- )
{
if ( *p == ( unsigned char ) c )
{
return ( void * ) p;
}
++p;
}
return NULL;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/memcmp.c
0,0 → 1,26
/* memcmp( const void *, const void *, size_t )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
int memcmp( const void * s1, const void * s2, size_t n )
{
const unsigned char * p1 = ( const unsigned char * ) s1;
const unsigned char * p2 = ( const unsigned char * ) s2;
while ( n-- )
{
if ( *p1 != *p2 )
{
return *p1 - *p2;
}
++p1;
++p2;
}
return 0;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/memcpy.c
0,0 → 1,20
/* memcpy( void *, const void *, size_t )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
void * memcpy( void * s1, const void * s2, size_t n )
{
char * dest = ( char * ) s1;
const char * src = ( const char * ) s2;
while ( n-- )
{
*dest++ = *src++;
}
return s1;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/memmove.c
0,0 → 1,33
/* memmove( void *, const void *, size_t )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
void * memmove( void * s1, const void * s2, size_t n )
{
char * dest = ( char * ) s1;
const char * src = ( const char * ) s2;
if ( dest <= src )
{
while ( n-- )
{
*dest++ = *src++;
}
}
else
{
src += n;
dest += n;
while ( n-- )
{
*--dest = *--src;
}
}
return s1;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/memset.c
0,0 → 1,20
/* memset( void *, int, size_t )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
#include <stdint.h>
void * memset( void * s, int c, size_t n )
{
unsigned char * p = ( unsigned char * ) s;
while ( n-- )
{
*p++ = ( unsigned char ) c;
}
return s;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strcat.c
0,0 → 1,27
/* strcat( char *, const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
char * strcat( char * s1, const char * s2 )
{
char * rc = s1;
if ( *s1 )
{
while ( *++s1 )
{
/* EMPTY */
}
}
while ( ( *s1++ = *s2++ ) )
{
/* EMPTY */
}
return rc;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strchr.c
0,0 → 1,20
/* strchr( const char *, int )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
char * strchr( const char * s, int c )
{
do
{
if ( *s == ( char ) c )
{
return ( char * ) s;
}
} while ( *s++ );
return NULL;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strcmp.c
0,0 → 1,14
/* strcmp( const char *, const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <errno.h>
#include <string.h>
#include <sys/ksys.h>
int strcmp(const char * s1, const char * s2)
{
return _ksys_strcmp(s1, s2);
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strcoll.c
0,0 → 1,13
/* strcoll( const char *, const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
int strcoll( const char * s1, const char * s2 )
{
/* FIXME: This should access _PDCLIB_lc_collate. */
return strcmp( s1, s2 );
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strcpy.c
0,0 → 1,19
/* strcpy( char *, const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
char * strcpy( char * s1, const char * s2 )
{
char * rc = s1;
while ( ( *s1++ = *s2++ ) )
{
/* EMPTY */
}
return rc;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strcspn.c
0,0 → 1,30
/* strcspn( const char *, const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
size_t strcspn( const char * s1, const char * s2 )
{
size_t len = 0;
const char * p;
while ( s1[len] )
{
p = s2;
while ( *p )
{
if ( s1[len] == *p++ )
{
return len;
}
}
++len;
}
return len;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strdup.c
0,0 → 1,10
#include <string.h>
#include <stdlib.h>
char* strdup(const char *str)
{
char *buf = malloc(strlen(str) + 1);
buf[strlen(str)] = '\0';
strcpy(buf, str);
return buf;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strlen.c
0,0 → 1,19
/* strlen( const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
size_t strlen( const char * s )
{
size_t rc = 0;
while ( s[rc] )
{
++rc;
}
return rc;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strncat.c
0,0 → 1,29
/* strncat( char *, const char *, size_t )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
char * strncat( char * s1, const char * s2, size_t n )
{
char * rc = s1;
while ( *s1 )
{
++s1;
}
while ( n && ( *s1++ = *s2++ ) )
{
--n;
}
if ( n == 0 )
{
*s1 = '\0';
}
return rc;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strncmp.c
0,0 → 1,26
/* strncmp( const char *, const char *, size_t )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
int strncmp( const char * s1, const char * s2, size_t n )
{
while ( n && *s1 && ( *s1 == *s2 ) )
{
++s1;
++s2;
--n;
}
if ( n == 0 )
{
return 0;
}
else
{
return ( *( unsigned char * )s1 - * ( unsigned char * )s2 );
}
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strncpy.c
0,0 → 1,29
/* strncpy( char *, const char *, size_t )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
char * strncpy( char * s1, const char * s2, size_t n )
{
char * rc = s1;
while ( n && ( *s1++ = *s2++ ) )
{
/* Cannot do "n--" in the conditional as size_t is unsigned and we have
to check it again for >0 in the next loop below, so we must not risk
underflow.
*/
--n;
}
/* Checking against 1 as we missed the last --n in the loop above. */
while ( n-- > 1 )
{
*s1++ = '\0';
}
return rc;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strpbrk.c
0,0 → 1,30
/* strpbrk( const char *, const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
char * strpbrk( const char * s1, const char * s2 )
{
const char * p1 = s1;
const char * p2;
while ( *p1 )
{
p2 = s2;
while ( *p2 )
{
if ( *p1 == *p2++ )
{
return ( char * ) p1;
}
}
++p1;
}
return NULL;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strrchr.c
0,0 → 1,27
/* strrchr( const char *, int )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
char * strrchr( const char * s, int c )
{
size_t i = 0;
while ( s[i++] )
{
/* EMPTY */
}
do
{
if ( s[--i] == ( char ) c )
{
return ( char * ) s + i;
}
} while ( i );
return NULL;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strrev.c
0,0 → 1,15
#include <string.h>
char* strrev(char *p)
{
char *q = p, *res = p, z;
while(q && *q) ++q; /* find eos */
for(--q; p < q; ++p, --q)
{
z = *p;
*p = *q;
*q = z;
}
return res;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strspn.c
0,0 → 1,37
/* strspn( const char *, const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
size_t strspn( const char * s1, const char * s2 )
{
size_t len = 0;
const char * p;
while ( s1[ len ] )
{
p = s2;
while ( *p )
{
if ( s1[len] == *p )
{
break;
}
++p;
}
if ( ! *p )
{
return len;
}
++len;
}
return len;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strstr.c
0,0 → 1,34
/* strstr( const char *, const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
char * strstr( const char * s1, const char * s2 )
{
const char * p1 = s1;
const char * p2;
while ( *s1 )
{
p2 = s2;
while ( *p2 && ( *p1 == *p2 ) )
{
++p1;
++p2;
}
if ( ! *p2 )
{
return ( char * ) s1;
}
++s1;
p1 = s1;
}
return NULL;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strtok.c
0,0 → 1,30
/* strtok( char *, const char * )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
char* strtok(char* s, const char* delim)
{
static char* savep;
char* res;
if(s)
savep = NULL;
else
s = savep;
if (*s == '\0')
return NULL;
s += strspn(s, delim);
if (*s == '\0')
return NULL;
res = s;
s += strcspn(s, delim);
savep = s + 1;
*s = '\0';
return res;
}

/programs/develop/ktcc/trunk/libc.obj/source/string/strxfrm.c
0,0 → 1,26
/* strxfrm( char *, const char *, size_t )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <string.h>
size_t strxfrm( char * s1, const char * s2, size_t n )
{
size_t len = strlen( s2 );
if ( len < n )
{
/* Cannot use strncpy() here as the filling of s1 with '\0' is not part
of the spec.
*/
/* FIXME: This should access _PDCLIB_lc_collate. */
while ( n-- && ( *s1++ = ( unsigned char )*s2++ ) )
{
/* EMPTY */
}
}
return len;
}

/programs/develop/ktcc/trunk/libc.obj/source/symbols.txt
0,0 → 1,172
!____STDIO______
clearerr
debug_printf
fclose
feof
ferror
fflush
fgetc
fgetpos
fgets
fopen
fprintf
fputc
fputs
fread
freopen
fscanf
fseek
fsetpos
ftell
fwrite
getchar
gets
perror
printf
puts
remove
rename
rewind
scanf
setbuf
setvbuf
snprintf
sprintf
sscanf
tmpfile
tmpnam
vfscanf
vprintf
vfscanf
vsnprintf
vsscanf
ungetc
!____STDLIB____
abs
atoi
atol
atoll
calloc
div
exit
free
itoa
labs
ldiv
llabs
lldiv
malloc
realloc
strtol
srand
rand
!____STRING____
!memcpy
memchr
memcmp
!memmove
!memset
strncat
strchr
strcat
strcmp
strcoll
strcpy
strcspn
strdup
strerror
strlen
strncat
strncmp
strncpy
strrchr
strrev
strspn
strstr
strtok
strxfrm
_errno
!____SYS____
closedir
opendir
readdir
rewinddir
seekdir
telldir
getcwd
mkdir
rmdir
setcwd
getcwd
!____SOCKET____
socket
close
bind
listen
connect
accept
send
recv
setsockopt
socketpair
!____UNISTD____
!____MATH____
acosh
asinh
atanh
acosh
frexp
hypot
ldexp
sinh
tanh
acos
asin
atan
atan2
ceil
cos
exp
fabs
floor
fmod
log
modf
modfl
pow
pow2
pow10
!____LONGJMP____
longjmp
setjmp
!____CTYPE____
__is
tolower
toupper
!___CONIO___
con_set_title
con_init
con_init_opt
con_write_asciiz
con_write_string
con_printf
con_exit
con_get_flags
con_set_flags
con_kbhit
con_getch
con_getch2
con_gets
con_gets2
con_get_font_height
con_get_cursor_height
con_set_cursor_height
con_cls
con_get_cursor_pos
con_set_cursor_pos
!____TIME____
mktime
time
localtime
asctime
difftime

/programs/develop/ktcc/trunk/libc.obj/source/sys/socket.c
0,0 → 1,155
#include <sys/socket.h>
static void _conv_socket_err(){
switch(errno){
case 1: errno = ENOBUFS; break;
case 2: errno = EINPROGRESS; break;
case 4: errno = EOPNOTSUPP; break;
case 6: errno = EWOULDBLOCK; break;
case 9: errno = ENOTCONN; break;
case 10: errno = EALREADY; break;
case 11: errno = EINVAL; break;
case 12: errno = EMSGSIZE; break;
case 18: errno = ENOMEM; break;
case 20: errno = EADDRINUSE; break;
case 61: errno = ECONNREFUSED; break;
case 52: errno = ECONNRESET; break;
case 56: errno = EISCONN; break;
case 60: errno = ETIMEDOUT; break;
case 54: errno = ECONNABORTED; break;
default: errno = 0; break;
}
}
int socket(int domain, int type, int protocol)
{
int socket;
asm_inline(
"int $0x40"
:"=b"(errno), "=a"(socket)
:"a"(75), "b"(0), "c"(domain), "d"(type), "S"(protocol)
);
_conv_socket_err();
return socket;
}
int close(int socket)
{
int status;
asm_inline(
"int $0x40"
:"=b"(errno), "=a"(status)
:"a"(75), "b"(1), "c"(socket)
);
_conv_socket_err();
return status;
}
int bind(int socket, const struct sockaddr *addres, int addres_len)
{
int status;
asm_inline(
"int $0x40"
:"=b"(errno), "=a"(status)
:"a"(75), "b"(2), "c"(socket), "d"(addres), "S"(addres_len)
);
_conv_socket_err();
return status;
}
int listen(int socket, int backlog)
{
int status;
asm_inline(
"int $0x40"
:"=b"(errno), "=a"(status)
:"a"(75), "b"(3), "c"(socket), "d"(backlog)
);
_conv_socket_err();
return status;
}
int connect(int socket, const struct sockaddr* address, int socket_len)
{
int status;
asm_inline(
"int $0x40"
:"=b"(errno), "=a"(status)
:"a"(75), "b"(4), "c"(socket), "d"(address), "S"(socket_len)
);
_conv_socket_err();
return status;
}
int accept(int socket, const struct sockaddr *address, int address_len)
{
int new_socket;
asm_inline(
"int $0x40"
:"=b"(errno), "=a"(new_socket)
:"a"(75), "b"(5), "c"(socket), "d"(address), "S"(address_len)
);
_conv_socket_err();
return new_socket;
}
int send(int socket, const void *message, size_t msg_len, int flag)
{
int status;
asm_inline(
"int $0x40"
:"=b"(errno), "=a"(status)
:"a"(75), "b"(6), "c"(socket), "d"(message), "S"(msg_len), "D"(flag)
);
_conv_socket_err();
return status;
}
int recv(int socket, void *buffer, size_t buff_len, int flag)
{
int status;
asm_inline(
"int $0x40"
:"=b"(errno), "=a"(status)
:"a"(75), "b"(7), "c"(socket), "d"(buffer), "S"(buff_len), "D"(flag)
);
_conv_socket_err();
return status;
}
int setsockopt(int socket,const optstruct* opt)
{
int status;
asm_inline(
"int $0x40"
:"=b"(errno), "=a"(status)
:"a"(75), "b"(8), "c"(socket),"d"(opt)
);
_conv_socket_err();
return status;
}
int getsockopt(int socket, optstruct* opt)
{
int status;
asm_inline(
"int $0x40"
:"=b"(errno), "=a"(status)
:"a"(75), "b"(9), "c"(socket),"d"(opt)
);
_conv_socket_err();
return status;
}
int socketpair(int *socket1, int *socket2)
{
asm_inline(
"int $0x40"
:"=b"(*socket2), "=a"(*socket1)
:"a"(75), "b"(10)
);
errno=*socket2;
_conv_socket_err();
return *socket1;
}

/programs/develop/ktcc/trunk/libc.obj/source/sys/dir.c
0,0 → 1,25
#include <sys/ksys.h>
#include <sys/dir.h>
#include <stdlib.h>
char *getcwd(char *buf, unsigned size){
if(!buf){
if((buf = malloc(size))==NULL){
return NULL;
}
}
_ksys_getcwd(buf, size);
return(buf);
}
void setcwd(const char* cwd){
_ksys_setcwd((char*)cwd);
}
int rmdir(const char* dir){
return _ksys_file_delete(dir);
}
int mkdir(const char* dir){
return _ksys_mkdir(dir);
}

/programs/develop/ktcc/trunk/libc.obj/source/sys/closedir.c
0,0 → 1,14
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
#include <sys/dirent.h>
#include <stdlib.h>
int closedir(DIR *dir){
if(dir == NULL){
return -1;
}else{
free(dir->objs);
free(dir);
return 0;
}
}

/programs/develop/ktcc/trunk/libc.obj/source/sys/opendir.c
0,0 → 1,53
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
#include <sys/dirent.h>
#include <sys/ksys.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#define CHECK_DIR_ERR() if(_ksys_work_files(&inf)){ \
free((void*)inf.p16); \
errno = ENOTDIR; \
return NULL; \
}
DIR* opendir(const char* path)
{
DIR* list = malloc(sizeof(DIR));
if(list==NULL){
errno = ENOMEM;
return NULL;
}
list->pos=0;
unsigned num_of_file=0;
ksys70_t inf;
inf.p00 = 1;
inf.p04 = 0;
inf.p12 = 2;
inf.p16 = (unsigned) malloc(32+inf.p12*560);
inf.p20 = 0;
inf.p21 = (char*)path;
CHECK_DIR_ERR();
num_of_file = *(unsigned*)(inf.p16+8);
inf.p12 = num_of_file;
free((void*)inf.p16);
inf.p16 = (unsigned) malloc(32+inf.p12*560);
list->objs = (struct dirent*)malloc(num_of_file*sizeof(struct dirent));
CHECK_DIR_ERR();
for(int i=0; i<num_of_file; i++){
list->objs[i].d_ino = i;
list->objs[i].d_type = *(unsigned*)(inf.p16+32+(264+40)*i);
strcpy(list->objs[i].d_name,(char*)(inf.p16+32+40+(264+40)*i));
}
list->num_objs = num_of_file;
return list;
}

/programs/develop/ktcc/trunk/libc.obj/source/sys/readdir.c
0,0 → 1,14
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
#include <sys/dirent.h>
#include <stdlib.h>
struct dirent* readdir(DIR *dir)
{
if(dir->num_objs>dir->pos){
dir->pos++;
return &dir->objs[dir->pos-1];
}else{
return NULL;
}
}

/programs/develop/ktcc/trunk/libc.obj/source/sys/rewinddir.c
0,0 → 1,9
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
#include <sys/dirent.h>
void rewinddir(DIR *dir){
if(dir!=NULL){
dir->pos=0;
}
}

/programs/develop/ktcc/trunk/libc.obj/source/sys/seekdir.c
0,0 → 1,12
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
#include <sys/dirent.h>
void seekdir(DIR *dir, unsigned pos)
{
if(dir==NULL || pos>dir->num_objs){
return;
}
dir->pos=pos;
return;
}

/programs/develop/ktcc/trunk/libc.obj/source/sys/telldir.c
0,0 → 1,12
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
#include <sys/dirent.h>
unsigned telldir(DIR *dir)
{
if(dir!=NULL){
return dir->pos;
}else{
return 0;
}
}

/programs/develop/ktcc/trunk/libc.obj/source/time/asctime.c
0,0 → 1,27
#include <errno.h>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
const char *wday_str[7]={"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
const char *mon_str[12]={"Jan", "Feb", "Mar", "Ap", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
#pragma GCC push_options
#pragma GCC optimize("O0")
char *asctime(const struct tm *tm){
static char time_str[30];
if(tm->tm_wday>7 || tm->tm_wday<1 || tm->tm_mon<1 || tm->tm_mon>12){
errno = EINVAL;
return NULL;
}
snprintf(time_str, 26, "%.3s %.3s%3d %2d:%2d:%2d %d\n",
wday_str[tm->tm_wday-1],
mon_str[tm->tm_mon-1],
tm->tm_mday, tm->tm_hour,
tm->tm_min, tm->tm_sec,
1900 + tm->tm_year
);
return time_str;
}
#pragma GCC pop_options

/programs/develop/ktcc/trunk/libc.obj/source/time/difftime.c
0,0 → 1,6
#include <time.h>
double difftime (time_t end, time_t beginning)
{
return end - beginning;
}

/programs/develop/ktcc/trunk/libc.obj/source/time/localtime.c
0,0 → 1,108
#include <time.h>
#include <sys/ksys.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#define LEAPOCH (946684800LL + 86400*(31+29))
#define DAYS_PER_400Y (365*400 + 97)
#define DAYS_PER_100Y (365*100 + 24)
#define DAYS_PER_4Y (365*4 + 1)
static int __secs_to_tm(long long t, struct tm *tm)
{
long long days, secs, years;
int remdays, remsecs, remyears;
int qc_cycles, c_cycles, q_cycles;
int months;
int wday, yday, leap;
static const char days_in_month[] = {31,30,31,30,31,31,30,31,30,31,31,29};
// Reject time_t values whose year would overflow int
if (t < INT_MIN * 31622400LL || t > INT_MAX * 31622400LL)
return -1;
secs = t - LEAPOCH;
days = secs / 86400;
remsecs = secs % 86400;
if (remsecs < 0) {
remsecs += 86400;
days--;
}
wday = (3+days)%7;
if (wday < 0) wday += 7;
qc_cycles = days / DAYS_PER_400Y;
remdays = days % DAYS_PER_400Y;
if (remdays < 0) {
remdays += DAYS_PER_400Y;
qc_cycles--;
}
c_cycles = remdays / DAYS_PER_100Y;
if (c_cycles == 4) c_cycles--;
remdays -= c_cycles * DAYS_PER_100Y;
q_cycles = remdays / DAYS_PER_4Y;
if (q_cycles == 25) q_cycles--;
remdays -= q_cycles * DAYS_PER_4Y;
remyears = remdays / 365;
if (remyears == 4) remyears--;
remdays -= remyears * 365;
leap = !remyears && (q_cycles || !c_cycles);
yday = remdays + 31 + 28 + leap;
if (yday >= 365+leap) yday -= 365+leap;
years = remyears + 4*q_cycles + 100*c_cycles + 400LL*qc_cycles;
for (months=0; days_in_month[months] <= remdays; months++)
remdays -= days_in_month[months];
if (months >= 10) {
months -= 12;
years++;
}
if (years+100 > INT_MAX || years+100 < INT_MIN)
return -1;
tm->tm_year = years + 100;
tm->tm_mon = months + 2;
tm->tm_mday = remdays + 1;
tm->tm_wday = wday;
tm->tm_yday = yday;
tm->tm_hour = remsecs / 3600;
tm->tm_min = remsecs / 60 % 60;
tm->tm_sec = remsecs % 60;
return 0;
}
struct tm *__localtime_r(const time_t *restrict t, struct tm *restrict tm)
{
// Reject time_t values whose year would overflow int because
// __secs_to_zone cannot safely handle them.
if (*t < INT_MIN * 31622400LL || *t > INT_MAX * 31622400LL) {
errno = EOVERFLOW;
return NULL;
}
//__secs_to_zone(*t, 0, &tm->tm_isdst, &tm->__tm_gmtoff, 0, &tm->__tm_zone);
if (__secs_to_tm((long long)*t,tm) < 0) {
errno = EOVERFLOW;
return NULL;
}
return tm;
}
struct tm * localtime (const time_t * timer)
{
static struct tm tm;
return __localtime_r(timer, &tm);
}

/programs/develop/ktcc/trunk/libc.obj/source/time/mktime.c
0,0 → 1,23
#include <time.h>
time_t mktime (struct tm * timeptr)
{
int utcdiff = -3;
const int mon_days [] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
unsigned long int tyears, tdays, leaps, utc_hrs;
int i;
tyears = timeptr->tm_year - 70 ;// tm->tm_year is from 1900.
leaps = (tyears + 2) / 4; // no of next two lines until year 2100.
i = (timeptr->tm_year - 100) / 100;
leaps -= ( (i/4)*3 + i%4 );
tdays = 0;
for (i=0; i < timeptr->tm_mon; i++) tdays += mon_days[i];
tdays += timeptr->tm_mday-1; // days of month passed.
tdays = tdays + (tyears * 365) + leaps;
utc_hrs = timeptr->tm_hour + utcdiff; // for your time zone.
return (tdays * 86400) + (utc_hrs * 3600) + (timeptr->tm_min * 60) + timeptr->tm_sec;
}

/programs/develop/ktcc/trunk/libc.obj/source/time/time.c
0,0 → 1,34
#include <time.h>
#include <sys/ksys.h>
static struct tm __buffertime;
time_t time(time_t *timer){
int kos_date, kos_time;
kos_date = _ksys_get_date();
kos_time = _ksys_get_clock();
int bcd_day = (kos_date >> 16);
int bcd_mon = ((kos_date & 0xFF00) >> 8);
int bcd_year = (kos_date & 0xFF);
__buffertime.tm_mday = ((bcd_day & 0xF0)>>4)*10 + (bcd_day & 0x0F);
__buffertime.tm_mon = ((bcd_mon & 0xF0)>>4)*10 + (bcd_mon & 0x0F) - 1;
__buffertime.tm_year = ((bcd_year & 0xF0)>>4)*10 + (bcd_year & 0x0F) + 100;
__buffertime.tm_wday = __buffertime.tm_yday = __buffertime.tm_isdst = -1; /* temporary */
int bcd_sec = (kos_time >> 16);
int bcd_min = ((kos_time & 0xFF00) >> 8);
int bcd_hour = (kos_time & 0xFF);
__buffertime.tm_sec = ((bcd_sec & 0xF0)>>4)*10 + (bcd_sec & 0x0F);
__buffertime.tm_min = ((bcd_min & 0xF0)>>4)*10 + (bcd_min & 0x0F);
__buffertime.tm_hour = ((bcd_hour & 0xF0)>>4)*10 + (bcd_hour & 0x0F);
time_t ret = mktime(&__buffertime);
if(timer){
*timer=ret;
}
return ret;
}

/programs/develop/ktcc/trunk/libc.obj/source/ctype/tolower.c
0,0 → 1,7
#include <ctype.h>
int tolower(int c)
{
if (isupper(c)) return c | 32;
return c;
}

/programs/develop/ktcc/trunk/libc.obj/source/ctype/toupper.c
0,0 → 1,7
#include <ctype.h>
int toupper(int c)
{
if (islower(c)) return c & 0x5f;
return c;
}

/programs/develop/ktcc/trunk/libc.obj/source/ctype/is.c
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
};

/programs/develop/ktcc/trunk/libc.obj/source/crt/crt0.asm
0,0 → 1,221
format ELF
section '.text' executable
public start
public start as '_start'
;extrn mf_init
extrn main
include '../../../../../proc32.inc'
include '../../../../../macros.inc'
include '../../../../../dll.inc'
;include '../../../../../debug.inc'
;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:
;DEBUGF 1, "Library: %s not loaded!\n", esi
;mcall -1
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
;==============================
lib_init_str db 'lib_init', 0
public argc as '__argc'
public params as '__argv'
public path as '__path'
section '.bss'
buf_len = 0x400
max_parameters=0x20
argc rd 1
argv rd max_parameters
path rb buf_len
params rb buf_len

/programs/develop/ktcc/trunk/libc.obj/source/libtcc/Makefile
0,0 → 1,17
KTCC_DIR=../../../../ktcc/trunk
KTCC=$(KTCC_DIR)/bin/kos32-tcc
FASM=fasm
OBJ= memcpy.o memmove.o memset.o libtcc1.o
all: $(OBJ)
ar -crs ../../lib/libtcc.a $(OBJ)
rm -f *.o
%.o : %.c
$(KTCC) -c $< -o $@
%.o : %.asm
$(FASM) $< $@
Property changes:
Added: svn:executable
+*
\ No newline at end of property

/programs/develop/ktcc/trunk/libc.obj/source/libtcc/libtcc1.c
0,0 → 1,763
/* TCC runtime library.
Parts of this code are (c) 2002 Fabrice Bellard
Copyright (C) 1987, 1988, 1992, 1994, 1995 Free Software Foundation, Inc.
This file is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
In addition to the permissions in the GNU General Public License, the
Free Software Foundation gives you unlimited permission to link the
compiled version of this file into combinations with other programs,
and to distribute those combinations without any restriction coming
from the use of this file. (The General Public License restrictions
do apply in other respects; for example, they cover modification of
the file, and distribution when not linked into a combine
executable.)
This file is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
//#include <stdint.h>
#define TCC_TARGET_I386
#define W_TYPE_SIZE 32
#define BITS_PER_UNIT 8
typedef int Wtype;
typedef unsigned int UWtype;
typedef unsigned int USItype;
typedef long long DWtype;
typedef unsigned long long UDWtype;
struct DWstruct {
Wtype low, high;
};
typedef union
{
struct DWstruct s;
DWtype ll;
} DWunion;
typedef long double XFtype;
#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
/* the following deal with IEEE single-precision numbers */
#define EXCESS 126
#define SIGNBIT 0x80000000
#define HIDDEN (1 << 23)
#define SIGN(fp) ((fp) & SIGNBIT)
#define EXP(fp) (((fp) >> 23) & 0xFF)
#define MANT(fp) (((fp) & 0x7FFFFF) | HIDDEN)
#define PACK(s,e,m) ((s) | ((e) << 23) | (m))
/* the following deal with IEEE double-precision numbers */
#define EXCESSD 1022
#define HIDDEND (1 << 20)
#define EXPD(fp) (((fp.l.upper) >> 20) & 0x7FF)
#define SIGND(fp) ((fp.l.upper) & SIGNBIT)
#define MANTD(fp) (((((fp.l.upper) & 0xFFFFF) | HIDDEND) << 10) | \
(fp.l.lower >> 22))
#define HIDDEND_LL ((long long)1 << 52)
#define MANTD_LL(fp) ((fp.ll & (HIDDEND_LL-1)) | HIDDEND_LL)
#define PACKD_LL(s,e,m) (((long long)((s)+((e)<<20))<<32)|(m))
/* the following deal with x86 long double-precision numbers */
#define EXCESSLD 16382
#define EXPLD(fp) (fp.l.upper & 0x7fff)
#define SIGNLD(fp) ((fp.l.upper) & 0x8000)
/* only for x86 */
union ldouble_long {
long double ld;
struct {
unsigned long long lower;
unsigned short upper;
} l;
};
union double_long {
double d;
#if 1
struct {
unsigned int lower;
int upper;
} l;
#else
struct {
int upper;
unsigned int lower;
} l;
#endif
long long ll;
};
union float_long {
float f;
unsigned int l;
};
/* XXX: we don't support several builtin supports for now */
#if !defined(TCC_TARGET_X86_64) && !defined(TCC_TARGET_ARM)
/* XXX: use gcc/tcc intrinsic ? */
#if defined(TCC_TARGET_I386)
#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
__asm__ ("subl %5,%1\n\tsbbl %3,%0" \
: "=r" ((USItype) (sh)), \
"=&r" ((USItype) (sl)) \
: "0" ((USItype) (ah)), \
"g" ((USItype) (bh)), \
"1" ((USItype) (al)), \
"g" ((USItype) (bl)))
#define umul_ppmm(w1, w0, u, v) \
__asm__ ("mull %3" \
: "=a" ((USItype) (w0)), \
"=d" ((USItype) (w1)) \
: "%0" ((USItype) (u)), \
"rm" ((USItype) (v)))
#define udiv_qrnnd(q, r, n1, n0, dv) \
__asm__ ("divl %4" \
: "=a" ((USItype) (q)), \
"=d" ((USItype) (r)) \
: "0" ((USItype) (n0)), \
"1" ((USItype) (n1)), \
"rm" ((USItype) (dv)))
#define count_leading_zeros(count, x) \
do { \
USItype __cbtmp; \
__asm__ ("bsrl %1,%0" \
: "=r" (__cbtmp) : "rm" ((USItype) (x))); \
(count) = __cbtmp ^ 31; \
} while (0)
#else
#error unsupported CPU type
#endif
/* most of this code is taken from libgcc2.c from gcc */
UDWtype __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
{
DWunion ww;
DWunion nn, dd;
DWunion rr;
UWtype d0, d1, n0, n1, n2;
UWtype q0, q1;
UWtype b, bm;
nn.ll = n;
dd.ll = d;
d0 = dd.s.low;
d1 = dd.s.high;
n0 = nn.s.low;
n1 = nn.s.high;
#if !defined(UDIV_NEEDS_NORMALIZATION)
if (d1 == 0)
{
if (d0 > n1)
{
/* 0q = nn / 0D */
udiv_qrnnd (q0, n0, n1, n0, d0);
q1 = 0;
/* Remainder in n0. */
}
else
{
/* qq = NN / 0d */
if (d0 == 0)
d0 = 1 / d0; /* Divide intentionally by zero. */
udiv_qrnnd (q1, n1, 0, n1, d0);
udiv_qrnnd (q0, n0, n1, n0, d0);
/* Remainder in n0. */
}
if (rp != 0)
{
rr.s.low = n0;
rr.s.high = 0;
*rp = rr.ll;
}
}
#else /* UDIV_NEEDS_NORMALIZATION */
if (d1 == 0)
{
if (d0 > n1)
{
/* 0q = nn / 0D */
count_leading_zeros (bm, d0);
if (bm != 0)
{
/* Normalize, i.e. make the most significant bit of the
denominator set. */
d0 = d0 << bm;
n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
n0 = n0 << bm;
}
udiv_qrnnd (q0, n0, n1, n0, d0);
q1 = 0;
/* Remainder in n0 >> bm. */
}
else
{
/* qq = NN / 0d */
if (d0 == 0)
d0 = 1 / d0; /* Divide intentionally by zero. */
count_leading_zeros (bm, d0);
if (bm == 0)
{
/* From (n1 >= d0) /\ (the most significant bit of d0 is set),
conclude (the most significant bit of n1 is set) /\ (the
leading quotient digit q1 = 1).
This special case is necessary, not an optimization.
(Shifts counts of W_TYPE_SIZE are undefined.) */
n1 -= d0;
q1 = 1;
}
else
{
/* Normalize. */
b = W_TYPE_SIZE - bm;
d0 = d0 << bm;
n2 = n1 >> b;
n1 = (n1 << bm) | (n0 >> b);
n0 = n0 << bm;
udiv_qrnnd (q1, n1, n2, n1, d0);
}
/* n1 != d0... */
udiv_qrnnd (q0, n0, n1, n0, d0);
/* Remainder in n0 >> bm. */
}
if (rp != 0)
{
rr.s.low = n0 >> bm;
rr.s.high = 0;
*rp = rr.ll;
}
}
#endif /* UDIV_NEEDS_NORMALIZATION */
else
{
if (d1 > n1)
{
/* 00 = nn / DD */
q0 = 0;
q1 = 0;
/* Remainder in n1n0. */
if (rp != 0)
{
rr.s.low = n0;
rr.s.high = n1;
*rp = rr.ll;
}
}
else
{
/* 0q = NN / dd */
count_leading_zeros (bm, d1);
if (bm == 0)
{
/* From (n1 >= d1) /\ (the most significant bit of d1 is set),
conclude (the most significant bit of n1 is set) /\ (the
quotient digit q0 = 0 or 1).
This special case is necessary, not an optimization. */
/* The condition on the next line takes advantage of that
n1 >= d1 (true due to program flow). */
if (n1 > d1 || n0 >= d0)
{
q0 = 1;
sub_ddmmss (n1, n0, n1, n0, d1, d0);
}
else
q0 = 0;
q1 = 0;
if (rp != 0)
{
rr.s.low = n0;
rr.s.high = n1;
*rp = rr.ll;
}
}
else
{
UWtype m1, m0;
/* Normalize. */
b = W_TYPE_SIZE - bm;
d1 = (d1 << bm) | (d0 >> b);
d0 = d0 << bm;
n2 = n1 >> b;
n1 = (n1 << bm) | (n0 >> b);
n0 = n0 << bm;
udiv_qrnnd (q0, n1, n2, n1, d1);
umul_ppmm (m1, m0, q0, d0);
if (m1 > n1 || (m1 == n1 && m0 > n0))
{
q0--;
sub_ddmmss (m1, m0, m1, m0, d1, d0);
}
q1 = 0;
/* Remainder in (n1n0 - m1m0) >> bm. */
if (rp != 0)
{
sub_ddmmss (n1, n0, n1, n0, m1, m0);
rr.s.low = (n1 << b) | (n0 >> bm);
rr.s.high = n1 >> bm;
*rp = rr.ll;
}
}
}
}
ww.s.low = q0;
ww.s.high = q1;
return ww.ll;
}
#define __negdi2(a) (-(a))
long long __divdi3(long long u, long long v)
{
int c = 0;
DWunion uu, vv;
DWtype w;
uu.ll = u;
vv.ll = v;
if (uu.s.high < 0) {
c = ~c;
uu.ll = __negdi2 (uu.ll);
}
if (vv.s.high < 0) {
c = ~c;
vv.ll = __negdi2 (vv.ll);
}
w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
if (c)
w = __negdi2 (w);
return w;
}
// https://github.com/KaMeHb-UA/UE4m/blob/1d9ad5bfead06520570c7f24dad062f9f8717c1a/\
Engine/Extras/ThirdPartyNotUE/emsdk/emscripten/incoming/system/lib/compiler-rt/lib/\
builtins/divmoddi4.c
long long __divmoddi4(long long a, long long b, long long* rem)
{
long long d = __divdi3(a, b);
*rem = a - (d * b);
return d;
}
long long __moddi3(long long u, long long v)
{
int c = 0;
DWunion uu, vv;
DWtype w;
uu.ll = u;
vv.ll = v;
if (uu.s.high < 0) {
c = ~c;
uu.ll = __negdi2 (uu.ll);
}
if (vv.s.high < 0)
vv.ll = __negdi2 (vv.ll);
__udivmoddi4 (uu.ll, vv.ll, (UDWtype *) &w);
if (c)
w = __negdi2 (w);
return w;
}
unsigned long long __udivdi3(unsigned long long u, unsigned long long v)
{
return __udivmoddi4 (u, v, (UDWtype *) 0);
}
unsigned long long __umoddi3(unsigned long long u, unsigned long long v)
{
UDWtype w;
__udivmoddi4 (u, v, &w);
return w;
}
/* XXX: fix tcc's code generator to do this instead */
long long __ashrdi3(long long a, int b)
{
#ifdef __TINYC__
DWunion u;
u.ll = a;
if (b >= 32) {
u.s.low = u.s.high >> (b - 32);
u.s.high = u.s.high >> 31;
} else if (b != 0) {
u.s.low = ((unsigned)u.s.low >> b) | (u.s.high << (32 - b));
u.s.high = u.s.high >> b;
}
return u.ll;
#else
return a >> b;
#endif
}
/* XXX: fix tcc's code generator to do this instead */
unsigned long long __lshrdi3(unsigned long long a, int b)
{
#ifdef __TINYC__
DWunion u;
u.ll = a;
if (b >= 32) {
u.s.low = (unsigned)u.s.high >> (b - 32);
u.s.high = 0;
} else if (b != 0) {
u.s.low = ((unsigned)u.s.low >> b) | (u.s.high << (32 - b));
u.s.high = (unsigned)u.s.high >> b;
}
return u.ll;
#else
return a >> b;
#endif
}
/* XXX: fix tcc's code generator to do this instead */
long long __ashldi3(long long a, int b)
{
#ifdef __TINYC__
DWunion u;
u.ll = a;
if (b >= 32) {
u.s.high = (unsigned)u.s.low << (b - 32);
u.s.low = 0;
} else if (b != 0) {
u.s.high = ((unsigned)u.s.high << b) | ((unsigned)u.s.low >> (32 - b));
u.s.low = (unsigned)u.s.low << b;
}
return u.ll;
#else
return a << b;
#endif
}
#ifndef COMMIT_4ad186c5ef61_IS_FIXED
long long __tcc_cvt_ftol(long double x)
{
unsigned c0, c1;
long long ret;
__asm__ __volatile__ ("fnstcw %0" : "=m" (c0));
c1 = c0 | 0x0C00;
__asm__ __volatile__ ("fldcw %0" : : "m" (c1));
__asm__ __volatile__ ("fistpll %0" : "=m" (ret));
__asm__ __volatile__ ("fldcw %0" : : "m" (c0));
return ret;
}
#endif
#endif /* !__x86_64__ */
/* XXX: fix tcc's code generator to do this instead */
float __floatundisf(unsigned long long a)
{
DWunion uu;
XFtype r;
uu.ll = a;
if (uu.s.high >= 0) {
return (float)uu.ll;
} else {
r = (XFtype)uu.ll;
r += 18446744073709551616.0;
return (float)r;
}
}
double __floatundidf(unsigned long long a)
{
DWunion uu;
XFtype r;
uu.ll = a;
if (uu.s.high >= 0) {
return (double)uu.ll;
} else {
r = (XFtype)uu.ll;
r += 18446744073709551616.0;
return (double)r;
}
}
long double __floatundixf(unsigned long long a)
{
DWunion uu;
XFtype r;
uu.ll = a;
if (uu.s.high >= 0) {
return (long double)uu.ll;
} else {
r = (XFtype)uu.ll;
r += 18446744073709551616.0;
return (long double)r;
}
}
unsigned long long __fixunssfdi (float a1)
{
register union float_long fl1;
register int exp;
register unsigned long l;
fl1.f = a1;
if (fl1.l == 0)
return (0);
exp = EXP (fl1.l) - EXCESS - 24;
l = MANT(fl1.l);
if (exp >= 41)
return (unsigned long long)-1;
else if (exp >= 0)
return (unsigned long long)l << exp;
else if (exp >= -23)
return l >> -exp;
else
return 0;
}
unsigned long long __fixunsdfdi (double a1)
{
register union double_long dl1;
register int exp;
register unsigned long long l;
dl1.d = a1;
if (dl1.ll == 0)
return (0);
exp = EXPD (dl1) - EXCESSD - 53;
l = MANTD_LL(dl1);
if (exp >= 12)
return (unsigned long long)-1;
else if (exp >= 0)
return l << exp;
else if (exp >= -52)
return l >> -exp;
else
return 0;
}
unsigned long long __fixunsxfdi (long double a1)
{
register union ldouble_long dl1;
register int exp;
register unsigned long long l;
dl1.ld = a1;
if (dl1.l.lower == 0 && dl1.l.upper == 0)
return (0);
exp = EXPLD (dl1) - EXCESSLD - 64;
l = dl1.l.lower;
if (exp > 0)
return (unsigned long long)-1;
else if (exp >= -63)
return l >> -exp;
else
return 0;
}
long long __fixsfdi (float a1)
{
long long ret; int s;
ret = __fixunssfdi((s = a1 >= 0) ? a1 : -a1);
return s ? ret : -ret;
}
long long __fixdfdi (double a1)
{
long long ret; int s;
ret = __fixunsdfdi((s = a1 >= 0) ? a1 : -a1);
return s ? ret : -ret;
}
long long __fixxfdi (long double a1)
{
long long ret; int s;
ret = __fixunsxfdi((s = a1 >= 0) ? a1 : -a1);
return s ? ret : -ret;
}
#if defined(TCC_TARGET_X86_64) && !defined(_WIN64)
#ifndef __TINYC__
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#else
/* Avoid including stdlib.h because it is not easily available when
cross compiling */
#include <stddef.h> /* size_t definition is needed for a x86_64-tcc to parse memset() */
void *malloc(unsigned long long);
void *memset(void *s, int c, size_t n);
void free(void*);
void abort(void);
#endif
enum __va_arg_type {
__va_gen_reg, __va_float_reg, __va_stack
};
//This should be in sync with the declaration on our include/stdarg.h
/* GCC compatible definition of va_list. */
typedef struct {
unsigned int gp_offset;
unsigned int fp_offset;
union {
unsigned int overflow_offset;
char *overflow_arg_area;
};
char *reg_save_area;
} __va_list_struct;
#undef __va_start
#undef __va_arg
#undef __va_copy
#undef __va_end
void __va_start(__va_list_struct *ap, void *fp)
{
memset(ap, 0, sizeof(__va_list_struct));
*ap = *(__va_list_struct *)((char *)fp - 16);
ap->overflow_arg_area = (char *)fp + ap->overflow_offset;
ap->reg_save_area = (char *)fp - 176 - 16;
}
void *__va_arg(__va_list_struct *ap,
enum __va_arg_type arg_type,
int size, int align)
{
size = (size + 7) & ~7;
align = (align + 7) & ~7;
switch (arg_type) {
case __va_gen_reg:
if (ap->gp_offset + size <= 48) {
ap->gp_offset += size;
return ap->reg_save_area + ap->gp_offset - size;
}
goto use_overflow_area;
case __va_float_reg:
if (ap->fp_offset < 128 + 48) {
ap->fp_offset += 16;
return ap->reg_save_area + ap->fp_offset - 16;
}
size = 8;
goto use_overflow_area;
case __va_stack:
use_overflow_area:
ap->overflow_arg_area += size;
ap->overflow_arg_area = (char*)((intptr_t)(ap->overflow_arg_area + align - 1) & -(intptr_t)align);
return ap->overflow_arg_area - size;
default:
#ifndef __TINYC__
fprintf(stderr, "unknown ABI type for __va_arg\n");
#endif
abort();
}
}
#endif /* __x86_64__ */
/* Flushing for tccrun */
#if defined(TCC_TARGET_X86_64) || defined(TCC_TARGET_I386)
void __clear_cache(void *beginning, void *end)
{
}
#elif defined(TCC_TARGET_ARM)
#define _GNU_SOURCE
#include <unistd.h>
#include <sys/syscall.h>
#include <stdio.h>
void __clear_cache(void *beginning, void *end)
{
/* __ARM_NR_cacheflush is kernel private and should not be used in user space.
* However, there is no ARM asm parser in tcc so we use it for now */
#if 1
syscall(__ARM_NR_cacheflush, beginning, end, 0);
#else
__asm__ ("push {r7}\n\t"
"mov r7, #0xf0002\n\t"
"mov r2, #0\n\t"
"swi 0\n\t"
"pop {r7}\n\t"
"ret");
#endif
}
#else
#warning __clear_cache not defined for this architecture, avoid using tcc -run
#endif

/programs/develop/ktcc/trunk/libc.obj/source/libtcc/memcpy.asm
0,0 → 1,24
format ELF
section '.text' executable
include '../../../../../proc32.inc'
public memcpy
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

/programs/develop/ktcc/trunk/libc.obj/source/libtcc/memmove.asm
0,0 → 1,34
format ELF
section '.text' executable
include '../../../../../proc32.inc'
public memmove
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

/programs/develop/ktcc/trunk/libc.obj/source/libtcc/memset.asm
0,0 → 1,16
format ELF
section '.text' executable
public memset
memset:
push edi
mov edi,[esp+8]
mov eax,[esp+12]
mov ecx,[esp+16]
jecxz .no_set
cld
rep stosb
.no_set:
mov eax, [esp+8]
pop edi
ret

/programs/develop/ktcc/trunk/libc.obj/source/setjmp/longjmp.s
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)

/programs/develop/ktcc/trunk/libc.obj/source/setjmp/setjmp.s
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

/programs/develop/ktcc/trunk/libc.obj/compile_flags.txt
0,0 → 1,5
-D
_BUILD_LIBC
-I
include

/programs/develop/ktcc/trunk/libc.obj/include/ctype.h
0,0 → 1,47
#ifndef _CTYPE_H_
#define _CTYPE_H_
/*
** All character classification functions except isascii().
** Integer argument (c) must be in ASCII range (0-127) for
** dependable answers.
*/
#include <stddef.h>
#define __ALNUM 1
#define __ALPHA 2
#define __CNTRL 4
#define __DIGIT 8
#define __GRAPH 16
#define __LOWER 32
#define __PRINT 64
#define __PUNCT 128
#define __BLANK 256
#define __UPPER 512
#define __XDIGIT 1024
#ifdef _BUILD_LIBC
extern unsigned short __is[129];
#else
extern unsigned short *__is;
#endif
#define isalnum(c)(__is[c+1] & __ALNUM ) /* 'a'-'z', 'A'-'Z', '0'-'9' */
#define isalpha(c)(__is[c+1] & __ALPHA ) /* 'a'-'z', 'A'-'Z' */
#define iscntrl(c)(__is[c+1] & __CNTRL ) /* 0-31, 127 */
#define isdigit(c)(__is[c+1] & __DIGIT ) /* '0'-'9' */
#define isgraph(c)(__is[c+1] & __GRAPH ) /* '!'-'~' */
#define islower(c)(__is[c+1] & __LOWER ) /* 'a'-'z' */
#define isprint(c)(__is[c+1] & __PRINT ) /* ' '-'~' */
#define ispunct(c)(__is[c+1] & __PUNCT ) /* !alnum && !cntrl && !space */
#define isspace(c)(__is[c+1] & __BLANK ) /* HT, LF, VT, FF, CR, ' ' */
#define isupper(c)(__is[c+1] & __UPPER ) /* 'A'-'Z' */
#define isxdigit(c)(__is[c+1] & __XDIGIT) /* '0'-'9', 'a'-'f', 'A'-'F' */
#define isascii(c) (!((c)&(~0x7f)))
#define toascii(c) ((c)&0x7f)
extern int _FUNC(tolower)(int c);
extern int _FUNC(toupper)(int c);
#endif

/programs/develop/ktcc/trunk/libc.obj/include/errno.h
0,0 → 1,150
#ifndef _ERRNO_H_
#define _ERRNO_H_
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifdef _BUILD_LIBC
extern int _errno;
#define errno _errno
#else
extern int* _errno;
#define errno *_errno
#endif
#define EPERM 1 /* Operation not permitted */
#define ENOENT 2 /* No such file or directory */
#define ESRCH 3 /* No such process */
#define EINTR 4 /* Interrupted system call */
#define EIO 5 /* Input/output error */
#define ENXIO 6 /* Device not configured */
#define E2BIG 7 /* Argument list too long */
#define ENOEXEC 8 /* Exec format error */
#define EBADF 9 /* Bad file descriptor */
#define ECHILD 10 /* No child processes */
#define EDEADLK 11 /* Resource deadlock avoided */
/* 11 was EAGAIN */
#define ENOMEM 12 /* Cannot allocate memory */
#define EACCES 13 /* Permission denied */
#define EFAULT 14 /* Bad address */
#define ENOTBLK 15 /* Block device required */
#define EBUSY 16 /* Device / Resource busy */
#define EEXIST 17 /* File exists */
#define EXDEV 18 /* Cross-device link */
#define ENODEV 19 /* Operation not supported by device */
#define ENOTDIR 20 /* Not a directory */
#define EISDIR 21 /* Is a directory */
#define EINVAL 22 /* Invalid argument */
#define ENFILE 23 /* Too many open files in system */
#define EMFILE 24 /* Too many open files */
#define ENOTTY 25 /* Inappropriate ioctl for device */
#define ETXTBSY 26 /* Text file busy */
#define EFBIG 27 /* File too large */
#define ENOSPC 28 /* No space left on device */
#define ESPIPE 29 /* Illegal seek */
#define EROFS 30 /* Read-only file system */
#define EMLINK 31 /* Too many links */
#define EPIPE 32 /* Broken pipe */
/* math software */
#define EDOM 33 /* Numerical argument out of domain */
#define ERANGE 34 /* Result too large */
/* non-blocking and interrupt i/o */
#define EAGAIN 35 /* Resource temporarily unavailable */
#define EWOULDBLOCK EAGAIN /* Operation would block */
#define EINPROGRESS 36 /* Operation now in progress */
#define EALREADY 37 /* Operation already in progress */
/* ipc/network software -- argument errors */
#define ENOTSOCK 38 /* Socket operation on non-socket */
#define EDESTADDRREQ 39 /* Destination address required */
#define EMSGSIZE 40 /* Message too long */
#define EPROTOTYPE 41 /* Protocol wrong type for socket */
#define ENOPROTOOPT 42 /* Protocol not available */
#define EPROTONOSUPPORT 43 /* Protocol not supported */
#define ESOCKTNOSUPPORT 44 /* Socket type not supported */
#define ENOTSUP 45 /* Operation not supported */
#define EOPNOTSUPP ENOTSUP /* Operation not supported on socket */
#define EPFNOSUPPORT 46 /* Protocol family not supported */
#define EAFNOSUPPORT 47 /* Address family not supported by protocol family */
#define EADDRINUSE 48 /* Address already in use */
#define EADDRNOTAVAIL 49 /* Can't assign requested address */
/* ipc/network software -- operational errors */
#define ENETDOWN 50 /* Network is down */
#define ENETUNREACH 51 /* Network is unreachable */
#define ENETRESET 52 /* Network dropped connection on reset */
#define ECONNABORTED 53 /* Software caused connection abort */
#define ECONNRESET 54 /* Connection reset by peer */
#define ENOBUFS 55 /* No buffer space available */
#define EISCONN 56 /* Socket is already connected */
#define ENOTCONN 57 /* Socket is not connected */
#define ESHUTDOWN 58 /* Can't send after socket shutdown */
#define ETOOMANYREFS 59 /* Too many references: can't splice */
#define ETIMEDOUT 60 /* Operation timed out */
#define ECONNREFUSED 61 /* Connection refused */
#define ELOOP 62 /* Too many levels of symbolic links */
#define ENAMETOOLONG 63 /* File name too long */
/* should be rearranged */
#define EHOSTDOWN 64 /* Host is down */
#define EHOSTUNREACH 65 /* No route to host */
#define ENOTEMPTY 66 /* Directory not empty */
/* quotas & mush */
#define EPROCLIM 67 /* Too many processes */
#define EUSERS 68 /* Too many users */
#define EDQUOT 69 /* Disc quota exceeded */
/* Network File System */
#define ESTALE 70 /* Stale NFS file handle */
#define EREMOTE 71 /* Too many levels of remote in path */
#define EBADRPC 72 /* RPC struct is bad */
#define ERPCMISMATCH 73 /* RPC version wrong */
#define EPROGUNAVAIL 74 /* RPC prog. not avail */
#define EPROGMISMATCH 75 /* Program version wrong */
#define EPROCUNAVAIL 76 /* Bad procedure for program */
#define ENOLCK 77 /* No locks available */
#define ENOSYS 78 /* Function not implemented */
#define EFTYPE 79 /* Inappropriate file type or format */
#define EAUTH 80 /* Authentication error */
#define ENEEDAUTH 81 /* Need authenticator */
/* Intelligent device errors */
#define EPWROFF 82 /* Device power is off */
#define EDEVERR 83 /* Device error, e.g. paper out */
#define EOVERFLOW 84 /* Value too large to be stored in data type */
/* Program loading errors */
#define EBADEXEC 85 /* Bad executable */
#define EBADARCH 86 /* Bad CPU type in executable */
#define ESHLIBVERS 87 /* Shared library version mismatch */
#define EBADMACHO 88 /* Malformed Macho file */
#define ECANCELED 89 /* Operation canceled */
#define EIDRM 90 /* Identifier removed */
#define ENOMSG 91 /* No message of desired type */
#define EILSEQ 92 /* Illegal byte sequence */
#define ENOATTR 93 /* Attribute not found */
#define EBADMSG 94 /* Bad message */
#define EMULTIHOP 95 /* Reserved */
#define ENODATA 96 /* No message available on STREAM */
#define ENOLINK 97 /* Reserved */
#define ENOSR 98 /* No STREAM resources */
#define ENOSTR 99 /* Not a STREAM */
#define EPROTO 100 /* Protocol error */
#define ETIME 101 /* STREAM ioctl timeout */
#define ENOPOLICY 103 /* No such policy registered */
#define ENOTRECOVERABLE 104 /* State not recoverable */
#define EOWNERDEAD 105 /* Previous owner died */
#define EQFULL 106 /* Interface output queue is full */
#define ELAST 106 /* Must be equal largest errno */
#ifdef __cplusplus
}
#endif
#endif // _ERRNO_H_

/programs/develop/ktcc/trunk/libc.obj/include/limits.h
0,0 → 1,22
#ifndef _LIMITS_H_
#define _LIMITS_H_
#define INT_MAX 2147483647
#define INT_MIN -2147483648
#define UINT_MAX (INT_MAX * 2U + 1)
#ifndef ARG_MAX
#define ARG_MAX 4096
#endif
#ifndef PATH_MAX
#define PATH_MAX 4096
#endif
#ifndef STDIO_MAX_MEM
#define STDIO_MAX_MEM 4096
#endif
#endif /* _LIMITS_H_ */

/programs/develop/ktcc/trunk/libc.obj/include/stddef.h
0,0 → 1,37
#ifndef _STDDEF_H_
#define _STDDEF_H_
typedef __SIZE_TYPE__ size_t;
typedef __PTRDIFF_TYPE__ ssize_t;
typedef __WCHAR_TYPE__ wchar_t;
typedef __PTRDIFF_TYPE__ ptrdiff_t;
typedef __PTRDIFF_TYPE__ intptr_t;
typedef __SIZE_TYPE__ uintptr_t;
#ifndef __int8_t_defined
#define __int8_t_defined
typedef signed char int8_t;
typedef signed short int int16_t;
typedef signed int int32_t;
typedef signed long long int int64_t;
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long int uint64_t;
typedef int64_t intmax_t;
typedef uint64_t uintmax_t;
#endif
#ifndef NULL
#define NULL ((void*)0)
#endif
#ifdef _BUILD_LIBC
#define _FUNC(func) func
#else
#define _FUNC(func) (*func)
#endif
#define offsetof(type, field) ((size_t)&((type *)0)->field)
#endif /* _STDDEF_H_ */

/programs/develop/ktcc/trunk/libc.obj/include/sys/socket.h
0,0 → 1,91
/* Copyright (C) 2019-2021 Logaev Maxim (turbocat2001), GPLv2 */
#ifndef _SOCKET_H_
#define _SOCKET_H_
#include <stddef.h>
#include <sys/ksys.h>
#include <errno.h>
// Socket Types
#define SOCK_STREAM 1
#define SOCK_DGRAM 2
#define SOCK_RAW 3
// IP protocols
#define IPPROTO_IP 0
#define IPPROTO_ICMP 1
#define IPPROTO_TCP 6
#define IPPROTO_UDP 17
#define IPPROTO_RAW 255
// IP options
#define IP_TTL 2
// Address families
#define AF_UNSPEC 0
#define AF_LOCAL 1
#define AF_INET 2 // Default INET=IPv4
#define AF_INET4 2 // IPv4
#define AF_INET6 10 // IPv6
#define PF_UNSPEC AF_UNSPEC
#define PF_LOCAL AF_LOCAL
#define PF_INET4 AF_INET4
#define PF_INET6 AF_INET6
// internal definition
#define AI_SUPPORTED 0x40F
// for system function 76
#define API_ETH (0<<16)
#define API_IPv4 (1<<16)
#define API_ICMP (2<<16)
#define API_UDP (3<<16)
#define API_TCP (4<<16)
#define API_ARP (5<<16)
#define API_PPPOE (6<<16)
// Socket flags for user calls
#define MSG_NOFLAG 0
#define MSG_PEEK 0x02
#define MSG_DONTWAIT 0x40
// Socket levels
#define SOL_SOCKET 0xffff
//Socket options
#define SO_BINDTODEVICE (1<<9)
#define SO_NONBLOCK (1<<31)
#define PORT(X) (X<<8)
#pragma pack(push,1)
struct sockaddr{
unsigned short sin_family;
unsigned short sin_port;
unsigned int sin_addr;
unsigned long long sin_zero;
};
typedef struct{
unsigned int level;
unsigned int optionname;
unsigned int optlenght;
unsigned char options;
}optstruct;
#pragma pack(pop)
extern int _FUNC(socket)(int domain, int type, int protocol);
extern int _FUNC(close)(int socket);
extern int _FUNC(bind)(int socket, const struct sockaddr *addres, int addres_len);
extern int _FUNC(listen)(int socket, int backlog);
extern int _FUNC(connect)(int socket, const struct sockaddr* address, int socket_len);
extern int _FUNC(accept)(int socket, const struct sockaddr *address, int address_len);
extern int _FUNC(send)(int socket, const void *message, size_t msg_len, int flag);
extern int _FUNC(recv)(int socket, void *buffer, size_t buff_len, int flag);
extern int _FUNC(setsockopt)(int socket,const optstruct* opt);
extern int _FUNC(getsockopt)(int socket, optstruct* opt);
extern int _FUNC(socketpair)(int *socket1, int *socket2);
#endif //_SOCKET_H_

/programs/develop/ktcc/trunk/libc.obj/include/sys/dir.h
0,0 → 1,11
#ifndef _DIR_H_
#define _DIR_H_
#include <stddef.h>
extern char* _FUNC(getcwd)(char *buf, unsigned size);
extern void _FUNC(setcwd)(const char* cwd);
extern int _FUNC(rmdir)(const char* dir);
extern int _FUNC(mkdir)(const char* dir);
#endif

/programs/develop/ktcc/trunk/libc.obj/include/sys/dirent.h
0,0 → 1,34
/* Copyright (C) 2021 Logaev Maxim (turbocat2001), GPLv2 */
#ifndef _DIRENT_H_
#define _DIRENT_H_
#include <stddef.h>
#include <limits.h>
#define IS_FOLDER 16
#define IS_FILE 0
typedef unsigned ino_t;
struct dirent{
ino_t d_ino; //File serial number.
char d_name[PATH_MAX]; // Name of entry.
unsigned d_type;
};
typedef struct{
struct dirent* objs;
ino_t pos;
ino_t num_objs;
}DIR;
extern int _FUNC(closedir)(DIR *dir);
extern DIR* _FUNC(opendir)(const char *path);
extern struct dirent* _FUNC(readdir)(DIR *);
extern void _FUNC(rewinddir)(DIR *dir);
extern void _FUNC(seekdir)(DIR *dir, unsigned pos);
extern unsigned _FUNC(telldir)(DIR *dir);
#endif // _DIRENT_H_

/programs/develop/ktcc/trunk/libc.obj/include/sys/ksys.h
0,0 → 1,1052
#ifndef _KSYS_H_
#define _KSYS_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stddef.h>
#define asm_inline __asm__ __volatile__
#define KSYS_FS_ERR_SUCCESS 0 // Success
#define KSYS_FS_ERR_1 1 // Base and/or partition of a hard disk is not defined (fn21.7 & fn21.8)
#define KSYS_FS_ERR_2 2 // Function is not supported for the given file system
#define KSYS_FS_ERR_3 3 // Unknown file system
#define KSYS_FS_ERR_4 4 // Reserved, is never returned in the current implementation
#define KSYS_FS_ERR_5 5 // File not found
#define KSYS_FS_ERR_EOF 6 // End of file, EOF
#define KSYS_FS_ERR_7 7 // Pointer lies outside of application memory
#define KSYS_FS_ERR_8 8 // Disk is full
#define KSYS_FS_ERR_9 9 // FAT table is destroyed
#define KSYS_FS_ERR_10 10 // Access denied
#define KSYS_FS_ERR_11 11 // Device error
typedef void ksys_panic(char *func_name);
typedef struct {
unsigned char blue;
unsigned char green;
unsigned char red;
}rgb_t;
#pragma pack(push,1)
typedef union{
unsigned val;
struct{
short x;
short y;
};
}ksys_pos_t;
typedef union ksys_oskey_t{
unsigned val;
struct{
unsigned char state;
unsigned char code;
unsigned char ctrl_key;
};
}ksys_oskey_t;
typedef struct{
void *data;
size_t size;
}ksys_ufile_t;
typedef struct{
unsigned p00;
union{
uint64_t p04;
struct {
unsigned p04dw;
unsigned p08dw;
};
};
unsigned p12;
union {
unsigned p16;
const char *new_name;
void *bdfe;
void *buf16;
const void *cbuf16;
};
char p20;
const char *p21;
}ksys70_t;
typedef struct {
unsigned attributes;
unsigned name_cp;
char creation_time[4];
char creation_date[4];
char last_access_time[4];
char last_access_date[4];
char last_modification_time[4];
char last_modification_date[4];
unsigned long long size;
char name[0];
}ksys_bdfe_t;
typedef struct {
int cpu_usage; //+0
int window_pos_info; //+4
short int reserved1; //+8
char name[12]; //+10
int memstart; //+22
int memused; //+26
int pid; //+30
int winx_start; //+34
int winy_start; //+38
int winx_size; //+42
int winy_size; //+46
short int slot_info; //+50
short int reserved2; //+52
int clientx; //+54
int clienty; //+58
int clientwidth; //+62
int clientheight; //+66
unsigned char window_state;//+70
char reserved3[1024-71]; //+71
}ksys_proc_table_t;
typedef unsigned int ksys_color_t;
typedef struct{
ksys_color_t frame_area;
ksys_color_t grab_bar;
ksys_color_t grab_bar_button;
ksys_color_t grab_button_text;
ksys_color_t grab_text;
ksys_color_t work_area;
ksys_color_t work_button;
ksys_color_t work_button_text;
ksys_color_t work_text;
ksys_color_t work_graph;
}ksys_colors_table_t;
typedef struct{
unsigned pid; // PID of sending thread
unsigned datalen; // data bytes
char *data; // data begin
}ksys_ipc_msg;
typedef struct{
unsigned lock; // nonzero is locked
unsigned used; // used bytes in buffer
ksys_ipc_msg *data; // data begin
}ksys_ipc_buffer;
typedef struct {
char* func_name;
void* func_ptr;
}ksys_coff_etable_t;
typedef unsigned ksys_drv_hand_t;
typedef struct{
ksys_drv_hand_t handler;
unsigned func_num;
void* in_data_ptr;
unsigned in_data_size;
void* out_data_ptr;
unsigned out_data_size;
}ksys_ioctl_t;
#pragma pack(pop)
enum KSYS_EVENTS {
KSYS_EVENT_NONE = 0, /* Event queue is empty */
KSYS_EVENT_REDRAW = 1, /* Window and window elements should be redrawn */
KSYS_EVENT_KEY = 2, /* A key on the keyboard was pressed */
KSYS_EVENT_BUTTON = 3, /* A button was clicked with the mouse */
KSYS_EVENT_DESKTOP = 5, /* Desktop redraw finished */
KSYS_EVENT_MOUSE = 6, /* Mouse activity (movement, button press) was detected */
KSYS_EVENT_IPC = 7, /* Interprocess communication notify */
KSYS_EVENT_NETWORK = 8, /* Network event */
KSYS_EVENT_DEBUG = 9, /* Debug subsystem event */
KSYS_EVENT_IRQBEGIN = 16 /* 16..31 IRQ0..IRQ15 interrupt =IRQBEGIN+IRQn */
};
enum KSYS_FILE_ENCODING{
KSYS_FILE_CP866 =1,
KSYS_FILE_UTF16LE = 2,
KSYS_FILE_UTF8 = 3
};
enum KSYS_CLIP_ENCODING{
KSYS_CLIP_UTF8 = 0,
KSYS_CLIP_CP866 = 1,
KSYS_CLIP_CP1251 = 2
};
enum KSYS_CLIP_TYPES{
KSYS_CLIP_TEXT = 0,
KSYS_CLIP_IMAGE = 1,
KSYS_CLIP_RAW = 2
};
enum KSYS_MOUSE_POS{
KSYS_MOUSE_SCREEN_POS = 0,
KSYS_MOUSE_WINDOW_POS = 1
};
enum KSYS_SHM_MODE{
KSYS_SHM_OPEN = 0x00,
KSYS_SHM_OPEN_ALWAYS = 0x04,
KSYS_SHM_CREATE = 0x08,
KSYS_SHM_READ = 0x00,
KSYS_SHM_WRITE = 0x01,
};
static inline
int _ksys_strcmp(const char * s1, const char * s2 )
{
while ((*s1) && (*s1 == *s2)){ ++s1; ++s2; }
return(*(unsigned char*)s1 - *(unsigned char *)s2);
}
// Functions for working with the graphical interface
static inline
void _ksys_start_draw()
{
asm_inline("int $0x40"::"a"(12),"b"(1));
}
static inline
void _ksys_end_draw()
{
asm_inline("int $0x40" ::"a"(12),"b"(2));
}
static inline
void _ksys_create_window(int x, int y, int w, int h, const char *name, ksys_color_t workcolor, unsigned style)
{
asm_inline(
"int $0x40"
::"a"(0),
"b"((x << 16) | ((w-1) & 0xFFFF)),
"c"((y << 16) | ((h-1) & 0xFFFF)),
"d"((style << 24) | (workcolor & 0xFFFFFF)),
"D"(name),
"S"(0)
:"memory"
);
};
static inline
void _ksys_change_window(int new_x, int new_y, int new_w, int new_h)
{
asm_inline(
"int $0x40"
::"a"(67), "b"(new_x), "c"(new_y), "d"(new_w),"S"(new_h)
);
}
static inline
void _ksys_define_button(unsigned x, unsigned y, unsigned w, unsigned h, unsigned id, ksys_color_t color)
{
asm_inline(
"int $0x40"
::"a"(8),
"b"((x<<16)+w),
"c"((y<<16)+h),
"d"(id),
"S"(color)
);
};
static inline
void _ksys_draw_line(int xs, int ys, int xe, int ye, ksys_color_t color)
{
asm_inline(
"int $0x40"
::"a"(38), "d"(color),
"b"((xs << 16) | xe),
"c"((ys << 16) | ye)
);
}
static inline
void _ksys_draw_bar(int x, int y, int w, int h, ksys_color_t color)
{
asm_inline(
"int $0x40"
::"a"(13), "d"(color),
"b"((x << 16) | w),
"c"((y << 16) | h)
);
}
static inline
void _ksys_draw_bitmap(void *bitmap, int x, int y, int w, int h)
{
asm_inline(
"int $0x40"
::"a"(7), "b"(bitmap),
"c"((w << 16) | h),
"d"((x << 16) | y)
:"memory"
);
}
static inline
void _ksys_draw_text(const char *text, int x, int y, int len, ksys_color_t color)
{
asm_inline(
"int $0x40"
::"a"(4),"d"(text),
"b"((x << 16) | y),
"S"(len),"c"(color)
:"memory"
);
}
static inline
void _ksys_draw_text_bg(const char *text, int x, int y, int len, ksys_color_t color, ksys_color_t bg)
{
asm_inline(
"int $0x40"
::"a"(4),"d"(text),
"b"((x << 16) | y),
"S"(len),"c"(color), "D"(bg)
:"memory"
);
}
static inline
void _ksys_draw_number(int number, int x, int y, int len, ksys_color_t color){
unsigned fmt;
fmt = len << 16 | 0x80000000; // no leading zeros + width
asm_inline(
"int $0x40"
::"a"(47), "b"(fmt), "c"(number), "d"((x << 16) | y), "S"(color)
);
}
static inline
void _ksys_draw_number_bg(unsigned number, int x, int y, int len, ksys_color_t color, ksys_color_t bg){
unsigned fmt;
fmt = len << 16 | 0x80000000; // no leading zeros + width
asm_inline(
"int $0x40"
::"a"(47), "b"(fmt), "c"(number), "d"((x << 16) | y), "S"(color), "D"(bg)
);
}
static inline
unsigned _ksys_get_skin_height()
{
unsigned height;
asm_inline(
"int $0x40 \n\t"
:"=a"(height)
:"a"(48),"b"(4)
);
return height;
}
static inline
void _ksys_get_system_colors(ksys_colors_table_t *color_table)
{
asm_inline(
"int $0x40"
::"a"(48),"b"(3),"c"(color_table),"d"(40)
);
}
/* Functions for working with a screen. */
static inline
ksys_pos_t _ksys_screen_size()
{
ksys_pos_t size;
ksys_pos_t size_tmp;
asm_inline(
"int $0x40"
:"=a"(size_tmp)
:"a"(14)
);
size.x = size_tmp.y;
size.y = size_tmp.x;
return size;
}
/* Functions for working with a mouse and cursors. */
static inline
ksys_pos_t _ksys_get_mouse_pos(int origin)
{
ksys_pos_t pos;
asm_inline(
"int $0x40 \n\t"
"rol $16, %%eax"
:"=a"(pos)
:"a"(37),"b"(origin)
);
return pos;
}
static inline
unsigned _ksys_get_mouse_buttons()
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(37),"b"(2)
);
return val;
}
static inline
unsigned _ksys_get_mouse_wheels()
{
unsigned val;
asm_inline(
"int $0x40 \n\t"
:"=a"(val)
:"a"(37),"b"(7)
);
return val;
}
static inline
unsigned _ksys_load_cursor(void *path, unsigned flags)
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(37), "b"(4), "c"(path), "d"(flags)
:"memory"
);
return val;
}
static inline
unsigned _ksys_set_cursor(unsigned cursor)
{
unsigned old;
asm_inline(
"int $0x40"
:"=a"(old)
:"a"(37), "b"(5), "c"(cursor)
);
return old;
}
static inline
int _ksys_destroy_cursor(unsigned cursor)
{
int ret;
asm_inline(
"int $0x40"
:"=a"(ret)
:"a"(37), "b"(6), "c"(cursor)
:"memory"
);
return ret;
}
static inline
unsigned _ksys_get_mouse_eventstate()
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(37),"b"(3)
);
return val;
}
/* Functions for working with events and buttons. */
static inline
unsigned _ksys_set_event_mask(unsigned mask)
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(40), "b"(mask)
);
return val;
}
static inline
unsigned _ksys_wait_event(unsigned time)
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(23), "b"(time)
);
return val;
}
static inline
unsigned _ksys_check_event()
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(11)
);
return val;
}
static inline
unsigned _ksys_get_event()
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(10)
);
return val;
}
static inline
unsigned _ksys_get_button()
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(17)
);
return val>>8;
}
static inline
ksys_oskey_t _ksys_get_key(void)
{
ksys_oskey_t val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(2)
);
return val;
}
/* Functions for working with the clipboard */
static inline
int _ksys_clip_num()
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(54), "b"(0)
);
return val;
}
static inline
char* _ksys_clip_get(int n) // returned buffer must be freed by _ksys_free()
{
char* val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(54), "b"(1), "c"(n)
);
return val;
}
static inline
int _ksys_clip_set(int n, char *buffer)
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(54), "b"(2), "c"(n), "d"(buffer)
:"memory"
);
return val;
}
static inline
int _ksys_clip_pop()
{
unsigned val;
asm_inline (
"int $0x40"
:"=a"(val)
:"a"(54), "b"(3)
);
return val;
}
static inline
int _ksys_clip_unlock()
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(54), "b"(4)
);
return val;
}
/* Working with time */
static inline
unsigned _ksys_get_tick_count()
{
unsigned val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(26),"b"(9)
);
return val;
}
static inline
uint64_t _ksys_get_ns_count()
{
uint64_t val;
asm_inline(
"int $0x40"
:"=A"(val)
:"a"(26), "b"(10)
);
return val;
}
static inline
void _ksys_delay(unsigned time)
{
asm_inline(
"int $0x40"
::"a"(5), "b"(time)
:"memory"
);
}
static inline
unsigned _ksys_get_date()
{
unsigned val;
asm_inline("int $0x40":"=a"(val):"a"(29));
return val;
}
static inline
unsigned _ksys_get_clock()
{
unsigned val;
asm_inline("int $0x40":"=a"(val):"a"(3));
return val;
}
/* Working with memory allocation */
static inline
void* _ksys_alloc(size_t size){
void *val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(68),"b"(12),"c"(size)
);
return val;
}
static inline
int _ksys_free(void *mem)
{
int val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(68),"b"(13),"c"(mem)
);
return val;
}
static inline
void* _ksys_realloc(void *mem, size_t size)
{
void *val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(68),"b"(20),"c"(size),"d"(mem)
:"memory"
);
return val;
}
static inline
int* _ksys_unmap(void *base, size_t offset, size_t size)
{
int *val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(68),"b"(26),"c"(base),"d"(offset),"S"(size)
);
return val;
}
/* Loading the dynamic coff library */
static inline
ksys_coff_etable_t* _ksys_load_coff(const char* path)
{
ksys_coff_etable_t *table;
asm_inline(
"int $0x40"
:"=a"(table)
:"a"(68),"b"(19), "c"(path)
:"memory"
);
return table;
}
static inline
void* _ksys_get_coff_func(ksys_coff_etable_t *table, const char* fun_name, ksys_panic* panic)
{
unsigned i=0;
while (1){
if (NULL == (table+i)->func_name){
break;
}else{
if (!_ksys_strcmp(fun_name, (table+i)->func_name)){
return (table+i)->func_ptr;
}
}
i++;
}
panic((char*)fun_name);
return NULL;
}
/* Debug board functions */
static inline
void _ksys_debug_putc(char c)
{
asm_inline("int $0x40"::"a"(63), "b"(1), "c"(c));
}
static inline
void _ksys_debug_puts(char *s)
{
unsigned i=0;
while (*(s+i)){
asm_inline ("int $0x40"::"a"(63), "b"(1), "c"(*(s+i)));
i++;
}
}
/* Working with threads and process */
static inline
int _ksys_start_thread(void* proc, char* stack_top)
{
int val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(51), "b"(1), "c"(proc), "d"(stack_top)
);
return val;
}
static inline
void _ksys_focus_window(int slot){
asm_inline(
"int $0x40"
::"a"(18), "b"(3), "c"(slot)
);
}
static inline
int _ksys_get_thread_slot(int tid){
int val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(18), "b"(21), "c"(tid)
);
return val;
}
static inline
int _ksys_process_info(ksys_proc_table_t* table, int pid)
{
int val;
asm_inline(
"int $0x40"
:"=a"(val)
:"a"(9), "b"(table), "c"(pid)
:"memory"
);
return val;
}
static inline
void _ksys_exit()
{
asm_inline("int $0x40"::"a"(-1));
}
/* Working with files and directories */
static inline
void _ksys_setcwd(char* dir){
asm_inline(
"int $0x40"
::"a"(30), "b"(1), "c"(dir)
);
}
static inline
int _ksys_getcwd(char* buf, int bufsize){
register int val;
asm_inline(
"int $0x40"
:"=a"(val):"a"(30), "b"(2), "c"(buf), "d"(bufsize)
);
return val;
}
static inline
ksys_ufile_t _ksys_load_file(const char *path)
{
ksys_ufile_t uf;
asm_inline(
"int $0x40"
:"=a"(uf.data), "=d"(uf.size)
:"a"(68), "b"(27),"c"(path)
:"memory"
);
return uf;
}
static inline
ksys_ufile_t _ksys_load_file_enc(const char *path, unsigned file_encoding)
{
ksys_ufile_t uf;
asm_inline(
"int $0x40"
:"=a"(uf.data), "=d"(uf.size)
:"a"(68), "b"(28),"c"(path), "d"(file_encoding)
:"memory"
);
return uf;
}
static inline
int _ksys_work_files(const ksys70_t *k)
{
int status;
asm_inline(
"int $0x40"
:"=a"(status)
:"a"(70), "b"(k)
:"memory"
);
return status;
}
static inline
int _ksys_file_read_file(const char *name, unsigned long long offset, unsigned size, void *buf, unsigned *bytes_read)
{
ksys70_t k;
k.p00 = 0;
k.p04 = offset;
k.p12 = size;
k.buf16 = buf;
k.p20 = 0;
k.p21 = name;
int status;
unsigned bytes_read_v;
asm_inline(
"int $0x40"
:"=a"(status), "=b"(bytes_read_v)
:"a"(70), "b"(&k)
:"memory"
);
if (!status) {
*bytes_read = bytes_read_v;
}
return status;
}
static inline
int _ksys_file_write_file(const char *name, unsigned long long offset, unsigned size, const void *buf, unsigned *bytes_written)
{
ksys70_t k;
k.p00 = 3;
k.p04 = offset;
k.p12 = size;
k.cbuf16 = buf;
k.p20 = 0;
k.p21 = name;
int status;
unsigned bytes_written_v;
asm_inline(
"int $0x40"
:"=a"(status), "=b"(bytes_written_v)
:"a"(70), "b"(&k)
:"memory"
);
if (!status) {
*bytes_written = bytes_written_v;
}
return status;
}
static inline
int _ksys_file_create(const char* name){
ksys70_t k;
k.p00 = 2;
k.p12 = 0;
k.p21 = name;
return _ksys_work_files(&k);
}
static inline
int _ksys_file_get_info(const char *name, ksys_bdfe_t *bdfe)
{
ksys70_t k;
k.p00 = 5;
k.bdfe = bdfe;
k.p20 = 0;
k.p21 = name;
return _ksys_work_files(&k);
}
static inline
int _ksys_file_delete(const char *name)
{
ksys70_t k;
k.p00 = 8;
k.p20 = 0;
k.p21 = name;
return _ksys_work_files(&k);
}
static inline
int _ksys_file_rename(const char *name, const char *new_name)
{
ksys70_t k;
k.p00 = 10;
k.new_name = new_name;
k.p20 = 0;
k.p21 = name;
return _ksys_work_files(&k);
}
static inline
int _ksys_exec(char *app_name, char *args)
{
ksys70_t file_opt;
file_opt.p00 = 7;
file_opt.p04dw = 0;
file_opt.p08dw = (unsigned)args;
file_opt.p21 = app_name;
return _ksys_work_files(&file_opt);
}
static inline
int _ksys_mkdir(const char *path)
{
ksys70_t dir_opt;
dir_opt.p00 = 9;
dir_opt.p21 = path;
return _ksys_work_files(&dir_opt);
}
/* Working with a named shared memory area. */
static inline
int _ksys_shm_open(char *name, int mode, int size, char **new_shm)
{
int error;
asm_inline(
"int $0x40"
:"=a"(*new_shm), "=d"(error)
:"a"(68), "b"(22), "c"(name), "d"(size), "S"(mode)
);
return error;
}
static inline
void _ksys_shm_close(char *shm_name)
{
asm_inline(
"int $0x40":
:"a"(68), "b"(23), "c"(shm_name)
);
}
/* Driver functions */
static inline
ksys_drv_hand_t _ksys_load_driver(char *driver_name)
{
ksys_drv_hand_t driver_h;
asm_inline(
"int $0x40"
:"=a"(driver_h)
:"a"(68), "b"(16), "c"(driver_name)
);
return driver_h;
}
static inline
ksys_drv_hand_t _ksys_load_pe_driver(char *driver_path, char *cmd_line)
{
ksys_drv_hand_t driver_h;
asm_inline(
"int $0x40"
:"=a"(driver_h)
:"a"(68), "b"(21), "c"(driver_path), "d"(cmd_line)
);
return driver_h;
}
static inline
unsigned _ksys_work_driver(ksys_ioctl_t *ioctl)
{
unsigned status;
asm_inline(
"int $0x40"
:"=a"(status)
:"a"(68), "b"(17), "c"(ioctl)
:"memory"
);
return status;
}
#ifdef __cplusplus
}
#endif
#endif // _KSYS_H_

/programs/develop/ktcc/trunk/libc.obj/include/time.h
0,0 → 1,31
#ifndef _TIME_H_
#define _TIME_H_
#include <sys/ksys.h>
typedef unsigned long int clock_t;
typedef unsigned long int time_t;
#define clock() _ksys_get_clock()
#define CLOCKS_PER_SEC 100
#pragma pack(push, 1)
struct tm {
int tm_sec; /* seconds after the minute 0-61*/
int tm_min; /* minutes after the hour 0-59 */
int tm_hour; /* hours since midnight 0-23 */
int tm_mday; /* day of the month 1-31 */
int tm_mon; /* months since January 0-11 */
int tm_year; /* years since 1900 */
int tm_wday; /* days since Sunday 0-6 */
int tm_yday; /* days since January 1 0-365 */
int tm_isdst; /* Daylight Saving Time flag */
};
#pragma pack(pop)
extern time_t _FUNC(mktime)(struct tm * timeptr);
extern time_t _FUNC(time)(time_t* timer);
extern struct tm * _FUNC(localtime)(const time_t * timer);
extern double _FUNC(difftime)(time_t end, time_t beginning);
extern char* _FUNC(asctime)(const struct tm *tm);
#endif

/programs/develop/ktcc/trunk/libc.obj/include/conio.h
0,0 → 1,62
/*
This is adapded thunk for console.obj sys library
.h is equal to svn:\programs\develop\libraries\console\console_en.txt
Adapted for tcc by Siemargl, 2016
*/
#ifndef _CONIO_H_
#define _CONIO_H_
#include <stddef.h>
#define cdecl __attribute__ ((cdecl))
#define stdcall __attribute__ ((stdcall))
/*
console.obj exports the following functions
*/
typedef unsigned int dword; /* 32-bit unsigned integer */
typedef unsigned short word; /* 16-bit unsigned integer */
#define CON_WINDOW_CLOSED 0x200
#define CON_COLOR_BLUE 0x01
#define CON_COLOR_GREEN 0x02
#define CON_COLOR_RED 0x04
#define CON_COLOR_BRIGHT 0x08
/* background color */
#define CON_BGR_BLUE 0x10
#define CON_BGR_GREEN 0x20
#define CON_BGR_RED 0x40
#define CON_BGR_BRIGHT 0x80
/* output controls */
#define CON_IGNORE_SPECIALS 0x100
extern int _FUNC(con_init)(void);
extern int _FUNC(con_init_opt)(dword wnd_width, dword wnd_height, dword scr_width, dword scr_height, const char* title);
extern void stdcall _FUNC((*con_exit))(int bCloseWindow);
extern void stdcall _FUNC((*con_set_title))(const char* title);
extern void stdcall _FUNC((*con_write_asciiz))(const char* str);
extern void stdcall _FUNC((*con_write_string))(const char* str, dword length);
extern int cdecl _FUNC((*con_printf))(const char* format, ...);
extern dword stdcall _FUNC((*con_get_flags))(void);
extern dword stdcall _FUNC((*con_set_flags))(dword new_flags);
extern int stdcall _FUNC((*con_get_font_height))(void);
extern int stdcall _FUNC((*con_get_cursor_height))(void);
extern int stdcall _FUNC((*con_set_cursor_height))(int new_height);
extern int stdcall _FUNC((*con_getch))(void);
extern word stdcall _FUNC((*con_getch2))(void);
extern int stdcall _FUNC((*con_kbhit))(void);
extern char* stdcall _FUNC((*con_gets))(char* str, int n);
typedef int (stdcall _FUNC(* con_gets2_callback))(int keycode, char** pstr, int* pn, int* ppos);
extern char* stdcall _FUNC((*con_gets2))(con_gets2_callback callback, char* str, int n);
extern void stdcall _FUNC((*con_cls))();
extern void stdcall _FUNC((*con_get_cursor_pos))(int* px, int* py);
extern void stdcall _FUNC((*con_set_cursor_pos))(int x, int y);
extern int _FUNC(__con_is_load);
#endif

/programs/develop/ktcc/trunk/libc.obj/include/stdio.h
0,0 → 1,138
///////////////////////////////////////////////////////////////////////////////
// \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 snprintf implementation, optimized for speed on
// embedded systems with a very limited resources.
// Use this instead of bloated standard/newlib printf.
// These routines are thread safe and reentrant.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef _STDIO_H_
#define _STDIO_H_
#include <stdarg.h>
#include <stddef.h>
#include <sys/ksys.h>
extern int _FUNC(puts)(const char *str);
extern int _FUNC(printf)(const char* format, ...);
extern int _FUNC(sprintf)(char* buffer, const char* format, ...);
extern int _FUNC(snprintf)(char* buffer, size_t count, const char* format, ...);
extern int _FUNC(vsnprintf)(char* buffer, size_t count, const char* format, va_list va);
extern int _FUNC(vprintf)(const char* format, va_list va);
extern void _FUNC(debug_printf)(const char* format, ...);
typedef size_t fpos_t;
#define _FILEMODE_R 1 << 0 // Read
#define _FILEMODE_W 1 << 1 // Write
#define _FILEMODE_A 1 << 2 // Append
typedef struct FILE_s {
char *name;
fpos_t position;
int error;
int eof;
int mode; // flags _FILEMODE_*
int __ungetc_emu_buff; // Uses __ungetc_emu (temporary solution!)
} FILE;
#define _IOFBF 0
#define _IOLBF 1
#define _IONBF 2
#define BUFSIZ 1024
#define EOF -1
#define FOPEN_MAX 0xffffffff
#define FILENAME_MAX 255
#define L_tmpnam FILENAME_MAX
#define SEEK_CUR 0
#define SEEK_END 1
#define SEEK_SET 2
#define TMP_MAX FOPEN_MAX
#define stderr (FILE*)3
#define stdin (FILE*)1
#define stdout (FILE*)2
extern int _FUNC(fgetc)(FILE *);
extern char* _FUNC(fgets)(char *restrict, int, FILE *restrict);
extern int _FUNC(fprintf)(FILE *restrict, const char *restrict, ...);
extern int _FUNC(fputc)(int, FILE *);
extern int _FUNC(fputs)(const char *restrict, FILE *restrict);
extern size_t _FUNC(fread)(void *restrict, size_t size, size_t count, FILE *restrict);
extern int _FUNC(fscanf)(FILE *restrict, const char *restrict, ...);
extern size_t _FUNC(fwrite)(const void *restrict, size_t size, size_t count, FILE *restrict);
extern int _FUNC(getc)(FILE *);
#define getc() _FUNC(fgetc)(stdin)
extern int _FUNC(getchar)(void);
extern int _FUNC(printf)(const char *restrict, ...);
#define putc(ch) _FUNC(fputc)(ch, stdout)
extern int _FUNC(puts)(const char *);
extern int _FUNC(scanf)(const char *restrict, ...);
extern char* _FUNC(gets)(char *str);
extern int _FUNC(ungetc)(int, FILE *);
extern int _FUNC(vfprintf)(FILE *restrict, const char *restrict, va_list);
extern int _FUNC(vfscanf)(FILE *restrict, const char *restrict, va_list);
extern int _FUNC(vprintf)(const char *restrict, va_list);
extern int _FUNC(vscanf)(const char *restrict, va_list);
extern int _FUNC(sscanf)(const char*, const char *restrict, ...);
extern int _FUNC(vsscanf)(const char *, const char*, va_list);
extern int _FUNC(remove)(const char *);
extern int _FUNC(rename)(const char *, const char *);
extern FILE* _FUNC(tmpfile)(void);
extern char* _FUNC(tmpnam)(char *);
extern int _FUNC(fclose)(FILE *);
extern int _FUNC(fflush)(FILE *);
extern FILE* _FUNC(fopen)(const char *restrict, const char *restrict);
extern FILE* _FUNC(freopen)(const char *restrict, const char *restrict, FILE *restrict);
extern void _FUNC(setbuf)(FILE *restrict, char *restrict);
extern int _FUNC(setvbuf)(FILE *restrict, char *restrict, int, size_t);
extern int _FUNC(fgetpos)(FILE *restrict, fpos_t *restrict);
extern int _FUNC(fseek)(FILE *, long, int);
extern int _FUNC(fsetpos)(FILE *, const fpos_t *);
extern long _FUNC(ftell)(FILE *);
extern void _FUNC(rewind)(FILE *);
extern void _FUNC(clearerr)(FILE *);
extern int _FUNC(feof)(FILE *);
extern int _FUNC(ferror)(FILE *);
extern void _FUNC(perror)(const char *);
extern size_t _FUNC(fread)(void *restrict, size_t, size_t, FILE *restrict);
extern int _FUNC(getchar)(void);
#endif // _STDIO_H_

/programs/develop/ktcc/trunk/libc.obj/include/stdlib.h
0,0 → 1,43
#ifndef _STDLIB_H_
#define _STDLIB_H_
#include <stddef.h>
#define RAND_MAX 65535
#ifndef NULL
# define NULL ((void*)0)
#endif
#define min(a, b) ((a)<(b) ? (a) : (b))
#define max(a, b) ((a)>(b) ? (a) : (b))
extern int _FUNC(atoi)(const char *s);
extern long _FUNC(atol)(const char *);
extern long long _FUNC(atoll)(const char *);
extern void _FUNC(itoa)(int n, char* s);
extern int _FUNC(abs)(int);
extern long _FUNC(labs)(long);
extern long long _FUNC(llabs)(long long);
typedef struct { int quot, rem; } div_t;
typedef struct { long quot, rem; } ldiv_t;
typedef struct { long long quot, rem; } lldiv_t;
extern div_t _FUNC(div)(int, int);
extern ldiv_t _FUNC(ldiv)(long, long);
extern lldiv_t _FUNC(lldiv)(long long, long long);
extern void* _FUNC(malloc)(size_t size);
extern void* _FUNC(calloc)(size_t num, size_t size);
extern void* _FUNC(realloc)(void *ptr, size_t newsize);
extern void _FUNC(free)(void *ptr);
extern long int _FUNC(strtol)(const char* str, char** endptr, int base);
extern void _FUNC(exit)(int status);
extern void _FUNC(srand)(unsigned s);
extern int _FUNC(rand)(void);
#endif

/programs/develop/ktcc/trunk/libc.obj/include/stdint.h
0,0 → 1,32
#ifndef _STDINT_H_
#define _STDINT_H_
#include <stddef.h>
#define INT8_MIN (-128)
#define INT8_MAX (127)
#define UINT8_MAX (255)
#define INT16_MIN (-32768)
#define INT16_MAX (32767)
#define UINT16_MAX (65535)
#define INT32_MIN (-2147483647L-1)
#define INT32_MAX (2147483647L)
#define UINT32_MAX (4294967295UL)
#if __have_long64
#define INT64_MIN (-9223372036854775807L-1L)
#define INT64_MAX (9223372036854775807L)
#define UINT64_MAX (18446744073709551615U)
#elif __have_longlong64
#define INT64_MIN (-9223372036854775807LL-1LL)
#define INT64_MAX (9223372036854775807LL)
#define UINT64_MAX (18446744073709551615ULL)
#else
#define INT64_MAX 0x7fffffffffffffffLL
#define INT64_MIN (-INT64_MAX - 1LL)
#define UINT64_MAX (__CONCAT(INT64_MAX, U) * 2ULL + 1ULL)
#endif
#endif /* _STDINT_H_*/

/programs/develop/ktcc/trunk/libc.obj/include/string.h
0,0 → 1,181
/* String handling <string.h>
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#ifndef _STRING_H_
#define _STRING_H_
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
/* String function conventions */
/*
In any of the following functions taking a size_t n to specify the length of
an array or size of a memory region, n may be 0, but the pointer arguments to
the call shall still be valid unless otherwise stated.
*/
/* Copying functions */
extern void* _FUNC(memccpy)(void *restrict dest, const void *restrict src, int c, size_t n);
/* Copy a number of n characters from the memory area pointed to by s2 to the
area pointed to by s1. If the two areas overlap, behaviour is undefined.
Returns the value of s1.
*/
#ifdef __TINYC__
extern void* memcpy(void* s1, const void* s2, size_t n);
extern void* memset(void* s, int c, size_t n);
extern void* memmove(void* s1, const void* s2, size_t n);
#else
extern void* _FUNC(memcpy)(void* s1, const void* s2, size_t n);
extern void* _FUNC(memset)(void* s, int c, size_t n);
extern void* _FUNC(memmove)(void* s1, const void* s2, size_t n);
#endif
/* Copy the character array s2 (including terminating '\0' byte) into the
character array s1.
Returns the value of s1.
*/
extern char* _FUNC(strcpy)(char* s1, const char* s2);
/* Copy a maximum of n characters from the character array s2 into the character
array s1. If s2 is shorter than n characters, '\0' bytes will be appended to
the copy in s1 until n characters have been written. If s2 is longer than n
characters, NO terminating '\0' will be written to s1. If the arrays overlap,
behaviour is undefined.
Returns the value of s1.
*/
extern char* _FUNC(strncpy)(char* s1, const char* s2, size_t n);
/* Concatenation functions */
/* Append the contents of the character array s2 (including terminating '\0') to
the character array s1 (first character of s2 overwriting the '\0' of s1). If
the arrays overlap, behaviour is undefined.
Returns the value of s1.
*/
extern char* _FUNC(strcat)(char* s1, const char* s2);
/* Append a maximum of n characters from the character array s2 to the character
array s1 (first character of s2 overwriting the '\0' of s1). A terminating
'\0' is ALWAYS appended, even if the full n characters have already been
written. If the arrays overlap, behaviour is undefined.
Returns the value of s1.
*/
extern char* _FUNC(strncat)(char* s1, const char* s2, size_t n);
/* Comparison functions */
/* Compare the first n characters of the memory areas pointed to by s1 and s2.
Returns 0 if s1 == s2, a negative number if s1 < s2, and a positive number if
s1 > s2.
*/
extern int _FUNC(memcmp)(const void * s1, const void* s2, size_t n);
/* Compare the character arrays s1 and s2.
Returns 0 if s1 == s2, a negative number if s1 < s2, and a positive number if
s1 > s2.
*/
extern int _FUNC(strcmp)(const char * s1, const char* s2);
/* Compare the character arrays s1 and s2, interpreted as specified by the
LC_COLLATE category of the current locale.
Returns 0 if s1 == s2, a negative number if s1 < s2, and a positive number if
s1 > s2.
TODO: Currently a dummy wrapper for strcmp() as PDCLib does not yet support
locales.
*/
extern int _FUNC(strcoll)(const char* s1, const char* s2);
/* Compare no more than the first n characters of the character arrays s1 and
s2.
Returns 0 if s1 == s2, a negative number if s1 < s2, and a positive number if
s1 > s2.
*/
extern int _FUNC(strncmp)(const char* s1, const char* s2, size_t n);
/* Transform the character array s2 as appropriate for the LC_COLLATE setting of
the current locale. If length of resulting string is less than n, store it in
the character array pointed to by s1. Return the length of the resulting
string.
*/
extern size_t _FUNC(strxfrm)(char* s1, const char* s2, size_t n);
/* Search functions */
/* Search the first n characters in the memory area pointed to by s for the
character c (interpreted as unsigned char).
Returns a pointer to the first instance found, or NULL.
*/
extern void* _FUNC(memchr)(const void* s, int c, size_t n);
/* Search the character array s (including terminating '\0') for the character c
(interpreted as char).
Returns a pointer to the first instance found, or NULL.
*/
extern char* _FUNC(strchr)(const char* s, int c);
/* Determine the length of the initial substring of character array s1 which
consists only of characters not from the character array s2.
Returns the length of that substring.
*/
extern size_t _FUNC(strcspn)(const char* s1, const char* s2);
/* Search the character array s1 for any character from the character array s2.
Returns a pointer to the first occurrence, or NULL.
*/
extern char* _FUNC(strpbrk)(const char* s1, const char* s2);
/* Search the character array s (including terminating '\0') for the character c
(interpreted as char).
Returns a pointer to the last instance found, or NULL.
*/
extern char* _FUNC(strrchr)(const char * s, int c );
/* Determine the length of the initial substring of character array s1 which
consists only of characters from the character array s2.
Returns the length of that substring.
*/
extern size_t _FUNC(strspn)(const char * s1, const char * s2);
/* Search the character array s1 for the substring in character array s2.
Returns a pointer to that sbstring, or NULL. If s2 is of length zero,
returns s1.
*/
extern char* _FUNC(strstr)(const char * s1, const char * s2);
/* In a series of subsequent calls, parse a C string into tokens.
On the first call to strtok(), the first argument is a pointer to the to-be-
parsed C string. On subsequent calls, the first argument is NULL unless you
want to start parsing a new string. s2 holds an array of separator characters
which can differ from call to call. Leading separators are skipped, the first
trailing separator overwritten with '\0'.
Returns a pointer to the next token.
WARNING: This function uses static storage, and as such is not reentrant.
*/
extern char* _FUNC(strtok)(char* s1, const char* s2);
/* Map an error number to a (locale-specific) error message string. Error
numbers are typically errno values, but any number is mapped to a message.
TODO: PDCLib does not yet support locales.
*/
extern char* _FUNC(strerror)(int errnum);
/* Returns the length of the string s (excluding terminating '\0').*/
extern size_t _FUNC(strlen)(const char * s);
/* The function reverses the sequence of characters in the string pointed to by str. */
extern char* _FUNC(strrev)(char *str);
/* The strdup function executes the function pointed to by the str argument. */
extern char* _FUNC(strdup)(const char *str);
#endif

/programs/develop/ktcc/trunk/libc.obj/include/clayer/network.h
0,0 → 1,57
#ifndef __NETWORK_H
#define __NETWORK_H
#include <sys/socket.h>
#include <sys/ksys.h>
#define stdcall __attribute__ ((stdcall))
#define EAI_ADDRFAMILY 1
#define EAI_AGAIN 2
#define EAI_BADFLAGS 3
#define EAI_FAIL 4
#define EAI_FAMILY 5
#define EAI_MEMORY 6
#define EAI_NONAME 8
#define EAI_SERVICE 9
#define EAI_SOCKTYPE 10
#define EAI_BADHINTS 12
#define EAI_PROTOCOL 13
#define EAI_OVERFLOW 14
// Flags for addrinfo
#define AI_PASSIVE 1
#define AI_CANONNAME 2
#define AI_NUMERICHOST 4
#define AI_NUMERICSERV 8
#define AI_ADDRCONFIG 0x400
#pragma pack(push, 1)
struct ARP_entry{
unsigned int IP;
unsigned char MAC[6];
unsigned short status;
unsigned short TTL;
};
#pragma pack(pop)
#pragma pack(push, 1)
struct addrinfo {
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
int ai_addrlen;
char *ai_canonname;
struct sockaddr *ai_addr;
struct addrinfo *ai_next;
};
#pragma pack(pop)
extern int networklib_init ();
extern int stdcall (*inet_addr)(const char* hostname);
extern char* stdcall (*inet_ntoa)(int ip_addr);
extern int stdcall (*getaddrinfo)(const char* hostname, const char* servname, const struct addrinfo* hints, struct addrinfo** res);
extern void stdcall (*freeaddrinfo)(struct addrinfo* ai);
#endif

/programs/develop/ktcc/trunk/libc.obj/include/float.h
0,0 → 1,65
#ifndef _FLOAT_H_
#define _FLOAT_H_
#define FLT_RADIX 2
/* IEEE float */
#define FLT_MANT_DIG 24
#define FLT_DIG 6
#define FLT_ROUNDS 1
#define FLT_EPSILON 1.19209290e-07F
#define FLT_MIN_EXP (-125)
#define FLT_MIN 1.17549435e-38F
#define FLT_MIN_10_EXP (-37)
#define FLT_MAX_EXP 128
#define FLT_MAX 3.40282347e+38F
#define FLT_MAX_10_EXP 38
/* IEEE double */
#define DBL_MANT_DIG 53
#define DBL_DIG 15
#define DBL_EPSILON 2.2204460492503131e-16
#define DBL_MIN_EXP (-1021)
#define DBL_MIN 2.2250738585072014e-308
#define DBL_MIN_10_EXP (-307)
#define DBL_MAX_EXP 1024
#define DBL_MAX 1.7976931348623157e+308
#define DBL_MAX_10_EXP 308
/* horrible intel long double */
#if defined __i386__ || defined __x86_64__
#define LDBL_MANT_DIG 64
#define LDBL_DIG 18
#define LDBL_EPSILON 1.08420217248550443401e-19L
#define LDBL_MIN_EXP (-16381)
#define LDBL_MIN 3.36210314311209350626e-4932L
#define LDBL_MIN_10_EXP (-4931)
#define LDBL_MAX_EXP 16384
#define LDBL_MAX 1.18973149535723176502e+4932L
#define LDBL_MAX_10_EXP 4932
#else
/* same as IEEE double */
#define LDBL_MANT_DIG 53
#define LDBL_DIG 15
#define LDBL_EPSILON 2.2204460492503131e-16
#define LDBL_MIN_EXP (-1021)
#define LDBL_MIN 2.2250738585072014e-308
#define LDBL_MIN_10_EXP (-307)
#define LDBL_MAX_EXP 1024
#define LDBL_MAX 1.7976931348623157e+308
#define LDBL_MAX_10_EXP 308
#endif
#ifndef NAN
# define NAN (__nan__)
#endif
#ifndef INFINITY
# define INFINITY (__inf__)
#endif
#endif /* _FLOAT_H_ */

/programs/develop/ktcc/trunk/libc.obj/include/math.h
0,0 → 1,171
/* Copyright (C) 1999 DJ Delorie, see COPYING.DJ for details */
/* Copyright (C) 1998 DJ Delorie, see COPYING.DJ for details */
/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
#ifndef _MATH_H_
#define _MATH_H_
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
extern double _FUNC(acos)(double _x);
extern double _FUNC(asin)(double _x);
extern double _FUNC(atan)(double _x);
extern double _FUNC(atan2)(double _y, double _x);
extern double _FUNC(ceil)(double _x);
extern double _FUNC(cos)(double _x);
extern double _FUNC(cosh)(double _x);
extern double _FUNC(exp)(double _x);
extern double _FUNC(fabs)(double _x);
extern double _FUNC(floor)(double _x);
extern double _FUNC(fmod)(double _x, double _y);
extern double _FUNC(frexp)(double _x, int *_pexp);
extern double _FUNC(ldexp)(double _x, int _exp);
extern double _FUNC(log)(double _y);
extern double _FUNC(log10)(double _x);
extern double _FUNC(modf)(double _x, double *_pint);
extern double _FUNC(pow)(double _x, double _y);
extern double _FUNC(sin)(double _x);
extern double _FUNC(sinh)(double _x);
extern double _FUNC(sqrt)(double _x);
extern double _FUNC(tan)(double _x);
extern double _FUNC(tanh)(double _x);
#define M_E 2.7182818284590452354
#define M_LOG2E 1.4426950408889634074
#define M_LOG10E 0.43429448190325182765
#define M_LN2 0.69314718055994530942
#define M_LN10 2.30258509299404568402
#define M_PI 3.14159265358979323846
#define M_PI_2 1.57079632679489661923
#define M_PI_4 0.78539816339744830962
#define M_1_PI 0.31830988618379067154
#define M_2_PI 0.63661977236758134308
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2 1.41421356237309504880
#define M_SQRT1_2 0.70710678118654752440
#define PI M_PI
#define PI2 M_PI_2
extern double _FUNC(acosh)(double);
extern double _FUNC(asinh)(double);
extern double _FUNC(atanh)(double);
extern double _FUNC(cbrt)(double);
extern double _FUNC(exp10)(double _x);
extern double _FUNC(exp2)(double _x);
extern double _FUNC(expm1)(double);
extern double _FUNC(hypot)(double, double);
extern double _FUNC(log1p)(double);
extern double _FUNC(log2)(double _x);
extern long double _FUNC(modfl)(long double _x, long double *_pint);
extern double _FUNC(pow10)(double _x);
extern double _FUNC(pow2)(double _x);
extern double _FUNC(powi)(double, int);
extern void _FUNC(sincos)(double, double *, double *);
/* These are in libm.a (Cygnus). You must link -lm to get these */
/* See libm/math.h for comments */
#ifndef __cplusplus
struct exception {
int type;
const char *name;
double arg1;
double arg2;
double retval;
int err;
};
#endif
extern double _FUNC(erf)(double);
extern double _FUNC(erfc)(double);
extern double _FUNC(gamma)(double);
extern int _FUNC(isinf)(double);
extern int _FUNC(isnan)(double);
extern int _FUNC(finite)(double);
extern double _FUNC(j0)(double);
extern double _FUNC(j1)(double);
extern double _FUNC(jn)(int, double);
extern double _FUNC(lgamma)(double);
extern double _FUNC(nan)(const char*);
extern double _FUNC(y0)(double);
extern double _FUNC(y1)(double);
extern double _FUNC(yn)(int, double);
extern double _FUNC(logb)(double);
extern double _FUNC(nextafter)(double, double);
extern double _FUNC(remainder)(double, double);
extern double _FUNC(scalb)(double, double);
#ifndef __cplusplus
extern int _FUNC(matherr)(struct exception *);
#endif
extern double _FUNC(significand)(double);
extern double _FUNC(copysign)(double, double);
extern int _FUNC(ilogb)(double);
extern double _FUNC(rint)(double);
extern double _FUNC(scalbn)(double, int);
extern double _FUNC(drem)(double, double);
extern double _FUNC(gamma_r)(double, int *);
extern double _FUNC(lgamma_r)(double, int *);
extern float _FUNC(acosf)(float);
extern float _FUNC(asinf)(float);
extern float _FUNC(atanf)(float);
extern float _FUNC(atan2f)(float, float);
extern float _FUNC(cosf)(float);
extern float _FUNC(sinf)(float);
extern float _FUNC(tanf)(float);
extern float _FUNC(coshf)(float);
extern float _FUNC(sinhf)(float);
extern float _FUNC(tanhf)(float);
extern float _FUNC(expf)(float);
extern float _FUNC(frexpf)(float, int *);
extern float _FUNC(ldexpf)(float, int);
extern float _FUNC(logf)(float);
extern float _FUNC(log10f)(float);
extern float _FUNC(modff)(float, float *);
extern float _FUNC(powf)(float, float);
extern float _FUNC(sqrtf)(float);
extern float _FUNC(ceilf)(float);
extern float _FUNC(fabsf)(float);
extern float _FUNC(floorf)(float);
extern float _FUNC(fmodf)(float, float);
extern float _FUNC(erff)(float);
extern float _FUNC(erfcf)(float);
extern float _FUNC(gammaf)(float);
extern float _FUNC(hypotf)(float, float);
extern int _FUNC(isinff)(float);
extern int _FUNC(isnanf)(float);
extern int _FUNC(finitef)(float);
extern float _FUNC(j0f)(float);
extern float _FUNC(j1f)(float);
extern float _FUNC(jnf)(int, float);
extern float _FUNC(lgammaf)(float);
extern float _FUNC(nanf)(const char*);
extern float _FUNC(y0f)(float);
extern float _FUNC(y1f)(float);
extern float _FUNC(ynf)(int, float);
extern float _FUNC(acoshf)(float);
extern float _FUNC(asinhf)(float);
extern float _FUNC(atanhf)(float);
extern float _FUNC(cbrtf)(float);
extern float _FUNC(logbf)(float);
extern float _FUNC(nextafterf)(float, float);
extern float _FUNC(remainderf)(float, float);
extern float _FUNC(scalbf)(float, float);
extern float _FUNC(significandf)(float);
extern float _FUNC(copysignf)(float, float);
extern int _FUNC(ilogbf)(float);
extern float _FUNC(rintf)(float);
extern float _FUNC(scalbnf)(float, int);
extern float _FUNC(dremf)(float, float);
extern float _FUNC(expm1f)(float);
extern float _FUNC(log1pf)(float);
extern float _FUNC(gammaf_r)(float, int *);
extern float _FUNC(lgammaf_r)(float, int *);
#ifdef __cplusplus
}
#endif
#endif /* _MATH_H_ */

/programs/develop/ktcc/trunk/libc.obj/include/setjmp.h
0,0 → 1,17
#ifndef _SETJMP_H_
#define _SETJMP_H_
#include <stddef.h>
typedef unsigned long __jmp_buf[6];
typedef struct __jmp_buf_tag {
__jmp_buf __jb;
unsigned long __fl;
unsigned long __ss[128/sizeof(long)];
} jmp_buf[1];
extern int _FUNC(setjmp)(jmp_buf env);
extern void _FUNC(longjmp)(jmp_buf env, int val);
#endif // _SETJMP_H_

/programs/develop/ktcc/trunk/libc.obj/include/stdarg.h
0,0 → 1,77
#ifndef _STDARG_H_
#define _STDARG_H_
#include <stddef.h>
#ifdef __x86_64__
#ifndef _WIN64
//This should be in sync with the declaration on our lib/libtcc1.c
/* GCC compatible definition of va_list. */
typedef struct {
unsigned int gp_offset;
unsigned int fp_offset;
union {
unsigned int overflow_offset;
char *overflow_arg_area;
};
char *reg_save_area;
} __va_list_struct;
typedef __va_list_struct va_list[1];
extern void _FUNC(__va_start)(__va_list_struct *ap, void *fp);
extern void* _FUNC(__va_arg)(__va_list_struct *ap, int arg_type, int size, int align);
#define va_start(ap, last) __va_start(ap, __builtin_frame_address(0))
#define va_arg(ap, type) \
(*(type *)(__va_arg(ap, __builtin_va_arg_types(type), sizeof(type), __alignof__(type))))
#define va_copy(dest, src) (*(dest) = *(src))
#define va_end(ap)
#else /* _WIN64 */
typedef char *va_list;
#define va_start(ap,last) __builtin_va_start(ap,last)
#define va_arg(ap,type) (ap += 8, sizeof(type)<=8 ? *(type*)ap : **(type**)ap)
#define va_copy(dest, src) ((dest) = (src))
#define va_end(ap)
#endif
#elif __arm__
typedef char *va_list;
#define _tcc_alignof(type) ((int)&((struct {char c;type x;} *)0)->x)
#define _tcc_align(addr,type) (((unsigned)addr + _tcc_alignof(type) - 1) \
& ~(_tcc_alignof(type) - 1))
#define va_start(ap,last) ap = ((char *)&(last)) + ((sizeof(last)+3)&~3)
#define va_arg(ap,type) (ap = (void *) ((_tcc_align(ap,type)+sizeof(type)+3) \
&~3), *(type *)(ap - ((sizeof(type)+3)&~3)))
#define va_copy(dest, src) (dest) = (src)
#define va_end(ap)
#elif defined(__aarch64__)
typedef struct {
void *__stack;
void *__gr_top;
void *__vr_top;
int __gr_offs;
int __vr_offs;
} va_list;
#define va_start(ap, last) __va_start(ap, last)
#define va_arg(ap, type) __va_arg(ap, type)
#define va_end(ap)
#define va_copy(dest, src) ((dest) = (src))
#else /* __i386__ */
typedef char *va_list;
/* only correct for i386 */
#define va_start(ap,last) ap = ((char *)&(last)) + ((sizeof(last)+3)&~3)
#define va_arg(ap,type) (ap += (sizeof(type)+3)&~3, *(type *)(ap - ((sizeof(type)+3)&~3)))
#define va_copy(dest, src) (dest) = (src)
#define va_end(ap)
#endif
/* fix a buggy dependency on GCC in libio.h */
typedef va_list __gnuc_va_list;
#define _VA_LIST_DEFINED
#endif /* _STDARG_H */

/programs/develop/ktcc/trunk/libc.obj/include/stdbool.h
0,0 → 1,11
#ifndef _STDBOOL_H_
#define _STDBOOL_H_
/* ISOC99 boolean */
#define bool _Bool
#define true 1
#define false 0
#define __bool_true_false_are_defined 1
#endif /* _STDBOOL_H */

/programs/develop/ktcc/trunk/libc.obj/lib/libc.obj.a
Cannot display: file marked as a binary type.
svn:mime-type = application/x-archive
Property changes:
Added: svn:mime-type
+application/x-archive
\ No newline at end of property

/programs/develop/ktcc/trunk/libc.obj/lib/crt0.o
Cannot display: file marked as a binary type.
svn:mime-type = application/x-object
Property changes:
Added: svn:mime-type
+application/x-object
\ No newline at end of property

/programs/develop/ktcc/trunk/libc.obj/lib/libtcc.a
Cannot display: file marked as a binary type.
svn:mime-type = application/x-archive
Property changes:
Added: svn:mime-type
+application/x-archive
\ No newline at end of property

/programs/develop/ktcc/trunk/libc.obj/samples/file_io.c
0,0 → 1,50
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#define READ_MAX 255
static char test_str1[] = "123454567890abcdefghijklmnopqrstufvwxyz";
static char test_str2[READ_MAX];
int main(int argc, char **argv)
{
int i=0;
FILE *f;
//write to file
debug_printf("Write file...\n");
f=fopen("testfile.txt","w");
while(test_str1[i]!='a'){
fputc(test_str1[i],f);
i++;
}
fclose(f);
//append to file
debug_printf("Apend file...\n");
f=fopen("testfile.txt","a");
fputs(test_str1+i,f);
char null_term = '\0';
fwrite(&null_term, sizeof(char), 1, f);
printf("Error: %s\n",strerror(errno));
fclose(f);
//copy from testfile.txt to copyfile.txt
debug_printf("Read file...\n");
f=fopen("testfile.txt","r");
i=0;
while((test_str2[i]=fgetc(f))!=EOF && i<READ_MAX){
fputc(test_str2[i], stdout);
i++;
}
printf("\n%s\n", test_str1);
if(!strcmp(test_str2, test_str1)){
puts("TEST: OK!");
}else{
puts("TEST: FAIL!");
}
fclose(f);
}

/programs/develop/ktcc/trunk/libc.obj/samples/whois.c
0,0 → 1,301
/*
WHOIS port for KolibriOS (Adapted by turbocat2001).
The main code is taken from the site:
https://www.binarytides.com/whois-client-code-in-c-with-linux-sockets/
*/
#include <errno.h>
int errno;
#include "sys/ksys.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <clayer/network.h>
#include <conio.h>
FILE *out=stdout;
#ifdef DEBUG
FILE *out=stderr;
#endif
#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1
#define fprintf fprintf
void show_help()
{
puts("Usage: whois <host> [-f <file>]\n");
puts(" host Connect to server host");
puts(" -f file Redirecting output to file\n");
puts("Example: whois google.com -f my.txt");
}
int get_whois_data(char * , char **);
int hostname_to_ip(char * , char *);
int whois_query(char * , char * , char **);
char *str_replace(char *search , char *replace , char *subject );
char* str_copy(char*);
int main(int argc , char *argv[])
{
networklib_init();
char *domain , *data = NULL;
int f_flag=0;
if(argc==2){
domain=strdup(argv[1]);
}
else if(!strcmp(argv[2], "-f") && argc==4){
domain=strdup(argv[1]);
if((out=fopen(argv[3],"w"))==NULL){
printf("Error writing to file: '%s' !\n", argv[3]);
exit(0);
}
}else{
show_help();
exit(0);
}
if(out==stdout){
con_init();
(*con_set_title)("Whois");
}
get_whois_data(domain , &data);
exit(0);
}
/*
Get the whois data of a domain
*/
int get_whois_data(char *domain , char **data)
{
char ext[1024] , *pch , *response = NULL , *response_2 = NULL , *wch , *dt;
//remove "http://" and "www."
domain = str_replace("http://" , "" , domain);
domain = str_replace("www." , "" , domain);
//get the extension , com , org , edu
dt = strdup(domain);
if(dt == NULL){
fprintf(out, "strdup failed");
}
pch = (char*)strtok(dt , ".");
while(pch != NULL){
strcpy(ext , pch);
pch = strtok(NULL , ".");
}
// This will tell the whois server for the particular TLD like com , org
if( whois_query("whois.iana.org" , ext , &response) == EXIT_FAILURE){
fprintf(out, "Whois query failed");
return 1;
}
fprintf(out, "\n\nResponse is:\n\n");
fprintf(out, "%s", response);
// Now analysze the response
pch = strtok(response , "\n");
while(pch != NULL){
// Check if whois line
wch = strstr(pch , "whois.");
if(wch != NULL){
break;
}
// Next line please
pch = strtok(NULL , "\n");
}
// Now we have the TLD whois server in wch , query again
//This will provide minimal whois information along with the parent whois server of the specific domain :)
wch = strdup(wch);
free(response);
//This should not be necessary , but segmentation fault without this , why ?
response = NULL;
if(wch != NULL){
fprintf(out,"\nTLD Whois server is : %s" , wch);
if( whois_query(wch , domain , &response) == EXIT_FAILURE){
fprintf(out, "Whois query failed\n");
return EXIT_FAILURE;
}
}else{
fprintf(out, "\nTLD whois server for %s not found\n" , ext);
return EXIT_SUCCESS;
}
response_2 = strdup(response);
// Again search for a whois server in this response. :)
pch = strtok(response , "\n");
while(pch != NULL){
// Check if whois line
wch = strstr(pch , "whois.");
if(wch != NULL){
break;
}
//Next line please
pch = strtok(NULL , "\n");
}
/*
If a registrar whois server is found then query it
*/
if(wch){
// Now we have the registrar whois server , this has the direct full information of the particular domain
// so lets query again
fprintf(out, "\nRegistrar Whois server is : %s" , wch);
if( whois_query(wch , domain , &response) == EXIT_FAILURE ){
fprintf(out, "Whois query failed");
}else{
fprintf(out, "\n%s" , response);
}
}
/*
otherwise echo the output from the previous whois result
*/
else{
fprintf(out, "%s" , response_2);
}
return 0;
}
/*
Perform a whois query to a server and record the response
*/
int whois_query(char *server , char *query , char **response)
{
char ip[32] , message[100] , buffer[1500];
int sock , read_size , total_size = 0;
int WHOIS_PORT = 43;
struct sockaddr dest;
sock = socket(AF_INET4 , SOCK_STREAM , IPPROTO_TCP);
//Prepare connection structures :)
memset(&dest , 0 , sizeof(dest) );
dest.sin_family = AF_INET;
server = str_copy(server);
server[strcspn(server, "\r\n")] = '\0';
fprintf(out, "\nResolving: %s ...\n" , server);
if(hostname_to_ip(server , ip) == EXIT_FAILURE ){
fprintf(out, "Failed\n");
return EXIT_FAILURE;
}
fprintf(out, "Found ip: %s \n" , ip);
dest.sin_addr = inet_addr(ip);
dest.sin_port = PORT(WHOIS_PORT);
; //Now connect to remote server
if(connect(sock , (const struct sockaddr*) &dest , sizeof(dest)) < 0){
perror("connect failed");
perror(strerror(errno));
return EXIT_FAILURE;
}
//Now send some data or message
fprintf(out, "\nQuerying for: %s ...\n" , query);
sprintf(message , "%s\r\n" , query);
if( send(sock , message , strlen(message) , 0) < 0){
perror("send failed");
return EXIT_FAILURE;
}
//Now receive the response
while((read_size = recv(sock, buffer, sizeof(buffer), 0))){
*response = realloc(*response , read_size + total_size);
if(*response == NULL){
fprintf(out, "realloc failed");
return EXIT_FAILURE;
}
memcpy(*response + total_size , buffer , read_size);
total_size += read_size;
}
fprintf(out, "Done\n");
*response = realloc(*response , total_size + 1);
*(*response + total_size) = '\0';
close(sock);
return EXIT_SUCCESS;
}
/*
Get the ip address of a given hostname
*/
int hostname_to_ip(char *hostname , char *ip)
{
struct addrinfo *addr_info;
char port_str[16]; sprintf(port_str, "%d", 80);
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // IPv4 or IPv6 doesnt matter
hints.ai_socktype = SOCK_STREAM; // TCP stream sockets
if (getaddrinfo(hostname, port_str, 0, &addr_info) != 0) {
freeaddrinfo(addr_info);
return EXIT_FAILURE;
}else{
strcpy(ip, inet_ntoa(addr_info->ai_addr->sin_addr));
return EXIT_SUCCESS;
}
}
/*
Search and replace a string with another string , in a string
*/
char *str_replace(char *search , char *replace , char *subject)
{
char *p = NULL , *old = NULL , *new_subject = NULL ;
int c = 0 , search_size;
search_size = strlen(search);
//Count how many occurences
for(p = strstr(subject , search) ; p != NULL ; p = strstr(p + search_size , search)){
c++;
}
//Final size
c = ( strlen(replace) - search_size )*c + strlen(subject);
//New subject with new size
new_subject = malloc( c );
//Set it to blank
strcpy(new_subject , "");
//The start position
old = subject;
for(p = strstr(subject , search) ; p != NULL ; p = strstr(p + search_size , search)){
//move ahead and copy some text from original subject , from a certain position
strncpy(new_subject + strlen(new_subject) , old , p - old);
//move ahead and copy the replacement text
strcpy(new_subject + strlen(new_subject) , replace);
//The new start position after this search match
old = p + search_size;
}
//Copy the part after the last search match
strcpy(new_subject + strlen(new_subject) , old);
return new_subject;
}
char* str_copy(char *source)
{
char *copy = malloc(strlen(source) + 1);
if(copy){
strcpy(copy, source);
}
return copy;
}

/programs/develop/ktcc/trunk/libc.obj/samples/dir_example.c
0,0 → 1,45
#include <sys/dirent.h>
#include <sys/dir.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
const char *folder_type = "Folder";
const char *file_type = "File";
int main()
{
char *path=getcwd(NULL, PATH_MAX);
printf("Current directory: %s\n", path);
if(mkdir("test")){
puts("Test folder created!");
}
else{
puts("Error creating folder!");
}
DIR *mydir = opendir(path);
if(!mydir){
puts("File system error.");
return -1;
}
struct dirent *file_info;
char *str_type=NULL;
putc(' ');
while((file_info = readdir(mydir))!=NULL){
if(file_info->d_type==IS_FOLDER){
(*con_set_flags)(CON_COLOR_GREEN);
str_type = (char*)folder_type;
}else {
(*con_set_flags)(7);
str_type = (char*)file_type;
}
printf("%3d %20s %s\n ", file_info->d_ino ,file_info->d_name, str_type);
};
setcwd("/sys/develop");
path=getcwd(NULL, PATH_MAX);
printf("Move to the directory: %s\n", path);
free(path);
}

/programs/develop/ktcc/trunk/libc.obj/samples/Makefile
0,0 → 1,29
KTCC=../../../ktcc/trunk/bin/kos32-tcc
FASM= fasm
KPACK = kpack
CFLAGS = -I../include
LDFLAGS = -nostdlib -L../lib ../lib/crt0.o
BIN= stdio_test.kex \
basic_gui.kex \
http_tcp_demo.kex \
math_test.kex \
string_test.kex \
whois.kex \
file_io.kex \
tmpdisk_work.kex \
fasm/sprintf_test.kex
all: $(BIN)
%.kex : %.c
$(KTCC) $(CFLAGS) $(LDFLAGS) $< -o $@ -ltcc -lnetwork -lc.obj
$(KPACK) --nologo $@
%.kex : %.asm
$(FASM) $< $@
$(KPACK) --nologo $@
clean:
rm *.kex

/programs/develop/ktcc/trunk/libc.obj/samples/basic_gui.c
0,0 → 1,115
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <sys/ksys.h>
ksys_colors_table_t sys_color_table;
char statusbar[255];
ksys_proc_table_t proc_info;
char text_line[255];
enum BUTTONS
{
BTN_QUIT = 1,
BTN_POP = 10,
BTN_UNLOCK = 11
};
#define FONT_W 8
#define FONT_H 14
#define LINES 10
void draw_window()
{
int win_hight, win_width, i, pos_y = _ksys_get_skin_height() + 36; // 60 == 24+36
// start redraw
_ksys_start_draw();
// define&draw window
_ksys_create_window(10, 40, 600, 400, "My window", sys_color_table.work_area, 0x13);
_ksys_process_info(&proc_info, -1);
win_width = proc_info.winx_size;
win_hight = proc_info.winy_size;
_ksys_define_button(10, 30, 70, 20, BTN_POP, sys_color_table.work_button);
_ksys_draw_text("BUTTON1", 15, 34, 0, 0x90000000 | sys_color_table.work_button_text); //0x80000000 asciiz
_ksys_define_button(100, 30, 80, 20, BTN_UNLOCK, sys_color_table.work_button);
_ksys_draw_text("BUTTTON2", 110, 34, 0, 0x90000000 | sys_color_table.work_button_text);
// display statusbar
_ksys_draw_bar(6, win_hight - 17, win_width - 11, 12, 0x80000000 | sys_color_table.work_area); //0x80000000 gradient
_ksys_draw_text(statusbar, 10, win_hight - 15, 0, 0x80000000 | sys_color_table.work_text);
// display strings
for (i = LINES; i > 0; i--){
snprintf (text_line, sizeof text_line, "Line[%d]<<Just a text>>", i);
text_line[(win_width - 10 - 5) / FONT_W + 1] = '\0'; // clip text size, seems to big lines crashing OS, and form len by window size
_ksys_draw_text(text_line, 5, pos_y, 0, 0x90000000 | sys_color_table.work_text);
pos_y += FONT_H;
if(pos_y + 29 > win_hight) break; // 12 font + 12 statusbar + 5 border
}
// end redraw
_ksys_end_draw();
}
int main()
{
int gui_event;
uint32_t pressed_button = 0, mouse_button;
ksys_pos_t mouse_pos;
strcpy(statusbar, "Program running...Double click on TEXT for details");
_ksys_get_system_colors(&sys_color_table);
_ksys_set_event_mask(0xC0000027); // mouse events only when focused window and mouse inside
do{
gui_event = _ksys_get_event();
switch(gui_event)
{
case KSYS_EVENT_NONE:
break;
case KSYS_EVENT_REDRAW:
draw_window();
break;
case KSYS_EVENT_KEY:
break;
case KSYS_EVENT_BUTTON:
pressed_button = _ksys_get_button();
switch (pressed_button)
{
case BTN_POP:
strcpy(statusbar, "POP pressed....");
draw_window();
break;
case BTN_UNLOCK:
strcpy(statusbar, "UNLOCK pressed....");
draw_window();
break;
case BTN_QUIT:
return 0;
break;
}
break;
case KSYS_EVENT_MOUSE:
mouse_pos = _ksys_get_mouse_pos(KSYS_MOUSE_WINDOW_POS); // window relative
mouse_button = _ksys_get_mouse_eventstate();
debug_printf("mouse ev (%d,%d)%x\n", mouse_pos.x, mouse_pos.y, mouse_button);
if (mouse_button & (1<<24)) // double click
{
int n = (mouse_pos.y - 60) / FONT_H;
if (n < 0 || n >= LINES) break;
debug_printf("click on str(%d), clip slot(%d)\n", n, LINES - n - 1);
sprintf(statusbar, "click on str(%d), clip slot(%d)\n", n, LINES - n - 1);
draw_window();
}
break;
}
} while(1) ; /* End of main activity loop */
return 0;
}

/programs/develop/ktcc/trunk/libc.obj/samples/fasm/sprintf_test.asm
0,0 → 1,81
format binary as "kex"
use32
org 0x0
db 'MENUET01'
dd 0x01
dd START
dd IM_END
dd MEM
dd MEM
dd 0
dd 0
include '../../../../../macros.inc'
include '../../../../../proc32.inc'
include '../../../../../KOSfuncs.inc'
include '../../../../../dll.inc'
;include '../../../../../debug-fdo.inc'
;__DEBUG__ = 1
;__DEBUG_LEVEL__ = 2
START:
stdcall dll.Load, @IMPORT
test eax, eax
jnz exit
cinvoke libc_strlen, test_str1
;DEBUGF 2, "%d", eax
mcall SF_SYS_MISC, SSF_MEM_ALLOC, eax
mov [test_str2], eax
cinvoke libc_sprintf, [test_str2], format_str, str_var, [dec_var], dword [float_var], dword[float_var+4], [hex_var]
cinvoke libc_puts, test_str1
cinvoke libc_puts, [test_str2]
cinvoke libc_strcmp, test_str1, [test_str2]
test eax, eax
jz print_succ
jmp print_fail
print_succ:
cinvoke libc_puts, success_msg
jmp exit
print_fail:
cinvoke libc_puts, failed_msg
exit:
mcall SF_SYS_MISC, SSF_MEM_FREE, [test_str2]
mcall SF_TERMINATE_PROCESS
; data
format_str db "%s %d %f 0x%x", 0
test_str1 db "Test 463 -26.432100 0x9d81", 0
test_str2 dd 0
str_var db "Test",0
dec_var dd 463
float_var dq -26.4321
hex_var dd 40321
success_msg db "Test successful!", 0
failed_msg db "Test failed!", 0
align 4
@IMPORT:
library libc, 'libc.obj'
import libc, \
libc_sprintf, 'sprintf', \
libc_strcmp, 'strcmp', \
libc_strlen, 'strlen', \
libc_puts, 'puts'
IM_END:
align 4
rb 1024 ; stack
MEM:

/programs/develop/ktcc/trunk/libc.obj/samples/stdio_test.c
0,0 → 1,19
#include <sys/ksys.h>
#include <stdio.h>
#include <limits.h>
char* test_string1 = "Hello world!";
int a, b;
int main(int argc, char** argv){
sscanf("43 53","%d %d",&a, &b);
printf("(43 53) = (%d %d)\n", a, b);
printf("Hello world! = %s\n", test_string1);
printf("345.358980 = %f\n", 345.35898);
printf("345 = %d\n", (int)345.35898);
printf("ff = %x\n", 255);
printf("-1 = %d\n", UINT_MAX);
printf("5A-4B-N$ = %s%c-%u%c-N%c\n", "5", 'A', 4, 'B', '$');
puts("Done!");
return 0;
}

/programs/develop/ktcc/trunk/libc.obj/samples/tmpdisk_work.c
0,0 → 1,56
#include "stddef.h"
#include <sys/ksys.h>
#include <stdio.h>
#include <stdlib.h>
#define DEV_ADD_DISK 1
#define TMPDISK_SIZE 10 //Mb
#pragma pack(push, 1)
struct{
unsigned disk_size;
unsigned char disk_id;
}tmpdisk_add;
#pragma pack(pop)
char *tmpdisk_res_text[]={
"TmpDisk operation completed successfully",
"Unknown IOCTL code, wrong input/output size...",
"DiskId must be from 0 to 9",
"DiskSize is too large",
"DiskSize is too small, might be too little free RAM",
"Memory allocation failed",
"Unknown error O_o",
0};
int main(){
ksys_drv_hand_t tmpdisk_drv = _ksys_load_driver("tmpdisk");
if(!tmpdisk_drv){
puts("tmpdisk.sys driver not load!");
exit(0);
}else{
puts("tmpdisk.sys driver is load!");
}
tmpdisk_add.disk_size = TMPDISK_SIZE*1024*1024/512;
tmpdisk_add.disk_id = 5;
ksys_ioctl_t ioctl;
ioctl.func_num = DEV_ADD_DISK;
ioctl.handler = tmpdisk_drv;
ioctl.in_data_ptr = &tmpdisk_add;
ioctl.in_data_size = sizeof(tmpdisk_add);
ioctl.out_data_ptr = NULL;
ioctl.out_data_size = 0;
printf("Create '/tmp%u/' disk a %u Mb size...\n", tmpdisk_add.disk_id, TMPDISK_SIZE);
unsigned status =_ksys_work_driver(&ioctl);
if(status<7){
puts(tmpdisk_res_text[status]);
}else{
puts(tmpdisk_res_text[6]);
}
exit(0);
}

/programs/develop/ktcc/trunk/libc.obj/samples/http_tcp_demo.c
0,0 → 1,61
#include <clayer/network.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
int errno;
int main() {
networklib_init();
char *host = "kolibrios.org";
int port = 80;
printf("Connecting to %s on port %d\n", host, port);
struct addrinfo *addr_info;
char port_str[16]; sprintf(port_str, "%d", port);
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // IPv4 or IPv6 doesnt matter
hints.ai_socktype = SOCK_STREAM; // TCP stream sockets
if (getaddrinfo(host, port_str, 0, &addr_info) != 0) {
printf("Host %s not found!\n", host);
freeaddrinfo(addr_info);
exit(-1);
}
printf("IP address of %s is %s\n", host, inet_ntoa(addr_info->ai_addr->sin_addr));
//printf("Host port = %d\n", addr_info->ai_addr->sin_port >> 8);
char request[256];
sprintf(request, "GET /en/ HTTP/1.1\r\nHost: %s\r\n\r\n", host);
printf("request = %s\n", request);
int sock = socket(AF_INET4, SOCK_STREAM, IPPROTO_TCP);
puts("Connecting...\n");
if (connect(sock, addr_info->ai_addr, addr_info->ai_addrlen) != 0) {
printf("Connection failed, errno = %d\n", errno);
exit(errno);
}
puts("Connected successfully\n");
puts("Sending request...\n");
if (send(sock, request, strlen(request), MSG_NOFLAG) == -1) {
printf("Sending failed, errno = %d\n", errno);
exit(errno);
}
puts("Request sended successfully, waiting for response...\n");
char buf[512 + 1];
if (recv(sock, buf, 512, MSG_NOFLAG) == -1) {
printf("Receive failed, errno = %d\n", errno);
exit(errno);
}
printf("Response = %s\n", buf);
freeaddrinfo(addr_info);
close(sock);
puts("\n goodbye)\n");
exit(0);
}

/programs/develop/ktcc/trunk/libc.obj/samples/math_test.c
0,0 → 1,43
#include <stdio.h>
#include <math.h>
int main()
{
int i;
for (i = 0; i < 20; i++)
{
printf("------------------------------------------------------\n");
// printf ( "remainder of 5.3 / 2 is %f\n", remainder (5.3,2) );
// printf ( "remainder of 18.5 / 4.2 is %f\n", remainder (18.5,4.2) );
//remainder of 5.3 / 2 is -0.700000
//remainder of 18.5 / 4.2 is 1.700000
printf ( "fmod of 5.3 / 2 is %f\n", fmod (5.3,2) );
printf ( "fmod of 18.5 / 4.2 is %f\n", fmod (18.5,4.2) );
// fmod of 5.3 / 2 is 1.300000
// fmod of 18.5 / 4.2 is 1.700000
double param, fractpart, intpart, result;
int n;
param = 3.14159265;
fractpart = modf (param , &intpart);
printf ("%f = %f + %f \n", param, intpart, fractpart);
//3.141593 = 3.000000 + 0.141593
param = 0.95;
n = 4;
result = ldexp (param , n);
printf ("%f * 2^%d = %f\n", param, n, result);
//0.950000 * 2^4 = 15.200000
param = 8.0;
result = frexp (param , &n);
printf ("%f = %f * 2^%d\n", param, result, n);
//8.000000 = 0.500000 * 2^4
param = 50;
result = frexp (param , &n);
printf ("%f = %f * 2^%d\n", param, result, n);
}
}

/programs/develop/ktcc/trunk/libc.obj/samples/string_test.c
0,0 → 1,18
#include <errno.h>
#include <sys/ksys.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int main(int argc, char** argv){
char hello1[]="Hello, KolibriOS!";
char hello2[20];
memcpy(hello1, hello2, strlen(hello1));
if(!_ksys_strcmp(hello1, hello2)){
printf("memcpy: Successfully!\n");
return 0;
} else{
printf("memcpy: Failure\n");
return -1;
}
}

/programs/develop/ktcc/trunk/libc.obj/linuxtools/LoaderBuild
0,0 → 1,24
#!/bin/bash
set -e
AR=ar
FASM=fasm
set -e
cd $1
echo "Compile ASM files..."
rm -f *.o
cp __lib__.asm.bak __lib__.asm
for asm_file in $(find *.asm)
do
$FASM $asm_file >> /dev/null
done
echo "Create libc.obj.a library..."
ar -rsc ../lib/libc.obj.a *.o
rm -f *.asm *.o
echo "Done!"
Property changes:
Added: svn:executable
+*
\ No newline at end of property

/programs/develop/ktcc/trunk/libc.obj/linuxtools/src/ExportGen.c
0,0 → 1,57
// export_table_gen
// Copyright (C) maxcodehack and turbocat2001, 2021
#include <stdio.h>
#include <string.h>
int main(int argc, char** argv) {
if (argc != 3) {
printf("Usage: %s <symbols.txt> <exports.c>\n", argv[0]);
return 0;
}
FILE *input, *output;
if ((input = fopen(argv[1], "r")) == NULL)
{
printf("error: file \"%s\" not found\n", argv[1]);
return 1;
}
char buf[10000];
// Head
strcpy(buf, \
"#include <stdio.h>\n" \
"#include <string.h>\n" \
"#include <stdlib.h>\n" \
"#include <time.h>\n" \
"#include <sys/dirent.h>\n" \
"#include <sys/ksys.h>\n\n" \
"#include <math.h>\n\n" \
"#include <setjmp.h>\n\n" \
"ksys_coff_etable_t EXPORTS[] = {\n");
// Generate
char symbol[256];
while(fscanf(input, "%s", symbol) != EOF) {
if(symbol[0]!='!'){
char temp[256];
sprintf(temp, "{\"%s\", &%s},\n", symbol, symbol);
strcat(buf, temp);
}
}
strcat(buf, "NULL,\n};");
fclose(input);
// Output generated
output = fopen(argv[2], "w");
if (output == NULL)
{
printf("Unable to write to file: '%s'!\n", argv[2]);
return 1;
}
fputs(buf, output);
fclose(output);
printf("Done, check %s!\n", argv[2]);
return 0;
}
Property changes:
Added: svn:executable
+*
\ No newline at end of property

/programs/develop/ktcc/trunk/libc.obj/linuxtools/src/LoaderGen.c
0,0 → 1,48
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
int main(int argc, char** argv) {
if(argc!=3){
printf("Usage: LoadGen <symbols.txt> <loader_dir>\n");
return 0;
}
argv[2][strlen(argv[1])-2]='\0';
FILE* symbols_txt = fopen(argv[1], "r");
if(!symbols_txt){
fprintf(stderr, "File '%s' not found!\n", argv[1]);
return -1;
}
char line[256];
while(fgets(line, 256, symbols_txt)) {
if(line[0]!='!'){
if(line[strlen(line)-1]=='\n'){
line[strlen(line)-1]='\0';
}
char asm_name[PATH_MAX];
sprintf(asm_name, "%s/%s.asm", argv[2], line);
FILE *out = fopen(asm_name, "wb");
if(!out){
fprintf(stderr, "Error! File '%s' not created!\n", asm_name);
return -1;
}else{
printf("File '%s' created successfully!\n", asm_name);
}
fprintf(out, "format ELF\n");
fprintf(out, "include \"__lib__.inc\"\n");
fprintf(out, "fun equ __func@%s\n", line);
fprintf(out, "fun_str equ '%s'\n", line);
fprintf(out, "section '.text'\n");
fprintf(out, "fun_name db fun_str, 0\n");
fprintf(out, "section '.data'\n");
fprintf(out, "extrn lib_name\n");
fprintf(out, "public fun as fun_str\n");
fprintf(out, "fun dd fun_name\n");
fprintf(out, "lib dd lib_name\n");
fclose(out);
}
}
}

/programs/develop/ktcc/trunk/libc.obj/linuxtools/src/Makefile
0,0 → 1,3
all:
$(CC) ExportGen.c -o ../ExportGen
$(CC) LoaderGen.c -o ../LoaderGen

/programs/develop/ktcc/trunk/libc.obj/.gitignore
0,0 → 1,8
*.swp
lib/libc.obj
lib/libc.obj.a
lib/crt0.o
*.o
tests/argtest
source/make.bat
/samples/*.kex

/programs/develop/ktcc/trunk/libc.obj/loader/__lib__.asm.bak
0,0 → 1,9
format ELF
include '__lib__.inc'
section '.text'
public lib_name
lib_name db 0x55, 0xAA, lib_name_str, 0

/programs/develop/ktcc/trunk/libc.obj/loader/__lib__.inc
0,0 → 1,2
lib_name equ @libc.obj
lib_name_str equ '/sys/lib/libc.obj'

/programs/develop/libraries/kolibri-libc/linuxtools/LoaderBuild
File deleted
Property changes:
Deleted: svn:executable
-*
\ No newline at end of property

/programs/develop/libraries/kolibri-libc/linuxtools/src/ExportGen.c
File deleted
Property changes:
Deleted: svn:executable
-*
\ No newline at end of property

/programs/develop/libraries/kolibri-libc/linuxtools/src/Makefile
File deleted

/programs/develop/libraries/kolibri-libc/linuxtools/src/LoaderGen.c
File deleted

/programs/develop/libraries/kolibri-libc/source/ctype/is.c
File deleted

/programs/develop/libraries/kolibri-libc/source/ctype/tolower.c
File deleted

/programs/develop/libraries/kolibri-libc/source/ctype/toupper.c
File deleted

/programs/develop/libraries/kolibri-libc/source/string/strxfrm.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strchr.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/memmove.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strlen.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strcmp.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/memchr.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strncat.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/memcmp.c
File deleted

/programs/develop/libraries/kolibri-libc/source/string/strdup.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strerror.c
File deleted

/programs/develop/libraries/kolibri-libc/source/string/strcoll.c
File deleted

/programs/develop/libraries/kolibri-libc/source/string/strcpy.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strrev.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strncmp.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strtok.c
File deleted

/programs/develop/libraries/kolibri-libc/source/string/strrchr.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strpbrk.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strspn.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/memcpy.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/memset.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strcspn.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/memccpy.c
File deleted

/programs/develop/libraries/kolibri-libc/source/string/strcat.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strstr.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/string/strncpy.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/symbols.txt
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/Tupfile.lua
File deleted
Property changes:
Deleted: svn:executable
-*
\ No newline at end of property

/programs/develop/libraries/kolibri-libc/source/crt/crt0.asm
File deleted

/programs/develop/libraries/kolibri-libc/source/math/atanh.c
File deleted

/programs/develop/libraries/kolibri-libc/source/math/fabs.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/cosh.c
File deleted

/programs/develop/libraries/kolibri-libc/source/math/ceil.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/acosh.c
File deleted

/programs/develop/libraries/kolibri-libc/source/math/log.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/floor.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/sinh.c
File deleted

/programs/develop/libraries/kolibri-libc/source/math/asinh.c
File deleted

/programs/develop/libraries/kolibri-libc/source/math/tan.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/atan.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/hypot.c
File deleted

/programs/develop/libraries/kolibri-libc/source/math/cos.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/modf.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/acos.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/fmod.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/pow2.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/sqrt.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/sin.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/asin.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/exp.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/ldexp.c
File deleted

/programs/develop/libraries/kolibri-libc/source/math/modfl.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/frexp.c
File deleted

/programs/develop/libraries/kolibri-libc/source/math/atan2.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/pow.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/pow10.s
File deleted

/programs/develop/libraries/kolibri-libc/source/math/tanh.c
File deleted

/programs/develop/libraries/kolibri-libc/source/libc.c
File deleted

/programs/develop/libraries/kolibri-libc/source/Makefile
File deleted

/programs/develop/libraries/kolibri-libc/source/time/localtime.c
File deleted

/programs/develop/libraries/kolibri-libc/source/time/time.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/time/asctime.c
File deleted

/programs/develop/libraries/kolibri-libc/source/time/mktime.c
File deleted

/programs/develop/libraries/kolibri-libc/source/time/difftime.c
File deleted

/programs/develop/libraries/kolibri-libc/source/sys/opendir.c
File deleted

/programs/develop/libraries/kolibri-libc/source/sys/closedir.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/sys/seekdir.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/sys/rewinddir.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/sys/socket.c
File deleted

/programs/develop/libraries/kolibri-libc/source/sys/readdir.c
File deleted

/programs/develop/libraries/kolibri-libc/source/sys/dir.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/sys/telldir.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/libtcc/Makefile
File deleted
Property changes:
Deleted: svn:executable
-*
\ No newline at end of property

/programs/develop/libraries/kolibri-libc/source/libtcc/libtcc1.c
File deleted

/programs/develop/libraries/kolibri-libc/source/libtcc/memmove.asm
File deleted

/programs/develop/libraries/kolibri-libc/source/libtcc/memcpy.asm
File deleted

/programs/develop/libraries/kolibri-libc/source/libtcc/memset.asm
File deleted

/programs/develop/libraries/kolibri-libc/source/stdlib/lldiv.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/atoll.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/labs.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/free.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/realloc.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/div.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/___chkstk_ms.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/rand.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdlib/strtol.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdlib/itoa.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/atoi.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdlib/llabs.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/calloc.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/ldiv.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/atol.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/abs.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/malloc.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdlib/exit.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/getchar.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/setvbuf.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fsetpos.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fflush.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/rewind.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/tmpnam.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/format_scan.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fseek.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/remove.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/ferror.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/tmpfile.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/format_scan.h
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/printf.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/snprintf.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/ftell.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fopen.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/conio.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/debug_printf.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fprintf.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/perror.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/sscanf.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/feof.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fread.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fputc.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/sprintf.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/ungetc.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fgetc.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/vprintf.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/setbuf.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/vsnprintf.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/scanf.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/puts.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/vfprintf.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/freopen.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/clearerr.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fwrite.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/fscanf.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fputs.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/gets.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/format_print.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/fgetpos.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/rename.c
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fgets.c
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/source/stdio/format_print.h
File deleted

/programs/develop/libraries/kolibri-libc/source/stdio/fclose.c
File deleted

/programs/develop/libraries/kolibri-libc/source/setjmp/longjmp.s
File deleted

/programs/develop/libraries/kolibri-libc/source/setjmp/setjmp.s
File deleted

/programs/develop/libraries/kolibri-libc/compile_flags.txt
File deleted

/programs/develop/libraries/kolibri-libc/include/stdlib.h
File deleted

/programs/develop/libraries/kolibri-libc/include/stdio.h
File deleted

/programs/develop/libraries/kolibri-libc/include/ctype.h
File deleted

/programs/develop/libraries/kolibri-libc/include/stdarg.h
File deleted

/programs/develop/libraries/kolibri-libc/include/errno.h
File deleted

/programs/develop/libraries/kolibri-libc/include/sys/dir.h
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/include/sys/dirent.h
File deleted

/programs/develop/libraries/kolibri-libc/include/sys/socket.h
File deleted

/programs/develop/libraries/kolibri-libc/include/sys/ksys.h
File deleted

/programs/develop/libraries/kolibri-libc/include/math.h
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/include/clayer/network.h
File deleted

/programs/develop/libraries/kolibri-libc/include/time.h
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/include/limits.h
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/include/setjmp.h
File deleted

/programs/develop/libraries/kolibri-libc/include/stdint.h
File deleted

/programs/develop/libraries/kolibri-libc/include/float.h
File deleted

/programs/develop/libraries/kolibri-libc/include/stdbool.h
File deleted

/programs/develop/libraries/kolibri-libc/include/string.h
File deleted

/programs/develop/libraries/kolibri-libc/include/conio.h
File deleted

/programs/develop/libraries/kolibri-libc/include/stddef.h
File deleted
\ No newline at end of file

/programs/develop/libraries/kolibri-libc/samples/Makefile
File deleted

/programs/develop/libraries/kolibri-libc/samples/tmpdisk_work.c
File deleted

/programs/develop/libraries/kolibri-libc/samples/stdio_test.c
File deleted

/programs/develop/libraries/kolibri-libc/samples/basic_gui.c
File deleted

/programs/develop/libraries/kolibri-libc/samples/string_test.c
File deleted

/programs/develop/libraries/kolibri-libc/samples/fasm/sprintf_test.asm
File deleted

/programs/develop/libraries/kolibri-libc/samples/file_io.c
File deleted

/programs/develop/libraries/kolibri-libc/samples/math_test.c
File deleted

/programs/develop/libraries/kolibri-libc/samples/whois.c
File deleted

/programs/develop/libraries/kolibri-libc/samples/http_tcp_demo.c
File deleted

/programs/develop/libraries/kolibri-libc/samples/dir_example.c
File deleted

/programs/develop/libraries/kolibri-libc/.gitignore
File deleted

/programs/develop/libraries/kolibri-libc/loader/__lib__.inc
File deleted

/programs/develop/libraries/kolibri-libc/loader/__lib__.asm.bak
File deleted

/programs/develop/libraries/kolibri-libc/lib/crt0.o
Cannot display: file marked as a binary type.
svn:mime-type = application/x-object
Property changes:
Deleted: svn:mime-type
-application/x-object
\ No newline at end of property

/programs/develop/libraries/kolibri-libc/lib/libtcc.a
Cannot display: file marked as a binary type.
svn:mime-type = application/x-archive
Property changes:
Deleted: svn:mime-type
-application/x-archive
\ No newline at end of property

/programs/develop/libraries/kolibri-libc/lib/libc.obj.a
Cannot display: file marked as a binary type.
svn:mime-type = application/x-archive
Property changes:
Deleted: svn:mime-type
-application/x-archive
\ No newline at end of property