* Common Library Functions
*/
#include <acess.h>
+#include <hal_proc.h>
// === CONSTANTS ===
#define RANDOM_SEED 0xACE55052
EXPORT(strlen);
EXPORT(strcpy);
EXPORT(strncpy);
+EXPORT(strcat);
+EXPORT(strncat);
EXPORT(strcmp);
EXPORT(strncmp);
//EXPORT(strdup);
EXPORT(ModUtil_LookupString);
EXPORT(ModUtil_SetIdent);
EXPORT(UnHex);
+EXPORT(SwapEndian16);
+EXPORT(SwapEndian32);
+EXPORT(memmove);
// === CODE ===
/**
{
char tmpBuf[64+1];
int pos=0, i;
+ Uint64 rem;
// Sanity check
if(!buf) return;
// Convert
while(num > base-1) {
- tmpBuf[pos] = cUCDIGITS[ num % base ];
- num /= (Uint)base; // Shift `num` right 1 digit
+ num = DivMod64U(num, base, &rem); // Shift `num` and get remainder
+ tmpBuf[pos] = cUCDIGITS[ rem ];
pos++;
}
- tmpBuf[pos++] = cUCDIGITS[ num % base ]; // Last digit of `num`
+ tmpBuf[pos++] = cUCDIGITS[ num ]; // Last digit of `num`
// Put in reverse
i = 0;
}
}
else
- minSize = 1;
+ minSize = 0;
// - Precision
precision = -1;
}
itoa(tmpBuf, val, 10, minSize, pad);
goto printString;
- case 'u':
+ case 'u': // Unsigned
GETVAL();
itoa(tmpBuf, val, 10, minSize, pad);
goto printString;
- case 'X':
+ case 'P': // Physical Address
+ PUTCH('0');
+ PUTCH('x');
+ if(sizeof(tPAddr) > 4) isLongLong = 1;
+ GETVAL();
+ itoa(tmpBuf, val, 16, minSize, pad);
+ goto printString;
+ case 'X': // Hex
if(BITS == 64)
isLongLong = 1; // TODO: Handle non-x86 64-bit archs
GETVAL();
itoa(tmpBuf, val, 16, minSize, pad);
goto printString;
- case 'x':
+ case 'x': // Lower case hex
GETVAL();
itoa(tmpBuf, val, 16, minSize, pad);
goto printString;
- case 'o':
+ case 'o': // Octal
GETVAL();
itoa(tmpBuf, val, 8, minSize, pad);
goto printString;
// String - Null Terminated Array
case 's':
p = va_arg(args, char*); // Get Argument
- if( !CheckString(p) ) p = "(inval)"; // Avoid #PFs
+ if( !p || !CheckString(p) ) p = "(inval)"; // Avoid #PFs
printString:
if(!p) p = "(null)";
len = strlen(p);
}
/**
- * \fn char *strcpy(char *__str1, const char *__str2)
* \brief Copy a string to a new location
*/
char *strcpy(char *__str1, const char *__str2)
}
/**
- * \fn char *strncpy(char *__str1, const char *__str2, size_t max)
* \brief Copy a string to a new location
+ * \note Copies at most `max` chars
*/
-char *strncpy(char *__str1, const char *__str2, size_t max)
+char *strncpy(char *__str1, const char *__str2, size_t __max)
{
- while(*__str2 && max-- >= 1)
+ while(*__str2 && __max-- >= 1)
*__str1++ = *__str2++;
- if(max)
+ if(__max)
*__str1 = '\0'; // Terminate String
return __str1;
}
+/**
+ * \brief Append a string to another
+ */
+char *strcat(char *__dest, const char *__src)
+{
+ while(*__dest++);
+ __dest--;
+ while(*__src)
+ *__dest++ = *__src++;
+ *__dest = '\0';
+ return __dest;
+}
+
+/**
+ * \brief Append at most \a n chars to a string from another
+ * \note At most n+1 chars are written (the dest is always zero terminated)
+ */
+char *strncat(char *__dest, const char *__src, size_t n)
+{
+ while(*__dest++);
+ while(*__src && n-- >= 1)
+ *__dest++ = *__src++;
+ *__dest = '\0';
+ return __dest;
+}
+
/**
* \fn int strcmp(const char *str1, const char *str2)
* \brief Compare two strings return the difference between
{
// ASCII
if( Val < 128 ) {
- *str = Val;
+ if( str ) {
+ *str = Val;
+ }
return 1;
}
// Two Byte
if( Val < 0x8000 ) {
- *str = 0xC0 | (Val >> 6);
- str ++;
- *str = 0x80 | (Val & 0x3F);
+ if( str ) {
+ *str++ = 0xC0 | (Val >> 6);
+ *str++ = 0x80 | (Val & 0x3F);
+ }
return 2;
}
// Three Byte
if( Val < 0x10000 ) {
- *str = 0xE0 | (Val >> 12);
- str ++;
- *str = 0x80 | ((Val >> 6) & 0x3F);
- str ++;
- *str = 0x80 | (Val & 0x3F);
+ if( str ) {
+ *str++ = 0xE0 | (Val >> 12);
+ *str++ = 0x80 | ((Val >> 6) & 0x3F);
+ *str++ = 0x80 | (Val & 0x3F);
+ }
return 3;
}
// Four Byte
if( Val < 0x110000 ) {
- *str = 0xF0 | (Val >> 18);
- str ++;
- *str = 0x80 | ((Val >> 12) & 0x3F);
- str ++;
- *str = 0x80 | ((Val >> 6) & 0x3F);
- str ++;
- *str = 0x80 | (Val & 0x3F);
+ if( str ) {
+ *str++ = 0xF0 | (Val >> 18);
+ *str++ = 0x80 | ((Val >> 12) & 0x3F);
+ *str++ = 0x80 | ((Val >> 6) & 0x3F);
+ *str++ = 0x80 | (Val & 0x3F);
+ }
return 4;
}
*/
int CheckString(const char *String)
{
- if( !MM_GetPhysAddr( (tVAddr)String ) )
+ tVAddr addr;
+ int bUser;
+
+ addr = (tVAddr)String;
+
+ if( !MM_GetPhysAddr( addr ) )
return 0;
// Check 1st page
- if( MM_IsUser( (tVAddr)String ) )
+ bUser = MM_IsUser( addr );
+
+ while( *(char*)addr )
{
- // Traverse String
- while( *String )
+ if( (addr & (PAGE_SIZE-1)) == 0 )
{
- if( !MM_IsUser( (tVAddr)String ) )
+ if(bUser && !MM_IsUser(addr) )
return 0;
- // Increment string pointer
- String ++;
- }
- return 1;
- }
- else if( MM_GetPhysAddr( (tVAddr)String ) )
- {
- // Traverse String
- while( *String )
- {
- if( !MM_GetPhysAddr( (tVAddr)String ) )
+ if(!bUser && !MM_GetPhysAddr(addr) )
return 0;
- // Increment string pointer
- String ++;
}
- return 1;
+ addr ++;
}
- return 0;
+ return 1;
}
/**
* \brief Check if a sized memory region is valid memory
+ * \return Boolean success
*/
int CheckMem(const void *Mem, int NumBytes)
{
- tVAddr addr = (tVAddr)Mem;
-
- if( MM_IsUser( addr ) )
- {
- while( NumBytes-- )
- {
- if( !MM_IsUser( addr ) )
- return 0;
- addr ++;
- }
- return 1;
- }
- else if( MM_GetPhysAddr( addr ) )
- {
- while( NumBytes-- )
- {
- if( !MM_GetPhysAddr( addr ) )
- return 0;
- addr ++;
- }
- return 1;
- }
- return 0;
+ return MM_IsValidBuffer( (tVAddr)Mem, NumBytes );
}
/* *
* \}
/**
* \brief Convert a string of hexadecimal digits into a byte stream
*/
-int UnHex(Uint8 *Dest, size_t DestSize, const char *SourceString)
+int UnHex(Uint8 *Dest, size_t DestSize, const char *SourceString)
{
int i;
}
return i/2;
}
+
+Uint16 SwapEndian16(Uint16 Val)
+{
+ return ((Val&0xFF)<<8) | ((Val>>8)&0xFF);
+}
+Uint32 SwapEndian32(Uint32 Val)
+{
+ return ((Val&0xFF)<<24) | ((Val&0xFF00)<<8) | ((Val>>8)&0xFF00) | ((Val>>24)&0xFF);
+}
+
+void *memmove(void *__dest, const void *__src, size_t len)
+{
+ size_t block_size;
+ char *dest = __dest;
+ const char *src = __src;
+ void *ret = __dest;
+
+ if( len == 0 || dest == src )
+ return dest;
+
+ if( (tVAddr)dest > (tVAddr)src + len )
+ return memcpy(dest, src, len);
+ if( (tVAddr)dest + len < (tVAddr)src )
+ return memcpy(dest, src, len);
+
+ // NOTE: Assumes memcpy works forward
+ if( (tVAddr)dest < (tVAddr)src )
+ return memcpy(dest, src, len);
+
+ if( (tVAddr)dest < (tVAddr)src )
+ block_size = (tVAddr)src - (tVAddr)dest;
+ else
+ block_size = (tVAddr)dest - (tVAddr)src;
+
+ block_size &= ~0xF;
+
+ while(len >= block_size)
+ {
+ memcpy(dest, src, block_size);
+ len -= block_size;
+ dest += block_size;
+ src += block_size;
+ }
+ memcpy(dest, src, len);
+ return ret;
+
+}
+