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