regex_slash() : tokenizer() { add_pattern(0, "[^\\/]+"); add_pattern(1, "\\."); add_pattern(2, "/"); add_pattern(3, "\r?\n"); regex_set_.Compile(); }
curlyblock() : tokenizer() { add_pattern(0, "{"); add_pattern(1, "[^}]+"); add_pattern(2, "}"); add_pattern(3, "\r?\n"); regex_set_.Compile(); }
regex_quote() : tokenizer() { add_pattern(0, "[^\\\"]+"); add_pattern(1, "\\."); add_pattern(2, "\""); add_pattern(3, "\r?\n"); regex_set_.Compile(); }
static void add_subr(PATTERN subr_pattern, short nparam) { PATTERN pattern; //if (has_output) // subr_pattern = PATTERN_set_flag(subr_pattern, RT_OUTPUT); add_pattern(subr_pattern); pattern = PATTERN_make(RT_PARAM, nparam); add_pattern(pattern); }
/* * Reads searching patterns from a file and adds them with add_pattern(). */ static void read_patterns(const char *fn) { struct stat st; FILE *f; char *line; size_t len; ssize_t rlen; if ((f = fopen(fn, "r")) == NULL) err(2, "%s", fn); if ((fstat(fileno(f), &st) == -1) || (S_ISDIR(st.st_mode))) { fclose(f); return; } len = 0; line = NULL; while ((rlen = getline(&line, &len, f)) != -1) { if (line[0] == '\0') continue; add_pattern(line, line[0] == '\n' ? 0 : (size_t)rlen); } free(line); if (ferror(f)) err(2, "%s", fn); fclose(f); }
void Control::on_open_clicked() { Gtk::FileChooserDialog dialog("Please choose a file", Gtk::FILE_CHOOSER_ACTION_OPEN); //Add response buttons the the dialog: dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL); dialog.add_button("_Open", Gtk::RESPONSE_OK); auto filter_any = Gtk::FileFilter::create(); filter_any->set_name("Any files"); filter_any->add_pattern("*"); dialog.add_filter(filter_any); if (dialog.run() == Gtk::RESPONSE_OK) { _image_path = dialog.get_filename(); _drawArea.signal_x_pos.connect(sigc::mem_fun(this, &Control::monitor_moved_x)); _drawArea.signal_y_pos.connect(sigc::mem_fun(this, &Control::monitor_moved_y)); _drawArea.signal_monitor_scale.connect(sigc::mem_fun(this, &Control::monitor_scaled)); _drawArea.signal_image_scale.connect(sigc::mem_fun(this, &Control::image_scaled)); _drawArea.loadImage(_image_path); _image_scale->set_value(_drawArea.get_last_image_scale()); _monitor_scale->set_value(_drawArea.get_last_monitor_scale()); _drawArea.show(); } }
aho_corasick_matcher::aho_corasick_matcher(std::vector<char*> patterns){ // Montar trie for(char* pattern : patterns){ this->root = add_pattern(this->root,pattern); } // achar funções de falha (transições) find_failure_functions(this->root); }
void setup(){ set_name("Indra"); set_gender(2); set_proper_name("Indra"); set_in_room_desc("An elven wench named Indra is here."); set_long("Indra is a dazzlingly beautiful elven woman. She looks at you"+ " with a smile that almost melts you where you stand. And taking into account"+ " that she is also stark naked, you don't have much to say right now."); add_pattern("%s smiles.", (: $1 !="Indra Elvenmist" ? "emote smiles happily"+ " at you." : 0 :)); add_pattern("%s kisses%s", "emote returns your kiss and puts her arms around"+ " your neck."); add_pattern("%s pulls %s", "emote lets her tounge play around in your"+ " mouth, stroking her hands through your hair."); add_pattern("%s says, \"F**k me gently with a chain saw!\"", "emote starts up"+ " her chainsaw and grins happily at you."); }
int lafe_exclude(struct lafe_matching **matching, const char *pattern) { if (*matching == NULL) initialize_matching(matching); add_pattern(&((*matching)->exclusions), pattern); (*matching)->exclusions_count++; return (0); }
int exclude(struct bsdtar *bsdtar, const char *pattern) { struct matching *matching; if (bsdtar->matching == NULL) initialize_matching(bsdtar); matching = bsdtar->matching; add_pattern(bsdtar, &(matching->exclusions), pattern); matching->exclusions_count++; return (0); }
int main(int argc, char *argv[]) { const char *zipfile; int nopts; if (isatty(STDOUT_FILENO)) tty = 1; if (getenv("UNZIP_DEBUG") != NULL) unzip_debug = 1; for (int i = 0; i < argc; ++i) debug("%s%c", argv[i], (i < argc - 1) ? ' ' : '\n'); /* * Info-ZIP's unzip(1) expects certain options to come before the * zipfile name, and others to come after - though it does not * enforce this. For simplicity, we accept *all* options both * before and after the zipfile name. */ nopts = getopts(argc, argv); /* * When more of the zipinfo mode options are implemented, this * will need to change. */ if (zipinfo_mode && !Z1_opt) { printf("Zipinfo mode needs additional options\n"); exit(1); } if (argc <= nopts) usage(); zipfile = argv[nopts++]; if (strcmp(zipfile, "-") == 0) zipfile = NULL; /* STDIN */ while (nopts < argc && *argv[nopts] != '-') add_pattern(&include, argv[nopts++]); nopts--; /* fake argv[0] */ nopts += getopts(argc - nopts, argv + nopts); if (n_opt + o_opt + u_opt > 1) errorx("-n, -o and -u are contradictory"); time(&now); unzip(zipfile); exit(0); }
static void add_operator_output(short op, short nparam, uint64_t byref) { PATTERN pattern; /* Why this test? add_operator() can be called without operator. See: if (RES_priority(op) < prio) ... */ if (op == RS_NONE || op == RS_UNARY) return; if (op == RS_EXCL) { op = RS_LSQR; nparam = 2; check_last_first(2); } pattern = PATTERN_make(RT_RESERVED, op); //if (op == RS_LBRA && byref) // pattern = PATTERN_set_flag(pattern, RT_OUTPUT); add_pattern(pattern); add_pattern(PATTERN_make(RT_PARAM, nparam)); if (op == RS_LBRA && byref) { while (byref) { add_pattern(PATTERN_make(RT_PARAM, byref & 0xFFFF)); byref >>= 16; } } }
int mkdev(const char *name, int _mode) { char *pattern; if (chdir("/dev")) return 1; pattern = add_pattern(name); patterns = &pattern; mode = _mode; n_patterns = 1; find_devs(true); find_devs(false); chdir("/"); return 0; }
ChooseFileWindow::ChooseFileWindow(MainWindow* mainWindow, Gtk::FileChooserAction file_chooser_action) : Gtk::FileChooserDialog("Select a wavefront file", file_chooser_action), mainWindow(mainWindow), selected_path("") { add_button("_Cancel", Gtk::RESPONSE_CANCEL); add_button("Select", Gtk::RESPONSE_OK); set_type_hint(Gdk::WINDOW_TYPE_HINT_DIALOG); set_modal(); set_transient_for(*mainWindow); auto filter_obj = Gtk::FileFilter::create(); filter_obj->set_name("Wavefront .obj files"); filter_obj->add_pattern("*.obj"); filter_obj->add_pattern("*.OBJ"); add_filter(filter_obj); }
/** * \brief Changes the id of a pattern in the tileset. * \param old_pattern_id Old id of the pattern. * \param new_pattern_id New id to set. * \return \c true in case of success. * In case of failure, the old pattern is unchanged. */ bool TilesetData::set_pattern_id( const std::string& old_pattern_id, const std::string& new_pattern_id) { if (!exists(old_pattern_id)) { // No pattern was found with the old id. return false; } if (exists(new_pattern_id)) { // The new id is already used. return false; } TilePatternData pattern = get_pattern(old_pattern_id); remove_pattern(old_pattern_id); add_pattern(new_pattern_id, pattern); return true; }
/* * Reads searching patterns from a file and adds them with add_pattern(). */ static void read_patterns(const char *fn) { struct stat st; FILE *f; char *line; size_t len; if ((f = fopen(fn, "r")) == NULL) err(2, "%s", fn); if ((fstat(fileno(f), &st) == -1) || (S_ISDIR(st.st_mode))) { fclose(f); return; } while ((line = fgetln(f, &len)) != NULL) add_pattern(line, line[0] == '\n' ? 0 : len); if (ferror(f)) err(2, "%s", fn); fclose(f); }
int main(int argc, char *argv[]) { const char *zipfile; int nopts; if (isatty(STDOUT_FILENO)) tty = 1; if (getenv("UNZIP_DEBUG") != NULL) unzip_debug = 1; for (int i = 0; i < argc; ++i) debug("%s%c", argv[i], (i < argc - 1) ? ' ' : '\n'); /* * Info-ZIP's unzip(1) expects certain options to come before the * zipfile name, and others to come after - though it does not * enforce this. For simplicity, we accept *all* options both * before and after the zipfile name. */ nopts = getopts(argc, argv); if (argc <= nopts) usage(); zipfile = argv[nopts++]; while (nopts < argc && *argv[nopts] != '-') add_pattern(&include, argv[nopts++]); nopts--; /* fake argv[0] */ nopts += getopts(argc - nopts, argv + nopts); if (n_opt + o_opt + u_opt > 1) errorx("-n, -o and -u are contradictory"); time(&now); unzip(zipfile); exit(0); }
void mexFunction(int nlhs,mxArray *plhs[],int nrhs,const mxArray *prhs[]) { int i,j,k; mwSize dims[] = {1,5}; mwSize CIdims[] = {0,0,2}; mwSize DSdims[] = {0,0,2}; const char* field_names[] = {"Events", "CIs", "Sign", "Nab", "DS", "String"}; int Events_field, CIs_field, Sign_field, Nab_field, DS_field, String_field; char *str; int max_event_name, max_event_indexes; double *pr; t_time_series ts; int Namax, buf[3], tid; t_pattern_list *tmp; t_pattern *Ip; mxArray *mArray; iteration_number = 0; ts.ci_strategy = T_SHORTEST_CI; ts.output = stdout; ts.alpha = 0.005; ts.Nmin = 3; ts.nlevels = 0; ts.allow_same_events_in_pattern = 1; logfac_table_size = 0; C_iz_N_po_k_table_K = C_iz_N_po_k_table_N = 0; ts.num_event_types = mxGetN( prhs[0] ); ts.Nt = mxGetScalar(prhs[1]); ts.nlevels = mxGetN( prhs[2] ); ts.event_i = (unsigned int**) malloc( ts.num_event_types * sizeof(unsigned int *)); ts.event_sign = (char**) malloc( ts.num_event_types * sizeof(char*) ); ts.N = (int*) malloc( ts.num_event_types * sizeof( unsigned int ) ); ts.levels = (t_levels*) malloc( ts.nlevels * sizeof( t_levels ) ); for ( i = 0; i < ts.num_event_types; i++ ) { pr = mxGetField( prhs[0], i, "indexes" ); ts.N[i] = mxGetN( pr ); ts.event_i[i] = (unsigned int*) malloc( ts.N[i] *sizeof( unsigned int ) ); /*Can't use memcpy here!!*/ for ( j = 0; j < ts.N[i]; j++ ) ts.event_i[i][j] = (unsigned int) *( mxGetPr(pr) + j) - 1 ; pr = mxGetField( prhs[0], i, "event_name" ); ts.event_sign[i] = (char*) mxArrayToString( pr ); } /*copy alpha and Nab struct*/ pr = mxGetPr( prhs[2] ); for ( i = 0; i < ts.nlevels; i++ ) { ts.levels[i].len = pr[i*3 + 0]; ts.levels[i].alpha = pr[i*3 + 1]; ts.levels[i].Nmin = pr[i*3 + 2]; } /*Defaults*/ ts.patterns = (t_pattern_list*) malloc( sizeof( t_pattern_list ) ); ts.patterns->next=NULL; ts.ci_strategy = mxGetScalar(prhs[4]); ts.output = stdout; ts.alpha = 0.005; ts.Nmin = 3; ts.allow_same_events_in_pattern = mxGetScalar(prhs[3]); logfac_table_size = 0; C_iz_N_po_k_table_K = C_iz_N_po_k_table_N = 0; /* Construct pseudo patterns */ for ( i = 0; i < ts.num_event_types; i++ ) { Namax = Namax < ts.N[i] ? ts.N[i] : Namax; buf[0] = i; tmp = add_pattern(ts.patterns, buf, 1); tmp->pat.ind = ( double_series*) malloc( sizeof(double_series) * ts.N[i] ); tmp->pat.N = ts.N[i]; for ( j = 0; j < ts.N[i]; j++) { tmp->pat.ind[j].l = tmp->pat.ind[j].r = ts.event_i[i][j]; } } if (logfac_table_size) { fill_logfac_table( Namax+1 ); fill_C_iz_N_po_k_table( Namax+1, Namax+1); } #pragma omp parallel private(tid) { tid = omp_get_thread_num(); mexPrintf("Hello World from thread = %d\n", tid); } t_detect_patterns(&ts); mexPrintf("\n ITERATIONS %d\n", iteration_number); dims[1] = num_patterns[ iteration_number - 1 ]; plhs[0] = mxCreateStructArray(2, dims, 6, field_names); Events_field = mxGetFieldNumber( plhs[0], "Events" ); CIs_field = mxGetFieldNumber( plhs[0], "CIs" ); Sign_field = mxGetFieldNumber( plhs[0], "Sign" ); Nab_field = mxGetFieldNumber( plhs[0], "Nab" ); DS_field = mxGetFieldNumber( plhs[0], "DS" ); String_field = mxGetFieldNumber( plhs[0], "String" ); tmp = patterns_it[ iteration_number - 1 ]->next; for ( i = 0; i < num_patterns[ iteration_number - 1 ]; i++ ) { Ip = &tmp->pat; /* Fill pattern field */ mArray = mxCreateDoubleMatrix( 1, Ip->nevents, mxREAL ); mxSetFieldByNumber(plhs[0], i, Events_field, mArray ); pr = mxGetPr( mArray ); for ( j = 0; j < Ip->nevents; j++ ) pr[j] = Ip->events[j] + 1; /*Matlab base index is 1 !!!*/ /* Fill significance field */ mArray = mxCreateDoubleScalar( Ip->significance ); mxSetFieldByNumber(plhs[0], i, Sign_field, mArray ); /* Fill Nab field */ mArray = mxCreateDoubleScalar( Ip->N ); mxSetFieldByNumber(plhs[0], i, Nab_field, mArray ); /* Fill CI field */ mArray = mxCreateDoubleMatrix( Ip->nevents - 1, 2, mxREAL); mxSetFieldByNumber(plhs[0], i, CIs_field, mArray ); pr = mxGetPr( mArray ); for ( j = 0; j < Ip->nevents - 1; j++ ) { pr[ 0*(Ip->nevents - 1) + j ] = Ip->CI[j].l; pr[ 1*(Ip->nevents - 1) + j ] = Ip->CI[j].r; } /* Fill DS field */ mArray = mxCreateDoubleMatrix( Ip->N, 2, mxREAL); mxSetFieldByNumber(plhs[0], i, DS_field, mArray ); pr = mxGetPr( mArray ); for ( j = 0; j < Ip->N; j++ ) { pr[ 0 * Ip->N + j ] = Ip->ind[j].l + 1; /*Matlab base index is 1 !!!*/ pr[ 1 * Ip->N + j ] = Ip->ind[j].r + 1; /*Matlab base index is 1 !!!*/ } mArray = mxCreateCharMatrixFromStrings( 1, &pattern_strings[i]); mxSetFieldByNumber(plhs[0], i, String_field, mArray ); tmp = tmp->next; } }
int main(int argc, char *argv[]) { char **aargv, **eargv, *eopts; char *ep; const char *pn; long long l; unsigned int aargc, eargc, i; int c, lastc, needpattern, newarg, prevoptind; setlocale(LC_ALL, ""); #ifndef WITHOUT_NLS catalog = catopen("grep", NL_CAT_LOCALE); #endif /* Check what is the program name of the binary. In this way we can have all the funcionalities in one binary without the need of scripting and using ugly hacks. */ pn = getprogname(); if (pn[0] == 'b' && pn[1] == 'z') { filebehave = FILE_BZIP; pn += 2; } else if (pn[0] == 'x' && pn[1] == 'z') { filebehave = FILE_XZ; pn += 2; } else if (pn[0] == 'l' && pn[1] == 'z') { filebehave = FILE_LZMA; pn += 2; } else if (pn[0] == 'r') { dirbehave = DIR_RECURSE; Hflag = true; } else if (pn[0] == 'z') { filebehave = FILE_GZIP; pn += 1; } switch (pn[0]) { case 'e': grepbehave = GREP_EXTENDED; break; case 'f': grepbehave = GREP_FIXED; break; } lastc = '\0'; newarg = 1; prevoptind = 1; needpattern = 1; fileeol = '\n'; eopts = getenv("GREP_OPTIONS"); /* support for extra arguments in GREP_OPTIONS */ eargc = 0; if (eopts != NULL && eopts[0] != '\0') { char *str; /* make an estimation of how many extra arguments we have */ for (unsigned int j = 0; j < strlen(eopts); j++) if (eopts[j] == ' ') eargc++; eargv = (char **)grep_malloc(sizeof(char *) * (eargc + 1)); eargc = 0; /* parse extra arguments */ while ((str = strsep(&eopts, " ")) != NULL) if (str[0] != '\0') eargv[eargc++] = grep_strdup(str); aargv = (char **)grep_calloc(eargc + argc + 1, sizeof(char *)); aargv[0] = argv[0]; for (i = 0; i < eargc; i++) aargv[i + 1] = eargv[i]; for (int j = 1; j < argc; j++, i++) aargv[i + 1] = argv[j]; aargc = eargc + argc; } else { aargv = argv; aargc = argc; } while (((c = getopt_long(aargc, aargv, optstr, long_options, NULL)) != -1)) { switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (newarg || !isdigit(lastc)) Aflag = 0; else if (Aflag > LLONG_MAX / 10 - 1) { errno = ERANGE; err(2, NULL); } Aflag = Bflag = (Aflag * 10) + (c - '0'); break; case 'C': if (optarg == NULL) { Aflag = Bflag = 2; break; } /* FALLTHROUGH */ case 'A': /* FALLTHROUGH */ case 'B': errno = 0; l = strtoll(optarg, &ep, 10); if (errno == ERANGE || errno == EINVAL) err(2, NULL); else if (ep[0] != '\0') { errno = EINVAL; err(2, NULL); } else if (l < 0) { errno = EINVAL; err(2, "context argument must be non-negative"); } if (c == 'A') Aflag = l; else if (c == 'B') Bflag = l; else Aflag = Bflag = l; break; case 'a': binbehave = BINFILE_TEXT; break; case 'b': bflag = true; break; case 'c': cflag = true; break; case 'D': if (strcasecmp(optarg, "skip") == 0) devbehave = DEV_SKIP; else if (strcasecmp(optarg, "read") == 0) devbehave = DEV_READ; else errx(2, getstr(3), "--devices"); break; case 'd': if (strcasecmp("recurse", optarg) == 0) { Hflag = true; dirbehave = DIR_RECURSE; } else if (strcasecmp("skip", optarg) == 0) dirbehave = DIR_SKIP; else if (strcasecmp("read", optarg) == 0) dirbehave = DIR_READ; else errx(2, getstr(3), "--directories"); break; case 'E': grepbehave = GREP_EXTENDED; break; case 'e': { char *token; char *string = optarg; while ((token = strsep(&string, "\n")) != NULL) add_pattern(token, strlen(token)); } needpattern = 0; break; case 'F': grepbehave = GREP_FIXED; break; case 'f': read_patterns(optarg); needpattern = 0; break; case 'G': grepbehave = GREP_BASIC; break; case 'H': Hflag = true; break; case 'h': Hflag = false; hflag = true; break; case 'I': binbehave = BINFILE_SKIP; break; case 'i': case 'y': iflag = true; cflags |= REG_ICASE; break; case 'J': #ifdef WITHOUT_BZIP2 errno = EOPNOTSUPP; err(2, "bzip2 support was disabled at compile-time"); #endif filebehave = FILE_BZIP; break; case 'L': lflag = false; Lflag = true; break; case 'l': Lflag = false; lflag = true; break; case 'm': mflag = true; errno = 0; mlimit = mcount = strtoll(optarg, &ep, 10); if (((errno == ERANGE) && (mcount == LLONG_MAX)) || ((errno == EINVAL) && (mcount == 0))) err(2, NULL); else if (ep[0] != '\0') { errno = EINVAL; err(2, NULL); } break; case 'M': filebehave = FILE_LZMA; break; case 'n': nflag = true; break; case 'O': linkbehave = LINK_EXPLICIT; break; case 'o': oflag = true; cflags &= ~REG_NOSUB; break; case 'p': linkbehave = LINK_SKIP; break; case 'q': qflag = true; break; case 'S': linkbehave = LINK_READ; break; case 'R': case 'r': dirbehave = DIR_RECURSE; Hflag = true; break; case 's': sflag = true; break; case 'U': binbehave = BINFILE_BIN; break; case 'u': case MMAP_OPT: filebehave = FILE_MMAP; break; case 'V': #ifdef WITH_GNU printf(getstr(10), getprogname(), VERSION); #else printf(getstr(9), getprogname(), VERSION); #endif exit(0); case 'v': vflag = true; break; case 'w': wflag = true; cflags &= ~REG_NOSUB; break; case 'x': xflag = true; cflags &= ~REG_NOSUB; break; case 'X': filebehave = FILE_XZ; break; case 'z': fileeol = '\0'; break; case 'Z': filebehave = FILE_GZIP; break; case BIN_OPT: if (strcasecmp("binary", optarg) == 0) binbehave = BINFILE_BIN; else if (strcasecmp("without-match", optarg) == 0) binbehave = BINFILE_SKIP; else if (strcasecmp("text", optarg) == 0) binbehave = BINFILE_TEXT; else errx(2, getstr(3), "--binary-files"); break; case COLOR_OPT: color = NULL; if (optarg == NULL || strcasecmp("auto", optarg) == 0 || strcasecmp("tty", optarg) == 0 || strcasecmp("if-tty", optarg) == 0) { char *term; term = getenv("TERM"); if (isatty(STDOUT_FILENO) && term != NULL && strcasecmp(term, "dumb") != 0) color = init_color("01;31"); } else if (strcasecmp("always", optarg) == 0 || strcasecmp("yes", optarg) == 0 || strcasecmp("force", optarg) == 0) { color = init_color("01;31"); } else if (strcasecmp("never", optarg) != 0 && strcasecmp("none", optarg) != 0 && strcasecmp("no", optarg) != 0) errx(2, getstr(3), "--color"); cflags &= ~REG_NOSUB; break; case LABEL_OPT: label = optarg; break; case LINEBUF_OPT: lbflag = true; break; case NULL_OPT: nullflag = true; break; case R_INCLUDE_OPT: finclude = true; add_fpattern(optarg, INCL_PAT); break; case R_EXCLUDE_OPT: fexclude = true; add_fpattern(optarg, EXCL_PAT); break; case R_DINCLUDE_OPT: dinclude = true; add_dpattern(optarg, INCL_PAT); break; case R_DEXCLUDE_OPT: dexclude = true; add_dpattern(optarg, EXCL_PAT); break; case HELP_OPT: default: usage(); } lastc = c; newarg = optind != prevoptind; prevoptind = optind; } aargc -= optind; aargv += optind; /* Empty pattern file matches nothing */ if (!needpattern && (patterns == 0)) exit(1); /* Fail if we don't have any pattern */ if (aargc == 0 && needpattern) usage(); /* Process patterns from command line */ if (aargc != 0 && needpattern) { char *token; char *string = *aargv; while ((token = strsep(&string, "\n")) != NULL) add_pattern(token, strlen(token)); --aargc; ++aargv; } switch (grepbehave) { case GREP_BASIC: break; case GREP_FIXED: /* * regex(3) implementations that support fixed-string searches generally * define either REG_NOSPEC or REG_LITERAL. Set the appropriate flag * here. If neither are defined, GREP_FIXED later implies that the * internal literal matcher should be used. Other cflags that have * the same interpretation as REG_NOSPEC and REG_LITERAL should be * similarly added here, and grep.h should be amended to take this into * consideration when defining WITH_INTERNAL_NOSPEC. */ #if defined(REG_NOSPEC) cflags |= REG_NOSPEC; #elif defined(REG_LITERAL) cflags |= REG_LITERAL; #endif break; case GREP_EXTENDED: cflags |= REG_EXTENDED; break; default: /* NOTREACHED */ usage(); } #ifndef WITHOUT_FASTMATCH fg_pattern = grep_calloc(patterns, sizeof(*fg_pattern)); #endif r_pattern = grep_calloc(patterns, sizeof(*r_pattern)); /* Don't process any patterns if we have a blank one */ #ifdef WITH_INTERNAL_NOSPEC if (!matchall && grepbehave != GREP_FIXED) { #else if (!matchall) { #endif /* Check if cheating is allowed (always is for fgrep). */ for (i = 0; i < patterns; ++i) { #ifndef WITHOUT_FASTMATCH /* * Attempt compilation with fastmatch regex and * fallback to regex(3) if it fails. */ if (fastncomp(&fg_pattern[i], pattern[i].pat, pattern[i].len, cflags) == 0) continue; #endif c = regcomp(&r_pattern[i], pattern[i].pat, cflags); if (c != 0) { regerror(c, &r_pattern[i], re_error, RE_ERROR_BUF); errx(2, "%s", re_error); } } } if (lbflag) setlinebuf(stdout); if ((aargc == 0 || aargc == 1) && !Hflag) hflag = true; if (aargc == 0 && dirbehave != DIR_RECURSE) exit(!procfile("-")); if (dirbehave == DIR_RECURSE) c = grep_tree(aargv); else for (c = 0; aargc--; ++aargv) { if ((finclude || fexclude) && !file_matching(*aargv)) continue; c+= procfile(*aargv); } #ifndef WITHOUT_NLS catclose(catalog); #endif /* Find out the correct return value according to the results and the command line option. */ exit(c ? (file_err ? (qflag ? 0 : 2) : 0) : (file_err ? 2 : 1)); }
static int _mutt_parse_color (BUFFER *buf, BUFFER *s, BUFFER *err, parser_callback_t callback, short dry_run) { int object = 0, attr = 0, fg = 0, bg = 0, q_level = 0; int r = 0; if(parse_object(buf, s, &object, &q_level, err) == -1) return -1; if(callback(buf, s, &fg, &bg, &attr, err) == -1) return -1; /* extract a regular expression if needed */ if (object == MT_COLOR_HEADER || object == MT_COLOR_BODY || object == MT_COLOR_INDEX) { if (!MoreArgs (s)) { strfcpy (err->data, _("too few arguments"), err->dsize); return (-1); } mutt_extract_token (buf, s, 0); } if (MoreArgs (s)) { strfcpy (err->data, _("too many arguments"), err->dsize); return (-1); } /* dry run? */ if(dry_run) return 0; #ifdef HAVE_COLOR # ifdef HAVE_USE_DEFAULT_COLORS if (!option (OPTNOCURSES) && has_colors() /* delay use_default_colors() until needed, since it initializes things */ && (fg == COLOR_DEFAULT || bg == COLOR_DEFAULT) && use_default_colors () != OK) { strfcpy (err->data, _("default colors not supported"), err->dsize); return (-1); } # endif /* HAVE_USE_DEFAULT_COLORS */ #endif if (object == MT_COLOR_HEADER) r = add_pattern (&ColorHdrList, buf->data, 0, fg, bg, attr, err,0); else if (object == MT_COLOR_BODY) r = add_pattern (&ColorBodyList, buf->data, 1, fg, bg, attr, err, 0); else if (object == MT_COLOR_INDEX) { r = add_pattern (&ColorIndexList, buf->data, 1, fg, bg, attr, err, 1); set_option (OPTFORCEREDRAWINDEX); } else if (object == MT_COLOR_QUOTED) { if (q_level >= ColorQuoteSize) { safe_realloc (&ColorQuote, (ColorQuoteSize += 2) * sizeof (int)); ColorQuote[ColorQuoteSize-2] = ColorDefs[MT_COLOR_QUOTED]; ColorQuote[ColorQuoteSize-1] = ColorDefs[MT_COLOR_QUOTED]; } if (q_level >= ColorQuoteUsed) ColorQuoteUsed = q_level + 1; if (q_level == 0) { ColorDefs[MT_COLOR_QUOTED] = fgbgattr_to_color(fg, bg, attr); ColorQuote[0] = ColorDefs[MT_COLOR_QUOTED]; for (q_level = 1; q_level < ColorQuoteUsed; q_level++) { if (ColorQuote[q_level] == A_NORMAL) ColorQuote[q_level] = ColorDefs[MT_COLOR_QUOTED]; } } else ColorQuote[q_level] = fgbgattr_to_color(fg, bg, attr); } else ColorDefs[object] = fgbgattr_to_color(fg, bg, attr); #ifdef HAVE_COLOR # ifdef HAVE_BKGDSET if (object == MT_COLOR_NORMAL && !option (OPTNOCURSES) && has_colors()) BKGDSET (MT_COLOR_NORMAL); # endif #endif return (r); }
static void add_reserved_pattern(int reserved) { add_pattern(PATTERN_make(RT_RESERVED, reserved)); }
static int getopts(int argc, char *argv[]) { int opt; optreset = optind = 1; while ((opt = getopt(argc, argv, "aCcd:fjLlnopqtuvx:Z1")) != -1) switch (opt) { case '1': Z1_opt = 1; break; case 'a': a_opt = 1; break; case 'C': C_opt = 1; break; case 'c': c_opt = 1; break; case 'd': d_arg = optarg; break; case 'f': f_opt = 1; break; case 'j': j_opt = 1; break; case 'L': L_opt = 1; break; case 'l': if (v_opt == 0) v_opt = 1; break; case 'n': n_opt = 1; break; case 'o': o_opt = 1; q_opt = 1; break; case 'p': p_opt = 1; break; case 'q': q_opt = 1; break; case 't': t_opt = 1; break; case 'u': u_opt = 1; break; case 'v': v_opt = 2; break; case 'x': add_pattern(&exclude, optarg); break; case 'Z': zipinfo_mode = 1; break; default: usage(); } return (optind); }
int t_read_structs_from_file(t_time_series* ts, char* fname) { FILE* fp; unsigned int i, j, time, Namax=0; char c, buf1[1024], buf2[1024]; int buf[3]; t_pattern_list *tmp; ts->patterns = (t_pattern_list*) malloc( sizeof( t_pattern_list ) ); ts->patterns->next=NULL; if (! ( fp = fopen(fname, "r") ) ) { return 0; } ts->allocated_num_event_types = 0; ts->num_event_types = 0; fscanf(fp, "Time\tEvent\n"); fscanf(fp, "0\t:\n"); for ( i = 0; !feof(fp); i++ ) { fscanf(fp, "%s\t%s\n", buf1, buf2); time = atoi(buf1); if ( buf2[0] == '&' ) { ts->Nt = time; break; } t_add_event_type(ts, buf2); t_add_event_ent(ts, buf2, time); } fclose(fp); /* Make pattern structs */ for ( i = 0; i < ts->num_event_types; i++ ) { Namax = Namax < ts->N[i] ? ts->N[i] : Namax; buf[0] = i; tmp = add_pattern(ts->patterns, buf, 1); tmp-> pat.tree = (int*) malloc( sizeof(int) ); tmp-> pat.tree[0] = i; tmp-> pat.tree_len = 1; tmp->pat.ind = ( double_series*) malloc( sizeof(double_series) * ts->N[i] ); tmp->pat.N = ts->N[i]; for ( j = 0; j < ts->N[i]; j++) { tmp->pat.ind[j].l = tmp->pat.ind[j].r = ts->event_i[i][j]; } } if (logfac_table_size) { fill_logfac_table( Namax+1 ); fill_C_iz_N_po_k_table( Namax+1, Namax+1); } return 1; }
static void analyze_single(int op) { PATTERN *pattern; bool jump_newline; jump_newline = PATTERN_is_newline(*current); if (jump_newline) { add_pattern(PATTERN_make(RT_NEWLINE, 0)); JOB->line++; current++; } if (op == RS_PT && !PATTERN_is_identifier(*current)) THROW("The '.' operator must be followed by an identifier"); else if (op == RS_EXCL && !PATTERN_is_string(*current)) THROW("The '!' operator must be followed by an identifier"); /* ( expr ) */ if (PATTERN_is(*current, RS_LBRA)) { int old_length = tree_length; PATTERN last; current++; analyze_expr(0, RS_NONE); if (!PATTERN_is(*current, RS_RBRA)) THROW(E_MISSING, "')'"); current++; if (tree_length == (old_length + 1)) { last = get_last_pattern(1); if (PATTERN_is_string(last)) change_last_pattern(1, PATTERN_make(RT_TSTRING, PATTERN_index(last))); } } /* [ expr, expr, ... ] */ else if (PATTERN_is(*current, RS_LSQR)) { current++; analyze_make_array(); } /* - expr | NOT expr */ else if (PATTERN_is(*current, RS_MINUS) || PATTERN_is(*current, RS_NOT)) { pattern = current; current++; analyze_expr(RES_priority(RS_NOT), RS_UNARY); add_operator(PATTERN_index(*pattern), 1); } // . symbol else if (PATTERN_is(*current, RS_PT) && PATTERN_is_identifier(current[1])) { add_operator(PATTERN_index(current[0]), 0); add_pattern(PATTERN_set_flag(current[1], RT_POINT)); current += 2; } // . [ ... ] else if (PATTERN_is(*current, RS_PT) && PATTERN_is(current[1], RS_LSQR)) { add_operator(PATTERN_index(current[0]), 0); //add_pattern(PATTERN_set_flag(RS_RSQR, RT_POINT)); current += 2; analyze_array(); } // ! symbol else if (PATTERN_is(*current, RS_EXCL) && PATTERN_is_string(current[1])) { add_operator(RS_PT, 0); add_pattern(PATTERN_set_flag(current[1], RT_POINT)); add_operator(RS_EXCL, 0); current += 2; } /* NULL, TRUE, FALSE, ME, PARENT, LAST, ERROR */ /* number, string or symbol */ else if (PATTERN_is(*current, RS_NULL) || PATTERN_is(*current, RS_ME) || PATTERN_is(*current, RS_LAST) || PATTERN_is(*current, RS_TRUE) || PATTERN_is(*current, RS_FALSE) || PATTERN_is(*current, RS_PINF) || PATTERN_is(*current, RS_MINF) || PATTERN_is(*current, RS_ERROR) || (!PATTERN_is_reserved(*current) && !PATTERN_is_newline(*current) && !PATTERN_is_end(*current))) { add_pattern(*current); if (PATTERN_is_identifier(*current)) { /*if ((op == RS_NONE || op == RS_UNARY) && (PATTERN_is_identifier(*current))) change_last_pattern(1, PATTERN_set_flag(get_last_pattern(1), RT_FIRST));*/ if (op == RS_PT) { change_last_pattern(1, PATTERN_set_flag(get_last_pattern(1), RT_POINT)); check_last_first(2); } } current++; } else if (PATTERN_is(*current, RS_SUPER)) { add_pattern(*current); current++; if (!PATTERN_is(*current, RS_PT) && !PATTERN_is(*current, RS_EXCL) && !PATTERN_is(*current, RS_LBRA) && !PATTERN_is(*current, RS_LSQR)) THROW("SUPER cannot be used alone"); } else { if (jump_newline) { current--; JOB->line--; } THROW_UNEXPECTED(current); } }
static void analyze_call() { static PATTERN *byref_pattern[MAX_PARAM_FUNC]; int i, nparam_post = 0; PATTERN subr_pattern = NULL_PATTERN; PATTERN last_pattern = get_last_pattern(1); SUBR_INFO *info; bool optional = TRUE; uint64_t byref = 0; PATTERN *save; /* get_pattern_subr(last_pattern, &subr); */ if (PATTERN_is_subr(last_pattern)) { subr_pattern = last_pattern; remove_last_pattern(); optional = FALSE; } else if (PATTERN_is_identifier(last_pattern)) { check_last_first(1); } else if (PATTERN_is_string(last_pattern) || PATTERN_is_number(last_pattern)) THROW(E_SYNTAX); /* N.B. Le cas où last_pattern = "." n'a pas de test spécifique */ if (PATTERN_type(subr_pattern) == RT_SUBR && PATTERN_index(subr_pattern) == SUBR_VarPtr) { if (!PATTERN_is_identifier(current[0]) || !PATTERN_is(current[1], RS_RBRA)) THROW("Syntax error. VarPtr() takes only one identifier"); add_pattern(*current); current += 2; add_subr(subr_pattern, 1); } else { for (;;) { if (PATTERN_is(*current, RS_RBRA)) { current++; break; } if (nparam_post > 0) { if (!PATTERN_is(*current, RS_COMMA)) THROW(E_MISSING, "',' or ')'"); current++; } #if 0 if (FALSE) /*(PATTERN_is(*current, RS_AMP))*/ { current++; output[nparam_post] = current; has_output = TRUE; } else { output[nparam_post] = NULL; } #endif if (optional && (PATTERN_is(*current, RS_COMMA) || PATTERN_is(*current, RS_RBRA))) { add_reserved_pattern(RS_OPTIONAL); } else if (optional && PATTERN_is(*current, RS_3PTS) && PATTERN_is(current[1], RS_RBRA)) { current++; add_reserved_pattern(RS_3PTS); nparam_post--; } else { if (PATTERN_is(*current, RS_AT) || PATTERN_is(*current, RS_BYREF)) { current++; BYREF_SET(byref, nparam_post); byref_pattern[nparam_post] = current; } analyze_expr(0, RS_NONE); } nparam_post++; if (nparam_post >= MAX_PARAM_FUNC) THROW("Too many arguments"); } last_pattern = get_last_pattern(1); if (PATTERN_is(last_pattern, RS_OPTIONAL)) THROW("Syntax error. Needless arguments"); /* while (nparam_post > 0) { if (get_last_pattern(1) != PATTERN_make(RT_RESERVED, RS_OPTIONAL)) break; remove_last_pattern(); nparam_post--; } */ if (PATTERN_is_null(subr_pattern)) { add_operator_output(RS_LBRA, nparam_post, byref); save = current; for (i = nparam_post - 1; i >= 0; i--) { if (BYREF_TEST(byref, i)) { current = byref_pattern[i]; analyze_expr(0, RS_NONE); //if (!is_statement()) // THROW("The &1 argument cannot be passed by reference", TRANS_get_num_desc(i + 1)); add_pattern(PATTERN_make(RT_RESERVED, RS_AT)); } } current = save; } else { info = &COMP_subr_info[PATTERN_index(subr_pattern)]; if (nparam_post < info->min_param) THROW("Not enough arguments to &1()", info->name); else if (nparam_post > info->max_param) THROW("Too many arguments to &1()", info->name); else if (byref) THROW("Subroutine arguments cannot be passed by reference"); add_subr(subr_pattern, nparam_post); } } }
/** * This function optimizes the given transition. */ static void optimize_transition(Variables* v,OutputVariables* output,Fst2* fst2,Transition* transition, OptimizedFst2State state,Fst2Tag* tags,Abstract_allocator prv_alloc) { if (transition->tag_number<0) { /* If the transition is a graph call */ add_graph_call(transition,&(state->graph_calls),prv_alloc); add_graph_call(transition,&(state->unoptimized_graph_calls),prv_alloc); return; } Fst2Tag tag=tags[transition->tag_number]; if (tag==NULL) { fatal_error("NULL transition tag in optimize_transition\n"); } int negation=is_bit_mask_set(tag->control,NEGATION_TAG_BIT_MASK); /* First, we look if there is a compound pattern associated to this tag */ if (tag->compound_pattern!=NO_COMPOUND_PATTERN) { add_pattern(tag->compound_pattern,transition,&(state->compound_patterns),negation,prv_alloc); } /* Then, we look the possible kind of transitions */ switch (tag->type) { case TOKEN_LIST_TAG: add_token_list(tag->matching_tokens,transition,&(state->token_list),&(state->number_of_tokens),prv_alloc); return; case PATTERN_NUMBER_TAG: add_pattern(tag->pattern_number,transition,&(state->patterns),negation,prv_alloc); return; case META_TAG: { add_meta(tag->meta,transition,&(state->metas),negation,prv_alloc); add_meta(tag->meta,transition,&(state->unoptimized_metas),negation,prv_alloc); return; } case BEGIN_VAR_TAG: { add_input_variable(v,tag->variable,transition,&(state->input_variable_starts),prv_alloc); add_input_variable(v,tag->variable,transition,&(state->unoptimized_input_variable_starts),prv_alloc); return; } case END_VAR_TAG: { add_input_variable(v,tag->variable,transition,&(state->input_variable_ends),prv_alloc); add_input_variable(v,tag->variable,transition,&(state->unoptimized_input_variable_ends),prv_alloc); return; } case BEGIN_OUTPUT_VAR_TAG: { add_output_variable(output,tag->variable,transition,&(state->output_variable_starts),prv_alloc); add_output_variable(output,tag->variable,transition,&(state->unoptimized_output_variable_starts),prv_alloc); return; } case END_OUTPUT_VAR_TAG: { add_output_variable(output,tag->variable,transition,&(state->output_variable_ends),prv_alloc); add_output_variable(output,tag->variable,transition,&(state->unoptimized_output_variable_ends),prv_alloc); return; } case BEGIN_POSITIVE_CONTEXT_TAG: add_positive_context(fst2,state,transition,prv_alloc); return; case BEGIN_NEGATIVE_CONTEXT_TAG: add_negative_context(fst2,state,transition,prv_alloc); return; case END_CONTEXT_TAG: add_end_context(state,transition,prv_alloc); return; case LEFT_CONTEXT_TAG: { add_meta(META_LEFT_CONTEXT,transition,&(state->metas),0,prv_alloc); add_meta(META_LEFT_CONTEXT,transition,&(state->unoptimized_metas),0,prv_alloc); return; } case BEGIN_MORPHO_TAG: { struct opt_meta* new_meta=add_meta(META_BEGIN_MORPHO,transition,&(state->metas),0,prv_alloc); get_reachable_closing_morphological_mode(fst2,transition->state_number,&(new_meta->morphological_mode_ends),prv_alloc); add_meta(META_BEGIN_MORPHO,transition,&(state->unoptimized_metas),0,prv_alloc); return; } case END_MORPHO_TAG: { add_meta(META_END_MORPHO,transition,&(state->metas),0,prv_alloc); add_meta(META_END_MORPHO,transition,&(state->unoptimized_metas),0,prv_alloc); return; } case TEXT_START_TAG: { add_meta(META_TEXT_START,transition,&(state->metas),0,prv_alloc); add_meta(META_TEXT_START,transition,&(state->unoptimized_metas),0,prv_alloc); return; } case TEXT_END_TAG: { add_meta(META_TEXT_END,transition,&(state->metas),0,prv_alloc); add_meta(META_TEXT_END,transition,&(state->unoptimized_metas),0,prv_alloc); return; } default: fatal_error("Unexpected transition tag type in optimize_transition\n"); } }
/** * This function analyses the inputs of all the tags of the given .fst2 in * order to determine their kind. 'tokens' contains all the text tokens. * After the execution of the function, 'number_of_patterns' will contain * the number of patterns found in the grammar, and 'is_DIC'/'is_CDIC'/'is_SDIC'/'is_TDIC' * will contain 1 if the tag 'DIC'/'CDIC'/'SDIC'/'TDIC' has been found. See * the comment below about the special case for '<!DIC>'. */ void process_tags(int *number_of_patterns, struct string_hash* semantic_codes, int *is_DIC,int *is_CDIC, int *is_SDIC,struct locate_parameters* parameters, Abstract_allocator prv_alloc) { (*number_of_patterns)=0; (*is_DIC)=0; (*is_CDIC)=0; (*is_SDIC)=0; Fst2* fst2=parameters->fst2; struct string_hash* tokens=parameters->tokens; Fst2Tag* tag=fst2->tags; /* We get the number of the SPACE token */ unichar t[2]; t[0]=' '; t[1]='\0'; parameters->SPACE=get_value_index(t,tokens,DONT_INSERT); /* Then, we test all the tags */ for (int i=0;i<fst2->number_of_tags;i++) { if (tag[i]->type!=UNDEFINED_TAG) { /* We don't need to process again things like variables and contexts * that have already been processed at the time of loading the fst2 */ continue; } int length=u_strlen(tag[i]->input); if (!u_strcmp(tag[i]->input,"#")) { /* If we have a #, we must check if it is the meta one that * forbids space or the "#" token */ if (is_bit_mask_set(tag[i]->control,RESPECT_CASE_TAG_BIT_MASK)) { /* If the case respect bit is set to 1, then we have the "#" token */ tag[i]->type=PATTERN_TAG; tag[i]->pattern=build_token_pattern(tag[i]->input,prv_alloc); } else { /* If we have the meta # */ tag[i]->type=META_TAG; tag[i]->meta=META_SHARP; } } else if (!u_strcmp(tag[i]->input,"<E>")) { /* If we have a transition tagged by the empty word epsilon */ tag[i]->type=META_TAG; tag[i]->meta=META_EPSILON; } else { int token_number=get_value_index(tag[i]->input,tokens,DONT_INSERT); if (token_number!=-1) { /* If the input is an existing token */ if (token_number==parameters->SPACE) { /* If it is a space */ tag[i]->type=META_TAG; tag[i]->meta=META_SPACE; } else { /* If it is a normal token */ tag[i]->type=PATTERN_TAG; tag[i]->pattern=build_token_pattern(tag[i]->input,prv_alloc); } } else { /* This input is not an existing token. Two cases can happen: * 1) metas like <!MOT> or patterns like <V:K> * 2) a word that is not in the text tokens */ if (tag[i]->input[0]!='<' || tag[i]->input[length-1]!='>') { /* If we are in case 2, it may not be an error. For instance, * if the tag contains "foo" and if it is a tag that allows * case variations, we could match "FOO" if this token is in the * text. */ tag[i]->type=PATTERN_TAG; tag[i]->pattern=build_token_pattern(tag[i]->input,prv_alloc); } else { /* If we have something of the form <...>, we must test first if it is * or not a negative tag like <!XXX> */ int negative_tag=(tag[i]->input[1]=='!')?1:0; if (negative_tag) { set_bit_mask(&(tag[i]->control),NEGATION_TAG_BIT_MASK); } /* Then, we must test if we have or not a meta. To do that, we * extract the content without < > and ! if any.*/ unichar* content=u_strdup(&(tag[i]->input[1+negative_tag]),length-2-negative_tag,prv_alloc); /* And we test all the possible metas */ if (!u_strcmp(content,"MOT")) { tag[i]->type=META_TAG; tag[i]->meta=META_MOT; } else if (!u_strcmp(content,"DIC")) { tag[i]->type=META_TAG; tag[i]->meta=META_DIC; if (!negative_tag) { /* We mark that the DIC tag has been found, but only * if it is not the negative one (<!DIC>). We do this * because things matched by <DIC> will be taken from * the 'dlf' and 'dlc' files, whereas things matched by <!DIC> * will be taken from the 'err' file. Such a trick is necessary * if we don't want 'priori' to be taken as an unknown word since * it is part of the compound word 'a priori' */ (*is_DIC)=1; } } else if (!u_strcmp(content,"CDIC")) { tag[i]->type=META_TAG; tag[i]->meta=META_CDIC; (*is_CDIC)=1; } else if (!u_strcmp(content,"SDIC")) { tag[i]->type=META_TAG; tag[i]->meta=META_SDIC; (*is_SDIC)=1; } else if (!u_strcmp(content,"TDIC")) { tag[i]->type=META_TAG; tag[i]->meta=META_TDIC; } else if (!u_strcmp(content,"MAJ")) { tag[i]->type=META_TAG; tag[i]->meta=META_MAJ; } else if (!u_strcmp(content,"MIN")) { tag[i]->type=META_TAG; tag[i]->meta=META_MIN; } else if (!u_strcmp(content,"PRE")) { tag[i]->type=META_TAG; tag[i]->meta=META_PRE; } else if (!u_strcmp(content,"NB")) { tag[i]->type=META_TAG; tag[i]->meta=META_NB; if (negative_tag) { error("Negative mark will be ignored in <!NB>\n"); } } else if (!u_strcmp(content,"TOKEN")) { tag[i]->type=META_TAG; tag[i]->meta=META_TOKEN; } else { /* If we arrive here, we have not a meta but a pattern like * <be>, <be.V>, <V:K>, ... */ tag[i]->type=PATTERN_TAG; tag[i]->pattern=build_pattern(content,semantic_codes,parameters->tilde_negation_operator,prv_alloc); if (tag[i]->pattern->type==CODE_PATTERN || tag[i]->pattern->type==LEMMA_AND_CODE_PATTERN || tag[i]->pattern->type==FULL_PATTERN || tag[i]->pattern->type==INFLECTED_AND_LEMMA_PATTERN) { /* If the pattern we obtain contains grammatical/semantic * codes, then we put it in the pattern tree and we note its number. */ tag[i]->pattern_number=add_pattern(number_of_patterns,tag[i]->pattern,parameters->pattern_tree_root,prv_alloc); if (tag[i]->pattern->type==CODE_PATTERN) { /* If we have a code pattern, then the tag will just need to contain * the pattern number, BUT, WE DO NOT FREE THE PATTERN, * since this pattern still could be used in morphological mode */ tag[i]->type=PATTERN_NUMBER_TAG; } } } /* We don't forget to free the content */ free_cb(content,prv_alloc); } } } } }