URL https://opencores.org/ocsvn/plasma/plasma/trunk

Subversion Repositories plasma

[/] [plasma/] [trunk/] [kernel/] [libc.c] - Blame information for rev 436

Details | Compare with Previous | View Log


/*--------------------------------------------------------------------
 * TITLE: ANSI C Library
 * AUTHOR: Steve Rhoads (rhoadss@yahoo.com)
 * DATE CREATED: 12/17/05
 * FILENAME: libc.c
 * PROJECT: Plasma CPU core
 * COPYRIGHT: Software placed into the public domain by the author.
 *    Software 'as is' without warranty.  Author liable for nothing.
 * DESCRIPTION:
 *    Subset of the ANSI C library
 *--------------------------------------------------------------------*/
#define NO_ELLIPSIS
#include "rtos.h"
 
char *strcpy(char *dst, const char *src)
{
   char *dstSave=dst;
   int c;
   do
   {
      c = *dst++ = *src++;
   } while(c);
   return dstSave;
}
 
 
char *strncpy(char *dst, const char *src, int count)
{
   int c=1;
   char *dstSave=dst;
   while(count-- > 0 && c)
      c = *dst++ = *src++;
   *dst = 0;
   return dstSave;
}
 
 
char *strcat(char *dst, const char *src)
{
   int c;
   char *dstSave=dst;
   while(*dst)
      ++dst;
   do
   {
      c = *dst++ = *src++;
   } while(c);
   return dstSave;
}
 
 
char *strncat(char *dst, const char *src, int count)
{
   int c=1;
   char *dstSave=dst;
   while(*dst)
      ++dst;
   while(--count >= 0 && c)
      c = *dst++ = *src++;
   *dst = 0;
   return dstSave;
}
 
#ifdef STRNCAT_SIZE
char *strncat_size(char *dst, const char *src, int sizeDst)
{
   int c=1;
   char *dstSave=dst;
   while(*dst)
      ++dst;
   sizeDst -= dst - dstSave;
   while(--sizeDst > 0 && c)
      c = *dst++ = *src++;
   *dst = 0;
   return dstSave;
}
#endif
 
