util.c

ks8695 loader > > > > > > > > > > > > >

/*****************************************
 Copyright (c) 2001-2002 
 Sigma Designs, Inc. All Rights Reserved
 Proprietary and Confidential
 *****************************************/

/* This file is part of the boot loader */

/*
 * util.c
 * 
 * utility functions
 *
 * first revision by Ho Lee 10/10/2002
 */

#include "util.h"

//
// ctype
//

int isspace(int ch)
{
	return (ch == '\r' || ch == '\n' || ch == ' ' || ch == '\t') ? 1 : 0;
}

int isdigit(int ch)
{
	return (ch >= '0' && ch <= '9') ? 1 : 0;
}

//
// string
//

char *trim(char *str)
{
	char *cp = str;

	while (*cp != 0 && isspace(*cp))
		++cp;
	
	if (cp == str)
		cp += strlen(str) - 1;
	else {
		char *cpdes;
		for (cpdes = str; *cp != 0; )
			*cpdes++ = *cp++;
		cp = cpdes;
		*cp-- = 0;
	}

	while (cp > str && isspace(*cp))
		*cp-- = 0;

	return str;
}

int strlen(const char *str)
{
	int i;

	for (i = 0; str[i] != 0; ++i)
		;

	return i;
}

char *strcpy(char *dest, const char *src)
{
	int i;

	for (i = 0; src[i] != 0; ++i)
		dest[i] = src[i];
	dest[i] = 0;
		
	return dest;
}

char *strncpy(char *dest, const char *src, int n)
{
	int i;

	for (i = 0; src[i] != 0 && i < (n - 1); ++i)
		dest[i] = src[i];
	dest[i] = src[i];

	return dest;
}

char *strncpy0(char *dest, const char *src, int n)
{
	int i;

	for (i = 0; src[i] != 0 && i < (n - 1); ++i)
		dest[i] = src[i];
	dest[i] = 0;

	return dest;
}

int strcmp(const char *str1, const char *str2)
{
	int i;

	for (i = 0; (str1[i] == str2[i]) && (str1[i] != 0); ++i)
		;
	
	return str1[i] - str2[i];
}

int strncmp(const char *str1, const char *str2, int num)
{
	int i;

	for (i = 0; (i < num - 1) && (str1[i] == str2[i]) && (str1[i] != 0); ++i)
		;
	
	return str1[i] - str2[i];
}

char *strchr(const char *str, char ch)
{
	int i;

	for (i = 0; str[i] != 0; ++i)
		if (str[i] == ch)
			return (char *) (str + i);

	return NULL;
}

char *strtok(char *str, const char *token)
{
	static char *s_last = NULL;
	int i;

	if (str == NULL)
		str = s_last;
	if (str == NULL)
		return NULL;

	for (i = 0; str[i] != 0; ++i) 
		if (strchr(token, str[i]) != NULL)
			break;

	if (str[i] != 0)
		str[i++] = 0;

	for (; str[i] != 0; ++i)
		if (strchr(token, str[i]) == NULL)
			break;

	s_last = (str[i] == 0) ? NULL : str + i;

	return str;
}

// 
// stdlib
//

unsigned int atoi(const char *str)
{
	const char *cp;
	unsigned int data;

	if (str[0] == '0' && (str[1] == 'X' || str[1] == 'x'))
		return htoi(str + 2);
	
	for (cp = str, data = 0; *cp != 0; ++cp) {
		if (*cp >= '0' && *cp <= '9')
			data = data * 10 + *cp - '0';
		else
			break;
	}

	return data;
}

unsigned int htoi(const char *str)
{
	const char *cp;
	unsigned int data, bdata;

	for (cp = str, data = 0; *cp != 0; ++cp) {
		if (*cp >= '0' && *cp <= '9')
			bdata = *cp - '0';
		else if (*cp >= 'A' && *cp <= 'F')
			bdata = *cp - 'A' + 10;
		else if (*cp >= 'a' && *cp <= 'f')
			bdata = *cp - 'a' + 10;
		else
			break;
		data = (data << 4) | bdata;
	}

	return data;
}

