int main(int argc, char **argv)
{
int ret, r2;
runcmd_init();
t_set_colors(0);
t_start("exec output comparison");
{
int i;
char *out = calloc(1, BUF_SIZE);
for (i = 0; cases[i].input != NULL; i++) {
memset(out, 0, BUF_SIZE);
int pfd[2] = {-1, -1}, pfderr[2] = {-1, -1};
int fd;
char *cmd;
asprintf(&cmd, "/bin/echo -n %s", cases[i].input);
fd = runcmd_open(cmd, pfd, pfderr, NULL);
read(pfd[0], out, BUF_SIZE);
ok_str(cases[i].output, out, "Echoing a command should give expected output");
close(pfd[0]);
close(pfderr[0]);
close(fd);
}
}
ret = t_end();
t_reset();
t_start("anomaly detection");
{
int i;
for (i = 0; anomaly[i].cmd; i++) {
int out_argc;
char *out_argv[256];
int result = runcmd_cmd2strv(anomaly[i].cmd, &out_argc, out_argv);
ok_int(result, anomaly[i].ret, anomaly[i].cmd);
}
}
r2 = t_end();
ret = r2 ? r2 : ret;
t_reset();
t_start("argument splitting");
{
int i;
for (i = 0; parse_case[i].cmd; i++) {
int x, out_argc;
char *out_argv[256];
int result = runcmd_cmd2strv(parse_case[i].cmd, &out_argc, out_argv);
out_argv[out_argc] = NULL;
ok_int(result, 0, parse_case[i].cmd);
ok_int(out_argc, parse_case[i].argc_exp, parse_case[i].cmd);
for (x = 0; x < parse_case[x].argc_exp && out_argv[x]; x++) {
ok_str(parse_case[i].argv_exp[x], out_argv[x], "argv comparison test");
}
}
}
r2 = t_end();
return r2 ? r2 : ret;
}
void meas_t(void) {
/* Measures the temperature and updates t_meas */
wr_tsens(0xCC); // Skip ROM
wr_tsens(0x44); // Convert T
if(rd_tsens()) { // If coversion is complete
t_err=t_reset();
wr_tsens(0xCC); // Skip ROM
wr_tsens(0xBE); // Read scratchpad
t_meas=rd_tsens();
t_err=t_reset();
}
}
void
serialize_test (char *buf, int len)
{
unsigned long time;
iks *x;
iksparser *prs;
char *xml;
int err;
prs = iks_dom_new (&x);
err = iks_parse (prs, buf, len, 1);
switch (err) {
case IKS_OK:
break;
case IKS_NOMEM:
exit (2);
case IKS_BADXML:
fprintf (stderr, "Invalid xml at byte %ld, line %ld\n",
iks_nr_bytes (prs), iks_nr_lines (prs));
exit (1);
case IKS_HOOK:
exit (1);
}
iks_parser_delete (prs);
t_reset ();
xml = iks_string (iks_stack (x), x);
time = t_elapsed ();
printf ("Serialize: serializing the tree took %ld milliseconds.\n", time);
iks_delete (x);
}
void dom_test (char *buf, int len)
{
int bs, i, err;
iksparser *prs;
unsigned long time;
iks *x;
size_t allocated, used;
bs = block_size;
if (0 == bs) bs = len;
t_reset ();
prs = iks_dom_new (&x);
iks_set_size_hint (prs, len);
i = 0;
while (i < len) {
if (i + bs > len) bs = len - i;
err = iks_parse (prs, buf + i, bs, 0);
switch (err) {
case IKS_OK:
break;
case IKS_NOMEM:
exit (2);
case IKS_BADXML:
fprintf (stderr, "Invalid xml at byte %ld, line %ld\n",
iks_nr_bytes (prs), iks_nr_lines (prs));
exit (1);
case IKS_HOOK:
exit (1);
}
i += bs;
}
time = t_elapsed ();
iks_stack_stat (iks_stack (x), &allocated, &used);
printf ("DOM: parsing and building the tree took %ld milliseconds.\n", time);
printf ("DOM: ikstack: %d bytes allocated, %d bytes used.\n", allocated, used);
t_reset ();
iks_delete (x);
time = t_elapsed ();
printf ("DOM: deleting the tree took %ld milliseconds.\n", time);
iks_parser_delete (prs);
}
void
devcntrl(FILE *fp) /* interpret device control functions */
{
char str[4096];
int n;
sget(str, sizeof str, fp);
switch (str[0]) { /* crude for now */
case 'i': /* initialize */
fileinit();
t_init(0);
break;
case 'T': /* device name */
sget(devname, sizeof devname, fp);
break;
case 't': /* trailer */
t_trailer();
break;
case 'p': /* pause -- can restart */
t_reset('p');
break;
case 's': /* stop */
t_reset('s');
break;
case 'r': /* resolution assumed when prepared */
fscanf(fp, "%d", &res);
break;
case 'f': /* font used */
fscanf(fp, "%d", &n);
sget(str, sizeof str, fp);
loadfont(n, str);
break;
}
while (getc(fp) != '\n') /* skip rest of input line */
;
}
void
sha_test (char *buf, int len)
{
unsigned long time;
iksha *s;
char out[41];
t_reset ();
s = iks_sha_new ();
iks_sha_hash (s, buf, len, 1);
iks_sha_print (s, out);
out[40] = '\0';
iks_sha_delete (s);
time = t_elapsed ();
printf ("SHA: hashing took %ld milliseconds.\n", time);
printf ("SHA: hash [%s]\n", out);
}
void
sax_test (char *buf, int len)
{
unsigned long time;
iksparser *prs;
int bs, i, err;
bs = block_size;
if (0 == bs) bs = len;
sax_tag = 0;
sax_cdata = 0;
t_reset ();
prs = iks_sax_new (NULL, tagHook, cdataHook);
i = 0;
while (i < len) {
if (i + bs > len) bs = len - i;
err = iks_parse (prs, buf + i, bs, 0);
switch (err) {
case IKS_OK:
break;
case IKS_NOMEM:
exit (2);
case IKS_BADXML:
fprintf (stderr, "Invalid xml at byte %ld, line %ld\n",
iks_nr_bytes (prs), iks_nr_lines (prs));
exit (1);
case IKS_HOOK:
exit (1);
}
i += bs;
}
time = t_elapsed ();
printf ("SAX: parsing took %ld milliseconds.\n", time);
printf ("SAX: tag hook called %d, cdata hook called %d times.\n", sax_tag, sax_cdata);
iks_parser_delete (prs);
}
int main(int argc, char **argv)
{
int ret, r2;
runcmd_init();
t_set_colors(0);
t_start("exec output comparison");
{
int i;
char *out = calloc(1, BUF_SIZE);
for (i = 0; cases[i].input != NULL; i++) {
memset(out, 0, BUF_SIZE);
int pfd[2] = {-1, -1}, pfderr[2] = {-1, -1};
/* We need a stub iobregarg since runcmd_open()'s prototype
* declares it attribute non-null. */
int stub_iobregarg = 0;
int fd;
char *cmd;
asprintf(&cmd, ECHO_COMMAND " -n %s", cases[i].input);
fd = runcmd_open(cmd, pfd, pfderr, NULL, stub_iobreg, &stub_iobregarg);
free(cmd);
read(pfd[0], out, BUF_SIZE);
ok_str(cases[i].output, out, "Echoing a command should give expected output");
close(pfd[0]);
close(pfderr[0]);
close(fd);
}
free(out);
}
ret = t_end();
t_reset();
t_start("anomaly detection");
{
int i;
for (i = 0; anomaly[i].cmd; i++) {
int out_argc;
char *out_argv[256];
int result = runcmd_cmd2strv(anomaly[i].cmd, &out_argc, out_argv);
ok_int(result, anomaly[i].ret, anomaly[i].cmd);
if (out_argv[0]) free(out_argv[0]);
}
}
r2 = t_end();
ret = r2 ? r2 : ret;
t_reset();
t_start("argument splitting");
{
int i;
for (i = 0; parse_case[i].cmd; i++) {
int x, out_argc;
char *out_argv[256];
int result = runcmd_cmd2strv(parse_case[i].cmd, &out_argc, out_argv);
/*out_argv[out_argc] = NULL;*//* This must be NULL terminated already. */
ok_int(result, parse_case[i].ret, parse_case[i].cmd);
ok_int(out_argc, parse_case[i].argc_exp, parse_case[i].cmd);
for (x = 0; x < parse_case[x].argc_exp && out_argv[x]; x++) {
ok_str(parse_case[i].argv_exp[x], out_argv[x], "argv comparison test");
}
if (out_argv[0]) free(out_argv[0]);
}
}
r2 = t_end();
return r2 ? r2 : ret;
}
void command_exec(void)
{
#if 1
unsigned long address = 0x20002000;
unsigned char type = 0;
unsigned char width = 8;
int count = 1;
unsigned char data[10] = {0xaa,0x55,0xaa,0x78};
if(new_cmd_pending == CMD_HALT)
{
t_halt();
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_GO)
{
t_go();
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_WRITE_MEM)
{
t_write_mem(type, address, width, count, data);
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_READ_MEM)
{
t_read_mem(type, address, width, count, data);
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_CORE_WRITE)
{
t_changePC(0,0);
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_CORE_RESET)
{
t_reset();
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_CORE_READ)
{
t_ReadPC();
new_cmd_pending = 0;
}
else
{
;
}
#endif
#if 0
uint32_t i = 0, j = 0, k = 0, l = 0;
uint32_t read_count = 0;
uint32_t retry = 0;
uint8_t led_state = 0;
uint32_t write_error = 0;
uint32_t sectorsize = 0;
uint32_t rambufsize = 0;
uint32_t rambufaddr = 0;
gpio_set_cdc_led(led_state);
led_state = !led_state;
//Start to program
if (!gpio_get_pin_loader_state())
{
//t_halt();
gpio_set_cdc_led(1);
while(!gpio_get_pin_loader_state())
{
;
}
gpio_set_cdc_led(0);
/*
while(gpio_get_pin_loader_state())
{
;
}
gpio_set_cdc_led(1);
while(!gpio_get_pin_loader_state())
{
;
}
gpio_set_cdc_led(0);
*/
t_reset();
for(i = 0; i < RETRY_TIME; i++)
{
write_error = 0;
pwrite = (uint32_t *)KINETIS_FLASHPRG;
pread = (uint32_t *)READBACK_ADDR;
t_write_mem(0,FLASH_PC - 1, 8, 1024, (unsigned char *)pwrite);
t_read_mem(0,FLASH_PC - 1, 8, 4, (unsigned char *)pread);
for(l = 0; l < 1; l++)
{
if(*pread != *pwrite)
{
write_error = 1;
}
*pread++;
*pwrite++;
}
if(write_error == 0)
{
break;
}
}
if(write_error == 1)
{
write_error = 0;
return;
}
//return ;
t_changePC(FLASH_PC,FLASH_SP);
t_go();
#if 1
//判断Target是否运行
while(1)
{
t_read_mem(0,HWESR, 32, 1, (unsigned char *)&readreg);
if((readreg == CPU_WAIT))
{
retry = 0;
read_count = 0;
break;
}
else
{
read_count++;
}
if(read_count > READ_TIME)
{
t_halt();
t_write_mem(0,FLASH_PC - 1, 8, 1024, (unsigned char *)KINETIS_FLASHPRG);
t_reset();
t_changePC(FLASH_PC,FLASH_SP);
t_go();
read_count = 0;
retry++;
}
//retry more times
if(retry >= RETRY_TIME)
{
retry = 0;
read_count = 0;
break;
}
}
#endif
#if 1
//计算烧写地址和大小
t_read_mem(0,HWSID, 32, 1, (unsigned char *)§orsize);
filenb = (*(uint32_t *)FILE_SIZE)/sectorsize;
if((*(uint32_t *)FILE_SIZE)%sectorsize)
{
filenb++;
}
//开始擦除flash
for(i = 0; i < filenb; i++)
{
gpio_set_cdc_led(led_state);
led_state = !led_state;
//write byte len
writereg = 0;
t_write_mem(0,HWBCR, 32, 1, (unsigned char *)&writereg);
//write addr
writereg = sectorsize*i;
t_write_mem(0,HWBFR, 32, 1, (unsigned char *)&writereg);
writereg = CMD_ERASE;
t_write_mem(0,HWCMR, 32, 1, (unsigned char *)&writereg);
writereg = CMD_RUN;
t_write_mem(0,HWCSR, 32, 1, (unsigned char *)&writereg);
//等待擦除完成
while(1)
{
t_read_mem(0,HWCSR, 32, 1, (unsigned char *)&readreg);
if((readreg == CMD_DONW))
{
read_count = 0;
break;
}
else
{
read_count++;
}
if(read_count > READ_TIME)
{
read_count = 0;
return;
}
}
}
#endif
#if 1
//开始编程
//i = 0;
//j = 0;
t_read_mem(0,HWFCG1, 32, 1, (unsigned char *)&rambufsize);
t_read_mem(0,HWFCG2, 32, 1, (unsigned char *)&rambufaddr);
t_read_mem(0,HWSID, 32, 1, (unsigned char *)§orsize);
fileram = (*(uint32_t *)FILE_SIZE)/rambufsize;
if((*(uint32_t *)FILE_SIZE)%rambufsize)
{
fileram++;
}
//for(i = 0; i < filenb;i++)
{
for(j = 0; j < fileram; j++)
{
gpio_set_cdc_led(led_state);
led_state = !led_state;
//t_halt();
//write buf addr
writereg = rambufaddr;
t_write_mem(0,HWBUFADDR, 32, 1, (unsigned char *)&writereg);
pwrite = (uint32_t *)(START_APP_ADDRESS + rambufsize*j);
pread = (uint32_t *)READBACK_ADDR;
t_write_mem(0,rambufaddr, 8, rambufsize, (unsigned char *)pwrite);
//write word len
writereg = rambufsize/4; //编程一次写4个字节
t_write_mem(0,HWBCR, 32, 1, (unsigned char *)&writereg);
//write addr
writereg = rambufsize*j;
t_write_mem(0,HWBFR, 32, 1, (unsigned char *)&writereg);
//write cmd
writereg = CMD_PROGRA;
t_write_mem(0,HWCMR, 32, 1, (unsigned char *)&writereg);
//start to run
writereg = CMD_RUN;
t_write_mem(0,HWCSR, 32, 1, (unsigned char *)&writereg);
//t_go();
//delay_us(10);
//wait for down
while(1)
{
t_read_mem(0,HWCSR, 32, 1, (unsigned char *)&readreg);
if((readreg == CMD_DONW))
{
read_count = 0;
break;
}
else
{
read_count++;
}
if(read_count > READ_TIME)
{
read_count = 0;
return;
}
}
}
}
#endif
}
#endif
}
//--------------------------------------------------------------------------------
//
// update_screen
//
//--------------------------------------------------------------------------------
void EmacsView::update_screen( int slow_update )
{
t_update_begin();
#if !MEMMAP
check_for_input = 999;
#endif
if( screen_garbaged )
{
t_reset();
screen_garbaged = 0;
for( int n=0; n<=t_length; n++ )
{
t_phys_screen[n].releaseLine();
}
}
if( current_line >= 0
&& t_desired_screen[ current_line ]->line_length <= t_width - columns_left )
t_desired_screen[ current_line ]->line_length =
(columns_left > 0 ?
t_width - columns_left
:
t_width);
current_line = -1;
if( t_il_ov == MISSINGFEATURE )
slow_update = 0;
if( slow_update )
{
int n;
for( n=1; n<=t_length; n++ )
{
if( t_desired_screen[n].isNull() )
t_desired_screen[n] = t_phys_screen[n];
}
int c = 0;
n = t_length;
while( n >= 1 && c <= 2 )
{
if( t_phys_screen[n] != t_desired_screen[n]
&& !t_phys_screen[n].isNull()
&& t_desired_screen[n]->lineHash() != t_phys_screen[n]->lineHash() )
c++;
n--;
}
if( c <= 2 )
slow_update = 0;
else
{
#if !MEMMAP
check_for_input = 1; // baud_rate / 2400;
#endif
executeInsertDelete();
}
}
if( !slow_update ) // fast update
{
int n;
for( n=1; n<=t_length; n++ )
if( !t_desired_screen[n].isNull() )
{
updateLine( t_phys_screen[n], t_desired_screen[n], n );
t_phys_screen[n] = t_desired_screen[n];
t_desired_screen[n].releaseLine();
}
}
if( input_pending == 0 )
t_topos( curs_y, curs_x );
t_update_end();
}
int main(int argc, char **argv)
{
dkhash_table *tx, *t;
unsigned int x;
int ret, r2;
struct test_data s;
char *p1, *p2;
char *strs[10];
char tmp[32];
t_set_colors(0);
t_start("dkhash basic test");
t = dkhash_create(512);
p1 = strdup("a not-so secret value");
dkhash_insert(t, "nisse", NULL, p1);
ok_int(dkhash_num_entries_max(t), 1, "Added one entry, so that's max");
ok_int(dkhash_num_entries_added(t), 1, "Added one entry, so one added");
ok_int(dkhash_table_size(t), 512, "Table must be sized properly");
ok_int(dkhash_collisions(t), 0, "One entry, so zero collisions");
p2 = dkhash_get(t, "nisse", NULL);
test(p1 == p2, "get should get what insert set");
dkhash_insert(t, "kalle", "bananas", p1);
p2 = dkhash_get(t, "kalle", "bezinga");
test(p1 != p2, "we should never get the wrong key");
ok_int(2, dkhash_num_entries(t), "should be 2 entries after 2 inserts");
p2 = dkhash_remove(t, "kalle", "bezinga");
ok_int(2, dkhash_num_entries(t), "should be 2 entries after 2 inserts and 1 failed remove");
ok_int(0, dkhash_num_entries_removed(t), "should be 0 removed entries after failed remove");
p2 = dkhash_remove(t, "kalle", "bananas");
test(p1 == p2, "dkhash_remove() should return removed data");
ok_int(dkhash_num_entries(t), 1, "should be 1 entries after 2 inserts and 1 successful remove");
p2 = dkhash_remove(t, "nisse", NULL);
test(p1 == p2, "dkhash_remove() should return removed data");
ret = t_end();
t_reset();
/* lots of tests below, so we shut up while they're running */
t_verbose = 0;
t_start("dkhash_walk_data() test");
memset(&s, 0, sizeof(s));
/* first we set up the dkhash-tables */
tx = dkhash_create(16);
for (x = 0; x < ARRAY_SIZE(keys); x++) {
dkhash_insert(tx, keys[x].k1, NULL, ddup(x, 0, 0));
dkhash_insert(tx, keys[x].k2, NULL, ddup(x, 0, 0));
dkhash_insert(tx, keys[x].k1, keys[x].k2, ddup(x, 0, 0));
s.x += 3;
ok_int(s.x, dkhash_num_entries(tx), "x table adding");
}
ok_int(s.x, dkhash_num_entries(tx), "x table done adding");
for (x = 0; x < ARRAY_SIZE(keys); x++) {
del.x = x;
del.i = del.j = 0;
ok_int(s.x, dkhash_num_entries(tx), "x table pre-delete");
s.x -= 3;
dkhash_walk_data(tx, del_matching);
ok_int(s.x, dkhash_num_entries(tx), "x table post-delete");
}
test(0 == dkhash_num_entries(tx), "x table post all ops");
test(0 == dkhash_check_table(tx), "x table consistency post all ops");
dkhash_debug_table(tx, 0);
r2 = t_end();
ret = r2 ? r2 : ret;
t_reset();
for (x = 0; x < 10; x++) {
sprintf(tmp, "string %d", x);
strs[x] = strdup(tmp);
}
t_start("dkhash single bucket add remove forward");
t = dkhash_create(1);
for (x = 0; x < 10; x++) {
dkhash_insert(t, strs[x], NULL, strs[x]);
}
for (x = 0; x < 10; x++) {
p1 = strs[x];
p2 = dkhash_remove(t, p1, NULL);
test(p1 == p2, "remove should return a value");
}
r2 = t_end();
ret = r2 ? r2 : ret;
t_reset();
t_start("dkhash single bucket add remove backward");
t = dkhash_create(1);
for (x = 0; x < 10; x++) {
dkhash_insert(t, strs[x], NULL, strs[x]);
}
for (x = 9; x; x--) {
p1 = strs[x];
p2 = dkhash_remove(t, p1, NULL);
test(p1 == p2, "remove should return a value");
}
dkhash_destroy(t);
r2 = t_end();
return r2 ? r2 : ret;
}
