int harp_unit_converter_new(const char *from_unit, const char *to_unit, harp_unit_converter **new_unit_converter) { harp_unit_converter *unit_converter; ut_unit *from_udunit; ut_unit *to_udunit; if (parse_unit(from_unit, &from_udunit) != 0) { return -1; } if (parse_unit(to_unit, &to_udunit) != 0) { ut_free(from_udunit); return -1; } if (!ut_are_convertible(from_udunit, to_udunit)) { harp_set_error(HARP_ERROR_UNIT_CONVERSION, "unit '%s' cannot be converted to unit '%s'", from_unit, to_unit); ut_free(to_udunit); ut_free(from_udunit); return -1; } unit_converter = (harp_unit_converter *)malloc(sizeof(harp_unit_converter)); if (unit_converter == NULL) { harp_set_error(HARP_ERROR_OUT_OF_MEMORY, "out of memory (could not allocate %lu bytes) (%s:%u)", sizeof(harp_unit_converter), __FILE__, __LINE__); ut_free(to_udunit); ut_free(from_udunit); return -1; } unit_converter->converter = ut_get_converter(from_udunit, to_udunit); if (unit_converter->converter == NULL) { handle_udunits_error(); harp_unit_converter_delete(unit_converter); ut_free(to_udunit); ut_free(from_udunit); return -1; } ut_free(to_udunit); ut_free(from_udunit); *new_unit_converter = unit_converter; return 0; }
std::unique_ptr<UnitEmitter> single_unit(std::unique_ptr<UnitEmitter> input) { trace_time timer("single unit"); php::Program program; program.units.push_back(parse_unit(*input)); auto const u = borrow(program.units[0]); // Single-unit index. Index index{u}; // Visit each method in the unit, except the pseudomain, which isn't // supported for anything yet. for (auto& c : u->classes) { for (auto& m : c->methods) { analyze_and_optimize_func(index, Context { u, borrow(m), borrow(c) }); } assert(check(*c)); } for (auto& f : u->funcs) { analyze_and_optimize_func(index, Context { u, borrow(f) }); assert(check(*f)); } assert(check(*u)); return emit_unit(index, *u); }
std::unique_ptr<php::Program> parse_program(const Container& units) { trace_time tracer("parse"); auto ret = folly::make_unique<php::Program>(); ret->units = parallel_map( units, [&] (const std::unique_ptr<UnitEmitter>& ue) { return parse_unit(*ue); } ); return ret; }
int main(int argc, char *argv[]) { combatant *def, *att[20]; double hit_chance; unsigned damage; bool slows; unsigned int i; if (argc < 3) run(argv[1] ? atoi(argv[1]) : 0); if (argc < 9) { fprintf(stderr,"Usage: %s <damage> <attacks> <hp> <hitprob> [drain,slows,slowed,swarm,firststrike,berserk,maxhp=<num>] <damage> <attacks> <hp> <hitprob> [drain,slows,slowed,berserk,firststrike,swarm,maxhp=<num>] ...", argv[0]); exit(1); } def = parse_unit(&argv, &damage, &hit_chance, &slows); for (i = 0; argv[1]; ++i) att[i] = parse_unit(&argv); att[i] = NULL; for (i = 0; att[i]; ++i) { // In case defender has swarm, effectiveness changes. debug(("Fighting next attacker\n")); def->set_effectiveness(damage, hit_chance, slows); att[i]->fight(*def); } def->print("Defender", 0); for (i = 0; att[i]; ++i) att[i]->print("Attacker", 0); delete def; for (i = 0; att[i]; ++i) delete att[i]; return 0; }
int harp_unit_is_valid(const char *str) { ut_unit *unit; if (parse_unit(str, &unit) != 0) { return 0; } ut_free(unit); return 1; }
/** * Compare the two specified units. Units can compare equal even if their string representations are not, e.g. consider * "W" (Watt) and "J/s" (Joule per second). * \return * \arg \c <0, \a unit_a is considered less than \a unit_b. * \arg \c 0, \a unit_a and \a unit_b are considered equal. * \arg \c >0, \a unit_a is considered greater than \a unit_b. */ int harp_unit_compare(const char *unit_a, const char *unit_b) { ut_unit *udunit_a; ut_unit *udunit_b; int result; if (parse_unit(unit_a, &udunit_a) != 0) { return -1; } if (parse_unit(unit_b, &udunit_b) != 0) { ut_free(udunit_a); return -1; } result = ut_compare(udunit_a, udunit_b); ut_free(udunit_b); ut_free(udunit_a); return result; }
void Parameter::file_results () { SuperString tmp; int junk; size_t size = m_matches.size(); for (int x=1; x<size; x++) { tmp = m_matches[x].str(); SuperString exp = get_numeral_regexpression( m_type ); int matches = tmp.regex_find( exp ); if (matches) parse_value( tmp, junk ); else parse_unit( tmp ); matches = tmp.regex_find( m_name ); if (matches) m_name_found = tmp; } }
/** main() */ int main(int argc, char *argv[]) { const char * fname[2] = { NULL, NULL }; FILE * fp[2] = { NULL, NULL }; compression_t compression[2] = { compression_unknown, compression_unknown }; int rc[2] = { -1, -1 }; int dc[2] = { -1, -1 }; int ru[2] = { radians, radians }; int du[2] = { radians, radians }; ccarray_t * list[2] = { NULL, NULL }; size_t capacity[2] = { 15000000, 15000000 }; char head[2][MAX_HEADER_LENGTH]; int beverbose = 0; int invert_match = 0; double r = -1; int i; size_t size1, size2, pos1, pos2; const obj_t * obj1, * obj2; //double rcd; /* parse command line */ for ( i = 1; i < argc; ++i ) { if ( strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-help") == 0 ) { show_usage(stdout, argc, argv); return 0; } if ( strncmp(argv[i], "rc1=", 4) == 0 ) { if ( sscanf(argv[i] + 4, "%d", &rc[0]) != 1 || rc[0] < 1 ) { fprintf(stderr,"Invalid value of %s\n", argv[i]); return -1; } } else if ( strncmp(argv[i], "rc2=", 4) == 0 ) { if ( sscanf(argv[i] + 4, "%d", &rc[1]) != 1 || rc[1] < 1 ) { fprintf(stderr,"Invalid value of %s\n", argv[i]); return -1; } } else if ( strncmp(argv[i], "dc1=", 4) == 0 ) { if ( sscanf(argv[i] + 4, "%d", &dc[0]) != 1 || dc[0] < 1 ) { fprintf(stderr,"Invalid value of %s\n", argv[i]); return -1; } } else if ( strncmp(argv[i], "dc2=", 4) == 0 ) { if ( sscanf(argv[i] + 4, "%d", &dc[1]) != 1 || dc[1] < 1 ) { fprintf(stderr,"Invalid value of %s\n", argv[i]); return -1; } } else if ( strncmp(argv[i], "ru1=", 4) == 0 ) { if ( (ru[0] = parse_unit(argv[i] + 4)) == -1 ) { fprintf(stderr,"Invalid value of %s\n", argv[i]); return -1; } } else if ( strncmp(argv[i], "ru2=", 4) == 0 ) { if ( (ru[1] = parse_unit(argv[i] + 4)) == -1 ) { fprintf(stderr,"Invalid value of %s\n", argv[i]); return -1; } } else if ( strncmp(argv[i], "du1=", 4) == 0 ) { if ( (du[0] = parse_unit(argv[i] + 4)) == -1 ) { fprintf(stderr,"Invalid value of %s\n", argv[i]); return -1; } } else if ( strncmp(argv[i], "du2=", 4) == 0 ) { if ( (du[1] = parse_unit(argv[i] + 4)) == -1 ) { fprintf(stderr,"Invalid value of %s\n", argv[i]); return -1; } } else if ( strncmp(argv[i], "r=", 2) == 0 ) { if ( sscanf(argv[i] + 2, "%lf", &r) != 1 || r <= 0 ) { fprintf(stderr,"Invalid value of %s\n", argv[i]); return -1; } } else if ( strcmp(argv[i], "-i") == 0 ) { invert_match = 1; } else if ( strcmp(argv[i], "-v") == 0 ) { beverbose = 1; } else if ( !fname[0] ) { fname[0] = argv[i]; } else if ( !fname[1] ) { fname[1] = argv[i]; } else { fprintf(stderr, "Invalid argument '%s'. Note that only 2 input files are allowed\n", argv[i]); return -1; } } /* check command line inputs */ if ( !fname[0] || !fname[1] ) { fprintf(stderr,"Two input file names expected\n"); show_usage(stderr, argc, argv); return -1; } if ( rc[0] < 1 ) { fprintf(stderr,"rc1 argument is mandatory\n"); show_usage(stderr, argc, argv); return -1; } if ( rc[1] < 1 ) { fprintf(stderr,"rc2 argument is mandatory\n"); show_usage(stderr, argc, argv); return -1; } if ( dc[0] < 1 ) { fprintf(stderr,"dc1 argument is mandatory\n"); show_usage(stderr, argc, argv); return -1; } if ( dc[1] < 1 ) { fprintf(stderr,"dc2 argument is mandatory\n"); show_usage(stderr, argc, argv); return -1; } if ( (r *= (PI / (180 * 3600))) <= 0 ) { fprintf(stderr,"r argument is mandatory\n"); show_usage(stderr, argc, argv); return -1; } /* check if input files are readable */ for ( i = 0; i < 2; ++i ) { if ( access(fname[i], R_OK) != 0 ) { fprintf(stderr, "Can't read %s: %s\n", fname[i], strerror(errno)); return -1; } } /* allocate memory storage */ for ( i = 0; i < 2; ++i ) { if ( !(list[i] = ccarray_create(capacity[i], sizeof(obj_t))) ) { fprintf(stderr, "ccarray_create(capacity=%zu) fails: %s\n", capacity[i], strerror(errno)); return -1; } } /* load input files */ for ( i = 0; i < 2; ++i ) { if ( beverbose ) { fprintf(stderr,"loading %s....\n", fname[i]); } if ( !(fp[i] = open_file(fname[i], &compression[i])) ) { fprintf(stderr, "Can't read '%s': %s\n", fname[i], strerror(errno)); return -1; } if ( load_objects(fp[i], rc[i], dc[i], ru[i], du[i], head[i], list[i]) != 0 ) { fprintf(stderr, "Can't load %s\n", fname[i]); return -1; } close_file( fp[i], compression[i] ); if ( beverbose ) { fprintf(stderr,"%s: %zu objects\n", fname[i], ccarray_size(list[i])); } if ( ccarray_size(list[i]) == capacity[i] && !feof(fp[i]) ) { fprintf(stderr, "load_objects() fails for %s: Too many objects. Try increase capacity1 (currently %zu)\n", fname[i], capacity[i]); return -1; } } /* sort lists */ for ( i = 0; i < 2; ++i ) { if ( beverbose ) { fprintf(stderr, "sort %s....\n", fname[i]); } //ccarray_sort(list[i], 0, ccarray_size(list[i]), cmpradec); ccarray_sort(list[i], 0, ccarray_size(list[i]), cmpdecra); } /* search pairs */ if ( beverbose ) { fprintf(stderr,"search pairs...\n"); } printf("%s\t%s\tdra\tddec\n", head[0], head[1]); size1 = ccarray_size(list[0]); size2 = ccarray_size(list[1]); double dra_closest=0; double ddec_closest=0; size_t imin=0; size_t imax=size2; for ( pos1 = 0; pos1 < size1; ++pos1 ) { char line_closest [MAX_INPUT_LINE_LENGTH]; line_closest[MAX_INPUT_LINE_LENGTH-1]=0; double decmin, decmax, dra, ddec; int objcount = 0; obj1 = ccarray_peek(list[0], pos1); decmin = obj1->dec - r; decmax = obj1->dec + r; get_index(list[1],&imin,&imax,size2,decmin,decmax); double rmin=r; double dr; for ( pos2=imin; pos2 < imax; ++pos2 ) { obj2 = ccarray_peek(list[1], pos2); dra = (obj2->ra - obj1->ra) * cos((obj1->dec + obj2->dec) / 2); ddec = (obj2->dec - obj1->dec); dr=hypot(dra, ddec); if ( dr< rmin ) { rmin=dr; dra_closest=dra; ddec_closest=ddec; strcpy(line_closest,obj2->line); if ( line_closest[MAX_INPUT_LINE_LENGTH - 1] != 0 ) { fprintf(stderr,"too long input line in this file\n"); return -1; } ++objcount; } } if ( !invert_match && objcount>0) { printf("%s\t%s\t%+9.3f\t%+9.3f\n", obj1->line, line_closest, dra_closest * 180 * 3600 / PI, ddec_closest * 180 * 3600 / PI); } if ( invert_match && objcount == 0 ) { printf("%s\n", obj1->line); } } return 0; }
int main (int argc, char * argv[]) { int c; extern char * optarg; extern int optind; svccfg_mode mode; if (argc < 2) { fprintf (stderr, "svccfg: expected option\n"); exit (1); } if (!strcasecmp (argv[1], "import")) mode = IMPORT; else goto mode_unknown; clnt = s16db_context_create (); optind++; switch (mode) { case IMPORT: { int is_systemd = 0; const char * manifest = 0; svc_t * newSvc; while ((c = getopt (argc, argv, "m:s")) != -1) { switch (c) { case 'm': manifest = optarg; break; case 's': is_systemd = 1; break; case '?': exit (1); break; } } if (!manifest) eerror ("import manifest mode, but no manifest specified\n"); newSvc = parse_unit (is_systemd, manifest); if (!newSvc) exit (1); int ret = s16db_svc_install (clnt, newSvc); printf ("installed manifest for service <%s> %d\n", newSvc->name, ret); // return 0; break; } } svc_list box = s16db_svc_retrieve_all (clnt); for (svc_list_iterator it = svc_list_begin (box); it != NULL; svc_list_iterator_next (&it)) { printf ("Service: %s\n", it->val->name); printf (" ID: %d\n", it->val->id); printf (" PList:\n"); for (prop_list_iterator itp = prop_list_begin (it->val->properties); itp != NULL; prop_list_iterator_next (&itp)) { printf (" %s: %s\n", itp->val->name, itp->val->value.pval_u.s); } } s16db_context_destroy (clnt); return 0; mode_unknown: fprintf (stderr, "svccfg: unknown operation: %s\n", argv[1]); }
void config::load(const std::string& path) { cybozu::config_parser cp(path); if( cp.exists(VIRTUAL_IP) ) m_vip.parse(cp.get(VIRTUAL_IP)); if( cp.exists(PORT) ) { int n = cp.get_as_int(PORT); if( n < 1 || n > 65535 ) throw bad_config("Bad port: " + cp.get(PORT)); m_port = static_cast<std::uint16_t>(n); } if( cp.exists(REPL_PORT) ) { int n = cp.get_as_int(REPL_PORT); if( n < 1 || n > 65535 ) throw bad_config("Bad repl port: " + cp.get(REPL_PORT)); m_repl_port = static_cast<std::uint16_t>(n); } if( cp.exists(BIND_IP) ) { for( auto& s: cybozu::tokenize(cp.get(BIND_IP), ' ') ) { m_bind_ip.emplace_back(s); } } if( cp.exists(MAX_CONNECTIONS) ) { int conns = cp.get_as_int(MAX_CONNECTIONS); if( conns < 0 ) throw bad_config("max_connections must be >= 0"); m_max_connections = conns; } if( cp.exists(TEMP_DIR) ) { m_tempdir = cp.get(TEMP_DIR); if( ! cybozu::is_dir(m_tempdir) ) throw bad_config("Not a directory: " + m_tempdir); if( ! cybozu::is_writable(m_tempdir) ) throw bad_config("Directory not writable: " + m_tempdir); } if( cp.exists(USER) ) { m_user = cp.get(USER); } if( cp.exists(GROUP) ) { m_group = cp.get(GROUP); } if( cp.exists(LOG_THRESHOLD) ) { auto it = THRESHOLDS.find(cp.get(LOG_THRESHOLD)); if( it == THRESHOLDS.end() ) throw bad_config("Invalid threshold: " + cp.get(LOG_THRESHOLD)); m_threshold = it->second; } if( cp.exists(LOG_FILE) ) { m_logfile = cp.get(LOG_FILE); if( m_logfile.size() == 0 || m_logfile[0] != '/' ) throw bad_config("Invalid log file: " + m_logfile); } if( cp.exists(BUCKETS) ) { int buckets = cp.get_as_int(BUCKETS); if( buckets < 1 ) throw bad_config("buckets must be > 0"); if( buckets < 10000 ) cybozu::logger::warning() << "Too small bucket count!"; m_buckets = buckets; } if( cp.exists(MAX_DATA_SIZE) ) { std::string t = cp.get(MAX_DATA_SIZE); if( t.empty() ) throw bad_config("max_data_size must not be empty"); m_max_data_size = parse_unit(t, MAX_DATA_SIZE); } if( cp.exists(HEAP_DATA_LIMIT) ) { std::string t = cp.get(HEAP_DATA_LIMIT); if( t.empty() ) throw bad_config("heap_data_limit must not be empty"); m_heap_data_limit = parse_unit(t, HEAP_DATA_LIMIT); if( m_heap_data_limit < 4096 ) throw bad_config("too small heap_data_limit"); } if( cp.exists(MEMORY_LIMIT) ) { std::string t = cp.get(MEMORY_LIMIT); if( t.empty() ) throw bad_config("memory_limit must not be empty"); m_memory_limit = parse_unit(t, MEMORY_LIMIT); } if( cp.exists(REPL_BUFSIZE) ) { int bufs = cp.get_as_int(REPL_BUFSIZE); if( bufs < 1 ) throw bad_config("repl_buffer_size must be > 0"); m_repl_bufsize = bufs; } if( cp.exists(SECURE_ERASE) ) { m_secure_erase = cp.get_as_bool(SECURE_ERASE); } if( cp.exists(LOCK_MEMORY) ) { m_lock_memory = cp.get_as_bool(LOCK_MEMORY); } if( cp.exists(WORKERS) ) { int n = cp.get_as_int(WORKERS); if( n < 1 ) throw bad_config("workers must be > 0"); if( n > MAX_WORKERS ) throw bad_config("workers must be <= " + std::to_string(MAX_WORKERS)); m_workers = n; } if( cp.exists(GC_INTERVAL) ) { int n = cp.get_as_int(GC_INTERVAL); if( n < 1 ) throw bad_config("gc_interval must be > 0"); m_gc_interval = n; } if( cp.exists(SLAVE_TIMEOUT) ) { int n = cp.get_as_int(SLAVE_TIMEOUT); if( n < 1 ) throw bad_config("slave_timeout must be > 0"); m_slave_timeout = n; } m_counter_config.load(cp); }
int frec_proc_heur(heur_t *h, const wchar_t *regex, size_t len, int cflags) { int errcode; parser_state state; errcode = init_state(&state, regex, len, cflags); if (errcode != REG_OK) goto err; DEBUG_PRINT("enter"); /* * Process the pattern char-by-char. * * state.procidx: position in regex * state.heur: buffer for the fragment being extracted * state.heurpos: buffer position */ for (state.procidx = 0; state.procidx < state.len; state.procidx++) { switch (state.regex[state.procidx]) { /* * BRE/ERE: Bracketed expression ends the segment or the * brackets are treated as normal if at least the opening * bracket is escaped. */ case L'[': if (state.escaped) { store_char(&state); continue; } else { if (parse_set(&state) == REG_BADPAT) return REG_BADPAT; state.tlen = (state.tlen == -1) ? -1 : state.tlen + 1; errcode = end_segment(&state, false); if (errcode != REG_OK) goto err; } continue; /* * If a repetition marker, erases the repeting character * and terminates the segment, otherwise treated as a normal * character. * BRE: repetition marker if ESCAPED. * ERE: repetition marker if NOT ESCAPED. */ case L'{': /* Be more permissive at the beginning of the pattern */ if (state.escaped && (state.procidx == 1)) { store_char(&state); continue; } else if (state.procidx == 0) { store_char(&state); continue; } if (state.escaped ^ state.ere) { drop_last_char(&state); parse_unit(&state, L'{', L'}'); errcode = end_segment(&state, true); if (errcode != REG_OK) goto err; } else { store_char(&state); continue; } continue; /* * Terminates the current segment if used for a subexpression, * otherwise treated as a normal character. * BRE: subexpression if ESCAPED. * ERE: subexpression if NOT ESCAPED. */ case L'(': if (state.escaped ^ state.ere) { parse_unit(&state, L'(', L')'); errcode = end_segment(&state, true); if (errcode != REG_OK) goto err; } else { store_char(&state); continue; } continue; /* * Sets escaped flag. * Escaped escape is treated as a normal character. * (This is also the GNU behaviour.) */ case L'\\': if (state.escaped) { store_char(&state); continue; } else state.escaped = true; continue; /* * BRE: If not the first character and not escaped, erases the * last character and terminates the segment. * Otherwise treated as a normal character. * ERE: Skipped if first character (GNU), rest is like in BRE. */ case L'*': /* Be more permissive at the beginning of the pattern */ if (state.escaped || (!state.ere && (state.procidx == 0))) { store_char(&state); continue; } else { drop_last_char(&state); errcode = end_segment(&state, true); if (errcode != REG_OK) goto err; } continue; /* * BRE: it is a normal character, behavior is undefined * when escaped. * ERE: it is special unless escaped. Terminate segment * when not escaped. Last character is not removed because it * must occur at least once. It is skipped when first * character (GNU). */ case L'+': /* Be more permissive at the beginning of the pattern */ if (state.ere && (state.procidx == 0)) continue; else if (state.ere ^ state.escaped) { errcode = end_segment(&state, true); if (errcode != REG_OK) goto err; } else { store_char(&state); continue; } continue; /* * BRE: it is a normal character, behavior is undefined * when escaped. * ERE: it is special unless escaped. Terminate segment * when not escaped. Last character is removed. Skipped when * first character (GNU). */ case L'?': /* Be more permissive at the beginning of the pattern */ if (state.ere && (state.procidx == 0)) continue; if (state.ere ^ state.escaped) { drop_last_char(&state); errcode = end_segment(&state, true); if (errcode != REG_OK) goto err; } else { store_char(&state); continue; } continue; /* * BRE: it is a normal character, behavior is undefined * when escaped. * ERE: alternation marker; unsupported. */ case L'|': if (state.ere ^ state.escaped) { errcode = REG_BADPAT; goto err; } else { store_char(&state); continue; } continue; /* * BRE/ERE: matches any single character; normal character * if escaped. */ case L'.': if (state.escaped) { store_char(&state); continue; } else { state.has_dot = true; state.tlen = (state.tlen == -1) ? -1 : state.tlen + 1; errcode = end_segment(&state, false); if (errcode != REG_OK) goto err; } continue; case L'\n': state.has_lf = true; store_char(&state); continue; /* * If escaped, terminates segment. * Otherwise adds current character to the current segment * by copying it to the temporary space. */ default: if (state.escaped) { if (state.regex[state.procidx] == L'n') { state.has_lf = true; store(&state, L'\n'); continue; } errcode = end_segment(&state, true); if (errcode != REG_OK) goto err; } else { store_char(&state); continue; } continue; } } if (state.heurpos > 0) { errcode = end_segment(&state, false); if (errcode != REG_OK) goto err; } h->heur = malloc(sizeof(fastmatch_t)); if (!h->heur) { errcode = REG_ESPACE; goto err; } errcode = fill_heuristics(&state, h); if (errcode != REG_OK) goto err; errcode = REG_OK; err: if ((errcode != REG_OK) && (h->heur != NULL)) frec_free_fast(h->heur); free_state(&state); return (errcode); }