int cmd_idcode(int argc, const char** argv)
{
cable* cbl;
chip* dev;
int index;
const char* param;
// Position
param = cmdline_get_non_opt(argc, argv, 0);
if (param == NULL || str2num(param, &index) || index <= 0)
{
msgf(STR_INVALID_PARAMETERS);
return 0;
}
cbl = open_cable(1);
if (cbl == NULL)
return 0;
dev = select_device_in_chain(index - 1);
if (dev)
msgf(STR_DEVICE_IDCODE, index, dev->id);
close_cable(cbl);
return 0;
}
int cmd_erase(int argc, const char** argv)
{
cable* cbl = NULL;
int index;
chip* dev;
const char* param;
// Position
param = cmdline_get_non_opt(argc, argv, 0);
if (param == NULL || str2num(param, &index) || index <= 0)
{
msgf(STR_INVALID_PARAMETERS);
return 0;
}
cbl = open_cable(1);
if (cbl == NULL)
return 0;
dev = select_device_in_chain(index - 1);
if (dev == NULL)
return -1;
msgf(STR_ERASING, index, dev->name.c_str());
if (dev->erase(cbl) == 0)
msgf(STR_SUCCESS_COMPLETED);
close_cable(cbl);
return 0;
}
int cmd_read(int argc, const char** argv)
{
u8* data = NULL;
cable* cbl;
const char* param;
chip* dev;
int index, length;
program_file* f = NULL;
// Position
param = cmdline_get_non_opt(argc, argv, 0);
if (param == NULL || str2num(param, &index) || index <= 0)
{
msgf(STR_INVALID_PARAMETERS);
return 0;
}
// File name
param = cmdline_get_non_opt(argc, argv, 1);
if (param == NULL)
{
msgf(STR_INVALID_PARAMETERS);
return 0;
}
cbl = open_cable(1);
if (cbl == NULL)
goto cleanup;
dev = select_device_in_chain(index - 1);
if (dev == NULL)
goto cleanup;
msgf(STR_READING, index, dev->name.c_str());
length = dev->readback(cbl, &data);
if (length <= 0 || data == NULL)
goto cleanup;
f = create_program_file(dev, argc, argv);
if (f == NULL)
goto cleanup;
if (f->save(param, data, length))
goto cleanup;
msgf(STR_SUCCESS_COMPLETED);
cleanup:
close_cable(cbl);
if (data)
free(data);
if (f)
delete f;
return 0;
}
int
load(TickReq *tick,int *pntick,int nmax) {
int ntick = *pntick;
FILE *tickf = NULL;
char *cp;
char buf[256];
int lno = 0;
memset(tick,0,sizeof *tick * ntick);
/*
* Open tickers.rc file :
*/
tickf = fopen(TICKPATH,"r");
if ( !tickf ) {
msgf('e',"%s: opening %s for reading",
strerror(errno),TICKPATH);
return -1;
}
/*
* Load tickers from file :
*/
while ( fgets(buf,sizeof buf,tickf) ) {
++lno;
cp = strtick(buf);
if ( cp - buf <= 0 ) {
msgf('e',"Line %d: Bad ticker\n",
lno);
continue;
}
/*
* Load one more ticker :
*/
*cp = 0;
strncpy(tick[ntick].ticker,
buf, TICKLEN)[TICKLEN] = 0;
tick[ntick].flags = 0;
tick[ntick++].next_samp = 0;
/*
* Don't load beyond the array limits:
*/
if ( ntick >= nmax ) {
msgf('w',
"Stopping at max of %d tickers.",
ntick);
break;
}
}
fclose(tickf);
msgf('i',"%d tickers loaded.",ntick);
*pntick = ntick; /* Return count */
return 0;
}
int process_command_line(const char* line)
{
int argc = 0;
char** argv = NULL;
int i, rc = 0;
const char* str_cmd;
if (line == NULL)
return 0;
current_command_line = line;
if (parse_cmdline_args(line, &argc, &argv) < 0)
{
rc = -1;
goto cleanup;
}
if (argc == 0)
goto cleanup;
for (i = 0; commands[i].fn != NULL; i++)
{
str_cmd = res_str(commands[i].res_id);
if (strcmp(str_cmd, argv[0]) == 0)
{
rc = commands[i].fn(argc, (const char**)argv);
break;
}
}
if (commands[i].fn == NULL)
{
msgf(STR_UNKNOWN_COMMAND);
rc = 0;
}
else
{
switch (rc)
{
case CMDLINE_INVALID_PARAMETER:
msgf(STR_INVALID_PARAMETERS);
help(argv[0]);
break;
}
}
cleanup:
if (argv != NULL)
free(argv);
current_command_line = NULL;
return rc;
}
void setpath(char *path)
{
short bytes;
freepath();
bytes=strlen(path+1);
defpathname = (char *) AllocMem(bytes,0);
msgf("Path len %d\n",bytes-1);
strcpy(defpathname, path);
msgf("New path: %s\n",defpathname);
}
int target_set_medium(target_context_t *tc, const char *medium)
{
char cmdbuf [CMDBUF_LENGTH];
msgf("setting medium to %s\n", medium);
#ifndef WIN32
/* if medium is Ethernet, negotiate remote MAC before switching */
if (!strcmp(medium, TM_ETHERNET))
if(target_negotiate_mac(tc) == -1){
return -1;
}
#endif
snprintf(cmdbuf, sizeof cmdbuf, "medium %s", medium);
target_write_command(tc, cmdbuf);
if(target_confirm_response(tc) == -1){
return -1;
}
if (!strcmp(medium, TM_ETHERNET)) {
tc->mtu = ETHERNET_MTU;
#ifndef WIN32
tc->write = target_write_ethernet;
#endif
} else if (!strcmp(medium, TM_SERIAL)) {
tc->mtu = SERIAL_MTU;
tc->write = target_write_serial;
} else{
panicf("unknown medium: %s", medium);
return -1;
}
tc->medium = medium;
return 0;
}
int enable_user_mode_io()
{
#if defined(WIN32) && !defined(__CYGWIN__)
HANDLE h;
h = CreateFile(
"\\\\.\\giveio",
GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (h != INVALID_HANDLE_VALUE)
{
// Giveio activated successfully
CloseHandle(h);
return 0;
}
#else
if (iopl(3) == 0)
// Success
return 0;
#endif
msgf(STR_ENABLE_USERMODE_IO_ERROR);
return -1;
}
static int target_get_mac(target_context_t *tc)
{
char buf [LINE_LENGTH];
/* read MAC address from target */
msg("getting target MAC\n");
target_write_command(tc, "mac");
target_gets(tc, buf, sizeof buf);
if(target_confirm_response(tc) == -1){
return -1;
}
/* and parse it */
msgf("target-provided remote MAC: %s", buf);
if (parsemac(tc->remote_mac, buf)){
panicf("can't parse target-provided remote MAC: %s", buf);
return -1;
}
if (opt_verbose) {
msg("target-provided remote MAC (parsed): ");
printmac(stdout, tc->remote_mac);
msg("\n");
}
return 0;
}
void qmail_finish(const char* sender)
{
int status;
close(msgfd);
if(waitpid(inject_pid, &status, WUNTRACED) == -1)
fail_temp("Failed to catch exit status of qmail-inject");
if(!WIFEXITED(status))
fail_temp("qmail-inject crashed");
if(WEXITSTATUS(status))
fail_temp("qmail-inject failed");
write_envelope(sender);
close(envfd);
if(waitpid(queue_pid, &status, WUNTRACED) == -1)
fail_temp("Failed to catch exit status of qmail-queue");
if(!WIFEXITED(status))
fail_temp("qmail-queue crashed");
if(WEXITSTATUS(status))
fail_temp("qmail-queue failed");
if (!opt_quiet)
msgf("{Sent response qp }d", queue_pid);
}
int cmd_cable(int argc, const char** argv)
{
cable* cbl;
int i;
string desc, cable_def;
if (argc > 1)
{
for (i = 1; i < argc; i++)
{
cable_def += argv[i];
if (i + 1 < argc)
cable_def += ' ';
}
g.vars[strCABLE] = cable_def;
}
else
{
if (g.vars.get(strCABLE, cable_def))
{
msgf(STR_INVALID_CABLE_DEF);
return -1;
}
}
cbl = cable::factory(cable_def.c_str());
if (cbl == NULL)
return 0;
cbl->get_description(desc);
//msgf(STR_SELECTED_CABLE, desc.c_str());
return 0;
}
cable* open_cable(int detect)
{
cable* cbl;
string desc, cable_def;
if (g.vars.get(strCABLE, cable_def))
{
msgf(STR_INVALID_CABLE_DEF);
return NULL;
}
cbl = cable::factory(cable_def.c_str());
if (cbl == NULL)
return NULL;
cbl->get_description(desc);
//msgf(STR_OPENING, desc.c_str());
if (cbl->open())
{
delete cbl;
return NULL;
}
if (detect)
cbl->detect_chain();
return cbl;
}
int cable::detect_chain()
{
u32 id;
vector<u32> ids;
bool unknown = false;
unsigned int i;
chip* dev;
string desc;
g.dev_chain.clear();
msgf(STR_IDENTIFY_CHAIN);
detect_chain_ids(ids);
for (i = 1; i <= ids.size(); i++)
{
id = ids[ids.size() - i];
dev = g.chips.find_chip(id);
if (dev && dev->family)
{
g.dev_chain.push_back(device_chain_item(id, dev));
dev->family->vars.get(strDESC, desc);
printf("\'%d\' %s %s\n", i, dev->name.c_str(), desc.c_str());
}
else
{
msgf(STR_UNKNOWN_DEVICE_IDCODE, i, id);
unknown = true;
}
}
if (unknown)
{
g.dev_chain.clear();
msgf(STR_UNKNOWN_DEVICES);
return -1;
}
if (g.sel_dev >= (int)g.dev_chain.size())
g.sel_dev = 0;
msgf(STR_DEVICES_FOUND, g.dev_chain.size());
return g.dev_chain.size();
}
int bin_file::load(const char* name)
{
FILE *f;
struct stat st;
int rc = -1;
if (data || length)
// Call clear() first
return -1;
if (stat(name, &st) < 0)
{
msgf(STR_UNABLE_TO_OPEN_FILE);
return -1;
}
f = fopen(name, "rb");
if (f == NULL)
{
msgf(STR_UNABLE_TO_OPEN_FILE);
return -1;
}
// File length
length = st.st_size;
data = (u8*)malloc(length);
if (data == NULL)
goto cleanup;
if (fread(data, 1, length, f) != length)
{
msgf(STR_INVALID_FILE_FORMAT);
goto cleanup;
}
rc = 0;
cleanup:
if (rc)
clear();
if (f)
fclose(f);
return rc;
}
void mem_map_read_from_file(target_context_t *tc,
const char *pathname)
{
msgf("reading memory map from file %s\n", pathname);
region_destroy(tc->memmap);
tc->memmap = NULL;
per_line(pathname, &mem_map_add_iter, tc);
}
chip* select_device_in_chain(int index)
{
if (index >= (int)g.dev_chain.size())
{
msgf(STR_INVALID_DEVICE);
return NULL;
}
g.sel_dev = index;
return g.dev_chain[index].dev;
}
int getIFF(char *filename, struct svx_info *info)
{
int file;
short bytes;
char *fullname;
msg("Going to malloc for fullname\n");
bytes= strlen(defpathname)+strlen(filename)+1;
fullname = (char *) AllocMem(bytes,0);
/* *fullname = 0; */
msgf("Path: %s\n",defpathname);
msgf("Filename: %s\n",filename);
strcpy(fullname, defpathname);
strcat(fullname, filename);
msgf("Loading %s...\n",fullname);
if ((file = open(fullname, O_RDONLY,0)) == -1)
{
printerror("Can't open file");
FreeMem(fullname,bytes);
return (-1);
}
FreeMem(fullname,bytes);
switch (getID(file))
{
case ID_FORM: getFORM(file,info); break;
case ID_CAT: getCAT(file); break;
case ID_LIST: getLIST(file); break;
default: NotIFF(file);
}
close(file);
return 0;
}
void target_per_line(target_context_t *tc, iter_func_t *func, void *arg)
{
char buf [LINE_LENGTH];
assert(tc);
assert(func);
while (1) {
target_gets(tc, buf, sizeof buf); /* XXX handle error */
msgf("read line from target: %s", buf);
if (ok_or_ng(buf))
break;
if (func(buf, arg) < 0)
break;
}
}
cable* cable::factory(const char* s)
{
cable* cbl = NULL;
int argc;
char** argv = NULL;
int addr;
if (*s == 0)
return NULL;
parse_cmdline_args(s, &argc, &argv);
if (argc == 0)
return NULL;
if (stricmp(argv[0], "xil3") == 0) {
if (argc == 1)
addr = 0x378;
else {
if (str2num(argv[1], &addr))
goto cleanup;
}
cbl = new parport((unsigned int)addr);
}
else if (stricmp(argv[0], "dusb") == 0)
cbl = new digilent;
else if (stricmp(argv[0],"znuhtag") == 0) {
int num=0;
if(argc > 1)
str2num(argv[1], &num);
cbl = new znuhtag(num);
}
else if (stricmp(argv[0],"amontec") == 0) {
int speed = 0;
if (argc > 1)
str2num(argv[1], &speed);
cbl = new amontec(speed);
}
else {
msgf(STR_INVALID_CABLE_DEF);
return NULL;
}
cleanup:
return cbl;
}
int mcs_file::save(const char* file, void* data, int len)
{
FILE* f;
int rc = -1;
int addr, addr_offs, count;
const int buff_len = 16;
union {
u8 buff[buff_len];
u16 word;
} u;
f = fopen(file, "wt");
if (f == NULL)
{
msgf(STR_UNABLE_TO_OPEN_FILE);
return -1;
}
addr = 0;
addr_offs = 0;
u.word = 0x0000;
if (write_record(f, 2, 0, RECORD_ADDRESS, u.buff))
goto cleanup;
while (addr_offs + addr < len)
{
if (addr_offs + addr + buff_len < len)
count = buff_len;
else
count = len - addr_offs - addr;
if (write_record(f, count, addr, RECORD_DATA, (u8*)data + addr_offs + addr))
goto cleanup;
addr += count;
if (addr >= 0x10000 && addr_offs + addr < len)
{
addr_offs += 0x10000;
addr &= 0xFFFF;
u.word = HTON16(addr_offs >> 16);
if (write_record(f, 2, 0, RECORD_ADDRESS, u.buff))
goto cleanup;
}
}
int cmd_cd(int argc, const char** argv)
{
char dir[256] = "";
if (argc == 2)
{
if (set_current_directory(argv[1]))
msgf(STR_CHDIR_ERROR);
}
else
{
if (get_current_directory(dir, sizeof(dir)) == 0)
printf("%s\n", dir);
}
return 0;
}
static int target_set_mac(target_context_t *tc, const unsigned char *mac)
{
char buf [CMDBUF_LENGTH];
/* set MAC address on target */
strcpy(buf, "mac ");
sprintmac(buf + 4, mac);
msgf("setting target MAC to `%s'\n", buf + 4);
target_write_command(tc, buf);
if(target_confirm_response(tc) == -1){
return -1;
}
/* update our local copy on success */
memcpy(tc->remote_mac, mac, 6);
return 0;
}
int target_retry_command_and_data(target_context_t *tc,
const char *command,
const void *data, size_t count)
{
int retries = 3;
while (retries--) {
msgf("trying command/data (retries = %d)\n", retries);
target_write_command(tc, command);
if (target_get_response(tc))
continue;
target_write_data(tc, data, count);
if (target_get_response(tc) == 0)
return 0;
}
panic("command/data write retry count exceeded.");
return -1;
}
void target_write_command(target_context_t *tc, const char *command)
{
char buf [MAX_COMMAND_LENGTH + 1];
size_t len;
assert(tc);
assert(command);
assert(strlen(command) < sizeof buf - 2);
/* tack '\n' onto the end of the command */
len = strlen(command);
memcpy(buf, command, len);
buf[len++] = '\n';
buf[len] = '\0';
msgf("writing command: %s", buf);
assert(tc->write);
tc->write(tc, buf, len);
}
int help(const char* cmd)
{
int i;
const char* str_cmd = NULL;
const char* str_help = NULL;
const char* str_usage = NULL;
if (cmd == NULL)
{
printf("%s:\n\n", res_str(STR_HELP));
for (i = 0; commands[i].fn != NULL; i++)
{
str_cmd = res_str(commands[i].res_id);
str_help = str_cmd + strlen(str_cmd) + 1;
printf("%-20s %s\n", str_cmd, str_help);
}
printf("\n");
}
else
{
for (i = 0; commands[i].fn != NULL; i++)
{
str_cmd = res_str(commands[i].res_id);
if (strcmp(str_cmd, cmd) == 0)
{
str_help = str_cmd + strlen(str_cmd) + 1;
str_usage = str_help + strlen(str_help) + 1;
break;
}
}
if (commands[i].fn != NULL)
printf("%s\n\n%s\n", str_help, str_usage);
else
msgf(STR_UNKNOWN_COMMAND);
}
return 0;
}
int bin_file::save(const char* file, void* data, int len)
{
FILE* f;
int rc = -1;
f = fopen(file, "wb");
if (f == NULL)
{
msgf(STR_UNABLE_TO_OPEN_FILE);
return -1;
}
if (fwrite(data, len, 1, f) != (size_t)len)
goto cleanup;
rc = 0;
cleanup:
fclose(f);
return rc;
}
int context_menu_cave(int cy, int cx, int adjacent, int mx, int my)
{
menu_type *m;
rect_region r;
int selected;
char *labels;
cave_type *c_ptr = area(cx,cy);
pcave_type *pc_ptr = parea(cx,cy);
feature_type *feat;
object_type *o_ptr;
/* paranoia */
if (!in_boundsp(cx,cy)) return 0;
m = menu_dynamic_new();
if (!m) {
return 0;
}
labels = (char*)string_make(lower_case);
m->selections = labels;
feat = &(f_info[c_ptr->feat]);
menu_dynamic_add_label(m, "Look At", 'l', 1, labels);
if (c_ptr->m_idx) {
menu_dynamic_add_label(m, "Recall Info", '/', 18, labels);
}
menu_dynamic_add_label(m, "Use Item On", 'u', 2, labels);
if (player_can_cast()) {
menu_dynamic_add_label(m, "Cast On", 'm', 3, labels);
}
if (adjacent) {
if (c_ptr->m_idx && m_list[c_ptr->m_idx].ml) {
menu_dynamic_add_label(m, "Attack", '+', 4, labels);
} else {
menu_dynamic_add_label(m, "Alter", '+', 4, labels);
}
if (c_ptr->o_idx) {
o_ptr = chest_check(cx,cy);
if (o_ptr && o_ptr->pval) {
//if (!squelch_item_ok(o_ptr)) {
if (object_known_p(o_ptr)) {
if (chest_traps[o_ptr->pval]) {
menu_dynamic_add_label(m, "Disarm Chest", 'D', 5, labels);
menu_dynamic_add_label(m, "Open Chest", 'o', 8, labels);
} else {
menu_dynamic_add_label(m, "Open Disarmed Chest", 'o', 8, labels);
}
} else {
menu_dynamic_add_label(m, "Open Chest", 'o', 8, labels);
}
//}
}
}
if (is_visible_trap(c_ptr)) {
menu_dynamic_add_label(m, "Disarm", 'D', 5, labels);
menu_dynamic_add_label(m, "Jump Onto", 'W', 6, labels);
}
if (pc_ptr->feat) {
if ((feat->flags & FF_CLOSEABLE)
|| ((feat->flags & FF_BROKEN) && (feat->flags & FF_DOOR)))
{
menu_dynamic_add_label(m, "Close", 'c', 7, labels);
}
if (feat->flags & FF_CLOSED) {
menu_dynamic_add_label(m, "Open", 'o', 8, labels);
menu_dynamic_add_label(m, "Bash Open", 'B', 9, labels);
menu_dynamic_add_label(m, "Lock", 'D', 5, labels);
menu_dynamic_add_label(m, "Jam", 'j', 10, labels);
}
if (feat->flags & FF_DIG) {
menu_dynamic_add_label(m, "Tunnel", 'T', 11, labels);
}
}
menu_dynamic_add_label(m, "Search", 's', 12, labels);
menu_dynamic_add_label(m, "Walk Towards", ';', 14, labels);
} else {
menu_dynamic_add_label(m, "Pathfind To", ',', 13, labels);
menu_dynamic_add_label(m, "Walk Towards", ';', 14, labels);
menu_dynamic_add_label(m, "Run Towards", '.', 15, labels);
}
if (player_can_fire()) {
menu_dynamic_add_label(m, "Fire On", 'f', 16, labels);
}
if (c_ptr->m_idx && m_list[c_ptr->m_idx].ml) {
if (is_pet(&(m_list[c_ptr->m_idx]))) {
menu_dynamic_add_label(m, "Pet Commands", 'p', 19, labels);
}
}
menu_dynamic_add_label(m, "Throw To", 'v', 17, labels);
/* work out display region */
r.width = menu_dynamic_longest_entry(m) + 3 + 2; /* +3 for tag, 2 for pad */
if (mx > Term->wid - r.width - 1) {
r.col = Term->wid - r.width - 1;
} else {
r.col = mx + 1;
}
r.page_rows = m->count;
if (my > Term->hgt - r.page_rows - 1) {
if (my - r.page_rows - 1 <= 0) {
/* menu has too many items, so put in upper right corner */
r.row = 1;
r.col = Term->wid - r.width - 1;
} else {
r.row = Term->hgt - r.page_rows - 1;
}
} else {
r.row = my + 1;
}
/* Hack -- no flush needed */
msg_flag = FALSE;
screen_save();
button_backup_all(TRUE);
/* if there is a monster, draw a target path, which will be erased by the
* screen load below */
if (c_ptr->m_idx && m_list[c_ptr->m_idx].ml) {
sint path_n;
coord path_g[2*MAX_RANGE+1];
/* Find the path. */
path_n = project_path(path_g, p_ptr->px, p_ptr->py, cx, cy, PROJECT_THRU);
/* Draw the path. */
draw_path(path_n, path_g, NULL, NULL, p_ptr->px, p_ptr->py);
}
menu_layout(m, &r);
rect_region_erase_bordered(&r);
/* display the prompt for the context menu */
target_look_grid_prompt(0, 0, cx, cy,
format("($UEnter to select command$Y\n$V, $UESC$ to cancel$Y%c$V) You see", ESCAPE));
/* Hack - redraw stuff to show the target health bar */
health_redraw();
/* show the menu and pick from it */
selected = menu_dynamic_select(m);
menu_dynamic_free(m);
string_free(labels);
button_restore();
screen_load();
if (selected == 1) {
/* look at the spot */
if (target_set_interactive(TARGET_LOOK, cx, cy)) {
msgf("Target Selected.");
}
} else
if (selected == 2) {
/* use an item on the spot */
p_ptr->cmd.dir = 5;
p_ptr->cmd.cmd = 'u';
repeat_check();
do_cmd_use();
/*cmd_insert(CMD_USE_AIMED);
cmd_set_arg_target(cmd_get_top(), 1, DIR_TARGET);*/
} else
if (selected == 3) {
/* cast a spell on the spot */
p_ptr->cmd.dir = 5;
p_ptr->cmd.cmd = 'm';
repeat_check();
do_cmd_cast_wrapper();
/*if (textui_obj_cast_ret() >= 0) {
cmd_set_arg_target(cmd_get_top(), 1, DIR_TARGET);
}*/
} else
if (selected == 4) {
/* attack a spot adjacent to the player */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.arg = 16;
p_ptr->cmd.cmd = '+';
repeat_check();
do_cmd_alter();
/*cmd_insert(CMD_ALTER);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 5) {
/* disarm an adjacent trap or chest */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.arg = 1;
p_ptr->cmd.cmd = 'D';
repeat_check();
do_cmd_disarm();
/*cmd_insert(CMD_DISARM);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 6) {
/* walk onto an adjacent spot even if there is a trap there */
bool orig_disarm = easy_disarm;
easy_disarm = always_pickup;
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.arg = 1;
p_ptr->cmd.cmd = 'W';
repeat_check();
do_cmd_walk(always_pickup);
easy_disarm = orig_disarm;
/*cmd_insert(CMD_JUMP);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 7) {
/* close a door */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
/*p_ptr->cmd.arg = 1;*/
p_ptr->cmd.cmd = 'c';
repeat_check();
do_cmd_close();
/*cmd_insert(CMD_CLOSE);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 8) {
/* open a door or chest */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
/*p_ptr->cmd.arg = 1;*/
p_ptr->cmd.cmd = 'o';
repeat_check();
do_cmd_open();
/*cmd_insert(CMD_OPEN);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 9) {
/* bash a door */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
/*p_ptr->cmd.arg = 1;*/
p_ptr->cmd.cmd = 'o';
repeat_check();
do_cmd_open();
/*p_ptr->cmd.cmd = 'B';
do_cmd_bash();*/
/*cmd_insert(CMD_BASH);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 10) {
/* jam a door */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
/*p_ptr->cmd.arg = 1;*/
p_ptr->cmd.cmd = 'j';
repeat_check();
do_cmd_spike();
/*cmd_insert(CMD_JAM);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 11) {
/* Tunnel in a direction */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.arg = 16;
p_ptr->cmd.cmd = 'T';
repeat_check();
do_cmd_tunnel();
/*cmd_insert(CMD_TUNNEL);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 12) {
/* Search */
/*p_ptr->cmd.arg = 1;*/
p_ptr->cmd.cmd = 's';
repeat_check();
do_cmd_search();
/*cmd_insert(CMD_SEARCH);*/
} else
if (selected == 13) {
/* pathfind to the spot */
/*p_ptr->cmd.arg = 16;*/
p_ptr->cmd.cmd = ',';
do_cmd_pathfind(cx,cy);
/*cmd_insert(CMD_PATHFIND);
cmd_set_arg_point(cmd_get_top(), 0, cx, cy);*/
} else
if (selected == 14) {
/* walk towards the spot */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.cmd = ';';
repeat_check();
do_cmd_walk(always_pickup);
/*cmd_insert(CMD_WALK);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 15) {
/* run towards the spot */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.cmd = '.';
repeat_check();
do_cmd_run();
/*cmd_insert(CMD_RUN);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 16) {
/* Fire ammo towards the spot */
p_ptr->cmd.dir = 5;
p_ptr->cmd.cmd = 'f';
repeat_check();
do_cmd_fire();
/*cmd_insert(CMD_FIRE);
cmd_set_arg_target(cmd_get_top(), 1, DIR_TARGET);*/
} else
if (selected == 17) {
/* throw an item towards the spot */
p_ptr->cmd.dir = 5;
p_ptr->cmd.cmd = 'v';
repeat_check();
do_cmd_throw();
/*cmd_insert(CMD_THROW);
cmd_set_arg_target(cmd_get_top(), 1, DIR_TARGET);*/
} else
if (selected == 18) {
/* recall monster Info */
monster_type *m_ptr = &m_list[c_ptr->m_idx];
if (m_ptr) {
/* Save screen */
screen_save();
button_backup_all(TRUE);
/* Recall on screen */
screen_roff_mon(m_ptr->r_idx, 0);
/* wait for a key or mouse press */
inkey();
/* Load screen */
button_restore();
screen_load();
}
} else
if (selected == 19) {
/* issue a pet command */
p_ptr->cmd.cmd = 'p';
repeat_check();
do_cmd_pet();
}
return 1;
}
int context_menu_player(int mx, int my)
{
menu_type *m;
rect_region r;
int selected;
char *labels;
cave_type *c_ptr = area(p_ptr->px,p_ptr->py);
pcave_type *pc_ptr = parea(p_ptr->px,p_ptr->py);
feature_type *feat;
m = menu_dynamic_new();
if (!m) {
return 0;
}
labels = (char*)string_make(lower_case);
m->selections = labels;
feat = &(f_info[c_ptr->feat]);
menu_dynamic_add_label(m, "Use Item", 'u', 1, labels);
/* if player can cast, add casting option */
if (player_is_caster()) {
if (player_can_cast()) {
menu_dynamic_add_label(m, "Cast", 'm', 2, labels);
} else {
menu_dynamic_add_label(m, "$Cast", 'm', 2, labels);
}
}
/* if player can use racial powers or mutations, add option */
if (player_has_power()) {
if (player_can_use_power()) {
menu_dynamic_add_label(m, "Use Power", 'U', 16, labels);
} else {
menu_dynamic_add_label(m, "$Use Power", 'U', 16, labels);
}
}
/* if player is on stairs add option to use them */
if (feat->flags & FF_EXIT_UP) {
menu_dynamic_add_label(m, "Go Up", '<', 11, labels);
}
if (feat->flags & FF_EXIT_DOWN) {
menu_dynamic_add_label(m, "Go Down", '>', 12, labels);
}
menu_dynamic_add_label(m, "Search", 's', 3, labels);
menu_dynamic_add_label(m, "Look", 'l', 6, labels);
menu_dynamic_add_label(m, "Rest", 'R', 4, labels);
menu_dynamic_add_label(m, "Inventory", 'i', 5, labels);
/* if object under player add pickup option */
if (c_ptr->o_idx) {
object_type *o_ptr = &(o_list[c_ptr->o_idx]);
//if (!squelch_item_ok(o_ptr)) {
menu_dynamic_add_label(m, "Floor", 'i', 13, labels);
if (inven_carry_okay(o_ptr)) {
menu_dynamic_add_label(m, "Pickup", 'g', 14, labels);
} else {
menu_dynamic_add_label(m, "$Pickup", 'g', 14, labels);
}
//}
}
menu_dynamic_add_label(m, "Character", 'C', 7, labels);
/* XXX Don't show the keymap line until the keymap list is implemented, to
* avoid confusion as to what should be there */
/*menu_dynamic_add(m, "Keymaps", 10);*/
if (!OPT(center_player)) {
menu_dynamic_add_label(m, "^Center Map", 'L', 15, labels);
}
menu_dynamic_add_label(m, "Other", ' ', 9, labels);
/* work out display region */
r.width = menu_dynamic_longest_entry(m) + 3 + 2; /* +3 for tag, 2 for pad */
if (mx > Term->wid - r.width - 1) {
r.col = Term->wid - r.width - 1;
} else {
r.col = mx + 1;
}
r.page_rows = m->count;
if (my > Term->hgt - r.page_rows - 1) {
if (my - r.page_rows - 1 <= 0) {
/* menu has too many items, so put in upper right corner */
r.row = 1;
r.col = Term->wid - r.width - 1;
} else {
r.row = Term->hgt - r.page_rows - 1;
}
} else {
r.row = my + 1;
}
/* Hack -- no flush needed */
msg_flag = FALSE;
screen_save();
button_backup_all(TRUE);
menu_layout(m, &r);
rect_region_erase_bordered(&r);
prtf(0, 0, "($UEnter to select$Y\n$V, $UESC$Y%c$V) Command:", ESCAPE);
selected = menu_dynamic_select(m);
menu_dynamic_free(m);
string_free(labels);
button_restore();
screen_load();
switch(selected) {
case 1:
{
/* use an item */
p_ptr->cmd.cmd = 'u';
repeat_check();
do_cmd_use();
} break;
case 2:
{
/* Cast a spell */
p_ptr->cmd.cmd = 'm';
repeat_check();
do_cmd_cast_wrapper();
} break;
case 3:
{
/* search */
p_ptr->cmd.cmd = 's';
repeat_check();
do_cmd_search();
} break;
case 4:
{
/* rest */
p_ptr->cmd.cmd = 'R';
repeat_check();
do_cmd_rest();
} break;
case 5:
{
/* show inventory screen */
Term_keypress('i');//,0);
} break;
case 6:
{
/* look mode */
if (target_set(TARGET_LOOK)) {
//if (target_set_interactive(TARGET_LOOK, p_ptr->px, p_ptr->py)) {
msgf("Target Selected.");
}
} break;
case 7:
{
/* show character screen */
do_cmd_character();
} break;
case 9:
{
/* show another layer of menu options screen */
int res;
while ((res = context_menu_player_2(mx,my)) == 3);
if (res == 2) return 3;
} break;
case 10:
{
/* show the commands */
int res;
while ((res = context_menu_command(mx,my)) == 3);
if (res == 2) return 3;
} break;
case 11:
{
/* go up stairs */
p_ptr->cmd.cmd = '<';
repeat_check();
do_cmd_go_up();
} break;
case 12:
{
/* go down stairs */
p_ptr->cmd.cmd = '>';
repeat_check();
do_cmd_go_down();
} break;
case 13:
{
if (c_ptr->o_idx) {
object_type *o_ptr = &(o_list[c_ptr->o_idx]);
/* there is an item on the floor, show the inventory screen starting
* from the floor */
if (o_ptr->next_o_idx) {
do_cmd_inven_floor();
} else {
/* if we only have one item, show the context menu directly */
if (o_ptr->k_idx) {
/* Track the object kind */
object_kind_track(o_ptr->k_idx);
while (context_menu_object(o_ptr) == 2);
}
}
}
} break;
case 14:
{
/* pick the item up */
//cmd_insert(CMD_PICKUP);
//cmd_set_arg_item(cmd_get_top(), 0, -1);
carry(TRUE);
} break;
case 15:
{
/* center the map on the player */
/*panel_center(p_ptr->px, p_ptr->py);*/
do_cmd_center_map();
} break;
case 16:
{
/* use character powers */
p_ptr->cmd.cmd = 'U';
repeat_check();
do_cmd_racial_power();
} break;
}
return 1;
}
int program_file::save(const char*, void*, int)
{
msgf(STR_INVALID_FILE_FORMAT);
return -1;
}
int mcs_file::load(const char* name)
{
FILE *f;
int rc = -1;
char line[256];
struct stat st;
int len, type, addr;
unsigned char buff[64];
int addr_offs = 0;
u32 max_length;
if (data || length)
// Call clear() first
return -1;
if (stat(name, &st) < 0)
{
msgf(STR_UNABLE_TO_OPEN_FILE);
return -1;
}
f = fopen(name, "rt");
if (f == NULL)
{
msgf(STR_UNABLE_TO_OPEN_FILE);
return -1;
}
// This size must be enough!
max_length = st.st_size / 2;
data = (u8*)malloc(max_length);
if (data == NULL)
goto cleanup;
memset(data, 0xFF, max_length);
length = 0;
// Read lines
while(!feof(f))
{
if (fgets(line, sizeof(line), f) == NULL)
break;
strip_whitespaces(line);
if (parse_record(line, &len, &addr, &type, buff, sizeof(buff)))
{
msgf(STR_INVALID_FILE_FORMAT);
goto cleanup;
}
if (type == RECORD_DATA)
{
if ((u32)(addr_offs + addr + len) > max_length)
{
msgf(STR_INVALID_FILE_FORMAT);
goto cleanup;
}
memcpy(data + addr_offs + addr, buff, len);
if ((u32)(addr_offs + addr + len) > length)
length = (u32)(addr_offs + addr + len);
}
else
if (type == RECORD_ADDRESS)
addr_offs = (buff[0] << 24) + (buff[1] << 16);
else
if (type == RECORD_EOF)
// EOF
break;
}
rc = 0;
cleanup:
if (rc)
clear();
if (f)
fclose(f);
return rc;
}
