static int lahocorasick_release ( lua_State* L ) { AC_AUTOMATA_t* m = *(AC_AUTOMATA_t**)luaL_checkudata ( L , 1 , AHO_METATABLE_KEY ); ac_automata_release ( m ); return 0; }
int main (int argc, char ** argv) { unsigned int i; struct parameter my_param; // we use this struct to send/receive input/output parameters to/from automata my_param.position = 250; // input: end position; change it to 1000 and see what happens my_param.match_count = 0; // output: AC_TEXT_t input_text; AC_AUTOMATA_t * atm = ac_automata_init (); for (i=0; i<PATTERN_COUNT; i++) { AC_STATUS_t status; sample_patterns[i].length = strlen (sample_patterns[i].astring); status = ac_automata_add (atm, &sample_patterns[i]); switch (status) { case ACERR_DUPLICATE_PATTERN: // printf ("Add pattern failed: ACERR_DUPLICATE_PATTERN: %s\n", sample_patterns[i].astring); break; case ACERR_LONG_PATTERN: printf ("Add pattern failed: ACERR_LONG_PATTERN: %s\n", sample_patterns[i].astring); break; case ACERR_ZERO_PATTERN: printf ("Add pattern failed: ACERR_ZERO_PATTERN: %s\n", sample_patterns[i].astring); break; case ACERR_AUTOMATA_CLOSED: printf ("Add pattern failed: ACERR_AUTOMATA_CLOSED: %s\n", sample_patterns[i].astring); break; case ACERR_SUCCESS: // printf ("Pattern Added: %s\n", sample_patterns[i].astring); break; } } ac_automata_finalize (atm); // here we illustrates how to search a big text chunk by chunk. // in this example input buffer size is 64 and input file is pretty // bigger than that. we want to imitate reading from input file. // in such situations searching must be done inside a loop. the loop // continues until it consumed all input file. // printf ("Automata finalized.\n\nSearching...\n"); //Added below code by Roja FILE *fp; char *line; size_t len=0; fp = fopen(argv[1], "r"); fp1 = fopen(argv[2], "w"); if(fp == NULL || fp1 == NULL) printf("File Couldn't Open\n"); input_line[0]='_'; while(getline(&line, &len, fp)!=-1) { strcpy(input_line+1, line); // printf("%s", input_line); //calling function replace_space_with_underscore() replace_space_with_underscore(input_line); *(input_line+len)='_'; //Code added by Roja ended char * chunk_start = input_line; char * end_of_file = input_line + sizeof(input_line); input_text.astring = buffer; while (chunk_start<end_of_file) { input_text.length = (chunk_start<end_of_file)?sizeof(buffer):(sizeof(input_line)%sizeof(buffer)); strncpy (buffer, chunk_start, input_text.length); if (ac_automata_search (atm, &input_text, 0, match_handler, (void *)(&my_param))) // if the search stopped in the middle (returned 1) we should break the loop break; chunk_start += sizeof(buffer); } printf(";~~~~~~~~~~\n"); //Added by Roja fprintf(fp1, ";~~~~~~~~~~\n"); //Added by Roja } // printf ("found %d occurrence in the beginning %d bytes\n", my_param.match_count, my_param.position); // TODO: do the same search with settext/findnext interface ac_automata_release (atm); return 0; }
int main (int argc, char ** argv) { unsigned int i; // 2. Define AC variables AC_AUTOMATA_t *atm; AC_PATTERN_t tmp_patt; AC_TEXT_t tmp_text; // 3. Get a new automata atm = ac_automata_init (); // 4. Add patterns to automata for (i=0; i<PATTERN_NUMBER; i++) { tmp_patt.astring = sample_patterns[i]; tmp_patt.rep.number = i+1; // optional tmp_patt.length = strlen (tmp_patt.astring); ac_automata_add (atm, &tmp_patt); } // 5. Finalize automata. ac_automata_finalize (atm); // after you have finished with adding patterns you must finalize the automata // from now you can not add patterns anymore. // 5.1. Display automata // ac_automata_display (atm, 'n'); // the second argument determines the cast type of the pattern representative. // 'n': as number // 's': as string // because we use the integer part of union (tmp_patt.rep.number) so we used 'n' printf ("Searching: \"%s\"\n", input_text1); // 6. Set input text tmp_text.astring = input_text1; tmp_text.length = strlen (tmp_text.astring); // 7. Do search ac_automata_search (atm, &tmp_text, 0, match_handler, 0); // the 5th option is a (void *), and it will be forwarded to the callback // function. you can pass everything you want to the callback function // using this argument. // in this example we don't send a parameter to callback function. // a typical practice is to define a struct that encloses whatever you want // to send the callback function, including input and output variables printf ("Searching: \"%s\"\n", input_text2); // do another search tmp_text.astring = input_text2; tmp_text.length = strlen (tmp_text.astring); ac_automata_search (atm, &tmp_text, 0, match_handler, 0); printf ("Searching: \"%s\" with \'keep\' enabled\n", input_text3); // and another tmp_text.astring = input_text3; tmp_text.length = strlen (tmp_text.astring); ac_automata_search (atm, &tmp_text, 1, match_handler, 0); // when the keep option (3rd argument) in set, then the automata // considers that the given text is the next chunk of the previous text. // to understand the difference try it with 0 and 1 and compare the result // 8. Release automata ac_automata_release (atm); // do not forget to release the automata after you have done with it return 0; }
int main (int argc, char ** argv) { //*** 2. Define AC variables AC_AUTOMATA_t * acap; AC_TEXT_t input_text = {0, 0}; #define PATTERN_NUMBER (sizeof(allpattern)/sizeof(AC_PATTERN_t)) unsigned int i; /* Sending parameter to call-back function */ struct sample_param my_param; my_param.anum = 1; my_param.achar = 'a'; /* 'a': find all, 'f': find first */ //*** 3. Get a new automata acap = ac_automata_init (match_handler); //*** 4. add patterns to automata for (i=0; i<PATTERN_NUMBER; i++) { allpattern[i].length = strlen(allpattern[i].astring); ac_automata_add (acap, &allpattern[i]); } //*** 5. Finalize automata. ac_automata_finalize (acap); //*** 5.1 Display automata //ac_automata_display (acap, 's'); /* This illustrates how to search big text chunk by chunk * in this example input buffer size is 2500 and input file is pretty * bigger than that. in fact it imitate reading from input file. * in such situations searching must be done inside a loop. the loop * continues until it consumes all input file. **/ FILE *fp; char *line; size_t len=0; int k=0; char tolower_input_line[10000]; fp = fopen(argv[1], "r"); if(fp == NULL) printf("File Couldn't Open\n"); input_line[0]='_'; tolower_input_line[0]='_'; while(getline(&line, &len, fp)!=-1) { strcpy(input_line+1, line); // printf("%s", input_line); //calling function replace_space_with_underscore() replace_space_with_underscore(input_line); *(input_line+len)='_'; k=0; strcpy(tolower_input_line+1, line); //tolower while(tolower_input_line[k]) { *(tolower_input_line+k)= tolower(tolower_input_line[k]); k++; } /*****appending original line and tolower of the same line *(input_line+strcspn(input_line, "\n"))= '/'; strcat(input_line, tolower_input_line); **********/ //calling function replace_space_with_underscore() replace_space_with_underscore(tolower_input_line); *(tolower_input_line+len)='_'; char * chunk_start = input_line; // char * end_of_file = input_line+sizeof(input_line); char * end_of_file = input_line+strlen(input_line); input_text.astring = buffer; /* Search loop */ while (chunk_start<end_of_file) { //*** 6. Set input text input_text.length = (chunk_start<end_of_file)? sizeof(buffer):(sizeof(input_line)%sizeof(buffer)); strncpy(input_text.astring, chunk_start, input_text.length); //*** 7. Do search if(ac_automata_search (acap, &input_text, (void *)(&my_param))) break; /* according to the return value of ac_automata_search() we decide to * continue or break loop. */ chunk_start += sizeof(buffer); } //*** 8. Reset ac_automata_reset(acap); //Checking multi words after tolowering the i/p. strcpy(input_line,tolower_input_line); chunk_start = input_line; end_of_file = input_line+strlen(input_line); input_text.astring = buffer; /* Search loop */ while (chunk_start<end_of_file) { //*** 6. Set input text input_text.length = (chunk_start<end_of_file)? sizeof(buffer):(sizeof(input_line)%sizeof(buffer)); strncpy(input_text.astring, chunk_start, input_text.length); //*** 7. Do search if(ac_automata_search (acap, &input_text, (void *)(&my_param))) break; /* according to the return value of ac_automata_search() we decide to * continue or break loop. */ chunk_start += sizeof(buffer); } ac_automata_reset(acap); printf(";~~~~~~~~~~\n"); } //*** 9. Release automata ac_automata_release (acap); return 0; }