int strcmp(const char *string1, const char *string2)
{
   int diff, c;
   for(;;)
   {
      diff = *string1++ - (c = *string2++);
      if(diff)
         return diff;
      if(c == 0)
         return 0;
   }
}
 
 
int strncmp(const char *string1, const char *string2, int count)
{
   int diff, c;
   while(count-- > 0)
   {
      diff = *string1++ - (c = *string2++);
      if(diff)
         return diff;
      if(c == 0)
         return 0;
   }
   return 0;
}
 
 
char *strstr(const char *string, const char *find)
{
   int i;
   for(;;)
   {
      for(i = 0; string[i] == find[i] && find[i]; ++i) ;
      if(find[i] == 0)
         return (char*)string;
      if(*string++ == 0)
         return NULL;
   }
}
 
 
int strlen(const char *string)
{
   const char *base=string;
   while(*string++) ;
   return string - base - 1;
}
 
 
void *memcpy(void *dst, const void *src, unsigned long bytes)
{
   if(((uint32)dst | (uint32)src | bytes) & 3)
   {
      uint8 *Dst = (uint8*)dst, *Src = (uint8*)src;
      while((int)bytes-- > 0)
         *Dst++ = *Src++;
   }
   else
   {
      uint32 *Dst32 = (uint32*)dst, *Src32 = (uint32*)src;
      bytes >>= 2;
      while((int)bytes-- > 0)
         *Dst32++ = *Src32++;
   }
   return dst;
}
 
 
void *memmove(void *dst, const void *src, unsigned long bytes)
{
   uint8 *Dst = (uint8*)dst;
   uint8 *Src = (uint8*)src;
   if(Dst < Src)
   {
      while((int)bytes-- > 0)
         *Dst++ = *Src++;
   }
   else
   {
      Dst += bytes;
      Src += bytes;
      while((int)bytes-- > 0)
         *--Dst = *--Src;
   }
   return dst;
}
 
 
int memcmp(const void *cs, const void *ct, unsigned long bytes)
{
   uint8 *Dst = (uint8*)cs;
   uint8 *Src = (uint8*)ct;
   int diff;
   while((int)bytes-- > 0)
   {
      diff = *Dst++ - *Src++;
      if(diff)
         return diff;
   }
   return 0;
}
 
 
void *memset(void *dst, int c, unsigned long bytes)
{
   uint8 *Dst = (uint8*)dst;
   while((int)bytes-- > 0)
      *Dst++ = (uint8)c;
   return dst;
}
 
 
int abs(int n)
{
   return n>=0 ? n : -n;
}
 
 
static uint32 Rand1=0x1f2bcda3;
int rand(void)
{
   Rand1 = 1664525 * Rand1 + 1013904223;  //from D.E. Knuth and H.W. Lewis
   return Rand1 << 16 | Rand1 >> 16;
}
 
 
void srand(unsigned int seed)
{
   Rand1 = seed;
}
 
 
long strtol(const char *s, char **end, int base)
{
   int i;
   unsigned long ch, value=0, neg=0;
 
   if(s[0] == '-')
   {
      neg = 1;
      ++s;
   }
   if(s[0] == '0' && s[1] == 'x')
   {
      base = 16;
      s += 2;
   }
   for(i = 0; i <= 8; ++i)
   {
      ch = *s++;
      if('0' <= ch && ch <= '9')
         ch -= '0';
      else if('A' <= ch && ch < base - 10 + 'A')
         ch = ch - 'A' + 10;
      else if('a' <= ch && ch < base - 10 + 'a')
         ch = ch - 'a' + 10;
      else
         break;
      value = value * base + ch;
   }
   if(end)
      *end = (char*)s - 1;
   if(neg)
      value = -(int)value;
   return value;
}
 
 
int atoi(const char *s)
{
   return strtol(s, NULL, 10);
}
 
 
char *itoa(int num, char *dst, int base)
{
   int digit, negate=0, place;
   char c, text[20];
 
   if(base == 10 && num < 0)
   {
      num = -num;
      negate = 1;
   }
   text[16] = 0;
   for(place = 15; place > 0; --place)
   {
      digit = (unsigned int)num % (unsigned int)base;
      if(num == 0 && place < 15 && base == 10 && negate)
      {
         c = '-';
         negate = 0;
      }
      else if(digit < 10)
         c = (char)('0' + digit);
      else
         c = (char)('a' + digit - 10);
      text[place] = c;
      num = (unsigned int)num / (unsigned int)base;
      if(num == 0 && negate == 0)
         break;
   }
   strcpy(dst, text + place);
   return dst;
}
 
 
int sprintf(char *s, const char *format,
            int arg0, int arg1, int arg2, int arg3,
            int arg4, int arg5, int arg6, int arg7)
{
   int argv[8];
   int argc=0, width, length;
   char f=0, prev, text[20], fill;
 
   argv[0] = arg0; argv[1] = arg1; argv[2] = arg2; argv[3] = arg3;
   argv[4] = arg4; argv[5] = arg5; argv[6] = arg6; argv[7] = arg7;
 
   for(;;)
   {
      prev = f;
      f = *format++;
      if(f == 0)
         return argc;
      else if(f == '%')
      {
         width = 0;
         fill = ' ';
         f = *format++;
         while('0' <= f && f <= '9')
         {
            width = width * 10 + f - '0';
            f = *format++;
         }
         if(f == '.')
         {
            fill = '0';
            f = *format++;
         }
         if(f == 0)
            return argc;
 
         if(f == 'd')
         {
            memset(s, fill, width);
            itoa(argv[argc++], text, 10);
            length = (int)strlen(text);
            if(width < length)
               width = length;
            strcpy(s + width - length, text);
         }
         else if(f == 'x' || f == 'f')
         {
            memset(s, '0', width);
            itoa(argv[argc++], text, 16);
            length = (int)strlen(text);
            if(width < length)
               width = length;
            strcpy(s + width - length, text);
         }
         else if(f == 'c')
         {
            *s++ = (char)argv[argc++];
            *s = 0;
         }
         else if(f == 's')
         {
            length = strlen((char*)argv[argc]);
            if(width > length)
            {
               memset(s, ' ', width - length);
               s += width - length;
            }
            strcpy(s, (char*)argv[argc++]);
         }
         s += strlen(s);
      }
      else
      {
         if(f == '\n' && prev != '\r')
            *s++ = '\r';
         *s++ = f;
      }
      *s = 0;
   }
}
 
 
int sscanf(const char *s, const char *format,
           int arg0, int arg1, int arg2, int arg3,
           int arg4, int arg5, int arg6, int arg7)
{
   int argv[8];
   int argc=0;
   char f, *ptr;
 
   argv[0] = arg0; argv[1] = arg1; argv[2] = arg2; argv[3] = arg3;
   argv[4] = arg4; argv[5] = arg5; argv[6] = arg6; argv[7] = arg7;
 
   for(;;)
   {
      if(*s == 0)
         return argc;
      f = *format++;
      if(f == 0)
         return argc;
      else if(f == '%')
      {
         while(isspace(*s))
            ++s;
         f = *format++;
         if(f == 0)
            return argc;
         if(f == 'd')
            *(int*)argv[argc++] = strtol(s, (char**)&s, 10);
         else if(f == 'x')
            *(int*)argv[argc++] = strtol(s, (char**)&s, 16);
         else if(f == 'c')
            *(char*)argv[argc++] = *s++;
         else if(f == 's')
         {
            ptr = (char*)argv[argc++];
            while(!isspace(*s))
               *ptr++ = *s++;
            *ptr = 0;
         }
      }
      else
      {
         while(*s && *s != f)
            ++s;
         if(*s)
            ++s;
      }
   }
}
 
 
#ifdef INCLUDE_DUMP
/*********************** dump ***********************/
void dump(const unsigned char *data, int length)
{
   int i, index=0, value;
   char string[80];
   memset(string, 0, sizeof(string));
   for(i = 0; i < length; ++i)
   {
      if((i & 15) == 0)
      {
         if(strlen(string))
            printf("%s\n", string);
         printf("%4x ", i);
         memset(string, 0, sizeof(string));
         index = 0;
      }
      value = data[i];
      printf("%2x ", value);
      if(isprint(value))
         string[index] = (char)value;
      else
         string[index] = '.';
      ++index;
   }
   for(; index < 16; ++index)
      printf("   ");
   printf("%s\n", string);
}
#endif //INCLUDE_DUMP
 
 
#ifdef INCLUDE_QSORT
/*********************** qsort ***********************/
static void QsortSwap(char *base, long left, long right, long size)
{
   int temp, i;
   char *ptrLeft, *ptrRight;
   ptrLeft = base + left * size;
   ptrRight = base + right * size;
   for(i = 0; i < size; ++i)
   {
      temp = ptrLeft[i];
      ptrLeft[i] = ptrRight[i];
      ptrRight[i] = (char)temp;
   }
}
 
 
//Modified from K&R
static void qsort2(void *base, long left, long right, long size,
      int (*cmp)(const void *,const void *))
{
   int i, last;
   char *base2=(char*)base, *pivot;
   if(left >= right)
      return;
   QsortSwap(base2, left, (left + right)/2, size);
   last = left;
   pivot = &base2[left*size];
   for(i = left + 1; i <= right; ++i)
   {
      if(cmp(&base2[i*size], pivot) < 0)
         QsortSwap(base2, ++last, i, size);
   }
   QsortSwap(base2, left, last, size);
   qsort2(base, left, last-1, size, cmp);
   qsort2(base, last+1, right, size, cmp);
}
 
 
void qsort(void *base,
           long n,
           long size,
           int (*cmp)(const void *,const void *))
{
   qsort2(base, 0, n-1, size, cmp);
}
 
 
void *bsearch(const void *key,
              const void *base,
              long n,
              long size,
              int (*cmp)(const void *,const void *))
{
   long cond, low=0, high=n-1, mid;
   char *base2=(char*)base;
   while(low <= high)
   {
      mid = (low + high)/2;
      cond = cmp(key, &base2[mid*size]);
      if(cond < 0)
         high = mid - 1;
      else if(cond > 0)
         low = mid + 1;
      else
         return &base2[mid * size];
   }
   return NULL;
}
#endif //INCLUDE_QSORT
 
 
#ifdef INCLUDE_TIMELIB
/************************* time.h ***********************/
#define SEC_PER_YEAR (365L*24*60*60)
#define SEC_PER_DAY (24L*60*60)
//typedef unsigned long time_t;  //start at 1/1/80
//struct tm {
//   int tm_sec;      //(0,59)
//   int tm_min;      //(0,59)
//   int tm_hour;     //(0,23)
//   int tm_mday;     //(1,31)
//   int tm_mon;      //(0,11)
//   int tm_year;     //(0,n) from 1900
//   int tm_wday;     //(0,6)     calculated
//   int tm_yday;     //(0,365)   calculated
//   int tm_isdst;    //hour adjusted for day light savings
//};
static const unsigned short DaysUntilMonth[]=
   {0,31,59,90,120,151,181,212,243,273,304,334,365};
