/* Return 1 if changed directory, 0 if directory was the same, -1 if tried
* to change but failed */
static int fpick_enter_dirname(fpick_dd *dt, const char *name, int l)
{
char txt[PATHBUF], *ctxt;
int res = 0;
if (name) name = g_strndup(name, l);
else
{
cmd_read(dt->combo, dt);
name = g_strdup(dt->cdir);
}
gtkncpy(txt, name, PATHBUF);
fpick_cleanse_path(txt); // Path might have been entered manually
if (strcmp(txt, dt->txt_directory) &&
// Only do something if the directory is new
((res = fpick_scan_directory(dt, txt, NULL)) <= 0))
{ // Directory doesn't exist so tell user
ctxt = g_strdup_printf(__("Could not access directory %s"), name);
alert_box(_("Error"), ctxt, NULL);
g_free(ctxt);
res = res < 0 ? 1 : -1;
}
g_free((char *)name);
return (res);
}
static void shift_btn(shifter_dd *dt, void **wdata, int what, void **where)
{
int i;
if ((what == op_EVT_OK) || (what == op_EVT_CANCEL))
{
shift_play_state = FALSE; // Stop
mem_pal_copy(mem_pal, dt->old_pal);
update_stuff(UPD_PAL);
run_destroy(wdata);
return;
}
if (what == op_EVT_CHANGE) // Play toggle
{
cmd_read(where, dt);
if (shift_play_state && !shift_timer_state) // Start timer
shift_timer_state = threads_timeout_add(100,
shift_play_timer_call, dt);
return;
}
where = origin_slot(where);
if (where == dt->fix) // Button to fix palette pressed
{
i = dt->frame[0];
if (!i || (i > dt->frame[2])) return; // Nothing to do
mem_pal_copy(mem_pal, dt->old_pal);
spot_undo(UNDO_PAL);
shifter_set_palette(dt, i);
mem_pal_copy(dt->old_pal, mem_pal);
cmd_set(dt->slider, 0);
update_stuff(UPD_PAL);
}
else if (where == dt->clear) // Button to clear all of the values
{
for (i = 0; i < NSHIFT; i++)
spins[i][0][0] = spins[i][1][0] = spins[i][2][0] = 0;
cmd_reset(dt->spinpack, dt);
shifter_moved(dt, wdata, op_EVT_CHANGE, dt->spinpack);
}
else if (where == dt->create) // Button to create a sequence of undo images
{
if (!dt->frame[2]) return; // Nothing to do
for (i = 0; i <= dt->frame[2]; i++)
{
shifter_set_palette(dt, i);
spot_undo(UNDO_PAL);
}
shifter_set_palette(dt, dt->frame[0]);
update_stuff(UPD_PAL);
}
}
int main(int argc, char *argv[])
{
if (argc == 2) cmd_read(argv[1]);
char line[MAX_LINE_LEN + 1];
while (get_line(stdin,line)) parse_line(line);
return 0;
}
/*****************************************************************************
Main program.
*****************************************************************************/
int main (int argc, char* argv[]) {
const char* usage0 =
"usage: rtkgps [-h] [-v] [-d <dev> [-r <rate>] | -b <addr>]\n"
" ([-e] status | date | list | [-y] erase |\n"
" [-c <flg>] [-l <lgtp>] [-m <mfo>] [-s <int>] set |\n"
" [-n] [-p] [-o <dest> [-u]] [-f <nstr>] read)\n\n"
" -h display usage\n"
" -v verbose mode\n"
" -d <dev> specify serial device\n"
" -r <rate> specify baud rate for serial device\n"
" -b <addr> specify bluetooth address\n"
" -e display extended status information\n";
const char* usage1 =
" -c <flg> set real-time output (GPS mouse) mode "
"(0=disable, 1=enable)\n"
" -l <lgtp> set log record type (tl, tla, or tlav)\n"
" -m <mfo> set memory overwrite behaviour (o=overwrite, s=stop)\n"
" -s <int> set sampling interval in seconds\n"
" -n output data in simple native text form\n"
" -p display text progress bar\n"
" -o <dest> specify destination file or directory\n"
" -u skip downloading date for existing files\n";
const char* usage2 =
" -f <nstr> string specifying index number(s) of log file(s) \n"
" to retrieve as a single file number, or range of \n"
" file numbers in the format -n, n-, or n-m\n"
" -y don't ask for confirmation\n";
/* most Royalteks operate on 57600 baud, use that as the default */
cmdlnopts_t cmdopt = {0,0,0,0,0,0,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
NULL,NULL,-1,-1,-1,57600,""};
/* Initialise usage string */
strcpy(cmdopt.usgs, usage0);
strcat(cmdopt.usgs, usage1);
strcat(cmdopt.usgs, usage2);
/* Scan command line options */
scan_cmdline(argc, argv, &cmdopt);
/* Set up warning callback function */
gcwrnfp = warning;
/* Perform requested task */
if (strcmp(cmdopt.cmds,"status") == 0) {
cmd_status(&cmdopt);
} else if (strcmp(cmdopt.cmds,"date") == 0) {
cmd_date(&cmdopt);
} else if (strcmp(cmdopt.cmds,"list") == 0) {
cmd_list(&cmdopt);
} else if (strcmp(cmdopt.cmds,"set") == 0) {
cmd_set(&cmdopt);
} else if (strcmp(cmdopt.cmds,"read") == 0) {
cmd_read(&cmdopt);
} else if (strcmp(cmdopt.cmds,"erase") == 0) {
cmd_erase(&cmdopt);
}
exit(0);
}
static void shifter_slider_moved(shifter_dd *dt, void **wdata, int what,
void **where)
{
cmd_read(where, dt);
shifter_set_palette(dt, dt->frame[0]);
update_stuff(UPD_PAL);
}
bool ConsoleManager::RunCommand(char* buf)
{
if (strcmp(buf, "user") == 0) {
go_user();
}
//! exit command
if (strcmp(buf, "exit") == 0) {
return true;
}
//! clear screen
else if (strcmp(buf, "cls") == 0) {
console.Clear();
}
//! help
else if (strcmp(buf, "help") == 0) {
console.Print("Orange OS Console Help\n");
console.Print(" - exit: quits and halts the system\n");
console.Print(" - cls: clears the display\n");
console.Print(" - help: displays this message\n");
console.Print(" - read: reads a file\n");
console.Print(" - reset: Resets and recalibrates floppy for reading\n");
console.Print(" - proc: Run process\n");
}
//! read sector
else if (strcmp(buf, "read") == 0) {
cmd_read();
}
else if (strcmp(buf, "memstate") == 0) {
cmd_memstate();
}
else if (strcmp(buf, "alloc") == 0) {
cmd_alloc();
}
else if (strcmp(buf, "memtask") == 0) {
cmd_memtask();
}
//! run process
else if (strcmp(buf, "proc") == 0) {
cmd_proc();
}
else
{
console.Print("Unknown Command\n");
}
return false;
}
int sd_read_sector(unsigned long lba,unsigned char *buf)
{
int result=0;
int i;
int r;
// printf("sd_read_sector %d, %d\n",lba,buf);
SPI(0xff);
SPI_CS(1|(1<<HW_SPI_FAST));
SPI(0xff);
r=cmd_read(lba);
if(r!=0)
{
puts("Read failed\n");
// printf("Read command failed at %d (%d)\n",lba,r);
return(result);
}
i=1500000;
while(--i)
{
int v;
SPI(0xff);
// SPI_WAIT();
v=SPI_READ();
if(v==0xfe)
{
// puts("Reading sector data\n");
// spi_readsector((long *)buf);
int j;
// SPI(0xff);
for(j=0;j<128;++j)
{
int t,v;
t=SPI_PUMP();
*(int *)buf=t;
// printf("%d: %d\n",buf,t);
buf+=4;
}
i=1; // break out of the loop
result=1;
}
}
SPI(0xff);
SPI(0xff); // Discard Two CRC bytes
SPI_CS(0);
return(result);
}
void cmd_main_entry(void *pEntry)
{
/*
cmd_outprompt(vty->prompt);
*/
for (;;)
{
cmd_read(vty);
}
cmd_vty_deinit(vty);
return ;
}
int main(int argc, char *argv[]) {
struct ihf_msg *msg = NULL;
uint8_t *req = NULL;
int ret = 0;
int len;
req = malloc(sizeof(char) * BUFMAX);
if (!req) {
fprintf(stderr, "cannot allocate receiving request buffer !\n");
ret = -1;
goto exit;
}
len = read(STDIN_FILENO, req, BUFMAX);
msg = msg_unpack(req, len);
if (!msg) {
fprintf(stderr, "error unpacking message\n");
ret = -1;
goto exit;
}
switch (msg->type) {
case MSG_TYPE_INIT:
cmd_init();
break;
case MSG_TYPE_KILL:
cmd_kill();
break;
case MSG_TYPE_EXEC:
cmd_exec(msg->arg, msg->arglen);
break;
case MSG_TYPE_READ:
cmd_read();
break;
case MSG_TYPE_WRITE:
cmd_write(msg->arg, msg->arglen);
break;
default:
fprintf(stderr, "unknown request type %d\n", msg->type);
ret = -1;
goto exit;
}
exit:
if (req)
free(req);
if (msg)
free(msg);
return ret;
}
/* An input widget has changed in the dialog */
static void shifter_moved(shifter_dd *dt, void **wdata, int what, void **where)
{
int i, j, *v = cmd_read(where, dt);
/* Scriptable parts */
if (v == &dt->row) return;
if (v && (v != spins[0][0]))
{
j = v - dt->sfd;
i = spins[dt->row][j][2];
spins[dt->row][j][0] = *v < i ? *v : i;
}
reset_frames(dt);
}
void exec_command(char cmd, char *param)
{
switch(cmd){
case'Q':cmd_quit(); break;
case'C':cmd_check(); break;
case'P':cmd_print(atoi(param)); break;
case'R':cmd_read(param); break;
case'W':cmd_write(param); break;
case'F':cmd_find(param); break;
case'S':cmd_sort(atoi(param)); break;
case'E':cmd_edit(); break;
case'H':cmd_help(); break;
default:fprintf(stderr,"error\n\n");
}
printf(":");
}
static void faction_changed(spawn_dd *dt, void **wdata, int what, void **where)
{
void *cause;
spawn_row *rp;
if (dt->lock) return;
cause = cmd_read(where, dt);
rp = dt->strs + dt->idx;
if (cause == dt->dir) strncpy(rp->dir, dt->dir, sizeof(rp->dir));
else
{
strncpy0(rp->name, dt->name, sizeof(rp->name));
strncpy0(rp->cmd, dt->cmd, sizeof(rp->cmd));
cmd_setv(dt->list, (void *)dt->idx, LISTC_RESET_ROW);
}
}
static void faction_select_row(spawn_dd *dt, void **wdata, int what, void **where)
{
spawn_row *rp;
cmd_read(where, dt);
if (dt->nidx == dt->idx) return; // no change
dt->lock = TRUE;
/* Get strings from array, and reset entries */
rp = dt->strs + (dt->idx = dt->nidx);
dt->name = rp->name;
dt->cmd = rp->cmd;
strncpy(dt->dir, rp->dir, PATHBUF);
cmd_reset(dt->group, dt);
dt->lock = FALSE;
}
void exec_command(char cmd, char *param)
{
switch (cmd) {
case 'Q': cmd_quit(); break;
case 'C': cmd_check(); break;
case 'P': cmd_print(atoi(param)); break;
case 'R': cmd_read(param); break;
case 'W': cmd_write(param); break;
case 'F': cmd_find(param); break;
case 'S': cmd_sort(atoi(param)); break;
case 'D': cmd_delete(param); break;
case 'r': cmd_random(); break;
case 'T': test(atoi(param)); break;
default:
fprintf(stderr, "Invalid command %c: ignored.\n", cmd);
break;
}
}
static gboolean shift_play_timer_call(gpointer data)
{
if (!shift_play_state)
{
shift_timer_state = 0;
return FALSE; // Stop animating
}
else
{
shifter_dd *dt = data;
int i;
cmd_read(dt->slider, dt);
i = dt->frame[0] + 1;
if (i > dt->frame[2]) i = dt->frame[1];
cmd_set(dt->slider, i);
return TRUE;
}
}
int
main (int argc, char *argv[])
{
set_program_name (argv[0]);
i18n_init ();
if (argc < 2)
error (1, 0, "missing command name; use `%s help' for help", program_name);
else if (!strcmp(argv[1], "help") || !strcmp(argv[1], "--help"))
usage ();
else if (!strcmp(argv[1], "buffer-size"))
printf ("%d\n", U8_ISTREAM_BUFFER_SIZE);
else if (!strcmp(argv[1], "read"))
cmd_read (argc, argv);
else
error (1, 0, "unknown command `%s'; use `%s help' for help",
argv[1], program_name);
return 0;
}
//-----------------------------------------------------------------------------
int main(void)
{
halInit();
chSysInit();
kuroBoxInit();
chprintf(prnt, "Starting... [%s] \n", BOARD_NAME);
kbg_setLCDBacklight(1);
memset(&factory_config, 0, sizeof(factory_config));
cmd_read(prnt, 0, NULL);
cmd_print(prnt, 0, NULL);
Thread * shelltp = NULL;
while ( 1 )
{
if (!shelltp)
{
shelltp = shellCreate(&shell_cfg, SHELL_WA_SIZE, NORMALPRIO);
}
else if (chThdTerminated(shelltp))
{
chThdRelease(shelltp);
shelltp = NULL;
}
}
//--------------------------------------------------------------------------
// endless loop to say we've finished
while(1)
{
kbg_setLED1(0);
kbg_setLED2(0);
kbg_setLED3(0);
chThdSleepMilliseconds(200);
kbg_setLED1(1);
kbg_setLED2(1);
kbg_setLED3(1);
chThdSleepMilliseconds(200);
}
}
BYTE CHD61102::instruction(qint16 cmd)
{
if (pPC->pCPU->fp_log)fprintf(pPC->pCPU->fp_log,"HD61102 CMD: %04x\n",cmd);
AddLog(LOG_DISPLAY,tr("HD61102 CMD:%1").arg(cmd,4,16,QChar('0')));
if ((cmd & MASK_read) == MASK_read ) { return cmd_read(cmd); }
else
if ((cmd & MASK_status) == MASK_status ) { return cmd_status(cmd); }
else
if ((cmd & MASK_write) == MASK_write ) { cmd_write(cmd); }
else
if ((cmd & MASK_displaySL) == MASK_displaySL ) { cmd_displaySL(cmd); }
else
if ((cmd & MASK_setX) == MASK_setX ) { cmd_setX(cmd); }
else
if ((cmd & MASK_setY) == MASK_setY ) { cmd_setY(cmd); }
else
if ((cmd & MASK_on_off) == MASK_on_off ) { cmd_on_off(cmd); }
return 0;
}
void cmd_parse(u08 len, const u08 *buf, u08 *result_len, u08 *res_buf)
{
in = buf;
in_size = len;
out = res_buf;
out_size = 0;
while(in_size > 0) {
u08 cmd = get_char();
switch(cmd) {
// f) floppy commands
case 'f':
cmd_floppy();
break;
// t) track commands
case 't':
cmd_track();
break;
// m) memory commands
case 'm':
cmd_memory();
break;
// i) io commands
case 'i':
cmd_io();
break;
// r) sampler commands
case 'r':
cmd_sampler();
break;
// d) diagnose commands
case 'd':
cmd_diagnose();
break;
// c) clock commands
case 'c':
cmd_clock();
break;
// n) wiznet commands
case 'n':
cmd_wiznet();
break;
// ----- TASKS -----
// R) read disk
case 'R':
cmd_read();
break;
}
}
*result_len = out_size;
}
static void console_command_mode_run(void)
{
char szTemp[256];
char *str = NULL;
int len = 0, i = 0;
OS_PRINTF("\nEnter command mode. 'help' to show command list(non specific)\n");
OS_PRINTF("\nEnter command mode. 'spechelp' to show specific command list\n");
while (1)
{
if(get_console_mode() == DOWNLOAD_MODE)
{
OS_PRINTF("> ");
}
else
{
OS_PRINTF("Cmd > ");
}
get_command(szTemp);
#ifdef ENABLE_CMD_HISTORY
save_command(szTemp);
#endif
len = strlen(szTemp);
if(len <= 0)
{
// do nothing
continue;
}
// trim the space at the begin of the input
for(i = 0; i < len; i++)
{
if(szTemp[i] != ' ')
{
str = &szTemp[i];
break;
}
}
// trim the space at the end of the input
for(i = len-1; i >= 0; i--)
{
if(szTemp[i] != ' ')
{
szTemp[i+1] = 0;
break;
}
}
len = strlen(str);
if(len <= 0)
{
continue;
// do nothing
}
else
{
int i = 0, j =0;
int showhelp = 0;
testfm_p_suite_t pSuite = NULL;
testfm_p_cmd_t pTest = NULL;
testfm_error_code_t res = TESTFM_SUCCESS;
if(!(((str[0] >= 'a') && (str[0] <= 'z')) || ((str[0] >= 'A') && (str[0] <= 'Z'))))
{
OS_PRINTF("CMD should start with 'a-z' and 'A-Z'.\n");
continue;
}
for(i = 0; i < len-1; i++)
{
if((j == 0) && (str[i] == ' '))
{
j = i;
memset(parameter_str, 0, 256);
memcpy(parameter_str, &str[i+1], strlen(&str[i+1]));
}
if((str[i] == '-') && (str[i+1] == 'h') && (str[i-1] == ' ')
&& (((i+2) == len) || (str[i+2] == ' ')))
{
showhelp = 1;
break;
}
}
if(j != 0)
str[j] = 0;
if(0 == memcmp(str, "help", 4))
{
// list all non specific command
cmd_help();
continue;
}
if(0 == memcmp(str, "wizardshelp", 11))
{
// list all specific command
cmd_help_specific(PLATFORM_WIZARD);
continue;
}
if(0 == memcmp(str, "magichelp", 9))
{
// list all specific command
cmd_help_specific(PLATFORM_MAGIC);
continue;
}
if(0 == memcmp(str, "warriorshelp", 12))
{
// list all specific command
cmd_help_specific(PLATFORM_WARRIORS);
continue;
}
if(0 == memcmp(str, "anyhelp", 7))
{
// list all specific command
cmd_help_specific(PLATFORM_ANY);
continue;
}
if(0 == memcmp(str, "read", 4))
{
cmd_read();
continue;
}
if(0 == memcmp(str, "write", 5))
{
//cmd_write();
continue;
}
if(get_console_mode() == DOWNLOAD_MODE)
{
if(0 == memcmp(str, "download", 8))
{
cmd_download();
continue;
}
if(0 == memcmp(str, "go", 2))
{
cmd_go();
continue;
}
if(0 == memcmp(str, "reboot", 6))
{
cmd_reboot();
continue;
}
OS_PRINTF("'%s' is not recognized as an internal or external command.\n", str);
continue;
}
if(0 == memcmp(str, "exit", 4))
{
cmd_exit();
continue;
}
if(0 == memcmp(str, "runall", 6))
{
cmd_runall();
continue;
}
if(0 == memcmp(str, "statistic", 9))
{
cmd_statistic();
continue;
}
if(0 == memcmp(str, "autorun", 7))
{
//cmd_autorun();
continue;
}
// add the reboot cmd for white box test
if(0 == memcmp(str, "reboot", 6))
{
cmd_reboot();
continue;
}
if(testfm_find_cmd(str, &pSuite, &pTest) == FALSE)
{
OS_PRINTF("'%s' is not recognized as an internal or external command.\n", str);
}
else
{
if(showhelp == 1)
{
pTest->pHelpFunc();
}
else
{
//OS_PRINTF(", name: %s\n", pTest->pName);
res = testfm_run_cmd(pSuite, pTest);
if(res != TESTFM_SUCCESS)
OS_PRINTF("error code: %d\n", res);
}
}
}
}
}
f_describe()
{ register char *cp;
register int i, c;
char str[10];
struct buffer *savbuf, *b, *make_buf();
chroff bdot;
saynow("Help for command: ");
i = cmd_idx(c = cmd_read()); /* Get function idx for cmd */
if(c&CB_META) sayntoo("M-");
if(i == FN_PFXMETA)
{ sayntoo("M-");
i = cmd_idx(c = (cmd_read() | CB_META));
}
else if(i == FN_PFXEXT)
{ sayntoo("^X-");
i = cmd_idx(c = (cmd_read() | CB_EXT));
}
str[0] = c&0177;
str[1] = 0;
sayntoo(str);
/* Now read in the help file, if necessary */
savbuf = cur_buf;
if(help_buf)
chg_buf(help_buf);
else
{
saynow("Loading ");
sayntoo(ev_helpfile);
sayntoo("...");
chg_buf(help_buf = make_buf(" **HELP**"));
if(read_file(ev_helpfile) == 0)
{ chg_buf(savbuf);
kill_buf(help_buf);
help_buf = 0;
return;
}
}
/* Find function index in current buffer */
cp = str;
*cp++ = '<';
*cp++ = 'F';
cp = dottoa(cp, (chroff)i);
*cp++ = '>';
e_gobob();
if(e_search(str, cp-str, 0) == 0)
sayntoo(" No help found");
else
{
bdot = e_dot();
while(!e_lblankp()) e_gonl(); /* Move past 1st blank line */
b = make_buf(" *SHOW*");
sb_sins((SBBUF *)b, e_copyn(bdot - e_dot()));
mk_showin(b); /* Show the stuff */
kill_buf(b);
sayclr();
}
chg_buf(savbuf);
}
int main( int argc, char ** argv )
{
char path[_MAX_PATH];
char buffer[ MAX_COMMAND_LINE + 2 ] = { (char)MAX_COMMAND_LINE }; /* Used with _cgets() - maximum number of characters in must be set in 1st byte */
int _argc;
char * _argv[ MAX_ARGS ],
* result,
* fullpath;
int archive_handle = -1; /* last attached archive */
int i, cmd;
if( !ResInit( NULL ))
return( 1 ); /* ResInit failed */
/* these would be called after parsing an .ini file or similar */
IF_DEBUG( ResDbgLogOpen( "resource.log" ));
print_heading();
_getcwd( path, _MAX_PATH );
printf( "PATH: %s\n", path );
do {
do {
#if( !RES_USE_FLAT_MODEL )
printf( "\n%s> ", GLOBAL_CURRENT_PATH );
#else
printf( "\nRoot > " );
#endif
_getcwd( path, _MAX_PATH );
printf( "[SD: %s]>", path );
result = GETS( buffer ); /* Input a line of text */
} while( !buffer[1] );
if( !stricmp( result, "exit" ))
break;
_argc = parse_args( result, _argv );
cmd = COMMAND_ERROR;
for( i=0; i<COMMAND_COUNT; i++ ) {
if( !stricmp( result, command[i] )) {
cmd = i;
break;
}
}
if( cmd == COMMAND_EXIT && !_argc )
break;
if( _argc > 1 ) {
if( !stricmp( _argv[1], "?" ) || !stricmp( _argv[1], "help" )) {
show_help( cmd );
continue;
}
else
if( strchr( _argv[1], ASCII_BACKSLASH )) {
res_fullpath( path, _argv[1], _MAX_PATH );
fullpath = path;
}
else
fullpath = _argv[1];
}
switch( cmd )
{
case COMMAND_DIR:
#if( RES_USE_FLAT_MODEL )
printf( "This function is only meaningful when using the hierarchical model.\n" );
break;
#endif
if( _argc > 1 )
cmd_dir( _argv[1] );
else
cmd_dir( NULL );
break;
case COMMAND_ANALYZE:
{
#if( !RES_USE_FLAT_MODEL )
HASH_ENTRY * entry;
if( _argc == 1 )
entry = hash_find( GLOBAL_CURRENT_PATH, GLOBAL_HASH_TABLE );
else
entry = hash_find( fullpath, GLOBAL_HASH_TABLE );
if( entry ) {
#if( RES_DEBUG_VERSION )
if( entry -> dir )
dbg_analyze_hash( (HASH_TABLE *)entry -> dir );
else
printf( "No directory table for this directory.\n" );
#endif /* RES_DEBUG_VERSION */
}
else
printf( "Directory not found.\n" );
#else
printf( "This command only meaningful when using the hierarchical model!\n" );
#endif
break;
}
case COMMAND_RUN:
cmd_run( _argc, _argv );
break;
case COMMAND_CD:
if( _argc > 1 ) {
if( !ResSetDirectory( fullpath ))
printf( "Error changing to directory %s\n", fullpath );
}
else
printf( "Current directory is: %s\n", GLOBAL_CURRENT_PATH );
break;
case COMMAND_ADD:
if( _argc > 1 ) {
int test = FALSE,
flag = -1;
if( _argc > 2 )
flag = is_bool( _argv[2] );
if( flag == -1 )
flag = TRUE;
if( !GLOBAL_SEARCH_INDEX )
test = ResCreatePath( fullpath, flag );
else
test = ResAddPath( fullpath, flag );
if( !test )
printf( "Error adding %s to search path\n", fullpath );
}
else
show_help(cmd);
break;
case COMMAND_STREAM:
{
FILE * fptr;
char c;
int test;
if( _argc < 2 ) {
show_help(cmd);
break;
}
fptr = fopen( _argv[1], "r" );
if( fptr ) {
while( (test = fscanf( fptr, "%c", &c )) != EOF )
printf( "%c", c );
printf( "\n\n\n\n ************** REWINDING ****************** \n\n\n\n\n\n\n" );
fseek( fptr, 0, SEEK_SET );
while( (test = fscanf( fptr, "%c", &c )) != EOF )
printf( "%c", c );
fclose( fptr );
} else {
printf( "Error opening file %s\n", _argv[1] );
}
break;
}
case COMMAND_PATH:
{
int x=0;
char b[_MAX_PATH];
if( GLOBAL_PATH_LIST ) {
while( ResGetPath( x++, b ))
printf( "%s\n", b );
}
else
printf( "No path created.\n" );
break;
}
case COMMAND_EXTRACT:
{
/* extracts the archive to the local directory with the same filename */
if( _argc < 3 )
show_help(cmd);
else
ResExtractFile( _argv[1], _argv[2] );
break;
}
case COMMAND_READ:
if( _argc >= 2 )
cmd_read( _argv[1] );
else
show_help(cmd);
break;
case COMMAND_ATTACH:
{
char dst[_MAX_PATH];
int flag = -1;
if( _argc < 2 ) {
show_help(cmd);
break;
}
if( _argc >= 3 )
flag = is_bool( _argv[ _argc - 1 ] );
if( _argc >= 3 ) res_fullpath( dst, _argv[2], _MAX_PATH );
if( _argc == 2 )
archive_handle = ResAttach( GLOBAL_CURRENT_PATH, fullpath, FALSE );
else
if( _argc == 3 ) {
if( flag != -1 )
archive_handle = ResAttach( GLOBAL_CURRENT_PATH, fullpath, flag );
else
archive_handle = ResAttach( fullpath, dst, FALSE );
} else
if( _argc == 4 )
archive_handle = ResAttach( fullpath, dst, flag == -1 ? 0 : flag );
if( archive_handle == -1 )
printf( "Error attaching zip file %s\n", fullpath );
break;
}
case COMMAND_DUMP:
ResDbgDump();
MemDump(); printf("\n");
MemFindLevels(); printf("\n");
MemFindUsage();
break;
case COMMAND_DETACH:
if( archive_handle != -1 )
{
ResDetach( archive_handle );
archive_handle = -1;
}
else
printf( "No archives currently attached.\n" );
break;
case COMMAND_MAP:
if( _argc < 2 )
show_help(cmd);
else
cmd_map( _argv[1] );
break;
case COMMAND_FIND:
if( _argc < 2 )
show_help(cmd);
else
cmd_find( fullpath );
break;
case COMMAND_HELP:
print_heading();
show_help(cmd);
break;
case COMMAND_ERROR:
default:
printf( "Syntax error\n" );
break;
}
} while( TRUE );
ResExit();
MemDump();
_getcwd( path, _MAX_PATH );
printf( "PATH: %s\n", path );
return(0);
}
byte fdc_read_data(void)
{
byte val;
val = 0xff; // default value
switch (FDC.phase)
{
case EXEC_PHASE: // in execution phase?
if (FDC.cmd_direction == FDC_TO_CPU) { // proper direction?
FDC.timeout = OVERRUN_TIMEOUT;
val = *FDC.buffer_ptr++; // read byte from current sector
#ifdef DEBUG_FDC
if (!(FDC.flags & OVERRUN_flag)) {
dwBytesTransferred++;
}
#endif
if (FDC.buffer_ptr >= FDC.buffer_endptr) {
FDC.buffer_ptr = active_track->data; // wrap around
}
if (!(--FDC.buffer_count)) { // completed the data transfer?
if (FDC.flags & RNDDE_flag) { // simulate random Data Errors?
// ***! random DE handling
}
active_drive->current_sector++; // increase sector index
if (FDC.flags & OVERRUN_flag) { // overrun condition detected?
FDC.flags &= ~OVERRUN_flag;
FDC.result[RES_ST0] |= 0x40; // AT
FDC.result[RES_ST1] |= 0x10; // Overrun
LOAD_RESULT_WITH_CHRN
FDC.phase = RESULT_PHASE; // switch to result phase
}
else {
if (FDC.command[CMD_CODE] == 0x42) { // read track command?
if ((--FDC.command[CMD_EOT])) { // continue reading sectors?
if (active_drive->current_sector >= active_track->sectors) { // index beyond number of sectors for this track?
active_drive->current_sector = 0; // reset index
}
FDC.command[CMD_R]++; // advance to next sector
cmd_readtrk();
}
else {
LOAD_RESULT_WITH_STATUS
LOAD_RESULT_WITH_CHRN
FDC.phase = RESULT_PHASE; // switch to result phase
}
}
else { // normal read (deleted) data command
if (!((FDC.result[RES_ST1] & 0x31) || (FDC.result[RES_ST2] & 0x21))) { // no error bits set?
if (FDC.command[CMD_R] != FDC.command[CMD_EOT]) { // haven't reached End of Track?
FDC.command[CMD_R]++; // advance to next sector
cmd_read();
}
else {
LOAD_RESULT_WITH_STATUS
LOAD_RESULT_WITH_CHRN
FDC.phase = RESULT_PHASE; // switch to result phase
}
}
else {
LOAD_RESULT_WITH_STATUS
LOAD_RESULT_WITH_CHRN
FDC.phase = RESULT_PHASE; // switch to result phase
}
}
}
}
}
break;
case RESULT_PHASE: // in result phase?
val = FDC.result[FDC.byte_count++]; // copy value from buffer
#ifdef DEBUG_FDC
if (dwBytesTransferred) {
fprintf(pfoDebug, "{%d} ", dwBytesTransferred);
dwBytesTransferred = 0;
}
fprintf(pfoDebug, "[%02x] ", val);
#endif
if (FDC.byte_count == FDC.res_length) { // sent all result bytes?
FDC.flags &= ~SCAN_flag; // reset scan command flag
FDC.byte_count = 0; // clear byte counter
FDC.phase = CMD_PHASE; // switch to command phase
FDC.led = 0; // turn the drive LED off
}
break;
}
return val;
}
int sd_read_sector(unsigned long lba,unsigned char *buf)
{
int result=0;
int i;
int r;
// printf("sd_read_sector %d, %d\n",lba,buf);
SPI_CS(1|(1<<VAMPIRE_SPI_FAST));
SPI(0xff);
r=cmd_read(lba);
if(r!=0)
{
printf("Read command failed at %d (%d)\n",lba,r);
return(result);
}
i=1500000;
while(--i)
{
int v;
SPI(0xff);
// SPI_WAIT();
v=SPI_READ();
if(v==0xfe)
{
// puts("Reading sector data\n");
// spi_readsector((long *)buf);
int j;
// SPI(0xff);
short *out=(short *)buf;
for(j=0;j<256;++j)
{
unsigned int t=0;
SPI(0xff);
t=SPI_READ()<<8;
SPI(0xff);
t|=SPI_READ();
*out++=t;
}
#if 0
for(j=0;j<256;++j)
{
int t,v;
t=SPI_PUMP();
*(short *)buf=t;
// printf("%d: %d\n",buf,t);
buf+=2;
}
#endif
i=1; // break out of the loop
result=1;
}
}
SPI(0xff);
// SPI_WAIT();
SPI_CS(0);
// puts("Sector read\n");
return(result);
}
int main(void) {
uint8_t c;
DATA_OUT // Шина данных (DDRD)
DDRC = 0b00000000; // Шина адреса
DDRB = 0b00101101; // Шина адреса, карта и светодиод
PORTB = 0b00010001; // Подтягивающий резистор на MISO и светодиод
// Пауза, пока не стабилизируется питание
_delay_ms(100);
// while(1) {
// error();
// }
// Запуск файловой системы
if(fs_init()) error();
strcpy_P((char*)buf, PSTR("boot/boot.rk"));
if(fs_open()) error();
if(fs_getfilesize()) error();
if(fs_tmp < 7) error();
if(fs_tmp > 128) error();
if(fs_read0(rom, (WORD)fs_tmp)) error();
// Гасим светодиод
PORTB |= _BV(PB0);
while(1) {
// Эмуляция ПЗУ
RomEmu();
// Зажигаем светодиод
PORTB |= _BV(PB0);
// Проверяем наличие карты
sendStart(ERR_START);
send(ERR_WAIT);
if(fs_check()) {
send(ERR_DISK_ERR);
} else {
send(ERR_OK_DISK);
recvStart();
c = wrecv();
// Сбрасываем ошибку
lastError = 0;
// Принимаем аргументы
switch(c) {
case 0: cmd_boot(); break;
case 1: cmd_ver(); break;
case 2: cmd_exec(); break;
case 3: cmd_find(); break;
case 4: cmd_open(); break;
case 5: cmd_lseek(); break;
case 6: cmd_read(); break;
case 7: cmd_write(); break;
case 8: cmd_move(); break;
default: lastError = ERR_INVALID_COMMAND;
}
// Вывод ошибки
if(lastError) sendStart(lastError);
}
// Порт рабоатет на выход
wait();
DATA_OUT
// Гасим светодиод
PORTB &=~_BV(PB0);
_delay_ms(500);
}
}
int main(int argc, char **argv) {
int skp=0, port = FPGAPORT;
bool use_usb = true, long_state = false;
unsigned int v;
skp=1;
for(int argn=0; argn<argc-skp; argn++) {
if (argv[argn+skp][0] == '-') {
if (argv[argn+skp][1] == 'u')
use_usb = true;
else if (argv[argn+skp][1] == 'l')
long_state = true;
else if (argv[argn+skp][1] == 'p') {
use_usb = false;
if (isdigit(argv[argn+skp][2]))
port = atoi(&argv[argn+skp][2]);
}
skp++; argn--;
} else
argv[argn] = argv[argn+skp];
} argc -= skp;
if (use_usb)
m_fpga = new FPGA(new USBI());
else
m_fpga = new FPGA(new NETCOMMS(FPGAHOST, port));
if (!long_state) {
v = m_fpga->readio(R_ZIPCTRL);
printf("0x%08x: ", v);
if (v & 0x0080) printf("PINT ");
// if (v & 0x0100) printf("STEP "); // self resetting
if((v & 0x00200)==0) printf("STALL ");
if (v & 0x00400) printf("HALTED ");
if((v & 0x03000)==0x01000) {
printf("SW-HALT");
} else {
if (v & 0x01000) printf("SLEEPING ");
if (v & 0x02000) printf("GIE(UsrMode) ");
}
// if (v & 0x0800) printf("CLR-CACHE ");
printf("\n");
} else {
printf("Reading the long-state ...\n");
for(int i=0; i<14; i++) {
printf("sR%-2d: 0x%08x ", i, cmd_read(m_fpga, i));
if ((i&3)==3)
printf("\n");
} printf("sCC : 0x%08x ", cmd_read(m_fpga, 14));
printf("sPC : 0x%08x ", cmd_read(m_fpga, 15));
printf("\n\n");
for(int i=0; i<14; i++) {
printf("uR%-2d: 0x%08x ", i, cmd_read(m_fpga, i+16));
if ((i&3)==3)
printf("\n");
} printf("uCC : 0x%08x ", cmd_read(m_fpga, 14+16));
printf("uPC : 0x%08x ", cmd_read(m_fpga, 15+16));
printf("\n\n");
}
delete m_fpga;
}
int main( void )
#endif
{
iu8 i, len, b;
/* TODO: On error? */
hal_init();
/* Send ATR */
/* TODO: Possible from EEPROM? */
hal_io_sendByteT0( 0x3B );
#if CONF_WITH_LOGGING==1
log_init();
#endif
resplen = 0;
#if CONF_WITH_TRANSACTIONS==1
/* Commit transactions not yet done. */
/* TODO: On error? */
ta_commit();
#endif /* CONF_WITH_TRANSACTIONS */
/* Initialize FS state in RAM. */
/* TODO: On error? */
fs_init();
#if CONF_WITH_PINAUTH==1
/* Initialize authentication state. */
/* TODO: On error? */
auth_init();
#endif /* CONF_WITH_PINAUTH==1 */
if( !(hal_eeprom_read( &len, ATR_LEN_ADDR, 1 ) && (len<=ATR_MAXLEN)) )
for(;;) {} /* XXX good loop mechanism? what is it anyway */
for( i=1; i<len; i++ ) {
if( !hal_eeprom_read( &b, ATR_ADDR+i, 1 ) ) for(;;) {}
hal_io_sendByteT0( b );
}
/* Command loop */
for(;;) {
for( i=0; i<5; i++ ) {
header[i] = hal_io_recByteT0();
}
#if CONF_WITH_KEYAUTH==1
if( challvalidity ) challvalidity--;
#endif /* CONF_WITH_KEYAUTH==1 */
#if CONF_WITH_TRNG==1
hal_rnd_addEntropy();
#endif /* CONF_WITH_TRNG==1 */
if( (header[0]&0xFC)==CLA_PROP ) {
switch( header[1]&0xFE ) {
#if CONF_WITH_TESTCMDS==1
case INS_WRITE:
cmd_write();
break;
case INS_READ:
cmd_read();
break;
#endif /* CONF_WITH_TESTCMDS==1 */
#if CONF_WITH_FUNNY==1
case INS_LED:
cmd_led();
break;
#endif /* CONF_WITH_FUNNY==1 */
#if CONF_WITH_PINCMDS==1
case INS_CHANGE_PIN:
cmd_changeUnblockPIN();
break;
#endif /* CONF_WITH_PINCMDS==1 */
#if CONF_WITH_CREATECMD==1
case INS_CREATE:
cmd_create();
break;
#endif /* CONF_WITH_CREATECMD==1 */
#if CONF_WITH_DELETECMD==1
case INS_DELETE:
cmd_delete();
break;
#endif /* CONF_WITH_DELETECMD==1 */
#if CONF_WITH_KEYCMDS==1
case INS_EXTERNAL_AUTH:
cmd_extAuth();
break;
#endif /* CONF_WITH_KEYCMDS==1 */
#if CONF_WITH_KEYCMDS==1
case INS_GET_CHALLENGE:
cmd_getChallenge();
break;
#endif /* CONF_WITH_KEYCMDS==1 */
case INS_GET_RESPONSE:
cmd_getResponse();
break;
#if CONF_WITH_KEYCMDS==1
case INS_INTERNAL_AUTH:
cmd_intAuth();
break;
#endif /* CONF_WITH_KEYCMDS==1 */
case INS_READ_BINARY:
cmd_readBinary();
break;
case INS_SELECT:
cmd_select();
break;
#if CONF_WITH_PINCMDS==1
case INS_UNBLOCK_PIN:
cmd_changeUnblockPIN();
break;
#endif /* CONF_WITH_PINCMDS==1 */
case INS_UPDATE_BINARY:
cmd_updateBinary();
break;
#if CONF_WITH_KEYCMDS==1
case INS_VERIFY_KEY:
cmd_verifyKeyPIN();
break;
#endif /* CONF_WITH_KEYCMDS==1 */
#if CONF_WITH_PINCMDS==1
case INS_VERIFY_PIN:
cmd_verifyKeyPIN();
break;
#endif /* CONF_WITH_PINCMDS==1 */
default:
t0_sendWord( SW_WRONG_INS );
}
} else {
t0_sendWord( SW_WRONG_CLA );
}
#if CONF_WITH_TRNG==1
hal_rnd_addEntropy();
#endif
/* Return the SW in sw */
t0_sendSw();
}
}
byte t_FDC::fdc_read_data(void)
{
auto emulator = _emulator.lock();
byte val;
val = 0xff; // default value
switch (phase)
{
case EXEC_PHASE: // in execution phase?
if (cmd_direction == FDC_TO_CPU) { // proper direction?
timeout = OVERRUN_TIMEOUT;
val = *buffer_ptr++; // read byte from current sector
#ifdef USE_DEBUGGER_FDC
if (dwDebugFlag)
{
if (!(flags & OVERRUN_flag)) {
dwBytesTransferred++;
}
}
#endif
if (buffer_ptr >= buffer_endptr) {
buffer_ptr = active_track->data; // wrap around
}
if (!(--buffer_count)) { // completed the data transfer?
if (flags & RNDDE_flag) { // simulate random Data Errors?
// ***! random DE handling
}
active_drive->current_sector++; // increase sector index
if (flags & OVERRUN_flag) { // overrun condition detected?
flags &= ~OVERRUN_flag;
result[RES_ST0] |= 0x40; // AT
result[RES_ST1] |= 0x10; // Overrun
LOAD_RESULT_WITH_CHRN();
phase = RESULT_PHASE; // switch to result phase
}
else {
if (command[CMD_CODE] == 0x42) { // read track command?
if ((--command[CMD_EOT])) { // continue reading sectors?
if (active_drive->current_sector >= active_track->sectors) { // index beyond number of sectors for this track?
active_drive->current_sector = 0; // reset index
}
command[CMD_R]++; // advance to next sector
cmd_readtrk();
}
else {
LOAD_RESULT_WITH_STATUS();
LOAD_RESULT_WITH_CHRN();
phase = RESULT_PHASE; // switch to result phase
}
}
else { // normal read (deleted) data command
if (!((result[RES_ST1] & 0x31) || (result[RES_ST2] & 0x21))) { // no error bits set?
if (command[CMD_R] != command[CMD_EOT]) { // haven't reached End of Track?
command[CMD_R]++; // advance to next sector
cmd_read();
}
else {
LOAD_RESULT_WITH_STATUS();
LOAD_RESULT_WITH_CHRN();
phase = RESULT_PHASE; // switch to result phase
}
}
else {
LOAD_RESULT_WITH_STATUS();
LOAD_RESULT_WITH_CHRN();
phase = RESULT_PHASE; // switch to result phase
}
}
}
}
}
break;
case RESULT_PHASE: // in result phase?
val = result[byte_count++]; // copy value from buffer
#ifdef USE_DEBUGGER_FDC
if (dwDebugFlag)
{
if (dwBytesTransferred) {
fprintf(pfoDebug, "FDCByteTransfert : {%d}\n", dwBytesTransferred);
dwBytesTransferred = 0;
}
fprintf(pfoDebug, "FDCResultPhase : [%02x]\n", val);
}
#endif
if (byte_count == res_length) { // sent all result bytes?
flags &= ~SCAN_flag; // reset scan command flag
byte_count = 0; // clear byte counter
phase = CMD_PHASE; // switch to command phase
emulator->fdcLed(false);
}
break;
}
return val;
}
/* Extended-prefix command.
* Likewise trivial; perhaps later hair up with timeout "^X-" prompt?
*/
f_pfxext()
{ return(cmd_xct(cmd_read()|CB_EXT));
}
/* Meta-prefix command.
* For now, very simple. Perhaps later try to hair up with
* time-out "M-" prompt?
*/
f_pfxmeta()
{ return(cmd_xct(cmd_read()|CB_META));
}
