int main() { std::ifstream ifs( "/home/peter/Downloads/Sheetal09Singular.pdf"); std::string in( ( std::istreambuf_iterator<char>( ifs)), std::istreambuf_iterator<char>()); std::string text = "Some text for matching sub-strings in the text."; find_duplicates( in.c_str(), in.size()); }
int app::run(int argc, const char* argv[]) { std::cout << "QCon Duplicatetext finder" << std::endl; try { std::list<std::string> paths; for (auto i = 1; i < argc; i++) { if (argv[i][strlen(argv[i])] != '/') { paths.insert(paths.end(), string(argv[i]) + "/"); } else { paths.insert(paths.end(), string(argv[i])); } } find_duplicates(paths); print_platform_info(); } catch(std::exception& e) { std::cerr << "error: " << e.what() << "\n"; return 1; } catch(...) { std::cerr << "Exception of unknown type!\n"; return 1; } return 0; }
int main(){ int arr[100],*freq,n; //freq[i] will hold the frequency of the ith element in the list printf("Number of elements: "); scanf("%d",&n); freq = (int*)malloc(sizeof(int)*100); printf("Fill the array with integers within 0-100:\n"); for(int i=0;i<n;i++) scanf("%d",&arr[i]); freq = find_duplicates(arr,n); for(int i=0;i<100;i++) if(freq[i]>0) printf("Element '%d' has occured %d times.\n",arr[i],freq[i]); return 0; }
static inline size_t add_builtins(const struct ast_unit *const unit) { size_t offset = 0; for (scope_bcon_id_t id = 0; id < SCOPE_BCON_ID_COUNT; ++id) { unit->scope->objs[offset++] = (struct scope_obj) { .name = scope_builtin_consts[id].name, .obj = SCOPE_OBJ_BCON, .bcon_id = id, }; } for (scope_bfun_id_t id = 0; id < SCOPE_BFUN_ID_COUNT; ++id) { unit->scope->objs[offset++] = (struct scope_obj) { .name = scope_builtin_funcs[id].name, .obj = SCOPE_OBJ_BFUN, .bfun_id = id, }; } return offset; } static int scope_build_inner(struct ast_node *const node, const struct scope *const outer) { assert(node != NULL); static struct ast_func *outer_func; int error = SCOPE_OK; switch (node->an) { case AST_AN_FUNC: { struct ast_func *const func = ast_data(node, func); const size_t objcount = count_objects_block(node); assert(func->scope == NULL); if (unlikely(!(func->scope = scope_alloc(objcount)))) { return NOMEM; } func->scope->outer = outer; func->scope->objcount = objcount; size_t offset = 0; for (size_t param_idx = 0; param_idx < func->param_count; ++param_idx) { func->scope->objs[offset++] = (struct scope_obj) { .name = func->params[param_idx].name, .obj = SCOPE_OBJ_PARM, .type = func->params[param_idx].type, }; } outer_func = func; for (size_t idx = 0; idx < func->stmt_count; ++idx) { struct ast_node *const stmt = func->stmts[idx]; if (unlikely(!stmt)) { continue; } if (stmt->an == AST_AN_DECL) { const struct ast_decl *const decl = ast_data(stmt, decl); for (size_t name_idx = 0; name_idx < decl->name_count; ++name_idx) { func->scope->objs[offset++] = (struct scope_obj) { .name = decl->names[name_idx], .obj = SCOPE_OBJ_AVAR, .decl = stmt, }; } } else if (stmt->an == AST_AN_WLAB) { aggr_error(&error, add_func_wlab(func, stmt)); } else { aggr_error(&error, scope_build_inner(stmt, func->scope)); } } qsort(func->wlabs, func->wlab_count, sizeof(*func->wlabs), cmp_scope_obj); identify_wlabs(func); aggr_error(&error, find_duplicates(func->scope->objs, objcount)); qsort(func->scope->objs, objcount, sizeof(struct scope_obj), cmp_scope_obj); } break; case AST_AN_BLOK: case AST_AN_NOIN: case AST_AN_WHIL: case AST_AN_DOWH: { struct scope **scope; size_t stmt_count; struct ast_node **stmts; const size_t objcount = count_objects_block(node); if (node->an == AST_AN_BLOK || node->an == AST_AN_NOIN) { struct ast_blok *const blok = ast_data(node, blok); scope = &blok->scope; stmt_count = blok->stmt_count; stmts = blok->stmts; } else { struct ast_whil *const whil = ast_data(node, whil); scope = &whil->scope; stmt_count = whil->stmt_count; stmts = whil->stmts; } assert(*scope == NULL); if (unlikely(!(*scope = scope_alloc(objcount)))) { return NOMEM; } (*scope)->outer = outer; (*scope)->objcount = objcount; for (size_t idx = 0, offset = 0; idx < stmt_count; ++idx) { struct ast_node *const stmt = stmts[idx]; if (unlikely(!stmt)) { continue; } if (stmt->an == AST_AN_DECL) { const struct ast_decl *const decl = ast_data(stmt, decl); for (size_t name_idx = 0; name_idx < decl->name_count; ++name_idx) { (*scope)->objs[offset++] = (struct scope_obj) { .name = decl->names[name_idx], .obj = SCOPE_OBJ_AVAR, .decl = stmt, }; } } else if (stmt->an == AST_AN_WLAB) { aggr_error(&error, add_func_wlab(outer_func, stmt)); } else { aggr_error(&error, scope_build_inner(stmt, *scope)); } } aggr_error(&error, find_duplicates((*scope)->objs, objcount)); qsort((*scope)->objs, objcount, sizeof(struct scope_obj), cmp_scope_obj); } break; case AST_AN_COND: { struct ast_cond *const cond = ast_data(node, cond); aggr_error(&error, scope_build_inner(cond->if_block, outer)); for (size_t idx = 0; idx < cond->elif_count; ++idx) { aggr_error(&error, scope_build_inner(cond->elif[idx].block, outer)); } if (cond->else_block) { aggr_error(&error, scope_build_inner(cond->else_block, outer)); } } break; } return error; } int scope_build(struct ast_node *const root) { assert(root != NULL); struct ast_unit *const unit = ast_data(root, unit); size_t objcount = count_objects_unit(unit); assert(unit->scope == NULL); if (unlikely(!(unit->scope = scope_alloc(objcount)))) { return NOMEM; } unit->scope->objcount = objcount; size_t offset = add_builtins(unit); int error = SCOPE_OK; for (size_t idx = 0; idx < unit->stmt_count; ++idx) { struct ast_node *const stmt = unit->stmts[idx]; if (unlikely(!stmt)) { continue; } if (stmt->an == AST_AN_DECL) { const struct ast_decl *const decl = ast_data(stmt, decl); for (size_t name_idx = 0; name_idx < decl->name_count; ++name_idx) { unit->scope->objs[offset++] = (struct scope_obj) { .name = decl->names[name_idx], .obj = SCOPE_OBJ_GVAR, .decl = stmt, }; } } else if (stmt->an == AST_AN_FUNC) { const struct ast_func *const func = ast_data(stmt, func); unit->scope->objs[offset++] = (struct scope_obj) { .name = func->name, .obj = SCOPE_OBJ_FUNC, .func = stmt, }; aggr_error(&error, scope_build_inner(stmt, unit->scope)); } } aggr_error(&error, find_duplicates(unit->scope->objs, objcount)); qsort(unit->scope->objs, objcount, sizeof(struct scope_obj), cmp_scope_obj); return error; } struct scope_obj *scope_find_object(const struct scope *scope, const struct lex_symbol *const name) { const struct scope_obj needle = { .name = name }; do { struct scope_obj *const found = bsearch(&needle, scope->objs, scope->objcount, sizeof(struct scope_obj), cmp_scope_obj); if (found && found->obj != SCOPE_OBJ_DUPL) { if (found->obj == SCOPE_OBJ_AVAR) { const struct ast_decl *const decl = ast_data(found->decl, decl); return likely(name->beg > decl->names[0]->beg) ? found : NULL; } else { return found; } } } while ((scope = scope->outer)); return NULL; } ptrdiff_t scope_find_wlab(const struct ast_func *const func, const struct lex_symbol *const name) { const struct scope_obj needle = { .name = name }; const ssize_t elem_size = sizeof(*func->wlabs); const void *const found = bsearch(&needle, func->wlabs, func->wlab_count, (size_t) elem_size, cmp_scope_obj); return likely(found) ? ((char *) found - (char *) func->wlabs) / elem_size : -1; }
static struct imgspec* create_imgspec(int argc, char* argv[]) { struct imgspec* spec = malloc(sizeof(*spec)); if (!spec) error("failed to allocate an image spec"); memset(spec, 0, sizeof(*spec)); spec->sp_root = malloc(sizeof(*spec->sp_root)); if (!spec->sp_root) error("failed to allocate the root entry"); memset(spec->sp_root, 0, sizeof(*spec->sp_root)); spec->sp_name = MICROFS_DEFAULTNAME; spec->sp_shareblocks = 1; spec->sp_lib = hostprog_lib_find_any(); if (!spec->sp_lib) { error("could not determine which hostprog lib to use"); } spec->sp_pagesz = sysconf(_SC_PAGESIZE); spec->sp_blksz = MICROFS_DEFAULBLKSZ; spec->sp_szpad = spec->sp_pagesz; if (argc < 2) usage(argc > 0 ? argv[0] : "microfsmki", stderr, spec); /* Check what the user want. */ int option; char optionbuffer[3]; while ((option = getopt(argc, argv, MKI_OPTIONS)) != EOF) { size_t len; switch (option) { case 'h': usage(argv[0], stdout, spec); break; case 'v': hostprog_verbosity++; break; case 'e': hostprog_werror = 1; break; case 'p': spec->sp_pad = 1; break; case 'q': spec->sp_squashperms = 1; break; case 's': spec->sp_incsocks = 1; break; case 'S': spec->sp_shareblocks = 0; break; case 'b': opt_strtolx(ul, optiontostr(option, optionbuffer), optarg, spec->sp_blksz); if (!microfs_ispow2(spec->sp_blksz)) error("the block size must be a power of two"); if (spec->sp_blksz < MICROFS_MINBLKSZ || spec->sp_blksz > MICROFS_MAXBLKSZ) { error("block size out of boundaries, %llu given;" " min=%d, max=%d", spec->sp_blksz, MICROFS_MINBLKSZ, MICROFS_MAXBLKSZ); } break; case 'u': opt_strtolx(ull, optiontostr(option, optionbuffer), optarg, spec->sp_usrupperbound); break; case 'P': opt_strtolx(ull, optiontostr(option, optionbuffer), optarg, spec->sp_szpad); if (!microfs_ispow2(spec->sp_szpad)) error("the size padding must be a power of two"); break; case 'n': spec->sp_name = optarg; len = strlen(spec->sp_name); if (len > MICROFS_SBNAME_LENGTH) { warning("image name \"%s\" is too long" " it will be truncated from %zu to %d bytes", spec->sp_name, len, MICROFS_SBNAME_LENGTH); } break; case 'c': spec->sp_lib = hostprog_lib_find_byname(optarg); if (!spec->sp_lib) error("could not find a compression library named %s", optarg); break; case 'D': spec->sp_devtable = optarg; break; case 'l': spec->sp_lib_options = optarg; break; default: /* Ignore it. */ warning("unrecognized option -%c", option); break; } } /* The block size should now be correctly set, which means * that the block left shift can be calculated. */ __u64 blksz = spec->sp_blksz; while ((blksz >>= 1) > 0) spec->sp_blkshift++; if (spec->sp_usrupperbound % spec->sp_blksz != 0) error("upper bound must be a multiple of the block size"); if (hostprog_stack_create(&spec->sp_regstack, 64, 64) < 0) error("failed to create the regular file stack"); if (spec->sp_squashperms && spec->sp_devtable) { warning("both -q and -d are set, this might not be a good idea" " - the device table could override some or all permissions"); } spec->sp_upperbound = sizeof(struct microfs_sb); if (spec->sp_pad) spec->sp_upperbound += MICROFS_PADDING; if ((argc - optind) != 2) usage(argv[0], stderr, spec); spec->sp_rootdir = argv[optind + 0]; spec->sp_outfile = argv[optind + 1]; if (!spec->sp_lib->hl_compiled) error("%s support has not been compiled", spec->sp_lib->hl_info->li_name); if (spec->sp_lib->hl_init(&spec->sp_lib_data, spec->sp_blksz) < 0) error("failed to init %s", spec->sp_lib->hl_info->li_name); lib_options(spec); spec->sp_upperbound += spec->sp_lib->hl_info->li_dd_sz; if (spec->sp_lib->hl_info->li_min_blksz == 0 && spec->sp_blksz < spec->sp_pagesz) { warning("block size smaller than page size of host" " - the resulting image can not be used on this host"); } struct stat st; if (stat(spec->sp_rootdir, &st) == 0) { if (!S_ISDIR(st.st_mode)) error("\"%s\" is not a directory", spec->sp_rootdir); } else error("can not stat \"%s\": %s", spec->sp_rootdir, strerror(errno)); struct hostprog_path* path = NULL; if (hostprog_path_create(&path, spec->sp_rootdir, MICROFS_MAXNAMELEN, MICROFS_MAXNAMELEN) != 0) { error("failed to create the path for the rootdir: %s", strerror(errno)); } spec->sp_root->e_mode = st.st_mode; spec->sp_root->e_uid = st.st_uid; spec->sp_root->e_gid = st.st_gid; spec->sp_root->e_size = walk_directory(spec, path, &spec->sp_root->e_firstchild); hostprog_path_destroy(path); if (spec->sp_shareblocks) find_duplicates(spec); if (spec->sp_devtable) devtable_parse(devtable_process_dentry, spec, spec->sp_devtable, MICROFS_ISIZE_WIDTH); if (spec->sp_usrupperbound && spec->sp_upperbound > spec->sp_usrupperbound) { warning("the estimated upper bound %llu is larger than the" " user requested upper bound %llu", spec->sp_upperbound, spec->sp_usrupperbound); } /* Allocate a max block size sized multiple of bytes. */ spec->sp_upperbound = sz_blkceil(spec->sp_upperbound, MICROFS_MAXBLKSZ); if (spec->sp_upperbound > MICROFS_MAXIMGSIZE) { warning("upper bound image size (absolute worst-case scenario)" " of %llu bytes is larger than the max image size of %llu bytes," " there might not be room for everything", spec->sp_upperbound, MICROFS_MAXIMGSIZE); spec->sp_upperbound = MICROFS_MAXIMGSIZE; } int flags = O_RDWR | O_CREAT | O_TRUNC; spec->sp_fd = open(spec->sp_outfile, flags, 0666); if (spec->sp_fd < 0) error("failed to open \"%s\": %s", spec->sp_rootdir, strerror(errno)); /* The worst case compression scenario will always fit in the * buffer since the upper bound for a data size smaller than * a block is always smaller than the upper bound for an entire * block. */ spec->sp_compressionbufsz = spec->sp_lib->hl_upperbound( spec->sp_lib_data, spec->sp_blksz); spec->sp_compressionbuf = malloc(spec->sp_compressionbufsz); if (!spec->sp_compressionbuf) error("failed to allocate the compression buffer"); message(VERBOSITY_1, "Block size: %llu", spec->sp_blksz); message(VERBOSITY_1, "Block shift: %llu", spec->sp_blkshift); message(VERBOSITY_0, "Compression library: %s", spec->sp_lib->hl_info->li_name); message(VERBOSITY_0, "Upper bound image size: %llu bytes", spec->sp_upperbound); message(VERBOSITY_0, "Number of files: %llu", spec->sp_files); message(VERBOSITY_0, "Directories: %llu", spec->sp_dirnodes); message(VERBOSITY_0, "Regular files: %llu", spec->sp_regnodes); message(VERBOSITY_0, "Duplicate files: %llu", spec->sp_duplicatenodes); message(VERBOSITY_0, "Special files: %llu", spec->sp_specnodes); message(VERBOSITY_0, "Skipped files: %llu", spec->sp_skipnodes); message(VERBOSITY_1, "Data size: %llu", spec->sp_datasz); message(VERBOSITY_1, "Real data size: %llu", spec->sp_realdatasz); message(VERBOSITY_1, "Block pointers required: %llu", spec->sp_blkptrs); if (spec->sp_skipnodes) { warning("not all files will be included in the image"); if (hostprog_verbosity < VERBOSITY_1) message(VERBOSITY_0, ">>> use -v to get more information"); } return spec; }
/* * NOTE: We should consider to install an exit handler which does the * unlink() of the output file. In case of error we just do exit() and * forget about all the clumsy error handling free/close code, which * blows up the code significantly and makes it hard to read. */ int main(int argc, char *argv[]) { int conf_file, rc; struct ffs_chain_t ffs_chain; int c; int smart_pad = 0; /* default */ int notime = 0; const char *config_file = "boot_rom.ffs"; const char *output_file = "boot_rom.bin"; memset((void *) &ffs_chain, 0, sizeof(struct ffs_chain_t)); while (1) { int option_index = 0; static struct option long_options[] = { {"romfs-size", 1, 0, 's'}, {"smart-pad", 0, 0, 'p'}, {"notime", 0, 0, 'n'}, {"verbose", 0, 0, 'v'}, {"help", 1, 0, 'h'}, {0, 0, 0, 0} }; c = getopt_long(argc, argv, "s:ph?nv", long_options, &option_index); if (c == -1) break; switch (c) { case 's': ffs_chain.romfs_size = str_to_num(optarg); break; case 'p': smart_pad = 1; break; case 'n': notime = 1; break; case 'v': verbose = 1; break; case '?': case 'h': print_usage(); return EXIT_SUCCESS; default: printf("?? getopt returned character code 0%o ??\n", c); } } /* two files must always be specified: config-file and output-file */ if (optind + 2 != argc) { print_usage(); return EXIT_FAILURE; } config_file = argv[optind++]; output_file = argv[optind++]; dprintf("ROMFS FILESYSTEM CREATION V0.3 (bad parser)\n" "Build directory structure...\n" " smart padding %s, maximum romfs size %d bytes\n", smart_pad ? "enabled" : "disabled", ffs_chain.romfs_size); conf_file = open(config_file, O_RDONLY); if (0 >= conf_file) { perror("load config file:"); return EXIT_FAILURE; } rc = read_config(conf_file, &ffs_chain); close(conf_file); if (rc < 1) { fprintf(stderr, "flash cannot be built due to config errors\n"); return EXIT_FAILURE; } rc = EXIT_SUCCESS; if (verbose) dump_fs_contents(&ffs_chain); if (smart_pad) /* FIXME: size is only verified during reorder */ rc = reorder_ffs_chain(&ffs_chain); if (rc == EXIT_FAILURE) goto out; dprintf("Build ffs and write to image file...\n"); if (build_ffs(&ffs_chain, output_file, notime) != 0) { fprintf(stderr, "build ffs failed\n"); rc = EXIT_FAILURE; } else { rc = EXIT_SUCCESS; } /* Check if there are any duplicate entries in the image, print warning if this is the case. */ find_duplicates(&ffs_chain); free_chain_memory(&ffs_chain); dprintf("\n"); out: /* If the build failed, remove the target image file */ if (rc == EXIT_FAILURE) unlink(output_file); return rc; }