source: libcaca/trunk/kernel/klibc.c @ 4154

Last change on this file since 4154 was 4154, checked in by Jean-Yves Lamoureux, 10 years ago
  • Total kernel rewrite
File size: 10.8 KB
Line 
1#include "config.h"
2#include "caca_types.h"
3
4#include "klibc.h"
5#include "drivers/timer.h"
6#include "kernel.h"
7
8
9void htoa(unsigned int value, char s[]);
10
11#define IS_DIGIT(x) (x>='0' && x<='9')
12#define IS_ALPHA(x) (x>='A' && x<='z')
13#define IS_UPPER(x) (x>='A' && x<='Z')
14#define IS_LOWER(x) (x>='a' && x<='z')
15#define UPPER(x) (IS_LOWER(x)?(x+('A'-'a')):x)
16#define LOWER(x) (IS_UPPER(x)?(x-('a'-'A')):x)
17
18/* Our default seed for random number generator */
19static int seed = 0x68743284;
20
21/* Our memory mapping */
22static uint32_t *freemem = (uint32_t*) 0x00200000;
23int kX = 0;
24int kY = 0;
25
26void scroll(void)
27{
28        unsigned char* video, *tmp;
29       
30        for(video=(unsigned char*)0xB8000 ; video<(unsigned char*)0xB8FA0 ; video++){
31        tmp = (unsigned char*) (video+1*160);
32       
33        if(tmp<(unsigned char*)0xB8FA0)
34            *video = *tmp;
35        else
36            *video = 0;
37        }
38   
39        kY-=1;
40        if(kY<0)
41                kY=0;}
42
43void putcar(unsigned char c)
44{
45        unsigned char* video;
46   
47        if(c==10){     
48                kX=0;
49                kY++;
50        }
51        else{
52                video = (unsigned char*) (0xB8000+2*kX+160*kY);
53                *video = c;
54                *(video+1) = 0x07;
55       
56                kX++;
57                if(kX>79){
58                        kX = 0;
59                        kY++;
60                }
61        if(kY >= 24) {
62            scroll();
63        }
64    }
65}
66
67void print(char *str)
68{
69    char const *ptr = str;
70    while(*ptr) {
71        putcar(*ptr++);
72    }
73}
74
75void clearscreen(void)
76{
77    int x, y;
78    kX = 0;
79    kY = 0;
80        for(y = 0; y < 25; y++)
81        for(x = 0; x < 80; x++) {
82                putcar(' ');   
83        }
84    kX = 0;
85    kY = 0;       
86}
87
88/* stdlib.h functions */
89void *malloc(size_t size)
90{
91    uint32_t *p = freemem;
92    if(!size)
93        return NULL;
94    size = (size + 0x7) / 4;
95    *p = size;
96    freemem += size + 1;
97    return p + 1;
98}
99
100void free(void *ptr)
101{
102    return;
103}
104
105void *realloc(void *ptr, size_t size)
106{
107    uint32_t oldsize;
108    void *p;
109   
110    if(!size)
111        return NULL;
112   
113    if(!ptr)
114        oldsize = 0;
115    else
116    {
117        oldsize = ((uint32_t *)ptr)[-1];
118        if(oldsize >= size)
119            return ptr;
120    }
121   
122    p = malloc(size);
123    memcpy(p, ptr, oldsize);
124    return p;
125}
126
127char *getenv(const char *name)
128{
129    return NULL;
130}
131
132int getpid(void)
133{
134    return 0x1337;
135}
136
137void srand(unsigned int s)
138{
139    seed = rand();
140}
141
142int time(void *dummy)
143{
144    return rand();
145}
146
147int rand(void)
148{
149    seed = (seed * 0x7f32ba17) ^ 0xf893a735;
150    return seed % RAND_MAX;
151}
152
153int abs(int j)
154{
155    if(j < 0)
156        return -j;
157    return j;
158}
159
160void exit(int status)
161{
162    /* FIXME: reboot? */
163    while(1);
164}
165
166int atexit(void (*function)(void))
167{
168    /* FIXME: register function */
169    return 0;
170}
171
172/* string.h functions */
173void *memset(void *s, int c, size_t n)
174{
175    uint8_t *ptr = s;
176   
177    while(n--)
178        *ptr++ = c;
179   
180    return s;
181}
182
183void *memcpy(void *dest, const void *src, size_t n)
184{
185    uint8_t *destptr = dest;
186    uint8_t const *srcptr = src;
187   
188    while(n--)
189        *destptr++ = *srcptr++;
190   
191    return dest;
192}
193
194void *memmove(void *dest, const void *src, size_t n)
195{
196    memcpy(freemem, src, n);
197    memcpy(dest, freemem, n);
198    return dest;
199}
200
201size_t strlen(const char *s)
202{
203    int len = 0;
204   
205    while(*s++)
206        len++;
207   
208    return len;
209}
210
211int strcmp(const char *s1, const char *s2)
212{
213    while(*s1 && *s1 == *s2)
214    {
215        s1++;
216        s2++;
217    }
218   
219    return (int)*s1 - (int)*s2;
220}
221
222int strcasecmp(const char *s1, const char *s2)
223{
224    while(*s1 && *s2 && UPPER(*s1) == UPPER(*s2))
225    {
226        s1++;
227        s2++;
228    }
229   
230    return (int)UPPER(*s1) - (int)UPPER(*s2);
231}
232
233int memcmp(const void *_s1, const void *_s2, size_t n)
234{
235    uint8_t const *s1 = _s1, *s2 = _s2;
236   
237    while(n--)
238    {
239        if(*s1 != *s2)
240            return (int)*s1 - (int)*s2;
241        s1++;
242        s2++;
243    }
244    return 0;
245}
246
247char *strdup(const char *s)
248{
249    char *new;
250    unsigned int len = strlen(s);
251   
252    new = malloc(len + 1);
253    memcpy(new, s, len + 1);
254   
255    return new;
256}
257
258char *strchr(const char *s, int c)
259{
260    do
261        if(*s == c)
262            return (char *)(intptr_t)s;
263    while(*s++);
264   
265    return NULL;
266}
267
268/* stdarg.h functions */
269int vsnprintf(char *str, size_t size, const char *format, va_list ap)
270{
271    /* FIXME */
272    return 0;
273}
274
275/* stdio.h functions */
276FILE *fopen(const char *path, const char *mode)
277{
278    /* FIXME */
279    return NULL;
280}
281
282int feof(FILE *stream)
283{
284    /* FIXME */
285    return 0;
286}
287
288char *fgets(char *s, int size, FILE *stream)
289{
290    /* FIXME */
291    return NULL;
292}
293
294size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
295{
296    return 0;
297}
298
299int fclose(FILE *fp)
300{
301    /* FIXME */
302    return 0;
303}
304
305int printf(const char *fmt, ...)
306{
307    char str[200];
308    char tmp[100];
309    args_list args;
310    args_start(args, fmt);
311   
312    char *s;
313    int ptr = 0;
314    int i = 0;
315   
316    for (; fmt[i]; ++i) {
317        if ((fmt[i]!='%') && (fmt[i]!='\\')) {
318            str[ptr++] = fmt[i];
319            continue;
320        } else if (fmt[i] == '\\') {
321            switch (fmt[++i]) {
322                case 'a': str[ptr++] = '\a'; break;
323                case 'b': str[ptr++] = '\b'; break;
324                case 't': str[ptr++] = '\t'; break;
325                case 'n': str[ptr++] = '\n'; break;
326                case 'r': str[ptr++] = '\r'; break;
327                case '\\':str[ptr++] = '\\'; break;
328            }
329            continue;
330        }
331       
332        switch (fmt[++i]) {
333            case 's':
334                s = (char *)args_next(args, char *);
335                while (*s)
336                    str[ptr++] = *s++;
337                break;
338            case 'c':
339                str[ptr++] = (char)args_next(args, int);
340                break;
341            case 'p':
342            case 'x':
343                htoa((unsigned long)args_next(args, unsigned long), tmp);
344                memcpy(&str[ptr], tmp, strlen(tmp));
345                ptr+=strlen(tmp);
346                break;
347            case 'd':
348                itoa((unsigned long)args_next(args, unsigned long), tmp);
349                memcpy(&str[ptr], tmp, strlen(tmp));
350                ptr+=strlen(tmp);
351                break;
352            case '%':
353                str[ptr++] = '%';
354                break;
355            default:
356                str[ptr++] = fmt[i];
357                break;
358        }
359    }
360   
361    str[ptr] = '\0';
362    args_end(args);
363   
364    print(str);
365   
366    return 0;
367}
368
369int fprintf(FILE *stream, const char *format, ...)
370{
371    /* FIXME */
372    return 0;
373}
374
375int fflush(FILE *stream)
376{
377    /* FIXME */
378    return 0;
379}
380
381int sprintf(char *str, const char *fmt, ...)
382{
383    char tmp[100];
384    args_list args;
385    args_start(args, fmt);
386   
387    char *s;
388    int ptr = 0;
389    int i = 0;
390   
391    for (; fmt[i]; ++i) {
392        if ((fmt[i]!='%') && (fmt[i]!='\\')) {
393            str[ptr++] = fmt[i];
394            continue;
395        } else if (fmt[i] == '\\') {
396            switch (fmt[++i]) {
397                case 'a': str[ptr++] = '\a'; break;
398                case 'b': str[ptr++] = '\b'; break;
399                case 't': str[ptr++] = '\t'; break;
400                case 'n': str[ptr++] = '\n'; break;
401                case 'r': str[ptr++] = '\r'; break;
402                case '\\':str[ptr++] = '\\'; break;
403            }
404            continue;
405        }
406   
407        switch (fmt[++i]) {
408            case 's':
409                s = (char *)args_next(args, char *);
410                while (*s)
411                    str[ptr++] = *s++;
412                break;
413            case 'c':
414                str[ptr++] = (char)args_next(args, int);
415                break;
416            case 'p':
417            case 'x':
418                htoa((unsigned long)args_next(args, unsigned long), tmp);
419                memcpy(&str[ptr], tmp, strlen(tmp));
420                ptr+=strlen(tmp);
421                break;
422            case 'd':
423                itoa((unsigned long)args_next(args, unsigned long), tmp);
424                memcpy(&str[ptr], tmp, strlen(tmp));
425                ptr+=strlen(tmp);
426                break;
427            case '%':
428                str[ptr++] = '%';
429                break;
430            default:
431                str[ptr++] = fmt[i];
432                break;
433        }
434    }
435
436    str[ptr] = '\0';
437    args_end(args);
438
439    return 0;
440}
441
442int sscanf(const char *str, const char *format, ...)
443{
444    /* FIXME */
445    return 0;
446}
447
448/* unistd.h functions */
449void usleep(unsigned long usec)
450{
451        u32 start = ticks;
452    signed int diff  = 0;
453   
454    while(1) {
455        diff = (signed int)(ticks - start);
456        if(diff >= (signed int)(usec/20)) break;
457    }
458}
459
460void sleep(unsigned long sec)   
461{
462        usleep(sec*1000);       
463}
464
465/* time.h functions */
466  u64 rdtsc() {
467    u64 x;
468    __asm__ volatile ("rdtsc" : "=A" (x));
469    return x;
470}
471
472int gettimeofday(struct timeval *tv, struct timezone *tz)
473{
474    static int usec = 0;
475    static int sec = 0;
476   
477    /* FIXME */
478    usec += 10000;
479    if(usec > 1000000)
480    {
481        sec++;
482        usec -= 1000000;
483    }
484   
485    tv->tv_sec = sec;
486    tv->tv_usec = usec;
487   
488    return 0;
489}
490
491/* math.h functions */
492double cos(double x)
493{
494    double ret = 0.0;
495#ifdef HAVE_FSIN_FCOS
496    asm volatile("fcos" : "=t" (ret) : "0" (x));
497#else
498    double x2;
499    double num = 1.0;
500    double fact = 1.0;
501    int i;
502   
503    x = x - ((double)(int)(x / (2 * M_PI))) * (2 * M_PI);
504    x2 = x * x;
505   
506    /* cos(x) = 1/0! - x^2/2! + x^4/4! - x^6/6! ... */
507    for(i = 0; i < 10; i++)
508    {
509        ret += num / fact;
510        num *= - x2;
511        fact *= (2 * i + 1) * (2 * i + 2);
512    }
513#endif
514    return ret;
515}
516
517double sin(double x)
518{
519    double ret = 0.0;
520#ifdef HAVE_FSIN_FCOS
521    asm volatile("fsin" : "=t" (ret) : "0" (x));
522#else
523    double x2;
524    double num;
525    double fact = 1.0;
526    int i;
527   
528    x = x - ((double)(int)(x / (2 * M_PI))) * (2 * M_PI);
529    x2 = x * x;
530    num = x;
531   
532    /* sin(x) = x/1! - x^3/3! + x^5/5! - x^7/7! ... */
533    for(i = 0; i < 10; i++)
534    {
535        ret += num / fact;
536        num *= - x2;
537        fact *= (2 * i + 2) * (2 * i + 3);
538    }
539#endif
540    return ret;
541}
542
543double sqrt(double x)
544{
545    double ret = x;
546    int i;
547   
548    /* This is Newton's method */
549    for(i = 0; i < 10; i++)
550        ret = (ret * ret + x) / (ret * 2.0);
551   
552    return ret;
553}
554
555
556/* reverse:  reverse string s in place */
557void reverse(char s[])
558{
559    int i, j;
560    char c;
561   
562    for (i = 0, j = strlen(s)-1; i<j; i++, j--) {
563        c = s[i];
564        s[i] = s[j];
565        s[j] = c;
566    }
567}
568
569
570/* itoa implementation, by Kernighan and Ritchie's The C Programming Language */
571void itoa(int n, char s[])
572{
573    int i, sign;
574   
575    if ((sign = n) < 0)  /* record sign */
576        n = -n;          /* make n positive */
577    i = 0;
578    do {       /* generate digits in reverse order */
579        s[i++] = n % 10 + '0';   /* get next digit */
580    } while ((n /= 10) > 0);     /* delete it */
581    if (sign < 0)
582        s[i++] = '-';
583    s[i] = '\0';
584    reverse(s);
585}
586
587void htoa(unsigned int value, char s[]) {
588    int i = 8;
589    int ptr = 0;
590    while (i-- > 0) {
591        s[ptr++] = "0123456789abcdef"[(value>>(i*4))&0xf];
592    }
593    s[ptr] = 0;
594}
595
596
597/* errno.h stuff */
598int errno = 0;
Note: See TracBrowser for help on using the repository browser.