arch/ppc-sam440/boot/parthenope/src/support.c

   1 #include "context.h"
   2 #include "support.h"
   3
   4 int strlen(const char *str)
   5 {
   6         int len = 0;
   7         while (*str++)
   8                 len++;
   9         return len;
  10 }
  11
  12 int isblank(char c)
  13 {
  14         return (c == ' ' || c == '\t');
  15 }
  16
  17 int isspace(char c)
  18 {
  19         return (c == ' ' || c == '\t' || c == '\f' || c == '\n' || c == '\r'
  20                 || c == '\v');
  21 }
  22
  23 int isdigit(char c)
  24 {
  25         return (c >= '0' && c <= '9');
  26 }
  27
  28 int tolower(char c)
  29 {
  30         if (c >= 'A' && c <= 'Z')
  31                 c -= ('A' - 'a');
  32
  33         return c;
  34 }
  35
  36 int strncasecmp(const char *s1, const char *s2, int max)
  37 {
  38         int diff = 0;
  39         for (; max && !(diff = tolower(*s2) - tolower(*s1)) && *s1;
  40              max--, s1++, s2++) ;
  41         return diff;
  42 }
  43
  44 int strcasecmp(const char *s1, const char *s2)
  45 {
  46         int diff = 0;
  47         for (; !(diff = tolower(*s2) - tolower(*s1)) && *s1; s1++, s2++) ;
  48         return diff;
  49 }
  50
  51 int strncmp(const char *s1, const char *s2, int max)
  52 {
  53         int diff = 0;
  54         for (; max && !(diff = *s2 - *s1) && *s1; max--, s1++, s2++) ;
  55         return diff;
  56 }
  57
  58 int strcmp(const char *s1, const char *s2)
  59 {
  60         int diff = 0;
  61         for (; !(diff = *s2 - *s1) && *s1; s1++, s2++) ;
  62         return diff;
  63 }
  64
  65 void bzero(void *dest, int length)
  66 {
  67         char *d = dest;
  68
  69         while (length--)
  70                 *d++ = 0;
  71 }
  72
  73 char *strcpy(char *dest, const char *src)
  74 {
  75         return (char *)memmove(dest, src, strlen(src) + 1);
  76
  77 }
  78
  79 char *strncpy(char *dest, const char *src, int n)
  80 {
  81         return (char *)memmove(dest, src, n);
  82 }
  83
  84 int StackSwap(struct StackSwapStruct *sss)
  85 {
  86         register uint32_t real_sp asm("r1");
  87         uint32_t *sp;
  88         uint32_t *src;
  89         uint32_t *dst;
  90
  91         asm volatile ("wrteei 0");
  92
  93         /* Get the real stack pointer */
  94         asm volatile ("mr %0,%1":"=r" (sp):"r"(real_sp));
  95
  96         /* Go one stack frame upper - now src points to the stackframe of caller */
  97         src = (uint32_t *) * sp;
  98
  99         /* Go one more stack frame up. Now you may copy from src to dst (src - sp) IPTR's */
 100         src = (uint32_t *) * src;
 101
 102         /* If no StackSwapStruct is given, return the "reserved" area behind the stk_Pointer */
 103         if (!sss)
 104                 return (src - sp) * sizeof(uint32_t);
 105
 106         dst = sss->stk_Pointer;
 107
 108         /* Rewind the dst pointer too. */
 109         dst += (src - sp);
 110
 111         /* Copy the two stack frames */
 112         while (src != sp) {
 113                 *--dst = *--src;
 114         }
 115
 116         sss->stk_Pointer = sp;
 117
 118         asm volatile ("mr %0,%1"::"r" (real_sp), "r"(dst));
 119
 120         asm volatile ("wrteei 1");
 121
 122         return 0;
 123 }
 124
 125 void *calloc(int size, int n)
 126 {
 127         return malloc(size * n);
 128 }
 129
 130 void *memcpy(void *dest, const void *src, int n)
 131 {
 132         return memmove(dest, src, n);
 133 }
 134
 135 void *memset(void *dest, int c, int n)
 136 {
 137         char *ptr = (char *)dest;
 138
 139         while (n-- > 0)
 140                 *ptr++ = c;
 141         return dest;
 142 }
 143
 144 char *strchr(char *s, int c)
 145 {
 146         char *sptr;
 147         for (sptr = s; *sptr != 0 && *sptr != c; sptr++) ;
 148         if (*sptr == 0)
 149                 return NULL;
 150         return sptr;
 151 }
 152
 153 char *strdup(const char *s)
 154 {
 155         char *dup;
 156         dup = malloc(strlen(s) + 1);
 157         strcpy(dup, s);
 158         return dup;
 159 }
 160
 161 int strtol(const char *s)
 162 {
 163         int l, i, m;
 164         l = 0;
 165         for (i = strlen(s) - 1, m = 1; i >= 0; i--, m *= 10) {
 166                 l += (s[i] - 48) * m;
 167         }
 168         return l;
 169 }
 170
 171 list_t *list_new(void)
 172 {
 173         list_t *self;
 174
 175         self = malloc(sizeof(list_t));
 176
 177         self->l_head = (node_t *) & self->l_tail;
 178         self->l_tail = NULL;
 179         self->l_tailpred = (node_t *) & self->l_head;
 180
 181         return self;
 182 }
 183
 184 void list_append(list_t * self, node_t * node)
 185 {
 186         node->n_succ = (node_t *) & self->l_tail;
 187         node->n_pred = self->l_tailpred;
 188         node->n_pred->n_succ = node;
 189         self->l_tailpred = node;
 190 }