static gboolean prox_cutoff_handler (xmlNodePtr node, gpointer billterm_pdata) { struct billterm_pdata *pdata = billterm_pdata; return set_int (node, pdata->term, gncBillTermSetCutoff); }
static bool recquality(void) { return set_int(str(LANG_RECORDING_QUALITY), "", UNIT_INT, &global_settings.rec_quality, NULL, 1, 0, 7, NULL ); }
static gboolean prox_discday_handler (xmlNodePtr node, gpointer billterm_pdata) { struct billterm_pdata *pdata = billterm_pdata; return set_int (node, pdata->term, gncBillTermSetDiscountDays); }
static int run_child(int *cfd, SSL_CTX *ctx, struct sockaddr_storage *addr, int status_wfd, int status_rfd, const char *conffile, int forking) { int ret=-1; int ca_ret=0; SSL *ssl=NULL; BIO *sbio=NULL; struct conf **confs=NULL; struct conf **cconfs=NULL; struct cntr *cntr=NULL; struct async *as=NULL; const char *cname=NULL; struct asfd *asfd=NULL; int is_status_server=0; if(!(confs=confs_alloc()) || !(cconfs=confs_alloc())) goto end; set_peer_env_vars(addr); // Reload global config, in case things have changed. This means that // the server does not need to be restarted for most conf changes. confs_init(confs); confs_init(cconfs); if(conf_load_global_only(conffile, confs)) goto end; // Hack to keep forking turned off if it was specified as off on the // command line. if(!forking) set_int(confs[OPT_FORK], 0); if(!(sbio=BIO_new_socket(*cfd, BIO_NOCLOSE)) || !(ssl=SSL_new(ctx))) { logp("There was a problem joining ssl to the socket\n"); goto end; } SSL_set_bio(ssl, sbio, sbio); /* Do not try to check peer certificate straight away. Clients can send a certificate signing request when they have no certificate. */ SSL_set_verify(ssl, SSL_VERIFY_PEER /* | SSL_VERIFY_FAIL_IF_NO_PEER_CERT */, 0); if(ssl_do_accept(ssl)) goto end; if(!(as=async_alloc()) || as->init(as, 0) || !(asfd=setup_asfd_ssl(as, "main socket", cfd, ssl))) goto end; asfd->set_timeout(asfd, get_int(confs[OPT_NETWORK_TIMEOUT])); asfd->ratelimit=get_float(confs[OPT_RATELIMIT]); if(authorise_server(as->asfd, confs, cconfs) || !(cname=get_string(cconfs[OPT_CNAME])) || !*cname) { // Add an annoying delay in case they are tempted to // try repeatedly. log_and_send(as->asfd, "unable to authorise on server"); sleep(1); goto end; } if(!get_int(cconfs[OPT_ENABLED])) { log_and_send(as->asfd, "client not enabled on server"); sleep(1); goto end; } // Set up counters. Have to wait until here to get cname. if(!(cntr=cntr_alloc()) || cntr_init(cntr, cname)) goto end; set_cntr(confs[OPT_CNTR], cntr); set_cntr(cconfs[OPT_CNTR], cntr); /* At this point, the client might want to get a new certificate signed. Clients on 1.3.2 or newer can do this. */ if((ca_ret=ca_server_maybe_sign_client_cert(as->asfd, confs, cconfs))<0) { logp("Error signing client certificate request for %s\n", cname); goto end; } else if(ca_ret>0) { // Certificate signed and sent back. // Everything is OK, but we will close this instance // so that the client can start again with a new // connection and its new certificates. logp("Signed and returned client certificate request for %s\n", cname); ret=0; goto end; } /* Now it is time to check the certificate. */ if(ssl_check_cert(ssl, confs, cconfs)) { log_and_send(as->asfd, "check cert failed on server"); goto end; } if(status_rfd>=0) { is_status_server=1; if(!setup_asfd(as, "status server parent socket", &status_rfd)) goto end; } ret=child(as, is_status_server, status_wfd, confs, cconfs); end: *cfd=-1; if(as && asfd_flush_asio(as->asfd)) ret=-1; async_asfd_free_all(&as); // This closes cfd for us. logp("exit child\n"); if(cntr) cntr_free(&cntr); if(confs) { set_cntr(confs[OPT_CNTR], NULL); confs_free(&confs); } if(cconfs) { set_cntr(cconfs[OPT_CNTR], NULL); confs_free(&cconfs); } return ret; }
void for_loop_finish_iteration(Stack* stack, bool enableLoopOutput) { INCREMENT_STAT(LoopFinishIteration); Frame* frame = top_frame(stack); Branch* contents = frame->branch; // Find list length caValue* listInput = get_frame_register(frame, 0); // Increment the loop index caValue* index = get_top_register(stack, for_loop_find_index(contents)); set_int(index, as_int(index) + 1); // Preserve list output if (enableLoopOutput && frame->exitType != name_Discard) { caValue* outputIndex = get_frame_register(frame, for_loop_find_output_index(contents)); Term* outputPlaceholder = get_output_placeholder(contents, 0); caValue* outputList = get_frame_register(frame, outputPlaceholder); caValue* outputValue = find_stack_value_for_term(stack, outputPlaceholder->input(0), 0); if (!is_list(outputList)) set_list(outputList); list_touch(outputList); copy(outputValue, list_get(outputList, as_int(outputIndex))); INCREMENT_STAT(LoopWriteOutput); // Advance output index set_int(outputIndex, as_int(outputIndex) + 1); } // Check if we are finished if (as_int(index) >= list_length(listInput) || frame->exitType == name_Break || frame->exitType == name_Return) { // Possibly truncate output list, in case any elements were discarded. if (enableLoopOutput) { caValue* outputIndex = get_frame_register(frame, for_loop_find_output_index(contents)); Term* outputPlaceholder = get_output_placeholder(contents, 0); caValue* outputList = get_frame_register(frame, outputPlaceholder); list_resize(outputList, as_int(outputIndex)); } else { Term* outputPlaceholder = get_output_placeholder(contents, 0); caValue* outputList = get_frame_register(frame, outputPlaceholder); set_list(outputList, 0); } finish_frame(stack); return; } // If we're not finished yet, copy rebound outputs back to inputs. for (int i=1;; i++) { Term* input = get_input_placeholder(contents, i); if (input == NULL) break; Term* output = get_output_placeholder(contents, i); copy(get_frame_register(frame, output), get_frame_register(frame, input)); INCREMENT_STAT(Copy_LoopCopyRebound); } // Return to start of loop body frame->pc = 0; frame->nextPc = 0; frame->exitType = name_None; }
int main(int argc, char *argv[]) { lprec *lp = NULL; char *filen, *wlp = NULL, *wmps = NULL, *wfmps = NULL, plp = FALSE; int i; int verbose = IMPORTANT /* CRITICAL */; int debug = -1; MYBOOL report = FALSE; MYBOOL nonames = FALSE, norownames = FALSE, nocolnames = FALSE; MYBOOL write_model_after = FALSE; MYBOOL noint = FALSE; int print_sol = -1; MYBOOL print_stats = FALSE; int floor_first = -1; MYBOOL do_set_bb_depthlimit = FALSE; int bb_depthlimit = 0; MYBOOL do_set_solutionlimit = FALSE; int solutionlimit = 0; MYBOOL break_at_first = FALSE; int scaling = 0; double scaleloop = 0; MYBOOL tracing = FALSE; short filetype = filetypeLP; int anti_degen1 = -1; int anti_degen2 = -1; short print_timing = FALSE; short parse_only = FALSE; int do_presolve = -1; short objective = 0; short PRINT_SOLUTION = 2; int improve = -1; int pivoting1 = -1; int pivoting2 = -1; int bb_rule1 = -1; int bb_rule2 = -1; int max_num_inv = -1; int scalemode1 = -1; int scalemode2 = -1; int crashmode = -1; char *guessbasis = NULL; /* short timeoutok = FALSE; */ double sectimeout = -1; int result; MYBOOL preferdual = AUTOMATIC; int simplextype = -1; MYBOOL do_set_obj_bound = FALSE; REAL obj_bound = 0; REAL mip_absgap = -1; REAL mip_relgap = -1; REAL epsperturb = -1; REAL epsint = -1; REAL epspivot = -1; REAL epsd = -1; REAL epsb = -1; REAL epsel = -1; MYBOOL do_set_break_at_value = FALSE; REAL break_at_value = 0; FILE *fpin = stdin; char *bfp = NULL; char *rxliname = NULL, *rxli = NULL, *rxlidata = NULL, *rxlioptions = NULL, *wxliname = NULL, *wxlisol = NULL, *wxli = NULL, *wxlioptions = NULL, *wxlisoloptions = NULL; char *rbasname = NULL, *wbasname = NULL; char *debugdump_before = NULL; char *debugdump_after = NULL; char *rparname = NULL; char *rparoptions = NULL; char *wparname = NULL; char *wparoptions = NULL; char obj_in_basis = -1; char mps_ibm = FALSE; char mps_negobjconst = FALSE; char mps_free = FALSE; MYBOOL ok; # define SCALINGTHRESHOLD 0.03 /* read command line arguments */ # if defined FORTIFY Fortify_EnterScope(); # endif for(i = 1; i < argc; i++) { ok = FALSE; if(strncmp(argv[i], "-v", 2) == 0) { if (argv[i][2]) verbose = atoi(argv[i] + 2); else verbose = NORMAL; } else if(strcmp(argv[i], "-d") == 0) debug = TRUE; else if(strcmp(argv[i], "-R") == 0) report = TRUE; else if(strcmp(argv[i], "-i") == 0) print_sol = TRUE; else if(strcmp(argv[i], "-ia") == 0) print_sol = AUTOMATIC; else if(strcmp(argv[i], "-stat") == 0) print_stats = TRUE; else if(strcmp(argv[i], "-nonames") == 0) nonames = TRUE; else if(strcmp(argv[i], "-norownames") == 0) norownames = TRUE; else if(strcmp(argv[i], "-nocolnames") == 0) nocolnames = TRUE; else if((strcmp(argv[i], "-c") == 0) || (strcmp(argv[i], "-cc") == 0)) floor_first = BRANCH_CEILING; else if(strcmp(argv[i], "-cf") == 0) floor_first = BRANCH_FLOOR; else if(strcmp(argv[i], "-ca") == 0) floor_first = BRANCH_AUTOMATIC; else if((strcmp(argv[i], "-depth") == 0) && (i + 1 < argc)) { do_set_bb_depthlimit = TRUE; bb_depthlimit = atoi(argv[++i]); } else if(strcmp(argv[i], "-Bw") == 0) or_value(&bb_rule2, NODE_WEIGHTREVERSEMODE); else if(strcmp(argv[i], "-Bb") == 0) or_value(&bb_rule2, NODE_BRANCHREVERSEMODE); else if(strcmp(argv[i], "-Bg") == 0) or_value(&bb_rule2, NODE_GREEDYMODE); else if(strcmp(argv[i], "-Bp") == 0) or_value(&bb_rule2, NODE_PSEUDOCOSTMODE); else if(strcmp(argv[i], "-BR") == 0) or_value(&bb_rule2, NODE_PSEUDORATIOSELECT); else if(strcmp(argv[i], "-Bf") == 0) or_value(&bb_rule2, NODE_DEPTHFIRSTMODE); else if(strcmp(argv[i], "-Br") == 0) or_value(&bb_rule2, NODE_RANDOMIZEMODE); else if(strcmp(argv[i], "-BG") == 0) or_value(&bb_rule2, 0 /* NODE_GUBMODE */); /* doesn't work yet */ else if(strcmp(argv[i], "-Bd") == 0) or_value(&bb_rule2, NODE_DYNAMICMODE); else if(strcmp(argv[i], "-Bs") == 0) or_value(&bb_rule2, NODE_RESTARTMODE); else if(strcmp(argv[i], "-BB") == 0) or_value(&bb_rule2, NODE_BREADTHFIRSTMODE); else if(strcmp(argv[i], "-Bo") == 0) or_value(&bb_rule2, NODE_AUTOORDER); else if(strcmp(argv[i], "-Bc") == 0) or_value(&bb_rule2, NODE_RCOSTFIXING); else if(strcmp(argv[i], "-Bi") == 0) or_value(&bb_rule2, NODE_STRONGINIT); else if(strncmp(argv[i], "-B", 2) == 0) { if (argv[i][2]) set_value(&bb_rule1, atoi(argv[i] + 2)); else set_value(&bb_rule1, NODE_FIRSTSELECT); } else if((strcmp(argv[i], "-n") == 0) && (i + 1 < argc)) { do_set_solutionlimit = TRUE; solutionlimit = atoi(argv[++i]); } else if((strcmp(argv[i], "-b") == 0) && (i + 1 < argc)) { obj_bound = atof(argv[++i]); do_set_obj_bound = TRUE; } else if(((strcmp(argv[i], "-g") == 0) || (strcmp(argv[i], "-ga") == 0)) && (i + 1 < argc)) mip_absgap = atof(argv[++i]); else if((strcmp(argv[i], "-gr") == 0) && (i + 1 < argc)) mip_relgap = atof(argv[++i]); else if((strcmp(argv[i], "-e") == 0) && (i + 1 < argc)) { epsint = atof(argv[++i]); if((epsint <= 0.0) || (epsint >= 0.5)) { fprintf(stderr, "Invalid tolerance %g; 0 < epsilon < 0.5\n", (double)epsint); EndOfPgr(FORCED_EXIT); } } else if((strcmp(argv[i], "-r") == 0) && (i + 1 < argc)) max_num_inv = atoi(argv[++i]); else if((strcmp(argv[i], "-o") == 0) && (i + 1 < argc)) { break_at_value = atof(argv[++i]); do_set_break_at_value = TRUE; } else if(strcmp(argv[i], "-f") == 0) break_at_first = TRUE; else if(strcmp(argv[i], "-timeoutok") == 0) /* timeoutok = TRUE */; /* option no longer needed, but still accepted */ else if(strcmp(argv[i], "-h") == 0) { print_help(argv); EndOfPgr(EXIT_SUCCESS); } else if(strcmp(argv[i], "-prim") == 0) preferdual = FALSE; else if(strcmp(argv[i], "-dual") == 0) preferdual = TRUE; else if(strcmp(argv[i], "-simplexpp") == 0) simplextype = SIMPLEX_PRIMAL_PRIMAL; else if(strcmp(argv[i], "-simplexdp") == 0) simplextype = SIMPLEX_DUAL_PRIMAL; else if(strcmp(argv[i], "-simplexpd") == 0) simplextype = SIMPLEX_PRIMAL_DUAL; else if(strcmp(argv[i], "-simplexdd") == 0) simplextype = SIMPLEX_DUAL_DUAL; else if(strcmp(argv[i], "-sp") == 0) or_value(&scalemode2, SCALE_POWER2); else if(strcmp(argv[i], "-si") == 0) or_value(&scalemode2, SCALE_INTEGERS); else if(strcmp(argv[i], "-se") == 0) or_value(&scalemode2, SCALE_EQUILIBRATE); else if(strncmp(argv[i], "-s", 2) == 0) { set_value(&scalemode1, SCALE_NONE); scaling = SCALE_MEAN; if (argv[i][2]) { switch (atoi(argv[i] + 2)) { case 0: scaling = SCALE_NONE; break; case 1: set_value(&scalemode1, SCALE_GEOMETRIC); break; case 2: set_value(&scalemode1, SCALE_CURTISREID); break; case 3: set_value(&scalemode1, SCALE_EXTREME); break; case 4: set_value(&scalemode1, SCALE_MEAN); break; case 5: set_value(&scalemode1, SCALE_MEAN | SCALE_LOGARITHMIC); break; case 6: set_value(&scalemode1, SCALE_RANGE); break; case 7: set_value(&scalemode1, SCALE_MEAN | SCALE_QUADRATIC); break; } } else set_value(&scalemode1, SCALE_MEAN); if((i + 1 < argc) && (isNum(argv[i + 1]))) scaleloop = atoi(argv[++i]); } else if(strncmp(argv[i], "-C", 2) == 0) crashmode = atoi(argv[i] + 2); else if((strcmp(argv[i],"-gbas") == 0) && (i + 1 < argc)) guessbasis = argv[++i]; else if(strcmp(argv[i], "-t") == 0) tracing = TRUE; else if(strncmp(argv[i], "-S", 2) == 0) { if (argv[i][2]) PRINT_SOLUTION = (short) atoi(argv[i] + 2); else PRINT_SOLUTION = 2; } else if(strncmp(argv[i], "-improve", 8) == 0) { if (argv[i][8]) or_value(&improve, atoi(argv[i] + 8)); } else if(strcmp(argv[i], "-pivll") == 0) or_value(&pivoting2, PRICE_LOOPLEFT); else if(strcmp(argv[i], "-pivla") == 0) or_value(&pivoting2, PRICE_LOOPALTERNATE); #if defined EnablePartialOptimization else if(strcmp(argv[i], "-pivpc") == 0) or_value(&pivoting2, PRICE_AUTOPARTIALCOLS); else if(strcmp(argv[i], "-pivpr") == 0) or_value(&pivoting2, PRICE_AUTOPARTIALROWS); else if(strcmp(argv[i], "-pivp") == 0) or_value(&pivoting2, PRICE_AUTOPARTIAL); #endif else if(strcmp(argv[i], "-pivf") == 0) or_value(&pivoting2, PRICE_PRIMALFALLBACK); else if(strcmp(argv[i], "-pivm") == 0) or_value(&pivoting2, PRICE_MULTIPLE); else if(strcmp(argv[i], "-piva") == 0) or_value(&pivoting2, PRICE_ADAPTIVE); else if(strcmp(argv[i], "-pivr") == 0) or_value(&pivoting2, PRICE_RANDOMIZE); else if(strcmp(argv[i], "-pivh") == 0) or_value(&pivoting2, PRICE_HARRISTWOPASS); else if(strcmp(argv[i], "-pivt") == 0) or_value(&pivoting2, PRICE_TRUENORMINIT); else if(strncmp(argv[i], "-piv", 4) == 0) { if (argv[i][4]) set_value(&pivoting1, atoi(argv[i] + 4)); else set_value(&pivoting1, PRICER_DEVEX | PRICE_ADAPTIVE); } #if defined PARSER_LP else if(strcmp(argv[i],"-lp") == 0) filetype = filetypeLP; #endif else if((strcmp(argv[i],"-wlp") == 0) && (i + 1 < argc)) wlp = argv[++i]; else if(strcmp(argv[i],"-plp") == 0) plp = TRUE; else if(strcmp(argv[i],"-mps") == 0) filetype = filetypeMPS; else if(strcmp(argv[i],"-mps_ibm") == 0) mps_ibm = TRUE; else if(strcmp(argv[i],"-mps_negobjconst") == 0) mps_negobjconst = TRUE; else if(strcmp(argv[i],"-mps_free") == 0) mps_free = TRUE; else if(strcmp(argv[i],"-fmps") == 0) filetype = filetypeFREEMPS; else if((strcmp(argv[i],"-wmps") == 0) && (i + 1 < argc)) wmps = argv[++i]; else if((strcmp(argv[i],"-wfmps") == 0) && (i + 1 < argc)) wfmps = argv[++i]; else if(strcmp(argv[i],"-wafter") == 0) write_model_after = TRUE; else if(strcmp(argv[i],"-degen") == 0) set_value(&anti_degen1, ANTIDEGEN_DEFAULT); else if(strcmp(argv[i],"-degenf") == 0) or_value(&anti_degen2, ANTIDEGEN_FIXEDVARS); else if(strcmp(argv[i],"-degenc") == 0) or_value(&anti_degen2, ANTIDEGEN_COLUMNCHECK); else if(strcmp(argv[i],"-degens") == 0) or_value(&anti_degen2, ANTIDEGEN_STALLING); else if(strcmp(argv[i],"-degenn") == 0) or_value(&anti_degen2, ANTIDEGEN_NUMFAILURE); else if(strcmp(argv[i],"-degenl") == 0) or_value(&anti_degen2, ANTIDEGEN_LOSTFEAS); else if(strcmp(argv[i],"-degeni") == 0) or_value(&anti_degen2, ANTIDEGEN_INFEASIBLE); else if(strcmp(argv[i],"-degend") == 0) or_value(&anti_degen2, ANTIDEGEN_DYNAMIC); else if(strcmp(argv[i],"-degenb") == 0) or_value(&anti_degen2, ANTIDEGEN_DURINGBB); else if(strcmp(argv[i],"-degenr") == 0) or_value(&anti_degen2, ANTIDEGEN_RHSPERTURB); else if(strcmp(argv[i],"-degenp") == 0) or_value(&anti_degen2, ANTIDEGEN_BOUNDFLIP); else if(strcmp(argv[i],"-time") == 0) { if(clock() == -1) fprintf(stderr, "CPU times not available on this machine\n"); else print_timing = TRUE; } else if((strcmp(argv[i],"-bfp") == 0) && (i + 1 < argc)) bfp = argv[++i]; else if((strcmp(argv[i],"-rxli") == 0) && (i + 2 < argc)) { rxliname = argv[++i]; rxli = argv[++i]; fpin = NULL; filetype = filetypeXLI; } else if((strcmp(argv[i],"-rxlidata") == 0) && (i + 1 < argc)) rxlidata = argv[++i]; else if((strcmp(argv[i],"-rxliopt") == 0) && (i + 1 < argc)) rxlioptions = argv[++i]; else if((strcmp(argv[i],"-wxli") == 0) && (i + 2 < argc)) { wxliname = argv[++i]; wxli = argv[++i]; } else if((strcmp(argv[i],"-wxliopt") == 0) && (i + 1 < argc)) wxlioptions = argv[++i]; else if((strcmp(argv[i],"-wxlisol") == 0) && (i + 2 < argc)) { wxliname = argv[++i]; wxlisol = argv[++i]; } else if((strcmp(argv[i],"-wxlisolopt") == 0) && (i + 1 < argc)) wxlisoloptions = argv[++i]; else if((strcmp(argv[i],"-rbas") == 0) && (i + 1 < argc)) rbasname = argv[++i]; else if((strcmp(argv[i],"-wbas") == 0) && (i + 1 < argc)) wbasname = argv[++i]; else if((strcmp(argv[i],"-Db") == 0) && (i + 1 < argc)) debugdump_before = argv[++i]; else if((strcmp(argv[i],"-Da") == 0) && (i + 1 < argc)) debugdump_after = argv[++i]; else if((strcmp(argv[i],"-timeout") == 0) && (i + 1 < argc)) sectimeout = atof(argv[++i]); else if((strcmp(argv[i],"-trej") == 0) && (i + 1 < argc)) epspivot = atof(argv[++i]); else if((strcmp(argv[i],"-epsp") == 0) && (i + 1 < argc)) epsperturb = atof(argv[++i]); else if((strcmp(argv[i],"-epsd") == 0) && (i + 1 < argc)) epsd = atof(argv[++i]); else if((strcmp(argv[i],"-epsb") == 0) && (i + 1 < argc)) epsb = atof(argv[++i]); else if((strcmp(argv[i],"-epsel") == 0) && (i + 1 < argc)) epsel = atof(argv[++i]); else if(strcmp(argv[i],"-parse_only") == 0) parse_only = TRUE; else ok = TRUE; if(!ok) ; else if(strcmp(argv[i],"-presolverow") == 0) or_value(&do_presolve, PRESOLVE_ROWS); else if(strcmp(argv[i],"-presolvecol") == 0) or_value(&do_presolve, PRESOLVE_COLS); else if(strcmp(argv[i],"-presolve") == 0) or_value(&do_presolve, PRESOLVE_ROWS | PRESOLVE_COLS); else if(strcmp(argv[i],"-presolvel") == 0) or_value(&do_presolve, PRESOLVE_LINDEP); else if(strcmp(argv[i],"-presolves") == 0) or_value(&do_presolve, PRESOLVE_SOS); else if(strcmp(argv[i],"-presolver") == 0) or_value(&do_presolve, PRESOLVE_REDUCEMIP); else if(strcmp(argv[i],"-presolvek") == 0) or_value(&do_presolve, PRESOLVE_KNAPSACK); else if(strcmp(argv[i],"-presolveq") == 0) or_value(&do_presolve, PRESOLVE_ELIMEQ2); else if(strcmp(argv[i],"-presolvem") == 0) or_value(&do_presolve, PRESOLVE_MERGEROWS); else if(strcmp(argv[i],"-presolvefd") == 0) or_value(&do_presolve, PRESOLVE_COLFIXDUAL); else if(strcmp(argv[i],"-presolvebnd") == 0) or_value(&do_presolve, PRESOLVE_BOUNDS); else if(strcmp(argv[i],"-presolved") == 0) or_value(&do_presolve, PRESOLVE_DUALS); else if(strcmp(argv[i],"-presolvef") == 0) or_value(&do_presolve, PRESOLVE_IMPLIEDFREE); else if(strcmp(argv[i],"-presolveslk") == 0) or_value(&do_presolve, PRESOLVE_IMPLIEDSLK); else if(strcmp(argv[i],"-presolveg") == 0) or_value(&do_presolve, PRESOLVE_REDUCEGCD); else if(strcmp(argv[i],"-presolveb") == 0) or_value(&do_presolve, PRESOLVE_PROBEFIX); else if(strcmp(argv[i],"-presolvec") == 0) or_value(&do_presolve, PRESOLVE_PROBEREDUCE); else if(strcmp(argv[i],"-presolverowd") == 0) or_value(&do_presolve, PRESOLVE_ROWDOMINATE); else if(strcmp(argv[i],"-presolvecold") == 0) or_value(&do_presolve, PRESOLVE_COLDOMINATE); else if(strcmp(argv[i],"-min") == 0) objective = -1; else if(strcmp(argv[i],"-max") == 0) objective = 1; else if(strcmp(argv[i],"-noint") == 0) noint = TRUE; else if((strcmp(argv[i],"-rpar") == 0) && (i + 1 < argc)) i++; else if((strcmp(argv[i],"-rparopt") == 0) && (i + 1 < argc)) i++; else if((strcmp(argv[i],"-wpar") == 0) && (i + 1 < argc)) i++; else if((strcmp(argv[i],"-wparopt") == 0) && (i + 1 < argc)) i++; else if(strcmp(argv[i],"-o0") == 0) obj_in_basis = FALSE; else if(strcmp(argv[i],"-o1") == 0) obj_in_basis = TRUE; else if(fpin == stdin) { filen = argv[i]; if(*filen == '<') filen++; if((fpin = fopen(filen, "r")) == NULL) { print_help(argv); fprintf(stderr,"\nError, Unable to open input file '%s'\n", argv[i]); EndOfPgr(FORCED_EXIT); } } else { filen = argv[i]; if(*filen != '>') { print_help(argv); fprintf(stderr, "\nError, Unrecognized command line argument '%s'\n", argv[i]); EndOfPgr(FORCED_EXIT); } } } signal(SIGABRT,/* (void (*) OF((int))) */ SIGABRT_func); if ((filetype != filetypeXLI) && (fpin == NULL)) { lp = NULL; fprintf(stderr, "Cannot combine -rxli option with -lp, -mps, -fmps.\n"); } else { switch(filetype) { #if defined PARSER_LP case filetypeLP: lp = read_lp(fpin, verbose, NULL); break; #endif case filetypeMPS: lp = read_mps(fpin, verbose | (mps_free ? MPS_FREE : 0) | (mps_ibm ? MPS_IBM : 0) | (mps_negobjconst ? MPS_NEGOBJCONST : 0)); break; case filetypeFREEMPS: lp = read_freemps(fpin, verbose | (mps_ibm ? MPS_IBM : 0) | (mps_negobjconst ? MPS_NEGOBJCONST : 0)); break; case filetypeXLI: lp = read_XLI(rxliname, rxli, rxlidata, rxlioptions, verbose); break; } } if((fpin != NULL) && (fpin != stdin)) fclose(fpin); if(print_timing) print_cpu_times("Parsing input"); if(lp == NULL) { fprintf(stderr, "Unable to read model.\n"); EndOfPgr(FORCED_EXIT); } for(i = 1; i < argc; i++) { if((strcmp(argv[i],"-rpar") == 0) && (i + 1 < argc)) { if(rparname != NULL) { if(!read_params(lp, rparname, rparoptions)) { fprintf(stderr, "Unable to read parameter file (%s)\n", rparname); delete_lp(lp); EndOfPgr(FORCED_EXIT); } } rparname = argv[++i]; } else if((strcmp(argv[i],"-rparopt") == 0) && (i + 1 < argc)) rparoptions = argv[++i]; else if((strcmp(argv[i],"-wpar") == 0) && (i + 1 < argc)) wparname = argv[++i]; else if((strcmp(argv[i],"-wparopt") == 0) && (i + 1 < argc)) wparoptions = argv[++i]; } if(rparname != NULL) if(!read_params(lp, rparname, rparoptions)) { fprintf(stderr, "Unable to read parameter file (%s)\n", rparname); delete_lp(lp); EndOfPgr(FORCED_EXIT); } if((nonames) || (nocolnames)) set_use_names(lp, FALSE, FALSE); if((nonames) || (norownames)) set_use_names(lp, TRUE, FALSE); if(objective != 0) { if(objective == 1) set_maxim(lp); else set_minim(lp); } if (obj_in_basis != -1) set_obj_in_basis(lp, obj_in_basis); if(noint) { /* remove integer conditions */ for(i = get_Ncolumns(lp); i >= 1; i--) { if(is_SOS_var(lp, i)) { fprintf(stderr, "Unable to remove integer conditions because there is at least one SOS constraint\n"); delete_lp(lp); EndOfPgr(FORCED_EXIT); } set_semicont(lp, i, FALSE); set_int(lp, i, FALSE); } } if(!write_model_after) write_model(lp, plp, wlp, wmps, wfmps, wxli, NULL, wxliname, wxlioptions); if(print_stats) print_statistics(lp); if(parse_only) { if(!write_model_after) { delete_lp(lp); EndOfPgr(0); } /* else if(!sectimeout) */ sectimeout = 1; } if(PRINT_SOLUTION >= 5) print_lp(lp); #if 0 put_abortfunc(lp,(abortfunc *) myabortfunc, NULL); #endif if(sectimeout > 0.) set_timeout(lp, sectimeout); if(print_sol >= 0) set_print_sol(lp, print_sol); if(epsint >= 0) set_epsint(lp, epsint); if(epspivot >= 0) set_epspivot(lp, epspivot); if(epsperturb >= 0) set_epsperturb(lp, epsperturb); if(epsd >= 0) set_epsd(lp, epsd); if(epsb >= 0) set_epsb(lp, epsb); if(epsel >= 0) set_epsel(lp, epsel); if(debug >= 0) set_debug(lp, (MYBOOL) debug); if(floor_first != -1) set_bb_floorfirst(lp, floor_first); if(do_set_bb_depthlimit) set_bb_depthlimit(lp, bb_depthlimit); if(do_set_solutionlimit) set_solutionlimit(lp, solutionlimit); if(tracing) set_trace(lp, tracing); if(do_set_obj_bound) set_obj_bound(lp, obj_bound); if(do_set_break_at_value) set_break_at_value(lp, break_at_value); if(break_at_first) set_break_at_first(lp, break_at_first); if(mip_absgap >= 0) set_mip_gap(lp, TRUE, mip_absgap); if(mip_relgap >= 0) set_mip_gap(lp, FALSE, mip_relgap); if((anti_degen1 != -1) || (anti_degen2 != -1)) { if((anti_degen1 == -1) || (anti_degen2 != -1)) anti_degen1 = 0; if(anti_degen2 == -1) anti_degen2 = 0; set_anti_degen(lp, anti_degen1 | anti_degen2); } set_presolve(lp, ((do_presolve == -1) ? get_presolve(lp): do_presolve) | ((PRINT_SOLUTION >= 4) ? PRESOLVE_SENSDUALS : 0), get_presolveloops(lp)); if(improve != -1) set_improve(lp, improve); if(max_num_inv >= 0) set_maxpivot(lp, max_num_inv); if(preferdual != AUTOMATIC) set_preferdual(lp, preferdual); if((pivoting1 != -1) || (pivoting2 != -1)) { if(pivoting1 == -1) pivoting1 = get_pivoting(lp) & PRICER_LASTOPTION; if(pivoting2 == -1) pivoting2 = 0; set_pivoting(lp, pivoting1 | pivoting2); } if((scalemode1 != -1) || (scalemode2 != -1)) { if(scalemode1 == -1) scalemode1 = get_scaling(lp) & SCALE_CURTISREID; if(scalemode2 == -1) scalemode2 = 0; set_scaling(lp, scalemode1 | scalemode2); } if(crashmode != -1) set_basiscrash(lp, crashmode); if((bb_rule1 != -1) || (bb_rule2 != -1)) { if(bb_rule1 == -1) bb_rule1 = get_bb_rule(lp) & NODE_USERSELECT; if(bb_rule2 == -1) bb_rule2 = 0; set_bb_rule(lp, bb_rule1 | bb_rule2); } if(simplextype != -1) set_simplextype(lp, simplextype); if(bfp != NULL) if(!set_BFP(lp, bfp)) { fprintf(stderr, "Unable to set BFP package.\n"); delete_lp(lp); EndOfPgr(FORCED_EXIT); } if(debugdump_before != NULL) print_debugdump(lp, debugdump_before); if(report) put_msgfunc(lp, LPMessageCB, NULL, MSG_LPFEASIBLE | MSG_LPOPTIMAL | MSG_MILPFEASIBLE | MSG_MILPBETTER | MSG_PERFORMANCE); if(scaling) { if(scaleloop <= 0) scaleloop = 5; if(scaleloop - (int) scaleloop < SCALINGTHRESHOLD) scaleloop = (int) scaleloop + SCALINGTHRESHOLD; set_scalelimit(lp, scaleloop); } if(guessbasis != NULL) { REAL *guessvector, a; int *basisvector; int Nrows = get_Nrows(lp); int Ncolumns = get_Ncolumns(lp); int col; char buf[50], *ptr; FILE *fp; if ((fp = fopen(guessbasis, "r")) != NULL) { guessvector = (REAL *) calloc(1+Ncolumns, sizeof(*guessvector)); basisvector = (int *) malloc((1+Nrows+Ncolumns)*sizeof(*basisvector)); if ((guessvector != NULL) && (basisvector != NULL)) { while ((!feof(fp)) && (fgets(buf, sizeof(buf), fp) != NULL)) { ptr = strrchr(buf, ':'); if (ptr == NULL) { printf("Mallformed line: %s\n", buf); } else { a = atof(ptr + 1); while ((ptr > buf) && (isspace(ptr[-1]))) ptr--; *ptr = 0; col = get_nameindex(lp, buf, FALSE); if (col < 1) printf("guess_basis: Unknown variable name %s\n", buf); else guessvector[col] = a; } } if (guess_basis(lp, guessvector, basisvector)) { if (!set_basis(lp, basisvector, TRUE)) printf("Unable to set guessed basis.\n"); } else printf("Unable to guess basis from provided variables.\n"); } else printf("guess_basis: Out of memory.\n"); if (basisvector != NULL) free(basisvector); if (guessvector != NULL) free(guessvector); fclose(fp); } else printf("Unable to open file %s\n", guessbasis); } if(rbasname != NULL) if(!read_basis(lp, rbasname, NULL)) { fprintf(stderr, "Unable to read basis file.\n"); delete_lp(lp); EndOfPgr(FORCED_EXIT); } result = solve(lp); if(wbasname != NULL) if(!write_basis(lp, wbasname)) fprintf(stderr, "Unable to write basis file.\n"); if(write_model_after) write_model(lp, plp, wlp, wmps, wfmps, wxli, NULL, wxliname, wxlioptions); write_model(lp, FALSE, NULL, NULL, NULL, NULL, wxlisol, wxliname, wxlisoloptions); if(PRINT_SOLUTION >= 6) print_scales(lp); if((print_timing) && (!parse_only)) print_cpu_times("solving"); if(debugdump_after != NULL) print_debugdump(lp, debugdump_after); if(wparname != NULL) if(!write_params(lp, wparname, wparoptions)) { fprintf(stderr, "Unable to write parameter file (%s)\n", wparname); delete_lp(lp); EndOfPgr(FORCED_EXIT); } if(parse_only) { delete_lp(lp); EndOfPgr(0); } /* if((timeoutok) && (result == TIMEOUT) && (get_solutioncount(lp) > 0)) result = OPTIMAL; */ switch(result) { case SUBOPTIMAL: case PRESOLVED: case OPTIMAL: case PROCBREAK: case FEASFOUND: if ((result == SUBOPTIMAL) && (PRINT_SOLUTION >= 1)) printf("Suboptimal solution\n"); if (result == PRESOLVED) printf("Presolved solution\n"); if (PRINT_SOLUTION >= 1) print_objective(lp); if (PRINT_SOLUTION >= 2) print_solution(lp, 1); if (PRINT_SOLUTION >= 3) print_constraints(lp, 1); if (PRINT_SOLUTION >= 4) print_duals(lp); if(tracing) fprintf(stderr, "Branch & Bound depth: %d\nNodes processed: %.0f\nSimplex pivots: %.0f\nNumber of equal solutions: %d\n", get_max_level(lp), (REAL) get_total_nodes(lp), (REAL) get_total_iter(lp), get_solutioncount(lp)); break; case NOMEMORY: if (PRINT_SOLUTION >= 1) printf("Out of memory\n"); break; case INFEASIBLE: if (PRINT_SOLUTION >= 1) printf("This problem is infeasible\n"); break; case UNBOUNDED: if (PRINT_SOLUTION >= 1) printf("This problem is unbounded\n"); break; case PROCFAIL: if (PRINT_SOLUTION >= 1) printf("The B&B routine failed\n"); break; case TIMEOUT: if (PRINT_SOLUTION >= 1) printf("Timeout\n"); break; case USERABORT: if (PRINT_SOLUTION >= 1) printf("User aborted\n"); break; default: if (PRINT_SOLUTION >= 1) printf("lp_solve failed\n"); break; } if (PRINT_SOLUTION >= 7) print_tableau(lp); delete_lp(lp); EndOfPgr(result); return(result); }
int do_exec(task_t *t, char *path, char **argv, char **env) { unsigned int i=0; addr_t end, eip; unsigned int argc=0, envc=0; int desc; char **backup_argv=0, **backup_env=0; /* Sanity */ if(!t) panic(PANIC_NOSYNC, "Tried to execute with empty task"); if(t == kernel_task) panic(0, "Kernel is being executed at the gallows!"); if(t != current_task) panic(0, "I don't know, was really drunk at the time"); if(t->magic != TASK_MAGIC) panic(0, "Invalid task in exec (%d)", t->pid); if(!path || !*path) return -EINVAL; /* Load the file, and make sure that it is valid and accessable */ if(EXEC_LOG == 2) printk(0, "[%d]: Checking executable file (%s)\n", t->pid, path); struct file *efil; int err_open, num; efil=d_sys_open(path, O_RDONLY, 0, &err_open, &num); if(efil) desc = num; else desc = err_open; if(desc < 0 || !efil) return -ENOENT; if(!permissions(efil->inode, MAY_EXEC)) { sys_close(desc); return -EACCES; } /* Detirmine if the file is a valid ELF */ int header_size = 0; #if CONFIG_ARCH == TYPE_ARCH_X86_64 header_size = sizeof(elf64_header_t); #elif CONFIG_ARCH == TYPE_ARCH_X86 header_size = sizeof(elf32_header_t); #endif char mem[header_size]; read_data(desc, mem, 0, header_size); int other_bitsize=0; #if CONFIG_ARCH == TYPE_ARCH_X86_64 if(is_valid_elf32_otherarch(mem, 2)) other_bitsize = 1; #endif if(!is_valid_elf(mem, 2) && !other_bitsize) { sys_close(desc); return -ENOEXEC; } if(EXEC_LOG == 2) printk(0, "[%d]: Copy data\n", t->pid); /* okay, lets back up argv and env so that we can * clear out the address space and not lose data..*/ if(__is_valid_user_ptr(SYS_EXECVE, argv, 0)) { while(__is_valid_user_ptr(SYS_EXECVE, argv[argc], 0) && *argv[argc]) argc++; backup_argv = (char **)kmalloc(sizeof(addr_t) * argc); for(i=0;i<argc;i++) { backup_argv[i] = (char *)kmalloc(strlen(argv[i]) + 1); _strcpy(backup_argv[i], argv[i]); } } if(__is_valid_user_ptr(SYS_EXECVE, env, 0)) { while(__is_valid_user_ptr(SYS_EXECVE, env[envc], 0) && *env[envc]) envc++; backup_env = (char **)kmalloc(sizeof(addr_t) * envc); for(i=0;i<envc;i++) { backup_env[i] = (char *)kmalloc(strlen(env[i]) + 1); _strcpy(backup_env[i], env[i]); } } /* and the path too! */ char *path_backup = (char *)kmalloc(strlen(path) + 1); _strcpy((char *)path_backup, path); path = path_backup; if(pd_cur_data->count > 1) printk(0, "[exec]: Not sure what to do here...\n"); /* Preexec - This is the point of no return. Here we close out unneeded * file descs, free up the page directory and clear up the resources * of the task */ if(EXEC_LOG) printk(0, "Executing (task %d, cpu %d, tty %d, cwd=%s): %s\n", t->pid, ((cpu_t *)t->cpu)->apicid, t->tty, current_task->thread->pwd->name, path); preexec(t, desc); strncpy((char *)t->command, path, 128); if(other_bitsize) { #if CONFIG_ARCH == TYPE_ARCH_X86_64 if(!process_elf_other(mem, desc, &eip, &end)) eip=0; #endif } else if(!process_elf(mem, desc, &eip, &end)) eip=0; sys_close(desc); if(!eip) { printk(5, "[exec]: Tried to execute an invalid ELF file!\n"); free_dp(backup_argv, argc); free_dp(backup_env, envc); #if DEBUG panic(0, ""); #endif exit(0); } if(EXEC_LOG == 2) printk(0, "[%d]: Updating task values\n", t->pid); /* Setup the task with the proper values (libc malloc stack) */ addr_t end_l = end; end = (end&PAGE_MASK); user_map_if_not_mapped_noclear(end); /* now we need to copy back the args and env into userspace * writeable memory...yippie. */ addr_t args_start = end + PAGE_SIZE; addr_t env_start = args_start; addr_t alen = 0; if(backup_argv) { for(i=0;i<(sizeof(addr_t) * (argc+1))/PAGE_SIZE + 2;i++) user_map_if_not_mapped_noclear(args_start + i * PAGE_SIZE); memcpy((void *)args_start, backup_argv, sizeof(addr_t) * argc); alen += sizeof(addr_t) * argc; *(addr_t *)(args_start + alen) = 0; /* set last argument value to zero */ alen += sizeof(addr_t); argv = (char **)args_start; for(i=0;i<argc;i++) { char *old = argv[i]; char *new = (char *)(args_start+alen); user_map_if_not_mapped_noclear((addr_t)new); unsigned len = strlen(old) + 4; user_map_if_not_mapped_noclear((addr_t)new + len + 1); argv[i] = new; _strcpy(new, old); kfree(old); alen += len; } kfree(backup_argv); } env_start = args_start + alen; alen = 0; if(backup_env) { for(i=0;i<(((sizeof(addr_t) * (envc+1))/PAGE_SIZE) + 2);i++) user_map_if_not_mapped_noclear(env_start + i * PAGE_SIZE); memcpy((void *)env_start, backup_env, sizeof(addr_t) * envc); alen += sizeof(addr_t) * envc; *(addr_t *)(env_start + alen) = 0; /* set last argument value to zero */ alen += sizeof(addr_t); env = (char **)env_start; for(i=0;i<envc;i++) { char *old = env[i]; char *new = (char *)(env_start+alen); user_map_if_not_mapped_noclear((addr_t)new); unsigned len = strlen(old) + 1; user_map_if_not_mapped_noclear((addr_t)new + len + 1); env[i] = new; _strcpy(new, old); kfree(old); alen += len; } kfree(backup_env); } end = (env_start + alen) & PAGE_MASK; t->env = env; t->argv = argv; kfree(path); t->heap_start = t->heap_end = end + PAGE_SIZE; if(other_bitsize) raise_task_flag(t, TF_OTHERBS); user_map_if_not_mapped_noclear(t->heap_start); /* Zero the heap and stack */ memset((void *)end_l, 0, PAGE_SIZE-(end_l%PAGE_SIZE)); memset((void *)(end+PAGE_SIZE), 0, PAGE_SIZE); memset((void *)(STACK_LOCATION - STACK_SIZE), 0, STACK_SIZE); /* Release everything */ if(EXEC_LOG == 2) printk(0, "[%d]: Performing call\n", t->pid); set_int(0); lower_task_flag(t, TF_SCHED); if(!(kernel_state_flags & KSF_HAVEEXECED)) set_ksf(KSF_HAVEEXECED); arch_specific_exec_initializer(t, argc, eip); return 0; }
/* * Parse the generator output. Find the generators which are vertices * (non-rays) add their corresponding inequalities to an output set. * * Returns a matrix where each row contains the x-coordinate of the vertex, * y-coordinate of the vertex, and 0-based index of the inequality which bounds * the polytope to the right of the vertex. output_size is set to the total * length of the ouptut. */ static double *list_extreme_vertices(const dd_MatrixPtr generators, const dd_SetFamilyPtr incidence, const size_t nrows, long lower_bound_index, /*OUT*/ size_t * output_size) { assert(generators->rowsize > 0); assert(generators->colsize > 2); set_type cur_vert_set, next_vert_set, s; dd_rowrange i; long elem; size_t out_row = 0, r; size_t vertex_count = count_vertices(generators); /* Last vertex intersects with upper bound - not output */ *output_size = 3 * (vertex_count - 1); double *output = (double *) malloc(sizeof(double) * (*output_size)); /* Sorted indices into generators */ size_t *indices = sort_generators(generators); assert(*output_size > 0); /* Loop over vertices in generators, extracting solutions * * For vertices 0..n_vertices-2, find the inequality incident to the vertex * also incident in the next vertex. */ for (i = 0; i < vertex_count - 1; i++) { r = indices[i]; assert(is_vertex(generators->matrix[r][0])); assert(is_vertex(generators->matrix[indices[i + 1]][0])); assert(out_row < vertex_count - 1); cur_vert_set = incidence->set[r]; next_vert_set = incidence->set[indices[i + 1]]; /* Sets should be same size */ assert(cur_vert_set[0] == next_vert_set[0]); set_initialize(&s, cur_vert_set[0]); set_int(s, cur_vert_set, next_vert_set); /* Remove added index for first item */ /*if (!i)*/ /*set_delelem(s, lower_bound_index);*/ /* Set may have > 1 solution if ~identical slopes and intercepts due to * rounding. */ /*assert(set_card(s) == 1); */ /* Only one item in the set */ elem = set_first(s); set_free(s); /* Fill output row */ int base = out_row * 3; output[base] = *generators->matrix[r][1]; /* x */ output[base + 1] = *generators->matrix[r][2]; /* y */ output[base + 2] = (double) (elem - 1); /* ineq index, converted to 0-base */ out_row++; } free(indices); return output; }
int real_main(int argc, char *argv[]) { int ret=1; int option=0; int daemon=1; int forking=1; int strip=0; int randomise=0; struct lock *lock=NULL; struct conf **confs=NULL; int forceoverwrite=0; enum action act=ACTION_LIST; const char *backup=NULL; const char *backup2=NULL; char *restoreprefix=NULL; const char *regex=NULL; const char *browsefile=NULL; char *browsedir=NULL; const char *conffile=get_conf_path(); const char *orig_client=NULL; const char *logfile=NULL; // The orig_client is the original client that the normal client // would like to restore from. #ifndef HAVE_WIN32 int generate_ca_only=0; #endif int vss_restore=1; int test_confs=0; enum burp_mode mode; log_init(argv[0]); #ifndef HAVE_WIN32 if(!strcmp(prog, "bedup")) return run_bedup(argc, argv); if(!strcmp(prog, "bsigs")) return run_bsigs(argc, argv); #endif while((option=getopt(argc, argv, "a:b:c:C:d:fFghil:nq:r:s:tvxjz:?"))!=-1) { switch(option) { case 'a': if(parse_action(&act, optarg)) goto end; break; case 'b': // The diff command may have two backups // specified. if(!backup2 && backup) backup2=optarg; if(!backup) backup=optarg; break; case 'c': conffile=optarg; break; case 'C': orig_client=optarg; break; case 'd': restoreprefix=optarg; // for restores browsedir=optarg; // for lists break; case 'f': forceoverwrite=1; break; case 'F': daemon=0; break; case 'g': #ifndef HAVE_WIN32 generate_ca_only=1; #endif break; case 'i': cmd_print_all(); ret=0; goto end; case 'l': logfile=optarg; break; case 'n': forking=0; break; case 'q': randomise=atoi(optarg); break; case 'r': regex=optarg; break; case 's': strip=atoi(optarg); break; case 'v': printf("%s-%s\n", progname(), VERSION); ret=0; goto end; case 'x': vss_restore=0; break; case 't': test_confs=1; break; case 'z': browsefile=optarg; break; case 'h': case '?': default: usage(); goto end; } } if(optind<argc) { usage(); goto end; } if(act==ACTION_MONITOR) { // Try to output everything in JSON. log_set_json(1); #ifndef HAVE_WIN32 // Need to do this so that processes reading stdout get the // result of the printfs of logp straight away. setlinebuf(stdout); #endif } if(!(confs=confs_alloc())) goto end; if(reload(confs, conffile, 1 /* first time */, 0 /* no oldmax_children setting */, 0 /* no oldmax_status_children setting */)) goto end; // Dry run to test config file syntax. if(test_confs) { ret=run_test_confs(confs, orig_client, conffile); goto end; } if(!backup) switch(act) { case ACTION_DELETE: logp("No backup specified for deletion.\n"); goto end; case ACTION_RESTORE: case ACTION_VERIFY: case ACTION_DIFF: case ACTION_DIFF_LONG: logp("No backup specified. Using the most recent.\n"); backup="0"; default: break; } if(!backup2) switch(act) { case ACTION_DIFF: case ACTION_DIFF_LONG: logp("No second backup specified. Using file system scan.\n"); backup2="n"; // For 'next'. default: break; } // The logfile option is only used for the status client stuff. if(logfile && (act!=ACTION_STATUS && act!=ACTION_STATUS_SNAPSHOT)) logp("-l <logfile> option obsoleted\n"); if(orig_client && *orig_client && set_string(confs[OPT_ORIG_CLIENT], orig_client)) goto end; // The random delay needs to happen before the lock is got, otherwise // you would never be able to use burp by hand. if(randomise) set_int(confs[OPT_RANDOMISE], randomise); mode=get_e_burp_mode(confs[OPT_BURP_MODE]); if(mode==BURP_MODE_CLIENT && (act==ACTION_BACKUP_TIMED || act==ACTION_TIMER_CHECK)) random_delay(confs); if(mode==BURP_MODE_SERVER && act==ACTION_CHAMP_CHOOSER) { // These server modes need to run without getting the lock. } else if(mode==BURP_MODE_CLIENT && (act==ACTION_LIST || act==ACTION_LIST_LONG || act==ACTION_DIFF || act==ACTION_DIFF_LONG || act==ACTION_STATUS || act==ACTION_STATUS_SNAPSHOT || act==ACTION_MONITOR)) { // These client modes need to run without getting the lock. } else { const char *lockfile=confs_get_lockfile(confs); if(!(lock=lock_alloc_and_init(lockfile))) goto end; lock_get(lock); switch(lock->status) { case GET_LOCK_GOT: break; case GET_LOCK_NOT_GOT: logp("Could not get lockfile.\n"); logp("Another process is probably running,\n"); goto end; case GET_LOCK_ERROR: default: logp("Could not get lockfile.\n"); logp("Maybe you do not have permissions to write to %s.\n", lockfile); goto end; } } set_int(confs[OPT_OVERWRITE], forceoverwrite); set_int(confs[OPT_STRIP], strip); set_int(confs[OPT_FORK], forking); set_int(confs[OPT_DAEMON], daemon); strip_trailing_slashes(&restoreprefix); strip_trailing_slashes(&browsedir); if(replace_conf_str(confs[OPT_BACKUP], backup) || replace_conf_str(confs[OPT_BACKUP2], backup2) || replace_conf_str(confs[OPT_RESTOREPREFIX], restoreprefix) || replace_conf_str(confs[OPT_REGEX], regex) || replace_conf_str(confs[OPT_BROWSEFILE], browsefile) || replace_conf_str(confs[OPT_BROWSEDIR], browsedir) || replace_conf_str(confs[OPT_MONITOR_LOGFILE], logfile)) goto end; base64_init(); hexmap_init(); if(mode==BURP_MODE_SERVER) { #ifdef HAVE_WIN32 logp("Sorry, server mode is not implemented for Windows.\n"); #else ret=server_modes(act, conffile, lock, generate_ca_only, confs); #endif } else { ret=client(confs, act, vss_restore); } end: lock_release(lock); lock_free(&lock); confs_free(&confs); return ret; }
void floor(caStack* stack) { set_int(circa_output(stack, 0), (int) std::floor(circa_float_input(stack, 0))); }
void ceil(caStack* stack) { set_int(circa_output(stack, 0), (int) std::ceil(circa_float_input(stack, 0))); }
void remainder_i(caStack* stack) { set_int(circa_output(stack, 0), circa_int_input(stack, 0) % circa_int_input(stack, 1)); }
void min_i(caStack* stack) { set_int(circa_output(stack, 0), std::min(circa_int_input(stack, 0), circa_int_input(stack, 1))); }
void pow(caStack* stack) { set_int(circa_output(stack, 0), (int) std::pow((float) circa_int_input(stack, 0), circa_int_input(stack, 1))); }
void set (char *command_line) { unsigned short *int_ptr; unsigned char *char_ptr; unsigned long *long_ptr,offset=0; int i,len, found=0; char *ptr,buffer [80],variable [80],value [80]; if (device_handle==NULL) { wprintw (command_win,"Error - No device opened\n");refresh_command_win (); return; } if (current_type==NULL) { hex_set (command_line); return; } ptr=parse_word (command_line,buffer); if (ptr==NULL || *ptr==0) { wprintw (command_win,"Error - Missing arguments\n");refresh_command_win (); return; } parse_word (ptr,buffer); ptr=strchr (buffer,'='); if (ptr==NULL) { wprintw (command_win,"Error - Bad syntax\n");refresh_command_win ();return; } strncpy (variable,buffer,ptr-buffer);variable [ptr-buffer]=0; strcpy (value,++ptr); if (current_type==NULL) { wprintw (command_win,"Sorry, not yet supported\n");refresh_command_win ();return; } for (i=0;i<current_type->fields_num && !found;i++) { if (strcmp (current_type->field_names [i],variable)==0) { found=1; ptr=type_data.u.buffer+offset; len = current_type->field_lengths [i]; switch (current_type->field_types [i]) { case FIELD_TYPE_INT: set_int(len, ptr, variable, value); break; case FIELD_TYPE_UINT: set_uint(len, ptr, variable, value); break; case FIELD_TYPE_CHAR: set_char(len, ptr, variable, value); break; default: wprintw (command_win, "set: unhandled type %d\n", current_type->field_types [i]); break; } refresh_command_win (); } offset+=current_type->field_lengths [i]; } if (found) dispatch ("show"); else { wprintw (command_win,"Error - Variable %s not found\n",variable); refresh_command_win (); } }
void __cls_plug_flow_operator_get(t_plug_mode mode,t_plug *plug,t_plug *plug_src) { t_brick *brick = plug->brick; t_block *block = brick->block; t_brick *brick_indice = block_brick_get(block,"indice"); t_brick *brick_result = block_brick_get(block,"result"); t_plug *plug_result = &brick_result->plug_intern; t_plug *plug_indice = &brick_indice->plug_intern; t_lst *lst; t_vlst *vlst; // IN if(plug_src && mode == mode_in) { switch(plug_src->data_type) { // + LST case (dt_lst): // get lst lst = plug_src->data; // if lst if(lst) { if(!lst->current) { // set first if(lst->first) { lst->current = lst->first; } } else { t_link *link = lst->current; if(link->next) { lst->current = link->next; } else { // } //XXX change type plug_result->data_type=dt_camera; t_camera *camera=link->data; plug_result->data=camera; } } break; // +VLST case(dt_vlst): // get vlst vlst = plug_src->data; if(vlst) { t_plug _plug; _plug.data_type = dt_vector; // change type to vector if(brick_result->plug_intern.data_type != dt_vector) brick_type_change(brick_result,&_plug); // get indice int i = drf_int(plug_indice->data); // if < indice if(i < vlst->count) { t_vector *vector = plug_result->data; // get pointer float *ptr = vlst->data; // do pointer arithmetic vector->data = ptr + (vlst->length * i); } else { t_vector *vector = plug_result->data; set_int(plug_indice->data,vlst->count-1); float *ptr = vlst->data; vector->data = ptr + (vlst->length * (vlst->count-1)); } t_plug *plug_result_out = &brick_result->plug_out; //XXX // open vector if(plug_result_out->is_connected) { t_plug *plug_vector = plug_get_dst(plug_result); if(plug_vector->data_type == dt_vector) { t_brick *brick_vector = plug_vector->brick; t_plug *plug_vector_in = &brick_vector->plug_in; // FLOW IN plug_vector_in->flow_in=1; t_block *block_vector = brick_vector->block; t_brick *brick_x = block_brick_get(block_vector,"x"); t_brick *brick_y = block_brick_get(block_vector,"y"); t_brick *brick_z = block_brick_get(block_vector,"z"); brick_x->state.draw_value=1; brick_y->state.draw_value=1; brick_z->state.draw_value=1; brick_x->action = op_slider; brick_y->action = op_slider; brick_z->action = op_slider; } } } break; default: printf(">> %s\n",data_name_get(plug_src->data_type)); break; } } }
MYBOOL SOS_unmark(SOSgroup *group, int sosindex, int column) { int i, n, nn, *list; MYBOOL isactive; lprec *lp = group->lp; #ifdef Paranoia if((sosindex < 0) || (sosindex > group->sos_count)) { report(lp, IMPORTANT, "SOS_unmark: Invalid SOS index %d\n", sosindex); return(FALSE); } #endif if(!(lp->var_type[column] & (ISSOS | ISGUB))) return(FALSE); if(sosindex == 0) { /* Undefine a SOS3 member variable that has temporarily been set as integer */ if(lp->var_type[column] & ISSOSTEMPINT) { lp->var_type[column] &= !ISSOSTEMPINT; set_int(lp, column, FALSE); } nn = 0; for(i = group->memberpos[column-1]; i < group->memberpos[column]; i++) { n = group->membership[i]; if(SOS_unmark(group, n, column)) nn++; } return((MYBOOL) (nn == group->sos_count)); } else { list = group->sos_list[sosindex-1]->members; n = list[0]+1; nn = list[n]; /* Search for the variable */ i = SOS_member_index(group, sosindex, column); /* Restore sign in main list */ if((i > 0) && (list[i] < 0)) list[i] *= -1; else return(TRUE); /* Find the variable in the active list... */ isactive = SOS_is_active(group, sosindex, column); if(isactive) { for(i = 1; i <= nn; i++) if(list[n+i] == column) break; /* ...shrink the list if found, otherwise return error */ if(i <= nn) { for(; i<nn; i++) list[n+i] = list[n+i+1]; list[n+nn] = 0; return(TRUE); } return(FALSE); } else return(TRUE); } }
static gboolean prox_dueday_handler (xmlNodePtr node, gpointer billterm_pdata) { struct billterm_pdata* pdata = static_cast<decltype (pdata)> (billterm_pdata); return set_int (node, pdata->term, gncBillTermSetDueDays); }
void cmd_line_parse(int argc, uTCHAR **argv) { QStringList splitted; QString arg, key, skey, value, exe = QFileInfo(uQString(argv[0])).baseName(); int opt = 0; for (int a = 1; a < argc; a++) { arg = uQString(argv[a]); splitted = arg.split("="); key = QString(splitted.at(0)); if (key.startsWith("--") || key.startsWith("-")) { key = key.replace("-", ""); for (unsigned int b = 0; b < LENGTH(opt_long); b++) { if ((opt_long[b].lopt == key) || (opt_long[b].sopt == key)) { skey = opt_long[b].sopt; if (opt_long[b].ra == req_arg) { if (splitted.count() > 1) { value = QString(splitted.at(1)); } else { if ((a + 1) >= argc) { QMessageBox::warning(0, "Error", QString("%1: the option needs an arguments -- \"%2\"").arg(exe, key)); usage(exe); } else { value = uQString(argv[++a]); } } } opt = (*((char *) skey.toLatin1().constData())); } } } else { umemset(info.rom_file, 0x00, usizeof(info.rom_file)); ustrncpy(info.rom_file, uQStringCD(key), usizeof(info.rom_file) - 1); continue; } switch (opt) { case 0: // long options if (key == "swap-duty") { set_int(cfg_from_file.swap_duty, SET_SWAP_DUTY); } else if (key == "swap-emphasis") { set_int(cfg_from_file.disable_swap_emphasis_pal, SET_SWAP_EMPHASIS_PAL); } else if (key == "portable") { // l'ho gia' controllato quindi qui non faccio niente } else if (key == "txt-on-screen") { set_int(cfg_from_file.txt_on_screen, SET_TEXT_ON_SCREEN); } else if (key == "input-display") { set_int(cfg_from_file.input_display, SET_INPUT_DISPLAY); } else if (key == "disable-tv-noise") { set_int(cfg_from_file.disable_tv_noise, SET_DISABLE_TV_NOISE); } else if (key == "disable-sepia") { set_int(cfg_from_file.disable_sepia_color, SET_DISABLE_SEPIA_PAUSE); #if defined (WITH_OPENGL) } else if (key == "disable-srgb-fbo") { set_int(cfg_from_file.disable_srgb_fbo, SET_DISABLE_SRGB_FBO); #endif } else if (key == "overscan-brd-ntsc") { set_oscan(SET_OVERSCAN_BRD_NTSC, 0); } else if (key == "overscan-brd-pal") { set_oscan(SET_OVERSCAN_BRD_PAL, 1); } else if (key == "par-soft-stretch") { set_int(cfg_from_file.PAR_soft_stretch, SET_PAR_SOFT_STRETCH); } else if (key == "hide-sprites") { set_int(cfg_from_file.hide_sprites, SET_HIDE_SPRITES); } else if (key == "hide-background") { set_int(cfg_from_file.hide_background, SET_HIDE_BACKGROUND); } else if (key == "unlimited-sprites") { set_int(cfg_from_file.unlimited_sprites, SET_UNLIMITED_SPRITES); } else if (key == "save-battery-ram-file") { set_int(cfg_from_file.save_battery_ram_file, SET_BATTERY_RAM_FILE_EVEY_TOT); } else if (key == "background-pause") { set_int(cfg_from_file.bck_pause, SET_BCK_PAUSE); } else if (key == "language") { set_int(cfg_from_file.language, SET_GUI_LANGUAGE); } else if (key == "disable-new-menu") { set_int(cfg_from_file.disable_new_menu, SET_GUI_DISABLE_NEW_MENU); } break; case 'a': set_int(cfg_from_file.apu.channel[APU_MASTER], SET_AUDIO); break; case 'b': set_int(cfg_from_file.audio_buffer_factor, SET_AUDIO_BUFFER_FACTOR); break; case 'c': set_int(cfg_from_file.channels_mode, SET_CHANNELS); break; case 'd': cfg_from_file.stereo_delay = set_double(5); break; case 'f': set_int(cfg_from_file.fps, SET_FPS); break; case 'g': set_int(cfg_from_file.cheat_mode, SET_CHEAT_MODE); break; case 'h': case '?': usage(exe); break; case 'V': { if (!info.portable) { fprintf(stdout, "%s %s\n", NAME, VERSION); } else { fprintf(stdout, "Portable %s %s\n", NAME, VERSION); } emu_quit(EXIT_SUCCESS); break; } case 'k': set_int(cfg_from_file.frameskip, SET_FRAMESKIP); break; case 'i': set_int(cfg_from_file.filter, SET_FILTER); break; case 'l': set_int(cfg_from_file.samplerate, SET_SAMPLERATE); break; case 'm': set_int(cfg_from_file.mode, SET_MODE); break; case 'n': set_int(cfg_from_file.ntsc_format, SET_NTSC_FORMAT); break; case 'o': set_int(cfg_from_file.oscan, SET_OVERSCAN_DEFAULT); break; case 'p': set_int(cfg_from_file.palette, SET_PALETTE); break; case 'q': set_int(cfg_from_file.audio_quality, SET_AUDIO_QUALITY); break; #if defined (WITH_OPENGL) case 'r': set_int(cfg_from_file.render, SET_RENDERING); gfx_set_render(cfg_from_file.render); break; #endif case 's': set_int(cfg_from_file.scale, SET_SCALE); gfx.scale_before_fscreen = cfg_from_file.scale; break; case 't': { int rc = settings_val_to_int(SET_STRETCH_FULLSCREEN, oarg); if (rc >= 0) { cfg_from_file.scale = !rc; } } break; case 'u': set_int(cfg_from_file.fullscreen, SET_FULLSCREEN); break; case 'v': set_int(cfg_from_file.vsync, SET_VSYNC); break; case 'e': set_int(cfg_from_file.pixel_aspect_ratio, SET_PAR); break; case 'j': set_int(cfg_from_file.interpolation, SET_INTERPOLATION); break; default: break; } } }
int process_command_file(uint8_t *params, uint8_t *result) { int process_result = 0; HEADER header; get_header(&header,¶ms); uint8_t buffer[BUFFER_MAX]; bzero(buffer,BUFFER_SIZE); memcpy(buffer,FILE_PATH,sizeof(FILE_PATH)-1); printf("process file header.func_id=%d\n",header.func_id); switch(header.func_id) { case FUNID_SDF_CREATEFILE: { int re = get_data(¶ms,buffer); if(re>0) { uint32_t buffer_size = get_int(¶ms); buffer[sizeof(FILE_PATH)-1+buffer_size] = '\0'; uint32_t file_size = get_int(¶ms); if(!create_file(buffer,buffer_size, file_size)) { HEADER header; header.func_id = FUNID_SDF_CREATEFILE; header.data_size = 0; header.param_sum = 0; header.reserved = 0; process_result+=set_header(&result,header); } } break; } case FUNID_SDF_DELETEFILE: { int re = get_data(¶ms,buffer); if(re>0) { uint32_t buffer_size = get_int(¶ms); buffer[sizeof(FILE_PATH)-1+buffer_size] = '\0'; if(!delete_file(buffer,buffer_size)) { HEADER header; header.func_id = FUNID_SDF_DELETEFILE; header.data_size = 0; header.param_sum = 0; header.reserved = 0; process_result+=set_header(&result,header); } } break; } case FUNID_SDF_READFILE: { int re = get_data(¶ms,buffer); if(re>0) { uint32_t buffer_size = get_int(¶ms); buffer[sizeof(FILE_PATH)-1+buffer_size] = '\0'; uint32_t offset = get_int(¶ms); uint32_t read_len = get_int(¶ms); uint8_t my_buff[BUFFER_MAX]; bzero(my_buff,BUFFER_SIZE); int size = read_file(buffer,buffer_size,offset,read_len,my_buff); if(size>0) { HEADER header; header.func_id = FUNID_SDF_READFILE; header.data_size = sizeof(uint32_t)*3+size; header.param_sum = 2; header.reserved = 0; process_result+=set_header(&result,header); process_result+=set_int(&result,size); process_result+=set_data(&result,my_buff,size); } } break; } case FUNID_SDF_WRITEFILE: { int re = get_data(¶ms,buffer); if(re>0) { uint32_t buffer_size = get_int(¶ms); buffer[sizeof(FILE_PATH)-1+buffer_size] = '\0'; uint32_t offset = get_int(¶ms); uint32_t write_len = get_int(¶ms); uint8_t my_buff[BUFFER_MAX]; bzero(my_buff,BUFFER_SIZE); uint32_t my_buff_size = get_data(¶ms,my_buff); int size = write_file(buffer,buffer_size,offset,write_len,my_buff); if(size>0) { HEADER header; header.func_id = FUNID_SDF_WRITEFILE; header.data_size = 0; header.param_sum = 0; header.reserved = 0; process_result+=set_header(&result,header); } } break; } default: break; } }
void reset(Type*, caValue* v) { set_int(v, 0); }
/* * Routine: set_option(int var, char *value) * Purpose: set a particular parameter; main entry point for the module * Algorithm: * Data Structures: * * Params: * Returns: * Called By: * Calls: * Assumptions: * Side Effects: * TODO: None */ int set_option(char *name, char *param) { int res = 1; option_t *o; char parse_int[15]; char *cp; init_params(); res = fnd_param(name); if (res == -1) return(res); o = &options[res]; if (o->flags & OPT_NOP) { printf("ERROR: Cannot accept %s.\tNot Implemented!\n", o->name); return(0); } /* option is already set from the command line or hard-coded */ /* and doesn't allow multiple settings */ switch(o->flags & TYPE_MASK) { case OPT_FLG: if ((param && (*param == 'Y' || *param == 'Y' || *param == OPTION_START)) || (param == NULL)) { if (o->action) if (o->action(o->name, NULL) < 0) usage(o->name, "Cannot process option"); set_flg(name); } else clr_flg(name); res = 1; break; case OPT_INT: if (o->action) { if ((res = o->action(o->name, param)) < 0) usage(NULL, "Bad parameter argument"); else sprintf(parse_int, "%d", res); } set_int(name, (o->action)?parse_int:param); res = 2; break; case OPT_STR: if (*param == '"') { cp = strchr((param + 1), '"'); if (cp == NULL) /* non-terminated string literal */ usage(NULL, "Non-terminated string"); *cp = '\0'; param += 1; } else { cp = strpbrk(param, " \t\n"); if (cp != NULL) *cp = '\0'; } if (o->action && strlen(param)) if (o->action(o->name, param) < 0) usage(o->name, "Cannot process option"); set_str(name, param); res = 2; break; default: fprintf(stderr, "Invalid option/type (%d/%s)\n", o->flags & TYPE_MASK, o->name); exit(0); break; } o->flags |= OPT_SET; /* marked as set */ return(res); }
void CLPLpsolve::setFunction(CLPFunction* function) { m_status = 0; m_lpFunction = function; const int nVars = function->getNumCoefficients(); // Creates an empty problem with getNumCoefficients variables m_env = make_lp(0, nVars); if(m_env == NULL) { m_status = 1; } //if(!set_add_rowmode(m_env, FALSE)) //{ // m_status = 1; //} //Allowing memory for rows //int * colno = new int[nVars]; REAL * row= new REAL[nVars + 1]; //set variables names for (int i = 0; i < nVars; ++i) { int lpIndex = i + 1; row[lpIndex] = function->getCoefficients().at(i); //colno[i] = lpIndex; //Determines the type switch(function->getIntegers().at(i)) { case 'C' : m_status = set_unbounded(m_env, lpIndex); break; case 'B' : m_status = set_binary(m_env, lpIndex, TRUE); break; case 'I' : m_status = set_int(m_env, lpIndex, TRUE); break; case 'S' : m_status = set_semicont(m_env, lpIndex, TRUE); break; default: assert(false); break; } //Sets upper bound and lower bound set_upbo(m_env, lpIndex, function->getUpperBounds().at(i)); set_lowbo(m_env, lpIndex, function->getLowerBounds().at(i)); set_col_name(m_env, lpIndex, const_cast<char*>(function->getVarNames().at(i).c_str())); } //set_obj_fnex(m_env, nVars, row, colno); set_obj_fn(m_env, row); // Set the type of the problem (Min or Max) switch (function->getType()) { case lpMinFunction: set_minim(m_env); break; case lpMaxFunction: set_maxim(m_env); break; } if(!set_add_rowmode(m_env, TRUE)) { m_status = 1; } delete [] row; }
static gboolean days_duedays_handler (xmlNodePtr node, gpointer billterm_pdata) { struct billterm_pdata *pdata = billterm_pdata; return set_int (node, pdata->term, gncBillTermSetDueDays); }
static int extra_comms_read(struct async *as, struct vers *vers, int *srestore, char **incexc, struct conf **globalcs, struct conf **cconfs) { int ret=-1; struct asfd *asfd; struct iobuf *rbuf; asfd=as->asfd; rbuf=asfd->rbuf; while(1) { iobuf_free_content(rbuf); if(asfd->read(asfd)) goto end; if(rbuf->cmd!=CMD_GEN) { iobuf_log_unexpected(rbuf, __func__); goto end; } if(!strcmp(rbuf->buf, "extra_comms_end")) { if(asfd->write_str(asfd, CMD_GEN, "extra_comms_end ok")) goto end; break; } else if(!strncmp_w(rbuf->buf, "autoupgrade:")) { char *os=NULL; os=rbuf->buf+strlen("autoupgrade:"); iobuf_free_content(rbuf); if(os && *os && autoupgrade_server(as, vers->ser, vers->cli, os, globalcs)) goto end; } else if(!strcmp(rbuf->buf, "srestore ok")) { iobuf_free_content(rbuf); // Client can accept the restore. // Load the restore config, then send it. *srestore=1; if(conf_parse_incexcs_path(cconfs, get_string(cconfs[OPT_RESTORE_PATH])) || incexc_send_server_restore(asfd, cconfs)) goto end; // Do not unlink it here - wait until // the client says that it wants to do the // restore. // Also need to leave it around if the // restore is to an alternative client, so // that the code below that reloads the config // can read it again. //unlink(get_string(cconfs[OPT_RESTORE_PATH])); } else if(!strcmp(rbuf->buf, "srestore not ok")) { const char *restore_path=get_string( cconfs[OPT_RESTORE_PATH]); // Client will not accept the restore. unlink(restore_path); if(set_string(cconfs[OPT_RESTORE_PATH], NULL)) goto end; logp("Client not accepting server initiated restore.\n"); } else if(!strcmp(rbuf->buf, "sincexc ok")) { // Client can accept incexc conf from the // server. iobuf_free_content(rbuf); if(incexc_send_server(asfd, cconfs)) goto end; } else if(!strcmp(rbuf->buf, "incexc")) { // Client is telling server its incexc // configuration so that it can better decide // what to do on resume. iobuf_free_content(rbuf); if(incexc_recv_server(asfd, incexc, globalcs)) goto end; if(*incexc) { char *tmp=NULL; char comp[32]=""; snprintf(comp, sizeof(comp), "compression = %d\n", get_int(cconfs[OPT_COMPRESSION])); if(!(tmp=prepend(*incexc, comp))) goto end; free_w(incexc); *incexc=tmp; } } else if(!strcmp(rbuf->buf, "countersok")) { // Client can accept counters on // resume/verify/restore. logp("Client supports being sent counters.\n"); set_int(cconfs[OPT_SEND_CLIENT_CNTR], 1); } else if(!strncmp_w(rbuf->buf, "uname=") && strlen(rbuf->buf)>strlen("uname=")) { char *uname=rbuf->buf+strlen("uname="); if(!strncasecmp("Windows", uname, strlen("Windows"))) set_int(cconfs[OPT_CLIENT_IS_WINDOWS], 1); } else if(!strncmp_w(rbuf->buf, "orig_client=") && strlen(rbuf->buf)>strlen("orig_client=")) { if(conf_switch_to_orig_client(globalcs, cconfs, rbuf->buf+strlen("orig_client="))) goto end; // If this started out as a server-initiated // restore, need to load the restore file // again. if(*srestore) { if(conf_parse_incexcs_path(cconfs, get_string(cconfs[OPT_RESTORE_PATH]))) goto end; } if(asfd->write_str(asfd, CMD_GEN, "orig_client ok")) goto end; } else if(!strncmp_w(rbuf->buf, "restore_spool=")) { // Client supports temporary spool directory // for restores. if(set_string(cconfs[OPT_RESTORE_SPOOL], rbuf->buf+strlen("restore_spool="))) goto end; } else if(!strncmp_w(rbuf->buf, "protocol=")) { char msg[128]=""; // Client wants to set protocol. enum protocol protocol=get_e_protocol( cconfs[OPT_PROTOCOL]); if(protocol!=PROTO_AUTO) { snprintf(msg, sizeof(msg), "Client is trying to use protocol=%s but server is set to protocol=%d\n", rbuf->buf, protocol); log_and_send_oom(asfd, __func__); goto end; } else if(!strcmp(rbuf->buf+strlen("protocol="), "1")) { set_e_protocol(cconfs[OPT_PROTOCOL], PROTO_1); set_e_protocol(globalcs[OPT_PROTOCOL], PROTO_1); } else if(!strcmp(rbuf->buf+strlen("protocol="), "2")) { set_e_protocol(cconfs[OPT_PROTOCOL], PROTO_2); set_e_protocol(globalcs[OPT_PROTOCOL], PROTO_2); } else { snprintf(msg, sizeof(msg), "Client is trying to use protocol=%s, which is unknown\n", rbuf->buf); log_and_send_oom(asfd, __func__); goto end; } logp("Client has set protocol=%d\n", (int)get_e_protocol(cconfs[OPT_PROTOCOL])); } else if(!strncmp_w(rbuf->buf, "rshash=blake2")) { #ifdef RS_DEFAULT_STRONG_LEN logp("Client is trying to use librsync hash blake2, but server does not support it.\n"); goto end; #else set_e_rshash(cconfs[OPT_RSHASH], RSHASH_BLAKE2); set_e_rshash(globalcs[OPT_RSHASH], RSHASH_BLAKE2); #endif } else if(!strncmp_w(rbuf->buf, "msg")) { set_int(cconfs[OPT_MESSAGE], 1); set_int(globalcs[OPT_MESSAGE], 1); } else { iobuf_log_unexpected(rbuf, __func__); goto end; } } ret=0; end: iobuf_free_content(rbuf); return ret; }
int main(void) { # if defined ERROR # undef ERROR # endif # define ERROR() { fprintf(stderr, "Error\n"); exit(1); } lprec *lp; int majorversion, minorversion, release, build; #if defined FORTIFY Fortify_EnterScope(); #endif lp_solve_version(&majorversion, &minorversion, &release, &build); printf("lp_solve %d.%d.%d.%d demo\n\n", majorversion, minorversion, release, build); printf("This demo will show most of the features of lp_solve %d.%d.%d.%d\n", majorversion, minorversion, release, build); press_ret(); printf("\nWe start by creating a new problem with 4 variables and 0 constraints\n"); printf("We use: lp=make_lp(0,4);\n"); if ((lp=make_lp(0,4)) == NULL) ERROR(); press_ret(); printf("We can show the current problem with print_lp(lp)\n"); print_lp(lp); press_ret(); printf("Now we add some constraints\n"); printf("str_add_constraint(lp, \"3 2 2 1\" ,LE,4)\n"); printf("This is the string version of add_constraint. For the normal version\n"); printf("of add_constraint see the help file\n"); if (!str_add_constraint(lp, "3 2 2 1", LE, 4)) ERROR(); print_lp(lp); press_ret(); printf("str_add_constraint(lp, \"0 4 3 1\" ,GE,3)\n"); if (!str_add_constraint(lp, "0 4 3 1", GE, 3)) ERROR(); print_lp(lp); press_ret(); printf("Set the objective function\n"); printf("str_set_obj_fn(lp, \"2 3 -2 3\")\n"); if (!str_set_obj_fn(lp, "2 3 -2 3")) ERROR(); print_lp(lp); press_ret(); printf("Now solve the problem with printf(solve(lp));\n"); printf("%d",solve(lp)); press_ret(); printf("The value is 0, this means we found an optimal solution\n"); printf("We can display this solution with print_objective(lp) and print_solution(lp)\n"); print_objective(lp); print_solution(lp, 1); print_constraints(lp, 1); press_ret(); printf("The dual variables of the solution are printed with\n"); printf("print_duals(lp);\n"); print_duals(lp); press_ret(); printf("We can change a single element in the matrix with\n"); printf("set_mat(lp,2,1,0.5)\n"); if (!set_mat(lp,2,1,0.5)) ERROR(); print_lp(lp); press_ret(); printf("If we want to maximize the objective function use set_maxim(lp);\n"); set_maxim(lp); print_lp(lp); press_ret(); printf("after solving this gives us:\n"); solve(lp); print_objective(lp); print_solution(lp, 1); print_constraints(lp, 1); print_duals(lp); press_ret(); printf("Change the value of a rhs element with set_rh(lp,1,7.45)\n"); set_rh(lp,1,7.45); print_lp(lp); solve(lp); print_objective(lp); print_solution(lp, 1); print_constraints(lp, 1); press_ret(); printf("We change %s to the integer type with\n", get_col_name(lp, 4)); printf("set_int(lp, 4, TRUE)\n"); set_int(lp, 4, TRUE); print_lp(lp); printf("We set branch & bound debugging on with set_debug(lp, TRUE)\n"); set_debug(lp, TRUE); printf("and solve...\n"); press_ret(); solve(lp); print_objective(lp); print_solution(lp, 1); print_constraints(lp, 1); press_ret(); printf("We can set bounds on the variables with\n"); printf("set_lowbo(lp,2,2); & set_upbo(lp,4,5.3)\n"); set_lowbo(lp,2,2); set_upbo(lp,4,5.3); print_lp(lp); press_ret(); solve(lp); print_objective(lp); print_solution(lp, 1); print_constraints(lp, 1); press_ret(); printf("Now remove a constraint with del_constraint(lp, 1)\n"); del_constraint(lp,1); print_lp(lp); printf("Add an equality constraint\n"); if (!str_add_constraint(lp, "1 2 1 4", EQ, 8)) ERROR(); print_lp(lp); press_ret(); printf("A column can be added with:\n"); printf("str_add_column(lp,\"3 2 2\");\n"); if (!str_add_column(lp,"3 2 2")) ERROR(); print_lp(lp); press_ret(); printf("A column can be removed with:\n"); printf("del_column(lp,3);\n"); del_column(lp,3); print_lp(lp); press_ret(); printf("We can use automatic scaling with:\n"); printf("set_scaling(lp, SCALE_MEAN);\n"); set_scaling(lp, SCALE_MEAN); print_lp(lp); press_ret(); printf("The function get_mat(lprec *lp, int row, int column) returns a single\n"); printf("matrix element\n"); printf("%s get_mat(lp,2,3), get_mat(lp,1,1); gives\n","printf(\"%f %f\\n\","); printf("%f %f\n", (double)get_mat(lp,2,3), (double)get_mat(lp,1,1)); printf("Notice that get_mat returns the value of the original unscaled problem\n"); press_ret(); printf("If there are any integer type variables, then only the rows are scaled\n"); printf("set_int(lp,3,FALSE);\n"); printf("set_scaling(lp, SCALE_MEAN);\n"); set_scaling(lp, SCALE_MEAN); set_int(lp,3,FALSE); print_lp(lp); press_ret(); solve(lp); printf("print_objective, print_solution gives the solution to the original problem\n"); print_objective(lp); print_solution(lp, 1); print_constraints(lp, 1); press_ret(); printf("Scaling is turned off with unscale(lp);\n"); unscale(lp); print_lp(lp); press_ret(); printf("Now turn B&B debugging off and simplex tracing on with\n"); printf("set_debug(lp, FALSE), set_trace(lp, TRUE) and solve(lp)\n"); set_debug(lp, FALSE); set_trace(lp, TRUE); press_ret(); solve(lp); printf("Where possible, lp_solve will start at the last found basis\n"); printf("We can reset the problem to the initial basis with\n"); printf("default_basis(lp). Now solve it again...\n"); press_ret(); default_basis(lp); solve(lp); printf("It is possible to give variables and constraints names\n"); printf("set_row_name(lp,1,\"speed\"); & set_col_name(lp,2,\"money\")\n"); if (!set_row_name(lp,1,"speed")) ERROR(); if (!set_col_name(lp,2,"money")) ERROR(); print_lp(lp); printf("As you can see, all column and rows are assigned default names\n"); printf("If a column or constraint is deleted, the names shift place also:\n"); press_ret(); printf("del_column(lp,1);\n"); del_column(lp,1); print_lp(lp); press_ret(); delete_lp(lp); #if FALSE printf("A lp structure can be created and read from a .lp file\n"); printf("lp = read_lp(\"lp_examples/demo_lag.lp\", TRUE);\n"); printf("The verbose option is used\n"); if ((lp = read_LP("lp_examples/demo_lag.lp", TRUE, "test")) == NULL) ERROR(); press_ret(); printf("lp is now:\n"); print_lp(lp); press_ret(); printf("solution:\n"); set_debug(lp, TRUE); solve(lp); set_debug(lp, FALSE); print_objective(lp); print_solution(lp, 1); print_constraints(lp, 1); press_ret(); printf("You can see that branch & bound was used in this problem\n"); printf("Now remove the last constraint and use lagrangian relaxation\n"); printf("del_constraint(lp,6);\n"); printf("str_add_lag_con(lp, \"1 1 1 0 0 0\", LE, 2);\n"); del_constraint(lp,6); if (!str_add_lag_con(lp, "1 1 1 0 0 0", LE, 2)) ERROR(); print_lp(lp); printf("Lagrangian relaxation is used in some heuristics. It is now possible\n"); printf("to get a feasible integer solution without usage of branch & bound.\n"); printf("Use lag_solve(lp, 0, 30); 0 is the initial bound, 30 the maximum\n"); printf("number of iterations, the last variable turns the verbose mode on.\n"); press_ret(); set_lag_trace(lp, TRUE); printf("%d\n",lag_solve(lp, 0, 30)); printf("The returncode of lag_solve is 6 or FEAS_FOUND. this means that a feasible\n"); printf("solution has been found. For a list of other possible return values\n"); printf("see the help file. Print this solution with print_objective, print_solution\n"); print_objective(lp); print_solution(lp, 1); print_constraints(lp, 1); delete_lp(lp); press_ret(); #endif #if defined FORTIFY Fortify_LeaveScope(); #endif return(0); }