Subversion Repositories layer2

/******************************************************************************

 * Standard Library                                                           *

 ******************************************************************************

 * Copyright (C)2011  Mathias Hörtnagl <mathias.hoertnagl@gmail.com>          *

 *                                                                            *

 * This program is free software: you can redistribute it and/or modify       *

 * it under the terms of the GNU General Public License as published by       *

 * the Free Software Foundation, either version 3 of the License, or          *

 * (at your option) any later version.                                        *

 *                                                                            *

 * This program is distributed in the hope that it will be useful,            *

 * but WITHOUT ANY WARRANTY; without even the implied warranty of             *

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *

 * GNU General Public License for more details.                               *

 *                                                                            *

 * You should have received a copy of the GNU General Public License          *

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *

 ******************************************************************************/

#include "stddef.h"

#include "stdlib.h"

/******************************************************************************

 * Timer                                                                      *

 ******************************************************************************/

/* Resets the counter. If you call reset before the counter has finished, it

   returns the count progress. */

uint pit_reset() {

   return PIT_ADDRESS[0];

}

/* Set PIT limit and start counting. */

void pit_run(uint cycles) {

   PIT_ADDRESS[0] = cycles;

}

/******************************************************************************

 * RS-232                                                                     *

 ******************************************************************************/

/* Wait for one byte of data. Return n reception. */

uchar rs232_receive() {

   return RS232_ADDRESS[0];

}

/* Send one byte of data. */

void rs232_transmit(uchar chr) {

   RS232_ADDRESS[1] = chr;

}

/******************************************************************************

 * Memory Operations                                                          *

 ******************************************************************************/

void memcpy(const void *src, void *dst, uint len) {

   for(char *s = src, *d = dst; len-- > 0; *d++ = *s++);

}

void memset(const void *ptr, int val, uint len) {

   for(char *p = ptr; len-- > 0; *p++ = val);

}

// 

// int memcmp(const void *src, void *dst, uint len) {

   // for(char *s = src, *d = dst; len > 0; len--)

      // if(*s++ != *p++) return 1;

   // return 0;

// }

/******************************************************************************

 * String Operations                                                          *

 ******************************************************************************/

/* Returns the length of a string */

uint strlen(const uchar *str) {

   uint c = 0;

   for(uchar *s = str; *s++; c++);

   return c;

}

/* Copys a string at location src to location dst. */

void strcpy(const uchar *src, uchar *dst) {

   for(uchar *s = src, *d = dst; *d++ = *s++; );

}

/* Returns a pointer to the leftmost occurence of character chr in

   string str or NULL, if not found. */

uchar *strchr(const uchar *str, const uchar chr) {

   for(uchar *s = str; *s; s++)

      if(*s == chr) return *s;

   return NULL;

}

/******************************************************************************

 * Number/String Conversion                                                   *

 ******************************************************************************/

 /* Convert a string containing a decimal number into a number. */

int atoi(const uchar *str) {

   int num = 0;

   uchar sign;

   uchar *s = str;

   for(; !( isdigit(*s) || (*s == '-') ) && (*s != NULL); s++);

   sign = *s++;

   for(; isdigit(*s); s++)

      num = x10(num) + (*s-'0');

   return (sign == '-') ? -num : num;

}

/* Returns a binary representation of an integer <num>. The buffer <str> must be

   at least 35 byte wide to hold the char sequence of the form '0bn...n\0'. */

uchar* itob(int num, uchar *str) {

   uchar *s = str;

   uint p = 0x80000000;

   *s++ = '0';

   *s++ = 'b';

   //while( !(num & p) ) p >>= 1;

   while(p) {

      *s++ = (num & p) ? '1' : '0';

      p >>= 1;

   }

   *s = '\0';

   return str;

}

/* Returns a hexadecimal representation of an integer <num>. The buffer <str>

   must be at least 11 byte wide to hold the char sequence of the form

   '0xn...n\0'. */

uchar* itox(int num, uchar *str) {

   uchar *s = str;

   uchar n;

   uint p = 0xf0000000;

   *s++ = '0';

   *s++ = 'x';

   //while( !(num & p) ) p >>= 1;

   for(int i=28; i>=0; i-=4) {

      n = ((uint) num & p) >> i;

      if ( n <= 9 )

         *s++ = n + '0';

      else

         *s++ = n - 10 + 'a';

      p >>= 4;

   }

   *s = '\0';

   return str;

}

/******************************************************************************

 * Nathematics                                                                *

 ******************************************************************************/

static uint x = 314159265;

/* Xorshift RNGs, George Marsaglia

   http://www.jstatsoft.org/v08/i14/paper */

uint rand() {

  x ^= x << 13;

  x ^= x >> 17;

  x ^= x << 5;

  return x;

}

/* Radix-4 Booth Multiplication Algorithm */

int mul(short a, short b) {

   int r = 0;

   int ai = a << 1;

   for(int i=0; i++<16; ai>>=1, b<<=1)

      switch (ai & 3) {

         case 1: r += b; break;

         case 2: r -= b; break;

      }

   return r;

}

short div(int a, int b) {

   char s = 0;

   short m = 0;

   if(a < 0) {

      s = 1;

      a = -a;

   }

   if(b < 0) {

      if(s == 1)

         s = 0;

      else

         s = 1;

      b = -b;

   }

   if(b == 0) {

      return 0;

   }

   while(a > b) {

      m++;

      a = a-b;

   }

   return m;

}