C++ count_lines函数代码示例

t_map	ft_read(char *filename)
{
	int			fd;
	char		*line;
	char		**tab;
	t_index		index;
	t_map		grid;

	index.j = 0;
	grid.nb_lines = count_lines(filename);
	grid.tab = (int **)ft_memalloc(sizeof(int *) * count_lines(filename));
	fd = open(filename, O_RDONLY);
	while (get_next_line(fd, &line) > 0)
	{
		grid.nb_col = count_col(line); //attention ne fonctionne que pour les maps rectangle (prend la valeur de la derniere line)
		grid.tab[index.j] = (int *)ft_memalloc(sizeof(int) * count_col(line));
		tab = ft_strsplit(line, ' ');
		index.i = 0;
		while (tab[index.i])
		{
			grid.tab[index.j][index.i] = ft_atoi(tab[index.i]);
			index.i++;
		}
		index.j++;
	}
	return (grid);
}

char	test(int cur_col, int cur_line, t_lines *lines, t_pos *pos)
{
  char	*cur_char;
  int	length;

  cur_char = get_pos(cur_line, cur_col, lines);
  length = my_strlen(get_line(cur_line, lines)->buffer);
  if (cur_line == 0 && cur_col == 0 && *cur_char != pos->top_left)
    return (-1);
  if (cur_line == 0 && cur_col == (length-1) && *cur_char != pos->top_right)
    return (-2);
  if (cur_line == count_lines(lines)-1 && cur_col == 0
      && *cur_char != pos->bottom_left)
    return (-3);
  if (cur_line == count_lines(lines)-1 && cur_col == (length-1)
      && *cur_char != pos->bottom_right)
    return (-3);
  if (cur_line > 0 && cur_line < count_lines(lines)-1 && cur_col == 0
      && *cur_char != pos->left)
    return (-4);
  if (cur_line > 0 && cur_line < count_lines(lines)-1
      && cur_col == (length-1) && *cur_char != pos->right)
    return (-5);
  return (1);
}

END_TEST

START_TEST (count_lines_test) {
  int l = count_lines(
        "a\n"
        "sdijb\n"
        "aosjfblk\n"
        "alks\n"
        "lkfn\n"
        "kajs\n"
        "nfk\n"
        "lf");

  ck_assert_int_eq(l, 8);

  l = count_lines(
        "a\n"
        "sdijb\n");

  ck_assert_int_eq(l, 2);

  l = count_lines("a");

  ck_assert_int_eq(l, 1);
}

/*
 * Prompts user to input paths to data files, then loads it.
 */
void prompt_for_files(){
    char fname[100];
    
    printf("Please, give a path to the file containing "
            "event name, date and start time:\n ");
    scanf("%s", &fname);
    load_event_data(&event, fname);
    
    printf("\nPlease, give a path to the file containing "
            "nodes:\n ");
    scanf("%s", &fname);
    TOTAL_NODES = count_lines(fname);
    nodes = load_nodes_from_file(fname);
    
    printf("\nPlease, give a path to the file containing "
            "tracks:\n ");
    scanf("%s", &fname);
    TOTAL_TRACKS = count_lines(fname);
    tracks = load_tracks_from_file(fname);
    
    printf("\nPlease, give a path to the file containing "
            "courses:\n ");
    scanf("%s", &fname);
    TOTAL_COURSES = count_lines(fname);
    courses = load_courses_from_file(fname);
    
    printf("\nPlease, give a path to the file containing "
            "entrants:\n ");
    scanf("%s", &fname);
    TOTAL_ENTRANTS = count_lines(fname);
    entrants = load_entrants_from_file(fname);    
}

char	parse_pos(t_pos *pos, t_lines *lines)
{
  int	cur_line;
  int	return_v;
  int	cur_col;
  int	length;

  cur_line = 0;
  while (cur_line < count_lines(lines))
    {
      cur_col = 0;
      length = my_strlen(get_line(cur_line, lines)->buffer);
      while (cur_col < length)
	{
	  if (count_lines(lines) > 2)
	    {
	      if (test(cur_col, cur_line, lines, pos) <= 0)
		return (0);
	    }
	  cur_col = cur_col + 1;
	}
      cur_line = cur_line + 1;
    }
  return (1);
}

