static void add_argument_list(char *header, struct objhead *h)
{
struct obj *i = h->head;
while (i) {
if (header)
add_argument(header);
add_argument(i->name);
i->used = 1;
i = i->next;
}
}
void formalparitem(int level) {
char *tmp = malloc(35*sizeof(char));
SYMBOL *s;
PARTYPE type;
debug(level,"FORMALPARITEM");
if (token == TK_IN || token == TK_INOUT) {
if (token == TK_IN) {
type = IN;
} else {
type = INOUT;
}
debug_lex();
id(&tmp, level+1);
s = lookup(tmp);
if (s != NULL && s->type == TYPE_FUNC) {
fprintf(stderr, "error line %d: there is already a function or a procedure called '%s'\n", line, tmp);
exit(1);
}
add_argument(tmp, type);
} else {
/* syntax error expected in id inout id */
syntax_error("in id or inout id expected");
}
}
static void build_arglist(char *p)
{
arginfd = -1;
argoutfd = -1;
argptr = arglist;
add_argument(p);
}
void create_init(void)
{
uint8_t *j, *e;
udata.u_top = PROGLOAD + 512; /* Plenty for the boot */
init_process = ptab_alloc();
udata.u_ptab = init_process;
init_process->p_top = udata.u_top;
map_init();
/* wipe file table */
e = udata.u_files + UFTSIZE;
for (j = udata.u_files; j < e; ++j)
*j = NO_FILE;
makeproc(init_process, &udata);
init_process->p_status = P_RUNNING;
udata.u_insys = 1;
init_process->p_status = P_RUNNING;
/* Poke the execve arguments into user data space so _execve() can read them back */
/* Some systems only have a tiny window we can use at boot as most of
this space is loaded with common memory */
argptr = PROGLOAD;
progptr = PROGLOAD + 256;
uzero((void *)progptr, 32);
add_argument("/init");
}
/**
* Test that the parser correctly parses a choice value.
*/
TEST(choice_option_test, parse_choice)
{
auto parser = qflags::parser();
auto option = qflags::choice_option("foo", {"bar", "baz"}, "bar");
ASSERT_EQ(true, parser.add_argument(&option));
{
char const* argv[] = { "--foo", "bar" };
auto command_line = qflags::command_line(argv);
std::string errors;
ASSERT_EQ(true, parser.parse(command_line, &errors));
EXPECT_EQ("bar", static_cast<std::string>(parser["foo"]));
EXPECT_EQ("bar", static_cast<std::string>(option));
EXPECT_EQ(2, parser.argc());
EXPECT_EQ(0, parser.remaining_argc());
EXPECT_EQ(0u, errors.length());
}
{
char const* argv[] = { "--foo", "baz" };
auto command_line = qflags::command_line(argv);
std::string errors;
ASSERT_EQ(true, parser.parse(command_line, &errors));
EXPECT_EQ("baz", static_cast<std::string>(parser["foo"]));
EXPECT_EQ("baz", static_cast<std::string>(option));
EXPECT_EQ(2, parser.argc());
EXPECT_EQ(0, parser.remaining_argc());
EXPECT_EQ(0u, errors.length());
}
}
void convert_s_to_o(char *path)
{
build_arglist(CMD_AS);
add_argument(path);
run_command();
pathmod(path, ".s", ".o", 5);
}
static void add_argument_list(struct arglist *l)
{
while(l) {
add_argument(l->p);
l = l->next;
}
}
void create_init(void)
{
uint8_t *j;
init_process = ptab_alloc();
udata.u_ptab = init_process;
udata.u_top = PROGLOAD + 4096; /* Plenty for the boot */
init_process->p_top = udata.u_top;
map_init();
newproc(init_process);
udata.u_insys = 1;
init_process->p_status = P_RUNNING;
/* wipe file table */
for (j = udata.u_files; j < (udata.u_files + UFTSIZE); ++j) {
*j = NO_FILE;
}
/* Poke the execve arguments into user data space so _execve() can read them back */
argptr = PROGLOAD;
progptr = PROGLOAD + 2048;
uzero((void *)progptr, 32);
add_argument("/init");
}
// -----------------------------------------------------------------------
// handle the resurrection spell
// -----------------------------------------------------------------------
bool t_resurrection_spell::left_click( t_screen_point const& point )
{
t_map_point_2d map_point;
t_combat_creature_list creatures;
bool defender = get_caster()->belongs_to_defender();
creatures = get_targets( point );
if (creatures.empty())
return false;
eliminate_duplicates( creatures );
if (creatures.size() == 1)
{
resurrect( creatures.front().get() );
return true;
}
t_combat_creature_list::iterator index;
t_combat_creature_ptr creature;
t_handler handler;
t_window* window = t_window::get_modal_window();
m_menu = new t_scroll_menu( window );
for (index = creatures.begin(); index != creatures.end(); index++)
{
creature = *index;
handler = add_argument( bound_handler( *this, &t_resurrection_spell::resurrect ),
creature );
m_menu->add_item( get_text( creature ), handler );
}
m_menu->open( get_mouse_position( window ) );
m_battlefield.get_window()->set_help_balloon_text( "" );
return true;
}
static my_bool
get_one_option(int optid, const struct my_option * opt, char *argument)
{
switch(optid) {
case 'V':
print_version();
exit(-1);
case '?':
usage();
default:
{
int id;
switch (optid) {
case OPT_CONNECT_TIMEOUT: id = 't';
break;
case OPT_MAX_ALLOWED_PACKET: id = 'A';
break;
case OPT_NET_BUFFER_LENGTH: id = 'N';
break;
case OPT_SELECT_LIMIT: id = 'l';
break;
case OPT_MAX_JOIN_SIZE: id = 'J';
break;
case OPT_LOCAL_INFILE: id = 'L';
break;
default: id = optid;
break;
}
if (opt->var_type == GET_NO_ARG && opt->arg_type == NO_ARG) //Boolean options
add_argument(id, "");
else
add_argument(id, argument);
}
break;
}
return 0;
}
static void add_option(const char *a, const char *b)
{
char *x = malloc(strlen(a) + strlen(b) + 1);
if (x == NULL) {
fprintf(stderr, "Out of memory.\n");
exit(1);
}
strcpy(x, a);
strcat(x, b);
add_argument(x);
}
int main(int argc, char* argv[])
{
auto command_line = qflags::command_line(argc, argv);
auto parser = qflags::parser();
auto ignore_case = qflags::flag("ignore_case", "i");
auto print_matrix = qflags::flag("print_matrix", "p");
std::string errors;
bool result = true;
result &= parser.add_argument(&ignore_case);
result &= parser.add_argument(&print_matrix);
result &= parser.parse(command_line, &errors);
fprintf(stdout, "%s", errors.c_str());
// Compare two strings and print their edit distance.
if (parser.remaining_argc() == 3) {
unsigned long long distance = levenshtein(parser.remaining_argv()[1],
parser.remaining_argv()[2],
ignore_case,
print_matrix);
fprintf(stdout, "%llu\n", distance);
}
// Compare multiple strings and find the two nearest strings.
else if (parser.remaining_argc() > 3) {
find_nearest(parser.remaining_argc() - 1,
parser.remaining_argv() + 1,
ignore_case,
print_matrix);
}
// Print usage string
else {
fprintf(stdout,
"usage: levenshtein %s <string> <string> [<string>...]\n",
parser.usage_string().c_str());
}
return result ? 0 : 1;
}
void preprocess_c(char *path)
{
build_arglist(CMD_CPP);
add_argument_list("-I", &inclist);
add_argument_list("-D", &deflist);
add_argument(path);
/* Weird one .. -E goes to stdout */
if (last_phase != 1)
redirect_out(pathmod(path, ".c", ".%", 0));
run_command();
}
/* Just read a command, expecting args or command end */
static ParserState state_arguments(ParserContext *ctx, char *token)
{
if (token_class(token) == TC_TEXT)
{
/* is an argument */
add_argument(ctx, token);
return ST_ARGUMENTS;
}
/* otherwise, identical to ST_REDIRECTIONS */
return state_redirections(ctx, token);
}
/**
* \brief Calls the tokenize program in Cassys
*
* Tokenize is called with target text_name and options --word_by_word, --alphabet=alphabet_name, --token=token_txt_name if
* if token_txt_name is not NULL. For more information about tokenize, see the unitex manual.
*
* \param [in/out] text_name the name of the text
* \param [in] alphabet the name of the alphabet
* \param [in/out] token_txt_name the file containing all the of the text or
*
*
*
*
*/
int launch_tokenize_in_Cassys(const char *text_name, const char *alphabet_name, const char *token_txt_name,
Encoding encoding_output,int bom_output,int mask_encoding_compatibility_input){
fprintf(stdout,"Launch tokenize in Cassys\n");
ProgramInvoker *invoker = new_ProgramInvoker(main_Tokenize,"main_Tokenize");
char tmp[FILENAME_MAX];
{
tmp[0]=0;
get_reading_encoding_text(tmp,sizeof(tmp)-1,mask_encoding_compatibility_input);
if (tmp[0] != '\0') {
add_argument(invoker,"-k");
add_argument(invoker,tmp);
}
tmp[0]=0;
get_writing_encoding_text(tmp,sizeof(tmp)-1,encoding_output,bom_output);
if (tmp[0] != '\0') {
add_argument(invoker,"-q");
add_argument(invoker,tmp);
}
}
// add the alphabet
char alphabet_argument[FILENAME_MAX + 11];
sprintf(alphabet_argument, "--alphabet=%s", alphabet_name);
add_argument(invoker, alphabet_argument);
// Tokenize word by word
add_argument(invoker, "--word_by_word");
// add the target text file
add_argument(invoker,text_name);
// if a token.txt file already exists, use it
if(token_txt_name != NULL){
char token_argument[FILENAME_MAX + 9];
sprintf(token_argument,"--tokens=%s",token_txt_name);
add_argument(invoker,token_argument);
}
char line_command[4096];
build_command_line(invoker, line_command);
fprintf(stdout, "%s\n", line_command);
int result = invoke(invoker);
free_ProgramInvoker(invoker);
return result;
}
/**
* Allocates, initializes and returns a new program invoker.
*/
ProgramInvoker* new_ProgramInvoker(MAIN_FUNCTION f,const char* name) {
if (name==NULL) {
fatal_error("NULL program name in new_ProgramInvoker\n");
}
ProgramInvoker* res=(ProgramInvoker*)malloc(sizeof(ProgramInvoker));
if (res==NULL) {
fatal_alloc_error("new_ProgramInvoker");
}
res->main=f;
res->args=new_vector_ptr(16);
add_argument(res,name);
return res;
}
/* Parse other arguments */
void parse_args(char *p)
{
char *s;
while(*p) {
while(*p == ' ' || *p == '\n')
p++;
s = p;
while(*p && *p != ' ' && *p != '\n')
p++;
if(*p)
*p++=0;
if (!system_param(s))
add_argument(s);
}
}
void convert_c_to_s(char *path)
{
char *tmp;
build_arglist(CMD_CC);
redirect_in(path);
tmp = strdup(pathmod(path, ".%", ".@", 0));
if (tmp == NULL)
memory();
redirect_out(tmp);
run_command();
build_arglist(CMD_COPT);
add_argument(COPT_FILE);
redirect_in(tmp);
redirect_out(pathmod(path, ".%", ".s", 2));
run_command();
free(tmp);
}
/**
* Test that the parser correctly detects a missing choice value.
*/
TEST(choice_option_test, parse_choice_no_value)
{
auto parser = qflags::parser();
char const* argv[] = { "--foo" };
auto command_line = qflags::command_line(argv);
auto option = qflags::choice_option("foo", { "bar" }, "bar");
ASSERT_EQ(true, parser.add_argument(&option));
{
std::string errors;
EXPECT_EQ(false, parser.parse(command_line, &errors));
EXPECT_NE(0u, errors.length());
}
}
void link_phase(void)
{
build_arglist(CMD_LD);
add_argument("-b");
add_argument("-c");
add_argument("256");
if (strip)
add_argument("-s");
add_argument("-o");
add_argument(target);
if (!standalone)
add_argument(CRT0);
add_argument_list(NULL, &objlist);
add_argument_list(NULL, &liblist);
run_command();
}
void StaticPageHttpObject::get(const std::string& id)
{
const std::string path = env_.root + "/" + name_;
DirConfig config(path + "/.config");
std::ifstream in((path + "/page.html").c_str());
if (!in.good())
throw NotFound("Index page not found");
std::string body;
static const std::size_t buf_size = 4096;
char buffer[buf_size];
while (!in.eof()) {
const std::size_t read = in.readsome(buffer, buf_size);
if (read == 0)
break;
body.append(buffer, read);
}
ArgumentList args;
add_argument(args, "body", body);
const PageTemplate* tpl = TemplateList::instance().get("static_page");
set_page(config.data(), tpl->yield(args));
}
// Create `ChangeDirectory' dialog
void gdbChangeDirectoryCB(Widget w, XtPointer, XtPointer)
{
if (cd_dialog == 0)
{
Arg args[10];
int arg = 0;
cd_dialog =
verify(XmCreateSelectionDialog(find_shell(w),
XMST("cd_dialog"),
args, arg));
XtUnmanageChild(XmSelectionBoxGetChild(cd_dialog,
XmDIALOG_APPLY_BUTTON));
Delay::register_shell(cd_dialog);
XtAddCallback(cd_dialog, XmNokCallback, gdbChangeDirectoryDCB, 0);
XtAddCallback(cd_dialog, XmNapplyCallback, gdbChangeDirectoryDCB, 0);
XtAddCallback(cd_dialog, XmNhelpCallback, ImmediateHelpCB, 0);
cd_arguments_w = XmSelectionBoxGetChild(cd_dialog, XmDIALOG_LIST);
XtAddCallback(cd_arguments_w, XmNsingleSelectionCallback,
SelectChangeDirectoryArgsCB, 0);
XtAddCallback(cd_arguments_w, XmNmultipleSelectionCallback,
SelectChangeDirectoryArgsCB, 0);
XtAddCallback(cd_arguments_w, XmNextendedSelectionCallback,
SelectChangeDirectoryArgsCB, 0);
XtAddCallback(cd_arguments_w, XmNbrowseSelectionCallback,
SelectChangeDirectoryArgsCB, 0);
add_argument("..", cd_arguments, last_cd_argument,
cd_arguments_updated);
}
update_cd_arguments();
manage_and_raise(cd_dialog);
}
/**
* \brief Calls the Concord program in Cassys
*
* Concord is called with target index_file and options
* --merge=text_name, --alphabet=alphabet_name.
*
* For more information about Concord, see the unitex manual.
*
* \param [in/out] text_name the name of the text
* \param [in] alphabet the name of the alphabet
* \param [in] index_file file containing all the matches found by locate
*
*/
int launch_concord_in_Cassys(const char *text_name, const char *index_file, const char *alphabet_name,
Encoding encoding_output,int bom_output,int mask_encoding_compatibility_input){
ProgramInvoker *invoker = new_ProgramInvoker(main_Concord, "main_Concord");
add_argument(invoker,index_file);
char tmp[FILENAME_MAX];
{
tmp[0]=0;
get_reading_encoding_text(tmp,sizeof(tmp)-1,mask_encoding_compatibility_input);
if (tmp[0] != '\0') {
add_argument(invoker,"-k");
add_argument(invoker,tmp);
}
tmp[0]=0;
get_writing_encoding_text(tmp,sizeof(tmp)-1,encoding_output,bom_output);
if (tmp[0] != '\0') {
add_argument(invoker,"-q");
add_argument(invoker,tmp);
}
}
char text_argument[FILENAME_MAX+7];
sprintf(text_argument,"--merge=%s",text_name);
add_argument(invoker,text_argument);
char alphabet_argument[FILENAME_MAX+11];
sprintf(alphabet_argument,"--alphabet=%s",alphabet_name);
char line_command[4096];
build_command_line(invoker, line_command);
fprintf(stdout, "%s\n", line_command);
int result = invoke(invoker);
free_ProgramInvoker(invoker);
return result;
}
bool FixDirectoriesCommand::AddSubCommands() {
add_argument(BooleanCommandLineArgument("verbose", 'v', "Enable verbose output.", false));
return true;
}
/**
* \brief Calls the Locate program in Cassys
*
* Locate is called with target the transducer file name of transudcer and options
* --text=text_name, --alphabet=alphabet_name, --longest_matches, --all and --merge or --replace
* depending of the output policy of the transducer.
*
* For more information about Locate, see the unitex manual.
*
* \param [in/out] text_name the name of the text
* \param [in] alphabet the name of the alphabet
* \param [in] transducer structure containing information about the transducer to be applied
*
*/
int launch_locate_in_Cassys(const char *text_name, const transducer *transducer, const char* alphabet_name,
const char*negation_operator,
Encoding encoding_output,int bom_output,int mask_encoding_compatibility_input){
ProgramInvoker *invoker = new_ProgramInvoker(main_Locate, "main_Locate");
char tmp[FILENAME_MAX];
{
tmp[0]=0;
get_reading_encoding_text(tmp,sizeof(tmp)-1,mask_encoding_compatibility_input);
if (tmp[0] != '\0') {
add_argument(invoker,"-k");
add_argument(invoker,tmp);
}
tmp[0]=0;
get_writing_encoding_text(tmp,sizeof(tmp)-1,encoding_output,bom_output);
if (tmp[0] != '\0') {
add_argument(invoker,"-q");
add_argument(invoker,tmp);
}
}
add_argument(invoker, transducer->transducer_file_name);
// add the text
char text_argument[FILENAME_MAX+7];
sprintf(text_argument,"--text=%s",text_name);
add_argument(invoker, text_argument);
// add the merge or replace option
switch (transducer ->output_policy) {
case MERGE_OUTPUTS: add_argument(invoker,"--merge"); break;
case REPLACE_OUTPUTS: add_argument(invoker,"--replace"); break;
default: add_argument(invoker,"--ignore"); break;
}
// add the alphabet
char alphabet_argument[FILENAME_MAX+11];
sprintf(alphabet_argument,"--alphabet=%s",alphabet_name);
add_argument(invoker, alphabet_argument);
// look for the longest match argument
add_argument(invoker, "--longest_matches");
// look for all the occurrences
add_argument(invoker, "--all");
if ((*negation_operator) != 0) {
char negation_operator_argument[0x40];
sprintf(negation_operator_argument,"--negation_operator=%s",negation_operator);
add_argument(invoker,negation_operator_argument);
}
char line_command[4096];
build_command_line(invoker,line_command);
fprintf(stdout, "%s\n",line_command);
int result = invoke(invoker);
free_ProgramInvoker(invoker);
return result;
}
// ---------------------------------------------------------------------------
// Initialize dialog. Continue only if the return value is true
// ---------------------------------------------------------------------------
bool t_dialog_caravan_arrivals::init_dialog( t_town & town, t_creature_array * visiting_army )
{
t_player & player = m_map.get_player();
int player_number = m_map.get_player_number();
bool foreigners = ( town.get_owner_number() != player_number
|| ( visiting_army && visiting_army->get_owner_number() != player_number ) );
t_keyword_replacer town_replacer;
town_replacer.add_keyword( "%town", town.get_name() );
t_caravan_set const & caravans = player.get_caravans();
t_caravan_set::const_iterator it;
for ( it = caravans.get_lower_bound_of_destination( &town ); it != caravans.end() && (*it)->get_destination().get() == &town; it++ )
{
if ( (*it)->has_arrived() )
m_caravans.push_back( *it );
}
if ( m_caravans.empty() )
{
ok_dialog( town_replacer( k_no_arrivals ), true );
return false;
}
// Create subwindows
m_bitmaps = k_bitmaps.get();
t_help_block const& help = get_help_block( "caravan_arrival" );
t_help_block const& shared_help = get_help_block( "shared" );
t_bitmap_layer const * layer;
t_window * background;
t_text_window * text_window;
t_button * button;
layer = m_bitmaps->find( "background" );
background = new t_bitmap_layer_window( layer, t_screen_point(0, 0), this );
layer = m_bitmaps->find( "text scroll" );
new t_bitmap_layer_window( layer, t_screen_point(0, 0), background );
layer = m_bitmaps->find( "title scroll" );
new t_bitmap_layer_window( layer, t_screen_point(0, 0), background );
layer = m_bitmaps->find( "title" );
text_window = new t_text_window( get_font( 20 ), layer->get_rect(), background, town_replacer( k_title ), t_pixel_24(0,0,0) );
text_window->set_drop_shadow( false );
text_window->set_justification( k_justify_center );
layer = m_bitmaps->find( "text" );
text_window = new t_text_window( get_font( 16 ), layer->get_rect(), background, town_replacer( k_text ), t_pixel_24(0,0,0) );
text_window->set_drop_shadow( false );
text_window->set_justification( k_justify_center );
layer = m_bitmaps->find( "ok_button" );
button = new t_button( g_ok_button.get(), layer->get_rect().top_left(), background );
button->set_click_handler( bound_handler( *this, &t_dialog_caravan_arrivals::ok_clicked ) );
set_help( button, shared_help, "ok" );
// Create creature windows
t_creature_array_window::t_layout garrison_layout;
t_bitmap_layer const * background_layer;
if ( visiting_army )
{
background_layer = m_bitmaps->find( "double_garrison_background" );
layer = m_bitmaps->find( "double_garrison_rings" );
garrison_layout = t_creature_array_window::k_top_row;
}
else
{
background_layer = m_bitmaps->find( "single_garrison_background" );
layer = m_bitmaps->find( "single_garrison_rings" );
garrison_layout = t_creature_array_window::k_single_row;
}
new t_bitmap_layer_window( background_layer, t_screen_point(0, 0), background );
m_garrison_window = new t_creature_array_window( layer->get_rect().top_left(), &town, garrison_layout, 0, background );
if ( foreigners )
setup_foreign_creature_array_window_controls( m_map, m_garrison_window );
if ( visiting_army )
{
t_screen_point visiting_point = layer->get_rect().top_left();
visiting_point.y += m_garrison_window->get_frame_height();
m_visiting_window = new t_creature_array_window( visiting_point, visiting_army, t_creature_array_window::k_bottom_row, 0, background );
m_visiting_window->link_selection( m_garrison_window );
m_visiting_window->move_before( m_garrison_window );
layer = m_bitmaps->find( "move_garrison_button" );
button = new t_button( k_move_garrison_down_button.get(), layer->get_rect().top_left(), background );
if ( town.get_owner_number() == player_number )
{
button->set_click_handler( discard_argument< t_button * >( bound_handler( *this, &t_dialog_caravan_arrivals::move_garrison_clicked ) ) );
}
else
{
button->enable( false );
}
set_help( button, shared_help, "move_garrison_to_adjacent" );
layer = m_bitmaps->find( "move_visiting_button" );
button = new t_button( k_move_up_button.get(), layer->get_rect().top_left(), background );
if ( visiting_army->get_owner_number() == player_number )
{
button->set_click_handler( discard_argument< t_button * >( bound_handler( *this, &t_dialog_caravan_arrivals::move_visiting_clicked ) ) );
}
else
{
button->enable( false );
}
set_help( button, shared_help, "move_adjacent_to_garrison" );
if ( foreigners )
setup_foreign_creature_array_window_controls( m_map, m_visiting_window );
}
// Create scrollbar
if ( m_caravans.size() > k_displayed_caravans )
{
layer = m_bitmaps->find( "scrollbar" );
t_scrollbar * scrollbar = new t_scrollbar( layer->get_rect().top_left(), layer->get_height(), background,
0, m_caravans.size() - k_displayed_caravans );
scrollbar->set_page_size( k_displayed_caravans);
scrollbar->set_handler( bound_handler( *this, &t_dialog_caravan_arrivals::scroll ) );
}
// Create caravan window(s)
int visible_caravans = minimum( unsigned int( k_displayed_caravans ), m_caravans.size() );
int i;
layer = m_bitmaps->find( "caravan_1" );
t_screen_point caravan_1_point = layer->get_rect().top_left();
background_layer = m_bitmaps->find( "caravan_background" );
layer = m_bitmaps->find( "move_caravan_to_garrison_button" );
t_screen_point move_to_garrison_offset = layer->get_rect().top_left() - caravan_1_point;
layer = m_bitmaps->find( "move_caravan_to_visiting_button" );
t_screen_point move_to_visiting_offset = layer->get_rect().top_left() - caravan_1_point;
layer = m_bitmaps->find( "caravan_rings" );
t_screen_point caravan_rings_offset = layer->get_rect().top_left() - caravan_1_point;
for ( i = 0; i < visible_caravans; i++ )
{
t_screen_point caravan_point;
if ( i == 0 )
{
caravan_point = caravan_1_point;
}
else
{
layer = m_bitmaps->find( format_string("caravan_%d", i + 1 ) );
caravan_point = layer->get_rect().top_left();
}
// Background
t_screen_point diff = caravan_point - caravan_1_point;
new t_bitmap_layer_window( background_layer, diff, background );
// Buttons
button = new t_button( k_move_caravan_to_garrison_button.get(), caravan_point + move_to_garrison_offset, background );
button->set_click_handler( discard_argument< t_button * >( add_argument( bound_handler( *this, &t_dialog_caravan_arrivals::move_to_garrison_clicked ), i ) ) );
set_help( button, help, "move_caravan_to_garrison" );
if ( visiting_army )
{
button = new t_button( k_move_caravan_to_visiting_button.get(), caravan_point + move_to_visiting_offset, background );
button->set_click_handler( discard_argument< t_button * >( add_argument( bound_handler( *this, &t_dialog_caravan_arrivals::move_to_visiting_clicked ), i ) ) );
set_help( button, help, "move_caravan_to_visiting" );
}
m_visible_caravans[i] = new t_creature_array_window( caravan_point + caravan_rings_offset,
m_caravans[i].get(),
t_creature_array_window::k_single_row,
0,
background );
m_visible_caravans[i]->link_selection( m_garrison_window );
if ( foreigners )
setup_foreign_creature_array_window_controls( m_map, m_visible_caravans[i] );
}
t_screen_rect rect = m_bitmaps->get_rect();
rect += (get_parent()->get_client_rect().size() - rect.size()) / 2;
init( rect );
return true;
}
// If LINE is an argument-setting command, add it to the list of arguments
void add_to_arguments(const string& line)
{
if (is_set_args_cmd(line))
{
string args = line.after("args");
args = args.after(rxwhite);
add_argument(args, run_arguments, last_run_argument,
run_arguments_updated);
}
else if (gdb->type() == PERL && line.contains("@ARGV = ", 0))
{
// @ARGV = ('arg1', 'arg2', )
string args = line.after("('");
args.gsub("', '", " ");
args = args.before("', )");
add_argument(args, run_arguments, last_run_argument,
run_arguments_updated);
}
else if (is_run_cmd(line))
{
string args;
if (gdb->type() == JDB)
{
// `run CLASS ARGS...'
args = line.after(rxwhite);
args = args.after(rxwhite);
}
else if (gdb->type() == PERL && line.contains("exec ", 0))
{
// `exec "perl -d PROGRAM ARGS..."'
args = line.after("exec ");
strip_leading_space(args);
if (args.contains('\"', 0) || args.contains('\'', 0))
args = unquote(args);
args = args.after("-d ");
strip_leading_space(args);
args = args.after(rxwhite);
}
else
{
// `run ARGS...'
args = line.after(rxwhite);
}
add_argument(args, run_arguments, last_run_argument,
run_arguments_updated);
}
else if (is_make_cmd(line))
{
string args = line.after("make");
args = args.after(rxwhite);
add_argument(args, make_arguments, last_make_argument,
make_arguments_updated);
}
else if (gdb->type() == PERL && line.contains("system 'make", 0))
{
string args = line.after("make");
args = args.after(rxwhite);
args = args.before("'");
add_argument(args, make_arguments, last_make_argument,
make_arguments_updated);
}
else if (is_cd_cmd(line))
{
string dir = line.after("cd");
dir = dir.after(rxwhite);
dir = source_view->full_path(dir);
if (dir.contains('/', 0))
add_argument(dir, cd_arguments, last_cd_argument,
cd_arguments_updated);
}
else if (gdb->type() == PERL && line.contains("chdir '", 0))
{
string dir = line.after("'");
dir = dir.before("'");
add_argument(dir, cd_arguments, last_cd_argument,
cd_arguments_updated);
}
else if (gdb->type() == PERL && is_file_cmd(line, gdb))
{
string args = line.after(" -d ");
args = args.after(rxwhite); // Skip file name
args = args.before('\"');
add_argument(args, run_arguments, last_run_argument,
run_arguments_updated);
}
}
int pseudo_main_SortTxt(const VersatileEncodingConfig* vec, int duplicates,
int reverse, char* sort_alphabet, char* line_info, int thai,
char* text, int factorize) {
ProgramInvoker* invoker = new_ProgramInvoker(main_SortTxt, "main_SortTxt");
char tmp[200];
{
tmp[0] = 0;
get_reading_encoding_text(tmp, sizeof(tmp) - 1,
vec->mask_encoding_compatibility_input);
if (tmp[0] != '\0') {
add_argument(invoker, "-k");
add_argument(invoker, tmp);
}
tmp[0] = 0;
get_writing_encoding_text(tmp, sizeof(tmp) - 1, vec->encoding_output,
vec->bom_output);
if (tmp[0] != '\0') {
add_argument(invoker, "-q");
add_argument(invoker, tmp);
}
}
if (duplicates) {
add_argument(invoker, "-d");
} else {
add_argument(invoker, "-n");
}
if (reverse) {
add_argument(invoker, "-r");
}
if (sort_alphabet != NULL) {
add_argument(invoker, "-o");
add_argument(invoker, sort_alphabet);
}
if (line_info != NULL) {
add_argument(invoker, "-l");
add_argument(invoker, line_info);
}
if (thai) {
add_argument(invoker, "-t");
}
if (factorize) {
add_argument(invoker, "-f");
}
add_argument(invoker, text);
int ret = invoke(invoker);
free_ProgramInvoker(invoker);
return ret;
}
int parse_arguments(modsec_rec *msr, const char *s, apr_size_t inputlength,
int argument_separator, const char *origin,
apr_table_t *arguments, int *invalid_count)
{
msc_arg *arg;
apr_size_t i, j;
char *value = NULL;
char *buf;
int status;
int changed;
if (s == NULL) return -1;
if (inputlength == 0) return 1;
/* Check that adding one will not overflow */
if (inputlength + 1 <= 0) return -1;
buf = (char *)malloc(inputlength + 1);
if (buf == NULL) return -1;
arg = (msc_arg *)apr_pcalloc(msr->mp, sizeof(msc_arg));
arg->origin = origin;
i = 0;
j = 0;
status = 0;
*invalid_count = 0;
while (i < inputlength) {
if (status == 0) {
/* parameter name */
arg->name_origin_offset = i;
while ((s[i] != '=') && (s[i] != argument_separator) && (i < inputlength)) {
buf[j] = s[i];
j++;
i++;
}
buf[j++] = '\0';
arg->name_origin_len = i - arg->name_origin_offset;
} else {
/* parameter value */
arg->value_origin_offset = i;
while ((s[i] != argument_separator) && (i < inputlength)) {
buf[j] = s[i];
j++;
i++;
}
buf[j++] = '\0';
arg->value_origin_len = i - arg->value_origin_offset;
}
if (status == 0) {
arg->name_len = urldecode_nonstrict_inplace_ex((unsigned char *)buf, arg->name_origin_len, invalid_count, &changed);
arg->name = apr_pstrmemdup(msr->mp, buf, arg->name_len);
if (s[i] == argument_separator) {
/* Empty parameter */
arg->value_len = 0;
arg->value = "";
add_argument(msr, arguments, arg);
arg = (msc_arg *)apr_pcalloc(msr->mp, sizeof(msc_arg));
arg->origin = origin;
status = 0; /* unchanged */
j = 0;
} else {
status = 1;
value = &buf[j];
}
}
else {
arg->value_len = urldecode_nonstrict_inplace_ex((unsigned char *)value, arg->value_origin_len, invalid_count, &changed);
arg->value = apr_pstrmemdup(msr->mp, value, arg->value_len);
add_argument(msr, arguments, arg);
arg = (msc_arg *)apr_pcalloc(msr->mp, sizeof(msc_arg));
arg->origin = origin;
status = 0;
j = 0;
}
i++; /* skip over the separator */
}
/* the last parameter was empty */
if (status == 1) {
arg->value_len = 0;
arg->value = "";
add_argument(msr, arguments, arg);
}
free(buf);
return 1;
}
bool DumpBbsDataCommand::AddSubCommands() {
add_argument(BooleanCommandLineArgument("bbslist", 'l', "Parse BBSList.NET vs. BBSDATA.NET", false));
return true;
}