Esempio n. 1
0
void search_buffer(struct search_state *state, const char *pattern,
        int pattern_size, char *buffer, int buffer_size,
        const char *file_name, ullong buffer_offset) {
    const char *buffer_start = buffer;
    /* Where to stop matching */
    const char *buffer_end = buffer + buffer_size - pattern_size;
    int buffer_hash = hash_code(buffer, pattern_size);
    int pattern_hash = state->pattern_hash;
    int most_significant_factor = state->most_significant_factor;

    /* Loop through the buffer... */
    while(buffer < buffer_end) {
        /* Compare hashes, and strings if necessary */
        if(buffer_hash == pattern_hash &&
                !strncmp(buffer, pattern, pattern_size)) {
            print_match(file_name, buffer_offset + (buffer - buffer_start));
        }

        /* Update hash */
        buffer_hash = ((buffer_hash -
                ((unsigned char) *buffer) * most_significant_factor) << 1) +
                (unsigned char) *(buffer + pattern_size);

        buffer++;
    }

    /* Comparison for the last position */
    if(buffer_hash == pattern_hash &&
            !strncmp(buffer, pattern, pattern_size)) {
        print_match(file_name, buffer_offset + (buffer - buffer_start));
    }
}
Esempio n. 2
0
int main()
{
	int xmatch[MAX], ymatch[MAX];
	bipartite b1(4, 5);
	b1.b_g[0][0] = 1; b1.b_g[0][1] = 1; b1.b_g[0][2] = 1; b1.b_g[0][3] = 1;
	b1.b_g[1][0] = 1; b1.b_g[1][1] = 1; b1.b_g[1][3] = 1; b1.b_g[1][4] = 1;
	b1.b_g[2][1] = 1; b1.b_g[2][2] = 1; b1.b_g[2][3] = 1; b1.b_g[2][4] = 1;
	b1.b_g[3][0] = 1; b1.b_g[3][1] = 1; b1.b_g[3][2] = 1; b1.b_g[3][4] = 1;
	cout << "hungarian 1 max binary match: " << hungarian1(b1, xmatch, ymatch) << endl;	//1
	print_match(b1, ymatch);
	cout << "hungarian 2 max binary match: " << hungarian2(b1, ymatch) << endl;
	print_match(b1, ymatch);
	cout << "hopcroft karp max binary match: " << hopcroft_karp(b1, xmatch, ymatch) << endl;	//2
	print_match(b1, ymatch);

	bipartite b2(5, 5);
	b2.b_g[0][0] = 3; b2.b_g[0][1] = 5; b2.b_g[0][2] = 5; b2.b_g[0][3] = 4; b2.b_g[0][4] = 1;
	b2.b_g[1][0] = 2; b2.b_g[1][1] = 2; b2.b_g[1][2] = 0; b2.b_g[1][3] = 2; b2.b_g[1][4] = 2;
	b2.b_g[2][0] = 2; b2.b_g[2][1] = 4; b2.b_g[2][2] = 4; b2.b_g[2][3] = 1; b2.b_g[2][4] = 0;
	b2.b_g[3][0] = 0; b2.b_g[3][1] = 1; b2.b_g[3][2] = 1; b2.b_g[3][3] = 0; b2.b_g[3][4] = 0;
	b2.b_g[4][0] = 1; b2.b_g[4][1] = 2; b2.b_g[4][2] = 1; b2.b_g[4][3] = 3; b2.b_g[4][4] = 3;
	cout << "kuhn munkres: " << kuhn_munkres(b2, ymatch) << endl; //5
	print_match(b2, ymatch);

	graph_matrix g(6);
	g.g_m[0][0] = 0; g.g_m[0][1] = 1; g.g_m[0][2] = 1; g.g_m[0][3] = 1; g.g_m[0][4] = INF; g.g_m[0][5] = INF;
	g.g_m[1][0] = INF; g.g_m[1][1] = 0; g.g_m[1][2] = INF; g.g_m[1][3] = 1; g.g_m[1][4] = 1; g.g_m[1][5] = INF;
	g.g_m[2][0] = INF; g.g_m[2][1] = INF; g.g_m[2][2] = 0; g.g_m[2][3] = 1; g.g_m[2][4] = INF; g.g_m[2][5] = 1;
	g.g_m[3][0] = 0; g.g_m[3][1] = INF; g.g_m[3][2] = INF; g.g_m[3][3] = 0; g.g_m[3][4] = 1; g.g_m[3][5] = 1;
	g.g_m[4][0] = INF; g.g_m[4][1] = INF; g.g_m[4][2] = INF; g.g_m[4][3] = INF; g.g_m[4][4] = 0; g.g_m[4][5] = 1;
	g.g_m[5][0] = INF; g.g_m[5][1] = INF; g.g_m[5][2] = INF; g.g_m[5][3] = INF; g.g_m[5][4] = INF; g.g_m[5][5] = 0;
	cout << "disjoint path covering: " << minimum_disjoint_path_covering(g) << endl;//3
	cout << "joint path covering: " << minimum_joint_path_covering(g) << endl; //4
	return(0);
}
Esempio n. 3
0
void
libwacom_print_device_description(int fd, const WacomDevice *device)
{
	const WacomMatch **match;
	WacomClass class;
	const char *class_name;

	class  = libwacom_get_class(device);
	switch(class) {
		case WCLASS_UNKNOWN:	class_name = "Unknown";	break;
		case WCLASS_INTUOS3:	class_name = "Intuos3";	break;
		case WCLASS_INTUOS4:	class_name = "Intuos4";	break;
		case WCLASS_INTUOS5:	class_name = "Intuos5";	break;
		case WCLASS_CINTIQ:	class_name = "Cintiq";	break;
		case WCLASS_BAMBOO:	class_name = "Bamboo";	break;
		case WCLASS_GRAPHIRE:	class_name = "Graphire";break;
		case WCLASS_ISDV4:	class_name = "ISDV4";	break;
		case WCLASS_INTUOS:	class_name = "Intuos";	break;
		case WCLASS_INTUOS2:	class_name = "Intuos2";	break;
		case WCLASS_PEN_DISPLAYS:	class_name = "PenDisplay";	break;
		case WCLASS_REMOTE:	class_name = "Remote";	break;
		default:		g_assert_not_reached(); break;
	}

	dprintf(fd, "[Device]\n");
	dprintf(fd, "Name=%s\n", libwacom_get_name(device));
	dprintf(fd, "DeviceMatch=");
	for (match = libwacom_get_matches(device); *match; match++)
		print_match(fd, *match);
	dprintf(fd, "\n");

	if (libwacom_get_paired_device(device)) {
		dprintf(fd, "PairedID=");
		print_match(fd, libwacom_get_paired_device(device));
		dprintf(fd, "\n");
	}

	dprintf(fd, "Class=%s\n",		class_name);
	dprintf(fd, "Width=%d\n",		libwacom_get_width(device));
	dprintf(fd, "Height=%d\n",		libwacom_get_height(device));
	print_integrated_flags_for_device(fd, device);
	print_layout_for_device(fd, device);
	print_styli_for_device(fd, device);
	dprintf(fd, "\n");

	dprintf(fd, "[Features]\n");
	dprintf(fd, "Reversible=%s\n", libwacom_is_reversible(device)	? "true" : "false");
	dprintf(fd, "Stylus=%s\n",	 libwacom_has_stylus(device)	? "true" : "false");
	dprintf(fd, "Ring=%s\n",	 libwacom_has_ring(device)	? "true" : "false");
	dprintf(fd, "Ring2=%s\n",	 libwacom_has_ring2(device)	? "true" : "false");
	dprintf(fd, "Touch=%s\n",	 libwacom_has_touch(device)	? "true" : "false");
	dprintf(fd, "TouchSwitch=%s\n",	libwacom_has_touchswitch(device)? "true" : "false");
	print_supported_leds(fd, device);

	dprintf(fd, "NumStrips=%d\n",	libwacom_get_num_strips(device));
	dprintf(fd, "Buttons=%d\n",		libwacom_get_num_buttons(device));

	print_buttons_for_device(fd, device);
}
Esempio n. 4
0
/*
*	Searches through a nucleic acid sequence and matchs the K-mer and the K-mer reverse complement.
*	Uses a binary AND operation to limit the number of conditionals within the for loop.
*/
void search_nucleic_acid(Sequence* currentSequence, char* k_mer, char* reverseComplementKmer, int k)
{
	int i;
	int j;
	float gcContent;
	int gc = 0;
	
	for (i = 0; i <= currentSequence->sequenceLength - k; i++)
	{
		if (k_mer[0] & currentSequence->data[i])
		{
			for (j = 1; j < k; j++)
			{
				if (!(k_mer[j] & currentSequence->data[ i + j ]))
				{
					break;
				}
			}
			if (j == k)
			{
				print_match(currentSequence, i, i + k, '+');
			}
		}
		
		if (reverseComplementKmer[0] & currentSequence->data[i])
		{
			for (j = 1; j < k; j++)
			{
				if (!(reverseComplementKmer[j] & currentSequence->data[ i + j ]))
				{
					break;
				}
			}
			if (j == k)
			{
				print_match(currentSequence, i, i + k, '-');
			}
		}
		if (currentSequence->data[i] & 6)
		{
			gc++;
		}
	}
	
	for (; i <= currentSequence->sequenceLength; i++)
	{
		if (currentSequence->data[i] & 6)
		{
			gc++;
		}
	}
	gcContent = 100 * ((float)gc / currentSequence->sequenceLength);
	printf("GC content for sequence %s: %.2f\%\n\n", currentSequence->sequenceName, gcContent);
}
Esempio n. 5
0
static void
set_save_v1(const void *ip, const struct xt_entry_match *match)
{
	const struct xt_set_info_match_v1 *info = (const void *)match->data;

	print_match("--match-set", &info->match_set);
}
Esempio n. 6
0
/* Prints out the matchinfo. */
static void
set_print_v1(const void *ip, const struct xt_entry_match *match, int numeric)
{
	const struct xt_set_info_match_v1 *info = (const void *)match->data;

	print_match("match-set", &info->match_set);
}
Esempio n. 7
0
/* Saves the matchinfo in parsable form to stdout. */
static void set_save(const void *ip, const struct xt_entry_match *match)
{
	struct ipt_set_info_match *info = 
		(struct ipt_set_info_match *) match->data;

	print_match("--set", &info->match_set);
}
Esempio n. 8
0
/* Prints out the matchinfo. */
static void set_print(const void *ip, const struct xt_entry_match *match,
                      int numeric)
{
	struct ipt_set_info_match *info = 
		(struct ipt_set_info_match *) match->data;

	print_match("set", &info->match_set);
}
Esempio n. 9
0
static void
statistic_print(const void *ip, const struct xt_entry_match *match, int numeric)
{
	struct xt_statistic_info *info = (struct xt_statistic_info *)match->data;

	printf("statistic ");
	print_match(info, "");
}
Esempio n. 10
0
/* Prints the matches that takes place within the timespan of the range */
void print_range_matches(match_s *match_range, int matches_in_range) {
    int match_number = 0;

    printf("Weekday\tDate & Time\tHome  Out\tGoals\tSpectators\n");

    for(match_number = 0; match_number < matches_in_range; match_number++) {
        print_match(match_range, match_number);
    }
}
Esempio n. 11
0
static void
set_save_v2(const void *ip, const struct xt_entry_match *match)
{
	const struct xt_set_info_match_v1 *info = (const void *)match->data;

	print_match("--match-set", &info->match_set);
	if (info->match_set.flags & IPSET_RETURN_NOMATCH)
		printf(" --return-nomatch");
}
Esempio n. 12
0
/* Task one - performs all work for task one */
void task_one(match_s *match, int number_of_matches) {

    int match_number = 0;

    printf("The following matches have a total of 7 or more goals:\n");
    printf("Weekday\tDate & Time\tHome  Out\tGoals\tSpectators\n");

    for(match_number = 0; match_number < number_of_matches; match_number++) {
        if(match[match_number].home_goal + match[match_number].out_goal >= 7) {
            print_match(match, match_number);
        }
    }
}
Esempio n. 13
0
static void
set_print_v4_matchinfo(const struct xt_set_info_match_v4 *info,
		       const char *opt, const char *sep)
{
	print_match(opt, &info->match_set);
	if (info->flags & IPSET_FLAG_RETURN_NOMATCH)
		printf(" %sreturn-nomatch", sep);
	if ((info->flags & IPSET_FLAG_SKIP_COUNTER_UPDATE))
		printf(" ! %supdate-counters", sep);
	if ((info->flags & IPSET_FLAG_SKIP_SUBCOUNTER_UPDATE))
		printf(" ! %supdate-subcounters", sep);
	set_printv4_counter(&info->packets, "packets", sep);
	set_printv4_counter(&info->bytes, "bytes", sep);
}
Esempio n. 14
0
int main(int argc, char **argv) {
    if (argc != 4) {
        printUsage();
    }
    
    int number = atoi(argv[1]);
    int pos_1 = atoi(argv[2]);
    int pos_2 = atoi(argv[3]);
    char *pointer = dec_to_bin(number);

    int check = check_bits(pointer, pos_1, pos_2);
    print_match(check);

    free(pointer);
    return 0;
}
Esempio n. 15
0
void printer::run() {
  for (;;) {
    {
      std::unique_lock<std::mutex> lock(contents_mtx);
      contents_cv.wait(lock, [this] { return !this->contents.empty(); });
      while (!contents.empty()) {
        auto&& top = contents.front();
        switch (top.t) {
        case tag::finish:
          return;
        case tag::match:
          print_match(os, *top.result);
          break;
        }
        contents.pop();
      }
    }
  }
}
Esempio n. 16
0
void print_align_list_segments (alignel* alignList)
	{
	alignel*	a;
	unspos		beg1, end1, beg2, end2;
	unspos		height, width, i, j, prevI, prevJ, run;
	u32			opIx;
	score		s;

	for (a=alignList ; a!=NULL ; a=a->next)
		{
		beg1   = a->beg1;
		end1   = a->end1;
		beg2   = a->beg2;
		end2   = a->end2;
		height = end1 - beg1 + 1;
		width  = end2 - beg2 + 1;

		snoopGenpaf_1;

		// print the alignment's segments

		opIx = 0;
		for (i=j=0 ; (i< height)||(j<width) ; )
			{
			prevI = i;  prevJ = j;
			run = edit_script_run_of_subs (a->script, &opIx);
			i += run; j += run;
			if ((i < height) || (j < width))
				edit_script_indel_len (a->script, &opIx, &i, &j);

			s = score_match (currParams->scoring,
			                 currParams->seq1, beg1-1+prevI,
			                 currParams->seq2, beg2-1+prevJ,
			                 run);
			print_match (beg1-1+prevI, beg2-1+prevJ, run, s);
			}
		}

	}