void memcpy(void *to, const void *from, unsigned long n)
{
#if 0	
	// brute-force copying

	int i;
	unsigned char *_to = (unsigned char *) to;
	unsigned char *_from = (unsigned char *) from;
	
	for (i = 0; i < n; ++i)
		_to[i] = _from[i];
#else	
	// copy based on alignment of source and target
	// copy is fast when the source and destination have the same alignment 
	//   and the both are 4-byte aligned
	// alignment difference : 
	//   0 : copy_4
	//   1, 3 : copy_1
	//   2 : copy_2

	unsigned char *_to = (unsigned char *) to;
	unsigned char *_from = (unsigned char *) from;
	int align_to, align_from;
	unsigned int i, x, y, z;

	if (n < 8)
		goto copy_1;
	
	align_to = ((unsigned int) to) & 0x03;
	align_from = ((unsigned int) from) & 0x03;

	if (align_to == align_from) {
		x = (align_to) ? 4 - align_to : 0;
		n -= x;
		y = n >> 2;
		z = n & 0x03;
		goto copy_4;
	} else {
		if ((align_to & 0x01) == (align_from & 0x01)) {
			x = (align_to & 0x01);
			n -= x;
			y = n >> 1;
			z = n & 0x01;
			goto copy_2;
		} else
			goto copy_1;
	}
		
copy_4:
	while (x--)
		*_to++ = *_from++;
	if (y) {
		unsigned int *__to = (unsigned int *) _to;
		unsigned int *__from = (unsigned int *) _from;
		for (i = 0; i < y; ++i)
			__to[i] = __from[i];
		_to += (y << 2);
		_from += (y << 2);
	}
	while (z--)
		*_to++ = *_from++;
	goto copy_return;

copy_2:
	while (x--)
		*_to++ = *_from++;
	if (y) {
		unsigned short *__to = (unsigned short *) _to;
		unsigned short *__from = (unsigned short *) _from;
		for (i = 0; i < y; ++i)
			__to[i] = __from[i];
		_to += (y << 1);
		_from += (y << 1);
	}
	while (z--)
		*_to++ = *_from++;
	goto copy_return;

copy_1:
	for (i = 0; i < n; ++i)
		_to[i] = _from[i];

copy_return:
#endif
}

int memcmp(const void *ptr1, const void *ptr2, unsigned long n)
{
	int i;
	
	unsigned char *_ptr1 = (unsigned char *) ptr1;
	unsigned char *_ptr2 = (unsigned char *) ptr2;

	if (n == 0)
		return 0;

	for (i = 0; i < (n - 1) && _ptr1[i] == _ptr2[i]; ++i)
		;

	return _ptr1[i] - _ptr2[i];
}

void memset(void *ptr, unsigned char value, unsigned long n)
{
#if 0
	int i;
	unsigned char *_ptr = (unsigned char *) ptr;
	
	for (i = 0; i < n; ++i)
		_ptr[i] = 0;
#else
	unsigned char *_ptr = (unsigned char *) ptr;
	int align;
	unsigned int i, x, y, z;

	if (n < 8)
		goto memset_1;
	
	align = ((unsigned int) ptr) & 0x03;

	x = (align) ? 4 - align : 0;
	n -= x;
	y = n >> 2;
	z = n & 0x03;

	while (x--)
		*_ptr++ = value;
	if (y) {
		unsigned int *__ptr = (unsigned int *) _ptr;
		unsigned int value4 = (value) | (value << 8) | (value << 16) | (value << 24);
		for (i = 0; i < y; ++i)
			__ptr[i] = value4;
		_ptr += (y << 2);
	}
	while (z--)
		*_ptr++ = value;
	return;

memset_1:
	for (i = 0; i < n; ++i)
		_ptr[i] = value;
	return;
#endif
}

/*
//
// Miscellaneous
//

// decode ip address or MAC address string to series of number
// retrun :
//   0 : valid address
//   non-zero : invalid address
int parse_netaddr(char *str, unsigned char *addr, int len)
{
	int i, j, value;
	char *cp;
		
	trim(str);
	cp = strtok(str, ".:");
	
	for (i = 0; i < len && cp != NULL; ++i) {
		for (j = 0; cp[j] != 0; ++j)
			if (!isdigit(cp[j]))
				return 1;
		value = atoi(cp);
		if (value < 0 || value >= 0x100)
			return 1;
		addr[i] = (unsigned char) value;
		cp = strtok(NULL, ".");
	}
	
	return (i == len && cp == NULL) ? 0 : 1;
}

int parse_ipaddr(char *str, unsigned int *ipaddr)
{
	unsigned int addr;
	unsigned char *cp = (unsigned char *) &addr;
	
	if (parse_netaddr(str, cp, 4) == 0) {
		*ipaddr = ntohl(addr);
		return 0;
	}

	return 1;
}

#include "vsprintf.h"
char *ipaddr_to_str(unsigned int ipaddr)
{
	static char s_buf[16];
	
	unsigned int addr = htonl(ipaddr);
	unsigned char *cp = (unsigned char *) &addr;

	sprintf(s_buf, "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);

	return s_buf;
}
*/