/* 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)); }