Bool zpl_read_with_args(char** argv, int argc, Bool with_management, void* user_data) { const char* options = "D:mP:sv:"; unsigned long seed = 13021967UL; char** param_table; int param_count = 0; int c; int i; Prog* prog = NULL; Set* set; void* lp = NULL; Bool ret = FALSE; char* inppipe = NULL; Bool use_startval = FALSE; stkchk_init(); yydebug = 0; yy_flex_debug = 0; param_table = malloc(sizeof(*param_table)); zpl_print_banner(stdout, FALSE); /* getopt might be called more than once */ optind = 1; while((c = getopt(argc, argv, options)) != -1) { switch(c) { case 'D' : param_table = realloc(param_table, ((unsigned int)param_count + 1) * sizeof(*param_table)); param_table[param_count] = strdup(optarg); if (verbose >= VERB_DEBUG) printf("Parameter %d [%s]\n", param_count, param_table[param_count]); param_count++; break; case 'm' : use_startval = TRUE; break; case 'P' : inppipe = strdup(optarg); break; case 's' : seed = (unsigned long)atol(optarg); break; case 'v' : verbose = atoi(optarg); break; case '?': fprintf(stderr, "Unknown option '%c'\n", c); return FALSE; default : abort(); } } if ((argc - optind) < 1) { fprintf(stderr, "Filename missing\n"); free(param_table); return FALSE; } blk_init(); str_init(); rand_init(seed); numb_init(with_management); elem_init(); set_init(); mio_init(); interns_init(); local_init(); if (0 == setjmp( zpl_read_env)) { is_longjmp_ok = TRUE; /* Make symbol to hold entries of internal variables */ set = set_pseudo_new(); (void)symbol_new(SYMBOL_NAME_INTERNAL, SYM_VAR, set, 100, NULL); set_free(set); /* Now store the param defines */ for(i = 0; i < param_count; i++) zpl_add_parameter(param_table[i]); prog = prog_new(); for(i = optind; i < argc; i++) prog_load(prog, inppipe, argv[i]); if (prog_is_empty(prog)) fprintf(stderr, "*** Error 168: No program statements to execute\n"); else { if (verbose >= VERB_DEBUG) prog_print(stderr, prog); lp = xlp_alloc(argv[optind], use_startval, user_data); prog_execute(prog, lp); ret = TRUE; } } is_longjmp_ok = FALSE; if (lp != NULL) xlp_free(lp); /* Now clean up. */ if (inppipe != NULL) free(inppipe); for(i = 0; i < param_count; i++) free(param_table[i]); free(param_table); if (prog != NULL) prog_free(prog); local_exit(); interns_exit(); mio_exit(); symbol_exit(); define_exit(); set_exit(); elem_exit(); numb_exit(); str_exit(); blk_exit(); return ret; }
int main(int argc, char* const* argv) { Prog* prog; Set* set; void* lp; const char* extension = ""; char* filter = strdup("%s"); char* outfile; char* tblfile; char* ordfile; char* mstfile; char* basefile = NULL; char* inppipe = NULL; char* outpipe; LpFormat format = LP_FORM_LPF; FILE* fp; Bool write_order = FALSE; Bool write_mst = FALSE; Bool presolve = FALSE; int name_length = 0; char* prog_text; unsigned long seed = 13021967UL; char** param_table; int param_count = 0; int c; int i; FILE* (*openfile)(const char*, const char*) = fopen; int (*closefile)(FILE*) = fclose; stkchk_init(); yydebug = 0; yy_flex_debug = 0; verbose = VERB_NORMAL; param_table = malloc(sizeof(*param_table)); while((c = getopt(argc, argv, options)) != -1) { switch(c) { case 'b' : yydebug = 1; break; case 'D' : param_table = realloc(param_table, ((unsigned int)param_count + 1) * sizeof(*param_table)); param_table[param_count] = strdup(optarg); param_count++; break; case 'h' : zpl_print_banner(stdout, TRUE); printf(usage, argv[0]); puts(help); exit(0); case 'f' : yy_flex_debug = 1; break; case 'F' : free(filter); filter = strdup(optarg); openfile = popen; closefile = pclose; break; case 'l' : name_length = atoi(optarg); break; case 'm' : write_mst = TRUE; break; case 'n' : if (*optarg != 'c') { fprintf(stderr, usage, argv[0]); exit(0); } switch(optarg[1]) { case 'm' : conname_format(CON_FORM_MAKE); break; case 'n' : conname_format(CON_FORM_NAME); break; case 'f' : conname_format(CON_FORM_FULL); break; default : fprintf(stderr, usage, argv[0]); exit(0); } break; case 'o' : basefile = strdup(optarg); break; case 'O' : presolve = TRUE; break; case 'P' : inppipe = strdup(optarg); break; case 's' : seed = (unsigned long)atol(optarg); break; case 'r' : write_order = TRUE; break; case 't' : switch(tolower(*optarg)) { case 'h' : format = LP_FORM_HUM; break; case 'm' : format = LP_FORM_MPS; break; case 'l' : format = LP_FORM_LPF; break; case 'p' : format = LP_FORM_PIP; break; case 'r' : format = LP_FORM_RLP; break; default : if (verbose > VERB_QUIET) fprintf(stderr, "--- Warning 103: Output format \"%s\" not supported, using LP format\n", optarg); format = LP_FORM_LPF; break; } break; case 'v' : verbose = atoi(optarg); break; case 'V' : printf("%s\n", VERSION); exit(0); case '?': fprintf(stderr, usage, argv[0]); exit(0); default : abort(); } } if ((argc - optind) < 1) { fprintf(stderr, usage, argv[0]); exit(0); } zpl_print_banner(stdout, TRUE); if (basefile == NULL) basefile = strip_extension(strdup(strip_path(argv[optind]))); switch(format) { case LP_FORM_LPF : extension = ".lp"; break; case LP_FORM_MPS : extension = ".mps"; break; case LP_FORM_HUM : extension = ".hum"; break; case LP_FORM_RLP : extension = ".rlp"; break; case LP_FORM_PIP : extension = ".pip"; break; default : abort(); } assert(extension != NULL); outfile = add_extention(basefile, extension); tblfile = add_extention(basefile, ".tbl"); ordfile = add_extention(basefile, ".ord"); mstfile = add_extention(basefile, ".mst"); outpipe = malloc(strlen(basefile) + strlen(filter) + 256); assert(outpipe != NULL); blk_init(); str_init(); rand_init(seed); numb_init(TRUE); elem_init(); set_init(); mio_init(); interns_init(); local_init(); /* Make symbol to hold entries of internal variables */ set = set_pseudo_new(); (void)symbol_new(SYMBOL_NAME_INTERNAL, SYM_VAR, set, 100, NULL); set_free(set); /* Now store the param defines */ for(i = 0; i < param_count; i++) zpl_add_parameter(param_table[i]); /* Next we read in the zpl program(s) */ prog = prog_new(); for(i = optind; i < argc; i++) prog_load(prog, inppipe, argv[i]); if (prog_is_empty(prog)) { fprintf(stderr, "*** Error 168: No program statements to execute\n"); exit(EXIT_FAILURE); } if (verbose >= VERB_DEBUG) prog_print(stderr, prog); lp = xlp_alloc(argv[optind], write_mst || write_order, NULL); zlp_setnamelen(lp, name_length); prog_execute(prog, lp); /* Presolve */ if (presolve) fprintf(stderr, "--- Warning: Presolve no longer support. If you need it, send me an email\n"); #if 0 if (!zlp_presolve()) exit(EXIT_SUCCESS); #endif if (verbose >= VERB_NORMAL) zlp_stat(lp); /* Write order file */ if (write_order) { sprintf(outpipe, filter, ordfile, "ord"); if (verbose >= VERB_NORMAL) printf("Writing [%s]\n", outpipe); if (NULL == (fp = (*openfile)(outpipe, "w"))) { fprintf(stderr, "*** Error 104: File open failed "); perror(ordfile); exit(EXIT_FAILURE); } zlp_orderfile(lp, fp, format); check_write_ok(fp, ordfile); (void)(*closefile)(fp); } /* Write MST file */ if (write_mst) { sprintf(outpipe, filter, mstfile, "mst"); if (verbose >= VERB_NORMAL) printf("Writing [%s]\n", outpipe); if (NULL == (fp = (*openfile)(outpipe, "w"))) { fprintf(stderr, "*** Error 104: File open failed "); perror(mstfile); exit(EXIT_FAILURE); } zlp_mstfile(lp, fp, format); check_write_ok(fp, mstfile); (void)(*closefile)(fp); } /* Write Output */ sprintf(outpipe, filter, outfile, "lp"); if (verbose >= VERB_NORMAL) printf("Writing [%s]\n", outpipe); if (NULL == (fp = (*openfile)(outpipe, "w"))) { fprintf(stderr, "*** Error 104: File open failed "); perror(outfile); exit(EXIT_FAILURE); } if (format != LP_FORM_RLP) prog_text = prog_tostr(prog, format == LP_FORM_MPS ? "* " : "\\ ", title, 128); else { prog_text = malloc(strlen(title) + 4); assert(prog_text != NULL); sprintf(prog_text, "\\%s\n", title); } zlp_write(lp, fp, format, prog_text); check_write_ok(fp, outfile); (void)(*closefile)(fp); /* We do not need the translation table for human readable format * Has to be written after the LP file, so the scaling has been done. */ if (format != LP_FORM_HUM) { /* Write translation table */ sprintf(outpipe, filter, tblfile, "tbl"); if (verbose >= VERB_NORMAL) printf("Writing [%s]\n", outpipe); if (NULL == (fp = (*openfile)(outpipe, "w"))) { fprintf(stderr, "*** Error 104: File open failed"); perror(tblfile); exit(EXIT_FAILURE); } zlp_transtable(lp, fp, format); check_write_ok(fp, tblfile); (void)(*closefile)(fp); } free(prog_text); if (verbose >= VERB_DEBUG) symbol_print_all(stderr); #if defined(__INSURE__) || !defined(NDEBUG) || defined(FREEMEM) /* Now clean up. */ if (inppipe != NULL) free(inppipe); for(i = 0; i < param_count; i++) free(param_table[i]); free(param_table); prog_free(prog); local_exit(); interns_exit(); xlp_free(lp); mio_exit(); symbol_exit(); define_exit(); set_exit(); elem_exit(); numb_exit(); str_exit(); blk_exit(); free(mstfile); free(ordfile); free(outfile); free(tblfile); free(basefile); free(filter); free(outpipe); if (verbose >= VERB_NORMAL) { mem_display(stdout); stkchk_maximum(stdout); } #endif /* __INSURE__ || !NDEBUG || FREEMEM */ return 0; }
Bool zpl_read(const char* filename, Bool with_management, void* user_data) { Prog* prog = NULL; Set* set; void* lp = NULL; Bool ret = FALSE; stkchk_init(); yydebug = 0; yy_flex_debug = 0; zpl_print_banner(stdout, FALSE); blk_init(); str_init(); rand_init(13021967UL); numb_init(with_management); elem_init(); set_init(); mio_init(); interns_init(); local_init(); if (0 == setjmp(zpl_read_env)) { is_longjmp_ok = TRUE; set = set_pseudo_new(); (void)symbol_new(SYMBOL_NAME_INTERNAL, SYM_VAR, set, 100, NULL); set_free(set); prog = prog_new(); prog_load(prog, NULL, filename); if (prog_is_empty(prog)) fprintf(stderr, "*** Error 168: No program statements to execute\n"); else { if (verbose >= VERB_DEBUG) prog_print(stderr, prog); lp = xlp_alloc(filename, FALSE, user_data); prog_execute(prog, lp); ret = TRUE; } } is_longjmp_ok = FALSE; if (lp != NULL) xlp_free(lp); if (prog != NULL) prog_free(prog); local_exit(); interns_exit(); mio_exit(); symbol_exit(); define_exit(); set_exit(); elem_exit(); numb_exit(); str_exit(); blk_exit(); return ret; }
static EFI_STATUS parse_args(CHAR16 *options, UINT32 size, CHAR16 *type, CHAR16 **name, CHAR8 **cmdline) { CHAR16 *n; EFI_STATUS err; int i = 0; *cmdline = NULL; *name = NULL; /* Skip whitespace */ for (i = 0; i < size && isspace(options[i]); i++) ; /* No arguments */ if (i == size) { debug(L"No args\n"); return EFI_SUCCESS; } n = &options[i]; while (n <= &options[size]) { if (*n == '-') { switch (*++n) { case 'h': goto usage; #ifdef RUNTIME_SETTINGS case 'l': blk_init(); list_blk_devices(); blk_exit(); goto fail; case 'm': print_memory_map(); n++; goto fail; case 'f': case 'p': case 't': case 'c': #endif /* RUNTIME_SETTINGS */ case 'a': *type = *n; n++; n = get_argument(n, name); if (!*name) goto fail; break; #ifdef RUNTIME_SETTINGS case 'e': { CHAR16 *em_policy; EFI_STATUS status; n++; n = get_argument(n, &em_policy); if (!*em_policy) goto usage; status = em_set_policy(em_policy); if (EFI_ERROR(status)) goto usage; break; } case 'n': { saved_hook_before_jump = loader_ops.hook_before_jump; loader_ops.hook_before_jump = hook_before_jump_forever_loop; warning(L"-n option set : OSloader will not jump to kernel\n"); break; } case 'A': list_acpi_tables(); goto fail; #endif /* RUNTIME_SETTINGS */ default: error(L"Unknown command-line switch\n"); goto usage; } } else { CHAR8 *s1; CHAR16 *s2; int j; j = StrLen(n); *cmdline = malloc(j + 1); if (!*cmdline) { error(L"Unable to alloc cmdline memory\n"); err = EFI_OUT_OF_RESOURCES; goto free_name; } s1 = *cmdline; s2 = n; while (j--) *s1++ = *s2++; *s1 = '\0'; /* Consume the rest of the args */ n = &options[size] + 1; } } return EFI_SUCCESS; usage: #ifdef RUNTIME_SETTINGS Print(L"usage: efilinux [OPTIONS] <kernel-command-line-args>\n\n"); Print(L"\t-h: display this help menu\n"); Print(L"\t-l: list boot devices\n"); Print(L"\t-m: print memory map\n"); #else Print(L"usage: efilinux [OPTIONS]\n\n"); #endif /* RUNTIME_SETTINGS */ Print(L"\t-a <address>: boot an already in memory image\n"); #ifdef RUNTIME_SETTINGS Print(L"\t-A: List ACPI tables\n"); Print(L"\t-e <policy>: Set the energy management policy ('uefi', 'fake')\n"); Print(L"\t-f <filename>: image to load\n"); Print(L"\t-p <partname>: partition to load\n"); Print(L"\t-t <target>: target to boot\n"); Print(L"\t-n: do as usual but wait indefinitely instead of jumping to the loaded image (for test purpose only)\n"); Print(L"\t-c <command>: debug commands (dump_infos, print_pidv, print_rsci,\n"); Print(L"\t dump_acpi_tables, print_esrt or load_dsdt)\n"); #endif /* RUNTIME_SETTINGS */ fail: err = EFI_INVALID_PARAMETER; if (*cmdline) free(*cmdline); free_name: if (*name) free(*name); return err; }