blob: 3a3972771083e8cb8fa0ee8d46276d483d7049ba [file] [log] [blame]
/*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file "COPYING" in the main directory of this archive
* for more details.
*
* Copyright (C) Hewlett-Packard (Paul Bame) paul_bame@hp.com
*/
#include "bootloader.h"
void
blockprint(__u64 zero_offset, char *buf, int nbytes)
{
int i;
for (i = 0; i < nbytes; i += 16)
{
int j;
printf("%lld:", zero_offset + i);
for (j = 0; j < 16; j++)
{
printf(" %02x", buf[i + j] & 0xff);
}
printf("\r\n");
}
}
static char *__free = 0;
char *malloc_aligned(int nbytes, int align)
{
/* allocate */
__free -= nbytes;
/* align */
__free = (char *)(((unsigned)__free) & ~(align - 1));
if (0) printf("malloc_aligned(%d) = %x\n", nbytes, (unsigned) __free);
return __free;
}
void *malloc(size_t nbytes)
{
return malloc_aligned(nbytes, 8);
}
void *calloc(unsigned nitems, unsigned size)
{
unsigned l = nitems * size;
void *p = malloc(l);
memset(p, 0, l);
return p;
}
void mark (void **ptr)
{
*ptr = (void *) __free;
}
void release (void *ptr)
{
__free = (char *) ptr;
}
void malloc_init(char *free)
{
__free = free;
}
/* some of these are lifted from linux/lib */
char * strpbrk(const char * cs,const char * ct)
{
const char *sc1,*sc2;
for( sc1 = cs; *sc1 != '\0'; ++sc1) {
for( sc2 = ct; *sc2 != '\0'; ++sc2) {
if (*sc1 == *sc2)
return (char *) sc1;
}
}
return NULL;
}
size_t strspn(const char *s, const char *accept)
{
const char *p;
const char *a;
size_t count = 0;
for (p = s; *p != '\0'; ++p) {
for (a = accept; *a != '\0'; ++a) {
if (*p == *a)
break;
}
if (*a == '\0')
return count;
++count;
}
return count;
}
char * strtok(char * s,const char * ct)
{
char *sbegin, *send;
static char * ___strtok = NULL;
sbegin = s ? s : ___strtok;
if (!sbegin) {
return NULL;
}
sbegin += strspn(sbegin,ct);
if (*sbegin == '\0') {
___strtok = NULL;
return( NULL );
}
send = strpbrk( sbegin, ct);
if (send && *send != '\0')
*send++ = '\0';
___strtok = send;
return (sbegin);
}
int strncmp(const char * cs,const char * ct,size_t count)
{
register signed char __res = 0;
while (count) {
if ((__res = *cs - *ct++) != 0 || !*cs++)
break;
count--;
}
return __res;
}
void * memset(void * s,int c,size_t count)
{
char *xs = (char *) s;
while (count--)
*xs++ = c;
return s;
}
int streq(const char *a, const char *b)
{
if (a == b)
return 1;
while (*a != '\0' && *b != '\0' && *a++ == *b++)
{
}
return *a == '\0' && *b == '\0';
}
char *strcpy(char *dest, const char *src)
{
char *savedest = dest;
while((*dest++ = *src++));
return savedest;
}
char *strcat(char *dest, const char *src)
{
char *savedest = dest;
/* go to end of 'dest' string */
while (*dest != '\0')
dest++;
strcpy(dest, src);
return savedest;
}
int memcmp(const void * cs,const void * ct,size_t count)
{
const unsigned char *su1, *su2;
signed char res = 0;
for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
if ((res = *su1 - *su2) != 0)
break;
return res;
}
char * strstr(const char * s1,const char * s2)
{
int l1, l2;
l2 = strlen(s2);
if (!l2)
return (char *) s1;
l1 = strlen(s1);
while (l1 >= l2) {
l1--;
if (!memcmp(s1,s2,l2))
return (char *) s1;
s1++;
}
return NULL;
}
void bzero(char *p, size_t len)
{
/* slow but safe */
while (len--)
*p++ = 0;
}
void *memcpy(void *d, const void *s, size_t len)
{
char *dest = (char *)d;
const char *source = (const char *)s;
while (len--)
*dest++ = *source++;
return d;
}
size_t strlen(const char * s)
{
const char *sc;
for (sc = s; *sc != '\0'; ++sc)
/* nothing */;
return sc - s;
}
size_t strnlen(const char * s, size_t count)
{
const char *sc;
for (sc = s; count-- && *sc != '\0'; ++sc)
/* nothing */;
return sc - s;
}
/* Copyright (C) 1999 Jason L. Eckhardt (jle@cygnus.com) */
char *enter_text(char *txt, int maxchars)
{
char c;
int pos;
for (pos = 0; txt[pos]; pos++); /* calculate no. of chars */
if (pos > maxchars) /* if input too long, shorten it */
{
pos = maxchars;
txt[pos] = '\0';
}
printf(txt); /* print initial text */
do
{
c = getchar();
if (c == 13)
{ /* CR -> finish! */
if (pos <= maxchars)
txt[pos] = 0;
else
txt[maxchars] = '\0';
return txt;
};
if (c == '\b' || c == 127 )
{ /* BS -> delete prev. char */
if (pos)
{
pos--;
c='\b';
putchar(c);
putchar(' ');
putchar(c);
}
} else if (c == 21)
{ /* CTRL-U */
while (pos)
{
pos--;
c='\b';
putchar(c);
putchar(' ');
putchar(c);
}
txt[0] = 0;
} else if ((pos < maxchars) && c >= ' ')
{
txt[pos] = c;
pos++;
putchar(c);
}
}
while (c != 13);
return txt;
}
/**
* strrchr - Find the last occurrence of a character in a string
* @s: The string to be searched
* @c: The character to search for
*/
char * strrchr(const char * s, int c)
{
const char *p = s + strlen(s);
do {
if (*p == (char)c)
return (char *)p;
} while (--p >= s);
return NULL;
}
/**
* strncpy - Copy a length-limited, %NUL-terminated string
* @dest: Where to copy the string to
* @src: Where to copy the string from
* @count: The maximum number of bytes to copy
*
* Note that unlike userspace strncpy, this does not %NUL-pad the buffer.
* However, the result is not %NUL-terminated if the source exceeds
* @count bytes.
*/
char * strncpy(char * dest,const char *src,size_t count)
{
char *tmp = dest;
while (count-- && (*dest++ = *src++) != '\0')
/* nothing */;
return tmp;
}
/**
* strchr - Find the first occurrence of a character in a string
* @s: The string to be searched
* @c: The character to search for
*/
char * strchr(const char * s, int c)
{
while (*s != (char)c) {
if (*s == '\0')
return NULL;
++s;
}
return (char *) s;
}