Esempio n. 17
0
/*
*	Searches through an amino acid sequence to match a given K-mer.
*	Uses exact matching to locate a match.
*/
void search_amino_acid(Sequence* currentSequence, char* k_mer, int k)
{
	int i;
	int j;
	
	for (i = 0; i < currentSequence->sequenceLength - k; i++)
	{
		if (k_mer[0] == currentSequence->data[i])
		{
			for (j = 1; j < k; j++)
			{
				if (k_mer[j] != currentSequence->data[i+j])
				{
					break;
				}
			}
			if (j == k)
			{
				print_match(currentSequence, i, i + k, '.');
			}
		}
	}
}
Esempio n. 18
0
static void save(const struct ipt_ip *ip, const struct ipt_entry_match *match)
{
#ifdef IPTABLES_SAVE
	print_match((const struct ipt_web_info *)match->data);
#endif
}
Esempio n. 19
0
File: mgrep.c Progetto: hildjj/mgrep
int main(int argc, char *const argv[])
{
    size_t before = 16;
    size_t after = 16;
    int color = 0;
    bool hexlify = true;
    int ch;
    long ia, ib;
    while ((ch = getopt(argc, argv, "a:b:chH")) != -1)
    {
        switch(ch)
        {
            case 'a':
                ia = strtol(optarg, NULL, 10);
                if ((ia > 0) && (ia < 1024))
                {
                    after = (size_t)ia;
                }
                break;
            case 'b':
                ib = strtol(optarg, NULL, 10);
                if ((ib > 0) && (ib < 1024))
                {
                    before = (size_t)ib;
                }
                break;
            case 'c':
                color++;
                break;
            case 'H':
                hexlify = !hexlify;
                break;
            case 'h':
            default:
                usage();
                break;
        }
    }

    if (!isatty(STDOUT_FILENO) && color)
    {
        color--;
    }

    argc -= optind;
    argv += optind;

    if (argc < 2)
    {
        usage();
    }

    size_t pattern_size = 0;
    uint8_t *pattern;
    if (hexlify)
    {
        pattern = hex_decode(argv[0], &pattern_size);
    }
    else
    {
        pattern_size = strlen(argv[0]);
        pattern = (uint8_t*)strndup(argv[0], pattern_size);
    }

    if (!pattern)
    {
        fprintf(stderr, "Invalid pattern\n");
    }

    // initialize boyer-moore patterns
    int *delta1 = (int*)malloc(ALPHABET_LEN * sizeof(int));
    int *delta2 = (int*)malloc(pattern_size * sizeof(int));
    make_delta1(delta1, pattern, pattern_size);
    make_delta2(delta2, pattern, pattern_size);

    size_t count = 0;
    size_t errors = 0;
    for (int f=1; f<argc; f++)
    {
        int first = 1;
        const char *file_name = argv[f];
        int fd = open(file_name, O_RDONLY);
        if (fd < 0)
        {
            fprintf(stderr, "Open error ");
            perror(file_name);
            errors++;
            continue;
        }

        // Get the file size, to make mmap search the whole thing
        struct stat file_stat;
        if (fstat(fd, &file_stat) != 0)
        {
            fprintf(stderr, "Stat error ");
            perror(file_name);
            errors++;
            close(fd); // ignore error
            continue;
        }

        size_t file_size = (size_t)file_stat.st_size;
        if ((file_size == 0) || !S_ISREG(file_stat.st_mode))
        {
            close(fd); // ignore error
            continue;
        }

        const uint8_t *file = mmap(0, file_size, PROT_READ, MAP_SHARED, fd, 0);
        if (file == MAP_FAILED)
        {
            fprintf(stderr, "Mmap error ");
            perror(file_name);
            errors++;
            close(fd); // ignore error
            continue;
        }


        // Find all matches, don't worry about overlaps
        size_t last = 0;
        size_t next = 0;
        while ((next = bm_search(file + last,
                                 file_size - last,
                                 pattern, pattern_size,
                                 delta1, delta2)) != NOT_FOUND)
        {
            if (first)
            {
                first = 0;
                printf("---- %s ----\n", file_name);
            }

            print_match(file, last + next, pattern_size, before, after, color);
            last += next + pattern_size;
            count++;
        }

        if (munmap((void*)file, file_size) != 0)
        {
            fprintf(stderr, "Unmap error ");
            perror(file_name);
            errors++;
        }

        if (close(fd) != 0)
        {
            fprintf(stderr, "Close error ");
            perror(file_name);
            errors++;
        }
    }

    free(delta2);
    free(delta1);
    free(pattern);

    if (count > 0)
    {
        return 0;
    }
    if (errors > 0)
    {
        return 2;
    }
    return 1;
}
Esempio n. 20
0
int main(int argc, char *argv[]) {
  kseq_t *seq;
  int l, index, shift, min=5, min_keep=35;
  int debug=0, verbose=1;
  int contaminated=0, total=0;
  quality_type qual_type=SANGER;
  match *best_match;
  float *qprobs, prior=default_prior;
  adapter_array *aa;
  gzFile adapter_fp=NULL, fp;
  FILE *output_fp=stdout, *matches_fp=NULL;
  int optc;
  int add_tag = 0;
  extern char *optarg;

  while (1) {
    int option_index = 0;
    optc = getopt_long(argc, argv, "dtfp:a:o:q:m:o:n:M:", long_options, &option_index);

    if (optc == -1)
       break;
    switch (optc) {
      if (long_options[option_index].flag != 0)
        break;
      case 'a':
        adapter_fp = gzopen(optarg, "r");
        if (!adapter_fp) {
          fprintf(stderr, "Could not open adapter file '%s'.\n", optarg);
          return EXIT_FAILURE;
        }
        break;
      case 'd':
        debug = 1;
        break;
      case 't':
        add_tag = 1;
        break;
      case 'Q':
        verbose = 0;
        break;
      case 'o':
        output_fp = fopen(optarg, "w");
        if (!output_fp) {
          fprintf(stderr, "Could not open output file '%s'.\n", optarg);
          return EXIT_FAILURE;
        }
        break;
      case 'm':
        matches_fp = fopen(optarg, "w");
        if (!matches_fp) {
          fprintf(stderr, "Could not open matches file '%s'.\n", optarg);
          return EXIT_FAILURE;
        }
        break;
      case 'n':
        min = atoi(optarg);
        break;
      case 'M':
        min_keep = atoi(optarg);
        break;
      case 'q':
        if (strcmp(optarg, "illumina") == 0)
          qual_type = ILLUMINA;
        else if (strcmp(optarg, "solexa") == 0)
          qual_type = SOLEXA;
        else if (strcmp(optarg, "sanger") == 0)
          qual_type = SANGER;
        else {
          fprintf(stderr, "Unknown quality type '%s'.\n", optarg);
          usage(EXIT_FAILURE);
        }          
        break;
      case 'p':
        /* This truncation is acceptable... priors need not be doubles */
        prior = (float) atof(optarg);
        if (prior > 1 || prior < 0) {
          fprintf(stderr, "Prior must be between 0 and 1\n");
          usage(EXIT_FAILURE);
        }
        break;
        
      case_GETOPT_HELP_CHAR;
      case_GETOPT_VERSION_CHAR(PROGRAM_NAME, VERSION, AUTHORS);
      case '?':
        break;
      default:
        usage(EXIT_FAILURE);
      }
  }
  
  if (debug) {
    matches_fp = stdout;
    output_fp = stdout;
  }
  
  if ((index = optind) == argc) {
    fprintf(stderr, "No FASTQ file specified.\n");
    usage(EXIT_FAILURE);
  }
 
  /* load all adapter sequences into memory */
  if (!adapter_fp) {
    fprintf(stderr, "No adapter file specified.\n");
    usage(EXIT_FAILURE);
  }
  aa = load_adapters(adapter_fp);
  gzclose(adapter_fp);

  fp = strcmp(argv[index], "-") ? gzopen(argv[index], "r") : gzdopen(fileno(stdin), "r");

  if (!fp) {
    fprintf(stderr, "FASTQ file '%s' not found.\n", argv[index]);
    return EXIT_FAILURE;
  }

  seq = kseq_init(fp);

  /* Loop through entire sequence file. Write trimmed sequences to
     file (or stdout), and record matches in a match file if specifed.
  */
  while ((l = kseq_read(seq)) >= 0) {
    shift = -1;
    if (!seq->qual.s) {
      fputs("Sequence file missing or has malformed quality line.\n", stderr);
      usage(EXIT_FAILURE);
    }
      
    qprobs = qual_to_probs(seq->qual.s, qual_type);
    best_match = find_best_match(aa, seq->seq.s, qprobs, prior, 0.25, min);
    
    if (best_match && best_match->ps->is_contam) {
      contaminated++;
      shift = best_match->shift;
      if (matches_fp) print_match(seq, best_match, matches_fp, aa, qual_type);
      /* TODO */
      /* aa->adapters[best_match->adapter_index].occurrences[best_match->n-1]++; */
    }    
    write_fastq(output_fp, seq, add_tag, shift, min_keep);
    if (best_match) destroy_match(best_match);
    free(qprobs);
    total++;
  }
  
  if (verbose) 
    print_summary(aa, prior, total-contaminated, contaminated, total);

  kseq_destroy(seq);
  destroy_adapters(aa, MAX_ADAPTERS);
  gzclose(fp);
  return 0;
}
void _match_pattern_indels(const cachedCharSeq *P, const cachedCharSeq *S,
		int max_nmis, int fixedP, int fixedS)
{
	int i0, j0, max_nmis1, nedit1, width1;
	char c0;
	cachedCharSeq P1;

	if (P->length <= 0)
		error("empty pattern");
	_select_nmismatch_at_Pshift_fun(fixedP, fixedS);
	if (!fixedP || !fixedS)
		error("'fixed' must be TRUE when 'algorithm=\"indels\"' (for now)");
	// Before we can support fixedP=FALSE or fixedS=FALSE in
	// _match_pattern_indels(), we need to support them in
	// _init_byte2offset_with_cachedCharSeq() and _nedit_for_Ploffset().
	_init_byte2offset_with_cachedCharSeq(byte2offset, P, 0);
	provisory_match_nedit = -1; // means no provisory match yet
	j0 = 0;
	while (j0 < S->length) {
		while (1) {
			c0 = S->seq[j0];
			i0 = byte2offset[(unsigned char) c0];
			if (i0 != NA_INTEGER) break;
			j0++;
			if (j0 >= S->length) goto done;
		}
		P1.seq = P->seq + i0 + 1;
		P1.length = P->length - i0 - 1;
		max_nmis1 = max_nmis - i0;
/*
#ifdef DEBUG_BIOSTRINGS
		if (debug) {
			Rprintf("[DEBUG] _match_pattern_indels(): "
				"j0=%d c0=%c i0=%d max_nmis1=%d\n", j0, c0, i0, max_nmis1);
		}
#endif
*/
		if (max_nmis1 >= 0) {
			if (max_nmis1 == 0) {
				nedit1 = _selected_nmismatch_at_Pshift_fun(&P1, S, j0 + 1, max_nmis1);
				width1 = P1.length;
			} else {
				nedit1 = _nedit_for_Ploffset(&P1, S, j0 + 1, max_nmis1, 1, &width1);
			}
			if (nedit1 <= max_nmis1) {
#ifdef DEBUG_BIOSTRINGS
				if (debug) {
					Rprintf("[DEBUG] _match_pattern_indels(): "
						"provisory match found at ");
					print_match(j0 + 1, width1 + 1, P, S);
				}
#endif
				report_provisory_match(j0 + 1, width1 + 1, nedit1 + i0);
			}
		}
		j0++;
	}
	done:
	if (provisory_match_nedit != -1)
		_report_match(provisory_match_start, provisory_match_width);
	return;
}
Esempio n. 22
0
static void print(const struct ipt_ip *ip, const struct ipt_entry_match *match, int numeric)
{
	printf("web ");
	print_match((const struct ipt_web_info *)match->data);
}
Esempio n. 23
0
void _match_pattern_indels(const Chars_holder *P, const Chars_holder *S,
		int max_nmis, int fixedP, int fixedS)
{
	int i0, j0, max_nmis1, nedit1, width1;
	char c0;
	const BytewiseOpTable *bytewise_match_table;
	Chars_holder P1;

	if (P->length <= 0)
		error("empty pattern");
	bytewise_match_table = _select_bytewise_match_table(fixedP, fixedS);
	_init_byte2offset_with_Chars_holder(&byte2offset, P,
					     bytewise_match_table);
	provisory_match_nedit = -1; // means no provisory match yet
	j0 = 0;
	while (j0 < S->length) {
		while (1) {
			c0 = S->ptr[j0];
			i0 = byte2offset.byte2code[(unsigned char) c0];
			if (i0 != NA_INTEGER) break;
			j0++;
			if (j0 >= S->length) goto done;
		}
		P1.ptr = P->ptr + i0 + 1;
		P1.length = P->length - i0 - 1;
		max_nmis1 = max_nmis - i0;
/*
#ifdef DEBUG_BIOSTRINGS
		if (debug) {
			Rprintf("[DEBUG] _match_pattern_indels(): "
				"j0=%d c0=%c i0=%d max_nmis1=%d\n", j0, c0, i0, max_nmis1);
		}
#endif
*/
		if (max_nmis1 >= 0) {
			if (max_nmis1 == 0) {
				nedit1 = _nmismatch_at_Pshift(&P1, S, j0 + 1,
							max_nmis1,
							bytewise_match_table);
				width1 = P1.length;
			} else {
				nedit1 = _nedit_for_Ploffset(&P1, S, j0 + 1,
							max_nmis1, 1, &width1,
							bytewise_match_table);
			}
			if (nedit1 <= max_nmis1) {
#ifdef DEBUG_BIOSTRINGS
				if (debug) {
					Rprintf("[DEBUG] _match_pattern_indels(): "
						"provisory match found at ");
					print_match(j0 + 1, width1 + 1, P, S,
						    bytewise_match_table);
				}
#endif
				report_provisory_match(j0 + 1, width1 + 1, nedit1 + i0);
			}
		}
		j0++;
	}
	done:
	if (provisory_match_nedit != -1)
		_report_match(provisory_match_start, provisory_match_width);
	return;
}
Esempio n. 24
0
static void statistic_save(const void *ip, const struct xt_entry_match *match)
{
	struct xt_statistic_info *info = (struct xt_statistic_info *)match->data;

	print_match(info, "--");
}
Esempio n. 25
0
int main (int argc, char *argv[]) {

  int i, j, n, res;
  regex_t regex;
  char buffer[1024];
  regmatch_t matches[MAX_MATCHES];

  /* At least one argument, -h | --help | <regex> */
  if (argc < 2) {
    usage (argv[0]);
    exit (1);
  }

  /* Help */
  if ( (strcmp (argv[1], "-h") == 0) || (strcmp (argv[1], "--help") == 0) ) {
    usage (argv[0]);
    exit (0);
  }
  /* Show version */
  if ( (strcmp (argv[1], "-v") == 0) || (strcmp (argv[1], "--version") == 0) ) {
    printf ("Pcre version is %s\n", pcre_version());
    exit (0);
  }

  /* Compile regex */
  res = regcomp (&regex, argv[1], 0);
  if (res != 0) {
    (void) regerror (res, &regex, buffer, sizeof(buffer));
    fprintf (stderr, "ERROR: Compilation has failed with error: %s\n",
             buffer);
    exit (1);
  }

  /* Check strings */
  for (i = 3; i <= argc; i++) {
    /* Compile */
    res = regexec (&regex, argv[i-1], MAX_MATCHES, matches, 0);
    if (res == REG_NOMATCH) {
      printf ("No match\n");
      continue;
    }
    if (res != 0) {
      (void) regerror (res, &regex, buffer, sizeof(buffer));
      fprintf (stderr, "ERROR: Execution has failed with error: %s\n",
               buffer);
      exit (1);
    }
    /* Print result */
    print_match (matches[0]);

    /* Count matching substrings */
    n = 0;
    for (j = MAX_MATCHES - 1; j >= 0; j--) {
      if (matches[j].rm_so != -1) {
        n = j;
        break;
      }
    }

    /* Print matching substrings */
    for (j = 1; j <= n; j++) {
      print_match (matches[j]);
    }
  }

  /* Cleanup */
  regfree (&regex);
    
  /* Done */
  exit (0);
}
Esempio n. 26
0
//TODO: append matches to some data structure instead of just printing them out
// then there can be sweet summaries of matches/files scanned/time/etc
int search_dir(pcre *re, const char* path, const int depth) {
    //TODO: don't just die. also make max depth configurable
    if(depth > MAX_SEARCH_DEPTH) {
        log_err("Search depth greater than %i, giving up.", depth);
        exit(1);
    }
    struct dirent **dir_list = NULL;
    struct dirent *dir = NULL;
    int results = 0;

    FILE *fp = NULL;
    int f_len;
    size_t r_len;
    char *buf = NULL;
    int rv = 0;
    char *dir_full_path = NULL;
    size_t path_length = 0;

    results = scandir(path, &dir_list, &ignorefile_filter, &alphasort);
    if (results > 0) {
        for (int i = 0; i < results; i++) {
            dir = dir_list[i];
            path_length = (size_t)(strlen(path) + strlen(dir->d_name) + 2); // 2 for slash and null char
            dir_full_path = malloc(path_length);
            dir_full_path = strncpy(dir_full_path, path, path_length);
            dir_full_path = strncat(dir_full_path, "/", path_length);
            dir_full_path = strncat(dir_full_path, dir->d_name, path_length);
            load_ignore_patterns(dir_full_path);
            free(dir);
            free(dir_full_path);
        }
    }
    free(dir_list);

    results = scandir(path, &dir_list, &filename_filter, &alphasort);
    if (results == 0)
    {
        log_debug("No results found");
        free(dir_list);
        return(0);
    }
    else if (results == -1) {
        log_err("Error opening directory %s", path);
        return(0);
    }

    for (int i=0; i<results; i++) {
        dir = dir_list[i];
        // XXX: this is copy-pasted from about 30 lines above
        path_length = (size_t)(strlen(path) + strlen(dir->d_name) + 2); // 2 for slash and null char
        dir_full_path = malloc(path_length);
        dir_full_path = strncpy(dir_full_path, path, path_length);
        dir_full_path = strncat(dir_full_path, "/", path_length);
        dir_full_path = strncat(dir_full_path, dir->d_name, path_length);

        log_debug("dir %s type %i", dir_full_path, dir->d_type);
        //TODO: scan files in current dir before going deeper
        if (dir->d_type == DT_DIR && opts.recurse_dirs) {
            log_debug("searching dir %s", dir_full_path);
            rv = search_dir(re, dir_full_path, depth + 1);
            goto cleanup;
            continue;
        }
        fp = fopen(dir_full_path, "r");
        if (fp == NULL) {
            log_err("Error opening file %s. Skipping...", dir_full_path);
            goto cleanup;
            continue;
        }

        rv = fseek(fp, 0, SEEK_END);
        if (rv != 0) {
            log_err("Error fseek()ing file %s. Skipping...", dir_full_path);
            goto cleanup;
        }

        f_len = ftell(fp); //TODO: behave differently if file is HUGE. on 32 bit, anything > 2GB will screw up this program
        if (f_len == 0) {
            log_debug("file is empty. skipping");
            goto cleanup;
        }

        rewind(fp);
        buf = (char*) malloc(sizeof(char) * f_len + 1);
        r_len = fread(buf, 1, f_len, fp);
        buf[r_len] = '\0';
        int buf_len = (int)r_len;

        int buf_offset = 0;
        int offset_vector[MAX_MATCHES_PER_FILE * 2]; //XXXX
        int rc = 0;
        char *match_start = NULL;
        char *match_end = NULL;
        int first_match = 1;
        // In my profiling, most of the execution time is spent in this pcre_exec
        while(buf_offset < buf_len && (rc = pcre_exec(re, NULL, buf, r_len, buf_offset, 0, offset_vector, sizeof(offset_vector))) >= 0 ) {
            log_debug("Match found. File %s, offset %i bytes.", dir_full_path, offset_vector[0]);
            match_start = buf + offset_vector[0];
            match_end = buf + offset_vector[1];
            buf_offset = offset_vector[1];
            print_match(dir_full_path, buf, match_start, match_end, first_match);
            first_match = 0;
        }

        free(buf);

        cleanup:
        if (fp != NULL) {
            fclose(fp);
        }
        free(dir);
        free(dir_full_path);
    }

    free(dir_list);
    return(0);
}
Esempio n. 27
0
File: fix.c Progetto: her0m31/Studys
void fix_adrb(struct tree **root)
{
  FILE *fp;
  char chose[MAXLEN];
  char items[2][MAXLEN];
  struct adrb *data[MAXLEN];
  struct tree **view;
  struct tree *temp;
  int loop_main, loop_sub, flag_x;
  int i, j, num;
  
  data[0] = NULL;
  loop_main = 0;
  while( loop_main != 1 ) {
    
    loop_sub = 0;
    while(loop_sub != 1) {
      loop_sub = 1;
      printf("修正する住所録を検索します…\n");
      printf("修正したい住所録の「氏名」を入力してください。終了するには「Ctrlキーを押しながらDを押してください」。\n");
      printf("> ");
      if( scanf("%s", items[0] ) == EOF ) {
        printf("住所録の修正を終了します…\n\n");
        return;
      }
    }
    
    i = 0;
    print_match(*root, data, items[0], 0, &i);

    if( data[0] == NULL ) {
      printf("一致する住所録はありませんでした…\n\n"); 
      continue;
    } else {
      printf("一致する住所録があります…\n");
      for(j = 0; j < i; j++)
        printf("・%2d: %s\t%s\t%s\t%s\t%s\n", j+1, data[j]->name, data[j]->posc, data[j]->adre, data[j]->tell, data[j]->mail); 
    }
    
    loop_sub = 0;
    while( loop_sub != 1 ) {
      printf("\nどの住所録を修正しますか?左の番号を入力してください。修正せずに終了するには「Ctrlキーを押しながらDを押してください」。\n"); 
      printf("> ");
      if( scanf("%s", chose) == EOF ) {
        printf("住所録の修正を終了します…\n\n");
        return;
      };
      if(strlen(chose) != 1) {
        printf("入力エラーです!\n");
        continue;
      }
      if( atoi(chose) < 1 || i < atoi(chose) ) {
        printf("入力エラーです!\n");
        continue;
      }
      printf("次の住所録が選択されました。\n");
      printf("・%2d: %s\t%s\t%s\t%s\t%s\n", atoi(chose), data[atoi(chose)-1]->name, data[atoi(chose)-1]->posc, data[atoi(chose)-1]->adre, data[atoi(chose)-1]->tell, data[atoi(chose)-1]->mail); 
      num = atoi(chose) - 1;
      loop_sub = 1;
    }
    
    loop_sub = 0;
    while( loop_sub != 1 ) {
      printf("\nどの項目を修正しますか?番号を入力してください。修正せずに終了するには5を入力してください。\n"); 
      printf("0: 氏名\n1: 郵便番号\n2: 住所\n3: 電話番号\n4: メールアドレス\n");
      printf("> ");
      if( scanf("%s", chose) == EOF ) {
        printf("入力エラーです!\n");
        continue;
      };
      if(strlen(chose) != 1) {
        printf("入力エラーです!\n");
        continue;
      }
      switch(chose[0]) {
      case '0':
        loop_sub = 1;
        break;
      case '1':
        loop_sub = 1;
        break;
      case '2':
        loop_sub = 1;
        break;
      case '3':
        loop_sub = 1;
        break;
      case '4':
        loop_sub = 1;
        break;
      case '5': 
        printf("住所録の修正を終了します…\n\n");
        return;
      default:
        printf("入力エラーです!\n");
        break;
      }  
    }
    
    loop_sub = 0;
    while(loop_sub != 1) {
      loop_sub = 1;
      printf("修正してください。\n");
      printf("> ");
      if( scanf("%s", items[1]) == EOF ) {
        printf("入力エラーです!\n\n");
        loop_sub = 0;
        continue;
      }
    }
    
    fix_item( data[num], items[1], atoi(chose) );
    printf("修正完了\n");
    print_adrb(*root);
    printf("\n");
  
    fp = fopen( "adrb.dat", "w");
    if( fp == NULL ) {
      return;
    }
    save_file( fp, root );
    fclose(fp); 
  
    loop_sub = 0;
    while( loop_sub != 1 ) {
      printf("住所録の修正を続けますか?番号を入力してください!\n");
      printf("0: Yes\n1: No\n");
      printf("> ");
      if( scanf("%s", chose) == EOF ) {
        printf("入力エラーです!\n");
        continue;
      };
      if( strlen(chose) != 1) {
        printf("入力エラーです。\n");
        continue;
      }
      switch(chose[0]) {
      case '0':
        loop_sub = 1;
        break;
      case '1':
        loop_sub = loop_main = 1;
        break;
      default:
        printf("入力エラーです!\n");
        break;
      }
    }
    
  }
  printf("住所録の修正を終了します…\n\n");
}