void vmm_print_list(list_type *list)
{
put_str("\nlist=");
put_hex((u32int) list);
put_str(" first=");
put_hex((u32int) list->first);
put_str(" last=");
put_hex((u32int) list->last);
if (list->first != NULL)
{
list_node_type *current = list->first;
do
{
vmm_print_node(current);
current = current->next;
} while (current != NULL);
}
else
{
put_str("\nEmpty list.");
}
put_str("\n");
}
int main()
{
load_default_font();
put_string("Lo", 0, 2);
put_hex(&__huc_rodata, 4, 0, 3);
put_hex(&__huc_rodata_end, 4, 5, 3);
put_hex(&__huc_data, 4, 10, 3);
put_number(a, 5, 15, 3);
for(;;);
}
int main(int argc, char const* const* argv) {
put("argc = "); put_long(argc); put("\n");
for(int i = 0; i < argc; ++i) {
put("argv["); put_long(i); put("]="); put(argv[i]); put("\n");
}
put("__libc_csu_fini: "); put_hex(&__libc_csu_fini, sizeof(__libc_csu_fini)); put("\n");
put("__libc_csu_init: "); put_hex(&__libc_csu_init, sizeof(__libc_csu_init)); put("\n");
return 0;
}
void vmm_print_node(list_node_type *node)
{
print_node(node);
vmm_data_type *node_data = (vmm_data_type *) node->data;
put_str("\n\tnode_data=");
put_hex((u32int) node_data);
put_str(" virt_addr=");
put_hex(node_data->virt_addr);
put_str(" size=");
put_hex(node_data->size);
}
void check(unsigned int mem, unsigned int expected_val) {
if(mem == expected_val) {
putc('Y', vga);
put_hex(mem, vga + 2);
put_hex(expected_val, vga + 14);
vga += screen_width/4;
}
else {
deref(0xddd00000) = 0;
putc('N', vga);
put_hex(mem, vga + 2);
put_hex(expected_val, vga + 14);
vga += screen_width/4;
}
}
int16
command_dump (void)
{
put_string ("size: ");
put_hex (size, 2);
put_string ("\n");
dump (xmodem_recv_buffer_start_address, size);
return 0;
}
int main() {
char* vga = VMEM + screen_width*2 + 5;
unsigned val = 0xffff0001;
unsigned val2 = 0xaaaa0001;
unsigned addr = 0;
unsigned addr_step = 0x800;
union debug_que_entry dqe;
for (int i = 0; i < 6; ++i) {
deref(addr) = val;
deref(addr+16) = val2;
val += 1;
val2 += 1;
addr += addr_step;
}
addr = 0;
for (int i = 0; i < 6; ++i) {
put_hex(deref(addr+16), vga);
vga += screen_width/10;
put_hex(deref(addr), vga);
vga += screen_width/10;
vga += screen_width/10 * 8;
addr += addr_step;
}
vga += screen_width*2;
for (unsigned j = 0; j < (64 << 4); j += 16) {
dqe.part[3] = deref(0xd0000000 | j | (0 << 2));
dqe.part[2] = deref(0xd0000000 | j | (1 << 2));
dqe.part[1] = deref(0xd0000000 | j | (2 << 2));
dqe.part[0] = deref(0xd0000000 | j | (3 << 2));
put_hex(dqe.part[0], vga);
vga += screen_width/10;
put_hex(dqe.part[1], vga);
vga += screen_width/10;
put_hex(dqe.part[2], vga);
vga += screen_width/10;
put_hex(dqe.part[3], vga);
vga += screen_width/10 * 7;
if (j == (16 << 4) || j == (32 << 4) || j == (48 << 4)) {
vga += screen_width;
}
}
putc('N', vga++);
putc('I', vga++);
putc('C', vga++);
putc('E', vga++);
deref(0xdddd0000) = 0;
return 0;
}
int16
command_run (void)
{
int8 *entry_point;
void
(*f) (void);
entry_point = elf_load (xmodem_recv_buffer_start_address);
if (!entry_point)
{
put_string ("run error!\n");
}
else
{
put_string ("starting from entry point:");
put_hex ((uint32) entry_point, 6);
put_string ("\n");
put_string ("\n");
f = (void
(*) (void)) entry_point;
f ();
}
return 0;
}
int hb_vsnprintf( char * buffer, size_t bufsize, const char * format, va_list ap )
{
va_list args;
size_t size;
char c;
#ifndef __NO_ARGPOS__
const char * fmt_start = format;
v_param argbuf[ _ARGBUF_SIZE ];
v_paramlst params;
params.size = _ARGBUF_SIZE;
params.maxarg = 0;
params.arglst = argbuf;
#endif
#ifndef __NO_ARGPOS__
do
{
params.repeat = HB_FALSE;
if( params.maxarg > 0 )
{
va_copy( args, ap );
va_arg_fill( ¶ms, args );
va_end( args );
}
format = fmt_start;
#endif
va_copy( args, ap );
size = 0;
do
{
c = *format++;
if( c == '%' )
{
const char * pattern = format;
c = *format++;
if( c != 0 && c != '%' )
{
/* decode pattern */
v_param argval;
int param = 0, flags = 0, width = -1, precision = -1, length,
value, stop = 0;
/* parameter position */
if( c >= '0' && c <= '9' )
{
c = get_decimal( c, &format, &value );
if( c == '$' )
param = value;
else
format = pattern;
c = *format++;
}
/* flags */
while( ! stop )
{
switch( c )
{
case '#':
flags |= _F_ALTERNATE;
c = *format++;
break;
case '0':
flags |= _F_ZEROPADED;
c = *format++;
break;
case '-':
flags |= _F_LEFTADJUSTED;
c = *format++;
break;
case ' ':
flags |= _F_SPACE;
c = *format++;
break;
case '+':
flags |= _F_SIGN;
c = *format++;
break;
#ifdef _SUSV2_COMPAT_
case '\'': /* group with locale thousands' grouping characters */
c = *format++;
break;
#endif
default:
stop = 1;
break;
}
}
/* field width */
if( c == '*' )
{
c = *format++;
if( c >= '0' && c <= '9' )
{
c = get_decimal( c, &format, &value );
if( c == '$' )
{
width = va_arg_n( args, _x_int, value );
c = *format++;
}
/* else error, wrong format */
}
else
width = va_arg_n( args, _x_int, 0 );
}
else if( c >= '0' && c <= '9' )
c = get_decimal( c, &format, &width );
/* precision */
if( c == '.' )
{
precision = 0;
c = *format++;
if( c == '*' )
{
c = *format++;
if( c >= '0' && c <= '9' )
{
c = get_decimal( c, &format, &value );
if( c == '$' )
{
precision = va_arg_n( args, _x_int, value );
c = *format++;
}
/* else error, wrong format */
}
else
precision = va_arg_n( args, _x_int, 0 );
}
else if( c >= '0' && c <= '9' )
c = get_decimal( c, &format, &precision );
}
/* length modifier */
switch( c )
{
case 'h':
c = *format++;
if( c == 'h' )
{
length = _L_CHAR_;
c = *format++;
}
else
length = _L_SHORT_;
break;
case 'l':
c = *format++;
if( c == 'l' )
{
length = _L_LONGLONG_;
c = *format++;
}
else
length = _L_LONG_;
break;
case 'L':
length = _L_LONGDOUBLE_;
c = *format++;
break;
case 'j':
length = _L_INTMAX_;
c = *format++;
break;
case 'z':
length = _L_SIZE_;
c = *format++;
break;
case 't':
length = _L_PTRDIFF_;
c = *format++;
break;
case 'I': /* MS-Windows extension */
if( format[ 0 ] == '6' && format[ 1 ] == '4' )
{
length = _L_LONGLONG_;
format += 2;
c = *format++;
break;
}
else if( format[ 0 ] == '1' && format[ 1 ] == '6' )
{
length = _L_SHORT_;
format += 2;
c = *format++;
break;
}
else if( format[ 0 ] == '3' && format[ 1 ] == '2' )
{
format += 2;
c = *format++;
}
/* no break; */
default:
length = _L_UNDEF_;
break;
}
/* conversion specifier */
switch( c )
{
#ifndef __NO_DOUBLE__
case 'a':
case 'A':
case 'e':
case 'E':
case 'g':
case 'G':
/* redirect above conversion to 'f' or 'F' type to keep
* valid parameters order
*/
c = ( c == 'a' || c == 'e' || c == 'g' ) ? 'f' : 'F';
/* no break; */
case 'f': /* double decimal notation */
case 'F': /* double decimal notation */
if( length == _L_LONGDOUBLE_ )
{
argval.value.as_x_long_dbl = va_arg_n( args, _x_long_dbl, param );
HB_NUMTYPEL( value, argval.value.as_x_long_dbl );
}
else
{
double d = va_arg_n( args, _x_double, param );
HB_NUMTYPE( value, d );
argval.value.as_x_long_dbl =
( value & ( _HB_NUM_NAN | _HB_NUM_PINF | _HB_NUM_NINF ) ) == 0 ? d : 0;
}
if( value & _HB_NUM_NAN )
size = put_str( buffer, bufsize, size,
c == 'f' ?
( flags & _F_SIGN ? "+nan": "nan" ) :
( flags & _F_SIGN ? "+NAN": "NAN" ) ,
flags, width, -1 );
else if( value & _HB_NUM_PINF )
size = put_str( buffer, bufsize, size,
c == 'f' ?
( flags & _F_SIGN ? "+inf": "inf" ) :
( flags & _F_SIGN ? "+INF": "INF" ),
flags, width, -1 );
else if( value & _HB_NUM_NINF )
size = put_str( buffer, bufsize, size,
c == 'f' ? "-inf" : "-INF",
flags, width, -1 );
else
size = put_dbl( buffer, bufsize, size, argval.value.as_x_long_dbl,
flags, width, precision );
continue;
#endif
case 'd':
case 'i': /* signed int decimal conversion */
if( length == _L_CHAR_ )
argval.value.as_x_intmax_t = ( unsigned char ) va_arg_n( args, _x_int, param );
else if( length == _L_SHORT_ )
argval.value.as_x_intmax_t = ( unsigned short ) va_arg_n( args, _x_int, param );
else if( length == _L_LONG_ )
argval.value.as_x_intmax_t = va_arg_n( args, _x_long, param );
else if( length == _L_LONGLONG_ )
argval.value.as_x_intmax_t = va_arg_n( args, _x_longlong, param );
else if( length == _L_INTMAX_ )
argval.value.as_x_intmax_t = va_arg_n( args, _x_intmax_t, param );
else if( length == _L_SIZE_ )
argval.value.as_x_intmax_t = va_arg_n( args, _x_size_t, param );
else if( length == _L_PTRDIFF_ )
argval.value.as_x_intmax_t = va_arg_n( args, _x_ptrdiff_t, param );
else
argval.value.as_x_intmax_t = va_arg_n( args, _x_int, param );
value = argval.value.as_x_intmax_t < 0;
argval.value.as_x_uintmax_t = value ? -argval.value.as_x_intmax_t :
argval.value.as_x_intmax_t;
size = put_dec( buffer, bufsize, size, argval.value.as_x_uintmax_t,
flags, width, precision, value );
continue;
case 'o': /* unsigned int octal conversion */
case 'u': /* unsigned int decimal conversion */
case 'x': /* unsigned int hexadecimal conversion */
case 'X': /* unsigned int hexadecimal conversion */
if( length == _L_CHAR_ )
argval.value.as_x_uintmax_t = ( unsigned char ) va_arg_n( args, _x_int, param );
else if( length == _L_SHORT_ )
argval.value.as_x_uintmax_t = ( unsigned short ) va_arg_n( args, _x_int, param );
else if( length == _L_LONG_ )
argval.value.as_x_uintmax_t = va_arg_n( args, _x_ulong, param );
else if( length == _L_LONGLONG_ )
argval.value.as_x_uintmax_t = va_arg_n( args, _x_ulonglong, param );
else if( length == _L_INTMAX_ )
argval.value.as_x_uintmax_t = va_arg_n( args, _x_uintmax_t, param );
else if( length == _L_SIZE_ )
argval.value.as_x_uintmax_t = va_arg_n( args, _x_size_t, param );
else if( length == _L_PTRDIFF_ )
argval.value.as_x_uintmax_t = va_arg_n( args, _x_ptrdiff_t, param );
else
argval.value.as_x_uintmax_t = va_arg_n( args, _x_uint, param );
if( c == 'o' )
size = put_octal( buffer, bufsize, size, argval.value.as_x_uintmax_t,
flags, width, precision );
else if( c == 'u' )
size = put_dec( buffer, bufsize, size, argval.value.as_x_uintmax_t,
flags & ~( _F_SPACE | _F_SIGN ),
width, precision, 0 );
else
size = put_hex( buffer, bufsize, size, argval.value.as_x_uintmax_t,
flags, width, precision, c == 'X' );
continue;
case 'p': /* void * pointer */
argval.value.as_x_ptr = va_arg_n( args, _x_ptr, param );
if( argval.value.as_x_ptr )
size = put_hex( buffer, bufsize, size, ( HB_PTRUINT ) argval.value.as_x_ptr,
flags | _F_ALTERNATE, width, precision, 0 );
else
size = put_str( buffer, bufsize, size, "(nil)",
flags, width, -1 );
continue;
case 'c': /* signed int casted to unsigned char */
if( ( flags & _F_LEFTADJUSTED ) == 0 )
{
while( --width > 0 )
{
if( size < bufsize )
buffer[ size ] = ' ';
++size;
}
}
c = ( unsigned char ) va_arg_n( args, _x_int, param );
if( size < bufsize )
buffer[ size ] = c;
++size;
while( --width > 0 )
{
if( size < bufsize )
buffer[ size ] = ' ';
++size;
}
continue;
case 's': /* const char * */
if( length == _L_LONG_ )
{
argval.value.as_x_wstr = va_arg_n( args, _x_wstr, param );
size = put_wstr( buffer, bufsize, size, argval.value.as_x_wstr,
flags, width, precision );
}
else
{
argval.value.as_x_str = va_arg_n( args, _x_str, param );
size = put_str( buffer, bufsize, size, argval.value.as_x_str,
flags, width, precision );
}
continue;
case 'n': /* store current result size in int * arg */
/* This is very danger feature in *printf() functions
* family very often used by hackers to create buffer
* overflows. It can also cause unintentional memory
* corruption by programmers typo in pattern so if it's
* not strictly necessary it's good to disable it.
*/
*( va_arg_n( args, _x_intptr, param ) ) = ( int ) size;
continue;
case '%': /* store % consuming arguments % */
break;
default: /* error, wrong format, store pattern */
format = pattern;
c = '%';
break;
}
}
}
/* ISO C99 defines that when size is 0 and buffer is NULL we should
* return number of characters that would have been written in case
* the output string has been large enough without trailing 0.
* Many implementations always returns number of characters necessary
* to hold the string even if the above condition is not true so the
* returned value can be used to check if buffer was large enough
* and if not to allocate bigger buffer. Let's do the same.
*/
if( size < bufsize )
buffer[ size ] = c;
++size;
}
while( c != 0 );
va_end( args );
#ifndef __NO_ARGPOS__
}
while( params.repeat );
if( params.arglst != argbuf )
hb_xfree( params.arglst );
#endif
/* always set trailing \0 !!! */
if( bufsize )
buffer[ bufsize - 1 ] = 0;
return ( int ) ( size - 1 );
}
int
main(int argc, char **argv)
{
unsigned char bufA[PIPE_MAX], bufB[PIPE_MAX], *bp, *bp1, *bp2;
int tail_nr;
int nbuf = 0;
char hex[65];
#if PIPE_MAX < 32
"this compilation error means that PIPE_MAX < 32 bytes"
#endif
if (argc != 1)
die(EXIT_BAD_ARGC, "wrong number of command line arguments");
(void)argv;
// read exactly PIPE_MAX bytes or read the tail of the blob,
// alternating between bufA and bufB.
bp = bufA;
while (fill(bp, &tail_nr)) {
nbuf++;
if (bp == bufA)
bp = bufB;
else
bp = bufA;
}
bp = (bp == bufA ? bufB : bufA);
// final read() of blob got at least 32 bytes
if (tail_nr >= 32)
put_hex(hex, bp + tail_nr - 32, 32);
// zero length blob
if (nbuf == 0)
_exit(0);
// total blob size < 32 bytes
if (nbuf == 1)
put_hex(hex, bp, tail_nr);
// we now know that the suffix will be exactly 32 bytes.
// is the suffix entirely in the previous block
if (tail_nr == PIPE_MAX)
put_hex(hex, bp + PIPE_MAX - 32, 32);
// tail block was read less than PIPE_MAX bytes, so 32 byte suffix
// spans final two chunks, where the length of tail chunk is 0 <&&< 32
// bytes and that the length of previous chunk is exactly PIPE_MAX
// bytes.
if (bp == bufA) {
bp1 = bufB;
bp2 = bufA;
} else {
bp1 = bufA;
bp2 = bufB;
}
byte2hex(hex, bp1 + (PIPE_MAX - (32 - tail_nr)), 32 - tail_nr);
byte2hex(hex + (64 - tail_nr * 2), bp2, tail_nr);
hex[64] = '\n';
_write(1, hex, 65);
_exit(0);
}
int main() {
char* vga = VMEM + screen_width*2 + 5;
unsigned val = 0xffff0001;
unsigned addr = 0;
unsigned addr_step = 0x800;
union debug_que_entry dqe;
for (int i = 0; i < 6; ++i) {
deref(addr) = val;
val += 1;
addr += addr_step;
}
addr = 0;
val = 0xffff0001;
for (int i = 0; i < 6; ++i) {
unsigned test_read = deref(addr);
if (test_read != val) {
putc('N', vga);
vga += 2;
put_hex(addr, vga);
put_hex(test_read, vga + 16);
unsigned start = deref(start_reg);
unsigned end = deref(end_reg);
if (end < start) {
end += 64; // round up
}
put_hex(start, vga + 32);
put_hex(end, vga + 48);
vga += 2*screen_width;
for (unsigned j = 0; j < (64 << 4); j += 16) {
dqe.part[3] = deref(0xd0000000 | j | (0 << 2));
dqe.part[2] = deref(0xd0000000 | j | (1 << 2));
dqe.part[1] = deref(0xd0000000 | j | (2 << 2));
dqe.part[0] = deref(0xd0000000 | j | (3 << 2));
put_hex(dqe.part[0], vga);
vga += screen_width/10;
put_hex(dqe.part[1], vga);
vga += screen_width/10;
put_hex(dqe.part[2], vga);
vga += screen_width/10;
put_hex(dqe.part[3], vga);
vga += screen_width/10 * 7;
if (j == (16 << 4) || j == (32 << 4) || j == (48 << 4)) {
vga += screen_width;
}
}
vga += screen_width*2;
break;
}
val += 1;
addr += addr_step;
}
putc('N', vga++);
putc('I', vga++);
putc('C', vga++);
putc('E', vga++);
deref(0xdddd0000) = 0;
return 0;
}
