Use macros to allow prefixing C runtime library symbols
authorcoderain <coderain@sdf.org>
Mon, 14 Jan 2019 06:38:16 +0000 (07:38 +0100)
committercoderain <coderain@sdf.org>
Mon, 14 Jan 2019 06:38:16 +0000 (07:38 +0100)
24 files changed:
libraries/mlcrt/include/ctype.h
libraries/mlcrt/include/errno.h
libraries/mlcrt/include/malloc.h
libraries/mlcrt/include/mlcrt.h [new file with mode: 0644]
libraries/mlcrt/include/setjmp.h
libraries/mlcrt/include/stdio.h
libraries/mlcrt/include/stdlib.h
libraries/mlcrt/include/string.h
libraries/mlcrt/include/unistd.h
libraries/mlcrt/src/algorithm.c
libraries/mlcrt/src/crt0.c
libraries/mlcrt/src/crt_priv.h [new file with mode: 0644]
libraries/mlcrt/src/ctype.c
libraries/mlcrt/src/errno.c
libraries/mlcrt/src/exit.c
libraries/mlcrt/src/fcntl.c
libraries/mlcrt/src/io.c
libraries/mlcrt/src/io_priv.h
libraries/mlcrt/src/malloc.c
libraries/mlcrt/src/numconv.c
libraries/mlcrt/src/printf.c
libraries/mlcrt/src/setjmp.c
libraries/mlcrt/src/string.c
libraries/mlcrt/src/wd.c

index e3c3b1b3327664a3ba6d4046be0c452157706da3..fa559a4f05ab3cf91c864cba43709e4e54065ece 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * ctype.h
  *
- * Copyright (C) 2017 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
 #ifndef _CTYPE_H_
 #define _CTYPE_H_
 
-int isprint(int c);
-int isdigit(int c);
-int isxdigit(int c);
-int isspace(int c);
-char tolower(char c);
-char toupper(char c);
+#include <mlcrt.h>
+
+int __CRT_PUBLIC(isprint)(int c);
+int __CRT_PUBLIC(isdigit)(int c);
+int __CRT_PUBLIC(isxdigit)(int c);
+int __CRT_PUBLIC(isspace)(int c);
+char __CRT_PUBLIC(tolower)(char c);
+char __CRT_PUBLIC(toupper)(char c);
 
 #endif
index c0ffe70560d5e71a570ad0f1e2a36e326347d753..6484f961fe19cf7d9632787f50c7cbee1245e1f7 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * errno.h
  *
- * Copyright (C) 2017 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -20,6 +20,7 @@
 #ifndef _ERRNO_H_
 #define _ERRNO_H_
 
+#include <mlcrt.h>
 #include <stdint.h>
 
 #define EPERM        1
@@ -66,9 +67,9 @@
 #define ETOOSMALL    45
 #define EOVERFLOW    46
 
-extern int errno;
+extern int __CRT_PUBLIC(errno);
 
-int __crt_translate_error(uint32_t status_code);
+int __CRT_PRIVATE(translate_error)(uint32_t status_code);
 
 #endif
 
index b3001e8e7b0c90276af3f0bc1f2205cd66c1b486..cfe886f5107d2a81db696cf78175725bf439f133 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * malloc.h
  *
- * Copyright (C) 2017 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -17,6 +17,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "mlcrt.h"
+
 #ifndef _MALLOC_H_
 #define _MALLOC_H_
 
@@ -43,11 +45,11 @@ typedef struct
     void (*lock_mutex_proc)(void*);
     void (*unlock_mutex_proc)(void*);
     void (*problem)(int);
-} __crt_heap_t;
+} __CRT_PRIVATE(heap_t);
 
-void *malloc(size_t size);
-void free(void *ptr);
-void *calloc(size_t nmemb, size_t size);
-void *realloc(void *ptr, size_t size);
+void *__CRT_PUBLIC(malloc)(size_t size);
+void __CRT_PUBLIC(free)(void *ptr);
+void *__CRT_PUBLIC(calloc)(size_t nmemb, size_t size);
+void *__CRT_PUBLIC(realloc)(void *ptr, size_t size);
 
 #endif