wxString pgsRecord::value() const
{
	wxString data;
	pgsVarMap vars;

	// Go through each line and enclose it into braces
	for (USHORT i = 0; i < count_lines(); i++)
	{
		data += wxT("(");

		// Go through each column and separate them with commas
		for (USHORT j = 0; j < count_columns(); j++)
		{
			wxString elm(m_record[i][j]->eval(vars)->value());
			if (!m_record[i][j]->is_number())
			{
				elm.Replace(wxT("\\"), wxT("\\\\"));
				elm.Replace(wxT("\""), wxT("\\\""));
				elm = wxT("\"") + elm + wxT("\"");
			}
			data += elm + (j != count_columns() - 1 ? wxT(",") : wxT(""));
		}

		data += (i == count_lines() - 1) ? wxT(")") : wxT(")\n");
	}

	// Return the string representation of the record
	return data;
}

int main(int argc,char *argv[]){
    int i=0;
    srand(time(NULL));

    net mlpnet;
    int layer_neurons[]={2,10,5,1};
    char sigmods[]={'l','l','l','l'};
    init_net(&mlpnet,4,layer_neurons,sigmods);
    
    float *inputs=(float*)malloc(sizeof(float)*2);

    sample *samples;

    int num_lines=count_lines(argv[1]);

    samples=(sample*)malloc(sizeof(sample)*num_lines);

    read_samples(argv[1],samples,num_lines);

    train(&mlpnet,num_lines,samples,EPOCHS);
    
    free_samples(samples,num_lines);

    //==================================================

    num_lines=count_lines(argv[2]);
    sample *test_samples=(sample*)malloc(sizeof(sample)*num_lines);

    read_samples(argv[2],test_samples,num_lines);

    float *scores=(float*)malloc(sizeof(float)*num_lines);
    predict(&mlpnet,num_lines,test_samples,scores);

    free_samples(test_samples,num_lines);

    free_net(&mlpnet,4,layer_neurons);

    char scorefile[100];
    sprintf(scorefile,"%s.score",argv[1]);
    FILE *score=fopen(scorefile,"w");

    for(i=0;i<num_lines;i++)
    {
        fprintf(score,"%f\n",scores[i]);
    }

    fclose(score);

    return 0;
}

void do_refresh()
{
    int count = 0;
    char wrap_output[STRING_LENGTH];
    int L;
    int i;

    for (i = 0; i < HISTORY; i++) {
        wrap(wrap_output, lines[i], x);
        L = count_lines(wrap_output);
        count = count + L;

        if (count < y) {
            move(y - 1 - count, 0);
            printw(wrap_output);
            clrtoeol();
        }
    }

    move(y - 1, 0);
    clrtoeol();
    printw(">> ");
    printw(line);
    clrtoeol();
    refresh();
}

extern void parse_file(char *CONFIG_FILE_PATH, char **PARSED_LINES){
  char *line;
  FILE *CONFIG_FILE;
  ssize_t read;
  size_t len = 0;

  int lines = 0;
  int number_of_lines = 0;

  CONFIG_FILE = fopen(CONFIG_FILE_PATH, "r");

  lines = count_lines(CONFIG_FILE);

  while((read = getline(&line, &len, CONFIG_FILE)) != -1){
    
    PARSED_LINES[number_of_lines] = malloc(strlen(line)*sizeof(char));

    snprintf(PARSED_LINES[number_of_lines], strlen(line), "%s", line);

    number_of_lines++;
  }

  // cleanup
  fclose(CONFIG_FILE);
  free(line);

}

static void
marked_message_internal (char *msg, int mark_start, int mark_end)
{
  rp_screen *s = current_screen ();
  int num_lines;
  int width;
  int height;

  PRINT_DEBUG (("msg = %s\n", msg?msg:"NULL"));
  PRINT_DEBUG (("mark_start = %d, mark_end = %d\n", mark_start, mark_end));

  /* Calculate the width and height of the window. */
  num_lines = count_lines (msg, strlen(msg));
  width = defaults.bar_x_padding * 2 + max_line_length(msg);
  height = FONT_HEIGHT (s) * num_lines + defaults.bar_y_padding * 2;

  prepare_bar (s, width, height, num_lines > 1 ? 1 : 0);

  if (defaults.bar_sticky)
    /* Sticky bar is only showing the current window title, don't mark it */
    mark_start = mark_end = -1;
  else
    {
      /* Draw the mark over the designated part of the string. */
      correct_mark (strlen (msg), &mark_start, &mark_end);
      draw_mark (s, msg, mark_start, mark_end);
    }

  draw_string (s, msg, mark_start, mark_end);

  /* Keep a record of the message. */
  update_last_message (msg, mark_start, mark_end);
}

