root/user/ulib.c

DEFINITIONS

1. start
2. strcpy
3. strcmp
4. strlen
5. memset
6. strchr
7. gets
8. stat
9. atoi
10. memmove
11. memcmp
12. memcpy
13. sbrk
14. sbrklazy

   1 #include "kernel/types.h"
   2 #include "kernel/stat.h"
   3 #include "kernel/fcntl.h"
   4 #include "kernel/riscv.h"
   5 #include "kernel/vm.h"
   6 #include "user/user.h"
   7 
   8 //
   9 // wrapper so that it's OK if main() does not call exit().
  10 //
  11 void
  12 start()
  13 {
  14   extern int main();
  15   main();
  16   exit(0);
  17 }
  18 
  19 char*
  20 strcpy(char *s, const char *t)
  21 {
  22   char *os;
  23 
  24   os = s;
  25   while((*s++ = *t++) != 0)
  26     ;
  27   return os;
  28 }
  29 
  30 int
  31 strcmp(const char *p, const char *q)
  32 {
  33   while(*p && *p == *q)
  34     p++, q++;
  35   return (uchar)*p - (uchar)*q;
  36 }
  37 
  38 uint
  39 strlen(const char *s)
  40 {
  41   int n;
  42 
  43   for(n = 0; s[n]; n++)
  44     ;
  45   return n;
  46 }
  47 
  48 void*
  49 memset(void *dst, int c, uint n)
  50 {
  51   char *cdst = (char *) dst;
  52   int i;
  53   for(i = 0; i < n; i++){
  54     cdst[i] = c;
  55   }
  56   return dst;
  57 }
  58 
  59 char*
  60 strchr(const char *s, char c)
  61 {
  62   for(; *s; s++)
  63     if(*s == c)
  64       return (char*)s;
  65   return 0;
  66 }
  67 
  68 char*
  69 gets(char *buf, int max)
  70 {
  71   int i, cc;
  72   char c;
  73 
  74   for(i=0; i+1 < max; ){
  75     cc = read(0, &c, 1);
  76     if(cc < 1)
  77       break;
  78     buf[i++] = c;
  79     if(c == '\n' || c == '\r')
  80       break;
  81   }
  82   buf[i] = '\0';
  83   return buf;
  84 }
  85 
  86 int
  87 stat(const char *n, struct stat *st)
  88 {
  89   int fd;
  90   int r;
  91 
  92   fd = open(n, O_RDONLY);
  93   if(fd < 0)
  94     return -1;
  95   r = fstat(fd, st);
  96   close(fd);
  97   return r;
  98 }
  99 
 100 int
 101 atoi(const char *s)
 102 {
 103   int n;
 104 
 105   n = 0;
 106   while('0' <= *s && *s <= '9')
 107     n = n*10 + *s++ - '0';
 108   return n;
 109 }
 110 
 111 void*
 112 memmove(void *vdst, const void *vsrc, int n)
 113 {
 114   char *dst;
 115   const char *src;
 116 
 117   dst = vdst;
 118   src = vsrc;
 119   if (src > dst) {
 120     while(n-- > 0)
 121       *dst++ = *src++;
 122   } else {
 123     dst += n;
 124     src += n;
 125     while(n-- > 0)
 126       *--dst = *--src;
 127   }
 128   return vdst;
 129 }
 130 
 131 int
 132 memcmp(const void *s1, const void *s2, uint n)
 133 {
 134   const char *p1 = s1, *p2 = s2;
 135   while (n-- > 0) {
 136     if (*p1 != *p2) {
 137       return *p1 - *p2;
 138     }
 139     p1++;
 140     p2++;
 141   }
 142   return 0;
 143 }
 144 
 145 void *
 146 memcpy(void *dst, const void *src, uint n)
 147 {
 148   return memmove(dst, src, n);
 149 }
 150 
 151 char *
 152 sbrk(int n) {
 153   return sys_sbrk(n, SBRK_EAGER);
 154 }
 155 
 156 char *
 157 sbrklazy(int n) {
 158   return sys_sbrk(n, SBRK_LAZY);
 159 }
 160