diff --git a/libraries/mlcrt/include/mlcrt.h b/libraries/mlcrt/include/mlcrt.h
new file mode 100644 (file)
index 0000000..5fe4941
--- /dev/null
@@ -0,0 +1,37 @@
+/*
+ * mlcrt.h
+ *
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _MLCRT_H_
+#define _MLCRT_H_
+
+#ifndef __CRT_PUBLIC_PREFIX
+#define __CRT_PUBLIC_PREFIX
+#endif
+
+#ifndef __CRT_PRIVATE_PREFIX
+#define __CRT_PRIVATE_PREFIX __crt_
+#endif
+
+#define ___CRT_PASTE(a, b) a ## b
+#define __CRT_PASTE(a, b) ___CRT_PASTE(a, b)
+
+#define __CRT_PUBLIC(x)  __CRT_PASTE(__CRT_PUBLIC_PREFIX, x)
+#define __CRT_PRIVATE(x) __CRT_PASTE(__CRT_PRIVATE_PREFIX, x)
+
+#endif
index 0c1dad2844b427ee4c9472e1e1d5c3abdea38e11..d47897cc36842b621606dbcfc19e5c0fb1c1391b 100644 (file)
 
 #include <stddef.h>
 #include <monolithium.h>
+#include <mlcrt.h>
 
 typedef struct
 {
     int val;
     thread_state_t state;
-} jmp_buf[1];
+} __CRT_PUBLIC(jmp_buf)[1];
 
-int setjmp(jmp_buf env);
-int longjmp(jmp_buf env, int val);
+int __CRT_PUBLIC(setjmp)(__CRT_PUBLIC(jmp_buf) env);
+int __CRT_PUBLIC(longjmp)(__CRT_PUBLIC(jmp_buf) env, int val);
 
 #endif
index 467956d652b30d5f08fc5b8eab61b61dc1c49232..b2bae7370b0f686121d42d4f85749f6ba84ef62d 100644 (file)
 #ifndef _STDIO_H_
 #define _STDIO_H_
 
+#include <mlcrt.h>
 #include <stdlib.h>
 #include <stdarg.h>
 
 #define EOF -1
 
-#define getc(s) fgetc(s)
-#define getchar() fgetc(stdin)
-#define putc(c, s) fputc(c, s)
-#define putchar(c) fputc(c, stdout)
-
-#define getc_unlocked(s) fgetc_unlocked(s)
-#define getchar_unlocked() fgetc_unlocked(stdin)
-#define putc_unlocked(c, s) fputc_unlocked(c, s)
-#define putchar_unlocked(c) fputc(c, stdout)
-
-struct __crt_file;
-typedef struct __crt_file FILE;
-
-extern FILE *stdin;
-extern FILE *stdout;
-extern FILE *stderr;
-
-int fgetc(FILE *stream);
-int fputc(int c, FILE *stream);
-char *fgets(char *s, int size, FILE *stream);
-int fputs(const char *s, FILE *stream);
-int ungetc(int c, FILE *stream);
-char *gets(char *s);
-int puts(const char *s);
-
-int fgetc_unlocked(FILE *stream);
-int fputc_unlocked(int c, FILE *stream);
-char *fgets_unlocked(char *s, int size, FILE *stream);
-int fputs_unlocked(const char *s, FILE *stream);
-
-FILE *fopen(const char *pathname, const char *mode);
-FILE *fdopen(int fd, const char *mode);
-FILE *fmemopen(void *buf, size_t size, const char *mode);
-int fclose(FILE *stream);
+struct __CRT_PRIVATE(file);
+typedef struct __CRT_PRIVATE(file) FILE;
+
+extern FILE *__CRT_PUBLIC(stdin);
+extern FILE *__CRT_PUBLIC(stdout);
+extern FILE *__CRT_PUBLIC(stderr);
+
+int __CRT_PUBLIC(fgetc)(FILE *stream);
+int __CRT_PUBLIC(fputc)(int c, FILE *stream);
+char *__CRT_PUBLIC(fgets)(char *s, int size, FILE *stream);
+int __CRT_PUBLIC(fputs)(const char *s, FILE *stream);
+int __CRT_PUBLIC(ungetc)(int c, FILE *stream);
+char *__CRT_PUBLIC(gets)(char *s);
+int __CRT_PUBLIC(puts)(const char *s);
+
+static inline int __CRT_PUBLIC(getc)(FILE *stream)
+{
+    return __CRT_PUBLIC(fgetc)(stream);
+}
+
+static inline int __CRT_PUBLIC(getchar)(void)
+{
+    return __CRT_PUBLIC(fgetc)(__CRT_PUBLIC(stdin));
+}
+
+static inline int __CRT_PUBLIC(putc)(int c, FILE *stream)
+{
+    return __CRT_PUBLIC(fputc)(c, stream);
+}
+
+static inline int __CRT_PUBLIC(putchar)(int c)
+{
+    return __CRT_PUBLIC(fputc)(c, __CRT_PUBLIC(stdout));
+}
+
+int __CRT_PUBLIC(fgetc_unlocked)(FILE *stream);
+int __CRT_PUBLIC(fputc_unlocked)(int c, FILE *stream);
+char *__CRT_PUBLIC(fgets_unlocked)(char *s, int size, FILE *stream);
+int __CRT_PUBLIC(fputs_unlocked)(const char *s, FILE *stream);
+
+static inline int __CRT_PUBLIC(getc_unlocked)(FILE *stream)
+{
+    return __CRT_PUBLIC(fgetc_unlocked)(stream);
+}
+
+static inline int __CRT_PUBLIC(getchar_unlocked)(void)
+{
+    return __CRT_PUBLIC(fgetc_unlocked)(__CRT_PUBLIC(stdin));
+}
+
+static inline int __CRT_PUBLIC(putc_unlocked)(int c, FILE *stream)
+{
+    return __CRT_PUBLIC(fputc_unlocked)(c, stream);
+}
+
+static inline int __CRT_PUBLIC(putchar_unlocked)(int c)
+{
+    return __CRT_PUBLIC(fputc)(c, __CRT_PUBLIC(stdout));
+}
+
+FILE *__CRT_PUBLIC(fopen)(const char *pathname, const char *mode);
+FILE *__CRT_PUBLIC(fdopen)(int fd, const char *mode);
+FILE *__CRT_PUBLIC(fmemopen)(void *buf, size_t size, const char *mode);
+int __CRT_PUBLIC(fclose)(FILE *stream);
 
 #define BUFSIZ 4096
 #define _IOFBF 0
 #define _IOLBF 1
 #define _IONBF 2
 
-int setvbuf(FILE *stream, char *buf, int mode, size_t size);
-void setbuf(FILE *stream, char *buf);
-void setbuffer(FILE *stream, char *buf, size_t size);
-void setlinebuf(FILE *stream);
-
-int printf(const char *format, ...);
-int fprintf(FILE *stream, const char *format, ...);
-int dprintf(int fd, const char *format, ...);
-int sprintf(char *str, const char *format, ...);
-int snprintf(char *str, size_t size, const char *format, ...);
-int vprintf(const char *format, va_list ap);
-int vfprintf(FILE *stream, const char *format, va_list ap);
-int vdprintf(int fd, const char *format, va_list ap);
-int vsprintf(char *str, const char *format, va_list ap);
-int vsnprintf(char *str, size_t size, const char *format, va_list ap);
+int __CRT_PUBLIC(setvbuf)(FILE *stream, char *buf, int mode, size_t size);
+void __CRT_PUBLIC(setbuf)(FILE *stream, char *buf);
+void __CRT_PUBLIC(setbuffer)(FILE *stream, char *buf, size_t size);
+void __CRT_PUBLIC(setlinebuf)(FILE *stream);
 
+int __CRT_PUBLIC(printf)(const char *format, ...);
+int __CRT_PUBLIC(fprintf)(FILE *stream, const char *format, ...);
+int __CRT_PUBLIC(dprintf)(int fd, const char *format, ...);
+int __CRT_PUBLIC(sprintf)(char *str, const char *format, ...);
+int __CRT_PUBLIC(snprintf)(char *str, size_t size, const char *format, ...);
+int __CRT_PUBLIC(vprintf)(const char *format, va_list ap);
+int __CRT_PUBLIC(vfprintf)(FILE *stream, const char *format, va_list ap);
+int __CRT_PUBLIC(vdprintf)(int fd, const char *format, va_list ap);
+int __CRT_PUBLIC(vsprintf)(char *str, const char *format, va_list ap);
+int __CRT_PUBLIC(vsnprintf)(char *str, size_t size, const char *format, va_list ap);
 
 #endif
index f1a9524cf684c5efacc27fcf20dc3ec140022d42..6798a97a1991ade42b22645daa9461bea8afcc99 100644 (file)
 #ifndef _STDLIB_H_
 #define _STDLIB_H_
 
+#include <mlcrt.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <malloc.h>
 #include <errno.h>
 
-char *itoa(int value, char *str, int base);
-char *ltoa(long value, char *str, int base);
-char *lltoa(long long value, char *str, int base);
-char *uitoa(unsigned int value, char *str, int base);
-char *ultoa(unsigned long value, char *str, int base);
-char *ulltoa(unsigned long long value, char *str, int base);
-int atoi(const char *str);
-long atol(const char *str);
-long long atoll(const char *str);
-long strtol(const char *str, char **endptr, int base);
-long long strtoll(const char *str, char **endptr, int base);
-unsigned long strtoul(const char *str, char **endptr, int base);
-unsigned long long strtoull(const char *str, char **endptr, int base);
-
-void qsort(void *base, size_t nmemb, size_t size, int (*compare)(const void*, const void*));
-void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compare)(const void*, const void*));
+char *__CRT_PUBLIC(itoa)(int value, char *str, int base);
+char *__CRT_PUBLIC(ltoa)(long value, char *str, int base);
+char *__CRT_PUBLIC(lltoa)(long long value, char *str, int base);
+char *__CRT_PUBLIC(uitoa)(unsigned int value, char *str, int base);
+char *__CRT_PUBLIC(ultoa)(unsigned long value, char *str, int base);
+char *__CRT_PUBLIC(ulltoa)(unsigned long long value, char *str, int base);
+int __CRT_PUBLIC(atoi)(const char *str);
+long __CRT_PUBLIC(atol)(const char *str);
+long long __CRT_PUBLIC(atoll)(const char *str);
+long __CRT_PUBLIC(strtol)(const char *str, char **endptr, int base);
+long long __CRT_PUBLIC(strtoll)(const char *str, char **endptr, int base);
+unsigned long __CRT_PUBLIC(strtoul)(const char *str, char **endptr, int base);
+unsigned long long __CRT_PUBLIC(strtoull)(const char *str, char **endptr, int base);
+
+void __CRT_PUBLIC(qsort)(void *base, size_t nmemb, size_t size, int (*compare)(const void*, const void*));
+void *__CRT_PUBLIC(bsearch)(const void *key, const void *base, size_t nmemb, size_t size, int (*compare)(const void*, const void*));
 
 #define ATEXIT_MAX 32
 
-int atexit(void (*function)(void));
-void __attribute__((__noreturn__)) exit(int status);
+int __CRT_PUBLIC(atexit)(void (*function)(void));
+void __attribute__((__noreturn__)) __CRT_PUBLIC(exit)(int status);
 
 typedef uint32_t pid_t;
 
-pid_t getpid(void);
-pid_t getppid(void);
-pid_t fork(void);
+pid_t __CRT_PUBLIC(getpid)(void);
+pid_t __CRT_PUBLIC(getppid)(void);
+pid_t __CRT_PUBLIC(fork)(void);
 
 #endif
index 9bc9057ee3ac8dc39c08431105b87aa0596362b2..87c79ccc1f860cca466fd1caa90b04ac7ceae9e9 100644 (file)
 #ifndef _STRING_H_
 #define _STRING_H_
 
+#include <mlcrt.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <limits.h>
 #include <ctype.h>
 
-char *strcpy(char *destination, const char *source);
-char *strncpy(char *destination, const char *source, size_t n);
-int strcmp(const char *str1, const char *str2);
-int stricmp(const char *str1, const char *str2);
-int strncmp(const char *str1, const char *str2, size_t n);
-char *strstr(const char *haystack, const char *needle);
-char *strchr(const char *str, char c);
-char *strrchr(const char *str, char c);
-char *strcat(char *destination, const char *source);
-char *strncat(char *destination, const char *source, size_t n);
-char *strdup(const char *source);
-char *strtok(char *str, const char *delimiters);
-char *strtok_r(char *str, const char *delimiters, char **endptr);
-size_t strlen(const char *str);
-void strrev(char *str);
-void memset(void *ptr, int value, size_t n);
-void memcpy(void *destination, const void *source, size_t n);
-void memmove(void *destination, const void *source, size_t n);
-int memcmp(const void *mem1, const void *mem2, size_t n);
+char *__CRT_PUBLIC(strcpy)(char *destination, const char *source);
+char *__CRT_PUBLIC(strncpy)(char *destination, const char *source, size_t n);
+int __CRT_PUBLIC(strcmp)(const char *str1, const char *str2);
+int __CRT_PUBLIC(stricmp)(const char *str1, const char *str2);
+int __CRT_PUBLIC(strncmp)(const char *str1, const char *str2, size_t n);
+char *__CRT_PUBLIC(strstr)(const char *haystack, const char *needle);
+char *__CRT_PUBLIC(strchr)(const char *str, char c);
+char *__CRT_PUBLIC(strrchr)(const char *str, char c);
+char *__CRT_PUBLIC(strcat)(char *destination, const char *source);
+char *__CRT_PUBLIC(strncat)(char *destination, const char *source, size_t n);
+char *__CRT_PUBLIC(strdup)(const char *source);
+char *__CRT_PUBLIC(strtok)(char *str, const char *delimiters);
+char *__CRT_PUBLIC(strtok_r)(char *str, const char *delimiters, char **endptr);
+size_t __CRT_PUBLIC(strlen)(const char *str);
+void __CRT_PUBLIC(strrev)(char *str);
+void __CRT_PUBLIC(memset)(void *ptr, int value, size_t n);
+void __CRT_PUBLIC(memcpy)(void *destination, const void *source, size_t n);
+void __CRT_PUBLIC(memmove)(void *destination, const void *source, size_t n);
+int __CRT_PUBLIC(memcmp)(const void *mem1, const void *mem2, size_t n);
 
 #endif
index a1f1b8ac6c4fdb66010e4b4426333703c674d217..60532484a6d369067ac73ac7667af617303967a0 100644 (file)
@@ -20,6 +20,7 @@
 #ifndef _UNISTD_H_
 #define _UNISTD_H_
 
+#include <mlcrt.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -47,20 +48,20 @@ typedef uint16_t mode_t;
 typedef ptrdiff_t off_t;
 typedef ptrdiff_t ssize_t;
 
-char *getcwd(char *buf, size_t size);
-char *getwd(char *buf);
-char *get_current_dir_name(void);
-int fchdir(int fd);
-int chdir(const char *path);
+char *__CRT_PUBLIC(getcwd)(char *buf, size_t size);
+char *__CRT_PUBLIC(getwd)(char *buf);
+char *__CRT_PUBLIC(get_current_dir_name)(void);
+int __CRT_PUBLIC(fchdir)(int fd);
+int __CRT_PUBLIC(chdir)(const char *path);
 
 #ifndef __DONT_DEFINE_OPEN__
-int open(const char *pathname, int flags, ...);
+int __CRT_PUBLIC(open)(const char *pathname, int flags, ...);
 #endif
 
-int creat(const char *pathname, mode_t mode);
-int close(int fd);
-ssize_t read(int fd, void *buf, size_t count);
-ssize_t write(int fd, const void *buf, size_t count);
-off_t lseek(int fd, off_t offset, int whence);
+int __CRT_PUBLIC(creat)(const char *pathname, mode_t mode);
+int __CRT_PUBLIC(close)(int fd);
+ssize_t __CRT_PUBLIC(read)(int fd, void *buf, size_t count);
+ssize_t __CRT_PUBLIC(write)(int fd, const void *buf, size_t count);
+off_t __CRT_PUBLIC(lseek)(int fd, off_t offset, int whence);
 
 #endif
index c45e1d480b8462fe55da35037a9d3332e0bf5e0d..83ca697416e6ffe72379637b09ea6d492d13ded3 100644 (file)
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "crt_priv.h"
 #include <string.h>
 
-void qsort(void *base, size_t nmemb, size_t size, int (*compare)(const void*, const void*))
+void __CRT_PUBLIC(qsort)(void *base, size_t nmemb, size_t size, int (*compare)(const void*, const void*))
 {
     void *pivot = (void*)((uintptr_t)base + (nmemb / 2) * size);
     void *temp = __builtin_alloca(size);
@@ -34,16 +35,16 @@ void qsort(void *base, size_t nmemb, size_t size, int (*compare)(const void*, co
         while (compare((void*)((uintptr_t)base + high * size), pivot) > 0) high--;
         if (low >= high) break;
 
-        memcpy(temp, (void*)((uintptr_t)base + low * size), size);
-        memcpy((void*)((uintptr_t)base + low * size), (void*)((uintptr_t)base + high * size), size);
-        memcpy((void*)((uintptr_t)base + high * size), temp, size);
+        __builtin_memcpy(temp, (void*)((uintptr_t)base + low * size), size);
+        __builtin_memcpy((void*)((uintptr_t)base + low * size), (void*)((uintptr_t)base + high * size), size);
+        __builtin_memcpy((void*)((uintptr_t)base + high * size), temp, size);
     }
 
-    qsort(base, high, size, compare);
-    qsort((void*)((size_t)base + high * size), nmemb - high, size, compare);
+    __CRT_PUBLIC(qsort)(base, high, size, compare);
+    __CRT_PUBLIC(qsort)((void*)((size_t)base + high * size), nmemb - high, size, compare);
 }
 
-void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compare)(const void*, const void*))
+void *__CRT_PUBLIC(bsearch)(const void *key, const void *base, size_t nmemb, size_t size, int (*compare)(const void*, const void*))
 {
     long low = 0;
     long high = nmemb - 1;
index e8a5e7a89debdda3a2f72bc4027a03e52ff9e530..832e2c77bde88bf592260b6e14b0f23a7d32f817 100644 (file)
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "crt_priv.h"
 #include <stdlib.h>
 #include <string.h>
-#include <monolithium.h>
 
-int __crt_initialize_heap(void);
-int __crt_initialize_files(process_params_t *params);
+int __CRT_PRIVATE(initialize_heap)(void);
+int __CRT_PRIVATE(initialize_files)(process_params_t *params);
 int main(int argc, char **argv);
 
 void process_startup(process_params_t *params)
@@ -31,12 +31,12 @@ void process_startup(process_params_t *params)
     char *ptr;
     int space = 1;
 
-    if (__crt_initialize_heap() < 0) syscall_terminate(INVALID_HANDLE, 255);
-    if (__crt_initialize_files(params) < 0) syscall_terminate(INVALID_HANDLE, 255);
+    if (__CRT_PRIVATE(initialize_heap)() < 0) syscall_terminate(INVALID_HANDLE, 255);
+    if (__CRT_PRIVATE(initialize_files)(params) < 0) syscall_terminate(INVALID_HANDLE, 255);
 
     for (ptr = params->command_line; *ptr; ptr++)
     {
-        if (space != (isspace(*ptr) != 0))
+        if (space != (__CRT_PUBLIC(isspace)(*ptr) != 0))
         {
             argc++;
             space = !space;
@@ -46,7 +46,7 @@ void process_startup(process_params_t *params)
     char **argv = (char**)__builtin_alloca(argc * sizeof(char*));
     argc = 0;
 
-    for (ptr = strtok(params->command_line, " \t\r\n\v\f"); ptr != NULL; ptr = strtok(NULL, " \t\r\n\v\f"))
+    for (ptr = __CRT_PUBLIC(strtok)(params->command_line, " \t\r\n\v\f"); ptr != NULL; ptr = __CRT_PUBLIC(strtok)(NULL, " \t\r\n\v\f"))
     {
         if (*ptr) argv[argc++] = ptr;
     }
@@ -54,5 +54,5 @@ void process_startup(process_params_t *params)
     argv[argc] = NULL;
 
     int exit_code = main(argc, argv);
-    exit(exit_code);
+    __CRT_PUBLIC(exit)(exit_code);
 }
diff --git a/libraries/mlcrt/src/crt_priv.h b/libraries/mlcrt/src/crt_priv.h
new file mode 100644 (file)
index 0000000..a261476
--- /dev/null
@@ -0,0 +1,26 @@
+/*
+ * crt_priv.h
+ *
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _CRT_PRIV_H_
+#define _CRT_PRIV_H_
+
+#include <mlcrt.h>
+#include <monolithium.h>
+
+#endif
index 797ff5884f9342960e2bfb2d668d3a4fc91394ac..0e036bf0c983be6ae609e1e3ca4334a9615d8a22 100644 (file)
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "mlcrt.h"
 #include <string.h>
 
-int isprint(int c)
+int __CRT_PUBLIC(isprint)(int c)
 {
     return c >= 0x20 && c <= 0x7E;
 }
 
-int isdigit(int c)
+int __CRT_PUBLIC(isdigit)(int c)
 {
     return c >= '0' && c <= '9';
 }
 
-int isxdigit(int c)
+int __CRT_PUBLIC(isxdigit)(int c)
 {
     return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
 }
 
-int isspace(int c)
+int __CRT_PUBLIC(isspace)(int c)
 {
-    return strchr(" \t\n\v\f\r", c) != NULL;
+    return __CRT_PUBLIC(strchr)(" \t\n\v\f\r", c) != NULL;
 }
 
-char tolower(char c)
+char __CRT_PUBLIC(tolower)(char c)
 {
     if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
     return c;
 }
 
-char toupper(char c)
+char __CRT_PUBLIC(toupper)(char c)
 {
     if (c >= 'a' && c <= 'z') c -= 'a' - 'A';
     return c;
index 0c63fc8cb82c69c38a914bcb6ea6d9b9935d8c85..d4b0c6a1b5748c52993adcba218171252c0785f4 100644 (file)
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "crt_priv.h"
 #include <errno.h>
-#include <monolithium.h>
 
-int errno = 0;
+int __CRT_PUBLIC(errno) = 0;
 
-int __crt_translate_error(uint32_t status_code)
+int __CRT_PRIVATE(translate_error)(uint32_t status_code)
 {
     switch (status_code)
     {
index 0af3d524d81dd1f549eba6b01534320d4375fe96..ac472b07955f20e956dae3a9a776784103f8904a 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * exit.c
  *
- * Copyright (C) 2017 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "crt_priv.h"
 #include <stdlib.h>
-#include <monolithium.h>
 
 static void (*atexit_functions[ATEXIT_MAX])(void);
 static int num_atexit_functions = 0;
 
-int atexit(void (*function)(void))
+int __CRT_PUBLIC(atexit)(void (*function)(void))
 {
     if (num_atexit_functions == ATEXIT_MAX) return -1;
     atexit_functions[num_atexit_functions++] = function;
     return 0;
 }
 
-void __attribute__((__noreturn__)) exit(int status)
+void __attribute__((__noreturn__)) __CRT_PUBLIC(exit)(int status)
 {
     while (num_atexit_functions) atexit_functions[--num_atexit_functions]();
 
index a8b710914323aee64e518ab6cf661143c40b5e39..55c9e84c81c8c214889db25274e5ad79d82f307d 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * fcntl.c
  *
- * Copyright (C) 2017 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -17,7 +17,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <monolithium.h>
+#include "crt_priv.h"
 #include <stdlib.h>
 #include <string.h>
 
@@ -36,7 +36,7 @@ static struct
     size_t size;
 } descriptors[MAX_OPEN_FILES];
 
-handle_t __crt_get_raw_handle(int fd)
+handle_t __CRT_PRIVATE(get_raw_handle)(int fd)
 {
     syscall_wait_mutex(mutex, NO_TIMEOUT);
     handle_t handle = descriptors[fd].handle;
@@ -44,14 +44,14 @@ handle_t __crt_get_raw_handle(int fd)
     return handle;
 }
 
-static inline int __crt_open_handle_at(int fd, handle_t handle, int flags)
+static inline int __CRT_PRIVATE(open_handle_at)(int fd, handle_t handle, int flags)
 {
     object_type_t type;
     sysret_t status = syscall_query_handle(handle, HANDLE_INFO_TYPE, &type, sizeof(type));
 
     if (status != ERR_SUCCESS || (type != OBJECT_FILE && type != OBJECT_PIPE))
     {
-        errno = EINVAL;
+        __CRT_PUBLIC(errno) = EINVAL;
         return -1;
     }
 
@@ -61,13 +61,13 @@ static inline int __crt_open_handle_at(int fd, handle_t handle, int flags)
         status = syscall_query_file(handle, FILE_INFO_SIZE, &real_size, sizeof(real_size));
         if (status != ERR_SUCCESS)
         {
-            errno = __crt_translate_error(status);
+            __CRT_PUBLIC(errno) = __CRT_PRIVATE(translate_error)(status);
             return -1;
         }
 
         if (real_size > (qword_t)((size_t)-1))
         {
-            errno = EFBIG;
+            __CRT_PUBLIC(errno) = EFBIG;
             return -1;
         }
 
@@ -86,7 +86,7 @@ static inline int __crt_open_handle_at(int fd, handle_t handle, int flags)
     return fd;
 }
 
-static inline int __crt_open_handle(handle_t handle, int flags)
+static inline int __CRT_PRIVATE(open_handle)(handle_t handle, int flags)
 {
     int fd;
     syscall_wait_mutex(mutex, NO_TIMEOUT);
@@ -98,47 +98,47 @@ static inline int __crt_open_handle(handle_t handle, int flags)
 
     if (fd == MAX_OPEN_FILES)
     {
-        errno = EMFILE;
+        __CRT_PUBLIC(errno) = EMFILE;
         return -1;
     }
 
-    fd = __crt_open_handle_at(fd, handle, flags);
+    fd = __CRT_PRIVATE(open_handle_at)(fd, handle, flags);
 
     syscall_release_mutex(mutex);
     return fd;
 }
 
-int open(const char *pathname, int flags, mode_t mode)
+int __CRT_PUBLIC(open)(const char *pathname, int flags, mode_t mode)
 {
     handle_t handle;
     char fullpath[PATH_MAX];
 
     if (*pathname == '/')
     {
-        if (strlen(pathname) >= PATH_MAX)
+        if (__CRT_PUBLIC(strlen)(pathname) >= PATH_MAX)
         {
-            errno = ENAMETOOLONG;
+            __CRT_PUBLIC(errno) = ENAMETOOLONG;
             return -1;
         }
 
-        strcpy(fullpath, pathname);
+        __CRT_PUBLIC(strcpy)(fullpath, pathname);
     }
     else
     {
-        getwd(fullpath);
+        __CRT_PUBLIC(getwd)(fullpath);
 
-        if (strlen(fullpath) + strlen(pathname) >= PATH_MAX)
+        if (__CRT_PUBLIC(strlen)(fullpath) + __CRT_PUBLIC(strlen)(pathname) >= PATH_MAX)
         {
-            errno = ENAMETOOLONG;
+            __CRT_PUBLIC(errno) = ENAMETOOLONG;
             return -1;
         }
 
-        strcat(fullpath, pathname);
+        __CRT_PUBLIC(strcat)(fullpath, pathname);
     }
 
     if ((flags & 3) == 3)
     {
-        errno = EINVAL;
+        __CRT_PUBLIC(errno) = EINVAL;
         return -1;
     }
 
@@ -155,28 +155,28 @@ int open(const char *pathname, int flags, mode_t mode)
     sysret_t status = syscall_open_file(fullpath, &handle, kernel_flags, attributes);
     if (status != ERR_SUCCESS)
     {
-        errno = __crt_translate_error(status);
+        __CRT_PUBLIC(errno) = __CRT_PRIVATE(translate_error)(status);
         return -1;
     }
 
-    int fd = __crt_open_handle(handle, flags);
+    int fd = __CRT_PRIVATE(open_handle)(handle, flags);
     if (fd < 0) syscall_close_object(handle);
     return fd;
 }
 
-int creat(const char *pathname, mode_t mode)
+int __CRT_PUBLIC(creat)(const char *pathname, mode_t mode)
 {
-    return open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
+    return __CRT_PUBLIC(open)(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
 }
 
-int close(int fd)
+int __CRT_PUBLIC(close)(int fd)
 {
     int ret = -1;
     syscall_wait_mutex(mutex, NO_TIMEOUT);
 
     if (fd < 0 || fd >= MAX_OPEN_FILES || descriptors[fd].handle == INVALID_HANDLE)
     {
-        errno = EBADF;
+        __CRT_PUBLIC(errno) = EBADF;
         goto cleanup;
     }
 
@@ -189,7 +189,7 @@ cleanup:
     return ret;
 }
 
-ssize_t read(int fd, void *buf, size_t count)
+ssize_t __CRT_PUBLIC(read)(int fd, void *buf, size_t count)
 {
     syscall_wait_mutex(mutex, NO_TIMEOUT);
 
@@ -200,7 +200,7 @@ ssize_t read(int fd, void *buf, size_t count)
 
     if (status != ERR_SUCCESS && status != ERR_BEYOND)
     {
-        errno = __crt_translate_error(status);
+        __CRT_PUBLIC(errno) = __CRT_PRIVATE(translate_error)(status);
         ret = (off_t)-1;
     }
 
@@ -208,7 +208,7 @@ ssize_t read(int fd, void *buf, size_t count)
     return (ssize_t)ret;
 }
 
-ssize_t write(int fd, const void *buf, size_t count)
+ssize_t __CRT_PUBLIC(write)(int fd, const void *buf, size_t count)
 {
     syscall_wait_mutex(mutex, NO_TIMEOUT);
 
@@ -219,7 +219,7 @@ ssize_t write(int fd, const void *buf, size_t count)
 
     if (status != ERR_SUCCESS && status != ERR_BEYOND)
     {
-        errno = __crt_translate_error(status);
+        __CRT_PUBLIC(errno) = __CRT_PRIVATE(translate_error)(status);
         ret = (off_t)-1;
     }
 
@@ -227,11 +227,11 @@ ssize_t write(int fd, const void *buf, size_t count)
     return (ssize_t)ret;
 }
 
-off_t lseek(int fd, off_t offset, int whence)
+off_t __CRT_PUBLIC(lseek)(int fd, off_t offset, int whence)
 {
     if (whence < SEEK_SET || whence > SEEK_END)
     {
-        errno = EINVAL;
+        __CRT_PUBLIC(errno) = EINVAL;
         return (off_t)-1;
     }
 
@@ -239,13 +239,13 @@ off_t lseek(int fd, off_t offset, int whence)
 
     if (fd < 0 || fd >= MAX_OPEN_FILES || descriptors[fd].handle == INVALID_HANDLE)
     {
-        errno = EBADF;
+        __CRT_PUBLIC(errno) = EBADF;
         goto cleanup;
     }
 
     if (descriptors[fd].descriptor_flags & FD_PIPE)
     {
-        errno = ESPIPE;
+        __CRT_PUBLIC(errno) = ESPIPE;
         goto cleanup;
     }
 
@@ -257,7 +257,7 @@ off_t lseek(int fd, off_t offset, int whence)
 
     if ((offset > 0 && ret < origin) || (offset < 0 && ret > origin))
     {
-        errno = EOVERFLOW;
+        __CRT_PUBLIC(errno) = EOVERFLOW;
         goto cleanup;
     }
 
@@ -268,7 +268,7 @@ cleanup:
     return ret;
 }
 
-int dup(int oldfd)
+int __CRT_PUBLIC(dup)(int oldfd)
 {
     syscall_wait_mutex(mutex, NO_TIMEOUT);
 
@@ -279,14 +279,14 @@ int dup(int oldfd)
 
     if (status != ERR_SUCCESS)
     {
-        errno = __crt_translate_error(status);
+        __CRT_PUBLIC(errno) = __CRT_PRIVATE(translate_error)(status);
         return -1;
     }
 
-    return __crt_open_handle(duplicate, flags);
+    return __CRT_PRIVATE(open_handle)(duplicate, flags);
 }
 
-int dup2(int oldfd, int newfd)
+int __CRT_PUBLIC(dup2)(int oldfd, int newfd)
 {
     int fd = -1;
     syscall_wait_mutex(mutex, NO_TIMEOUT);
@@ -296,18 +296,18 @@ int dup2(int oldfd, int newfd)
 
     if (status != ERR_SUCCESS)
     {
-        errno = __crt_translate_error(status);
+        __CRT_PUBLIC(errno) = __CRT_PRIVATE(translate_error)(status);
         goto cleanup;
     }
 
-    fd = __crt_open_handle_at(newfd, duplicate, descriptors[oldfd].flags);
+    fd = __CRT_PRIVATE(open_handle_at)(newfd, duplicate, descriptors[oldfd].flags);
 
 cleanup:
     syscall_release_mutex(mutex);
     return fd;
 }
 
-int __crt_initialize_files(process_params_t *params)
+int __CRT_PRIVATE(initialize_files)(process_params_t *params)
 {
     sysret_t ret = syscall_create_mutex(NULL, TRUE, &mutex);
     if (ret != ERR_SUCCESS) return -1;
@@ -315,8 +315,8 @@ int __crt_initialize_files(process_params_t *params)
     int i;
     for (i = 0; i < MAX_OPEN_FILES; i++) descriptors[i].handle = INVALID_HANDLE;
 
-    if (params->standard_input != INVALID_HANDLE) __crt_open_handle_at(STDIN_FILENO, params->standard_input, O_RDONLY);
-    if (params->standard_input != INVALID_HANDLE) __crt_open_handle_at(STDOUT_FILENO, params->standard_output, O_WRONLY);
-    if (params->standard_input != INVALID_HANDLE) __crt_open_handle_at(STDERR_FILENO, params->standard_error, O_WRONLY);
+    if (params->standard_input != INVALID_HANDLE) __CRT_PRIVATE(open_handle_at)(STDIN_FILENO, params->standard_input, O_RDONLY);
+    if (params->standard_input != INVALID_HANDLE) __CRT_PRIVATE(open_handle_at)(STDOUT_FILENO, params->standard_output, O_WRONLY);
+    if (params->standard_input != INVALID_HANDLE) __CRT_PRIVATE(open_handle_at)(STDERR_FILENO, params->standard_error, O_WRONLY);
     return 0;
 }
index 2b461679844b9cc1e7e7bb44f433fe36c5e42c98..99f000d58adf9606e155c21dca7a4b204e7edf39 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * io.c
  *
- * Copyright (C) 2017 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -19,6 +19,7 @@
 
 #include <stdio.h>
 #include <unistd.h>
+#include "crt_priv.h"
 #include "io_priv.h"
 
 static list_entry_t open_files;
@@ -27,21 +28,21 @@ FILE *stdin  = NULL;
 FILE *stdout = NULL;
 FILE *stderr = NULL;
 
-int fileno_unlocked(FILE *stream)
+int __CRT_PUBLIC(fileno_unlocked)(FILE *stream)
 {
-    if (stream->fd == -1) errno = EBADF;
+    if (stream->fd == -1) __CRT_PUBLIC(errno) = EBADF;
     return stream->fd;
 }
 
-int fileno(FILE *stream)
+int __CRT_PUBLIC(fileno)(FILE *stream)
 {
     syscall_wait_mutex(stream->mutex, NO_TIMEOUT);
-    int ret = fileno_unlocked(stream);
+    int ret = __CRT_PUBLIC(fileno_unlocked)(stream);
     syscall_release_mutex(stream->mutex);
     return ret;
 }
 
-static int __crt_fflush_stream(FILE *stream)
+static int __CRT_PRIVATE(fflush_stream)(FILE *stream)
 {
     if (!stream->buffer) return EOF;
 
@@ -56,7 +57,7 @@ static int __crt_fflush_stream(FILE *stream)
 
     if (stream->buffer_start < stream->buffer_end)
     {
-        ssize_t written = write(stream->fd, &stream->buffer[stream->buffer_start], stream->buffer_end - stream->buffer_start);
+        ssize_t written = __CRT_PUBLIC(write)(stream->fd, &stream->buffer[stream->buffer_start], stream->buffer_end - stream->buffer_start);
         if (written < 0) return EOF;
 
         stream->buffer_start += written;
@@ -67,7 +68,7 @@ static int __crt_fflush_stream(FILE *stream)
     {
         if (stream->buffer_start < stream->buffer_size)
         {
-            ssize_t written = write(stream->fd, &stream->buffer[stream->buffer_start], stream->buffer_size - stream->buffer_start);
+            ssize_t written = __CRT_PUBLIC(write)(stream->fd, &stream->buffer[stream->buffer_start], stream->buffer_size - stream->buffer_start);
             if (written < 0) return EOF;
 
             stream->buffer_start += written;
@@ -77,7 +78,7 @@ static int __crt_fflush_stream(FILE *stream)
 
         if (stream->buffer_end)
         {
-            ssize_t written = write(stream->fd, stream->buffer, stream->buffer_end);
+            ssize_t written =__CRT_PUBLIC(write)(stream->fd, stream->buffer, stream->buffer_end);
             if (written < 0) return EOF;
 
             stream->buffer_start += written;
@@ -89,16 +90,16 @@ static int __crt_fflush_stream(FILE *stream)
     return 0;
 }
 
-int fflush_unlocked(FILE *stream)
+int __CRT_PUBLIC(fflush_unlocked)(FILE *stream)
 {
-    if (stream) return __crt_fflush_stream(stream);
+    if (stream) return __CRT_PRIVATE(fflush_stream)(stream);
 
     list_entry_t *entry;
     int result = 0;
 
     for (entry = open_files.next; entry != &open_files; entry = entry->next)
     {
-        if (__crt_fflush_stream(CONTAINER_OF(entry, struct __crt_file, link)) == EOF)
+        if (__CRT_PRIVATE(fflush_stream)(CONTAINER_OF(entry, struct __crt_file, link)) == EOF)
         {
             result = EOF;
         }
@@ -107,15 +108,15 @@ int fflush_unlocked(FILE *stream)
     return result;
 }
 
-int fflush(FILE *stream)
+int __CRT_PUBLIC(fflush)(FILE *stream)
 {
     syscall_wait_mutex(stream->mutex, NO_TIMEOUT);
-    int ret = fflush_unlocked(stream);
+    int ret = __CRT_PUBLIC(fflush_unlocked)(stream);
     syscall_release_mutex(stream->mutex);
     return ret;
 }
 
-int setvbuf(FILE *stream, char *buf, int mode, size_t size)
+int __CRT_PUBLIC(setvbuf)(FILE *stream, char *buf, int mode, size_t size)
 {
     int ret = EOF;
     syscall_wait_mutex(stream->mutex, NO_TIMEOUT);
@@ -123,7 +124,7 @@ int setvbuf(FILE *stream, char *buf, int mode, size_t size)
     switch (mode)
     {
     case _IONBF:
-        if (fflush_unlocked(stream) == 0)
+        if (__CRT_PUBLIC(fflush_unlocked)(stream) == 0)
         {
             stream->buffer = NULL;
             stream->buffer_size = 0;
@@ -132,7 +133,7 @@ int setvbuf(FILE *stream, char *buf, int mode, size_t size)
         break;
 
     case _IOLBF:
-        if (!buf || fflush_unlocked(stream) == 0)
+        if (!buf || __CRT_PUBLIC(fflush_unlocked)(stream) == 0)
         {
             if (buf)
             {
@@ -146,7 +147,7 @@ int setvbuf(FILE *stream, char *buf, int mode, size_t size)
         break;
 
     case _IOFBF:
-        if (!buf || fflush_unlocked(stream) == 0)
+        if (!buf || __CRT_PUBLIC(fflush_unlocked)(stream) == 0)
         {
             if (buf)
             {
@@ -164,28 +165,28 @@ int setvbuf(FILE *stream, char *buf, int mode, size_t size)
     return ret;
 }
 
-void setbuf(FILE *stream, char *buf)
+void __CRT_PUBLIC(setbuf)(FILE *stream, char *buf)
 {
-    setvbuf(stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
+    __CRT_PUBLIC(setvbuf)(stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
 }
 
-void setbuffer(FILE *stream, char *buf, size_t size)
+void __CRT_PUBLIC(setbuffer)(FILE *stream, char *buf, size_t size)
 {
-    setvbuf(stream, buf, buf ? _IOFBF : _IONBF, size);
+    __CRT_PUBLIC(setvbuf)(stream, buf, buf ? _IOFBF : _IONBF, size);
 }
 
-void setlinebuf(FILE *stream)
+void __CRT_PUBLIC(setlinebuf)(FILE *stream)
 {
-    setvbuf(stream, NULL, _IOLBF, 0);
+    __CRT_PUBLIC(setvbuf)(stream, NULL, _IOLBF, 0);
 }
 
-inline int fgetc_unlocked(FILE *stream)
+inline int __CRT_PUBLIC(fgetc_unlocked)(FILE *stream)
 {
     char c;
 
     if (!(stream->flags & FILE_READ))
     {
-        errno = EPERM;
+        __CRT_PUBLIC(errno) = EPERM;
         return EOF;
     }
 
@@ -193,7 +194,7 @@ inline int fgetc_unlocked(FILE *stream)
     {
         if (stream->flags & FILE_BUFFER_DIR)
         {
-            fflush_unlocked(stream);
+            __CRT_PUBLIC(fflush_unlocked)(stream);
             stream->flags &= ~FILE_BUFFER_DIR;
         }
 
@@ -203,7 +204,7 @@ inline int fgetc_unlocked(FILE *stream)
 
             if (stream->buffer_end < stream->buffer_size)
             {
-                ssize_t amount = read(stream->fd, &stream->buffer[stream->buffer_end], stream->buffer_size - stream->buffer_end);
+                ssize_t amount = __CRT_PUBLIC(read)(stream->fd, &stream->buffer[stream->buffer_end], stream->buffer_size - stream->buffer_end);
                 if (amount < 0) return EOF;
 
                 stream->buffer_end += amount;
@@ -213,7 +214,7 @@ inline int fgetc_unlocked(FILE *stream)
 
             if (stream->buffer_end < stream->buffer_start)
             {
-                ssize_t amount = read(stream->fd, &stream->buffer[stream->buffer_end], stream->buffer_start - stream->buffer_end);
+                ssize_t amount = __CRT_PUBLIC(read)(stream->fd, &stream->buffer[stream->buffer_end], stream->buffer_start - stream->buffer_end);
                 if (amount < 0) return EOF;
 
                 stream->buffer_end += amount;
@@ -230,25 +231,25 @@ inline int fgetc_unlocked(FILE *stream)
     }
     else
     {
-        if (read(stream->fd, &c, 1) != 1) c = EOF;
+        if (__CRT_PUBLIC(read)(stream->fd, &c, 1) != 1) c = EOF;
     }
 
     return (int)((unsigned int)c);
 }
 
-int fgetc(FILE *stream)
+int __CRT_PUBLIC(fgetc)(FILE *stream)
 {
     syscall_wait_mutex(stream->mutex, NO_TIMEOUT);
-    int ret = fgetc_unlocked(stream);
+    int ret = __CRT_PUBLIC(fgetc_unlocked)(stream);
     syscall_release_mutex(stream->mutex);
     return ret;
 }
 
-inline int fputc_unlocked(int c, FILE *stream)
+inline int __CRT_PUBLIC(fputc_unlocked)(int c, FILE *stream)
 {
     if (!(stream->flags & FILE_WRITE))
     {
-        errno = EPERM;
+        __CRT_PUBLIC(errno) = EPERM;
         return EOF;
     }
 
@@ -256,13 +257,13 @@ inline int fputc_unlocked(int c, FILE *stream)
     {
         if (!(stream->flags & FILE_BUFFER_DIR))
         {
-            fflush_unlocked(stream);
+            __CRT_PUBLIC(fflush_unlocked)(stream);
             stream->flags |= FILE_BUFFER_DIR;
         }
 
         if (stream->flags & FILE_BUFFER_FULL)
         {
-            errno = ENOSPC;
+            __CRT_PUBLIC(errno) = ENOSPC;
             return EOF;
         }
 
@@ -277,31 +278,31 @@ inline int fputc_unlocked(int c, FILE *stream)
 
         if (stream->fd != -1 && ((stream->flags & FILE_BUFFER_FULL) || ((stream->flags & FILE_BUFFER_LINE) && (char)c == '\n')))
         {
-            fflush_unlocked(stream);
+            __CRT_PUBLIC(fflush_unlocked)(stream);
         }
     }
     else
     {
-        if (write(stream->fd, &c, 1) != 1) return EOF;
+        if (__CRT_PUBLIC(write)(stream->fd, &c, 1) != 1) return EOF;
     }
 
     return 0;
 }
 
-int fputc(int c, FILE *stream)
+int __CRT_PUBLIC(fputc)(int c, FILE *stream)
 {
     syscall_wait_mutex(stream->mutex, NO_TIMEOUT);
-    int ret = fputc_unlocked(c, stream);
+    int ret = __CRT_PUBLIC(fputc_unlocked)(c, stream);
     syscall_release_mutex(stream->mutex);
     return ret;
 }
 
-char *fgets_unlocked(char *s, int size, FILE *stream)
+char *__CRT_PUBLIC(fgets_unlocked)(char *s, int size, FILE *stream)
 {
     int c;
     char *ptr = s;
 
-    while (size-- > 0 && (c = fgetc_unlocked(stream)) != EOF)
+    while (size-- > 0 && (c = __CRT_PUBLIC(fgetc_unlocked)(stream)) != EOF)
     {
         *ptr++ = (char)c;
         if (c == '\n') break;
@@ -310,36 +311,36 @@ char *fgets_unlocked(char *s, int size, FILE *stream)
     return (s != ptr) ? s : NULL;
 }
 
-char *fgets(char *s, int size, FILE *stream)
+char *__CRT_PUBLIC(fgets)(char *s, int size, FILE *stream)
 {
     syscall_wait_mutex(stream->mutex, NO_TIMEOUT);
-    char *ret = fgets_unlocked(s, size, stream);
+    char *ret = __CRT_PUBLIC(fgets_unlocked)(s, size, stream);
     syscall_release_mutex(stream->mutex);
     return ret;
 }
 
-int fputs_unlocked(const char *s, FILE *stream)
+int __CRT_PUBLIC(fputs_unlocked)(const char *s, FILE *stream)
 {
     const char *ptr = s;
-    while (*ptr) if (fputc_unlocked(*ptr++, stream) == EOF) return EOF;
+    while (*ptr) if (__CRT_PUBLIC(fputc_unlocked)(*ptr++, stream) == EOF) return EOF;
     return 0;
 }
 
-int fputs(const char *s, FILE *stream)
+int __CRT_PUBLIC(fputs)(const char *s, FILE *stream)
 {
     syscall_wait_mutex(stream->mutex, NO_TIMEOUT);
-    int ret = fputs_unlocked(s, stream);
+    int ret = __CRT_PUBLIC(fputs_unlocked)(s, stream);
     syscall_release_mutex(stream->mutex);
     return ret;
 }
 
-int ungetc(int c, FILE *stream)
+int __CRT_PUBLIC(ungetc)(int c, FILE *stream)
 {
     syscall_wait_mutex(stream->mutex, NO_TIMEOUT);
 
     if (stream->flags & FILE_BUFFER_DIR)
     {
-        fflush_unlocked(stream);
+        __CRT_PUBLIC(fflush_unlocked)(stream);
         stream->flags &= ~FILE_BUFFER_DIR;
     }
 
@@ -352,36 +353,36 @@ int ungetc(int c, FILE *stream)
     return c;
 }
 
-char *gets(char *s)
+char *__CRT_PUBLIC(gets)(char *s)
 {
     char *ptr = s;
     int c;
-    while ((c = getchar()) != EOF) *ptr++ = (char)c;
+    while ((c = __CRT_PUBLIC(getchar)()) != EOF) *ptr++ = (char)c;
     return ptr != s ? s : NULL;
 }
 
-int puts(const char *s)
+int __CRT_PUBLIC(puts)(const char *s)
 {
-    if (fputs(s, stdout) == EOF) return EOF;
-    if (fputc('\n', stdout) == EOF) return EOF;
+    if (__CRT_PUBLIC(fputs)(s, __CRT_PUBLIC(stdout)) == EOF) return EOF;
+    if (__CRT_PUBLIC(fputc)('\n', __CRT_PUBLIC(stdout)) == EOF) return EOF;
     return 0;
 }
 
-FILE *fdopen(int fd, const char *mode)
+FILE *__CRT_PUBLIC(fdopen)(int fd, const char *mode)
 {
-    FILE *stream = (FILE*)malloc(sizeof(FILE) + BUFSIZ);
+    FILE *stream = (FILE*)__CRT_PUBLIC(malloc)(sizeof(FILE) + BUFSIZ);
 
     if (stream == NULL)
     {
-        errno = ENOMEM;
+        __CRT_PUBLIC(errno) = ENOMEM;
         return NULL;
     }
 
     sysret_t status = syscall_create_mutex(NULL, TRUE, &stream->mutex);
     if (status != ERR_SUCCESS)
     {
-        free(stream);
-        errno = __crt_translate_error(status);
+        __CRT_PUBLIC(free)(stream);
+        __CRT_PUBLIC(errno) = __CRT_PRIVATE(translate_error)(status);
         return NULL;
     }
 
@@ -410,24 +411,24 @@ FILE *fdopen(int fd, const char *mode)
     stream->fd = fd;
 
     char *buffer = (char*)((uintptr_t)stream + sizeof(FILE));
-    setbuf(stream, buffer);
+    __CRT_PUBLIC(setbuf)(stream, buffer);
     return stream;
 }
 
-FILE *fmemopen(void *buf, size_t size, const char *mode)
+FILE *__CRT_PUBLIC(fmemopen)(void *buf, size_t size, const char *mode)
 {
-    FILE *stream = (FILE*)malloc(sizeof(FILE));
+    FILE *stream = (FILE*)__CRT_PUBLIC(malloc)(sizeof(FILE));
     if (stream == NULL)
     {
-        errno = ENOMEM;
+        __CRT_PUBLIC(errno) = ENOMEM;
         return NULL;
     }
 
     sysret_t status = syscall_create_mutex(NULL, TRUE, &stream->mutex);
     if (status != ERR_SUCCESS)
     {
-        free(stream);
-        errno = __crt_translate_error(status);
+        __CRT_PUBLIC(free)(stream);
+        __CRT_PUBLIC(errno) = __CRT_PRIVATE(translate_error)(status);
         return NULL;
     }
 
@@ -462,7 +463,7 @@ FILE *fmemopen(void *buf, size_t size, const char *mode)
     return stream;
 }
 
-FILE *fopen(const char *pathname, const char *mode)
+FILE *__CRT_PUBLIC(fopen)(const char *pathname, const char *mode)
 {
     int open_flags = 0;
 
@@ -486,23 +487,23 @@ FILE *fopen(const char *pathname, const char *mode)
         }
     }
 
-    int fd = open(pathname, open_flags);
+    int fd = __CRT_PUBLIC(open)(pathname, open_flags);
     if (fd < 0) return NULL;
 
-    FILE *stream = fdopen(fd, mode);
-    if (!stream) close(fd);
+    FILE *stream = __CRT_PUBLIC(fdopen)(fd, mode);
+    if (!stream) __CRT_PUBLIC(close)(fd);
     return NULL;
 }
 
-int fclose(FILE *stream)
+int __CRT_PUBLIC(fclose)(FILE *stream)
 {
-    fflush(stream);
+    __CRT_PUBLIC(fflush)(stream);
     list_remove(&stream->link);
     syscall_wait_mutex(stream->mutex, NO_TIMEOUT);
 
-    if (stream->fd) close(stream->fd);
+    if (stream->fd) __CRT_PUBLIC(close)(stream->fd);
 
     syscall_close_object(stream->mutex);
-    free(stream);
+    __CRT_PUBLIC(free)(stream);
     return 0;
 }
index c5258da530ae697e4644975aac8a2941721ec07a..89ec9886369b5dddab04aecc4efd7ad3c63b7483 100644 (file)
@@ -20,7 +20,7 @@
 #ifndef _IO_PRIV_H_
 #define _IO_PRIV_H_
 
-#include <monolithium.h>
+#include "crt_priv.h"
 
 #define FILE_READ        (1 << 0)
 #define FILE_WRITE       (1 << 1)
@@ -29,7 +29,7 @@
 #define FILE_BUFFER_DIR  (1 << 4)
 #define FILE_BUFFER_FULL (1 << 31)
 
-struct __crt_file
+struct __CRT_PRIVATE(file)
 {
     list_entry_t link;
     handle_t mutex;
index c044c8f7c7d1336a89d4e9a48430b9b0bdcc4c1c..ac860bc8fe1690c63af7c41d4b69423e983e36fc 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * heap.c
  *
- * Copyright (C) 2017 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -19,7 +19,7 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <monolithium.h>
+#include "crt_priv.h"
 
 #define ALLOCATED (1 << 0)
 
@@ -30,9 +30,9 @@ typedef struct
     size_t size;
 } heap_header_t;
 
-__crt_heap_t *__crt_default_heap = NULL;
+__CRT_PRIVATE(heap_t) *__CRT_PRIVATE(default_heap) = NULL;
 
-static void __crt_heap_coalesce(__crt_heap_t *heap)
+static void __CRT_PRIVATE(heap_coalesce)(__CRT_PRIVATE(heap_t) *heap)
 {
     heap_header_t *ptr = (heap_header_t*)heap->base;
     heap_header_t *previous = NULL;
@@ -59,7 +59,7 @@ static void __crt_heap_coalesce(__crt_heap_t *heap)
     }
 }
 
-void *__crt_heap_realloc(__crt_heap_t *heap, void *ptr, size_t alignment, size_t size)
+void *__CRT_PRIVATE(heap_realloc)(__CRT_PRIVATE(heap_t) *heap, void *ptr, size_t alignment, size_t size)
 {
     if (!alignment || (alignment & (alignment - 1))) return NULL;
 
@@ -84,7 +84,7 @@ void *__crt_heap_realloc(__crt_heap_t *heap, void *ptr, size_t alignment, size_t
             if (header->flags & ALLOCATED)
             {
                 header->flags &= ~ALLOCATED;
-                __crt_heap_coalesce(heap);
+                __CRT_PRIVATE(heap_coalesce)(heap);
             }
             else
             {
@@ -121,7 +121,7 @@ void *__crt_heap_realloc(__crt_heap_t *heap, void *ptr, size_t alignment, size_t
                  }
 
                  header->size += next->size + sizeof(heap_header_t);
-                 if (heap->flags & __CRT_HEAP_FLAG_ZEROFILL) memset(next, 0, size - header->size - size);
+                 if (heap->flags & __CRT_HEAP_FLAG_ZEROFILL) __CRT_PUBLIC(memset)(next, 0, size - header->size - size);
              }
              else
              {
@@ -136,7 +136,7 @@ void *__crt_heap_realloc(__crt_heap_t *heap, void *ptr, size_t alignment, size_t
             new_block->flags = 0;
             new_block->size = header->size - size - sizeof(heap_header_t);
             header->size = size;
-            __crt_heap_coalesce(heap);
+            __CRT_PRIVATE(heap_coalesce)(heap);
         }
 
         if (!source_block)
@@ -292,7 +292,7 @@ void *__crt_heap_realloc(__crt_heap_t *heap, void *ptr, size_t alignment, size_t
         previous->size += padding;
 
         heap_header_t *new_block = (heap_header_t*)(aligned_start - sizeof(heap_header_t));
-        memmove(new_block, hole, sizeof(heap_header_t));
+        __CRT_PUBLIC(memmove)(new_block, hole, sizeof(heap_header_t));
         if (heap->next_offset == (uintptr_t)hole - (uintptr_t)heap->base) heap->next_offset += padding;
 
         hole = new_block;
@@ -312,77 +312,77 @@ void *__crt_heap_realloc(__crt_heap_t *heap, void *ptr, size_t alignment, size_t
     }
 
     void *destination = (void*)((uintptr_t)hole + sizeof(heap_header_t));
-    if (heap->flags & __CRT_HEAP_FLAG_ZEROFILL) memset(destination, 0, size);
+    if (heap->flags & __CRT_HEAP_FLAG_ZEROFILL) __CRT_PUBLIC(memset)(destination, 0, size);
 
     if (source_block)
     {
         void *source = (void*)((uintptr_t)source_block + sizeof(heap_header_t));
-        memcpy(destination, source, source_block->size);
+        __CRT_PUBLIC(memcpy)(destination, source, source_block->size);
         source_block->flags &= ~ALLOCATED;
         coalesce = 1;
     }
 
-    if (coalesce) __crt_heap_coalesce(heap);
+    if (coalesce) __CRT_PRIVATE(heap_coalesce)(heap);
     heap->unlock_mutex_proc(heap->mutex);
     return destination;
 }
 
 void *aligned_alloc(size_t alignment, size_t size)
 {
-    return __crt_heap_realloc(__crt_default_heap, NULL, alignment, size);
+    return __CRT_PRIVATE(heap_realloc)(__CRT_PRIVATE(default_heap), NULL, alignment, size);
 }
 
 void *realloc(void *ptr, size_t size)
 {
-    return __crt_heap_realloc(__crt_default_heap, ptr, sizeof(long), size);
+    return __CRT_PRIVATE(heap_realloc)(__CRT_PRIVATE(default_heap), ptr, sizeof(long), size);
 }
 
 void *malloc(size_t size)
 {
-    return __crt_heap_realloc(__crt_default_heap, NULL, sizeof(long), size);
+    return __CRT_PRIVATE(heap_realloc)(__CRT_PRIVATE(default_heap), NULL, sizeof(long), size);
 }
 
 void free(void *ptr)
 {
-    __crt_heap_realloc(__crt_default_heap, ptr, sizeof(long), 0);
+    __CRT_PRIVATE(heap_realloc)(__CRT_PRIVATE(default_heap), ptr, sizeof(long), 0);
 }
 
 void *calloc(size_t nmemb, size_t size)
 {
-    void *ptr = malloc(nmemb * size);
+    void *ptr = __CRT_PUBLIC(malloc)(nmemb * size);
     if (!ptr) return NULL;
 
-    memset(ptr, 0, nmemb * size);
+    __CRT_PUBLIC(memset)(ptr, 0, nmemb * size);
     return ptr;
 }
 
-static void __crt_heap_lock(void *mutex)
+static void __CRT_PRIVATE(heap_lock)(void *mutex)
 {
     syscall_wait_mutex((handle_t)mutex, NO_TIMEOUT);
 }
 
-static void __crt_heap_unlock(void *mutex)
+static void __CRT_PRIVATE(heap_unlock)(void *mutex)
 {
     syscall_release_mutex((handle_t)mutex);
 }
 
-static void __crt_heap_problem(int problem)
+static void __CRT_PRIVATE(heap_problem)(int problem)
 {
     // TODO
 }
 
-int __crt_initialize_heap(void)
+int __CRT_PRIVATE(initialize_heap)(void)
 {
-    static __crt_heap_t heap;
+    static __CRT_PRIVATE(heap_t) heap;
 
     heap.magic             = 0x70616548;
     heap.base              = NULL;
     heap.size              = 0x10000000;
     heap.flags             = 0;
     heap.next_offset       = 0;
-    heap.lock_mutex_proc   = __crt_heap_lock;
-    heap.unlock_mutex_proc = __crt_heap_unlock;
-    heap.problem           = __crt_heap_problem;
+    heap.lock_mutex_proc   = __CRT_PRIVATE(heap_lock);
+    heap.unlock_mutex_proc = __CRT_PRIVATE(heap_unlock);
+    heap.problem           = __CRT_PRIVATE(heap_problem);
 
     sysret_t status = syscall_create_mutex(NULL, TRUE, (handle_t*)&heap.mutex);
     if (status != ERR_SUCCESS) return -1;
@@ -390,6 +390,6 @@ int __crt_initialize_heap(void)
     status = syscall_alloc_memory(INVALID_HANDLE, &heap.base, heap.size, MEMORY_BLOCK_ACCESSIBLE | MEMORY_BLOCK_WRITABLE);
     if (status != ERR_SUCCESS) return -1;
 
-    __crt_default_heap = &heap;
+    __CRT_PRIVATE(default_heap) = &heap;
     return 0;
 }
index 2b425e1f9af757860264f401ec641c5c743bf8ac..a90b11ba70d8f8dce027bf521d74c60ddde34127 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * numconv.c
  *
- * Copyright (C) 2017 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
+#include "crt_priv.h"
 
 #define DEFINE_XTOA(t, p, s)                                            \
-    char *p##toa(t value, char *str, int base)                          \
+    char *__CRT_PUBLIC(p##toa)(t value, char *str, int base)            \
     {                                                                   \
         char *ptr = str;                                                \
         if (base < 2 || base > 36) return NULL;                         \
@@ -53,7 +54,7 @@
         return str;                                                     \
     }                                                                   \
                                                                         \
-    char *u##p##toa(unsigned t value, char *str, int base)              \
+    char *__CRT_PUBLIC(u##p##toa)(unsigned t value, char *str, int base) \
     {                                                                   \
         char *ptr = str;                                                \
         if (base < 2 || base > 36) return NULL;                         \
     }
 
 #define DEFINE_ATOX(t, n, p, s)                                         \
-    t ato##p(const char *str)                                           \
+    t __CRT_PUBLIC(ato##p)(const char *str)                             \
     {                                                                   \
-        return strto##p(str, NULL, 10);                                 \
+        return __CRT_PUBLIC(strto##p)(str, NULL, 10);                   \
     }                                                                   \
                                                                         \
-    t strto##p(const char *str, char **endptr, int base)                \
+    t __CRT_PUBLIC(strto##p)(const char *str, char **endptr, int base)  \
     {                                                                   \
         const char *ptr;                                                \
         t result = 0##s;                                                \
                                                                         \
         for (ptr = str; *ptr; ptr++)                                    \
         {                                                               \
-            char *digit_ptr = strchr(all_digits, toupper(*ptr));        \
+            char *digit_ptr = __CRT_PUBLIC(strchr)(all_digits, __CRT_PUBLIC(toupper)(*ptr)); \
             if (digit_ptr == NULL) break;                               \
                                                                         \
             t digit = (t)(digit_ptr - all_digits);                      \
                                                                         \
         if (overflow)                                                   \
         {                                                               \
-            errno = ERANGE;                                             \
+            __CRT_PUBLIC(errno) = ERANGE;                               \
             return negative ? n##_MIN : n##_MAX;                        \
         }                                                               \
                                                                         \
         return result;                                                  \
     }                                                                   \
                                                                         \
-    unsigned t strtou##p(const char *str, char **endptr, int base)      \
+    unsigned t __CRT_PUBLIC(strtou##p)(const char *str, char **endptr, int base) \
     {                                                                   \
         const char *ptr;                                                \
         unsigned t result = 0UL;                                        \
                                                                         \
         for (ptr = str; *ptr; ptr++)                                    \
         {                                                               \
-            char *digit_ptr = strchr(all_digits, toupper(*ptr));        \
+            char *digit_ptr = __CRT_PUBLIC(strchr)(all_digits, __CRT_PUBLIC(toupper)(*ptr)); \
             if (digit_ptr == NULL) break;                               \
                                                                         \
             unsigned t digit = (unsigned t)(digit_ptr - all_digits);    \
                                                                         \
         if (overflow)                                                   \
         {                                                               \
-            errno = ERANGE;                                             \
+            __CRT_PUBLIC(errno) = ERANGE;                               \
             return U##n##_MAX;                                          \
         }                                                               \
                                                                         \
@@ -165,7 +166,7 @@ DEFINE_XTOA(long long, ll, LL);
 DEFINE_ATOX(long, LONG, l, L);
 DEFINE_ATOX(long long, LLONG, ll, LL);
 
-int atoi(const char *str)
+int __CRT_PUBLIC(atoi)(const char *str)
 {
-    return (int)strtol(str, NULL, 10);
+    return (int)__CRT_PUBLIC(strtol)(str, NULL, 10);
 }
index 57a83d8ddf069e3544f8753774ed833d4f43be96..036b66ae9eb99b68f16b1af825a52474b030bbd9 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * printf.c
  *
- * Copyright (C) 2018 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -20,7 +20,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
-#include <monolithium.h>
+#include "crt_priv.h"
 #include "io_priv.h"
 
 #define __CRT_PRINTF_FLAG_ALIGN_LEFT         (1 << 0)
@@ -38,13 +38,13 @@ typedef struct
     FILE *stream;
     char *string;
     size_t size;
-} __crt_stream_or_string_t;
+} stream_or_string_t;
 
-static int __crt_strputc(__crt_stream_or_string_t *str, char c)
+static int __CRT_PRIVATE(strputc)(stream_or_string_t *str, char c)
 {
     if (str->stream)
     {
-        return fputc_unlocked(c, str->stream) != EOF;
+        return __CRT_PUBLIC(fputc_unlocked)(c, str->stream) != EOF;
     }
     else
     {
@@ -58,19 +58,19 @@ static int __crt_strputc(__crt_stream_or_string_t *str, char c)
     }
 }
 
-static int __crt_strputs(__crt_stream_or_string_t *str, const char *s)
+static int __CRT_PRIVATE(strputs)(stream_or_string_t *str, const char *s)
 {
     if (str->stream)
     {
-        return fputs_unlocked(s, str->stream) != EOF ? strlen(s) : 0;
+        return __CRT_PUBLIC(fputs_unlocked)(s, str->stream) != EOF ? __CRT_PUBLIC(strlen)(s) : 0;
     }
     else
     {
-        int length = strlen(s);
+        int length = __CRT_PUBLIC(strlen)(s);
 
         if (str->size > 1)
         {
-            strncpy(str->string, s, str->size - 1);
+            __CRT_PUBLIC(strncpy)(str->string, s, str->size - 1);
 
             if (length < str->size)
             {
@@ -88,7 +88,7 @@ static int __crt_strputs(__crt_stream_or_string_t *str, const char *s)
     }
 }
 
-static inline int __crt_vstrprintf(__crt_stream_or_string_t *str, const char *format, va_list ap)
+static inline int __CRT_PRIVATE(vstrprintf)(stream_or_string_t *str, const char *format, va_list ap)
 {
     int ret = 0;
     if (str->stream) syscall_wait_mutex(str->stream->mutex, NO_TIMEOUT);
@@ -116,14 +116,14 @@ static inline int __crt_vstrprintf(__crt_stream_or_string_t *str, const char *fo
             }
 
             if (*ptr == '*') flags |= __CRT_PRINTF_FLAG_EXTERNAL_WIDTH;
-            else if (isdigit(*ptr)) width = strtoul(ptr, (char**)&ptr, 10);
+            else if (__CRT_PUBLIC(isdigit)(*ptr)) width = __CRT_PUBLIC(strtoul)(ptr, (char**)&ptr, 10);
             else flags |= __CRT_PRINTF_FLAG_DEFAULT_WIDTH;
 
             if (*ptr == '.')
             {
                 ptr++;
                 if (*ptr == '*') flags |= __CRT_PRINTF_FLAG_EXTERNAL_PRECISION;
-                else if (isdigit(*ptr)) precision = strtoul(ptr, (char**)&ptr, 10);
+                else if (__CRT_PUBLIC(isdigit)(*ptr)) precision =__CRT_PUBLIC(strtoul)(ptr, (char**)&ptr, 10);
                 else flags |= __CRT_PRINTF_FLAG_DEFAULT_PRECISION;
             }
             else
@@ -178,11 +178,11 @@ static inline int __crt_vstrprintf(__crt_stream_or_string_t *str, const char *fo
 
                 switch (variable_size)
                 {
-                case -2: itoa((char)va_arg(ap, int), buffer, 10); break;
-                case -1: itoa((short)va_arg(ap, int), buffer, 10); break;
-                case  0: itoa(va_arg(ap, int), buffer, 10); break;
-                case  1: ltoa(va_arg(ap, long), buffer, 10); break;
-                case  2: lltoa(va_arg(ap, long long), buffer, 10); break;
+                case -2: __CRT_PUBLIC(itoa)((char)va_arg(ap, int), buffer, 10); break;
+                case -1: __CRT_PUBLIC(itoa)((short)va_arg(ap, int), buffer, 10); break;
+                case  0: __CRT_PUBLIC(itoa)(va_arg(ap, int), buffer, 10); break;
+                case  1: __CRT_PUBLIC(ltoa)(va_arg(ap, long), buffer, 10); break;
+                case  2: __CRT_PUBLIC(lltoa)(va_arg(ap, long long), buffer, 10); break;
                 }
                 break;
 
@@ -200,24 +200,24 @@ static inline int __crt_vstrprintf(__crt_stream_or_string_t *str, const char *fo
 
                 switch (variable_size)
                 {
-                case -2: uitoa((unsigned char)va_arg(ap, unsigned int), buffer, radix); break;
-                case -1: uitoa((unsigned short)va_arg(ap, unsigned int), buffer, radix); break;
-                case  0: uitoa(va_arg(ap, unsigned int), buffer, radix); break;
-                case  1: ultoa(va_arg(ap, unsigned long), buffer, radix); break;
-                case  2: ulltoa(va_arg(ap, unsigned long long), buffer, radix); break;
+                case -2: __CRT_PUBLIC(uitoa)((unsigned char)va_arg(ap, unsigned int), buffer, radix); break;
+                case -1: __CRT_PUBLIC(uitoa)((unsigned short)va_arg(ap, unsigned int), buffer, radix); break;
+                case  0: __CRT_PUBLIC(uitoa)(va_arg(ap, unsigned int), buffer, radix); break;
+                case  1: __CRT_PUBLIC(ultoa)(va_arg(ap, unsigned long), buffer, radix); break;
+                case  2: __CRT_PUBLIC(ulltoa)(va_arg(ap, unsigned long long), buffer, radix); break;
                 }
                 break;
 
             case '%':
                 data = buffer;
-                strcpy(buffer, "%");
+                __CRT_PUBLIC(strcpy)(buffer, "%");
                 break;
             }
 
             if (flags & __CRT_PRINTF_FLAG_EXTERNAL_WIDTH) width = va_arg(ap, unsigned int);
             if (flags & __CRT_PRINTF_FLAG_EXTERNAL_PRECISION) precision = va_arg(ap, unsigned int);
 
-            int length = strlen(data);
+            int length = __CRT_PUBLIC(strlen)(data);
             char padding = (flags &__CRT_PRINTF_FLAG_ZERO_PAD) ? '0' : ' ';
 
             switch (*ptr)
@@ -227,7 +227,7 @@ static inline int __crt_vstrprintf(__crt_stream_or_string_t *str, const char *fo
                 {
                     while (length < width)
                     {
-                        ret += __crt_strputc(str, padding);
+                        ret += __CRT_PRIVATE(strputc)(str, padding);
                         length++;
                     }
                 }
@@ -236,13 +236,13 @@ static inline int __crt_vstrprintf(__crt_stream_or_string_t *str, const char *fo
                 {
                     while (*data && precision > 0)
                     {
-                        ret += __crt_strputc(str, *data++);
+                        ret += __CRT_PRIVATE(strputc)(str, *data++);
                         precision--;
                     }
                 }
                 else
                 {
-                    ret += __crt_strputs(str, data ? data : "(null)");
+                    ret += __CRT_PRIVATE(strputs)(str, data ? data : "(null)");
                 }
                 break;
 
@@ -256,12 +256,12 @@ static inline int __crt_vstrprintf(__crt_stream_or_string_t *str, const char *fo
                 {
                     if (*data == '-')
                     {
-                        ret += __crt_strputc(str, '-');
+                        ret += __CRT_PRIVATE(strputc)(str, '-');
                         data++;
                     }
                     else
                     {
-                        ret += __crt_strputc(str, (flags & __CRT_PRINTF_FLAG_PLUS) ? '+' : ' ');
+                        ret += __CRT_PRIVATE(strputc)(str, (flags & __CRT_PRINTF_FLAG_PLUS) ? '+' : ' ');
                         length++;
                     }
                 }
@@ -270,13 +270,13 @@ static inline int __crt_vstrprintf(__crt_stream_or_string_t *str, const char *fo
                 {
                     while (length < width - precision)
                     {
-                        ret += __crt_strputc(str, padding);
+                        ret += __CRT_PRIVATE(strputc)(str, padding);
                         length++;
                     }
 
                     while (length < width)
                     {
-                        ret += __crt_strputc(str, '0');
+                        ret += __CRT_PRIVATE(strputc)(str, '0');
                         length++;
                     }
                 }
@@ -284,24 +284,24 @@ static inline int __crt_vstrprintf(__crt_stream_or_string_t *str, const char *fo
                 {
                     while (length < precision)
                     {
-                        ret += __crt_strputc(str, '0');
+                        ret += __CRT_PRIVATE(strputc)(str, '0');
                         length++;
                     }
                 }
 
-                ret += __crt_strputs(str, data);
+                ret += __CRT_PRIVATE(strputs)(str, data);
                 break;
             }
 
             while (length < width)
             {
-                ret += __crt_strputc(str, padding);
+                ret += __CRT_PRIVATE(strputc)(str, padding);
                 length++;
             }
         }
         else
         {
-            ret += __crt_strputc(str, *ptr);
+            ret += __CRT_PRIVATE(strputc)(str, *ptr);
         }
     }
 
@@ -310,60 +310,60 @@ static inline int __crt_vstrprintf(__crt_stream_or_string_t *str, const char *fo
     return ret;
 }
 
-int vsnprintf(char *string, size_t size, const char *format, va_list ap)
+int __CRT_PUBLIC(vsnprintf)(char *string, size_t size, const char *format, va_list ap)
 {
-    __crt_stream_or_string_t str = { .stream = NULL, .string = string, .size = size };
-    return __crt_vstrprintf(&str, format, ap);
+    stream_or_string_t str = { .stream = NULL, .string = string, .size = size };
+    return __CRT_PRIVATE(vstrprintf)(&str, format, ap);
 }
 
-int vsprintf(char *str, const char *format, va_list ap)
+int __CRT_PUBLIC(vsprintf)(char *str, const char *format, va_list ap)
 {
-    return vsnprintf(str, -1, format, ap);
+    return __CRT_PUBLIC(vsnprintf)(str, -1, format, ap);
 }
 
-int vprintf(const char *format, va_list ap)
+int __CRT_PUBLIC(vprintf)(const char *format, va_list ap)
 {
-    return vfprintf(stdout, format, ap);
+    return __CRT_PUBLIC(vfprintf)(__CRT_PUBLIC(stdout), format, ap);
 }
 
-int vfprintf(FILE *stream, const char *format, va_list ap)
+int __CRT_PUBLIC(vfprintf)(FILE *stream, const char *format, va_list ap)
 {
-    __crt_stream_or_string_t str = { .stream = stream, .string = NULL, .size = 0 };
-    return __crt_vstrprintf(&str, format, ap);
+    stream_or_string_t str = { .stream = stream, .string = NULL, .size = 0 };
+    return __CRT_PRIVATE(vstrprintf)(&str, format, ap);
 }
 
-int fprintf(FILE *stream, const char *format, ...)
+int __CRT_PUBLIC(fprintf)(FILE *stream, const char *format, ...)
 {
     va_list ap;
     va_start(ap, format);
-    int ret = vfprintf(stream, format, ap);
+    int ret = __CRT_PUBLIC(vfprintf)(stream, format, ap);
     va_end(ap);
     return ret;
 }
 
-int snprintf(char *str, size_t size, const char *format, ...)
+int __CRT_PUBLIC(snprintf)(char *str, size_t size, const char *format, ...)
 {
     va_list ap;
     va_start(ap, format);
-    int ret = vsnprintf(str, size, format, ap);
+    int ret = __CRT_PUBLIC(vsnprintf)(str, size, format, ap);
     va_end(ap);
     return ret;
 }
 
-int sprintf(char *str, const char *format, ...)
+int __CRT_PUBLIC(sprintf)(char *str, const char *format, ...)
 {
     va_list ap;
     va_start(ap, format);
-    int ret = vsprintf(str, format, ap);
+    int ret = __CRT_PUBLIC(vsprintf)(str, format, ap);
     va_end(ap);
     return ret;
 }
 
-int printf(const char *format, ...)
+int __CRT_PUBLIC(printf)(const char *format, ...)
 {
     va_list ap;
     va_start(ap, format);
-    int ret = vprintf(format, ap);
+    int ret = __CRT_PUBLIC(vprintf)(format, ap);
     va_end(ap);
     return ret;
 }
index 646af24633f8b990a11ac9d1b8150fc91afd0009..aca9f8ee6544926a95cfe1d1be6d02750bbe1315 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * setjmp.c
  *
- * Copyright (C) 2017 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "crt_priv.h"
 #include <setjmp.h>
-#include <monolithium.h>
 
-int setjmp(jmp_buf env)
+int __CRT_PUBLIC(setjmp)(__CRT_PUBLIC(jmp_buf) env)
 {
     syscall_query_thread(INVALID_HANDLE, THREAD_CPU_STATE_INFO, &env->state, sizeof(env->state));
     return env->val;
 }
 
-int longjmp(jmp_buf env, int val)
+int __CRT_PUBLIC(longjmp)(__CRT_PUBLIC(jmp_buf) env, int val)
 {
     env->val = val ? val : 1;
     syscall_set_thread(INVALID_HANDLE, THREAD_CPU_STATE_INFO, &env->state, sizeof(env->state));
index 176ae659e54019d480a6be6fb7745cdfd5c9e891..207002ae1d11aeb02cea1fe8ec71c22937586c68 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * string.c
  *
- * Copyright (C) 2017 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <mlcrt.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 
-char *strcpy(char *destination, const char *source)
+char *__CRT_PUBLIC(strcpy)(char *destination, const char *source)
 {
     while (*source != 0) *(destination++) = *(source++);
     *destination = 0;
     return destination;
 }
 
-char *strncpy(char *destination, const char *source, uint32_t num)
+char *__CRT_PUBLIC(strncpy)(char *destination, const char *source, uint32_t num)
 {
     char *ptr = destination;
     while ((num--) && (*source)) *(ptr++) = *(source++);
@@ -36,7 +37,7 @@ char *strncpy(char *destination, const char *source, uint32_t num)
     return destination;
 }
 
-int strcmp(const char *str1, const char *str2)
+int __CRT_PUBLIC(strcmp)(const char *str1, const char *str2)
 {
     while (*str1 || *str2)
     {
@@ -50,11 +51,11 @@ int strcmp(const char *str1, const char *str2)
     else return 0;
 }
 
-int stricmp(const char *str1, const char *str2)
+int __CRT_PUBLIC(stricmp)(const char *str1, const char *str2)
 {
     while (*str1 || *str2)
     {
-        if (tolower(*str1) != tolower(*str2)) break;
+        if (__CRT_PUBLIC(tolower)(*str1) != __CRT_PUBLIC(tolower)(*str2)) break;
         str1++;
         str2++;
     }
@@ -63,7 +64,7 @@ int stricmp(const char *str1, const char *str2)
     else return 0;
 }
 
-int strncmp(const char *str1, const char *str2, size_t n)
+int __CRT_PUBLIC(strncmp)(const char *str1, const char *str2, size_t n)
 {
     int i;
 
@@ -77,7 +78,7 @@ int strncmp(const char *str1, const char *str2, size_t n)
     return 0;
 }
 
-char *strstr(const char *haystack, const char *needle)
+char *__CRT_PUBLIC(strstr)(const char *haystack, const char *needle)
 {
     while (*haystack)
     {
@@ -101,14 +102,14 @@ char *strstr(const char *haystack, const char *needle)
     return NULL;
 }
 
-char *strchr(const char *str, char c)
+char *__CRT_PUBLIC(strchr)(const char *str, char c)
 {
     while ((*str != 0) && (*str != c)) str++;
     if (*str == c) return (char*)str;
     else return NULL;
 }
 
-char *strrchr(const char *str, char c)
+char *__CRT_PUBLIC(strrchr)(const char *str, char c)
 {
     char *ret = NULL;
 
@@ -121,35 +122,35 @@ char *strrchr(const char *str, char c)
     return ret;
 }
 
-char *strcat(char *destination, const char *source)
+char *__CRT_PUBLIC(strcat)(char *destination, const char *source)
 {
-    strcpy(strchr(destination, '\0'), source);
+    __CRT_PUBLIC(strcpy)(__CRT_PUBLIC(strchr)(destination, '\0'), source);
     return destination;
 }
 
-char *strncat(char *destination, const char *source, size_t n)
+char *__CRT_PUBLIC(strncat)(char *destination, const char *source, size_t n)
 {
-    char *ptr = strchr(destination, 0);
+    char *ptr = __CRT_PUBLIC(strchr)(destination, 0);
     while ((n--) && (*source)) *(ptr++) = *(source++);
     *ptr = 0;
     return destination;
 }
 
-char *strdup(const char *source)
+char *__CRT_PUBLIC(strdup)(const char *source)
 {
-    char *destination = (char*)malloc(strlen(source) + 1);
-    if (destination) strcpy(destination, source);
+    char *destination = (char*)__CRT_PUBLIC(malloc)(__CRT_PUBLIC(strlen)(source) + 1);
+    if (destination) __CRT_PUBLIC(strcpy)(destination, source);
     return destination;
 }
 
-char *strtok_r(char *str, const char *delimiters, char **endptr)
+char *__CRT_PUBLIC(strtok_r)(char *str, const char *delimiters, char **endptr)
 {
     if (str == NULL) str = *endptr;
     char *start = str;
 
     while (*str != 0)
     {
-        if (strchr(delimiters, *str) != NULL)
+        if (__CRT_PUBLIC(strchr)(delimiters, *str) != NULL)
         {
             *str = 0;
             *endptr = str + 1;
@@ -166,7 +167,7 @@ char *strtok_r(char *str, const char *delimiters, char **endptr)
 char *strtok(char *str, const char *delimiters)
 {
     static char *endptr;
-    return strtok_r(str, delimiters, &endptr);
+    return __CRT_PUBLIC(strtok_r)(str, delimiters, &endptr);
 }
 
 size_t strlen(const char *str)
@@ -178,7 +179,7 @@ size_t strlen(const char *str)
 
 void strrev(char *str)
 {
-    size_t i, j = strlen(str) - 1;
+    size_t i, j = __CRT_PUBLIC(strlen)(str) - 1;
 
     while (i < j)
     {
@@ -191,7 +192,7 @@ void strrev(char *str)
     }
 }
 
-void memset(void *ptr, int value, size_t n)
+void __CRT_PUBLIC(memset)(void *ptr, int value, size_t n)
 {
     uint8_t *ptr_byte = (uint8_t*)ptr;
     value &= 0xFF;
@@ -217,7 +218,7 @@ void memset(void *ptr, int value, size_t n)
     }
 }
 
-void memcpy(void *destination, const void *source, size_t n)
+void __CRT_PUBLIC(memcpy)(void *destination, const void *source, size_t n)
 {
     uint8_t *src_byte = (uint8_t*)source;
     uint8_t *dest_byte = (uint8_t*)destination;
@@ -243,7 +244,7 @@ void memcpy(void *destination, const void *source, size_t n)
     }
 }
 
-void memmove(void *destination, const void *source, size_t n)
+void __CRT_PUBLIC(memmove)(void *destination, const void *source, size_t n)
 {
     if (!n) return;
 
@@ -297,7 +298,7 @@ void memmove(void *destination, const void *source, size_t n)
     }
 }
 
-int memcmp(const void *mem1, const void *mem2, size_t n)
+int __CRT_PUBLIC(memcmp)(const void *mem1, const void *mem2, size_t n)
 {
     uint32_t flags;
 
index ed0029a2fcc639b0523ffa20b38af20e37ebe6aa..680dfe68ae7d55ffb4b2b0748f9915ac914c61ff 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * wc.c
  *
- * Copyright (C) 2017 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
+ * Copyright (C) 2019 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <mlcrt.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <monolithium.h>
 
-handle_t __crt_get_raw_handle(int fd);
+handle_t __CRT_PRIVATE(get_raw_handle)(int fd);
 
 static char *wd_path = NULL;
 
-char *getcwd(char *buf, size_t size)
+char *__CRT_PUBLIC(getcwd)(char *buf, size_t size)
 {
-    return strncpy(buf, wd_path, size);
+    return __CRT_PUBLIC(strncpy)(buf, wd_path, size);
 }
 
-char *getwd(char *buf)
+char *__CRT_PUBLIC(getwd)(char *buf)
 {
-    return strcpy(buf, wd_path);
+    return __CRT_PUBLIC(strcpy)(buf, wd_path);
 }
 
-char *get_current_dir_name(void)
+char *__CRT_PUBLIC(get_current_dir_name)(void)
 {
-    return strdup(wd_path);
+    return __CRT_PUBLIC(strdup)(wd_path);
 }
 
-int fchdir(int fd)
+int __CRT_PUBLIC(fchdir)(int fd)
 {
     char path[MAX_PATH];
-    handle_t handle = __crt_get_raw_handle(fd);
+    handle_t handle = __CRT_PRIVATE(get_raw_handle)(fd);
 
     sysret_t ret = syscall_query_file(handle, FILE_INFO_NAME, path, sizeof(path));
 
@@ -53,10 +54,10 @@ int fchdir(int fd)
         switch (ret)
         {
         case ERR_FORBIDDEN:
-            errno = EACCES;
+            __CRT_PUBLIC(errno) = EACCES;
 
         default:
-            errno = __crt_translate_error(ret);
+            __CRT_PUBLIC(errno) = __CRT_PRIVATE(translate_error)(ret);
         }
 
         return -1;
@@ -64,20 +65,20 @@ int fchdir(int fd)
 
     if (wd_path)
     {
-        free(wd_path);
+        __CRT_PUBLIC(free)(wd_path);
         wd_path = NULL;
     }
 
-    wd_path = strdup(path);
+    wd_path = __CRT_PUBLIC(strdup)(path);
     return 0;
 }
 
-int chdir(const char *path)
+int __CRT_PUBLIC(chdir)(const char *path)
 {
-    int fd = open(path, O_RDONLY, 0);
+    int fd = __CRT_PUBLIC(open)(path, O_RDONLY, 0);
     if (fd < 0) return -1;
 
-    int ret = fchdir(fd);
-    close(fd);
+    int ret = __CRT_PUBLIC(fchdir)(fd);
+    __CRT_PUBLIC(close)(fd);
     return ret;
 }