static int help_getdata(struct _select_def *conf, int pos, int len)
{
int i;
int mode = *((int *)conf->arg);
for (i=0; i<help_num; i++) {
if (s_help[i].content) free(s_help[i].content);
}
bzero(s_help, sizeof(struct helps)*BBS_PAGESIZE);
// if( conf->item_count - conf->page_pos < BBS_PAGESIZE)
conf->item_count = count_help(mode);
i=get_help(s_help, mode , conf->page_pos -1, BBS_PAGESIZE);
if (i<=0) {
conf->pos = 1;
conf->page_pos = 1;
help_search[0]=0;
conf->item_count = count_help(mode);
i=get_help(s_help, mode, 0, BBS_PAGESIZE);
if (i<= 0)
return SHOW_QUIT;
}
help_num = i;
return SHOW_CONTINUE;
}
int
main(int argc, char* argv[])
{
int res;
while ((res = getopt(argc,argv,"l:o:m:vdh")) != -1){
switch (res) {
case 'o':
csvfile = optarg;
break;
case 'm':
monitor = optarg;
break;
case 'v':
printf("VERBOSE MOD!\n");
is_verbose = 1;
break;
case 'd':
printf("DEBUG MOD!\n");
is_debug = 1;
break;
case 'h':
get_help();
default:
printf("Error found !\n");
exit(0);
};
};
argc -= optind;
argv += optind;
if (monitor == NULL) {
warning("You need specify sites for monitoring\n");
get_help();
exit(1);
}
if (is_verbose) {
if (csvfile)
printf("Output CSV file: %s\n", csvfile);
else
printf("Output: STDOUT\n");
printf("Monitor sites: %s\n", monitor);
}
process_args(argc, argv);
return 0;
}
main(int argc, char ** argv)
{
check_help();
extern char *poptarg;
extern char *poparr[];
int c;
const char *param_string = "";
while ((c = pgetopt(argc, argv, param_string,
"$Revision: 1.5 $", _SRC_)) != -1)
switch(c) {
case '?': params_to_usage(cerr, argv[0], param_string);
get_help();
exit(1);
}
dyn *b;
real prev_time = -VERY_LARGE_NUMBER;
cerr.precision(HIGH_PRECISION);
while (b = get_dyn()) {
real time = b->get_system_time();
if (prev_time > -VERY_LARGE_NUMBER) {
real dt = time - prev_time;
PRC(time); PRL(dt);
} else
PRL(time);
prev_time = time;
rmtree(b);
}
}
int conf_string(struct menu *menu)
{
struct symbol *sym = menu->sym;
const char *def;
while (1) {
printf("%*s%s ", indent - 1, "", _(menu->prompt->text));
printf("(%s) ", sym->name);
def = sym_get_string_value(sym);
if (sym_get_string_value(sym))
printf("[%s] ", def);
if (!conf_askvalue(sym, def))
return 0;
switch (line[0]) {
case '\n':
break;
case '?':
/* print help */
if (line[1] == '\n') {
printf("\n%s\n", get_help(menu));
def = NULL;
break;
}
default:
line[strlen(line)-1] = 0;
def = line;
}
if (def && sym_set_string_value(sym, def))
return 0;
}
}
void uart_rx_process(void)
{
switch (g_uart_rx_buff[0]) {
case 'r':
get_stat();
break;
case 'u':
get_transmitter_uptime();
break;
case 's':
x_start();
break;
case 'q':
if (g_uart_rx_buff[1] == 'd') {
x_get_page();
} else {
x_get_status();
}
break;
case '?':
get_help();
break;
default:
uart_printf("invalid command, send ? to get help" UART_EOL);
uart_tx_flush();
}
}
void
Program_Options::check_options()
{
bool loop = true;
int verify = main_options();
if(verify != 0) {
while(loop) {
if (command == "help") {
for (auto c : *command_container) {
if ( subcommand == c.first) {
cout << get_help(c.first, c.second).str();
loop = false;
}
}
if(loop){
cout << get_main_help() << endl ;
loop = false;
}
}
else if (check_command() == true && loop == true) {
loop = false;
}
if(loop){
cout << get_main_help() << endl ;
loop = false;
}
}
}
}
int main(int argc, char ** argv)
{
int n = 1;
real m = 1.0;
check_help();
extern char *poptarg;
int c;
const char *param_string = "m:n:";
while ((c = pgetopt(argc, argv, param_string,
"$Revision: 1.9 $", _SRC_)) != -1)
switch(c) {
case 'm': m = atof(poptarg);
break;
case 'n': n = atoi(poptarg);
break;
case '?': params_to_usage(cerr, argv[0], param_string);
get_help();
exit(1);
}
if (m <= 0) err_exit("mknodes: M > 0 required!");
if (n <= 0) err_exit("mknodes: N > 0 required!");
node * root = mknode_mass(n, m);
root->log_history(argc, argv);
put_node(root);
rmtree(root);
return 0;
}
/*********************************************************************
*
* 0 - Help printed
* 1 - Command
*
*********************************************************************/
int gethelp(char *str) {
char *list;
char *p;
static char helpstr[] = "help [command]\nquit/exit";
static char help[] = "help";
if (strncmp(str, help, 4) == 0) {
/* Skip word "help" */
p = str + 4;
while (isspace((int)*p))
p++;
if ((*p != '\0') && (list = get_help(p))) {
if (write(1, list, strlen(list)) == -1)
printf("Failed write to stdout.\n");
free(list);
return 0;
} else {
if ((list = get_list_of_cmd()) == NULL) {
if (debug)
syslog(LOG_DEBUG, "NULL cmdlist");
if (write(1, helpstr, strlen(helpstr)) == -1)
printf("Failed write to stdout.\n");
return 0;
}
printf("%s%s", list, helpstr);
free(list);
return 0;
}
}
return 1;
}
int main(int argc, char *argv[])
{
int opt;
struct option longopts[] = {
{"initialize", 0, NULL, 'i'},
{"help", 0, NULL, 'h'},
{"list", 0, NULL, 'l'},
{"restart", 0, NULL, 'r'},
{0,0,0,0}
};
#if 0
while((opt = getopt(argc, argv, ":if:lr:h")) != -1) {
switch(opt) {
case 'i':
case 'h':
case 'r':
printf("option: %c\n", opt);
break;
case 'f':
printf("filename: %s\n", optarg);
break;
case ':':
printf("option needs a value\n");
break;
case '?':
printf("unknown option: %c\n", optopt);
break;
}
}
for(; optind < argc; optind++)
printf("argument: %s\n", argv[optind]);
#endif
do {
get_help();
switch(opt)
{
case 1:
init_server();
break;
case 2:
init_sla_support();
break;
case 3:
init_client();
break;
default:
printf("Oops you might pressed '%d' ", opt );
}
} while(opt != 0);
while(1)
{
sleep(1000);
}
}
/***************************************************************************//**
* @brief main
*******************************************************************************/
int main(void)
{
Xil_ICacheEnable();
Xil_DCacheEnable();
gpio_init(GPIO_DEVICE_ID);
gpio_direction(54 + 46, 1);
spi_init(SPI_DEVICE_ID, 1, 0);
adc_init();
dac_init(DATA_SEL_DDS);
ad9361_phy = ad9361_init(&default_init_param);
ad9361_set_tx_fir_config(ad9361_phy, tx_fir_config);
ad9361_set_rx_fir_config(ad9361_phy, rx_fir_config);
#ifdef DAC_DMA
dac_init(DATA_SEL_DMA);
#else
dac_init(DATA_SEL_DDS);
#endif
#ifdef CAPTURE_SCRIPT
adc_capture(16384, ADC_DDR_BASEADDR);
while(1);
#endif
get_help(NULL, 0);
while(1)
{
console_get_command(received_cmd);
invalid_cmd = 0;
for(cmd = 0; cmd < cmd_no; cmd++)
{
param_no = 0;
cmd_type = console_check_commands(received_cmd, cmd_list[cmd].name,
param, ¶m_no);
if(cmd_type == UNKNOWN_CMD)
{
invalid_cmd++;
}
else
{
cmd_list[cmd].function(param, param_no);
}
}
if(invalid_cmd == cmd_no)
{
console_print("Invalid command!\n");
}
}
Xil_DCacheDisable();
Xil_ICacheDisable();
return 0;
}
int main()
{
int sock;
struct sockaddr_in server;
char buffer[MAXBUF];
//Создание сокета
sock = socket(AF_INET , SOCK_STREAM , 0);
if (sock == -1)
{
printf("Could not create socket");
}
puts("Socket created\n");
server.sin_addr.s_addr = inet_addr("127.0.0.1");
server.sin_family = AF_INET;
server.sin_port = htons( 1234 );
//Connect to remote server
if (connect(sock , (struct sockaddr *)&server , sizeof(server)) < 0)
{
perror("connect failed. Error");
return 1;
}
bzero(buffer, MAXBUF);
recv(sock , buffer , MAXBUF , 0); // прием слова
puts(buffer);
printf("Для получения справки введите команду help\n");
while(1){
bzero(buffer, MAXBUF);
printf("Cmd: ");
scanf("%s" , buffer);
// команды
if(strcmp(buffer, "view") == 0)
view_dir(buffer, sock, MAXBUF);
else if(strcmp(buffer, "view_dir") == 0)
view_dir(buffer, sock, MAXBUF);
else if(strcmp(buffer, "help") == 0)
get_help();
else if(strcmp(buffer, "get_dir") == 0)
get_dir(buffer, sock, MAXBUF);
else if(strcmp(buffer, "ch_dir") == 0)
ch_dir(buffer, sock, MAXBUF);
else if(strcmp(buffer, "upload") == 0)
upload(buffer, MAXBUF, sock);
else if(strcmp(buffer, "mk_dir") == 0)
mk_dir(buffer, MAXBUF, sock);
else if(strcmp(buffer, "rm_dir") == 0)
rm_dir(buffer, MAXBUF, sock);
else
printf("unknown comand\n");
printf("Для получения справки введите команду help\n");
}
close(sock);
return 0;
}
void Terminal::parse_line(String line) {
int spacer = line.indexOf(" ");
String command = line.substring(0,spacer);
if(command == "pid") {
if(line.length() > (spacer + 1)) {
String rest = line.substring(spacer+1);
manage_pid(rest);
} else { get_help(); }
}
else if(command == "online") {
int cur_time = (millis() - global_info.start_time) / 1000;
Serial1.print("Time from start : ");
Serial1.println(cur_time);
}
else {
get_help();
}
}
void Terminal::manage_pid(String opts) {
int spacer = opts.indexOf(" ");
String action = opts.substring(0, spacer);
if(action == "current") {
get_PID_settings();
} else if (action == "set") {
if(opts.length() > (spacer + 1)) {
String rest = opts.substring(spacer+1);
set_PID_settings(rest);
} else { get_help(); }
}
}
void do_neededhelpfiles(CHAR_DATA *ch, char *argument)
{
HELP_DATA *pHelp;
bool bIsHelp = TRUE;
char *agg;
sh_int col = 0;
int star = 0;
int cmd;
int nLimit = 0;
bool bChanged = FALSE;
bool foundstar = FALSE;
char buf[MAX_INPUT_LENGTH];
if ( argument[0] == '\0' ) return stcf(ch,"Syntax: neededhelpfiles <max amount of help files>\n\r");
nLimit = atoi(argument);
for ( cmd = 0; cmd_table[cmd].name[0] != '\0'; cmd++ )
{
foundstar = TRUE;
agg = cmd_table[cmd].name;
if ( (pHelp = get_help( ch, agg )) == NULL )
{
bIsHelp = FALSE;
star++;
col++;
if ( star >= nLimit ) break;
bChanged = TRUE;
}
else
bIsHelp = TRUE;
sprintf( buf, "%-15s#n",cmd_table[cmd].name );
if ( bIsHelp == FALSE )
send_to_char( buf, ch );
if ( col % 5 == 0 && bChanged == TRUE)
send_to_char( "\n\r", ch );
bChanged = FALSE;
}
if (col % 5 != 0 && foundstar)
send_to_char("\n\r", ch);
if (foundstar && star != 0)
{
sprintf(buf, "\n%d command%s found.\n\r", star,
(star > 1) ? "s" : "");
stc(buf, ch);
}
if (!foundstar)
{
stc("No commands found.\n\r", ch);
}
return;
}
// fixme: move to task.c
int exec(int argc, char *argv[])
{
int ret;
const struct command *exe;
struct task *current;
int (*main)(int, char *[]);
// fixme
for (exe = build_in_cmd; exe < build_in_cmd + ARRAY_ELEM_NUM(build_in_cmd); exe++) {
if (!strncmp(exe->name, argv[0], MAX_ARG_LEN)) {
goto L1;
}
}
for (exe = g_exe_begin; exe < g_exe_end; exe++) {
if (!strncmp(exe->name, argv[0], MAX_ARG_LEN)) {
goto L1;
}
}
printf(" command \"%s\" not found!\n"
" Please use \"help\" to get g-bios command list.\n", argv[0]);
return -ENOEXEC;
L1:
main = exe->main;
if (!main)
return -EINVAL;
current = malloc(sizeof(*current));
if (!current)
return -ENOMEM;
current->argc = argc;
current->argv = argv;
current->exe = exe;
current->help = get_help(argv[0]); // fixme
set_current_task(current);
getopt_init();
ret = main(argc, argv);
set_current_task(NULL);
free(current);
return ret;
}
/*-----------------------------------------------------------------------------
* main -- driver to create directly a single node
*-----------------------------------------------------------------------------
*/
main(int argc, char ** argv)
{
bool c_flag = FALSE;
bool i_flag = FALSE;
real m = 1; // default mass: unity
char *comment;
check_help();
extern char *poptarg;
int c;
const char *param_string = "c:im:";
while ((c = pgetopt(argc, argv, param_string,
"$Revision: 1.7 $", _SRC_)) != -1)
switch(c) {
case 'c': c_flag = TRUE;
comment = poptarg;
break;
case 'i': i_flag = TRUE;
break;
case 'm': m = atof(poptarg);
break;
case '?': params_to_usage(cerr, argv[0], param_string);
get_help();
exit(1);
}
node * root;
root = new node();
root->set_root(root);
root->set_mass(m);
if (c_flag == TRUE)
root->log_comment(comment);
root->log_history(argc, argv);
if (i_flag)
root->set_label(1);
put_node(root);
rmtree(root);
}
static sint read_matrix(char *title,MatMenu menu, char *matnam, sint matn, short *mat, short *xref)
{ static char userfile[FILENAMELEN+1];
int i;
while(TRUE)
{
fprintf(stdout,"\n\n\n");
fprintf(stdout," ********* %s WEIGHT MATRIX MENU *********\n",title);
fprintf(stdout,"\n\n");
for(i=0;i<menu.noptions;i++)
fprintf(stdout," %d. %s\n",i+1,menu.opt[i].title);
fprintf(stdout," H. HELP\n\n");
fprintf(stdout,
" -- Current matrix is the %s ",menu.opt[matn-1].title);
if(matn == menu.noptions) fprintf(stdout,"(file = %s)",userfile);
fprintf(stdout,"--\n");
getstr("\n\nEnter number (or [RETURN] to exit)",lin2);
if(*lin2 == EOS) return(matn);
i=toupper(*lin2)-'0';
if(i>0 && i<menu.noptions) {
strcpy(matnam,menu.opt[i-1].string);
matn=i;
} else if (i==menu.noptions) {
if(user_mat(userfile, mat, xref)) {
strcpy(matnam,userfile);
matn=i;
}
}
else
switch(toupper(*lin2)) {
case '?':
case 'H':
get_help('8');
break;
default:
fprintf(stdout,"\n\nUnrecognised Command\n\n");
break;
}
}
}
int help(int argc, const char** argv) {
shell_func func;
//Check if they are trying to find help for a particular command
if (argc > 1) {
func = get_help(argv[1]);
if (func == NULL) {
putstr("Sorry no help exists for the command '");
putstr(argv[1]);
putstr("'\n");
} else {
func(argc, (const char **)argv);
}
} else {
//List all possible commands
putstr("Available commands:");
putoptions(get_commands(""));
putch('\n');
}
return 0;
}
static sint secstroutput_options(void)
{
while(TRUE)
{
fprintf(stdout,"\n\n\n");
fprintf(stdout," ********* Secondary Structure Output Menu *********\n");
fprintf(stdout,"\n\n");
fprintf(stdout," 1. %s\n",secstroutput_txt[0]);
fprintf(stdout," 2. %s\n",secstroutput_txt[1]);
fprintf(stdout," 3. %s\n",secstroutput_txt[2]);
fprintf(stdout," 4. %s\n",secstroutput_txt[3]);
fprintf(stdout," H. HELP\n\n");
fprintf(stdout,
" -- Current output is %s ",secstroutput_txt[output_struct_penalties]);
fprintf(stdout,"--\n");
getstr("\n\nEnter number (or [RETURN] to exit)",lin2);
if(*lin2 == EOS) return(output_struct_penalties);
switch(toupper(*lin2))
{
case '1': return(0);
case '2': return(1);
case '3': return(2);
case '4': return(3);
case '?':
case 'H': get_help('C');
case 'Q':
case 'X': return(0);
default: fprintf(stdout,"\n\nUnrecognised Command\n\n");
break;
}
}
}
main(int argc, char **argv)
{
dyn *root;
int e_flag = 0;
real eps = 0;
check_help();
extern char *poptarg;
int c;
const char *param_string = "e:";
while ((c = pgetopt(argc, argv, param_string,
"$Revision: 1.6 $", _SRC_)) != -1)
switch(c) {
case 'e': e_flag = 1;
eps = atof(poptarg);
break;
case '?': params_to_usage(cerr, argv[0], param_string);
get_help();
exit(1);
}
// Loop over input until no more data remain.
while ( (root = get_dyn()) != NULL) {
real kinetic_energy, potential_energy;
get_top_level_energies(root, eps*eps, potential_energy, kinetic_energy);
cout << "Top-level energies (T, U, E): "
<< kinetic_energy << " "
<< potential_energy << " "
<< kinetic_energy + potential_energy
<< endl;
}
}
static int conf_choice(struct menu *menu)
{
struct symbol *sym, *def_sym;
struct menu *child;
int type;
bool is_new;
sym = menu->sym;
type = sym_get_type(sym);
is_new = !sym_has_value(sym);
if (sym_is_changable(sym)) {
conf_sym(menu);
sym_calc_value(sym);
switch (sym_get_tristate_value(sym)) {
case no:
return 1;
case mod:
return 0;
case yes:
break;
}
} else {
switch (sym_get_tristate_value(sym)) {
case no:
return 1;
case mod:
printf("%*s%s\n", indent - 1, "", _(menu_get_prompt(menu)));
return 0;
case yes:
break;
}
}
while (1) {
int cnt, def;
printf("%*s%s\n", indent - 1, "", _(menu_get_prompt(menu)));
def_sym = sym_get_choice_value(sym);
cnt = def = 0;
line[0] = 0;
for (child = menu->list; child; child = child->next) {
if (!menu_is_visible(child))
continue;
if (!child->sym) {
printf("%*c %s\n", indent, '*', _(menu_get_prompt(child)));
continue;
}
cnt++;
if (child->sym == def_sym) {
def = cnt;
printf("%*c", indent, '>');
} else
printf("%*c", indent, ' ');
printf(" %d. %s", cnt, _(menu_get_prompt(child)));
if (child->sym->name)
printf(" (%s)", child->sym->name);
if (!sym_has_value(child->sym))
printf(_(" (NEW)"));
printf("\n");
}
printf(_("%*schoice"), indent - 1, "");
if (cnt == 1) {
printf("[1]: 1\n");
goto conf_childs;
}
printf("[1-%d", cnt);
if (menu_has_help(menu))
printf("?");
printf("]: ");
switch (input_mode) {
case ask_new:
case ask_silent:
if (!is_new) {
cnt = def;
printf("%d\n", cnt);
break;
}
check_stdin();
case ask_all:
fflush(stdout);
fgets(line, 128, stdin);
strip(line);
if (line[0] == '?') {
printf("\n%s\n", get_help(menu));
continue;
}
if (!line[0])
cnt = def;
else if (isdigit(line[0]))
cnt = atoi(line);
else
continue;
break;
default:
break;
}
conf_childs:
for (child = menu->list; child; child = child->next) {
if (!child->sym || !menu_is_visible(child))
continue;
if (!--cnt)
break;
}
if (!child)
continue;
if (line[strlen(line) - 1] == '?') {
printf("\n%s\n", get_help(child));
continue;
}
sym_set_choice_value(sym, child->sym);
for (child = child->list; child; child = child->next) {
indent += 2;
conf(child);
indent -= 2;
}
return 1;
}
}
static int conf_sym(struct menu *menu)
{
struct symbol *sym = menu->sym;
int type;
tristate oldval, newval;
while (1) {
printf("%*s%s ", indent - 1, "", _(menu->prompt->text));
if (sym->name)
printf("(%s) ", sym->name);
type = sym_get_type(sym);
putchar('[');
oldval = sym_get_tristate_value(sym);
switch (oldval) {
case no:
putchar('N');
break;
case mod:
putchar('M');
break;
case yes:
putchar('Y');
break;
}
if (oldval != no && sym_tristate_within_range(sym, no))
printf("/n");
if (oldval != mod && sym_tristate_within_range(sym, mod))
printf("/m");
if (oldval != yes && sym_tristate_within_range(sym, yes))
printf("/y");
if (menu_has_help(menu))
printf("/?");
printf("] ");
if (!conf_askvalue(sym, sym_get_string_value(sym)))
return 0;
strip(line);
switch (line[0]) {
case 'n':
case 'N':
newval = no;
if (!line[1] || !strcmp(&line[1], "o"))
break;
continue;
case 'm':
case 'M':
newval = mod;
if (!line[1])
break;
continue;
case 'y':
case 'Y':
newval = yes;
if (!line[1] || !strcmp(&line[1], "es"))
break;
continue;
case 0:
newval = oldval;
break;
case '?':
goto help;
default:
continue;
}
if (sym_set_tristate_value(sym, newval))
return 0;
help:
printf("\n%s\n", get_help(menu));
}
}
main(int argc, char ** argv)
{
char *comment;
bool c_flag = FALSE; // if TRUE, a comment given on command line
real t_extract;
bool t_flag = FALSE; // if TRUE, a time was specified
bool v_flag = FALSE; // if TRUE, print snap times as read
int n = 1;
bool n_flag = false; // if TRUE, a number was specified
check_help();
extern char *poptarg;
int c;
const char *param_string = "c:n:t:v";
while ((c = pgetopt(argc, argv, param_string,
"$Revision: 1.8 $", _SRC_)) != -1)
switch(c) {
case 'c': c_flag = TRUE;
comment = poptarg;
break;
case 't': t_flag = TRUE;
t_extract = atof(poptarg);
break;
case 'n': n_flag = TRUE;
n = atoi(poptarg);
break;
case 'v': v_flag = TRUE;
break;
case '?': params_to_usage(cerr, argv[0], param_string);
get_help();
exit(1);
}
if (n < 0) err_exit("n < 0 specified.");
if (n > 1 && !t_flag) {
warning("n > 1 but no time specified -- 0 assumed.");
t_extract = 0;
t_flag = true;
}
node *b = NULL, *bp = NULL;
int i = 0;
// Need to ensure that the data are not changed by this function.
// Currently, get_dyn() ends by calling check_and_correct_node(),
// which may change pos and vel to force the system to the center
// of mass frame. Can fix (1) by suppressing this call in this
// case, (2) setting a tolerance to avoid forcing if the system is
// already "close" to the CM frame, or (3) use nodes here, which
// will never interpret pos or vel and hence will not change them.
// The only number we really need below is sytsem_time. Options
// (1) and (2) are awkward, because this function is a member
// function and changing its arguments would propagate through the
// other classes. However, we could add a static local option to
// the dyn instance of the function. Option (3) seems cleanest.
// To revert, change node to dyn and use b->get_system_time() to
// determine time.
// (Steve, 7/04)
while (b = get_node()) {
real time;
if (find_qmatch(b->get_dyn_story(), "real_system_time"))
time = getrq(b->get_dyn_story(), "real_system_time");
else
time = getrq(b->get_dyn_story(), "system_time");
// real time = b->get_system_time();
i++;
if (v_flag) cerr << "Snap time #" << i << " = " << time << endl;
if (t_flag && time >= t_extract) {
if (n > 0) {
if (c_flag == TRUE)
b->log_comment(comment);
b->log_history(argc, argv);
put_node(b);
}
if (--n <= 0) exit(0);
}
if (bp) rmtree(bp);
bp = b;
}
if (n > 0 && !t_flag) {
bp->log_history(argc, argv);
put_node(bp);
}
}
main(int argc, char ** argv)
{
bool renumber = true;
check_help();
extern char *poptarg;
extern char *poparr[];
int c;
const char *param_string = "n";
// Parse the argument list:
while ((c = pgetopt(argc, argv, param_string,
"$Revision: 1.8 $", _SRC_)) != -1) {
switch (c) {
case 'n': renumber = false;
break;
default:
case '?': params_to_usage(cerr, argv[0], param_string);
get_help();
return false;
}
}
dyn *b, *root = new dyn;
if (!root) err_exit("merge_snaps: can't create root node.");
int count = 0;
root->log_history(argc, argv);
while (b = get_dyn()) {
b->offset_com(); // add root pos/vel to daughters
// Attach top-level nodes of b to root.
dyn *last = root->get_oldest_daughter();
while (last && last->get_younger_sister())
last = last->get_younger_sister();
for_all_daughters(dyn, b, bb) {
// First node is a special case.
if (!last)
root->set_oldest_daughter(bb);
else
last->set_younger_sister(bb);
bb->set_elder_sister(last);
bb->set_parent(root);
last = bb;
}
// Merge the root log stories, with a prefix indicating which
// initial snapshot this was. This code is not completely general,
// but should be sufficient for simple (typical) stories.
story *sr = root->get_log_story();
story *s = b->get_log_story();
for (story * d = s->get_first_daughter_node(); d != NULL;
d = d->get_next_story_node())
if (!d->get_chapter_flag()) {
char tmp[1024];
sprintf(tmp, " +%4.4d: ", count);
strncat(tmp, d->get_text(), 1013);
tmp[1023] = '\0';
add_story_line(sr, tmp);
}
count++;
delete b;
}
// Recompute the total mass and force the center of mass to 0.
// Better renumber too, unless specifically suppressed..
real mass = 0;
int index = 0;
for_all_daughters(dyn, root, bb) {
mass += bb->get_mass();
if (renumber) bb->set_index(++index);
}
static void multi_menu(void)
{
int catchint;
catchint = signal(SIGINT, SIG_IGN) != SIG_IGN;
if (catchint) {
if (setjmp(jmpbuf) != 0)
fprintf(stdout,"\n.. Interrupt\n");
#ifdef UNIX
if (signal(SIGINT,jumper) == BADSIG)
fprintf(stdout,"Error: signal\n");
#else
if (signal(SIGINT,SIG_DFL) == (void*)BADSIG)
fprintf(stdout,"Error: signal\n");
#endif
}
if(dnaflag) {
gap_open = dna_gap_open;
gap_extend = dna_gap_extend;
}
else {
gap_open = prot_gap_open;
gap_extend = prot_gap_extend;
}
while(TRUE) {
fprintf(stdout,"\n\n\n");
fprintf(stdout," ********* MULTIPLE ALIGNMENT PARAMETERS *********\n");
fprintf(stdout,"\n\n");
fprintf(stdout," 1. Gap Opening Penalty :%4.2f\n",gap_open);
fprintf(stdout," 2. Gap Extension Penalty :%4.2f\n",gap_extend);
fprintf(stdout," 3. Delay divergent sequences :%d %%\n\n",(pint)divergence_cutoff);
fprintf(stdout," 4. DNA Transitions Weight :%1.2f\n\n",transition_weight);
fprintf(stdout," 5. Protein weight matrix :%s\n"
,matrix_menu.opt[matnum-1].title);
fprintf(stdout," 6. DNA weight matrix :%s\n"
,dnamatrix_menu.opt[dnamatnum-1].title);
fprintf(stdout," 7. Use negative matrix :%s\n\n",(!neg_matrix) ? "OFF" : "ON");
fprintf(stdout," 8. Protein Gap Parameters\n\n");
fprintf(stdout," H. HELP\n\n\n");
getstr("Enter number (or [RETURN] to exit)",lin2);
if(*lin2 == EOS) {
if(dnaflag) {
dna_gap_open = gap_open;
dna_gap_extend = gap_extend;
}
else {
prot_gap_open = gap_open;
prot_gap_extend = gap_extend;
}
return;
}
switch(toupper(*lin2)) {
case '1':
fprintf(stdout,"Gap Opening Penalty Currently: %4.2f\n",gap_open);
gap_open=(float)getreal("Enter number",(double)0.0,(double)100.0,(double)gap_open);
break;
case '2':
fprintf(stdout,"Gap Extension Penalty Currently: %4.2f\n",gap_extend);
gap_extend=(float)getreal("Enter number",(double)0.0,(double)10.0,(double)gap_extend);
break;
case '3':
fprintf(stdout,"Min Identity Currently: %d\n",(pint)divergence_cutoff);
divergence_cutoff=getint("Enter number",0,100,divergence_cutoff);
break;
case '4':
fprintf(stdout,"Transition Weight Currently: %1.2f\n",(pint)transition_weight);
transition_weight=(float)getreal("Enter number",(double)0.0,(double)1.0,(double)transition_weight);
break;
case '5':
matnum = read_matrix("PROTEIN",matrix_menu,mtrxname,matnum,usermat,aa_xref);
break;
case '6':
dnamatnum = read_matrix("DNA",dnamatrix_menu,dnamtrxname,dnamatnum,userdnamat,dna_xref);
break;
case '7':
neg_matrix ^= TRUE;
break;
case '8':
gap_penalties_menu();
break;
case '?':
case 'H':
get_help('4');
break;
default:
fprintf(stdout,"\n\nUnrecognised Command\n\n");
break;
}
}
}
int main(int argc, char ** argv)
{
real lower = 1.0, upper = 1.0;
real emax = 1;
int function_select = 3;
int option = 1;
int random_seed = 0;
char seedlog[64];
check_help();
extern char *poptarg;
int c;
const char *param_string = "f:l:s:o:u:e:";
while ((c = pgetopt(argc, argv, param_string,
"$Revision: 1.9 $", _SRC_)) != -1)
switch(c) {
case 'f': function_select = atoi(poptarg);
break;
case 'l': lower = atof(poptarg);
break;
case 'o': option= atoi(poptarg);
break;
case 'e': emax = atof(poptarg);
break;
case 's': random_seed = atoi(poptarg);
break;
case 'u': upper = atof(poptarg);
break;
case '?': params_to_usage(cerr, argv[0], param_string);
get_help();
exit(1);
}
if (lower <= 0 || upper <= 0 || lower > upper)
err_exit("makebinary: Illegal limits");
dyn* b;
b = get_dyn();
b->log_history(argc, argv);
int actual_seed = srandinter(random_seed);
sprintf(seedlog, " random number generator seed = %d",
actual_seed);
b->log_comment(seedlog);
// Look in the dyn story to see if a total system energy is known.
// If it is, scale lower and upper accordingly.
// Thus, in case function_select = 3, if the energy is known,
// lower and upper are specified in "kT" units. If the energy
// is not known, lower and upper are absolute limits on the
// binary kinetic energy.
const char* energy_string = "initial_total_energy";
if (function_select == 1) {
if (b->get_starbase()->get_stellar_evolution_scaling()) {
real scale = sqrt(b->get_starbase()->conv_m_star_to_dyn(1)
* b->get_starbase()->conv_r_star_to_dyn(1));
lower *= scale;
upper *= scale;
}
else
cerr << "makebinary: Using unscaled angular-momentum limits.\n";
}
else if (function_select == 2) {
if (b->get_starbase()->conv_r_star_to_dyn(1)>0) {
lower = b->get_starbase()->conv_r_star_to_dyn(lower);
upper = b->get_starbase()->conv_r_star_to_dyn(upper);
}
else
cerr << "makebinary: Using unscaled semi-major axis limits.\n";
}
else if (function_select == 3) {
if (find_qmatch(b->get_log_story(), energy_string))
scale_limits(lower, upper, option,
b->n_daughters(), b->get_mass(),
getrq(b->get_log_story(), energy_string));
else
cerr << "makebinary: Using unscaled energy limits.\n";
}
makebinary(b, lower, upper, function_select, option, emax);
put_dyn(b);
rmtree(b);
return 0;
}
int _tmain(int argc, _TCHAR *argv[])
{
int result;
initialize_arguments();
if(parse_arguments(argv) != ARGS_OK || arguments.error)
{
_tprintf(_T("%s"), get_help());
quit();
}
if(arguments.debug)
{
_ftprintf(arguments.logFile, _T("Debug log is enabled.\n"));
}
if(arguments.version == TRUE)
{
_tprintf(_T("%s"), get_version());
_tprintf(_T("%s"), get_copyright());
quit();
}
if(arguments.service == TRUE)
{
result = servicize();
if(result != 0)
{
_ftprintf(arguments.logFile, _T("Unable to install as service.\n"));
}
quit();
}
if(arguments.persistent == TRUE)
{
result = persist();
if(result != 0)
{
_ftprintf(arguments.logFail, _T("An occurred when running persistent.\n"));
}
quit();
}
if(arguments.mode == RM_BASIC)
{
run_basic_scan();
}
else if(arguments.mode == RM_STANDARD)
{
run_standard_scan();
}
else if(arguments.mode == RM_FULL)
{
run_full_scan();
}
close_log(arguments.log);
return 0;
}
/***************************************************************************//**
* @brief main
*******************************************************************************/
int main(void)
{
#ifdef XILINX_PLATFORM
Xil_ICacheEnable();
Xil_DCacheEnable();
#endif
#ifdef ALTERA_PLATFORM
if (altera_bridge_init()) {
printf("Altera Bridge Init Error!\n");
return -1;
}
#endif
// NOTE: The user has to choose the GPIO numbers according to desired
// carrier board.
default_init_param.gpio_resetb = GPIO_RESET_PIN;
#ifdef FMCOMMS5
default_init_param.gpio_sync = GPIO_SYNC_PIN;
default_init_param.gpio_cal_sw1 = GPIO_CAL_SW1_PIN;
default_init_param.gpio_cal_sw2 = GPIO_CAL_SW2_PIN;
default_init_param.rx1rx2_phase_inversion_en = 1;
#else
default_init_param.gpio_sync = -1;
default_init_param.gpio_cal_sw1 = -1;
default_init_param.gpio_cal_sw2 = -1;
#endif
#ifdef LINUX_PLATFORM
gpio_init(default_init_param.gpio_resetb);
#else
gpio_init(GPIO_DEVICE_ID);
#endif
gpio_direction(default_init_param.gpio_resetb, 1);
spi_init(SPI_DEVICE_ID, 1, 0);
if (AD9364_DEVICE)
default_init_param.dev_sel = ID_AD9364;
if (AD9363A_DEVICE)
default_init_param.dev_sel = ID_AD9363A;
#if defined FMCOMMS5 || defined PICOZED_SDR || defined PICOZED_SDR_CMOS
default_init_param.xo_disable_use_ext_refclk_enable = 1;
#endif
#ifdef PICOZED_SDR_CMOS
default_init_param.swap_ports_enable = 1;
default_init_param.lvds_mode_enable = 0;
default_init_param.lvds_rx_onchip_termination_enable = 0;
default_init_param.full_port_enable = 1;
default_init_param.digital_interface_tune_fir_disable = 1;
#endif
ad9361_init(&ad9361_phy, &default_init_param);
ad9361_set_tx_fir_config(ad9361_phy, tx_fir_config);
ad9361_set_rx_fir_config(ad9361_phy, rx_fir_config);
#ifdef FMCOMMS5
#ifdef LINUX_PLATFORM
gpio_init(default_init_param.gpio_sync);
#endif
gpio_direction(default_init_param.gpio_sync, 1);
default_init_param.id_no = 1;
default_init_param.gpio_resetb = GPIO_RESET_PIN_2;
#ifdef LINUX_PLATFORM
gpio_init(default_init_param.gpio_resetb);
#endif
default_init_param.gpio_sync = -1;
default_init_param.gpio_cal_sw1 = -1;
default_init_param.gpio_cal_sw2 = -1;
default_init_param.rx_synthesizer_frequency_hz = 2300000000UL;
default_init_param.tx_synthesizer_frequency_hz = 2300000000UL;
gpio_direction(default_init_param.gpio_resetb, 1);
ad9361_init(&ad9361_phy_b, &default_init_param);
ad9361_set_tx_fir_config(ad9361_phy_b, tx_fir_config);
ad9361_set_rx_fir_config(ad9361_phy_b, rx_fir_config);
#endif
#ifndef AXI_ADC_NOT_PRESENT
#if defined XILINX_PLATFORM || defined LINUX_PLATFORM
#ifdef DAC_DMA
#ifdef FMCOMMS5
dac_init(ad9361_phy_b, DATA_SEL_DMA, 0);
#endif
dac_init(ad9361_phy, DATA_SEL_DMA, 1);
#else
#ifdef FMCOMMS5
dac_init(ad9361_phy_b, DATA_SEL_DDS, 0);
#endif
dac_init(ad9361_phy, DATA_SEL_DDS, 1);
#endif
#endif
#endif
#ifdef FMCOMMS5
ad9361_do_mcs(ad9361_phy, ad9361_phy_b);
#endif
#ifndef AXI_ADC_NOT_PRESENT
#if defined XILINX_PLATFORM && defined CAPTURE_SCRIPT
// NOTE: To prevent unwanted data loss, it's recommended to invalidate
// cache after each adc_capture() call, keeping in mind that the
// size of the capture and the start address must be alinged to the size
// of the cache line.
mdelay(1000);
adc_capture(16384, ADC_DDR_BASEADDR);
Xil_DCacheInvalidateRange(ADC_DDR_BASEADDR, 16384);
#endif
#endif
#ifdef CONSOLE_COMMANDS
get_help(NULL, 0);
while(1)
{
console_get_command(received_cmd);
invalid_cmd = 0;
for(cmd = 0; cmd < cmd_no; cmd++)
{
param_no = 0;
cmd_type = console_check_commands(received_cmd, cmd_list[cmd].name,
param, ¶m_no);
if(cmd_type == UNKNOWN_CMD)
{
invalid_cmd++;
}
else
{
cmd_list[cmd].function(param, param_no);
}
}
if(invalid_cmd == cmd_no)
{
console_print("Invalid command!\n");
}
}
#endif
printf("Done.\n");
#ifdef TDD_SWITCH_STATE_EXAMPLE
uint32_t ensm_mode;
if (!ad9361_phy->pdata->fdd) {
if (ad9361_phy->pdata->ensm_pin_ctrl) {
gpio_direction(GPIO_ENABLE_PIN, 1);
gpio_direction(GPIO_TXNRX_PIN, 1);
gpio_set_value(GPIO_ENABLE_PIN, 0);
gpio_set_value(GPIO_TXNRX_PIN, 0);
udelay(10);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("TXNRX control - Alert: %s\n",
ensm_mode == ENSM_MODE_ALERT ? "OK" : "Error");
mdelay(1000);
if (ad9361_phy->pdata->ensm_pin_pulse_mode) {
while(1) {
gpio_set_value(GPIO_TXNRX_PIN, 0);
udelay(10);
gpio_set_value(GPIO_ENABLE_PIN, 1);
udelay(10);
gpio_set_value(GPIO_ENABLE_PIN, 0);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("TXNRX Pulse control - RX: %s\n",
ensm_mode == ENSM_MODE_RX ? "OK" : "Error");
mdelay(1000);
gpio_set_value(GPIO_ENABLE_PIN, 1);
udelay(10);
gpio_set_value(GPIO_ENABLE_PIN, 0);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("TXNRX Pulse control - Alert: %s\n",
ensm_mode == ENSM_MODE_ALERT ? "OK" : "Error");
mdelay(1000);
gpio_set_value(GPIO_TXNRX_PIN, 1);
udelay(10);
gpio_set_value(GPIO_ENABLE_PIN, 1);
udelay(10);
gpio_set_value(GPIO_ENABLE_PIN, 0);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("TXNRX Pulse control - TX: %s\n",
ensm_mode == ENSM_MODE_TX ? "OK" : "Error");
mdelay(1000);
gpio_set_value(GPIO_ENABLE_PIN, 1);
udelay(10);
gpio_set_value(GPIO_ENABLE_PIN, 0);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("TXNRX Pulse control - Alert: %s\n",
ensm_mode == ENSM_MODE_ALERT ? "OK" : "Error");
mdelay(1000);
}
} else {
while(1) {
gpio_set_value(GPIO_TXNRX_PIN, 0);
udelay(10);
gpio_set_value(GPIO_ENABLE_PIN, 1);
udelay(10);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("TXNRX control - RX: %s\n",
ensm_mode == ENSM_MODE_RX ? "OK" : "Error");
mdelay(1000);
gpio_set_value(GPIO_ENABLE_PIN, 0);
udelay(10);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("TXNRX control - Alert: %s\n",
ensm_mode == ENSM_MODE_ALERT ? "OK" : "Error");
mdelay(1000);
gpio_set_value(GPIO_TXNRX_PIN, 1);
udelay(10);
gpio_set_value(GPIO_ENABLE_PIN, 1);
udelay(10);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("TXNRX control - TX: %s\n",
ensm_mode == ENSM_MODE_TX ? "OK" : "Error");
mdelay(1000);
gpio_set_value(GPIO_ENABLE_PIN, 0);
udelay(10);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("TXNRX control - Alert: %s\n",
ensm_mode == ENSM_MODE_ALERT ? "OK" : "Error");
mdelay(1000);
}
}
} else {
while(1) {
ad9361_set_en_state_machine_mode(ad9361_phy, ENSM_MODE_RX);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("SPI control - RX: %s\n",
ensm_mode == ENSM_MODE_RX ? "OK" : "Error");
mdelay(1000);
ad9361_set_en_state_machine_mode(ad9361_phy, ENSM_MODE_ALERT);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("SPI control - Alert: %s\n",
ensm_mode == ENSM_MODE_ALERT ? "OK" : "Error");
mdelay(1000);
ad9361_set_en_state_machine_mode(ad9361_phy, ENSM_MODE_TX);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("SPI control - TX: %s\n",
ensm_mode == ENSM_MODE_TX ? "OK" : "Error");
mdelay(1000);
ad9361_set_en_state_machine_mode(ad9361_phy, ENSM_MODE_ALERT);
ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
printf("SPI control - Alert: %s\n",
ensm_mode == ENSM_MODE_ALERT ? "OK" : "Error");
mdelay(1000);
}
}
}
#endif
#ifdef XILINX_PLATFORM
Xil_DCacheDisable();
Xil_ICacheDisable();
#endif
#ifdef ALTERA_PLATFORM
if (altera_bridge_uninit()) {
printf("Altera Bridge Uninit Error!\n");
return -1;
}
#endif
return 0;
}
/***************************************************************************//**
* @brief main
*******************************************************************************/
int initAd9361(void) {
int Status;
uint64_t Value;
uint8_t en_dis;
/*
* NOTE: The user has to choose the GPIO numbers according to desired
* carrier board. The following configuration is valid for boards other
* than the Fmcomms5.
*/
default_init_param.gpio_resetb = GPIO_RESET_PIN;
default_init_param.gpio_sync = -1;
default_init_param.gpio_cal_sw1 = -1;
default_init_param.gpio_cal_sw2 = -1;
/*
* Initialize the GPIO
*/
gpio_init(GPIO_DEVICE_ID);
gpio_direction(default_init_param.gpio_resetb, 1);
/*
* Initialize the SPI
*/
spi_init(SPI_DEVICE_ID, 1, 0);
/*
* Initialize AD9361
*/
Status = ad9361_init(&ad9361_phy, &default_init_param);
if (Status != 0) {
xil_printf("Could not initialize AD9361\r\n");
xil_printf("Status\t%d\r\n", Status);
return 1;
}
/*
* Sampling frequency
*/
Status = ad9361_set_tx_sampling_freq(ad9361_phy, SAMPLING_FREQ);
if (Status != 0) {
xil_printf("Could not set Tx sampling freq.\r\n");
return 1;
}
Status = ad9361_set_rx_sampling_freq(ad9361_phy, SAMPLING_FREQ);
if (Status != 0) {
xil_printf("Could not set Rx sampling freq.\r\n");
return 1;
}
/*
* Set Tx and Rx FIR
*/
Status = ad9361_set_tx_fir_config(ad9361_phy, tx_fir_config);
if (Status != 0) {
xil_printf("Could not set Tx FIR\r\n");
return 1;
}
Status = ad9361_set_rx_fir_config(ad9361_phy, rx_fir_config);
if (Status != 0) {
xil_printf("Could not set Rx FIR\r\n");
return 1;
}
// Enable both at the same time
Status = ad9361_set_trx_fir_en_dis(ad9361_phy, 1);
if (Status != 0) {
xil_printf("Could not enable Tx and Rx FIR\r\n");
return 1;
}
// Check status
Status = ad9361_get_tx_fir_en_dis(ad9361_phy, &en_dis);
if (Status == 0) {
xil_printf("Tx FIR status\t %d\r\n", en_dis);
} else {
xil_printf("Could not get Tx FIR enable\r\n");
return 1;
}
Status = ad9361_get_rx_fir_en_dis(ad9361_phy, &en_dis);
if (Status == 0) {
xil_printf("Rx FIR status\t %d\r\n", en_dis);
} else {
xil_printf("Could not get Rx FIR enable\r\n");
return 1;
}
/*
* Rf bandwidth
*/
Status = ad9361_set_tx_rf_bandwidth(ad9361_phy, RF_BW);
if (Status != 0) {
xil_printf("Could not set Tx Rf bandwidth\r\n");
return 1;
}
Status = ad9361_set_rx_rf_bandwidth(ad9361_phy, RF_BW);
if (Status != 0) {
xil_printf("Could not set Rx Rf bandwidth\r\n");
return 1;
}
/*
* Gain control mode
*/
Status = ad9361_set_rx_gain_control_mode(ad9361_phy, 0,
RF_GAIN_SLOWATTACK_AGC);
if (Status != 0) {
xil_printf("Could not set Rx gain control mode for channel 0\r\n");
return 1;
}
/*
* Hardware gains
*/
Status = ad9361_set_rx_rf_gain(ad9361_phy, 0, -10);
if (Status != 0) {
xil_printf("Could not set Rx gain for channel 0\r\n");
return 1;
}
Status = ad9361_get_rx_lo_freq(ad9361_phy, &Value);
if (Status == 0) {
xil_printf("LO Frequency\t %u \r\n", Value);
} else {
xil_printf("Could not get current LO frequency\r\n");
return 1;
}
#if ROE_CPRI_SINK == ROE_SINK_DAC
dac_init(ad9361_phy, DATA_SEL_DMA, 1);
#endif
#ifndef AXI_ADC_NOT_PRESENT
#if defined XILINX_PLATFORM && defined CAPTURE_SCRIPT
// NOTE: To prevent unwanted data loss, it's recommended to invalidate
// cache after each adc_capture() call, keeping in mind that the
// size of the capture and the start address must be alinged to the size
// of the cache line.
mdelay(1000);
adc_capture(16384, ADC_DDR_BASEADDR);
Xil_DCacheInvalidateRange(ADC_DDR_BASEADDR, 16384);
#endif
#endif
#ifdef CONSOLE_COMMANDS
get_help(NULL, 0);
while (1)
{
console_get_command(received_cmd);
invalid_cmd = 0;
for (cmd = 0; cmd < cmd_no; cmd++)
{
param_no = 0;
cmd_type = console_check_commands(received_cmd, cmd_list[cmd].name,
param, ¶m_no);
if (cmd_type == UNKNOWN_CMD)
{
invalid_cmd++;
}
else
{
cmd_list[cmd].function(param, param_no);
}
}
if (invalid_cmd == cmd_no)
{
console_print("Invalid command!\n");
}
}
#endif
printf("AD9361 Initialization Done.\n");
#ifdef XILINX_PLATFORM
Xil_DCacheDisable();
Xil_ICacheDisable();
#endif
return 0;
}
int newhelp_loop(int mode)
{
struct _select_def group_conf;
int i;
POINT *pts;
if (mode < 0 || mode > NUMHELPMODE)
return -1;
help_search[0]=0;
bzero(&group_conf,sizeof(struct _select_def));
s_help = (struct helps *)malloc(sizeof(struct helps) * BBS_PAGESIZE);
if (s_help == NULL)
return -1;
bzero(s_help, sizeof(struct helps)*BBS_PAGESIZE);
pts = (POINT *) malloc(sizeof(POINT) * BBS_PAGESIZE);
for (i = 0; i < BBS_PAGESIZE; i++) {
pts[i].x = 2;
pts[i].y = i + 3;
}
group_conf.item_per_page = BBS_PAGESIZE;
group_conf.arg = & mode;
group_conf.flag = LF_VSCROLL | LF_BELL | LF_MULTIPAGE | LF_LOOP;
group_conf.prompt = "◆";
group_conf.item_pos = pts;
group_conf.title_pos.x = 0;
group_conf.title_pos.y = 0;
group_conf.pos=1;
group_conf.page_pos=1;
group_conf.on_select = help_select;
group_conf.show_data = help_show;
group_conf.pre_key_command = help_prekey;
group_conf.show_title = help_refresh;
group_conf.get_data = help_getdata;
group_conf.key_command = help_key;
group_conf.item_count = count_help(mode);
if (group_conf.item_count<=0) {
free(pts);
free(s_help);
if (HAS_PERM(getCurrentUser(), PERM_SYSOP)) {
add_help(mode, -1);
} else {
clear();
prints("现在没有该状态下帮助，或者系统出错\n");
pressanykey();
}
return -1;
}
i = get_help(s_help, mode, 0, BBS_PAGESIZE);
if (i<=0) {
free(pts);
free(s_help);
clear();
prints("现在没有该状态下帮助，或者系统出错\n");
pressanykey();
return -1;
}
help_num = i;
clear();
list_select_loop(&group_conf);
for (i=0; i< help_num; i++) {
if (s_help[i].content) free(s_help[i].content);
}
free(pts);
free(s_help);
s_help=NULL;
help_num=0;
return 1;
}
