static void init_application ()
{
GtkBuilder *builder = NULL;
GtkWidget *window;
GtkWidget *btn_capture;
GtkWidget *infobar_close, *infobar_reconnect;
GtkWidget *infobar_box;
GtkWidget *vcheck_dont_show;
GtkAboutDialog *about = NULL;
unsigned int major, minor;
char patch[9];
const gchar *tmp;
gchar tmp2[1024];
builder = gtk_builder_new();
if (!gtk_builder_add_from_file(builder, "./osc.glade", NULL)) {
gtk_builder_add_from_file(builder, OSC_GLADE_FILE_PATH "osc.glade", NULL);
} else {
GtkImage *logo;
GdkPixbuf *pixbuf;
GError *err = NULL;
/* We are running locally, so load the local files */
logo = GTK_IMAGE(gtk_builder_get_object(builder, "about_ADI_logo"));
g_object_set(logo, "file","./icons/ADIlogo.png", NULL);
logo = GTK_IMAGE(gtk_builder_get_object(builder, "about_IIO_logo"));
g_object_set(logo, "file","./icons/IIOlogo.png", NULL);
about = GTK_ABOUT_DIALOG(gtk_builder_get_object(builder, "About_dialog"));
pixbuf = gdk_pixbuf_new_from_file("./icons/osc128.png", &err);
if (pixbuf) {
g_object_set(about, "logo", pixbuf, NULL);
g_object_unref(pixbuf);
}
}
/* Override version in About menu with git branch and commit hash. */
if (!about)
about = GTK_ABOUT_DIALOG(gtk_builder_get_object(builder, "About_dialog"));
gtk_about_dialog_set_version(about, OSC_VERSION);
iio_library_get_version(&major, &minor, patch);
tmp = gtk_label_get_label(GTK_LABEL(gtk_builder_get_object(builder, "libiio_title")));
sprintf(tmp2, "%s\nlibiio version : %i.%i-%s\n", tmp, major, minor, patch);
gtk_label_set_label(GTK_LABEL(gtk_builder_get_object(builder, "libiio_title")),
tmp2);
window = GTK_WIDGET(gtk_builder_get_object(builder, "main_menu"));
notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook"));
btn_capture = GTK_WIDGET(gtk_builder_get_object(builder, "new_capture_plot"));
tooltips_en = GTK_WIDGET(gtk_builder_get_object(builder, "menuitem_tooltips_en"));
versioncheck_en = GTK_WIDGET(gtk_builder_get_object(builder, "menuitem_vcheck_startup"));
vcheck_dont_show = GTK_WIDGET(gtk_builder_get_object(builder, "version_check_dont_show_again"));
infobar_box = GTK_WIDGET(gtk_builder_get_object(builder, "connect_infobar_container"));
infobar = gui_connection_infobar_new(&infobar_close, &infobar_reconnect);
gtk_box_pack_start(GTK_BOX(infobar_box), infobar, FALSE, TRUE, 0);
main_window = window;
/* Connect signals. */
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(application_quit), NULL);
g_signal_connect(G_OBJECT(btn_capture), "activate", G_CALLBACK(new_plot_cb), NULL);
g_signal_connect(G_OBJECT(tooltips_en), "toggled", G_CALLBACK(tooltips_enable_cb), NULL);
g_signal_connect(G_OBJECT(versioncheck_en), "toggled", G_CALLBACK(versioncheck_en_cb), vcheck_dont_show);
g_signal_connect(G_OBJECT(vcheck_dont_show), "toggled", G_CALLBACK(vcheck_dont_show_cb), versioncheck_en);
g_signal_connect(G_OBJECT(infobar_close), "clicked", G_CALLBACK(infobar_hide_cb), NULL);
g_signal_connect(G_OBJECT(infobar_reconnect), "clicked", G_CALLBACK(infobar_reconnect_cb), NULL);
dialogs_init(builder);
ctx = osc_create_context();
if (ctx)
do_init(ctx);
gtk_widget_show(window);
}
/*======================================
* CORE : MAINROUTINE
*--------------------------------------*/
int main (int argc, char **argv)
{
{// initialize program arguments
char *p1;
if((p1 = strrchr(argv[0], '/')) != NULL || (p1 = strrchr(argv[0], '\\')) != NULL ){
char *pwd = NULL; //path working directory
int n=0;
SERVER_NAME = ++p1;
n = p1-argv[0]; //calc dir name len
pwd = safestrncpy(malloc(n + 1), argv[0], n);
if(chdir(pwd) != 0)
ShowError("Couldn't change working directory to %s for %s, runtime will probably fail",pwd,SERVER_NAME);
free(pwd);
}
}
malloc_init();// needed for Show* in display_title() [FlavioJS]
#ifdef MINICORE // minimalist Core
display_title();
usercheck();
do_init(argc,argv);
do_final();
#else// not MINICORE
set_server_type();
display_title();
usercheck();
Sql_Init();
rathread_init();
mempool_init();
db_init();
signals_init();
#ifdef _WIN32
cevents_init();
#endif
timer_init();
socket_init();
do_init(argc,argv);
// Main runtime cycle
while (runflag != CORE_ST_STOP) {
int next = do_timer(gettick_nocache());
do_sockets(next);
}
do_final();
timer_final();
socket_final();
db_final();
mempool_final();
rathread_final();
ers_final();
#endif
malloc_final();
return 0;
}
void init_clcs_conditions(){do_init(VV);}
/*打印辅存*/
void do_print_vir()
{
int i;
char temp_byte;
FILE* p = fopen("vmm_auxMem","r");
printf("print virtual memory\n");
for(i = 0;i < VIRTUAL_MEMORY_SIZE;i++){
printf("%c",fgetc(p));
}
/*while((temp_byte = fgetc(p)) != EOF){
printf("%c",temp_byte);
}*/
/* 获取页面保护类型字符串 */
char *get_proType_str(char *str, BYTE type)
{
if (type & READABLE)
str[0] = 'r';
else
str[0] = '-';
if (type & WRITABLE)
str[1] = 'w';
else
str[1] = '-';
if (type & EXECUTABLE)
str[2] = 'x';
else
str[2] = '-';
str[3] = '\0';
return str;
}
int main(int argc, char* argv[])
{
char c;
int i;
int fifo2;
int count;
cmd req;
struct stat statbuf;
req.RT=NOR;
if(stat("/tmp/doreq",&statbuf)==0){
/* 如果FIFO文件存在,删掉 */
if(remove("/tmp/doreq")<0)
printf("remove failed\n");
}
if(mkfifo("/tmp/doreq",0666)<0)
printf("mkfifo failed\n");
/* 在非阻塞模式下打开FIFO */
if((fifo2=open("/tmp/doreq",O_RDONLY|O_NONBLOCK))<0)
printf("open fifo failed\n");
if (!(ptr_auxMem = fopen(AUXILIARY_MEMORY, "r+")))
{
do_error(ERROR_FILE_OPEN_FAILED);
exit(1);
}
do_init();
do_print_info();
ptr_memAccReq = (Ptr_MemoryAccessRequest) malloc(sizeof(MemoryAccessRequest));
/* 在循环中模拟访存请求与处理过程 */
while (TRUE)
{
if((count=read(fifo2,&req,CMDLEN))<0)
printf("read fifo failed\n");
switch(req.RT){
case REQUEST: printf("addr=%ld\n",req.virAddr);
do_request(req);req.RT=NOR;
break;
//case RESPONSE:printf("aaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n");
//do_response();req.RT=NOR;
//break;
default:
break;
}
do_response();
printf("按Y打印页表，按其他键不打印...\n");
if ((c = getchar()) == 'y' || c == 'Y')
do_print_info();
while (c != '\n')
c = getchar();
printf("按A打印实存，按其他键不打印...\n");
if ((c = getchar()) == 'a' || c == 'A')
do_print_act();
while (c != '\n')
c = getchar();
printf("按V打印辅存，按其他键不打印...\n");
if ((c = getchar()) == 'v' || c == 'V')
do_print_vir();
while (c != '\n')
c = getchar();
printf("按X退出程序，按其他键继续...\n");
if ((c = getchar()) == 'x' || c == 'X')
break;
while (c != '\n')
c = getchar();
//sleep(5000);
}
if (fclose(ptr_auxMem) == EOF)
{
do_error(ERROR_FILE_CLOSE_FAILED);
exit(1);
}
close(fifo2);
return (0);
}
int
main(int argc, char **argv)
{
int argerr = 0;
int flag;
const char *source = NULL;
const char *admin_input_xml = NULL;
const char *admin_input_file = NULL;
gboolean dangerous_cmd = FALSE;
gboolean admin_input_stdin = FALSE;
xmlNode *output = NULL;
xmlNode *input = NULL;
int option_index = 0;
crm_xml_init(); /* Sets buffer allocation strategy */
crm_system_name = strdup("cibadmin");
crm_set_options(NULL, "command [options] [data]", long_options,
"Provides direct access to the cluster configuration."
"\n\nAllows the configuration, or sections of it, to be queried, modified, replaced and deleted."
"\n\nWhere necessary, XML data will be obtained using the -X, -x, or -p options\n");
if (argc < 2) {
crm_help('?', EX_USAGE);
}
while (1) {
flag = crm_get_option(argc, argv, &option_index);
if (flag == -1)
break;
switch (flag) {
case 't':
message_timeout_ms = atoi(optarg);
if (message_timeout_ms < 1) {
message_timeout_ms = 30;
}
break;
case 'A':
obj_type = optarg;
command_options |= cib_xpath;
break;
case 'e':
command_options |= cib_xpath_address;
break;
case 'u':
cib_action = CIB_OP_UPGRADE;
dangerous_cmd = TRUE;
break;
case 'E':
cib_action = CIB_OP_ERASE;
dangerous_cmd = TRUE;
break;
case 'Q':
cib_action = CIB_OP_QUERY;
quiet = TRUE;
break;
case 'P':
cib_action = CIB_OP_APPLY_DIFF;
break;
case 'U':
cib_user = optarg;
break;
case 'M':
cib_action = CIB_OP_MODIFY;
break;
case 'R':
cib_action = CIB_OP_REPLACE;
break;
case 'C':
cib_action = CIB_OP_CREATE;
break;
case 'D':
cib_action = CIB_OP_DELETE;
break;
case '5':
cib_action = "md5-sum";
break;
case '6':
cib_action = "md5-sum-versioned";
break;
case 'c':
command_options |= cib_can_create;
break;
case 'n':
command_options |= cib_no_children;
break;
case 'B':
cib_action = CIB_OP_BUMP;
break;
case 'V':
command_options = command_options | cib_verbose;
bump_log_num++;
break;
case '?':
case '$':
case '!':
crm_help(flag, EX_OK);
break;
case 'o':
crm_trace("Option %c => %s", flag, optarg);
obj_type = optarg;
break;
case 'X':
crm_trace("Option %c => %s", flag, optarg);
admin_input_xml = optarg;
break;
case 'x':
crm_trace("Option %c => %s", flag, optarg);
admin_input_file = optarg;
break;
case 'p':
admin_input_stdin = TRUE;
break;
case 'N':
case 'h':
host = strdup(optarg);
break;
case 'l':
command_options |= cib_scope_local;
break;
case 'd':
cib_action = CIB_OP_DELETE;
command_options |= cib_multiple;
dangerous_cmd = TRUE;
break;
case 'b':
dangerous_cmd = TRUE;
command_options |= cib_inhibit_bcast;
command_options |= cib_scope_local;
break;
case 's':
command_options |= cib_sync_call;
break;
case 'f':
force_flag = TRUE;
command_options |= cib_quorum_override;
break;
case 'a':
output = createEmptyCib(1);
if (optind < argc) {
crm_xml_add(output, XML_ATTR_VALIDATION, argv[optind]);
}
admin_input_xml = dump_xml_formatted(output);
fprintf(stdout, "%s\n", crm_str(admin_input_xml));
goto bail;
break;
default:
printf("Argument code 0%o (%c)" " is not (?yet?) supported\n", flag, flag);
++argerr;
break;
}
}
if (bump_log_num > 0) {
quiet = FALSE;
}
crm_log_init(NULL, LOG_CRIT, FALSE, FALSE, argc, argv, quiet);
while (bump_log_num > 0) {
crm_bump_log_level(argc, argv);
bump_log_num--;
}
if (optind < argc) {
printf("non-option ARGV-elements: ");
while (optind < argc)
printf("%s ", argv[optind++]);
printf("\n");
crm_help('?', EX_USAGE);
}
if (optind > argc || cib_action == NULL) {
++argerr;
}
if (argerr) {
crm_help('?', EX_USAGE);
}
if (dangerous_cmd && force_flag == FALSE) {
fprintf(stderr, "The supplied command is considered dangerous."
" To prevent accidental destruction of the cluster,"
" the --force flag is required in order to proceed.\n");
fflush(stderr);
exit_code = -EINVAL;
goto bail;
}
if (admin_input_file != NULL) {
input = filename2xml(admin_input_file);
source = admin_input_file;
} else if (admin_input_xml != NULL) {
source = "input string";
input = string2xml(admin_input_xml);
} else if (admin_input_stdin) {
source = "STDIN";
input = stdin2xml();
}
if (input != NULL) {
crm_log_xml_debug(input, "[admin input]");
} else if (source) {
fprintf(stderr, "Couldn't parse input from %s.\n", source);
exit_code = -EINVAL;
goto bail;
}
if (safe_str_eq(cib_action, "md5-sum")) {
char *digest = NULL;
if (input == NULL) {
fprintf(stderr, "Please supply XML to process with -X, -x or -p\n");
exit_code = -EINVAL;
goto bail;
}
digest = calculate_on_disk_digest(input);
fprintf(stderr, "Digest: ");
fprintf(stdout, "%s\n", crm_str(digest));
free(digest);
goto bail;
} else if (safe_str_eq(cib_action, "md5-sum-versioned")) {
char *digest = NULL;
const char *version = NULL;
if (input == NULL) {
fprintf(stderr, "Please supply XML to process with -X, -x or -p\n");
exit_code = -EINVAL;
goto bail;
}
version = crm_element_value(input, XML_ATTR_CRM_VERSION);
digest = calculate_xml_versioned_digest(input, FALSE, TRUE, version);
fprintf(stderr, "Versioned (%s) digest: ", version);
fprintf(stdout, "%s\n", crm_str(digest));
free(digest);
goto bail;
}
exit_code = do_init();
if (exit_code != pcmk_ok) {
crm_err("Init failed, could not perform requested operations");
fprintf(stderr, "Init failed, could not perform requested operations\n");
return crm_exit(-exit_code);
}
exit_code = do_work(input, command_options, &output);
if (exit_code > 0) {
/* wait for the reply by creating a mainloop and running it until
* the callbacks are invoked...
*/
request_id = exit_code;
the_cib->cmds->register_callback(the_cib, request_id, message_timeout_ms, FALSE, NULL,
"cibadmin_op_callback", cibadmin_op_callback);
mainloop = g_main_new(FALSE);
crm_trace("%s waiting for reply from the local CIB", crm_system_name);
crm_info("Starting mainloop");
g_main_run(mainloop);
} else if (exit_code < 0) {
crm_err("Call failed: %s", pcmk_strerror(exit_code));
fprintf(stderr, "Call failed: %s\n", pcmk_strerror(exit_code));
operation_status = exit_code;
if (exit_code == -pcmk_err_schema_validation) {
if (crm_str_eq(cib_action, CIB_OP_UPGRADE, TRUE)) {
xmlNode *obj = NULL;
int version = 0, rc = 0;
rc = the_cib->cmds->query(the_cib, NULL, &obj, command_options);
if (rc == pcmk_ok) {
update_validation(&obj, &version, 0, TRUE, FALSE);
}
} else if (output) {
validate_xml_verbose(output);
}
}
}
if (output != NULL) {
print_xml_output(output);
free_xml(output);
}
crm_trace("%s exiting normally", crm_system_name);
free_xml(input);
flag = the_cib->cmds->signoff(the_cib);
cib_delete(the_cib);
if(exit_code == pcmk_ok) {
exit_code = flag;
}
bail:
return crm_exit(exit_code);
}
/*======================================
* CORE : MAINROUTINE
*--------------------------------------*/
int main (int argc, char **argv)
{
{// Inicializa os argumentos do programa
char *p1 = SERVER_NAME = argv[0];
char *p2 = p1;
while ((p1 = strchr(p2, '/')) != NULL || (p1 = strchr(p2, '\\')) != NULL)
{
SERVER_NAME = ++p1;
p2 = p1;
}
arg_c = argc;
arg_v = argv;
}
// Não precisamos chamar o malloc_init se o Memory Manager não está ativo [Keoy]
#ifdef USE_MEMMGR
malloc_init(); // needed for Show* in display_title() [FlavioJS]
#endif
#ifdef MINICORE // minimalist Core
display_title();
#ifndef _WIN32
usercheck();
#endif
do_init(argc,argv);
do_final();
#else// not MINICORE
set_server_type(); // Define o tipo de servidor (função exclusiva de cada servidor)
display_title(); // Mostra o título
// Não precisamos verificar se estamos em root se não estamos em um sistema WIN32 [Keoy]
#ifndef _WIN32
usercheck();
#endif
db_init();
signals_init();
timer_init();
socket_init();
plugins_init();
do_init(argc,argv); // Inicializa as funções do servidor
plugin_event_trigger(EVENT_ATHENA_INIT); // Evento inicial dos plugins
{// Ciclo principal do servidor
int next;
// Enquanto a runflag for verdadeira (1) o servidor rodará, do contrário entrará em processo de finalização
while (runflag) {
next = do_timer(gettick_nocache());
do_sockets(next);
}
}
plugin_event_trigger(EVENT_ATHENA_FINAL); // Evento final dos plugins
do_final();
timer_final();
plugins_final();
socket_final();
db_final();
#endif
// Não precisamos chamar o malloc_init se o Memory Manager não está ativo [Keoy]
#ifdef USE_MEMMGR
malloc_final();
#endif
return 0;
}
/*
* Opes connection to an LDAP server
* uri must be one URI
*/
static int do_open (LDAP **ld, const char* uri, int defport, ldap_ssl_options_t ssl_on_local)
{
#if defined(LDAP_OPT_NETWORK_TIMEOUT) || defined(HAVE_LDAP_START_TLS)
struct timeval tv;
#endif
#ifdef HAVE_LDAP_START_TLS
struct timeval *tvp;
LDAPMessage *res = NULL;
int msgid;
#endif
int rc;
rc = do_init (ld, uri, defport);
if (rc != LDAP_SUCCESS)
{
DBG("do_open(): do_init failed");
return rc;
}
if( ! *ld)
{
DBG("do_open(): internal error - assert (*ld != NULL)");
return(-2);
}
#if defined(HAVE_LDAP_SET_OPTION) && defined(LDAP_OPT_PROTOCOL_VERSION)
ldap_set_option (*ld, LDAP_OPT_PROTOCOL_VERSION, &ldapVersion);
#endif /* LDAP_OPT_PROTOCOL_VERSION */
#if defined(HAVE_LDAP_SET_OPTION) && defined(LDAP_OPT_NETWORK_TIMEOUT)
/* ldap_set_option (*ld, LDAP_OPT_NETWORK_TIMEOUT, &timeout); */
rc = ldap_set_option(*ld, LDAP_OPT_NETWORK_TIMEOUT, &timeout);
if ( rc != LDAP_SUCCESS ) {
DBG2("Warning: failed to set connection timeout to %d: %s", timeout, ldap_err2string(rc));
} else
DBG1("Set connection timeout to %d", timeout);
#endif /* LDAP_OPT_NETWORK_TIMEOUT */
#if defined(HAVE_LDAP_SET_OPTION) && defined(LDAP_OPT_NETWORK_TIMEOUT)
tv.tv_sec = bind_timelimit;
tv.tv_usec = 0;
ldap_set_option (*ld, LDAP_OPT_NETWORK_TIMEOUT, &tv);
#endif /* LDAP_OPT_NETWORK_TIMEOUT */
#if defined(HAVE_LDAP_START_TLS_S) || defined(HAVE_LDAP_START_TLS)
if (ssl_on_local == SSL_START_TLS)
{
int version;
/* we need V3 at least */
if (ldap_get_option(*ld, LDAP_OPT_PROTOCOL_VERSION,
&version) == LDAP_OPT_SUCCESS)
{
if (ldapVersion < LDAP_VERSION3)
{
ldapVersion = LDAP_VERSION3;
ldap_set_option (*ld, LDAP_OPT_PROTOCOL_VERSION,
&ldapVersion);
}
}
/* set up SSL context */
if (do_ssl_options (*ld) != LDAP_SUCCESS)
{
ldap_unbind (*ld);
DBG("do_open(): SSL setup failed");
return LDAP_UNAVAILABLE;
}
#ifdef HAVE_LDAP_START_TLS
DBG("do_open(): do_start_tls");
rc = ldap_start_tls (*ld, NULL, NULL, &msgid);
if (rc != LDAP_SUCCESS)
{
DBG1("do_open(): ldap_start_tls failed: %s", ldap_err2string (rc));
return rc;
}
if (bind_timelimit == LDAP_NO_LIMIT)
{
tvp = NULL;
}
else
{
tv.tv_sec = bind_timelimit;
tv.tv_usec = 0;
tvp = &tv;
}
rc = ldap_result (*ld, msgid, 1, tvp, &res);
if (rc == -1)
{
#if defined(HAVE_LDAP_GET_OPTION) && defined(LDAP_OPT_ERROR_NUMBER)
if (ldap_get_option (*ld, LDAP_OPT_ERROR_NUMBER, &rc) != LDAP_SUCCESS)
{
rc = LDAP_UNAVAILABLE;
}
#else
rc = ld->ld_errno;
#endif /* LDAP_OPT_ERROR_NUMBER */
DBG1("do_open(): ldap_start_tls failed: %s", ldap_err2string (rc));
return rc;
}
rc = ldap_result2error (*ld, res, 1);
if (rc != LDAP_SUCCESS)
{
DBG1("do_open(): ldap_result2error failed: %s)", ldap_err2string (rc));
return rc;
}
rc = ldap_install_tls (*ld);
#else
rc = ldap_start_tls_s (*ld, NULL, NULL);
#endif /* HAVE_LDAP_START_TLS */
if (rc == LDAP_SUCCESS)
{
DBG("do_open(): TLS startup succeeded");
}
else
{
ldap_unbind (*ld);
DBG2("do_open(): TLS startup failed for LDAP server %s: %s",
uri, ldap_err2string (rc));
return rc;
}
}
else
#endif /* HAVE_LDAP_START_TLS_S || HAVE_LDAP_START_TLS */
/*
* If SSL is desired, then enable it.
*/
if (ssl_on_local == SSL_LDAPS)
{
#if defined(HAVE_LDAP_SET_OPTION) && defined(LDAP_OPT_X_TLS)
int tls = LDAP_OPT_X_TLS_HARD;
if (ldap_set_option (*ld, LDAP_OPT_X_TLS, &tls) !=
LDAP_SUCCESS)
{
ldap_unbind (*ld);
DBG("do_open(): TLS setup failed");
return LDAP_UNAVAILABLE;
}
/* set up SSL context */
if (do_ssl_options (*ld) != LDAP_SUCCESS)
{
ldap_unbind (*ld);
DBG("do_open(): SSL setup failed");
return LDAP_UNAVAILABLE;
}
#endif
}
rc = do_bind (*ld, bind_timelimit);
if (rc != LDAP_SUCCESS)
{
DBG2("do_open(): failed to bind to LDAP server %s: %s",
uri, ldap_err2string (rc));
ldap_unbind (*ld);
}
return rc;
}
void cmd_version(UBool noLoad)
{
UVersionInfo icu;
char str[200];
printf("<ICUINFO>\n");
printf("International Components for Unicode for C/C++\n");
printf("%s\n", U_COPYRIGHT_STRING);
printf("Compiled-Version: %s\n", U_ICU_VERSION);
u_getVersion(icu);
u_versionToString(icu, str);
printf("Runtime-Version: %s\n", str);
printf("Compiled-Unicode-Version: %s\n", U_UNICODE_VERSION);
u_getUnicodeVersion(icu);
u_versionToString(icu, str);
printf("Runtime-Unicode-Version: %s\n", U_UNICODE_VERSION);
printf("Platform: %s\n", getPlatform());
#if defined(U_BUILD)
printf("Build: %s\n", U_BUILD);
#if defined(U_HOST)
if(strcmp(U_BUILD,U_HOST)) {
printf("Host: %s\n", U_HOST);
}
#endif
#endif
#if defined(U_CC)
printf("C compiler: %s\n", U_CC);
#endif
#if defined(U_CXX)
printf("C++ compiler: %s\n", U_CXX);
#endif
#if defined(CYGWINMSVC)
printf("Cygwin: CYGWINMSVC\n");
#endif
printf("ICUDATA: %s\n", U_ICUDATA_NAME);
do_init();
printf("Data Directory: %s\n", u_getDataDirectory());
printf("ICU Initialization returned: %s\n", u_errorName(initStatus));
printf( "Default locale: %s\n", uloc_getDefault());
{
UErrorCode subStatus = U_ZERO_ERROR;
ulocdata_getCLDRVersion(icu, &subStatus);
if(U_SUCCESS(subStatus)) {
u_versionToString(icu, str);
printf("CLDR-Version: %s\n", str);
} else {
printf("CLDR-Version: %s\n", u_errorName(subStatus));
}
}
#if !UCONFIG_NO_CONVERSION
if(noLoad == FALSE)
{
printf("Default converter: %s\n", ucnv_getDefaultName());
}
#endif
#if !UCONFIG_NO_FORMATTING
{
UChar buf[100];
char buf2[100];
UErrorCode subsubStatus= U_ZERO_ERROR;
int32_t len;
len = ucal_getDefaultTimeZone(buf, 100, &subsubStatus);
if(U_SUCCESS(subsubStatus)&&len>0) {
u_UCharsToChars(buf, buf2, len+1);
printf("Default TZ: %s\n", buf2);
} else {
printf("Default TZ: %s\n", u_errorName(subsubStatus));
}
}
{
UErrorCode subStatus = U_ZERO_ERROR;
const char *tzVer = ucal_getTZDataVersion(&subStatus);
if(U_FAILURE(subStatus)) {
tzVer = u_errorName(subStatus);
}
printf("TZ data version: %s\n", tzVer);
}
#endif
#if U_ENABLE_DYLOAD
const char *pluginFile = uplug_getPluginFile();
printf("Plugin file is: %s\n", (pluginFile&&*pluginFile)?pluginFile:"(not set. try setting ICU_PLUGINS to a directory.)");
#else
fprintf(stderr, "Dynamic Loading: is disabled. No plugins will be loaded at start-up.\n");
#endif
printf("</ICUINFO>\n\n");
}
void init_pcl_fngen(){do_init(VV);}
void init_pcl_gazonk6(){do_init(VV);}
void cmd_listplugins() {
int32_t i;
UPlugData *plug;
do_init();
printf("ICU Initialized: u_init() returned %s\n", u_errorName(initStatus));
printf("Plugins: \n");
printf( "# %6s %s \n",
"Level",
"Name" );
printf( " %10s:%-10s\n",
"Library",
"Symbol"
);
printf( " config| (configuration string)\n");
printf( " >>> Error | Explanation \n");
printf( "-----------------------------------\n");
for(i=0;(plug=uplug_getPlugInternal(i))!=NULL;i++) {
UErrorCode libStatus = U_ZERO_ERROR;
const char *name = uplug_getPlugName(plug);
const char *sym = uplug_getSymbolName(plug);
const char *lib = uplug_getLibraryName(plug, &libStatus);
const char *config = uplug_getConfiguration(plug);
UErrorCode loadStatus = uplug_getPlugLoadStatus(plug);
const char *message = NULL;
printf("\n#%d %-6s %s \n",
i+1,
udbg_enumName(UDBG_UPlugLevel,(int32_t)uplug_getPlugLevel(plug)),
name!=NULL?(*name?name:"this plugin did not call uplug_setPlugName()"):"(null)"
);
printf(" plugin| %10s:%-10s\n",
(U_SUCCESS(libStatus)?(lib!=NULL?lib:"(null)"):u_errorName(libStatus)),
sym!=NULL?sym:"(null)"
);
if(config!=NULL&&*config) {
printf(" config| %s\n", config);
}
switch(loadStatus) {
case U_PLUGIN_CHANGED_LEVEL_WARNING:
message = "Note: This plugin changed the system level (by allocating memory or calling something which does). Later plugins may not load.";
break;
case U_PLUGIN_DIDNT_SET_LEVEL:
message = "Error: This plugin did not call uplug_setPlugLevel during QUERY.";
break;
case U_PLUGIN_TOO_HIGH:
message = "Error: This plugin couldn't load because the system level was too high. Try loading this plugin earlier.";
break;
case U_ZERO_ERROR:
message = NULL; /* no message */
break;
default:
if(U_FAILURE(loadStatus)) {
message = "error loading:";
} else {
message = "warning during load:";
}
}
if(message!=NULL) {
printf("\\\\\\ status| %s\n"
"/// %s\n", u_errorName(loadStatus), message);
}
}
if(i==0) {
printf("No plugins loaded.\n");
}
}
init()
{
do_init();
}
int main() {
XStatus Status;
u32 btnsw = 0x00000000, old_btnsw = 0x000000FF, diff_btnsw;
u32 leds;
int rotcnt, old_rotcnt;
Test_t test;
ParamSel_t param_select;
bool wrlcd_dynamic;
bool wrlcd_static;
// initialize devices and set up interrupts, etc.
Status = do_init();
if (Status != XST_SUCCESS) {
LCD_setcursor(1, 0);
LCD_wrstring("****** ERROR *******");
LCD_setcursor(2, 0);
LCD_wrstring("INIT FAILED- EXITING");
exit(XST_FAILURE);
}
// initialize the global variables
timestamp = 0;
pwm_freq = PWM_FREQUENCY_HZ;
pwm_duty = PWM_STEPDC_MIN;
// initialize the local variables
btnsw = 0x00;
old_btnsw = 0x00;
rotcnt = 0;
old_rotcnt = 0;
param_select = SLCT_GP;
wrlcd_dynamic = true;
wrlcd_static = true;
leds = LEDS_ALLOFF;
_prev_button_down_count = 0;
// Enable the Microblaze caches and
// kick off the processing by enabling the Microblaze interrupt
// this starts the FIT timer which updates the timestamp.
if (USE_ICACHE == 1) {
microblaze_invalidate_icache();
microblaze_enable_icache();
}
if (USE_DCACHE == 1) {
microblaze_invalidate_dcache();
microblaze_enable_dcache();
}
microblaze_enable_interrupts();
// display the greeting
LCD_setcursor(1, 0);
LCD_wrstring("ECE544 Project 2");
LCD_setcursor(2, 0);
LCD_wrstring("Starter App-R5.0");
NX3_writeleds(LEDS_ALLON);
delay_msecs(2000);
NX3_writeleds(LEDS_ALLOFF);
// Set the PWM and ADC min and max counts by forcing a characterization
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring("Characterizing..");
DoTest_Characterize();
LCD_setcursor(2, 0);
LCD_wrstring("...Done ");
//*****GAIN AND OFFSET ARE HARDWIRED IN THE STARTER APP *****
// initialize the control parameters
// start the set point in the middle of the range
setpoint = (ADC_max_cnt - ADC_min_cnt) / 2;
offset = 100;
GP = 10;
GD = 5;
GI = 5;
init_high = false;
//*****GAIN AND OFFSET ARE HARDWIRED IN THE STARTER APP *****
// main loop - there is no exit except by hardware reset
while (1) {
// write static portion of output to display
if (wrlcd_static) {
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring("G|Pxxx Ixxx Dxxx");
LCD_setcursor(2, 0);
LCD_wrstring("SP:+x.xx OFF:xxx");
wrlcd_static = false;
}
// write the dynamic portion of output to display
if (wrlcd_dynamic) {
Xfloat32 v;
u16 count;
char s[20];
u32 row, col;
// display GP, GI, and GD
LCD_setcursor(1, 3);
LCD_wrstring(" ");
LCD_setcursor(1, 3);
LCD_putnum(GP, 10);
LCD_setcursor(1, 8);
LCD_wrstring(" ");
LCD_setcursor(1, 8);
LCD_putnum(GI, 10);
LCD_setcursor(1, 13);
LCD_wrstring(" ");
LCD_setcursor(1, 13);
LCD_putnum(GD, 10);
LCD_setcursor(2, 13);
LCD_wrstring(" ");
LCD_setcursor(2, 13);
LCD_putnum(offset, 10);
// display the setpoint in volts
count = setpoint;
v = PmodCtlSys_ADCVolts(count);
voltstostrng(v, s);
LCD_setcursor(2, 3);
LCD_wrstring(" ");
LCD_setcursor(2, 3);
LCD_wrstring(s);
// place the cursor under the currently selected parameter
LCD_docmd(LCD_DISPLAYONOFF, LCD_CURSOR_OFF);
switch (param_select) {
case SLCT_OFFSET:
row = 2;
col = 13;
break;
case SLCT_GP:
row = 1;
col = 3;
break;
case SLCT_GD:
row = 1;
col = 13;
break;
case SLCT_GI:
row = 1;
col = 8;
break;
case SLCT_INVALID:
break;
}
if (param_select != SLCT_INVALID) {
LCD_setcursor(row, col);
LCD_docmd(LCD_DISPLAYONOFF, LCD_CURSOR_ON);
}
wrlcd_dynamic = false;
}
// read switches and buttons to get the test to perform and its initial value
// display the selected test on the LEDs
NX3_readBtnSw(&btnsw);
init_high = (btnsw & SW_INIT_HILO) ? true : false;
test = btnsw & SW_TEST_SELECT;
//update the HI/LO and TEST LEDs
leds &= ~(LEDS_HILO | LEDS_TEST);
leds |= (init_high == true) ? LEDS_HILO : 0;
leds |= test << 3;
NX3_writeleds(leds);
// read rotary count and handle setpoint changes
// accelerate setpoint if speedup threshold has been exceeded
// Use MIN and MAX to keep scaled ADC count within range
ROT_readRotcnt(&rotcnt);
if (rotcnt != old_rotcnt) {
if (abs(rotcnt - old_rotcnt) > ROTCNT_SPEEDUP_GATE) {
setpoint += (rotcnt - old_rotcnt) * ROTCNT_DELTA
* ROTCNT_SPEEDUP_FACTOR;
} else {
setpoint += (rotcnt - old_rotcnt) * ROTCNT_DELTA;
}
setpoint = MAX(ADC_min_cnt, MIN(setpoint, ADC_max_cnt));
old_rotcnt = rotcnt;
wrlcd_dynamic = true;
} // rotary count changed
//***** NOTE: User interface handling should go in this section. *****
//***** The starter app just lets the user select the setpoint and *****
//***** run the test selected by the switches *****
// look at the buttons and take action on the rising edge of a button press
bool north_button = btnsw & msk_BTN_NORTH;
bool east_button = btnsw & msk_BTN_EAST;
bool west_button = btnsw & msk_BTN_WEST;
bool button_down = north_button || east_button || west_button;
if (button_down)
{
_prev_button_down_count++;
if (_prev_button_down_count > 5)
_prev_button_down_count = 5;
if (north_button) {
switch (param_select) {
case SLCT_GP:
param_select = SLCT_GI;
break;
case SLCT_GI:
param_select = SLCT_GD;
break;
case SLCT_GD:
param_select = SLCT_OFFSET;
break;
case SLCT_OFFSET:
param_select = SLCT_GP;
break;
}
wrlcd_dynamic = true;
}
if (east_button) {
switch (param_select) {
case SLCT_GP:
GP+=_prev_button_down_count;
break;
case SLCT_GI:
GI+=_prev_button_down_count;
break;
case SLCT_GD:
GD+=_prev_button_down_count;
break;
case SLCT_OFFSET:
offset+=_prev_button_down_count;
break;
}
wrlcd_dynamic = true;
}
if (west_button) {
switch (param_select) {
case SLCT_GP:
GP-=_prev_button_down_count;
break;
case SLCT_GI:
GI-=_prev_button_down_count;
break;
case SLCT_GD:
GD-=_prev_button_down_count;
break;
case SLCT_OFFSET:
offset-=_prev_button_down_count;
break;
}
wrlcd_dynamic = true;
}
} else {
_prev_button_down_count = 0;
}
btnsw &= BTN_MSK_ALLBUTTONS;
diff_btnsw = (btnsw ^ old_btnsw) & btnsw;
old_btnsw = btnsw;
if (diff_btnsw & BTN_RUN_XFER) // run a test
{
Xfloat32 vADC, vSP; // VADC from circuit and Vsetpoint
char s1[20], s2[30]; // display and print strings
int (*funcPtr)(void); // pointer to test function
int n; // number of samples to transfer (returned by test functions)
switch (test) // set up for the selected test
{
case TEST_BB: // Bit Bang control
strcpy(s1, "|BB |Press RBtn");
strcpy(s2, "Bit Bang Control Test Data");
funcPtr = DoTest_BB;
break;
case TEST_PID: // PID control
strcpy(s1, "|PID |Press RBtn");
strcpy(s2, "PID Control Test Data");
funcPtr = DoTest_PID;
break;
case TEST_CHARACTERIZE: // characterize control system simulator
strcpy(s1, "|CHAR|Press RBtn");
strcpy(s2, "Characterization Test Data");
funcPtr = DoTest_Characterize;
break;
default: // no test to run
strcpy(s1, "");
strcpy(s2, "");
funcPtr = NULL;
break;
}
// Change the display to indicate that a test will be run
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring(s1);
LCD_setcursor(2, 0);
LCD_wrstring("LED OFF-Release ");
// turn on Run LED to show the test has begun
// and do the test. The test will return when the ADC samples array
// has been filled. Turn off the rightmost LED after the data has been
// captured to let the user know he/she can release the button
if (funcPtr != NULL) {
leds |= LEDS_RUN;
NX3_writeleds(leds);
n = funcPtr();
leds &= ~LEDS_RUN;
NX3_writeleds(leds);
// wait for the Rotary Encoder button to be released
// and then send the sample data to stdout
do {
NX3_readBtnSw(&btnsw);
delay_msecs(10);
} while (btnsw & BTN_RUN_XFER);
// turn on Transfer LED to indicate that data is being transmitted
// Show the transfer traffic on the LCD
leds |= LEDS_XFER;
NX3_writeleds(leds);
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring("Sending Data....");
LCD_setcursor(2, 0);
LCD_wrstring("S: DATA: ");
// transfer the descriptive heading followed by the data
xil_printf("\n\r%s\tAppx. Sample Interval: %d msec\n\r", s2,
adc_smple_interval);
xil_printf("sample\tADCCount\tVout\tsetpoint\tPWMCount\n\r");
// tell SerialCharter to start gathering data)
xil_printf("===STARTPLOT===\n");
for (smpl_idx = 2; smpl_idx < n; smpl_idx++) {
u16 count;
count = sample[smpl_idx];
vADC = PmodCtlSys_ADCVolts(count);
vSP = PmodCtlSys_ADCVolts(setpoint);
voltstostrng(vADC, s1);
voltstostrng(vSP, s2);
xil_printf("%d\t%d\t%s\t%s\t%d\n\r", smpl_idx, count, s1,
s2, PIDdebug[smpl_idx].pwm_count);
LCD_setcursor(2, 2);
LCD_wrstring(" ");
LCD_setcursor(2, 2);
LCD_putnum(smpl_idx, 10);
LCD_setcursor(2, 11);
LCD_wrstring(" ");
LCD_setcursor(2, 11);
LCD_putnum(count, 10);
}
// tell SeriaCharter to stop gathering data and display the graph
xil_printf("===ENDPLOT===\n");
// transfer complete - turn Transfer LED off and wrap up command processing
leds &= ~LEDS_XFER;
NX3_writeleds(leds);
wrlcd_static = true;
wrlcd_dynamic = true;
}
} // run a test
// wait a bit and start again
delay_msecs(100);
} // while(1) loop
} // end main()
int main(int argc, char* argv[])
{
const char* interface;
test_t* t;
int c;
printf("# ef_vi_version_str: %s\n", ef_vi_version_str());
while( (c = getopt (argc, argv, "n:s:wfbvVpta:A:")) != -1 )
switch( c ) {
case 'n':
cfg_iter = atoi(optarg);
break;
case 's':
cfg_payload_len = atoi(optarg);
break;
case 'w':
cfg_eventq_wait = 1;
break;
case 'f':
cfg_fd_wait = 1;
break;
case 'v':
cfg_use_vf = 1;
break;
case 'V':
cfg_use_vport = 1;
break;
case 'p':
cfg_phys_mode = 1;
break;
case 't':
cfg_disable_tx_push = 1;
break;
case 'a':
cfg_tx_align = atoi(optarg);
break;
case 'A':
cfg_rx_align = atoi(optarg);
break;
case '?':
usage();
default:
TEST(0);
}
argc -= optind;
argv += optind;
if( argc != 7 )
usage();
interface = argv[1];
CL_CHK(parse_host(argv[2], &sa_local.sin_addr));
sa_local.sin_port = htons(atoi(argv[3]));
CL_CHK(parse_mac(argv[4], remote_mac));
CL_CHK(parse_host(argv[5], &sa_remote.sin_addr));
sa_remote.sin_port = htons(atoi(argv[6]));
if( cfg_payload_len > MAX_UDP_PAYLEN ) {
fprintf(stderr, "WARNING: UDP payload length %d is larged than standard "
"MTU\n", cfg_payload_len);
}
for( t = the_tests; t != the_tests + NUM_TESTS; ++t )
if( ! strcmp(argv[0], t->name) )
break;
if( t == the_tests + NUM_TESTS )
usage();
printf("# udp payload len: %d\n", cfg_payload_len);
printf("# iterations: %d\n", cfg_iter);
do_init(interface);
printf("# frame len: %d\n", tx_frame_len);
printf("# rx align: %d\n", cfg_rx_align);
printf("# tx align: %d\n", cfg_tx_align);
t->fn();
/* Free all ef_vi resources we allocated above. This isn't
* necessary as the process is about to exit which will free up all
* resources. It is just to serve as an example of how to free up
* ef_vi resources without exiting the process. */
do_free();
return 0;
}
init()
{
do_init(tag());
}
void init_clcs_debugger(){do_init(VV);}
void init_pcl_cpl(){do_init(VV);}
void init_pcl_defcombin(){do_init(VV);}
int main(void) {
do_init();
app_event_loop();
do_deinit();
}
int main(int argc, char *argv[]) {
int action = -1;
struct game_info Info;
struct game_state Game;
Info.map = 0;
Game.my_ants = 0;
Game.enemy_ants = 0;
Game.food = 0;
Game.dead_ants = 0;
Game.hill = 0;
while (42) {
int initial_buffer = 100000;
char *data = malloc(initial_buffer);
memset(data, 0, initial_buffer);
*data = '\n';
char *ins_data = data + 1;
int i = 0;
while (1 > 0) {
++i;
if (i >= initial_buffer) {
initial_buffer *= 2;
data = realloc(data, initial_buffer);
ins_data = data + i;
memset(ins_data, 0, initial_buffer - i);
}
*ins_data = getchar();
if (*ins_data == '\n') {
char *backup = ins_data;
while (*(backup - 1) != '\n') {
--backup;
}
char *test_cmd = get_line(backup);
if (strcmp(test_cmd, "go") == 0) {
action = 0;
free(test_cmd);
break;
}
else if (strcmp(test_cmd, "ready") == 0) {
action = 1;
free(test_cmd);
break;
}
free(test_cmd);
}
++ins_data;
}
if (action == 0) {
char *skip_line = data + 1;
while (*++skip_line != '\n');
++skip_line;
_init_map(skip_line, &Info);
_init_game(&Info, &Game);
do_turn(&Game, &Info);
fprintf(stdout, "go\n");
fflush(stdout);
}
else if (action == 1) {
_init_ants(data + 1, &Info);
Game.my_ant_index = -1;
do_init(&Game, &Info);
fprintf(stdout, "go\n");
fflush(stdout);
}
free(data);
}
}
/*======================================
* CORE : MAINROUTINE
*--------------------------------------*/
int main (int argc, char **argv)
{
{// initialize program arguments
char *p1 = SERVER_NAME = argv[0];
char *p2 = p1;
while ((p1 = strchr(p2, '/')) != NULL || (p1 = strchr(p2, '\\')) != NULL)
{
SERVER_NAME = ++p1;
p2 = p1;
}
arg_c = argc;
arg_v = argv;
}
malloc_init();// needed for Show* in display_title() [FlavioJS]
#ifdef MINICORE // minimalist Core
display_title();
usercheck();
do_init(argc,argv);
do_final();
#else// not MINICORE
set_server_type();
display_title();
usercheck();
rathread_init();
mempool_init();
db_init();
signals_init();
#ifdef _WIN32
cevents_init();
#endif
timer_init();
socket_init();
do_init(argc,argv);
{// Main runtime cycle
int next;
while (runflag != CORE_ST_STOP) {
next = do_timer(gettick_nocache());
do_sockets(next);
}
}
do_final();
timer_final();
socket_final();
db_final();
mempool_final();
rathread_final();
#endif
malloc_final();
return 0;
}
int main(int argc, char **argv)
{
int rc = 0;
struct cfgdata_t cfg;
struct params_t params;
kx_inputs inputs;
lg = log_open(16);
log_msg(lg, "%s starting", PACKAGE_STRING);
initmode = do_init();
/* Get cmdline parameters */
params.cfg = &cfg;
init_cfgdata(&cfg);
cfg.angle = 0; /* No rotation by default */
parse_cmdline(&cfg);
kxb_ttydev = cfg.ttydev;
setup_terminal(kxb_ttydev, &kxb_echo_state, 1);
/* Setup function that will restore terminal when exit() will called */
atexit(atexit_restore_terminal);
log_msg(lg, "FB angle is %d, tty is %s", cfg.angle, cfg.ttydev);
#ifdef USE_MACHINE_KERNEL
machine_kernel = get_machine_kernelpath(); /* FIXME should be passed as arg to get_bootinfo() */
#endif
#ifdef USE_DELAY
/* extra delay for initializing slow SD/CF */
sleep(USE_DELAY);
#endif
int no_ui = 1; /* UI presence flag */
#ifdef USE_FBMENU
params.gui = NULL;
if (no_ui) {
params.gui = gui_init(cfg.angle);
if (NULL == params.gui) {
log_msg(lg, "Can't initialize GUI");
} else no_ui = 0;
}
#endif
#ifdef USE_TEXTUI
FILE *ttyfp;
params.tui = NULL;
if (no_ui) {
if (cfg.ttydev) ttyfp = fopen(cfg.ttydev, "w");
else ttyfp = stdout;
params.tui = tui_init(ttyfp);
if (NULL == params.tui) {
log_msg(lg, "Can't initialize TUI");
if (ttyfp != stdout) fclose(ttyfp);
} else no_ui = 0;
}
#endif
if (no_ui) exit(-1); /* Exit if no one UI was initialized */
params.menu = build_menu(¶ms);
params.bootcfg = NULL;
scan_devices(¶ms);
if (-1 == fill_menu(¶ms)) {
exit(-1);
}
/* Collect input devices */
inputs_init(&inputs, 8);
inputs_open(&inputs);
inputs_preprocess(&inputs);
/* Run main event loop
* Return values: <0 - error, >=0 - selected item id */
rc = do_main_loop(¶ms, &inputs);
#ifdef USE_FBMENU
if (params.gui) {
if (rc < 0) gui_clear(params.gui);
gui_destroy(params.gui);
}
#endif
#ifdef USE_TEXTUI
if (params.tui) {
tui_destroy(params.tui);
if (ttyfp != stdout) fclose(ttyfp);
}
#endif
inputs_close(&inputs);
inputs_clean(&inputs);
log_close(lg);
lg = NULL;
/* rc < 0 indicate error */
if (rc < 0) exit(rc);
menu_destroy(params.menu, 0);
if (rc >= A_DEVICES) {
start_kernel(¶ms, rc - A_DEVICES);
}
/* When we reach this point then some error has occured */
DPRINTF("We should not reach this point!");
exit(-1);
}
int main()
{
XStatus Status;
u32 btnsw, old_btnsw = 0x000000FF;
int rotcnt, old_rotcnt = 0x1000;
bool done = false;
// initialize devices and set up interrupts, etc.
Status = do_init();
if (Status != XST_SUCCESS)
{
LCD_setcursor(1,0);
LCD_wrstring("****** ERROR *******");
LCD_setcursor(2,0);
LCD_wrstring("INIT FAILED- EXITING");
exit(XST_FAILURE);
}
// initialize the global variables
timestamp = 0;
pwm_freq = INITIAL_FREQUENCY;
pwm_duty = INITIAL_DUTY_CYCLE;
clkfit = 0;
new_perduty = false;
// start the PWM timer and kick of the processing by enabling the Microblaze interrupt
PWM_SetParams(&PWMTimerInst, pwm_freq, pwm_duty);
PWM_Start(&PWMTimerInst);
microblaze_enable_interrupts();
// display the greeting
LCD_setcursor(1,0);
LCD_wrstring(" PWM LIB TEST R0");
LCD_setcursor(2,0);
LCD_wrstring(" by Roy Kravitz ");
NX3_writeleds(0x000000FF);
delay_msecs(2000);
NX3_writeleds(0x00000000);
// write the static text to the display
LCD_clrd();
LCD_setcursor(1,0);
LCD_wrstring("G|FR: DCY: %");
LCD_setcursor(2,0);
LCD_wrstring("Vavg: ");
// main loop
do
{
// check rotary encoder pushbutton to see if it's time to quit
NX3_readBtnSw(&btnsw);
if (btnsw & msk_BTN_ROT)
{
done = true;
}
else
{
new_perduty = false;
if (btnsw != old_btnsw)
{
switch (btnsw & PWM_FREQ_MSK)
{
case 0x00: pwm_freq = PWM_FREQ_10HZ; break;
case 0x01: pwm_freq = PWM_FREQ_100HZ; break;
case 0x02: pwm_freq = PWM_FREQ_1KHZ; break;
case 0x03: pwm_freq = PWM_FREQ_10KHZ; break;
case 0x04: pwm_freq = PWM_FREQ_50KHZ; break;
case 0x05: pwm_freq = PWM_FREQ_100KHZ; break;
case 0x06: pwm_freq = PWM_FREQ_150KHZ; break;
case 0x07: pwm_freq = PWM_FREQ_200KHZ; break;
}
old_btnsw = btnsw;
new_perduty = true;
}
// read rotary count and handle duty cycle changes
// limit duty cycle to 0% to 99%
ROT_readRotcnt(&rotcnt);
if (rotcnt != old_rotcnt)
{
pwm_duty = MAX(0, MIN(rotcnt, 99));
old_rotcnt = rotcnt;
new_perduty = true;
}
// update generated frequency and duty cycle
if (new_perduty)
{
u32 freq, dutycycle;
float vavg;
char s[10];
// set the new PWM parameters - PWM_SetParams stops the timer
Status = PWM_SetParams(&PWMTimerInst, pwm_freq, pwm_duty);
if (Status == XST_SUCCESS)
{
PWM_GetParams(&PWMTimerInst, &freq, &dutycycle);
update_lcd(freq, dutycycle, 1);
vavg = dutycycle * .01 * 3.3;
voltstostrng(vavg, s);
LCD_setcursor(2,5);
LCD_wrstring(s);
PWM_Start(&PWMTimerInst);
}
}
}
} while (!done);
// wait until rotary encoder button is released
do
{
NX3_readBtnSw(&btnsw);
delay_msecs(10);
} while ((btnsw & msk_BTN_ROT) == 0x80);
// and say goodbye
LCD_clrd();
LCD_wrstring("That's all folks");
delay_msecs(2000);
LCD_clrd();
exit(XST_SUCCESS);
}
void init_pcl_dlisp(){do_init(VV);}
int main(void)
{
struct sigaction sigact;
int r = 1;
r = libusb_init(NULL);
if (r < 0) {
fprintf(stderr, "failed to initialise libusb\n");
exit(1);
}
r = find_dpfp_device();
if (r < 0) {
fprintf(stderr, "Could not find/open device\n");
goto out;
}
r = libusb_claim_interface(devh, 0);
if (r < 0) {
fprintf(stderr, "usb_claim_interface error %d %s\n", r, strerror(-r));
goto out;
}
printf("claimed interface\n");
r = print_f0_data();
if (r < 0)
goto out_release;
r = do_init();
if (r < 0)
goto out_deinit;
/* async from here onwards */
sigact.sa_handler = sighandler;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
sigaction(SIGINT, &sigact, NULL);
sigaction(SIGTERM, &sigact, NULL);
sigaction(SIGQUIT, &sigact, NULL);
r = pthread_create(&poll_thread, NULL, poll_thread_main, NULL);
if (r)
goto out_deinit;
r = alloc_transfers();
if (r < 0) {
request_exit(1);
pthread_join(poll_thread, NULL);
goto out_deinit;
}
r = init_capture();
if (r < 0) {
request_exit(1);
pthread_join(poll_thread, NULL);
goto out_deinit;
}
while (!do_exit) {
pthread_mutex_lock(&exit_cond_lock);
pthread_cond_wait(&exit_cond, &exit_cond_lock);
pthread_mutex_unlock(&exit_cond_lock);
}
printf("shutting down...\n");
pthread_join(poll_thread, NULL);
r = libusb_cancel_transfer(irq_transfer);
if (r < 0) {
request_exit(1);
goto out_deinit;
}
r = libusb_cancel_transfer(img_transfer);
if (r < 0) {
request_exit(1);
goto out_deinit;
}
while (img_transfer || irq_transfer)
if (libusb_handle_events(NULL) < 0)
break;
if (do_exit == 1)
r = 0;
else
r = 1;
out_deinit:
libusb_free_transfer(img_transfer);
libusb_free_transfer(irq_transfer);
set_mode(0);
set_hwstat(0x80);
out_release:
libusb_release_interface(devh, 0);
out:
libusb_close(devh);
libusb_exit(NULL);
return r >= 0 ? r : -r;
}
int main(int argc, char *argv[])
{
// Pid Code,erlaubt nur eine Instanz
int pid_file = open("/var/run/ctlmissile.pid", O_CREAT | O_RDWR, 0666);
int rc = flock(pid_file, LOCK_EX | LOCK_NB);
if(rc) {
if(EWOULDBLOCK == errno)
fprintf(stderr, "Another Instance is running!");
exit(0);
}
libusb_device **devlist;
libusb_device *dev;
ssize_t numdev, i;
int ret = 0;
do_init();
numdev = libusb_get_device_list(ctx, &devlist);
for(ret = 1, i = 0; i < numdev; i++) {
dev = devlist[i];
struct libusb_device_descriptor d;
libusb_get_device_descriptor(dev, &d);
int ret=0;
if (d.idVendor == 0x0a81 &&
d.idProduct == 0x0701) {
//fprintf(stderr, "Found Device:\n");
// Try to detach:
ret = detach_device(dev);
//fprintf(stderr, "%d:\n",ret);
libusb_device_handle *handle;
// get Handle:
ret = libusb_open(dev, &handle);
if(ret!=0){
fprintf(stderr, "Couldnt get Handle: %s\n",libusb_error_name(ret));
}
// Claim Device:
ret = libusb_claim_interface(handle,0);
if(ret!=0){
fprintf(stderr, "Error with Claiming: %s\n",libusb_error_name(ret));
}
int delay;
sscanf (argv[2],"%d",&delay);
// Try Command
makeCommand(handle,argv[1],delay);
// Try to reset
//libusb_reset_device(handle);
break;
}
}
if (!dev) {
fprintf(stderr, "Unable to find device.\n");
exit(EXIT_FAILURE);
}
return 0;
}
int
main(int argc, char **argv)
{
int argerr = 0;
int flag;
const char *source = NULL;
char *admin_input_xml = NULL;
char *admin_input_file = NULL;
gboolean dangerous_cmd = FALSE;
gboolean admin_input_stdin = FALSE;
xmlNode *output = NULL;
xmlNode *input = NULL;
int option_index = 0;
crm_log_init("cibadmin", LOG_CRIT, FALSE, FALSE, argc, argv);
crm_set_options("V?$o:QDUCEX:t:Srwlsh:MmBfbRx:pP5N:A:uncd", "command [options] [data]", long_options,
"Provides direct access to the cluster configuration."
"\n\n Allows the configuration, or sections of it, to be queried, modified, replaced and deleted."
"\n\n Where necessary, XML data will be obtained using the -X, -x, or -p options\n");
if(argc < 2) {
crm_help('?',LSB_EXIT_EINVAL);
}
while (1) {
flag = crm_get_option(argc, argv, &option_index);
if (flag == -1)
break;
switch(flag) {
case 't':
message_timeout_ms = atoi(optarg);
if(message_timeout_ms < 1) {
message_timeout_ms = 30;
}
break;
case 'A':
obj_type = crm_strdup(optarg);
command_options |= cib_xpath;
break;
case 'u':
cib_action = CIB_OP_UPGRADE;
dangerous_cmd = TRUE;
break;
case 'E':
cib_action = CIB_OP_ERASE;
dangerous_cmd = TRUE;
break;
case 'Q':
cib_action = CIB_OP_QUERY;
break;
case 'P':
cib_action = CIB_OP_APPLY_DIFF;
break;
case 'S':
cib_action = CIB_OP_SYNC;
break;
case 'U':
case 'M':
cib_action = CIB_OP_MODIFY;
break;
case 'R':
cib_action = CIB_OP_REPLACE;
break;
case 'C':
cib_action = CIB_OP_CREATE;
break;
case 'D':
cib_action = CIB_OP_DELETE;
break;
case '5':
cib_action = "md5-sum";
break;
case 'c':
command_options |= cib_can_create;
break;
case 'n':
command_options |= cib_no_children;
break;
case 'm':
cib_action = CIB_OP_ISMASTER;
command_options |= cib_scope_local;
break;
case 'B':
cib_action = CIB_OP_BUMP;
break;
case 'r':
dangerous_cmd = TRUE;
cib_action = CIB_OP_SLAVE;
break;
case 'w':
dangerous_cmd = TRUE;
cib_action = CIB_OP_MASTER;
command_options |= cib_scope_local;
break;
case 'V':
command_options = command_options | cib_verbose;
cl_log_enable_stderr(TRUE);
alter_debug(DEBUG_INC);
break;
case '?':
case '$':
crm_help(flag, LSB_EXIT_OK);
break;
case 'o':
crm_debug_2("Option %c => %s", flag, optarg);
obj_type = crm_strdup(optarg);
break;
case 'X':
crm_debug_2("Option %c => %s", flag, optarg);
admin_input_xml = crm_strdup(optarg);
break;
case 'x':
crm_debug_2("Option %c => %s", flag, optarg);
admin_input_file = crm_strdup(optarg);
break;
case 'p':
admin_input_stdin = TRUE;
break;
case 'h':
host = crm_strdup(optarg);
break;
case 'l':
command_options |= cib_scope_local;
break;
case 'd':
cib_action = CIB_OP_DELETE;
command_options |= cib_multiple;
dangerous_cmd = TRUE;
break;
case 'b':
dangerous_cmd = TRUE;
command_options |= cib_inhibit_bcast;
command_options |= cib_scope_local;
break;
case 's':
command_options |= cib_sync_call;
break;
case 'f':
force_flag = TRUE;
command_options |= cib_quorum_override;
break;
default:
printf("Argument code 0%o (%c)"
" is not (?yet?) supported\n",
flag, flag);
++argerr;
break;
}
}
if (optind < argc) {
printf("non-option ARGV-elements: ");
while (optind < argc)
printf("%s ", argv[optind++]);
printf("\n");
crm_help('?', LSB_EXIT_EINVAL);
}
if (optind > argc || cib_action == NULL) {
++argerr;
}
if (argerr) {
crm_help('?', LSB_EXIT_GENERIC);
}
if(dangerous_cmd && force_flag == FALSE) {
fprintf(stderr, "The supplied command is considered dangerous."
" To prevent accidental destruction of the cluster,"
" the --force flag is required in order to proceed.\n");
fflush(stderr);
exit(LSB_EXIT_GENERIC);
}
if(admin_input_file != NULL) {
input = filename2xml(admin_input_file);
source = admin_input_file;
} else if(admin_input_xml != NULL) {
source = "input string";
input = string2xml(admin_input_xml);
} else if(admin_input_stdin) {
source = "STDIN";
input = stdin2xml();
}
if(input != NULL) {
crm_log_xml_debug(input, "[admin input]");
} else if(source) {
fprintf(stderr, "Couldn't parse input from %s.\n", source);
return 1;
}
if(safe_str_eq(cib_action, "md5-sum")) {
char *digest = NULL;
if(input == NULL) {
fprintf(stderr,
"Please supply XML to process with -X, -x or -p\n");
exit(1);
}
digest = calculate_xml_digest(input, FALSE, FALSE);
fprintf(stderr, "Digest: ");
fprintf(stdout, "%s\n", crm_str(digest));
crm_free(digest);
exit(0);
}
exit_code = do_init();
if(exit_code != cib_ok) {
crm_err("Init failed, could not perform requested operations");
fprintf(stderr, "Init failed, could not perform requested operations\n");
return -exit_code;
}
exit_code = do_work(input, command_options, &output);
if (exit_code > 0) {
/* wait for the reply by creating a mainloop and running it until
* the callbacks are invoked...
*/
request_id = exit_code;
the_cib->cmds->register_callback(
the_cib, request_id, message_timeout_ms, FALSE, NULL,
"cibadmin_op_callback", cibadmin_op_callback);
mainloop = g_main_new(FALSE);
crm_debug_3("%s waiting for reply from the local CIB",
crm_system_name);
crm_info("Starting mainloop");
g_main_run(mainloop);
} else if(exit_code < 0) {
crm_err("Call failed: %s", cib_error2string(exit_code));
fprintf(stderr, "Call failed: %s\n",
cib_error2string(exit_code));
operation_status = exit_code;
if(exit_code == cib_dtd_validation) {
if(crm_str_eq(cib_action, CIB_OP_UPGRADE, TRUE)) {
xmlNode *obj = NULL;
int version = 0, rc = 0;
rc = the_cib->cmds->query(the_cib, NULL, &obj, command_options);
if(rc == cib_ok) {
update_validation(&obj, &version, TRUE, FALSE);
}
} else if(output) {
validate_xml_verbose(output);
}
}
}
if(output != NULL) {
char *buffer = dump_xml_formatted(output);
fprintf(stdout, "%s\n", crm_str(buffer));
crm_free(buffer);
}
the_cib->cmds->signoff(the_cib);
crm_debug_3("%s exiting normally", crm_system_name);
return -exit_code;
}
int main(int argc, char* argv[])
{
remove("/tmp/temp_mem");
if (mkfifo("/tmp/temp_mem", 0666) < 0)
printf("mkfifo failed");
remove("/tmp/temp_info");
if (mkfifo("/tmp/temp_info", 0666) < 0)
printf("mkfifo failed");
remove("/tmp/temp_var4");
if (mkfifo("/tmp/temp_var4", 0666) < 0)
printf("mkfifo failed");
char c;
int i;
/**********************************************************************************/
//用于进程间通信
signal(SIGUSR1, setMark1);
signal(SIGUSR2, setMark2);
/**********************************************************************************/
//if (!(ptr_auxMem = fopen(AUXILIARY_MEMORY, "r+")))
//创建辅存文件
if (!(ptr_auxMem = fopen(AUXILIARY_MEMORY, "w+")))
{
do_error(ERROR_FILE_OPEN_FAILED);
exit(1);
}
//初始化页表，辅存和实存
do_init();
//打印页表信息
do_print_info();
//为访存请求申请空间
ptr_memAccReq = (Ptr_MemoryAccessRequest)malloc(sizeof(MemoryAccessRequest));
/* 在循环中模拟访存请求与处理过程 */
/**********************************************************************************/
pid = do_fork();
/**********************************************************************************/
while (TRUE)
{
//do_request();
/***************************************************************************************/
new_do_request();
/***************************************************************************************/
//do_response();
while (mark2 == 0);
mark2 = 0;
c = getchar();
while (c != '\n')
c = getchar();
int flag_y = 0;
int flag_m = 0;
printf("按Y打印页表，按其他键不打印...\n");
if ((c = getchar()) == 'y' || c == 'Y')
{
//do_print_info();
do_print_info_from_file();
flag_y = 1;
}
if (flag_y == 0)
{
char temp_str[10000] = { 0 };
int temp_fifo;
if ((temp_fifo = open("/tmp/temp_info", O_RDONLY)) < 0)
printf("open /tmp/temp_info failed");
int count = 0;
//读200个，关
if ((count = read(temp_fifo, temp_str, 10000)) < 0)
printf("read /tmp/temp_info failed");
close(temp_fifo);
}
while (c != '\n')
c = getchar();
/***************************************************************************************/
printf("按A打印辅存，按其他键不打印...\n");
if ((c = getchar()) == 'a' || c == 'A')
do_print_auxiliaryStorage();
while (c != '\n')
c = getchar();
printf("按M打印实存，按其他键不打印...\n");
if ((c = getchar()) == 'm' || c == 'M')
{
//do_print_memory();
do_print_memory_from_file();
flag_m = 1;
}
if (flag_m == 0)
{
char temp_str[10000] = { 0 };
int temp_fifo;
if ((temp_fifo = open("/tmp/temp_mem", O_RDONLY)) < 0)
printf("open /tmp/temp_mem failed");
int count = 0;
//读200个，关
if ((count = read(temp_fifo, temp_str, 10000)) < 0)
printf("read /tmp/temp_info failed");
close(temp_fifo);
}
while (c != '\n')
c = getchar();
/***************************************************************************************/
printf("按X退出程序，按其他键继续...\n");
if ((c = getchar()) == 'x' || c == 'X')
break;
while (c != '\n')
c = getchar();
}
if (fclose(ptr_auxMem) == EOF)
{
do_error(ERROR_FILE_CLOSE_FAILED);
exit(1);
}
return (0);
}
int
main(int argc, char **argv)
{
int option_index = 0;
int argerr = 0;
int flag;
crm_log_cli_init("crmadmin");
crm_set_options(NULL, "command [options]", long_options,
"Development tool for performing some crmd-specific commands."
"\n Likely to be replaced by crm_node in the future");
if (argc < 2) {
crm_help('?', LSB_EXIT_EINVAL);
}
while (1) {
flag = crm_get_option(argc, argv, &option_index);
if (flag == -1)
break;
switch (flag) {
case 'V':
BE_VERBOSE = TRUE;
admin_verbose = XML_BOOLEAN_TRUE;
crm_bump_log_level();
break;
case 't':
message_timeout_ms = atoi(optarg);
if (message_timeout_ms < 1) {
message_timeout_ms = 30 * 1000;
}
break;
case '$':
case '?':
crm_help(flag, LSB_EXIT_OK);
break;
case 'D':
DO_WHOIS_DC = TRUE;
break;
case 'B':
BASH_EXPORT = TRUE;
break;
case 'K':
DO_RESET = TRUE;
crm_trace("Option %c => %s", flag, optarg);
dest_node = crm_strdup(optarg);
crmd_operation = CRM_OP_LOCAL_SHUTDOWN;
break;
case 'q':
BE_SILENT = TRUE;
break;
case 'i':
DO_DEBUG = debug_inc;
crm_trace("Option %c => %s", flag, optarg);
dest_node = crm_strdup(optarg);
break;
case 'd':
DO_DEBUG = debug_dec;
crm_trace("Option %c => %s", flag, optarg);
dest_node = crm_strdup(optarg);
break;
case 'S':
DO_HEALTH = TRUE;
crm_trace("Option %c => %s", flag, optarg);
dest_node = crm_strdup(optarg);
break;
case 'E':
DO_ELECT_DC = TRUE;
break;
case 'N':
DO_NODE_LIST = TRUE;
break;
case 'H':
DO_HEALTH = TRUE;
break;
default:
printf("Argument code 0%o (%c) is not (?yet?) supported\n", flag, flag);
++argerr;
break;
}
}
if (optind < argc) {
printf("non-option ARGV-elements: ");
while (optind < argc)
printf("%s ", argv[optind++]);
printf("\n");
}
if (optind > argc) {
++argerr;
}
if (argerr) {
crm_help('?', LSB_EXIT_GENERIC);
}
if (do_init()) {
int res = 0;
res = do_work();
if (res > 0) {
/* wait for the reply by creating a mainloop and running it until
* the callbacks are invoked...
*/
mainloop = g_main_new(FALSE);
crm_trace("Waiting for %d replies from the local CRM", expected_responses);
message_timer_id = g_timeout_add(message_timeout_ms, admin_message_timeout, NULL);
g_main_run(mainloop);
} else if (res < 0) {
crm_err("No message to send");
operation_status = -1;
}
} else {
crm_warn("Init failed, could not perform requested operations");
operation_status = -2;
}
crm_trace("%s exiting normally", crm_system_name);
return operation_status;
}
void pz_modules_init(char *path)
{
#ifdef IPOD
#define MODULEDIR "/opt/Base:/opt/Emulators:/opt/Media:/opt/Tools:/opt/Zillae"
#else
#define MODULEDIR "modules"
#endif
/* Used for the progress bar */
TWindow * sliderwin;
TWidget * slider;
int sliderVal=0;
int verbosity = pz_get_int_setting( pz_global_config, VERBOSITY );
#define MAXSLIDERVAL (100)
#define SETUPSECTIONS (6)
PzModule *last, *cur;
int i;
int modCount=0;
if (module_head) {
pz_error (_("modules_init called more than once"));
return;
}
/* set up the screen to show a pretty progress bar */
sliderwin = ttk_new_window();
ttk_window_hide_header(sliderwin);
sliderwin->x = sliderwin->y = 0;
slider = ttk_new_slider_widget(2, ttk_screen->h/3, ttk_screen->w - 8, 0,
MAXSLIDERVAL, &sliderVal, 0);
slider->x = (sliderwin->w - slider->w)/2;
ttk_add_widget(sliderwin, slider);
sliderVal = (MAXSLIDERVAL/SETUPSECTIONS) * 1;
updateprogress(sliderwin, slider, sliderVal, _("Scanning For Modules"), NULL);
if (!path)
path = MODULEDIR;
path = strtok(strdupa(path), ":");
while (path) {
find_modules (path);
path = strtok(NULL, ":");
}
sliderVal = (MAXSLIDERVAL/SETUPSECTIONS) * 2;
updateprogress(sliderwin, slider, sliderVal, _("Reading Modules"), NULL);
for (i = 0; i < __pz_builtin_number_of_init_functions; i++) {
int found = 0;
const char *name = __pz_builtin_names[i];
cur = module_head;
while (cur) {
char *p = strrchr (cur->podpath, '/');
if (!p) p = cur->podpath;
else p++;
if (!strncmp (p, name, strlen (name)) && !isalpha (p[strlen (name)])) {
found = 1;
break;
}
cur = cur->next;
}
if (!found) {
if (module_head) {
cur = module_head; while (cur->next) cur = cur->next;
cur->next = calloc (1, sizeof(PzModule));
cur = cur->next;
} else {
cur = module_head = calloc (1, sizeof(PzModule));
}
cur->podpath = 0;
cur->name = strdup (__pz_builtin_names[i]);
cur->init = __pz_builtin_init_functions[i];
cur->to_load = -1;
cur->ordered = 0;
cur->next = 0;
}
}
if (!module_head) {
pz_message_title (_("Warning"), _("No modules. podzilla will probably be very boring."));
return;
}
/* Used to initialize the window + progressbar used in loading the modules*/
cur = module_head;
while (cur) {
modCount++;
cur = cur->next;
}
sliderVal = (MAXSLIDERVAL/SETUPSECTIONS) * 3;
updateprogress(sliderwin, slider, sliderVal, _("Mounting Modules"), NULL);
// Mount 'em
cur = module_head;
last = 0;
while (cur) {
if (cur->podpath && cur->extracted) {
cur->mountpt = strdup (cur->podpath);
last = cur;
cur = cur->next;
} else if (cur->podpath && mount_pod (cur) == -1) {
if (last) last->next = cur->next;
else module_head = cur->next;
free (cur->podpath);
free (cur);
cur = last? last->next : module_head;
} else {
last = cur;
cur = cur->next;
}
}
sliderVal = (MAXSLIDERVAL/SETUPSECTIONS) * 4;
updateprogress(sliderwin, slider, sliderVal, _("Scanning Module Info"), NULL);
// Load the module.inf's
cur = module_head;
while (cur) {
load_modinf (cur);
cur = cur->next;
}
sliderVal = (MAXSLIDERVAL/SETUPSECTIONS) * 5;
updateprogress(sliderwin, slider, sliderVal, _("Module Dependencies"), NULL);
// Figure out the dependencies
cur = module_head;
last = 0;
while (cur) {
if (fix_dependencies (cur, 1, SOFTDEP) == -1 ||
fix_dependencies(cur, 1, HARDDEP) == -1) {
if (last) last->next = cur->next;
else module_head = cur->next;
free_module (cur);
cur = last? last->next : module_head;
} else {
last = cur;
cur = cur->next;
}
}
// Check which ones are linked in
cur = module_head;
last = 0;
while (cur) {
for (i = 0; i < __pz_builtin_number_of_init_functions; i++) {
if (!strcmp (__pz_builtin_names[i], cur->name)) {
cur->init = __pz_builtin_init_functions[i];
cur->to_load = -1;
cur->ordered = 0;
}
}
cur = cur->next;
}
// XXX. For now, we use a slow method for deps, and it'll crash
// for circular deps. davidc__ is working on a
// better solution.
cur = module_head;
while (cur) {
add_deps (cur);
cur = cur->next;
}
sliderVal = (MAXSLIDERVAL/SETUPSECTIONS) * 6;
updateprogress(sliderwin, slider, sliderVal, _("Loading Modules"), NULL);
struct dep *c = load_order;
while (c) {
if (c->mod->to_load > 0) {
do_load (c->mod);
}
if( verbosity < VERBOSITY_ERRORS && c->mod->longname ) {
updateprogress(sliderwin, slider, sliderVal, _("Loading Modules"),
c->mod->longname );
}
c = c->next;
}
c = load_order;
sliderVal = 0;
updateprogress(sliderwin, slider, sliderVal, _("Initializing Modules"), NULL);
/* trigger the sliders to switch to init mode, restting the slider */
sliderVal = 0;
/* initialize the modules */
while (c) {
sliderVal += MAXSLIDERVAL / modCount;
current_module = c->mod;
updateprogress(sliderwin, slider, sliderVal,
_("Initializing Modules"),
(verbosity < 2)? c->mod->longname : NULL );
do_init (c->mod);
c = c->next;
}
sliderVal = MAXSLIDERVAL;
updateprogress(sliderwin, slider, sliderVal,
_("Finishing Up..."), NULL);
// Any modules with unrecoverable errors on loading set mod->to_free.
// Oblige them.
cur = module_head;
last = 0;
while (cur) {
if (cur->to_free) {
if (last) last->next = cur->next;
else module_head = cur->next;
free_module (cur);
cur = last? last->next : module_head;
} else {
last = cur;
cur = cur->next;
}
}
ttk_free_window (sliderwin);
}