int deltafile_init_strbuf(struct deltafile *df, struct strbuf *buf, char delim)
{
    size_t lines = count_lines(buf);
    deltafile_init(df, lines + 1, delim);
    df->size = split_in_place(&df->file, df->arr, delim);
    return 0;
}

void do_refresh()
{
    int count = 0;
    char wrap_output[STRING_LENGTH_WRAPPED];
    int i;

    for (i = 0; i < HISTORY; i++) {
        if (flag[i])
            wrap_bars(wrap_output, lines[i], x);
        else
            wrap(wrap_output, lines[i], x);

        int L = count_lines(wrap_output);
        count = count + L;

        if (count < y) {
            move(y - 1 - count, 0);
            printw("%s", wrap_output);
            clrtoeol();
        }
    }

    move(y - 1, 0);
    clrtoeol();
    printw(">> ");
    printw("%s", input_line);
    clrtoeol();
    refresh();
}

void send_request (int socket_fd, char *cmd, int argc, char *argv[], char* dir, char* classpath)
{
  // Send request type byte:
  unsigned char type[1] = {CMD_REQ};
  if ( write(socket_fd, type, 1) != 1 )
    error("Failes to send request type byte to server: %s", error_msg());

  // Open stream for writing to server:
  FILE *socket_in = fdopen(socket_fd, "w");
  if ( socket_in == NULL )
    error("Failed to create i/o stream for writing to server: %s", error_msg());

  // Write request to stream:
  fprintf(socket_in, "pid\n%i\n\n", getpid());
  fprintf(socket_in, "cmd\n%s\n\n", cmd);
  fprintf(socket_in, "argc\n%i\n\n", argc);
  if ( argv != NULL )
    {
      int i;
      for (i = 0; i < argc; i++)
        fprintf(socket_in, "arg\n%i\n%s\n\n", count_lines(argv[i]), argv[i]);
    }
  fprintf(socket_in, "dir\n%s\n\n", dir);
  if ( classpath != NULL )
    fprintf(socket_in, "classpath\n%s\n\n", classpath);
  fprintf(socket_in, "start\n\n");
  fflush(socket_in);
}

void wc(FILE *ofile, FILE *infile, char *inname) {
  char *code;
  int c;
  size_t n = 0;
  code = malloc(1000);
  int char_count = 0;
  int line_count = 0;
  int word_count = 0;
  char path[1024];
  char result[1024];
  int fd = fileno(ofile);
  while ((c = fgetc(ofile)) != EOF)
  {
    code[n++] = (char) c;
  }
    
  code[n] = '\0';        
  char_count = count_characters(code);
  line_count = count_lines(code);
  word_count = count_words(code);
  sprintf(path, "/proc/self/fd/%d",fd); 
  memset(result, 0, sizeof(result));
  readlink(path, result, sizeof(result)-1);
  
 
  printf(" %d\t%d\t%d\t%s\t%s\n", line_count, word_count, char_count, result, path);
}

/* Recalculates virtual lines of a view with line wrapping. */
static void
calc_vlines_wrapped(void)
{
    const char *p;
    char *q;

    int i;
    const int nlines = count_lines(text, INT_MAX);

    data = reallocarray(NULL, nlines, sizeof(*data));

    nvlines = 0;

    p = text;
    q = text - 1;

    for(i = 0; i < nlines; ++i)
    {
        char saved_char;
        q = until_first(q + 1, '\n');
        saved_char = *q;
        *q = '\0';

        data[i][0] = nvlines++;
        data[i][1] = utf8_strsw_with_tabs(p, cfg.tab_stop);
        data[i][2] = p - text;
        nvlines += data[i][1]/viewport_width;

        *q = saved_char;
        p = q + 1;
    }
}