vector<Point> outerTrees(vector<Point>& points) { auto cmp = [](const Point &p1, const Point &p2) -> bool { return p1.x == p2.x ? (p1.y < p2.y) : (p1.x < p2.x); }; sort(points.begin(), points.end(), cmp); vector<Point> b, t; // bottom, top for (auto &p : points) { while (b.size() >= 2 && cross_prod(b[b.size()-2], b[b.size()-1], p) < 0) { b.pop_back(); } b.push_back(p); } for (auto &p : points) { while (t.size() >= 2 && cross_prod(t[t.size()-2], t[t.size()-1], p) > 0) { t.pop_back(); } t.push_back(p); } set<Point, decltype(cmp)> uniq(cmp); for (auto &p : b) { uniq.insert(p); } for (auto &p : t) { uniq.insert(p); } vector<Point> ans(uniq.begin(), uniq.end()); return ans; }
SummaryConfig::SummaryConfig( const Deck& deck, const Schedule& schedule, const TableManager& tables, const ParseContext& parseContext, const GridDims& dims) { SUMMARYSection section( deck ); for( auto& x : section ) handleKW( this->keywords, x, schedule, tables, parseContext, dims); if( section.hasKeyword( "ALL" ) ) this->merge( { ALL_keywords, schedule, tables, parseContext, dims} ); if( section.hasKeyword( "GMWSET" ) ) this->merge( { GMWSET_keywords, schedule, tables, parseContext, dims} ); if( section.hasKeyword( "FMWSET" ) ) this->merge( { FMWSET_keywords, schedule, tables, parseContext, dims} ); if (section.hasKeyword( "PERFORMA" ) ) this->merge( { PERFORMA_keywords, schedule, tables, parseContext, dims} ); uniq( this->keywords ); for (const auto& kw: this->keywords) { this->short_keywords.insert( kw.keyword() ); this->summary_keywords.insert( kw.gen_key() ); } }
int main (int argc, char const *const *argv) { genalloc lines = GENALLOC_ZERO ; /* array of stralloc */ char sep = '\n' ; int flagcheck = 0 ; PROG = "s6-sort" ; { subgetopt_t l = SUBGETOPT_ZERO ; for (;;) { register int opt = subgetopt_r(argc, argv, "bcfru0", &l) ; if (opt == -1) break ; switch (opt) { case 'b' : flagnoblanks = 1 ; break ; case 'c' : flagcheck = 1 ; break ; case 'f' : comp = &case_diffb ; break ; case 'r' : flagreverse = 1 ; break ; case 'u' : flaguniq = 1 ; break ; case '0' : sep = '\0' ; break ; default : strerr_dieusage(100, USAGE) ; } } argc -= l.ind ; argv += l.ind ; } if (slurplines(&lines, sep) < 0) strerr_diefu1sys(111, "read from stdin") ; if (flagcheck) return !check(genalloc_s(stralloc, &lines), genalloc_len(stralloc, &lines)) ; qsort(genalloc_s(stralloc, &lines), genalloc_len(stralloc, &lines), sizeof(stralloc), (qsortcmp_t_ref)&sacmp) ; if (flaguniq) uniq(&lines) ; if (outputlines(genalloc_s(stralloc, &lines), genalloc_len(stralloc, &lines)) < 0) strerr_diefu1sys(111, "write to stdout") ; return 0 ; }
int main() { int x[] = {1, 2, 1, 4, 5, 2, 15, 1, 3, 4}; int i, len = uniq(x, sizeof(x) / sizeof(x[0])); for (i = 0; i < len; i++) printf("%d\n", x[i]); return 0; }
SummaryConfig& SummaryConfig::merge( const SummaryConfig& other ) { this->keywords.insert( this->keywords.end(), other.keywords.begin(), other.keywords.end() ); uniq( this->keywords ); return *this; }
SummaryConfig& SummaryConfig::merge( SummaryConfig&& other ) { auto fst = std::make_move_iterator( other.keywords.begin() ); auto lst = std::make_move_iterator( other.keywords.end() ); this->keywords.insert( this->keywords.end(), fst, lst ); other.keywords.clear(); uniq( this->keywords ); return *this; }
widget::widget(const char *path, const char *options): handler() { _type = "undefined-widget"; _parent = NULL; // no parent defined _path = (path? path: (char *)uniq()); _options = (options? options: ""); _seq = "<Button-1>"; // mouseclick as default bindsequence created++; }
static int process(const char *fpath_bin, const char *fpath_uniq, const char *fpath_text) { #if INTERFACE_TYPE == 0 FILE *fp_bin = fopen(fpath_bin, "r+b"); if (!fp_bin) return -1; fseek(fp_bin, 0, SEEK_END); // sel_sort(ftell(fp_bin)/sizeof(rec_t), sizeof(rec_t), fp_bin, rec_stdio_getter, rec_stdio_setter, rec_stdio_cmp); heap_sort(ftell(fp_bin)/sizeof(rec_t), sizeof(rec_t), fp_bin, rec_stdio_getter, rec_stdio_setter, rec_stdio_cmp); fclose(fp_bin); #elif INTERFACE_TYPE == 1 || INTERFACE_TYPE == 2 || INTERFACE_TYPE == 3 int fd_bin = open(fpath_bin, O_RDWR); if (fd_bin == -1) return -1; #if INTERFACE_TYPE == 2 off_t f_len = lseek(fd_bin, 0, SEEK_END); lseek(fd_bin, 0, SEEK_SET); rec_t *rec_l = (rec_t*)mmap(NULL, f_len, PROT_WRITE, MAP_SHARED, fd_bin, 0); heap_sort(f_len/sizeof(rec_t), sizeof(rec_t), rec_l, rec_mem_getter, rec_mem_setter, rec_mem_cmp); munmap(rec_l, f_len); #elif INTERFACE_TYPE == 3 off_t f_len = lseek(fd_bin, 0, SEEK_END); rec_t *rec_l = (rec_t*)malloc(f_len); lseek(fd_bin, 0, SEEK_SET); read(fd_bin, rec_l, f_len); heap_sort(f_len/sizeof(rec_t), sizeof(rec_t), rec_l, rec_mem_getter, rec_mem_setter, rec_mem_cmp); lseek(fd_bin, 0, SEEK_SET); write(fd_bin, rec_l, f_len); free(rec_l); #else heap_sort(lseek(fd_bin, 0, SEEK_END)/sizeof(rec_t), sizeof(rec_t), (void*)fd_bin, rec_posix_getter, rec_posix_setter, rec_posix_cmp); #endif close(fd_bin); #endif FILE *fp_uniq = uniq(fpath_bin, fpath_uniq); write_to_text(fpath_text, fp_uniq); fclose(fp_uniq); return 0; }
void load_command_list(const char *prefix, struct cmdnames *main_cmds, struct cmdnames *other_cmds) { const char *env_path = getenv("PATH"); char *exec_path = get_argv_exec_path(); if (exec_path) { list_commands_in_dir(main_cmds, exec_path, prefix); qsort(main_cmds->names, main_cmds->cnt, sizeof(*main_cmds->names), cmdname_compare); uniq(main_cmds); } if (env_path) { char *paths, *path, *colon; path = paths = strdup(env_path); while (1) { if ((colon = strchr(path, ':'))) *colon = 0; if (!exec_path || strcmp(path, exec_path)) list_commands_in_dir(other_cmds, path, prefix); if (!colon) break; path = colon + 1; } free(paths); qsort(other_cmds->names, other_cmds->cnt, sizeof(*other_cmds->names), cmdname_compare); uniq(other_cmds); } free(exec_path); exclude_cmds(other_cmds, main_cmds); }
static void run_search(struct token*toks) { binop_init(); binop24_init(); result = evaluate(toks, -1, lm_any, NULL); progress("se: result.count == %lu\n", (unsigned long)result.count); if (do_uniq && (res_gran == g_word || res_gran == g_grapheme)) do_uniq = 0; if (do_uniq && result.count > 1) { uniq(&result); progress("se: post-uniq result.count == %lu\n", (unsigned long)result.count); } }
SummaryConfig::SummaryConfig( const Deck& deck, const Schedule& schedule, const Eclipse3DProperties& props, const ParseContext& parseContext, std::array< int, 3 > n_xyz ) { SUMMARYSection section( deck ); for( auto& x : section ) handleKW( this->keywords, x, schedule, props, parseContext, n_xyz ); if( section.hasKeyword( "ALL" ) ) this->merge( { ALL_keywords, schedule, props, parseContext, n_xyz } ); uniq( this->keywords ); for (const auto& kw: this->keywords) this->short_keywords.insert( kw.keyword() ); }
int main(int argc, char *argv[]) { FILE *fp[2] = { stdin, stdout }; int ret = 0, i; char *fname[2] = { "<stdin>", "<stdout>" }; ARGBEGIN { case 'c': countfmt = "%7ld "; break; case 'd': dflag = 1; break; case 'u': uflag = 1; break; case 'f': fskip = estrtonum(EARGF(usage()), 0, INT_MAX); break; case 's': sskip = estrtonum(EARGF(usage()), 0, INT_MAX); break; default: usage(); } ARGEND; if (argc > 2) usage(); for (i = 0; i < argc; i++) { if (strcmp(argv[i], "-")) { fname[i] = argv[i]; if (!(fp[i] = fopen(argv[i], (i == 0) ? "r" : "w"))) eprintf("fopen %s:", argv[i]); } } uniq(fp[0], fp[1]); uniqfinish(fp[1]); ret |= fshut(fp[0], fname[0]) | fshut(fp[1], fname[1]); return ret; }
// Update combo box containing TEXT static void update_combo_box(Widget text, HistoryFilter filter) { StringArray entries; for (int i = gdb_history.size() - 1; i >= 0; i--) { const string& entry = gdb_history[i]; string arg = filter(entry); if (arg.empty()) continue; // Empty arg if (entries.size() > 0 && entries[entries.size() - 1] == arg) continue; // Adjacent duplicate if (app_data.popdown_history_size > 0 && entries.size() >= int(app_data.popdown_history_size)) break; // Enough entries bool found_duplicate = false; if (!app_data.sort_popdown_history) { // We'll not be sorted. If we already have this value, // ignore new entry. for (int j = 0; !found_duplicate && j < entries.size(); j++) found_duplicate = (entries[j] == arg); } if (!found_duplicate) entries += arg; } if (app_data.sort_popdown_history) { smart_sort(entries); uniq(entries); } ComboBoxSetList(text, entries); }
int main(int argc, char *argv[]){ int i, j; int no; i = 0; while(fgets(ngram[i], N ,stdin) != NULL){ if(i >= ITEMNO){ fprintf(stderr, "ngram이 최대 수에 도달했씁니다.\n"); break; } ++i; } qsort(ngram, i, N, (int (*)(const void *, const void *))strcmp); no = uniq(i, ngram, result); qsort(result, no, N+NUMF,(int (*)(const void *, const void *))rescmp); for(j = 0; j<i;++j)printf("%s", result[j]); return 0; }
int main() { int x[] = {1, 2, 1, 4, 5, 2, 15, 1, 3, 4}; int i, len = uniq(x, sizeof(x) / sizeof(x[0])); for (i = 0; i < len; i++) printf("%d\n", x[i]);
const char *help_unknown_cmd(const char *cmd) { int i, n, best_similarity = 0; struct cmdnames main_cmds, other_cmds; memset(&main_cmds, 0, sizeof(main_cmds)); memset(&other_cmds, 0, sizeof(other_cmds)); memset(&aliases, 0, sizeof(aliases)); git_config(git_unknown_cmd_config, NULL); load_command_list("git-", &main_cmds, &other_cmds); add_cmd_list(&main_cmds, &aliases); add_cmd_list(&main_cmds, &other_cmds); qsort(main_cmds.names, main_cmds.cnt, sizeof(*main_cmds.names), cmdname_compare); uniq(&main_cmds); /* This abuses cmdname->len for levenshtein distance */ for (i = 0, n = 0; i < main_cmds.cnt; i++) { int cmp = 0; /* avoid compiler stupidity */ const char *candidate = main_cmds.names[i]->name; /* * An exact match means we have the command, but * for some reason exec'ing it gave us ENOENT; probably * it's a bad interpreter in the #! line. */ if (!strcmp(candidate, cmd)) die(_(bad_interpreter_advice), cmd, cmd); /* Does the candidate appear in common_cmds list? */ while (n < ARRAY_SIZE(common_cmds) && (cmp = strcmp(common_cmds[n].name, candidate)) < 0) n++; if ((n < ARRAY_SIZE(common_cmds)) && !cmp) { /* Yes, this is one of the common commands */ n++; /* use the entry from common_cmds[] */ if (starts_with(candidate, cmd)) { /* Give prefix match a very good score */ main_cmds.names[i]->len = 0; continue; } } main_cmds.names[i]->len = levenshtein(cmd, candidate, 0, 2, 1, 3) + 1; } qsort(main_cmds.names, main_cmds.cnt, sizeof(*main_cmds.names), levenshtein_compare); if (!main_cmds.cnt) die(_("Uh oh. Your system reports no Git commands at all.")); /* skip and count prefix matches */ for (n = 0; n < main_cmds.cnt && !main_cmds.names[n]->len; n++) ; /* still counting */ if (main_cmds.cnt <= n) { /* prefix matches with everything? that is too ambiguous */ best_similarity = SIMILARITY_FLOOR + 1; } else { /* count all the most similar ones */ for (best_similarity = main_cmds.names[n++]->len; (n < main_cmds.cnt && best_similarity == main_cmds.names[n]->len); n++) ; /* still counting */ } if (autocorrect && n == 1 && SIMILAR_ENOUGH(best_similarity)) { const char *assumed = main_cmds.names[0]->name; main_cmds.names[0] = NULL; clean_cmdnames(&main_cmds); fprintf_ln(stderr, _("WARNING: You called a Git command named '%s', " "which does not exist.\n" "Continuing under the assumption that you meant '%s'"), cmd, assumed); if (autocorrect > 0) { fprintf_ln(stderr, _("in %0.1f seconds automatically..."), (float)autocorrect/10.0); poll(NULL, 0, autocorrect * 100); } return assumed; } fprintf_ln(stderr, _("git: '%s' is not a git command. See 'git --help'."), cmd); if (SIMILAR_ENOUGH(best_similarity)) { fprintf_ln(stderr, Q_("\nDid you mean this?", "\nDid you mean one of these?", n)); for (i = 0; i < n; i++) fprintf(stderr, "\t%s\n", main_cmds.names[i]->name); } exit(1); }
const char *help_unknown_cmd(const char *cmd) { int i, n, best_similarity = 0; struct cmdnames main_cmds, other_cmds; memset(&main_cmds, 0, sizeof(main_cmds)); memset(&other_cmds, 0, sizeof(other_cmds)); memset(&aliases, 0, sizeof(aliases)); git_config(git_unknown_cmd_config, NULL); load_command_list("git-", &main_cmds, &other_cmds); add_cmd_list(&main_cmds, &aliases); add_cmd_list(&main_cmds, &other_cmds); qsort(main_cmds.names, main_cmds.cnt, sizeof(main_cmds.names), cmdname_compare); uniq(&main_cmds); /* This reuses cmdname->len for similarity index */ for (i = 0; i < main_cmds.cnt; ++i) main_cmds.names[i]->len = levenshtein(cmd, main_cmds.names[i]->name, 0, 2, 1, 4); qsort(main_cmds.names, main_cmds.cnt, sizeof(*main_cmds.names), levenshtein_compare); if (!main_cmds.cnt) die ("Uh oh. Your system reports no Git commands at all."); best_similarity = main_cmds.names[0]->len; n = 1; while (n < main_cmds.cnt && best_similarity == main_cmds.names[n]->len) ++n; if (autocorrect && n == 1 && SIMILAR_ENOUGH(best_similarity)) { const char *assumed = main_cmds.names[0]->name; main_cmds.names[0] = NULL; clean_cmdnames(&main_cmds); fprintf(stderr, "WARNING: You called a Git command named '%s', " "which does not exist.\n" "Continuing under the assumption that you meant '%s'\n", cmd, assumed); if (autocorrect > 0) { fprintf(stderr, "in %0.1f seconds automatically...\n", (float)autocorrect/10.0); poll(NULL, 0, autocorrect * 100); } return assumed; } fprintf(stderr, "git: '%s' is not a git command. See 'git --help'.\n", cmd); if (SIMILAR_ENOUGH(best_similarity)) { fprintf(stderr, "\nDid you mean %s?\n", n < 2 ? "this": "one of these"); for (i = 0; i < n; i++) fprintf(stderr, "\t%s\n", main_cmds.names[i]->name); } exit(1); }
title_set_info_t * DVDGetFileSet(char *dvd) { /* * TODO Fix close of files if * we error out * We also assume that all * DVD files are of valid * size i.e. file%2048 == 0 */ /* title interation */ int title_sets; int titles; int counter; int i; /* DVD file structures */ dvd_reader_t * _dvd = NULL; ifo_handle_t * vmg_ifo = NULL; ifo_handle_t * vts_ifo = NULL; dvd_file_t * vmg_vob_file = NULL; dvd_file_t * vmg_ifo_file = NULL; dvd_file_t * vts_ifo_file = NULL; dvd_file_t * vts_menu_file = NULL; dvd_file_t * vts_title_file = NULL; /* The sizes it self of each file */ int ifo; int bup; int menu_vob; int title_vob; /* Arrays keeping the title - filset relationship */ int * sector; int * title; int * title_sets_array; int * sector_sets_array; /* DVD Video files */ struct stat fileinfo; char temppoint[PATH_MAX + 1]; /* The Title Set Info struct*/ title_set_info_t * title_set_info; /* Temporary mount point - to be used later */ char mountpoint[PATH_MAX + 1]; strncpy(mountpoint, dvd, sizeof (mountpoint)); mountpoint[sizeof (mountpoint)-1] = '\0'; _dvd = DVDOpen(dvd); if (!_dvd) { #ifdef USE_LIBSCHILY errmsgno(EX_BAD, "Can't open device '%s'\n", dvd); #else fprintf(stderr, "Can't open device\n"); #endif return (0); } vmg_ifo = ifoOpen(_dvd, 0); if (!vmg_ifo) { #ifdef USE_LIBSCHILY errmsgno(EX_BAD, "Can't open VMG info for '%s'.\n", dvd); #else fprintf(stderr, "Can't open VMG info.\n"); #endif return (0); } /* Check mount point */ snprintf(temppoint, sizeof (temppoint), "%s/VIDEO_TS/VIDEO_TS.IFO", mountpoint); if (stat(temppoint, &fileinfo) < 0) { /* If we can't stat the file, give up */ #ifdef USE_LIBSCHILY errmsg("Can't stat %s\n", temppoint); #else fprintf(stderr, "Can't stat %s\n", temppoint); perror(""); #endif return (0); } title_sets = vmg_ifo->vmgi_mat->vmg_nr_of_title_sets; titles = vmg_ifo->tt_srpt->nr_of_srpts; sector = e_malloc(titles * sizeof (int)); memset(sector, 0, titles * sizeof (int)); title = e_malloc(titles * sizeof (int)); title_sets_array = e_malloc(title_sets * sizeof (int)); sector_sets_array = e_malloc(title_sets * sizeof (int)); title_set_info = (title_set_info_t *)e_malloc(sizeof (title_set_info_t)); title_set_info->title_set = (title_set_t *)e_malloc((title_sets + 1) * sizeof (title_set_t)); title_set_info->num_titles = title_sets; /* Fill and sort the arrays for titles*/ if (titles >= 1) { for (counter = 0; counter < titles; counter++) { sector[counter] = vmg_ifo->tt_srpt->title[counter].title_set_sector; title[counter] = counter + 1; } } /* Yes, we should probably do a better sort than B - but what the heck*/ bsort(sector, title, titles); /* * Since title sets and titles are not the same we will need to sort * out "bogus" titles */ uniq(sector, title, title_sets_array, sector_sets_array, titles); /* Open VIDEO_TS.VOB is present */ vmg_vob_file = DVDOpenFile(_dvd, 0, DVD_READ_MENU_VOBS); /* Check VIDEO_TS title set */ vmg_ifo_file = DVDOpenFile(_dvd, 0, DVD_READ_INFO_FILE); if ((vmg_vob_file == 0) && vmg_ifo->vmgi_mat->vmg_last_sector + 1 < 2 * DVDFileSize(vmg_ifo_file)) { #ifdef USE_LIBSCHILY errmsgno(EX_BAD, "IFO is not of correct size aborting\n"); #else fprintf(stderr, "IFO is not of correct size aborting\n"); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } else if ((vmg_vob_file != 0) && (vmg_ifo->vmgi_mat->vmg_last_sector + 1 < 2 * DVDFileSize(vmg_ifo_file) + DVDFileSize(vmg_vob_file))) { #ifdef USE_LIBSCHILY errmsgno(EX_BAD, "Either VIDEO_TS.IFO or VIDEO_TS.VOB is not of correct size"); #else fprintf(stderr, "Either VIDEO_TS.IFO or VIDEO_TS.VOB is not of correct size"); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } /* Find the actuall right size of VIDEO_TS.IFO */ if (vmg_vob_file == 0) { if (vmg_ifo->vmgi_mat->vmg_last_sector + 1 > 2 * DVDFileSize(vmg_ifo_file)) { ifo = vmg_ifo->vmgi_mat->vmg_last_sector - DVDFileSize(vmg_ifo_file) + 1; } else { ifo = vmg_ifo->vmgi_mat->vmgi_last_sector + 1; } } else { if (vmg_ifo->vmgi_mat->vmgi_last_sector + 1 < vmg_ifo->vmgi_mat->vmgm_vobs) { ifo = vmg_ifo->vmgi_mat->vmgm_vobs; } else { ifo = vmg_ifo->vmgi_mat->vmgi_last_sector + 1; } } title_set_info->title_set[0].size_ifo = ifo * 2048; title_set_info->title_set[0].realsize_ifo = fileinfo.st_size; title_set_info->title_set[0].pad_ifo = ifo - DVDFileSize(vmg_ifo_file); /* Find the actuall right size of VIDEO_TS.VOB */ if (vmg_vob_file != 0) { if (ifo + DVDFileSize(vmg_ifo_file) + DVDFileSize(vmg_vob_file) - 1 < vmg_ifo->vmgi_mat->vmg_last_sector) { menu_vob = vmg_ifo->vmgi_mat->vmg_last_sector - ifo - DVDFileSize(vmg_ifo_file) + 1; } else { menu_vob = vmg_ifo->vmgi_mat->vmg_last_sector - ifo - DVDFileSize(vmg_ifo_file) + 1; } snprintf(temppoint, sizeof (temppoint), "%s/VIDEO_TS/VIDEO_TS.VOB", mountpoint); if (stat(temppoint, &fileinfo) < 0) { #ifdef USE_LIBSCHILY errmsg("calc: Can't stat %s\n", temppoint); #else fprintf(stderr, "calc: Can't stat %s\n", temppoint); perror(""); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } title_set_info->title_set[0].realsize_menu = fileinfo.st_size; title_set_info->title_set[0].pad_menu = menu_vob - DVDFileSize(vmg_vob_file); title_set_info->title_set[0].size_menu = menu_vob * 2048; DVDCloseFile(vmg_vob_file); } else { title_set_info->title_set[0].size_menu = 0; title_set_info->title_set[0].realsize_menu = 0; title_set_info->title_set[0].pad_menu = 0; menu_vob = 0; } /* Finding the actuall right size of VIDEO_TS.BUP */ if (title_sets >= 1) { bup = sector_sets_array[0] - menu_vob - ifo; } else { /* Just in case we burn a DVD-Video without any title_sets */ bup = vmg_ifo->vmgi_mat->vmg_last_sector + 1 - menu_vob - ifo; } /* Never trust the BUP file - use a copy of the IFO */ snprintf(temppoint, sizeof (temppoint), "%s/VIDEO_TS/VIDEO_TS.IFO", mountpoint); if (stat(temppoint, &fileinfo) < 0) { #ifdef USE_LIBSCHILY errmsg("calc: Can't stat %s\n", temppoint); #else fprintf(stderr, "calc: Can't stat %s\n", temppoint); perror(""); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } title_set_info->title_set[0].realsize_bup = fileinfo.st_size; title_set_info->title_set[0].size_bup = bup * 2048; title_set_info->title_set[0].pad_bup = bup - DVDFileSize(vmg_ifo_file); /* Take care of the titles which we don't have in VMG */ title_set_info->title_set[0].number_of_vob_files = 0; title_set_info->title_set[0].realsize_vob[0] = 0; title_set_info->title_set[0].pad_title = 0; DVDCloseFile(vmg_ifo_file); if (title_sets >= 1) { for (counter = 0; counter < title_sets; counter++) { vts_ifo = ifoOpen(_dvd, counter + 1); if (!vts_ifo) { #ifdef USE_LIBSCHILY errmsgno(EX_BAD, "Can't open VTS info.\n"); #else fprintf(stderr, "Can't open VTS info.\n"); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } snprintf(temppoint, sizeof (temppoint), "%s/VIDEO_TS/VTS_%02i_0.IFO", mountpoint, counter + 1); if (stat(temppoint, &fileinfo) < 0) { #ifdef USE_LIBSCHILY errmsg("calc: Can't stat %s\n", temppoint); #else fprintf(stderr, "calc: Can't stat %s\n", temppoint); perror(""); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } /* Test if VTS_XX_0.VOB is present */ vts_menu_file = DVDOpenFile(_dvd, counter + 1, DVD_READ_MENU_VOBS); /* Test if VTS_XX_X.VOB are present */ vts_title_file = DVDOpenFile(_dvd, counter + 1, DVD_READ_TITLE_VOBS); /* Check VIDEO_TS.IFO */ vts_ifo_file = DVDOpenFile(_dvd, counter + 1, DVD_READ_INFO_FILE); /* * Checking that title will fit in the * space given by the ifo file */ if (vts_ifo->vtsi_mat->vts_last_sector + 1 < 2 * DVDFileSize(vts_ifo_file)) { #ifdef USE_LIBSCHILY errmsgno(EX_BAD, "IFO is not of correct size aborting.\n"); #else fprintf(stderr, "IFO is not of correct size aborting\n"); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } else if ((vts_title_file != 0) && (vts_menu_file != 0) && (vts_ifo->vtsi_mat->vts_last_sector + 1 < 2 * DVDFileSize(vts_ifo_file) + DVDFileSize(vts_title_file) + DVDFileSize(vts_menu_file))) { #ifdef USE_LIBSCHILY errmsgno(EX_BAD, "Either VIDEO_TS.IFO or VIDEO_TS.VOB is not of correct size.\n"); #else fprintf(stderr, "Either VIDEO_TS.IFO or VIDEO_TS.VOB is not of correct size"); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } else if ((vts_title_file != 0) && (vts_menu_file == 0) && (vts_ifo->vtsi_mat->vts_last_sector + 1 < 2 * DVDFileSize(vts_ifo_file) + DVDFileSize(vts_title_file))) { #ifdef USE_LIBSCHILY errmsgno(EX_BAD, "Either VIDEO_TS.IFO or VIDEO_TS.VOB is not of correct size.\n"); #else fprintf(stderr, "Either VIDEO_TS.IFO or VIDEO_TS.VOB is not of correct size"); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } else if ((vts_menu_file != 0) && (vts_title_file == 0) && (vts_ifo->vtsi_mat->vts_last_sector + 1 < 2 * DVDFileSize(vts_ifo_file) + DVDFileSize(vts_menu_file))) { #ifdef USE_LIBSCHILY errmsgno(EX_BAD, "Either VIDEO_TS.IFO or VIDEO_TS.VOB is not of correct size.\n"); #else fprintf(stderr, "Either VIDEO_TS.IFO or VIDEO_TS.VOB is not of correct size"); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } /* Find the actuall right size of VTS_XX_0.IFO */ if ((vts_title_file == 0) && (vts_menu_file == 0)) { if (vts_ifo->vtsi_mat->vts_last_sector + 1 > 2 * DVDFileSize(vts_ifo_file)) { ifo = vts_ifo->vtsi_mat->vts_last_sector - DVDFileSize(vts_ifo_file) + 1; } else { ifo = vts_ifo->vtsi_mat->vts_last_sector - DVDFileSize(vts_ifo_file) + 1; } } else if (vts_title_file == 0) { if (vts_ifo->vtsi_mat->vtsi_last_sector + 1 < vts_ifo->vtsi_mat->vtstt_vobs) { ifo = vmg_ifo->vtsi_mat->vtstt_vobs; } else { ifo = vmg_ifo->vtsi_mat->vtstt_vobs; } } else { if (vts_ifo->vtsi_mat->vtsi_last_sector + 1 < vts_ifo->vtsi_mat->vtsm_vobs) { ifo = vts_ifo->vtsi_mat->vtsm_vobs; } else { ifo = vts_ifo->vtsi_mat->vtsi_last_sector + 1; } } title_set_info->title_set[counter + 1].size_ifo = ifo * 2048; title_set_info->title_set[counter + 1].realsize_ifo = fileinfo.st_size; title_set_info->title_set[counter + 1].pad_ifo = ifo - DVDFileSize(vts_ifo_file); /* Find the actuall right size of VTS_XX_0.VOB */ if (vts_menu_file != 0) { if (vts_ifo->vtsi_mat->vtsm_vobs == 0) { /* * Apparently start sector 0 means that * VTS_XX_0.VOB is empty after all... */ menu_vob = 0; if (DVDFileSize(vts_menu_file) != 0) { /* * Paranoia: we most likely never * come here... */ #ifdef USE_LIBSCHILY errmsgno(EX_BAD, "%s/VIDEO_TS/VTS_%02i_0.IFO appears to be corrupted.\n", mountpoint, counter+1); #else fprintf(stderr, "%s/VIDEO_TS/VTS_%02i_0.IFO appears to be corrupted.\n", mountpoint, counter+1); #endif return (0); } } else if ((vts_title_file != 0) && (vts_ifo->vtsi_mat->vtstt_vobs - vts_ifo->vtsi_mat->vtsm_vobs > DVDFileSize(vts_menu_file))) { menu_vob = vts_ifo->vtsi_mat->vtstt_vobs - vts_ifo->vtsi_mat->vtsm_vobs; } else if ((vts_title_file == 0) && (vts_ifo->vtsi_mat->vtsm_vobs + DVDFileSize(vts_menu_file) + DVDFileSize(vts_ifo_file) - 1 < vts_ifo->vtsi_mat->vts_last_sector)) { menu_vob = vts_ifo->vtsi_mat->vts_last_sector - DVDFileSize(vts_ifo_file) - vts_ifo->vtsi_mat->vtsm_vobs + 1; } else { menu_vob = vts_ifo->vtsi_mat->vtstt_vobs - vts_ifo->vtsi_mat->vtsm_vobs; } snprintf(temppoint, sizeof (temppoint), "%s/VIDEO_TS/VTS_%02i_0.VOB", mountpoint, counter + 1); if (stat(temppoint, &fileinfo) < 0) { #ifdef USE_LIBSCHILY errmsg("calc: Can't stat %s\n", temppoint); #else fprintf(stderr, "calc: Can't stat %s\n", temppoint); perror(""); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } title_set_info->title_set[counter + 1].realsize_menu = fileinfo.st_size; title_set_info->title_set[counter + 1].size_menu = menu_vob * 2048; title_set_info->title_set[counter + 1].pad_menu = menu_vob - DVDFileSize(vts_menu_file); } else { title_set_info->title_set[counter + 1].size_menu = 0; title_set_info->title_set[counter + 1].realsize_menu = 0; title_set_info->title_set[counter + 1].pad_menu = 0; menu_vob = 0; } /* Find the actuall total size of VTS_XX_[1 to 9].VOB */ if (vts_title_file != 0) { if (ifo + menu_vob + DVDFileSize(vts_ifo_file) - 1 < vts_ifo->vtsi_mat->vts_last_sector) { title_vob = vts_ifo->vtsi_mat->vts_last_sector + 1 - ifo - menu_vob - DVDFileSize(vts_ifo_file); } else { title_vob = vts_ifo->vtsi_mat->vts_last_sector + 1 - ifo - menu_vob - DVDFileSize(vts_ifo_file); } /* * Find out how many vob files * and the size of them */ for (i = 0; i < 9; ++i) { snprintf(temppoint, sizeof (temppoint), "%s/VIDEO_TS/VTS_%02i_%i.VOB", mountpoint, counter + 1, i + 1); if (stat(temppoint, &fileinfo) < 0) { break; } title_set_info->title_set[counter + 1].realsize_vob[i] = fileinfo.st_size; } title_set_info->title_set[counter + 1].number_of_vob_files = i; title_set_info->title_set[counter + 1].size_title = title_vob * 2048; title_set_info->title_set[counter + 1].pad_title = title_vob - DVDFileSize(vts_title_file); } else { title_set_info->title_set[counter + 1].number_of_vob_files = 0; title_set_info->title_set[counter + 1].realsize_vob[0] = 0; title_set_info->title_set[counter + 1].size_title = 0; title_set_info->title_set[counter + 1].pad_title = 0; title_vob = 0; } /* Find the actuall total size of VTS_XX_0.BUP */ if (title_sets - 1 > counter) { bup = sector_sets_array[counter+1] - sector_sets_array[counter] - title_vob - menu_vob - ifo; } else { bup = vts_ifo->vtsi_mat->vts_last_sector + 1 - title_vob - menu_vob - ifo; } /* Never trust the BUP use a copy of the IFO */ snprintf(temppoint, sizeof (temppoint), "%s/VIDEO_TS/VTS_%02i_0.IFO", mountpoint, counter + 1); if (stat(temppoint, &fileinfo) < 0) { #ifdef USE_LIBSCHILY errmsg("calc: Can't stat %s\n", temppoint); #else fprintf(stderr, "calc: Can't stat %s\n", temppoint); perror(""); #endif DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); DVDFreeFileSet(title_set_info); return (0); } title_set_info->title_set[counter + 1].size_bup = bup * 2048; title_set_info->title_set[counter + 1].realsize_bup = fileinfo.st_size; title_set_info->title_set[counter + 1].pad_bup = bup - DVDFileSize(vts_ifo_file); /* Closing files */ if (vts_menu_file != 0) { DVDCloseFile(vts_menu_file); } if (vts_title_file != 0) { DVDCloseFile(vts_title_file); } if (vts_ifo_file != 0) { DVDCloseFile(vts_ifo_file); } ifoClose(vts_ifo); } } DVDFreeFileSetArrays(sector, title, title_sets_array, sector_sets_array); /* Close the VMG ifo file we got all the info we need */ ifoClose(vmg_ifo); /* Close the DVD */ DVDClose(_dvd); /* Return the actuall info*/ return (title_set_info); }
int main(int argc, char *argv[]) { DB *db; int ch; const char *fname = _PATH_SERVICES; const char *dbname = _PATH_SERVICES_DB; int warndup = 1; int unique = 0; int otherflag = 0; size_t cnt = 0; StringList *sl, ***svc; size_t port, proto; setprogname(argv[0]); while ((ch = getopt(argc, argv, "qo:u")) != -1) switch (ch) { case 'q': otherflag = 1; warndup = 0; break; case 'o': otherflag = 1; dbname = optarg; break; case 'u': unique++; break; case '?': default: usage(); } argc -= optind; argv += optind; if (argc > 1 || (unique && otherflag)) usage(); if (argc == 1) fname = argv[0]; if (unique) uniq(fname); svc = parseservices(fname, sl = sl_init()); if (atexit(cleanup)) err(1, "Cannot install exit handler"); (void)snprintf(tname, sizeof(tname), "%s.tmp", dbname); db = dbopen(tname, O_RDWR | O_CREAT | O_EXCL, (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH), DB_HASH, &hinfo); if (!db) err(1, "Error opening temporary database `%s'", tname); for (port = 0; port < PMASK + 1; port++) { if (svc[port] == NULL) continue; for (proto = 0; proto < PROTOMAX; proto++) { StringList *s; if ((s = svc[port][proto]) == NULL) continue; add(db, s, port, getprotostr(sl, proto), &cnt, warndup); } free(svc[port]); } free(svc); sl_free(sl, 1); if ((db->close)(db)) err(1, "Error closing temporary database `%s'", tname); if (rename(tname, dbname) == -1) err(1, "Cannot rename `%s' to `%s'", tname, dbname); return 0; }
int main(void) { initIO(); while (1) { if (TCNT1<2000) { } if ((TCNT1>=2000) && (TCNT1<=5500) && (dataOK == 1)) { //reset channels from high to low if (TCNT1>=CH1_out && bit_is_set(PORTB, PIN0)) PORTB &= ~(1<<PIN0); if (TCNT1>=CH2_out && bit_is_set(PORTB, PIN1)) PORTB &= ~(1<<PIN1); if (TCNT1>=CH3_out && bit_is_set(PORTB, PIN2)) PORTB &= ~(1<<PIN2); if (TCNT1>=CH4_out && bit_is_set(PORTB, PIN3)) PORTB &= ~(1<<PIN3); if (TCNT1>=CH5_out && bit_is_set(PORTB, PIN4)) PORTB &= ~(1<<PIN4); if (TCNT1>=CH6_out && bit_is_set(PORTD, PIN0)) PORTD &= ~(1<<PIN0); if (TCNT1>=CH7_out && bit_is_set(PORTD, PIN1)) PORTD &= ~(1<<PIN1); if (TCNT1>=CH8_out && bit_is_set(PORTD, PIN2)) PORTD &= ~(1<<PIN2); if (TCNT1>=CH9_out && bit_is_set(PORTD, PIN3)) PORTD &= ~(1<<PIN3); if (TCNT1>=CH10_out && bit_is_set(PORTD, PIN4)) PORTD &= ~(1<<PIN4); if (TCNT1>=CH11_out && bit_is_set(PORTD, PIN5)) PORTD &= ~(1<<PIN5); if (TCNT1>=CH12_out && bit_is_set(PORTD, PIN6)) PORTD &= ~(1<<PIN6); } if ((TCNT1>5500) && (TCNT1<35000)) { CH1_out = uniq(rxbuffer[1], rxbuffer[2]); CH2_out = uniq(rxbuffer[3], rxbuffer[4]); CH3_out = uniq(rxbuffer[5], rxbuffer[6]); CH4_out = uniq(rxbuffer[7], rxbuffer[8]); CH5_out = uniq(rxbuffer[9], rxbuffer[10]); CH6_out = uniq(rxbuffer[11], rxbuffer[12]); CH7_out = uniq(rxbuffer[13], rxbuffer[14]); CH8_out = uniq(rxbuffer[15], rxbuffer[16]); CH9_out = uniq(rxbuffer[17], rxbuffer[18]); CH10_out = uniq(rxbuffer[19], rxbuffer[20]); CH11_out = uniq(rxbuffer[21], rxbuffer[22]); CH12_out = uniq(rxbuffer[23], rxbuffer[24]); //ready for output dataOK = 1; } } return 0; // never reached }
int main(int argc, char *argv[]) { int c; static struct option const long_options[] = { {"help", 0, NULL, 'h'}, {"count", 0, NULL, 'c'}, {"repeated", 0, NULL, 'd'}, {"skip-fields", 1, NULL, 'f'}, {"ignore-case", 0, NULL, 'i'}, {"skip-chars", 1, NULL, 's'}, {"separater", 1, NULL, 'p'}, {NULL, 0, NULL, 0} }; init_option(&g_option); exit_status = EXIT_SUCESS; program_name = argv[0]; while((c = getopt_long(argc, argv, "hHcdf:is:p:", long_options, NULL)) != -1) { switch(c) { case 'h': case 'H': uniq_usage_exit(EXIT_SUCESS); break; case 'c': g_option.c = 1; break; case 'd': g_option.d = 1; break; case 'f': if(optarg) fill_f(optarg); break; case 'i': g_option.i = 1; break; case 's': if(optarg) fill_s(optarg); break; case 'p': if(optarg) fill_p(optarg); break; default: uniq_usage_exit(EXIT_FAILURE); break; } } if(argc - optind != 1) uniq_usage_exit(EXIT_FAILURE); adjust_option(); if(uniq(argv[optind]) != 0) exit_status = EXIT_FAILURE; exit(exit_status); }
std::string countFast() { MessageHandler mh; mh.begin("counting") << " paths of " << typenameof(spec); std::vector<Word> tmp(stateWords + 1); Word* ptmp = tmp.data(); int const n = spec.get_root(state(ptmp)); if (n <= 0) { mh << " ..."; mh.end(0); return (n == 0) ? "0" : "1"; } uint64_t totalStorage[n / 63 + 1]; BigNumber total(totalStorage); total.store(0); size_t maxWidth = 0; //std::cerr << "\nLevel,Width\n"; std::vector<MemoryPool> pools(n + 1); MyVector<MyList<Word> > vnodeTable(n + 1); int numberWords = 1; Word* p0 = vnodeTable[n].alloc_front(stateWords + 1); spec.get_copy(state(p0), state(ptmp)); spec.destruct(state(ptmp)); number(p0).store(1); mh.setSteps(n); for (int i = n; i > 0; --i) { MyList<Word>& vnodes = vnodeTable[i]; size_t m = 0; { UniqTable uniq(vnodes.size(), hasher, hasher); for (MyList<Word>::iterator t = vnodes.begin(); t != vnodes.end(); ++t) { Word* p = *t; Word* pp = uniq.add(p); if (pp == p) { ++m; } else { int w = number(pp).add(number(p)); if (numberWords < w) { numberWords = w; //FIXME might be broken at long skip } number(p).store(0); } } } //std::cerr << i << "," << m << "\n"; maxWidth = std::max(maxWidth, m); MyList<Word>& nextVnodes = vnodeTable[i - 1]; int const nextWords = stateWords + numberWords + 1; Word* pp = nextVnodes.alloc_front(nextWords); for (; !vnodes.empty(); vnodes.pop_front()) { Word* p = vnodes.front(); if (number(p).equals(0)) { spec.destruct(state(p)); continue; } for (int b = 0; b <= 1; ++b) { spec.get_copy(state(pp), state(p)); int ii = spec.get_child(state(pp), i, b); if (ii <= 0) { spec.destruct(state(pp)); if (ii != 0) { total.add(number(p)); } } else if (ii < i - 1) { Word* ppp = vnodeTable[ii].alloc_front( nextWords + (i - ii) / 63); spec.get_copy(state(ppp), state(pp)); spec.destruct(state(pp)); number(ppp).store(number(p)); } else { assert(ii == i - 1); number(pp).store(number(p)); pp = nextVnodes.alloc_front(nextWords); } } spec.destruct(state(p)); } nextVnodes.pop_front(); pools[i].clear(); spec.destructLevel(i); mh.step(); } mh.end(maxWidth); return total; }
/*! @brief main program of the I2C-slave Initializes the timer/counters and the I2C. Constantly updates the duty cycles of the PPM @return int */ int main(void) { int i; cli(); // Disable interrupts usiTwiSlaveInit(SLAVE_ADDR_ATTINY); // TWI slave init //Initialize rxbuffer rxbuffer[0] = HIGH_BYTE( (dutyCycles[0] - 1*8192) ); rxbuffer[1] = LOW_BYTE( (dutyCycles[0] - 1*8192) ); rxbuffer[2] = HIGH_BYTE( (dutyCycles[1] - 2*8192) ); rxbuffer[3] = LOW_BYTE( (dutyCycles[1] - 2*8192) ); rxbuffer[4] = HIGH_BYTE( (dutyCycles[2] - 3*8192) ); rxbuffer[5] = LOW_BYTE( (dutyCycles[2] - 3*8192) ); rxbuffer[6] = HIGH_BYTE( (dutyCycles[3] - 0*8192) ); rxbuffer[7] = LOW_BYTE( (dutyCycles[3] - 0*8192) ); ppmInit(); sei(); // Re-enable interrupts while(1) { /* receivedNewValue is updated whenever a new value is written to the rxbuffer with the corresponding index As always 2 bytes are used for one dutyCycle the interesting values are 1, 3, 5, 7 Then the corresponding value in the dutyCycle array is updated The new value for a dutyCycle is calculated first in a temp-variable. In a previous version it was directly assigned within the atomic block which caused severs problems that the ucontroller stopped responding to the I2C-master. Therefore now only the assignment to dutyCycles[x] is done in atomic block */ uint16_t temp; switch (receivedNewValue) { case 1: //update dutyCycle for channel 0 receivedNewValue = 0; temp = uniq(rxbuffer[1], rxbuffer[0]) + 1 * 8192; ATOMIC_BLOCK(ATOMIC_FORCEON) { dutyCycles[0] = temp; } txbuffer[0] = rxbuffer[0]; txbuffer[1] = rxbuffer[1]; break; case 3: //update dutyCycle for channel 1 receivedNewValue = 0; temp = uniq(rxbuffer[3], rxbuffer[2]) + 2 * 8192; ATOMIC_BLOCK(ATOMIC_FORCEON) { dutyCycles[1] = temp; } txbuffer[2] = rxbuffer[2]; txbuffer[3] = rxbuffer[3]; break; case 5: //update dutyCycle for channel 2 receivedNewValue = 0; temp = uniq(rxbuffer[5], rxbuffer[4]) + 3 * 8192; ATOMIC_BLOCK(ATOMIC_FORCEON) { dutyCycles[2] = temp; } txbuffer[4] = rxbuffer[4]; txbuffer[5] = rxbuffer[5]; break; case 7: //update dutyCycle for channel 3 receivedNewValue = 0; temp = uniq(rxbuffer[7], rxbuffer[6]) + 0 * 8192; ATOMIC_BLOCK(ATOMIC_FORCEON) { dutyCycles[3] = temp; } txbuffer[6] = rxbuffer[6]; txbuffer[7] = rxbuffer[7]; break; } //end.switch } //end.while } //end.main
int main(int argc, char * const*argv) { struct token *toks = NULL; int ntoks = 0; static struct Datum result; f_log = stderr; exit_on_error = TRUE; setlocale(LC_ALL,LOCALE); options(argc, argv, "28cdg:o:p:P:stuvx:"); if (!out_f) out_f = stdout; if (doing_debug) f_log = fopen("se.dbg","w"); /*atf2utf8_init();*/ charsets_init(); langtag_init(); tokinit(); if (pretrim_file || pretrim_args) pretrim_setup(); if (xmldir) toks = tokenize(xmldir_toks(xmldir),&ntoks); else toks = tokenize((const char **)(argv+optind),&ntoks); if (show_tokens) { showtoks(toks,ntoks); } else { binop_init(); binop24_init(); result = evaluate(toks, -1, lm_any, NULL); progress("se: result.count == %lu\n", (unsigned long)result.count); if (do_uniq && (res_gran == g_word || res_gran == g_grapheme)) do_uniq = 0; if (do_uniq && result.count > 1) { uniq(&result); progress("se: post-uniq result.count == %lu\n", (unsigned long)result.count); } if (show_count) printf("%lu\n",(unsigned long)result.count); else if (result.count) { if (xmldir) xmldir_results(xmldir,result.count); if ('v' == id_prefix(result.l.l8p[0]->text_id)) { if (!strcmp(return_index, "cat")) vid_display_proj = vid_proj_xmd; else vid_display_proj = vid_proj_xtf; vid_show_results(&result); } else show_results(&result); } else if (xmldir) xmldir_results(xmldir,result.count); } if (pretrim_args) { list_free(pretrim_args, NULL); pretrim_args = NULL; } if (pretrim) { hash_free(pretrim, NULL); pretrim = NULL; free(pretrim_lines); free(pretrim_content); pretrim_content = NULL; pretrim_lines = NULL; } langtag_term(); return 0; }
/* convert: read the text rewrite rules on fp, generating bog rewrite rules (on fr) and C tables (on ft) for use with tpo */ static void convert (FILE *fp, FILE *fr, FILE *ft) { int phase = IN, lc = 0, id, vused[26], i; char c, l[LSZ], *lp, v[VSZ], *vp; List trul = 0, tlin = 0, brul = 0, blin = 0, patterns = 0; for (i = 0; i < 26; i++) vused[i] = 0; while (fgets(l, LSZ, fp)) { ++lc; if (*l == '#' || *l == '\n') continue; if (!strcmp(l, "=\n")) { /* End of input pattern */ if (phase != IN) error(stringf("Misplaced '=' at line %d", lc)); if (!blin) warning(stringf("Empty input pattern at line %d", lc)); trul = l_append((void *)tlin, trul, ARENA0); tlin = 0; brul = l_append((void *)blin, brul, ARENA0); blin = 0; phase = OUT; continue; } if (!strcmp(l, "+\n")) { /* End of output pattern */ if (phase != OUT) error(stringf("Misplaced '+' at line %d", lc)); brul = l_append((void *)blin, brul, ARENA0); blin = 0; for (i = 0; i < 26; i++) vused[i] = 0; phase = IN; continue; } /* Extend text line list */ for (lp = l; *lp; lp++) ; if (*--lp == '\n') *lp = '\0'; if (phase == IN) tlin = l_append((void*)string(l), tlin, ARENA0); vp = v; /* "Uniqueify" string */ for (lp = l; *lp; lp++) if (*lp == '%') if ((c = tolower(*++lp)) >= 'a' && c <= 'z') { int j = c-'a'; *vp++ = c; *lp = ' '; if (phase == IN) vused[j] = 1; else if (!vused[j]) error(stringf("Symbol '%%%c' used with no prior " "definition at line %d", c, lc)); } else if (c != '%') error(stringf("Illegal expression '%%%c' at line %d", c, lc)); *vp++ = 0; /* Extend list of uniq'd patterns */ if (uniq(l, &lp, &id)) patterns = l_append((void *)lp, patterns, ARENA0); PDEBUG(("convert: %s :: %d\n", lp, id)); /* Extend binary line list (for bog) */ blin = l_append((void *)id, blin, ARENA0); blin = l_append((void *)string(v), blin, ARENA0); } unparsebin(brul, fr); fprintf(ft, "#include \"tpo.h\"\n\n"); unparsepat(patterns, ft); unparsetxt(trul, ft); }
const char *help_unknown_cmd(const char *cmd) { unsigned int i, n = 0, best_similarity = 0; struct cmdnames main_cmds, other_cmds; memset(&main_cmds, 0, sizeof(main_cmds)); memset(&other_cmds, 0, sizeof(main_cmds)); memset(&aliases, 0, sizeof(aliases)); perf_config(perf_unknown_cmd_config, NULL); load_command_list("perf-", &main_cmds, &other_cmds); add_cmd_list(&main_cmds, &aliases); add_cmd_list(&main_cmds, &other_cmds); qsort(main_cmds.names, main_cmds.cnt, sizeof(main_cmds.names), cmdname_compare); uniq(&main_cmds); if (main_cmds.cnt) { /* This reuses cmdname->len for similarity index */ for (i = 0; i < main_cmds.cnt; ++i) main_cmds.names[i]->len = levenshtein(cmd, main_cmds.names[i]->name, 0, 2, 1, 4); qsort(main_cmds.names, main_cmds.cnt, sizeof(*main_cmds.names), levenshtein_compare); best_similarity = main_cmds.names[0]->len; n = 1; while (n < main_cmds.cnt && best_similarity == main_cmds.names[n]->len) ++n; } if (autocorrect && n == 1) { const char *assumed = main_cmds.names[0]->name; main_cmds.names[0] = NULL; clean_cmdnames(&main_cmds); fprintf(stderr, "WARNING: You called a perf program named '%s', " "which does not exist.\n" "Continuing under the assumption that you meant '%s'\n", cmd, assumed); if (autocorrect > 0) { fprintf(stderr, "in %0.1f seconds automatically...\n", (float)autocorrect/10.0); poll(NULL, 0, autocorrect * 100); } return assumed; } fprintf(stderr, "perf: '%s' is not a perf-command. See 'perf --help'.\n", cmd); if (main_cmds.cnt && best_similarity < 6) { fprintf(stderr, "\nDid you mean %s?\n", n < 2 ? "this": "one of these"); for (i = 0; i < n; i++) fprintf(stderr, "\t%s\n", main_cmds.names[i]->name); } exit(1); }
Object() : t(uniq()) { std::cout << "(" << 0 << " " << t << ") "; }