rtems_task Init(rtems_task_argument not_used)
{
test_main();
rtems_test_exit(0);
}
int
main(void) {
test_main();
return 0;
}
static int test_main_entry(char *output, size_t sz)
{
test_main();
return 0;
}
int main(int ac, char* av[])
{
test_type_changes(11);
return test_main(ac, av);
}
bool Main::start() {
ERR_FAIL_COND_V(!_start_success,false);
bool editor=false;
String doc_tool;
bool doc_base=true;
String game_path;
String script;
String test;
String screen;
String optimize;
String optimize_preset;
String _export_platform;
String _import;
String _import_script;
String dumpstrings;
bool noquit=false;
bool convert_old=false;
bool export_debug=false;
bool project_manager_request = false;
List<String> args = OS::get_singleton()->get_cmdline_args();
for (int i=0;i<args.size();i++) {
//parameters that do not have an argument to the right
if (args[i]=="-nodocbase") {
doc_base=false;
} else if (args[i]=="-noquit") {
noquit=true;
} else if (args[i]=="-convert_old") {
convert_old=true;
} else if (args[i]=="-editor" || args[i]=="-e") {
editor=true;
} else if (args[i] == "-pm" || args[i] == "-project_manager") {
project_manager_request = true;
} else if (args[i].length() && args[i][0] != '-' && game_path == "") {
game_path=args[i];
}
//parameters that have an argument to the right
else if (i < (args.size()-1)) {
bool parsed_pair=true;
if (args[i]=="-doctool") {
doc_tool=args[i+1];
} else if (args[i]=="-script" || args[i]=="-s") {
script=args[i+1];
} else if (args[i]=="-level" || args[i]=="-l") {
OS::get_singleton()->_custom_level=args[i+1];
} else if (args[i]=="-test") {
test=args[i+1];
} else if (args[i]=="-optimize") {
optimize=args[i+1];
} else if (args[i]=="-optimize_preset") {
optimize_preset=args[i+1];
} else if (args[i]=="-export") {
editor=true; //needs editor
_export_platform=args[i+1];
} else if (args[i]=="-export_debug") {
editor=true; //needs editor
_export_platform=args[i+1];
export_debug=true;
} else if (args[i]=="-import") {
editor=true; //needs editor
_import=args[i+1];
} else if (args[i]=="-import_script") {
editor=true; //needs editor
_import_script=args[i+1];
} else if (args[i]=="-dumpstrings") {
editor=true; //needs editor
dumpstrings=args[i+1];
} else {
// The parameter does not match anything known, don't skip the next argument
parsed_pair=false;
}
if (parsed_pair) {
i++;
}
}
}
if (editor)
Globals::get_singleton()->set("editor_active",true);
String main_loop_type;
#ifdef TOOLS_ENABLED
if(doc_tool!="") {
DocData doc;
doc.generate(doc_base);
DocData docsrc;
if (docsrc.load(doc_tool)==OK) {
print_line("Doc exists. Merging..");
doc.merge_from(docsrc);
} else {
print_line("No Doc exists. Generating empty.");
}
doc.save(doc_tool);
return false;
}
if (optimize!="")
editor=true; //need editor
#endif
if (_export_platform!="") {
if (game_path=="") {
String err="Command line param ";
err+=export_debug?"-export_debug":"-export";
err+=" passed but no destination path given.\n";
err+="Please specify the binary's file path to export to. Aborting export.";
ERR_PRINT(err.utf8().get_data());
return false;
}
}
if(script=="" && game_path=="" && String(GLOBAL_DEF("application/main_scene",""))!="") {
game_path=GLOBAL_DEF("application/main_scene","");
}
MainLoop *main_loop=NULL;
if (editor) {
main_loop = memnew(SceneTree);
};
if (test!="") {
#ifdef DEBUG_ENABLED
main_loop = test_main(test,args);
if (!main_loop)
return false;
#endif
} else if (script!="") {
Ref<Script> script_res = ResourceLoader::load(script);
ERR_EXPLAIN("Can't load script: "+script);
ERR_FAIL_COND_V(script_res.is_null(),false);
if( script_res->can_instance() /*&& script_res->inherits_from("SceneTreeScripted")*/) {
StringName instance_type=script_res->get_instance_base_type();
Object *obj = ObjectTypeDB::instance(instance_type);
MainLoop *script_loop = obj?obj->cast_to<MainLoop>():NULL;
if (!script_loop) {
if (obj)
memdelete(obj);
ERR_EXPLAIN("Can't load script '"+script+"', it does not inherit from a MainLoop type");
ERR_FAIL_COND_V(!script_loop,false);
}
script_loop->set_init_script(script_res);
main_loop=script_loop;
} else {
return false;
}
} else {
main_loop_type=GLOBAL_DEF("application/main_loop_type","");
}
if (!main_loop && main_loop_type=="")
main_loop_type="SceneTree";
if (!main_loop) {
if (!ObjectTypeDB::type_exists(main_loop_type)) {
OS::get_singleton()->alert("godot: error: MainLoop type doesn't exist: "+main_loop_type);
return false;
} else {
Object *ml = ObjectTypeDB::instance(main_loop_type);
if (!ml) {
ERR_EXPLAIN("Can't instance MainLoop type");
ERR_FAIL_V(false);
}
main_loop=ml->cast_to<MainLoop>();
if (!main_loop) {
memdelete(ml);
ERR_EXPLAIN("Invalid MainLoop type");
ERR_FAIL_V(false);
}
}
}
if (main_loop->is_type("SceneTree")) {
SceneTree *sml = main_loop->cast_to<SceneTree>();
if (debug_collisions) {
sml->set_debug_collisions_hint(true);
}
if (debug_navigation) {
sml->set_debug_navigation_hint(true);
}
#ifdef TOOLS_ENABLED
EditorNode *editor_node=NULL;
if (editor) {
editor_node = memnew( EditorNode );
sml->get_root()->add_child(editor_node);
//root_node->set_editor(editor);
//startup editor
if (_export_platform!="") {
editor_node->export_platform(_export_platform,game_path,export_debug,"",true);
game_path=""; //no load anything
}
}
#endif
if (!editor) {
//standard helpers that can be changed from main config
String stretch_mode = GLOBAL_DEF("display/stretch_mode","disabled");
String stretch_aspect = GLOBAL_DEF("display/stretch_aspect","ignore");
Size2i stretch_size = Size2(GLOBAL_DEF("display/width",0),GLOBAL_DEF("display/height",0));
SceneTree::StretchMode sml_sm=SceneTree::STRETCH_MODE_DISABLED;
if (stretch_mode=="2d")
sml_sm=SceneTree::STRETCH_MODE_2D;
else if (stretch_mode=="viewport")
sml_sm=SceneTree::STRETCH_MODE_VIEWPORT;
SceneTree::StretchAspect sml_aspect=SceneTree::STRETCH_ASPECT_IGNORE;
if (stretch_aspect=="keep")
sml_aspect=SceneTree::STRETCH_ASPECT_KEEP;
else if (stretch_aspect=="keep_width")
sml_aspect=SceneTree::STRETCH_ASPECT_KEEP_WIDTH;
else if (stretch_aspect=="keep_height")
sml_aspect=SceneTree::STRETCH_ASPECT_KEEP_HEIGHT;
sml->set_screen_stretch(sml_sm,sml_aspect,stretch_size);
sml->set_auto_accept_quit(GLOBAL_DEF("application/auto_accept_quit",true));
String appname = Globals::get_singleton()->get("application/name");
appname = TranslationServer::get_singleton()->translate(appname);
OS::get_singleton()->set_window_title(appname);
} else {
GLOBAL_DEF("display/stretch_mode","disabled");
Globals::get_singleton()->set_custom_property_info("display/stretch_mode",PropertyInfo(Variant::STRING,"display/stretch_mode",PROPERTY_HINT_ENUM,"disabled,2d,viewport"));
GLOBAL_DEF("display/stretch_aspect","ignore");
Globals::get_singleton()->set_custom_property_info("display/stretch_aspect",PropertyInfo(Variant::STRING,"display/stretch_aspect",PROPERTY_HINT_ENUM,"ignore,keep,keep_width,keep_height"));
sml->set_auto_accept_quit(GLOBAL_DEF("application/auto_accept_quit",true));
}
if (game_path!="" && !project_manager_request) {
String local_game_path=game_path.replace("\\","/");
if (!local_game_path.begins_with("res://")) {
bool absolute=(local_game_path.size()>1) && (local_game_path[0]=='/' || local_game_path[1]==':');
if (!absolute) {
if (Globals::get_singleton()->is_using_datapack()) {
local_game_path="res://"+local_game_path;
} else {
int sep=local_game_path.find_last("/");
if (sep==-1) {
DirAccess *da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
local_game_path=da->get_current_dir()+"/"+local_game_path;
memdelete(da) ;
} else {
DirAccess *da = DirAccess::open(local_game_path.substr(0,sep));
if (da) {
local_game_path=da->get_current_dir()+"/"+local_game_path.substr(sep+1,local_game_path.length());;
memdelete(da);
}
}
}
}
}
local_game_path=Globals::get_singleton()->localize_path(local_game_path);
#ifdef TOOLS_ENABLED
if (editor) {
if (_import!="") {
//editor_node->import_scene(_import,local_game_path,_import_script);
if (!noquit)
sml->quit();
game_path=""; //no load anything
} else {
Error serr = editor_node->load_scene(local_game_path);
if (serr==OK) {
if (optimize!="") {
editor_node->save_optimized_copy(optimize,optimize_preset);
if (!noquit)
sml->quit();
}
if (dumpstrings!="") {
editor_node->save_translatable_strings(dumpstrings);
if (!noquit)
sml->quit();
}
}
}
OS::get_singleton()->set_context(OS::CONTEXT_EDITOR);
//editor_node->set_edited_scene(game);
} else {
#endif
{
//autoload
List<PropertyInfo> props;
Globals::get_singleton()->get_property_list(&props);
//first pass, add the constants so they exist before any script is loaded
for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) {
String s = E->get().name;
if (!s.begins_with("autoload/"))
continue;
String name = s.get_slicec('/',1);
String path = Globals::get_singleton()->get(s);
bool global_var=false;
if (path.begins_with("*")) {
global_var=true;
}
if (global_var) {
for(int i=0;i<ScriptServer::get_language_count();i++) {
ScriptServer::get_language(i)->add_global_constant(name,Variant());
}
}
}
//second pass, load into global constants
List<Node*> to_add;
for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) {
String s = E->get().name;
if (!s.begins_with("autoload/"))
continue;
String name = s.get_slicec('/',1);
String path = Globals::get_singleton()->get(s);
bool global_var=false;
if (path.begins_with("*")) {
global_var=true;
path=path.substr(1,path.length()-1);
}
RES res = ResourceLoader::load(path);
ERR_EXPLAIN("Can't autoload: "+path);
ERR_CONTINUE(res.is_null());
Node *n=NULL;
if (res->is_type("PackedScene")) {
Ref<PackedScene> ps = res;
n=ps->instance();
} else if (res->is_type("Script")) {
Ref<Script> s = res;
StringName ibt = s->get_instance_base_type();
bool valid_type = ObjectTypeDB::is_type(ibt,"Node");
ERR_EXPLAIN("Script does not inherit a Node: "+path);
ERR_CONTINUE( !valid_type );
Object *obj = ObjectTypeDB::instance(ibt);
ERR_EXPLAIN("Cannot instance script for autoload, expected 'Node' inheritance, got: "+String(ibt));
ERR_CONTINUE( obj==NULL );
n = obj->cast_to<Node>();
n->set_script(s.get_ref_ptr());
}
ERR_EXPLAIN("Path in autoload not a node or script: "+path);
ERR_CONTINUE(!n);
n->set_name(name);
//defer so references are all valid on _ready()
//sml->get_root()->add_child(n);
to_add.push_back(n);
if (global_var) {
for(int i=0;i<ScriptServer::get_language_count();i++) {
ScriptServer::get_language(i)->add_global_constant(name,n);
}
}
}
for(List<Node*>::Element *E=to_add.front();E;E=E->next()) {
sml->get_root()->add_child(E->get());
}
}
Node *scene=NULL;
Ref<PackedScene> scenedata = ResourceLoader::load(local_game_path);
if (scenedata.is_valid())
scene=scenedata->instance();
ERR_EXPLAIN("Failed loading scene: "+local_game_path);
ERR_FAIL_COND_V(!scene,false)
//sml->get_root()->add_child(scene);
sml->add_current_scene(scene);
String iconpath = GLOBAL_DEF("application/icon","Variant()""");
if (iconpath!="") {
Image icon;
if (icon.load(iconpath)==OK)
OS::get_singleton()->set_icon(icon);
}
//singletons
#ifdef TOOLS_ENABLED
}
#endif
}
#ifdef TOOLS_ENABLED
/*if (_export_platform!="") {
sml->quit();
}*/
/*
if (sml->get_root_node()) {
Console *console = memnew( Console );
sml->get_root_node()->cast_to<RootNode>()->set_console(console);
if (GLOBAL_DEF("console/visible_default",false).operator bool()) {
console->show();
} else {P
console->hide();
};
}
*/
if (project_manager_request || (script=="" && test=="" && game_path=="" && !editor)) {
ProjectManager *pmanager = memnew( ProjectManager );
sml->get_root()->add_child(pmanager);
OS::get_singleton()->set_context(OS::CONTEXT_PROJECTMAN);
}
#endif
}
OS::get_singleton()->set_main_loop( main_loop );
return true;
}
void app_main(void){
test_main();
}
int main(int argc, char **argv)
{
#ifdef EVALUATION
if (argc != 2) {
printf("INTANG is compiled in Evalution Mode. Usage:\n%s <sid>\n", argv[0]);
return 0;
}
#endif
//TODO: use option parser
int i;
if (argc >= 2) {
if (strcmp(argv[1], "-h") == 0) {
// print strategy list
printf("Strategies:\n");
for (i = 0; i < g_strat_num; i++) {
printf("%d\t%s\n", i, g_strats[i].name);
}
return 0;
}
int sid = atoi(argv[1]);
if (sid >= 0 && sid < g_strat_num) {
for (i = 0; i < g_strat_num; i++) {
g_strat_weights[i] = 0;
}
g_strat_weights[sid] = 10;
printf("Using strategy %d, %s.\n", sid, g_strats[sid].name);
}
else {
printf("Invalid SID %d.\n", sid);
return -1;
}
}
// check for root privilege
uid_t uid=getuid(), euid=geteuid();
if (euid != 0) {
printf("This program needs root privilege to work.\n");
exit(EXIT_FAILURE);
}
// create the application directory if not exist
mkdir(APP_DIR, 0755);
//setlogmask(LOG_UPTO(LOG_NOTICE));
//openlog("intangd", LOG_CONS | LOG_NDELAY | LOG_PID, LOG_LOCAL1);
// turns the process into a daemon
setup_daemon();
printf("Daemon has started.\n");
if (opt_logging_to_file) {
printf("The logs can be found in %s\n", LOG_FILE);
}
// now the process turns into a daemon process
// initialization
initialize();
#ifdef TEST
test_main();
#else
// Main loop
int rv;
char buf[65536];
while ((rv = recv(g_nfq_fd, buf, sizeof(buf), 0)) && rv >= 0) {
//log_debugv("pkt received");
nfq_handle_packet(g_nfq_h, buf, rv);
}
log_debug("rv = %d. errno: %d. %s", rv, errno, strerror(errno));
log_debug("Running out of the loop.");
#endif
cleanup();
log_info("Daemon exited.");
return 0;
}
/*
* main loop: listen on stdin (for user input) and master pty (for command output),
* and try to write output_queue to master_pty (if it is not empty)
* This function never returns.
*/
void
main_loop()
{
int nfds;
fd_set readfds;
fd_set writefds;
int nread;
char buf[BUFFSIZE], *timeoutstr, *old_raw_prompt, *new_output_minus_prompt;
int promptlen = 0;
int leave_prompt_alone;
sigset_t no_signals_blocked;
struct timespec select_timeout, *select_timeoutptr;
struct timespec immediately = { 0, 0 }; /* zero timeout when child is dead */
struct timespec wait_a_little = {0, 0xBadf00d }; /* tv_usec field will be filled in when initialising */
struct timespec *forever = NULL;
wait_a_little.tv_nsec = 1000 * 1000 * wait_before_prompt;
sigemptyset(&no_signals_blocked);
init_readline("");
last_minute_checks();
pass_through_filter(TAG_OUTPUT,""); /* If something is wrong with filter, get the error NOW */
set_echo(FALSE); /* This will also put the terminal in CBREAK mode */
test_main();
/* ------------------------------ main loop -------------------------------*/
while (TRUE) {
/* listen on both stdin and pty_fd */
FD_ZERO(&readfds);
FD_SET(STDIN_FILENO, &readfds);
FD_SET(master_pty_fd, &readfds);
/* try to write output_queue to master_pty (but only if it is nonempty) */
FD_ZERO(&writefds);
if (output_queue_is_nonempty())
FD_SET(master_pty_fd, &writefds);
DPRINTF1(DEBUG_AD_HOC, "prompt_is_still_uncooked = %d", prompt_is_still_uncooked);
if (command_is_dead || ignore_queued_input) {
select_timeout = immediately;
select_timeoutptr = &select_timeout;
timeoutstr = "immediately";
} else if (prompt_is_still_uncooked) {
select_timeout = wait_a_little;
select_timeoutptr = &select_timeout;
timeoutstr = "wait_a_little";
} else {
select_timeoutptr = forever; /* NULL */
timeoutstr = "forever";
}
DPRINTF1(DEBUG_TERMIO, "calling select() with timeout %s", timeoutstr);
nfds = my_pselect(1 + master_pty_fd, &readfds, &writefds, NULL, select_timeoutptr, &no_signals_blocked);
DPRINTF3(DEBUG_TERMIO, "select() returned %d (stdin|pty in|pty out = %03d), within_line_edit=%d", nfds,
100*(FD_ISSET(STDIN_FILENO, &readfds)?1:0) + 10*(FD_ISSET(master_pty_fd, &readfds)?1:0) + (FD_ISSET(master_pty_fd, &writefds)?1:0),
within_line_edit);
assert(!filter_pid || filter_is_dead || kill(filter_pid,0) == 0);
assert(command_is_dead || kill(command_pid,0) == 0);
/* check flags that may have been set by signal handlers */
if (filter_is_dead)
filters_last_words(); /* will call myerror with last words */
if (received_WINCH) { /* received_WINCH flag means we've had a WINCH while within_line_edit was FALSE */
DPRINTF0(DEBUG_READLINE, "Starting line edit as a result of WINCH ");
within_line_edit = TRUE;
restore_rl_state();
received_WINCH = FALSE;
continue;
}
if (nfds < 0) { /* exception */
if (errno == EINTR) { /* interrupted by signal */
continue;
} else
myerror("select received exception");
} else if (nfds == 0) {
/* timeout, which can only happen when .. */
if (ignore_queued_input) { /* ... we have read all the input keystrokes that should
be ignored (i.e. those that accumulated on stdin while we
were calling an external editor) */
ignore_queued_input = FALSE;
continue;
} else if (command_is_dead) { /* ... or else, if child is dead, ... */
DPRINTF2(DEBUG_SIGNALS,
"select returned 0, command_is_dead=%d, commands_exit_status=%d",
command_is_dead, commands_exit_status);
cleanup_rlwrap_and_exit(EXIT_SUCCESS);
} else if (prompt_is_still_uncooked) { /* cooking time? */
if (we_just_got_a_signal_or_EOF) {
we_just_got_a_signal_or_EOF = FALSE; /* 1. If we got a signal/EOF before cooking time, we don't need special action
to preserve the cooked prompt.
2. Reset we_just_got_a_signal_or_EOF after a signal or EOF that didn't kill command */
continue;
}
if (!skip_rlwrap()) { /* ... or else, it is time to cook the prompt */
if (pre_given && accepted_lines == 0) {
saved_rl_state.input_buffer = mysavestring(pre_given); /* stuff pre-given text into edit buffer */
saved_rl_state.point = strlen(pre_given);
DPRINTF0(DEBUG_READLINE, "Starting line edit (because of -P option)");
within_line_edit = TRUE;
restore_rl_state();
continue;
}
if (accepted_lines == 1 && one_shot_rlwrap)
cleanup_rlwrap_and_exit(EXIT_SUCCESS);
move_cursor_to_start_of_prompt(ERASE); /* cooked prompt may be shorter than raw prompt, hence the ERASE */
/* move and erase before cooking, as we need to move/erase according
to the raw prompt */
cook_prompt_if_necessary();
DPRINTF2(DEBUG_READLINE,"After cooking, raw_prompt=%s, cooked=%s",
mangle_string_for_debug_log(saved_rl_state.raw_prompt, MANGLE_LENGTH),
mangle_string_for_debug_log(saved_rl_state.cooked_prompt, MANGLE_LENGTH));
my_putstr(saved_rl_state.cooked_prompt);
rlwrap_already_prompted = TRUE;
}
prompt_is_still_uncooked = FALSE;
} else {
myerror("unexpected select() timeout");
}
} else if (nfds > 0) { /* Hah! something to read or write */
/* -------------------------- read pty --------------------------------- */
if (FD_ISSET(master_pty_fd, &readfds)) { /* there is something to read on master pty: */
if ((nread = read(master_pty_fd, buf, BUFFSIZE - 1)) <= 0) { /* read it */
if (command_is_dead || nread == 0) { /* child is dead or has closed its stdout */
if (promptlen > 0) /* commands dying words were not terminated by \n ... */
my_putchar('\n'); /* provide the missing \n */
cleanup_rlwrap_and_exit(EXIT_SUCCESS);
} else if (errno == EINTR) /* interrupted by signal ...*/
continue; /* ... don't worry */
else
myerror("read error on master pty");
}
completely_mirror_slaves_output_settings(); /* some programs (e.g. joe) need this. Gasp!! */
if (skip_rlwrap()) { /* Race condition here! The client may just have finished an emacs session and
returned to cooked mode, while its ncurses-riddled output is stil waiting for us to be processed. */
write_patiently(STDOUT_FILENO, buf, nread, "to stdout");
DPRINTF2(DEBUG_TERMIO, "read from pty and wrote to stdout %d bytes in direct mode <%s>",
nread, mangle_string_for_debug_log((buf[nread]='\0', buf), MANGLE_LENGTH));
yield();
continue;
}
DPRINTF2(DEBUG_TERMIO, "read %d bytes from pty into buffer: %s", nread, mangle_string_for_debug_log((buf[nread]='\0', buf), MANGLE_LENGTH));
remove_padding_and_terminate(buf, nread);
write_logfile(buf);
if (within_line_edit) /* client output arrives while we're editing keyboard input: */
save_rl_state(); /* temporarily disable readline and restore the screen state before readline was called */
assert(saved_rl_state.raw_prompt != NULL);
/* We *always* compute the printable part and the new raw prompt, and *always* print the printable part
There are four possibilities:
1. impatient before cooking. The raw prompt has been printed, write the new output after it
2. patient before cooking No raw prompt has been printed yet, don't print anything
3. impatient after cooking
3a no current prompt print the new output
3b some current prompt erase it, replace by current raw prompt and print new output
4. patient after cooking don't print anything
*/
/* sometimes we want to leave the prompt standing, e.g. after accepting a line, or when a signal arrived */
leave_prompt_alone =
*saved_rl_state.raw_prompt == '\0' /* saved_rl_state.raw_prompt = "" in two distinct cases: when there is actually no prompt,
or just after accepting a line, when the cursor is at the end of the prompt. In both
cases, we dont't want to move the cursor */
|| prompt_is_still_uncooked /* in this case no prompt has been displayed yet */
|| command_is_dead
|| (we_just_got_a_signal_or_EOF && strrchr(buf, '\n')); /* a signal followed by output with a newline in it: treat it as
response to user input, so leave the prompt alone */
DPRINTF3(DEBUG_READLINE, "leave_prompt_alone: %s (raw prompt: %s, prompt_is_still_uncooked: %d)",
(leave_prompt_alone? "yes" : "no"), mangle_string_for_debug_log(saved_rl_state.raw_prompt, MANGLE_LENGTH), prompt_is_still_uncooked);
if (!leave_prompt_alone) /* && (!impatient_prompt || !saved_rl_state.cooked_prompt)) */
move_cursor_to_start_of_prompt(ERASE);
else if (we_just_got_a_signal_or_EOF) {
free (saved_rl_state.raw_prompt);
saved_rl_state.raw_prompt = mysavestring(""); /* prevent reprinting the prompt */
}
if (impatient_prompt && !leave_prompt_alone)
old_raw_prompt = mysavestring(saved_rl_state.raw_prompt);
new_output_minus_prompt = process_new_output(buf, &saved_rl_state); /* chop off the part after the last newline and put this in
saved_rl_state.raw_prompt (or append buf if no newline found)*/
if (impatient_prompt) { /* in impatient mode, ALL command output is passed through the OUTPUT filter, including the prompt The
prompt, however, is filtered separately at cooking time and then displayed */
char *filtered = pass_through_filter(TAG_OUTPUT, buf);
if(!leave_prompt_alone) {
my_putstr(old_raw_prompt);
free(old_raw_prompt);
}
my_putstr(filtered);
free (filtered);
rlwrap_already_prompted = TRUE;
} else {
my_putstr(new_output_minus_prompt);
rlwrap_already_prompted = FALSE;
}
free(new_output_minus_prompt);
prompt_is_still_uncooked = TRUE;
if (within_line_edit)
restore_rl_state();
yield(); /* wait for what client has to say .... */
continue; /* ... and don't attempt to process keyboard input as long as it is talking ,
in order to avoid re-printing the current prompt (i.e. unfinished output line) */
}
/* ----------------------------- key pressed: read stdin -------------------------*/
if (FD_ISSET(STDIN_FILENO, &readfds)) { /* key pressed */
unsigned char byte_read; /* the readline function names and documentation talk about "characters" and "keys",
but we're reading bytes (i.e. unsigned chars) here, and those may very well be
part of a multi-byte character. Example: hebrew "aleph" in utf-8 is 0xd790; pressing this key
will make us read 2 bytes 0x90 and then 0xd7, (or maybe the other way round depending on endianness??)
The readline library hides all this complexity and allows one to just "pass the bytes around" */
nread = read(STDIN_FILENO, &byte_read, 1); /* read next byte of input */
assert(sizeof(unsigned char) == 1); /* gets optimised away */
if (nread <= 0)
DPRINTF1(DEBUG_TERMIO, "read from stdin returned %d", nread);
if (nread < 0)
if (errno == EINTR)
continue;
else
myerror("Unexpected error");
else if (nread == 0) /* EOF on stdin */
cleanup_rlwrap_and_exit(EXIT_SUCCESS);
else if (ignore_queued_input)
continue; /* do nothing with it*/
assert(nread == 1);
DPRINTF2(DEBUG_TERMIO, "read from stdin: byte 0x%02x (%s)", byte_read, mangle_char_for_debug_log(byte_read, TRUE));
if (skip_rlwrap()) { /* direct mode, just pass it on */
/* remote possibility of a race condition here: when the first half of a multi-byte char is read in
direct mode and the second half in readline mode. Oh well... */
DPRINTF0(DEBUG_TERMIO, "passing it on (in transparent mode)");
completely_mirror_slaves_terminal_settings(); /* this is of course 1 keypress too late: we should
mirror the terminal settings *before* the user presses a key.
(maybe using rl_event_hook??) @@@FIXME @@@ HOW?*/
write_patiently(master_pty_fd, &byte_read, 1, "to master pty");
} else { /* hand it over to readline */
if (!within_line_edit) { /* start a new line edit */
DPRINTF0(DEBUG_READLINE, "Starting line edit");
within_line_edit = TRUE;
restore_rl_state();
}
if (term_eof && byte_read == term_eof && strlen(rl_line_buffer) == 0) { /* hand a term_eof (usually CTRL-D) directly to command */
char *sent_EOF = mysavestring("?");
*sent_EOF = term_eof;
put_in_output_queue(sent_EOF);
we_just_got_a_signal_or_EOF = TRUE;
free(sent_EOF);
}
else {
rl_stuff_char(byte_read); /* stuff it back in readline's input queue */
DPRINTF0(DEBUG_TERMIO, "passing it to readline");
DPRINTF2(DEBUG_READLINE, "rl_callback_read_char() (_rl_eof_char=%d, term_eof=%d)", _rl_eof_char, term_eof);
rl_callback_read_char();
}
}
}
/* -------------------------- write pty --------------------------------- */
if (FD_ISSET(master_pty_fd, &writefds)) {
flush_output_queue();
yield(); /* give slave command time to respond. If we don't do this,
nothing bad will happen, but the "dialogue" on screen will be
out of order */
}
} /* if (ndfs > 0) */
} /* while (1) */
} /* void main_loop() */
int main()
{
return test_main();
}
int main(int argc, char *argv[])
{
qRegisterMetaType<CurrentStatusUpdate>("CurrentStatusUpdate");
qRegisterMetaType<Items>("Items");
qRegisterMetaType<std::vector<std::string>>("std::vector<std::string>");
qRegisterMetaType<std::vector<ItemLocation>>("std::vector<ItemLocation>");
qRegisterMetaType<QsLogging::Level>("QsLogging::Level");
qRegisterMetaType<TabSelection::Type>("TabSelection::Type");
QLocale::setDefault(QLocale::C);
std::setlocale(LC_ALL, "C");
#if defined(CRASHRPT) && !defined(_DEBUG)
CR_INSTALL_INFOW info;
memset(&info, 0, sizeof(info));
info.cb = sizeof(info);
info.pszAppName = L"Acquisition";
WCHAR wversion[64];
MultiByteToWideChar(CP_UTF8, 0, VERSION_NAME, -1, wversion, sizeof(wversion) / sizeof(wversion[0]));
info.pszAppVersion = wversion;
// URL for sending reports over HTTP.
info.pszUrl = L"https://xyz.is/crashfix/index.php/crashReport/uploadExternal";
// Define delivery transport priorities.
info.uPriorities[CR_HTTP] = 1; // Use HTTP.
info.uPriorities[CR_SMTP] = CR_NEGATIVE_PRIORITY; // Not use SMTP.
info.uPriorities[CR_SMAPI] = CR_NEGATIVE_PRIORITY; // Not use Simple MAPI.
// Define flags.
info.dwFlags = 0;
info.dwFlags |= CR_INST_ALL_POSSIBLE_HANDLERS; // Install all available exception handlers.
info.dwFlags |= CR_INST_HTTP_BINARY_ENCODING; // Use binary encoding for HTTP uploads (recommended).
CrAutoInstallHelper cr_install_helper(&info);
#endif
InitModlist();
QApplication a(argc, argv);
Filesystem::Init();
QFontDatabase::addApplicationFont(":/fonts/Fontin-SmallCaps.ttf");
QCommandLineParser parser;
QCommandLineOption option_test("test"), option_data_dir("data-dir", "Where to save Acquisition data.", "data-dir");
parser.addOption(option_test);
parser.addOption(option_data_dir);
parser.process(a);
if (parser.isSet(option_test))
return test_main();
if (parser.isSet(option_data_dir))
Filesystem::SetUserDir(parser.value(option_data_dir).toStdString());
QsLogging::Logger& logger = QsLogging::Logger::instance();
logger.setLoggingLevel(QsLogging::InfoLevel);
const QString sLogPath(QDir(Filesystem::UserDir().c_str()).filePath("log.txt"));
QsLogging::DestinationPtr fileDestination(
QsLogging::DestinationFactory::MakeFileDestination(sLogPath, true, 10 * 1024 * 1024, 0) );
QsLogging::DestinationPtr debugDestination(
QsLogging::DestinationFactory::MakeDebugOutputDestination() );
logger.addDestination(debugDestination);
logger.addDestination(fileDestination);
QLOG_DEBUG() << "-------------------------------------------------------------------------------";
QLOG_DEBUG() << "Built with Qt" << QT_VERSION_STR << "running on" << qVersion();
LoginDialog login(std::make_unique<Application>());
login.show();
return a.exec();
}
int main() {
test_main();
}
int main( int argc, char* argv[] )
{
return test_main(argc, argv);
}
void main(void)
{
build_station();
printf ("%u", test_main());
}
/*******************************************************************************
*
* 函数名 : main
* 负责人 : 彭鹏
* 创建日期: 无
* 函数功能: 主函数
*
* 输入参数: argc - 参数个数
* argv - 命令行参数数组
*
* 输出参数: 无
*
* 返回值: 0 : 正常退出
* 其它: 异常退出
* 调用关系: 无
* 其 它: 由于内存没有文件大，所以文件中的内容是mem_buf内容的循环
*
******************************************************************************/
int main(int argc, char *argv[])
{
int rst = 0;
char *mem_buf = NULL;
int mem_size = 0;
int times = 0;
int file_size = 0;
int show_interval = 0;
char *file_name = NULL;
struct timeval last_time;
struct timeval now_time;
time_t seconds_use = 0;
if(6 != argc)
{
fprintf(stderr, "Usage:%s mem_size(kB) file_size(MB) times show_interval file_name\n", argv[0]);
return 0;
}
mem_size = atoi(argv[1]) * NAND_K; /* mem以kBytes 为单位 */
file_size = atoi(argv[2]);
times = atoi(argv[3]);
show_interval = atoi(argv[4]); /* 以秒为单位 */
file_name = argv[5];
/* 1 => 100M*/
if((mem_size <= 0) || (mem_size > 100 * NAND_M))
{
fprintf(stderr, "mem_size(%dkB) is unvalid.\n", mem_size);
return 0;
}
/* 1 => 10G */
if((file_size <= 0) || (file_size > 10 * NAND_K))
{
fprintf(stderr, "file_size(%dkB) is unvalid.\n", file_size);
return 0;
}
/* 1 => 2^30(1G) */
if((times <= 0) || (times > NAND_K * NAND_M))
{
fprintf(stderr, "times(%d) is unvalid.\n", times);
return 0;
}
/* 1 => 1天(24 * 60 * 60) */
if((show_interval <= 0) || (show_interval > (24*60*60)))
{
fprintf(stderr, "show_interval(%d) is unvalid.\n", show_interval);
return 0;
}
/* 比较时需要使用同样大小的内存 故这里测试内存是否够用 */
mem_buf = (char *)malloc(mem_size * 2);
if(NULL == mem_buf)
{
fprintf(stderr, "%d\n", mem_size);
perror("malloc");
return 0;
}
free(mem_buf);
mem_buf = NULL; /* 避免野指针 */
/* 构造随机值 */
mem_buf = (char *)malloc(mem_size);
if(NULL == mem_buf)
{
fprintf(stderr, "%d\n", mem_size);
perror("malloc");
return 0;
}
srand(time(NULL));
for(int i=0;i<mem_size;i++)
{
mem_buf[i] = (char)(rand() % 0xff);
}
/* TODO； 由于test_main会阻塞 故时间精度不准 */
gettimeofday(&last_time, 0);
for(int i = 0; i < times; i++)
{
rst = test_main(mem_buf, mem_size, file_name, file_size);
if(0 != rst)
{
return 0;
}
gettimeofday(&now_time, 0);
seconds_use = now_time.tv_sec - last_time.tv_sec;
if(seconds_use >= show_interval)
{
/* 打印时间戳和正确信息 */
time_t now;
struct tm *time_now;
time(&now);
time_now = localtime(&now);
fprintf(stderr, "PASS:%s", asctime(time_now)); /* asctime自带回车 */
gettimeofday(&last_time, 0);
}
}
printf("all test passed!\n");
free(mem_buf);
mem_buf = NULL; /* 避免野指针 */
return 0;
}
void init_video()
{
test_main(3, arg);
}
// execution monitor hook implementation
int operator()() { return test_main( m_argc, m_argv ); }
int
main ()
{
test_main ();
return 0;
}
int main(int argc, char **argv)
{
Platform::OS::BsdSockets::disableBrokenPipeSignals();
RCF::RcfInitDeinit init;
RCF::Timer testTimer;
RCF::initializeTransportFactories();
std::cout << "Commandline: ";
for (int i=0; i<argc; ++i)
{
std::cout << argv[i] << " ";
}
std::cout << std::endl;
bool shoudNotCatch = false;
{
util::CommandLineOption<std::string> clTestCase( "testcase", "", "Run a specific test case.");
util::CommandLineOption<bool> clListTests("list", false, "List all test cases.");
util::CommandLineOption<bool> clAssert( "assert", false, "Enable assert popups, and assert on test failures.");
util::CommandLineOption<int> clLogLevel( "loglevel", 1, "Set RCF log level.");
util::CommandLineOption<bool> clLogTime( "logtime", false, "Set RCF time stamp logging.");
util::CommandLineOption<bool> clLogTid( "logtid", false, "Set RCF thread id logging.");
util::CommandLineOption<std::string> clLogFormat("logformat", "", "Set RCF log format.");
util::CommandLineOption<bool> clNoCatch( "nocatch", false, "Don't catch exceptions at top level.");
util::CommandLineOption<unsigned int> clTimeLimit("timelimit", 5*60, "Set program time limit in seconds. 0 to disable.");
#if defined(_MSC_VER) && _MSC_VER >= 1310
util::CommandLineOption<bool> clMinidump("minidump", true, "Enable minidump creation.");
#endif
bool exitOnHelp = false;
util::CommandLine::getSingleton().parse(argc, argv, exitOnHelp);
// -testcase
std::string testCase = clTestCase.get();
if (!testCase.empty())
{
gTestEnv().setTestCaseToRun(testCase);
}
// -list
bool list = clListTests.get();
if (list)
{
gTestEnv().setEnumerationOnly();
}
// -assert
bool assertOnFail = clAssert.get();
gTestEnv().setAssertOnFail(assertOnFail);
#ifdef BOOST_WINDOWS
if (!assertOnFail)
{
// Try to prevent those pesky crash dialogs from popping up.
DWORD dwFlags = SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS;
DWORD dwOldFlags = SetErrorMode(dwFlags);
SetErrorMode(dwOldFlags | dwFlags);
#ifdef _MSC_VER
// Disable CRT asserts.
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_DEBUG);
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG);
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG);
#endif
}
#endif
// -loglevel
int logName = RCF::LogNameRcf;
int logLevel = clLogLevel.get();
bool includeTid = clLogTid.get();
bool includeTimestamp = clLogTime.get();
std::string logFormat = clLogFormat.get();
if (logFormat.empty())
{
if (!includeTid && !includeTimestamp)
{
logFormat = "%E(%F): %X";
}
if (includeTid && !includeTimestamp)
{
logFormat = "%E(%F): (Tid:%D): %X";
}
else if (!includeTid && includeTimestamp)
{
logFormat = "%E(%F): (Time:%H): %X";
}
else if (includeTid && includeTimestamp)
{
logFormat = "%E(%F): (Tid:%D)(Time::%H): %X";
}
}
#ifdef BOOST_WINDOWS
util::LoggerPtr loggerPtr(new util::Logger(logName, logLevel, util::LogToDebugWindow(), logFormat) );
loggerPtr->activate();
#else
util::LoggerPtr loggerPtr(new util::Logger(logName, logLevel, util::LogToStdout(), logFormat) );
loggerPtr->activate();
#endif
// -minidump
#if defined(_MSC_VER) && _MSC_VER >= 1310
bool enableMinidumps = clMinidump.get();
if (enableMinidumps)
{
setMiniDumpExceptionFilter();
}
#endif
// -timelimit
unsigned int timeLimitS = clTimeLimit.get();
gpProgramTimeLimit = new ProgramTimeLimit(timeLimitS);
shoudNotCatch = clNoCatch.get();
}
int ret = 0;
bool shouldCatch = !shoudNotCatch;
if (shouldCatch)
{
try
{
ret = test_main(argc, argv);
}
catch(const RCF::RemoteException & e)
{
std::cout << "Caught top-level exception (RCF::RemoteException): " << e.getErrorString() << std::endl;
RCF_CHECK(1==0);
}
catch(const RCF::Exception & e)
{
std::cout << "Caught top-level exception (RCF::Exception): " << e.getErrorString() << std::endl;
RCF_CHECK(1==0);
}
catch(const std::exception & e)
{
std::cout << "Caught top-level exception (std::exception): " << e.what() << std::endl;
RCF_CHECK(1==0);
}
catch (...)
{
std::cout << "Caught top-level exception (...)" << std::endl;
RCF_CHECK(1==0);
}
}
else
{
ret = test_main(argc, argv);
}
std::string exitMsg;
std::size_t failCount = gTestEnv().getFailCount();
if (failCount)
{
std::ostringstream os;
os << "*** Test Failures: " << failCount << " ***" << std::endl;
exitMsg = os.str();
}
else
{
exitMsg = "*** All Tests Passed ***\n";
}
gTestEnv().printTestMessage(exitMsg);
// Print out how long the test took.
boost::uint32_t durationMs = testTimer.getDurationMs();
std::cout << "Time elapsed: " << durationMs/1000 << " (s)" << std::endl;
return ret + static_cast<int>(failCount);
}
int main(void)
{
// configure WDT
WDTCTL = WDTPW | WDTHOLD; // stop watch dog timer
_25mhz();
#ifdef TEST
// when compiled in test mode, use different main
// disconnect radio when testing to avoid damage!
test_main();
#endif
// configure LED1 and turn it off, we'll use that for error and other stuff
P1DIR |= LED1;
LED1_OFF;
P4DIR |= LED2;
LED2_ON;
// setup uart
uart_init();
#ifdef DEBUG_MESSAGES
uart_send_string("Hola mundo!\r\n");
#endif
// setup packet handler
ph_setup();
// setup an configure radio
radio_setup();
radio_configure();
// self-calibrate image rejection
radio_calibrate_ir();
// verify that radio configuration was successful
radio_get_chip_status(0);
if (radio_buffer.chip_status.chip_status & RADIO_CMD_ERROR) { // check for command error
uart_send_string("Error inicializando radio!!!\r\n");
while (1) {
LED1_TOGGLE;
_delay_cycles(8000000); // blink LED if there was an error
}
}
// start packet receiving
ph_start();
#ifdef DEBUG_MESSAGES
uart_send_string("dAISy 0.2 started\r\n");
LED2_OFF;
#endif
while (1) {
LPM0; // deep sleep until something worthwhile happens
__no_operation();
ph_loop(); // packet handler house-keeping, e.g. channel hopping
#ifdef DEBUG_MESSAGES
uint8_t channel;
int16_t rssi;
// debug code to monitor signal strength (RSSI)
if (ph_get_state() == PH_STATE_PREFETCH) { // found preamble and start flag
// record current channel and signal strength
channel = ph_get_radio_channel(); // read current channel
rssi = ph_get_radio_rssi(); // read current RSSI
}
#endif
// retrieve last packet handler error
uint8_t error = ph_get_last_error();
#ifdef DEBUG_MESSAGES
// report error if packet handler failed
if (error != PH_ERROR_NONE) {
dec_to_str(str_output_buffer, 3, rssi); // convert to decimal string (reuse radio buffer)
str_output_buffer[4] = 0; // terminate string
uart_send_string("sync "); // send debug message to UART
uart_send_byte(channel + 'A');
uart_send_string(" RSSI=");
uart_send_string(str_output_buffer);
uart_send_string("dBm\r\n");
uart_send_string("error: ");
switch (error) {
case PH_ERROR_NOEND:
uart_send_string("no end flag");
break;
case PH_ERROR_STUFFBIT:
uart_send_string("invalid stuff bit");
break;
case PH_ERROR_CRC:
uart_send_string("CRC error");
break;
case PH_ERROR_RSSI_DROP:
uart_send_string("RSSI drop");
break;
}
uart_send_string("\r\n");
ph_loop(); // house keeping, sending over UART takes time
}
#else
// toggle LED if packet handler failed after finding preamble and start flag
if (error == PH_ERROR_NOEND || error == PH_ERROR_STUFFBIT || error == PH_ERROR_CRC)
LED1_TOGGLE;
#endif
// check if a new valid packet arrived
uint16_t size = fifo_get_packet();
if (size > 0) { // if so, process packet
#ifdef DEBUG_MESSAGES
dec_to_str(str_output_buffer, 3, rssi); // convert to decimal string (reuse radio buffer)
str_output_buffer[4] = 0; // terminate string
uart_send_string("sync "); // send debug message to UART
uart_send_byte(channel + 'A');
uart_send_string(" RSSI=");
uart_send_string(str_output_buffer);
uart_send_string("dBm\r\n");
#endif
LED2_ON;
nmea_process_packet(); // process packet (NMEA message will be sent over UART)
fifo_remove_packet(); // remove processed packet from FIFO
LED2_OFF;
}
// enter low power mode LPM0 (everything off)
// TODO: wait for UART to complete transmission
// TODO: suspend UART
}
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
Sleep(test_main());
/*
Sleep(test_main()/1000);
.text:0040102A mov ecx, eax
.text:0040102C mov eax, 10624DD3h
.text:00401031 imul ecx
.text:00401033 sar edx, 6
.text:00401036 mov eax, edx
.text:00401038 shr eax, 1Fh
.text:0040103B add edx, eax
.text:0040103D push edx ; dwMilliseconds
.text:0040103E call ds:Sleep
Sleep(test_main()/10000);
.text:0040102A 024 mov ecx, eax
.text:0040102C 024 mov eax, 68DB8BADh
.text:00401031 024 imul ecx
.text:00401033 024 sar edx, 0Ch
.text:00401036 024 mov eax, edx
.text:00401038 024 shr eax, 1Fh
.text:0040103B 024 add edx, eax
.text:0040103D 024 push edx ; dwMilliseconds
.text:0040103E 028 call ds:Sleep
*/
// TODO: Place code here.
MSG msg;
HACCEL hAccelTable;
// Initialize global strings
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(hInstance, IDC_PETEST, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance);
// Perform application initialization:
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_PETEST);
// Main message loop:
while (GetMessage(&msg, NULL, 0, 0))
{
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return msg.wParam;
}