static const unsigned short DaysInMonth[]=
   {31,28,31,30,31,30,31,31,30,31,30,31};
static time_t DstTimeIn, DstTimeOut;
 
 
/* Leap year if divisible by 4.  Centenary years should only be
   leap-years if they were divisible by 400. */
static int IsLeapYear(int year)
{
   return(((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0));
}
 
time_t mktime(struct tm *tp)
{
   time_t seconds;
   unsigned long days, y, year;
 
   days = tp->tm_mday - 1 + DaysUntilMonth[tp->tm_mon] +
      365 * (tp->tm_year - 80);
   seconds = (unsigned long)tp->tm_sec + 60L * (tp->tm_min +
      60L * (tp->tm_hour + 24L * days));
   if(tp->tm_isdst)
      seconds -= 60 * 60;
   year = 1900 + tp->tm_year - (tp->tm_mon < 2);
   for(y = 1980; y <= year; y += 4)
   {
      if(y % 100 != 0 || y % 400 == 0)
         seconds += SEC_PER_DAY;
   }
   return seconds;
}
 
 
void gmtime_r(const time_t *tp, struct tm *out)
{
   time_t seconds, delta, secondsIn=*tp;
   int isLeapYear;
   unsigned long year, month;
 
   out->tm_isdst = 0;
   if(DstTimeIn <= secondsIn && secondsIn < DstTimeOut)
   {
      secondsIn += 60 * 60;
      out->tm_isdst = 1;
   }
   seconds = secondsIn;
   for(year = 0; ; ++year)
   {
      delta = SEC_PER_YEAR + IsLeapYear(1980 + year) * SEC_PER_DAY;
      if(seconds >= delta)
         seconds -= delta;
      else
         break;
   }
   out->tm_year = year + 80;
   out->tm_yday = seconds / SEC_PER_DAY;
   isLeapYear = IsLeapYear(1980 + year);
   for(month = 0; ; ++month)
   {
      delta = SEC_PER_DAY * (DaysInMonth[month] + (isLeapYear && (month == 1)));
      if(seconds >= delta)
         seconds -= delta;
      else
         break;
   }
   out->tm_mon = month;
   out->tm_mday = seconds / SEC_PER_DAY;
   seconds -= out->tm_mday * SEC_PER_DAY;
   ++out->tm_mday;
   out->tm_hour = seconds / (60 * 60);
   seconds -= out->tm_hour * (60 * 60);
   out->tm_min = seconds / 60;
   seconds -= out->tm_min * 60;
   out->tm_sec = seconds;
   seconds = secondsIn % (SEC_PER_DAY * 7);
   out->tm_wday = (seconds / SEC_PER_DAY + 2) % 7; /* 1/1/80 is a Tue */
   //printf("%4.d/%2.d/%2.d:%2.d:%2.d:%2.d\n", 
   //         out->tm_year+1900, out->tm_mon+1, out->tm_mday,
   //         out->tm_hour, out->tm_min, out->tm_sec);
}
 
 
void gmtimeDst(time_t dstTimeIn, time_t dstTimeOut)
{
   DstTimeIn = dstTimeIn;
   DstTimeOut = dstTimeOut;
}
 
 
//DST from 2am on the second Sunday in March to 2am first Sunday in November
void gmtimeDstSet(time_t *tp, time_t *dstTimeIn, time_t *dstTimeOut)
{
   time_t seconds, timeIn, timeOut;
   struct tm tmDate;
   int year, days;
 
   DstTimeIn = 0;
   DstTimeOut = 0;
   gmtime_r(tp, &tmDate);
   year = tmDate.tm_year;
 
   //March 1, year, 2AM -> second Sunday
   tmDate.tm_year = year;
   tmDate.tm_mon = 2;
   tmDate.tm_mday = 1;
   tmDate.tm_hour = 2;
   tmDate.tm_min = 0;
   tmDate.tm_sec = 0;
   seconds = mktime(&tmDate);
   gmtime_r(&seconds, &tmDate);
   days = 7 - tmDate.tm_wday + 7;
   *dstTimeIn = timeIn = seconds + days * SEC_PER_DAY;
 
   //November 1, year, 2AM -> first Sunday
   tmDate.tm_year = year;
   tmDate.tm_mon = 10;
   tmDate.tm_mday = 1;
   tmDate.tm_hour = 2;
   tmDate.tm_min = 0;
   tmDate.tm_sec = 0;
   seconds = mktime(&tmDate);
   gmtime_r(&seconds, &tmDate);
   days = 7 - tmDate.tm_wday;
   *dstTimeOut = timeOut = seconds + days * SEC_PER_DAY;
 
   DstTimeIn = timeIn;
   DstTimeOut = timeOut;
}
#endif //INCLUDE_TIMELIB
 

Line No.	Rev	Author	Line
1	138	rhoads	`/*--------------------------------------------------------------------`
2			`* TITLE: ANSI C Library`
3			`* AUTHOR: Steve Rhoads (rhoadss@yahoo.com)`
4			`* DATE CREATED: 12/17/05`
5	171	rhoads	`* FILENAME: libc.c`
6	138	rhoads	`* PROJECT: Plasma CPU core`
7			`* COPYRIGHT: Software placed into the public domain by the author.`
8			`* Software 'as is' without warranty. Author liable for nothing.`
9			`* DESCRIPTION:`
10			`* Subset of the ANSI C library`
11			`--------------------------------------------------------------------/`
12			`#define NO_ELLIPSIS`
13			`#include "rtos.h"`
14
15			`char strcpy(char dst, const char *src)`
16			`{`
17	258	rhoads	`char *dstSave=dst;`
18	138	rhoads	`int c;`
19			`do`
20			`{`
21			`c = dst++ = src++;`
22			`} while(c);`
23	258	rhoads	`return dstSave;`
24	138	rhoads	`}`
25
26
27			`char strncpy(char dst, const char *src, int count)`
28			`{`
29			`int c=1;`
30	258	rhoads	`char *dstSave=dst;`
31	138	rhoads	`while(count-- > 0 && c)`
32			`c = dst++ = src++;`
33			`*dst = 0;`
34	258	rhoads	`return dstSave;`
35	138	rhoads	`}`
36
37
38			`char strcat(char dst, const char *src)`
39			`{`
40			`int c;`
41	258	rhoads	`char *dstSave=dst;`
42	138	rhoads	`while(*dst)`
43			`++dst;`
44			`do`
45			`{`
46			`c = dst++ = src++;`
47			`} while(c);`
48	258	rhoads	`return dstSave;`
49	138	rhoads	`}`
50
51
52			`char strncat(char dst, const char *src, int count)`
53			`{`
54			`int c=1;`
55	258	rhoads	`char *dstSave=dst;`
56	399	rhoads	`while(*dst)`
57	138	rhoads	`++dst;`
58	399	rhoads	`while(--count >= 0 && c)`
59	138	rhoads	`c = dst++ = src++;`
60			`*dst = 0;`
61	258	rhoads	`return dstSave;`
62	138	rhoads	`}`
63
64	436	rhoads	`#ifdef STRNCAT_SIZE`
65			`char strncat_size(char dst, const char *src, int sizeDst)`
66			`{`
67			`int c=1;`
68			`char *dstSave=dst;`
69			`while(*dst)`
70			`++dst;`
71			`sizeDst -= dst - dstSave;`
72			`while(--sizeDst > 0 && c)`
73			`c = dst++ = src++;`
74			`*dst = 0;`
75			`return dstSave;`
76			`}`
77			`#endif`
78	138	rhoads
79			`int strcmp(const char string1, const char string2)`
80			`{`
81			`int diff, c;`
82			`for(;;)`
83			`{`
84			`diff = string1++ - (c = string2++);`
85			`if(diff)`
86			`return diff;`
87			`if(c == 0)`
88			`return 0;`
89			`}`
90			`}`
91
92
93			`int strncmp(const char string1, const char string2, int count)`
94			`{`
95			`int diff, c;`
96			`while(count-- > 0)`
97			`{`
98			`diff = string1++ - (c = string2++);`
99			`if(diff)`
100			`return diff;`
101			`if(c == 0)`
102			`return 0;`
103			`}`
104			`return 0;`
105			`}`
106
107
108	149	rhoads	`char strstr(const char string, const char *find)`
109	138	rhoads	`{`
110			`int i;`
111			`for(;;)`
112			`{`
113			`for(i = 0; string[i] == find[i] && find[i]; ++i) ;`
114			`if(find[i] == 0)`
115	149	rhoads	`return (char*)string;`
116	138	rhoads	`if(*string++ == 0)`
117			`return NULL;`
118			`}`
119			`}`
120
121
122			`int strlen(const char *string)`
123			`{`
124			`const char *base=string;`
125			`while(*string++) ;`
126			`return string - base - 1;`
127			`}`
128
129
130			`void memcpy(void dst, const void *src, unsigned long bytes)`
131			`{`
132	249	rhoads	`if(((uint32)dst \| (uint32)src \| bytes) & 3)`
133			`{`
134			`uint8 Dst = (uint8)dst, Src = (uint8)src;`
135			`while((int)bytes-- > 0)`
136			`Dst++ = Src++;`
137			`}`
138			`else`
139			`{`
140			`uint32 Dst32 = (uint32)dst, Src32 = (uint32)src;`
141			`bytes >>= 2;`
142			`while((int)bytes-- > 0)`
143			`Dst32++ = Src32++;`
144			`}`
145	138	rhoads	`return dst;`
146			`}`
147
148
149	144	rhoads	`void memmove(void dst, const void *src, unsigned long bytes)`
150			`{`
151			`uint8 Dst = (uint8)dst;`
152			`uint8 Src = (uint8)src;`
153			`if(Dst < Src)`
154			`{`
155			`while((int)bytes-- > 0)`
156			`Dst++ = Src++;`
157			`}`
158			`else`
159			`{`
160			`Dst += bytes;`
161			`Src += bytes;`
162			`while((int)bytes-- > 0)`
163			`--Dst = --Src;`
164			`}`
165			`return dst;`
166			`}`
167
168
169	138	rhoads	`int memcmp(const void cs, const void ct, unsigned long bytes)`
170			`{`
171			`uint8 Dst = (uint8)cs;`
172			`uint8 Src = (uint8)ct;`
173			`int diff;`
174			`while((int)bytes-- > 0)`
175			`{`
176			`diff = Dst++ - Src++;`
177			`if(diff)`
178			`return diff;`
179			`}`
180			`return 0;`
181			`}`
182
183
184			`void memset(void dst, int c, unsigned long bytes)`
185			`{`
186			`uint8 Dst = (uint8)dst;`
187			`while((int)bytes-- > 0)`
188			`*Dst++ = (uint8)c;`
189			`return dst;`
190			`}`
191
192
193			`int abs(int n)`
194			`{`
195			`return n>=0 ? n : -n;`
196			`}`
197
198
199	379	rhoads	`static uint32 Rand1=0x1f2bcda3;`
200	436	rhoads	`int rand(void)`
201	138	rhoads	`{`
202	379	rhoads	`Rand1 = 1664525 * Rand1 + 1013904223; //from D.E. Knuth and H.W. Lewis`
203	416	rhoads	`return Rand1 << 16 \| Rand1 >> 16;`
204	138	rhoads	`}`
205
206
207			`void srand(unsigned int seed)`
208			`{`
209			`Rand1 = seed;`
210			`}`
211
212
213	302	rhoads	`long strtol(const char s, char *end, int base)`
214	138	rhoads	`{`
215			`int i;`
216			`unsigned long ch, value=0, neg=0;`
217
218			`if(s[0] == '-')`
219			`{`
220			`neg = 1;`
221			`++s;`
222			`}`
223			`if(s[0] == '0' && s[1] == 'x')`
224			`{`
225			`base = 16;`
226			`s += 2;`
227			`}`
228			`for(i = 0; i <= 8; ++i)`
229			`{`
230			`ch = *s++;`
231			`if('0' <= ch && ch <= '9')`
232			`ch -= '0';`
233	432	rhoads	`else if('A' <= ch && ch < base - 10 + 'A')`
234	138	rhoads	`ch = ch - 'A' + 10;`
235	432	rhoads	`else if('a' <= ch && ch < base - 10 + 'a')`
236	138	rhoads	`ch = ch - 'a' + 10;`
237			`else`
238			`break;`
239			`value = value * base + ch;`
240			`}`
241			`if(end)`
242	302	rhoads	`end = (char)s - 1;`
243	138	rhoads	`if(neg)`
244			`value = -(int)value;`
245			`return value;`
246			`}`
247
248
249			`int atoi(const char *s)`
250			`{`
251			`return strtol(s, NULL, 10);`
252			`}`
253
254
255	149	rhoads	`char itoa(int num, char dst, int base)`
256	138	rhoads	`{`
257	149	rhoads	`int digit, negate=0, place;`
258			`char c, text[20];`
259	138	rhoads
260			`if(base == 10 && num < 0)`
261			`{`
262			`num = -num;`
263			`negate = 1;`
264			`}`
265	149	rhoads	`text[16] = 0;`
266	425	rhoads	`for(place = 15; place > 0; --place)`
267	138	rhoads	`{`
268	187	rhoads	`digit = (unsigned int)num % (unsigned int)base;`
269	149	rhoads	`if(num == 0 && place < 15 && base == 10 && negate)`
270	138	rhoads	`{`
271	149	rhoads	`c = '-';`
272	138	rhoads	`negate = 0;`
273			`}`
274			`else if(digit < 10)`
275			`c = (char)('0' + digit);`
276			`else`
277			`c = (char)('a' + digit - 10);`
278	149	rhoads	`text[place] = c;`
279			`num = (unsigned int)num / (unsigned int)base;`
280			`if(num == 0 && negate == 0)`
281			`break;`
282	138	rhoads	`}`
283	149	rhoads	`strcpy(dst, text + place);`
284			`return dst;`
285	138	rhoads	`}`
286
287
288			`int sprintf(char s, const char format,`
289			`int arg0, int arg1, int arg2, int arg3,`
290			`int arg4, int arg5, int arg6, int arg7)`
291			`{`
292			`int argv[8];`
293			`int argc=0, width, length;`
294	425	rhoads	`char f=0, prev, text[20], fill;`
295	138	rhoads
296			`argv[0] = arg0; argv[1] = arg1; argv[2] = arg2; argv[3] = arg3;`
297			`argv[4] = arg4; argv[5] = arg5; argv[6] = arg6; argv[7] = arg7;`
298
299			`for(;;)`
300			`{`
301	425	rhoads	`prev = f;`
302	138	rhoads	`f = *format++;`
303			`if(f == 0)`
304			`return argc;`
305			`else if(f == '%')`
306			`{`
307			`width = 0;`
308	187	rhoads	`fill = ' ';`
309	138	rhoads	`f = *format++;`
310	187	rhoads	`while('0' <= f && f <= '9')`
311	138	rhoads	`{`
312	187	rhoads	`width = width * 10 + f - '0';`
313	138	rhoads	`f = *format++;`
314			`}`
315	187	rhoads	`if(f == '.')`
316			`{`
317			`fill = '0';`
318			`f = *format++;`
319			`}`
320			`if(f == 0)`
321			`return argc;`
322	138	rhoads
323			`if(f == 'd')`
324	149	rhoads	`{`
325	187	rhoads	`memset(s, fill, width);`
326	149	rhoads	`itoa(argv[argc++], text, 10);`
327			`length = (int)strlen(text);`
328			`if(width < length)`
329			`width = length;`
330			`strcpy(s + width - length, text);`
331			`}`
332	138	rhoads	`else if(f == 'x' \|\| f == 'f')`
333	149	rhoads	`{`
334			`memset(s, '0', width);`
335			`itoa(argv[argc++], text, 16);`
336			`length = (int)strlen(text);`
337			`if(width < length)`
338			`width = length;`
339			`strcpy(s + width - length, text);`
340			`}`
341	138	rhoads	`else if(f == 'c')`
342			`{`
343			`*s++ = (char)argv[argc++];`
344			`*s = 0;`
345			`}`
346			`else if(f == 's')`
347			`{`
348			`length = strlen((char*)argv[argc]);`
349			`if(width > length)`
350			`{`
351			`memset(s, ' ', width - length);`
352			`s += width - length;`
353			`}`
354			`strcpy(s, (char*)argv[argc++]);`
355			`}`
356			`s += strlen(s);`
357			`}`
358	328	rhoads	`else`
359	138	rhoads	`{`
360	425	rhoads	`if(f == '\n' && prev != '\r')`
361	138	rhoads	`*s++ = '\r';`
362			`*s++ = f;`
363			`}`
364			`*s = 0;`
365			`}`
366			`}`
367
368
369			`int sscanf(const char s, const char format,`
370			`int arg0, int arg1, int arg2, int arg3,`
371			`int arg4, int arg5, int arg6, int arg7)`
372			`{`
373			`int argv[8];`
374	187	rhoads	`int argc=0;`
375			`char f, *ptr;`
376	138	rhoads
377			`argv[0] = arg0; argv[1] = arg1; argv[2] = arg2; argv[3] = arg3;`
378			`argv[4] = arg4; argv[5] = arg5; argv[6] = arg6; argv[7] = arg7;`
379
380			`for(;;)`
381			`{`
382			`if(*s == 0)`
383			`return argc;`
384			`f = *format++;`
385			`if(f == 0)`
386			`return argc;`
387			`else if(f == '%')`
388			`{`
389			`while(isspace(*s))`
390			`++s;`
391			`f = *format++;`
392			`if(f == 0)`
393			`return argc;`
394			`if(f == 'd')`
395	302	rhoads	`(int)argv[argc++] = strtol(s, (char**)&s, 10);`
396	138	rhoads	`else if(f == 'x')`
397	302	rhoads	`(int)argv[argc++] = strtol(s, (char**)&s, 16);`
398	138	rhoads	`else if(f == 'c')`
399			`(char)argv[argc++] = *s++;`
400			`else if(f == 's')`
401			`{`
402	207	rhoads	`ptr = (char*)argv[argc++];`
403	187	rhoads	`while(!isspace(*s))`
404			`ptr++ = s++;`
405			`*ptr = 0;`
406	138	rhoads	`}`
407			`}`
408			`else`
409			`{`
410			`while(s && s != f)`
411			`++s;`
412			`if(*s)`
413			`++s;`
414			`}`
415			`}`
416			`}`
417
418	149	rhoads
419	171	rhoads	`#ifdef INCLUDE_DUMP`
420			`/********************* dump *********************/`
421	149	rhoads	`void dump(const unsigned char *data, int length)`
422			`{`
423			`int i, index=0, value;`
424			`char string[80];`
425			`memset(string, 0, sizeof(string));`
426			`for(i = 0; i < length; ++i)`
427			`{`
428			`if((i & 15) == 0)`
429			`{`
430			`if(strlen(string))`
431			`printf("%s\n", string);`
432			`printf("%4x ", i);`
433			`memset(string, 0, sizeof(string));`
434			`index = 0;`
435			`}`
436			`value = data[i];`
437			`printf("%2x ", value);`
438			`if(isprint(value))`
439			`string[index] = (char)value;`
440			`else`
441			`string[index] = '.';`
442			`++index;`
443			`}`
444			`for(; index < 16; ++index)`
445			`printf(" ");`
446			`printf("%s\n", string);`
447			`}`
448	171	rhoads	`#endif //INCLUDE_DUMP`
449	149	rhoads
450
451	171	rhoads	`#ifdef INCLUDE_QSORT`
452			`/********************* qsort *********************/`
453			`static void QsortSwap(char *base, long left, long right, long size)`
454			`{`
455	249	rhoads	`int temp, i;`
456			`char ptrLeft, ptrRight;`
457			`ptrLeft = base + left * size;`
458			`ptrRight = base + right * size;`
459			`for(i = 0; i < size; ++i)`
460			`{`
461			`temp = ptrLeft[i];`
462			`ptrLeft[i] = ptrRight[i];`
463			`ptrRight[i] = (char)temp;`
464			`}`
465	171	rhoads	`}`
466	149	rhoads
467	171	rhoads
468			`//Modified from K&R`
469			`static void qsort2(void *base, long left, long right, long size,`
470			`int (cmp)(const void ,const void *))`
471			`{`
472			`int i, last;`
473	187	rhoads	`char base2=(char)base, *pivot;`
474	171	rhoads	`if(left >= right)`
475			`return;`
476			`QsortSwap(base2, left, (left + right)/2, size);`
477			`last = left;`
478	187	rhoads	`pivot = &base2[left*size];`
479	171	rhoads	`for(i = left + 1; i <= right; ++i)`
480			`{`
481	187	rhoads	`if(cmp(&base2[i*size], pivot) < 0)`
482	171	rhoads	`QsortSwap(base2, ++last, i, size);`
483			`}`
484			`QsortSwap(base2, left, last, size);`
485			`qsort2(base, left, last-1, size, cmp);`
486			`qsort2(base, last+1, right, size, cmp);`
487			`}`
488
489
490			`void qsort(void *base,`
491			`long n,`
492			`long size,`
493			`int (cmp)(const void ,const void *))`
494			`{`
495			`qsort2(base, 0, n-1, size, cmp);`
496			`}`
497
498
499			`void bsearch(const void key,`
500			`const void *base,`

Browse

Tools

Subversion Repositories plasma

[/] [plasma/] [trunk/] [kernel/] [libc.c] - Blame information for rev 436