static int do_connected(void) { while (!exitasap) { if (read_lines()) break; } /* Keep capturing lines as long as there are lines ready to read. */ while (!exitasap) { if (seq_next - seq_send >= startlines) return STATE_SENDING; switch (iopoll(io, 1, readwait)) { case -1: return STATE_EXITING; case 1: if (stdin_error) return exitoneof ? STATE_EXITING : STATE_SENDING; if (read_lines() > 0 || stdin_eof) return STATE_SENDING; continue; case 0: return STATE_SENDING; } } return STATE_EXITING; }
// printer processes the arguments and calls read_lines // with the appropriate arguments. This line is mostly // copied from Prof. Mackey's 'catbyline.c'. void printer(int argc, char **argv, int *flags) { // position of the first null in the arguments int null_pos = find_null (argv); // string to search files for char *search = argv[null_pos-argc]; // sends to read_lines with standard input if no files provided if (argc==1) { read_lines (stdin, STDIN_NAME, search, argc-1,flags); } else { // loop over filenames for (int argi=null_pos-argc+1; argi<null_pos; ++argi) { char *filename = argv[argi]; if (strcmp (filename, STDIN_NAME) == 0) { read_lines (stdin, STDIN_NAME, search, argc-1,flags); }else { // loop for valid filenames FILE *input = fopen (filename, "r"); if (input != NULL) { read_lines (input, filename, search, argc-1,flags); fclose (input); }else { exit_status = EXIT_FAILURE; fflush (NULL); fprintf (stderr, "%s: %s: %s\n", argv[0], filename, strerror (errno)); fflush (NULL); } } } } }
int main(int argc, char **argv) { ptable_s table; supermach_s *machine; printf("reading: %s\n",argv[1]); machine = build_smachine (_COMPINITID_, MACH_ARGS); if (argc < 2) read_lines(machine, "samples/workingtest"); else read_lines(machine, argv[1]); populate_reserved (machine, "keywords"); run_machine (machine); //cleanup(machine) table = build_ptable("samples/commandlinegrammar", machine); synan (machine, table); fprintlistingfile(machine); fprinttokenfile(machine); printlistingfile(machine); fprint_ptable (&table); //printtokenfile(machine); cleanup(machine); return 0; }
/* * Test the result for the bic calculator. */ int main(int argc, char** argv) { char** samples = read_lines(argv[1]); int depth = strtod(argv[2], NULL); setup_BIC(samples, depth, prob_root, bic_root); print_tree(prob_root, depth); printf("----------------\n"); // print_tree(bic_root, ""); printf("\nlogN=%f\n\n",logN); // int n = size_of_sample(); get_T(prob_root); print_tree(prob_root, depth); Vec c = get_Tvec(prob_root); print_Vec(c); sort_Vec(c); uniquefy_Vec(c); print_Vec(c); for(int i = 0; i < c->len; i++) c->x[i] /= logN; print_Vec(c); Champion_item champs = champion_set_from_vec(c); ITERA(Champion_item, cs, champs, next) { pprint_Tau(cs->tau); printf("\n"); }
static int do_connecting(void) { struct key csession_secret; struct key csession_public; struct key tmpkey; unsigned backoff = 1; saw_seq_gap = 0; buffer->rewind(); key_generate(&csession_secret, &csession_public, keyex); make_ini(&csession_public, buffer->peek()); keylist_exchange_list_key(&tmpkey, &server_publics, &csession_secret); auth_start(&cid_authenticator, &tmpkey); while (!exitasap) { send_packet("INI1", cid_timeout * backoff); while (!exitasap) { if (poll_both() == 0) return STATE_DISCONNECTED; if (stdin_ready) read_lines(); if (sock_ready) { if (receive_cid(&csession_secret)) return STATE_SENDING; backoff = 0; } } if (backoff < retransmits) ++backoff; } return STATE_EXITING; }
// create a mesh storing a pointer in a map so it can be retrieved later by geometry UID bool MeshImporter::write_geometry(const COLLADAFW::Geometry *geom) { if (geom->getType() != COLLADAFW::Geometry::GEO_TYPE_MESH) { // TODO: report warning fprintf(stderr, "Mesh type %s is not supported\n", bc_geomTypeToStr(geom->getType())); return true; } COLLADAFW::Mesh *mesh = (COLLADAFW::Mesh *)geom; if (!is_nice_mesh(mesh)) { fprintf(stderr, "Ignoring mesh %s\n", bc_get_dae_name(mesh).c_str()); return true; } const std::string& str_geom_id = mesh->getName().size() ? mesh->getName() : mesh->getOriginalId(); Mesh *me = BKE_mesh_add(G.main, (char *)str_geom_id.c_str()); me->id.us--; // is already 1 here, but will be set later in BKE_mesh_assign_object // store the Mesh pointer to link it later with an Object // mesh_geom_map needed to map mesh to its geometry name (for shape key naming) this->uid_mesh_map[mesh->getUniqueId()] = me; this->mesh_geom_map[std::string(me->id.name)] = str_geom_id; read_vertices(mesh, me); read_polys(mesh, me); BKE_mesh_calc_edges(me, false, false); // read_lines() must be called after the face edges have been generated. // Oterwise the loose edges will be silently deleted again. read_lines(mesh, me); return true; }
static void fortran_prescanner_process(prescanner_t* prescanner) { file_lines = NULL; last_line = file_lines; // Load all the file into memory read_lines(prescanner); // Cut lines to be of width 'prescanner.width' cut_lines(prescanner); // We used to remove comments here but it is better to convert them convert_whole_line_comments(); // Join continuated lines join_continuated_lines(prescanner); #if 0 // Lines that were not appended any continuation line have not been trimmed // their inline comments remove_inlined_comments(); #endif convert_lines(prescanner); if (!prescanner->append) { continuate_lines(prescanner); } print_lines(prescanner); close_files(prescanner); }
int main(void) { n_array t; int i, j, m; char *a, *vars; c_link op_stack; i_link num_stack; printf("Enter those lines:\n"); t = read_lines(); cSTACKinit(); iSTACKinit(); for (i = 0; i < t.n; i++) { a = t.arr[i]; m = strlen(a); for (j = 0; j < m; j++) { } } /* printf("Enter the seize of stack: "); */ /* scanf("%d", &n); */ /* STACKinit(n); */ /* STACKpush(1); */ /* STACKpush(2); */ /* printf("%d, %d\n", STACKpop(), STACKpop()); */ /* printf("Stack empty? %d\n", STACKempty()); */ return 0; }
/* Move the buffer up and down in the file in order to scroll */ static void buffer_down(int nlines) { cur_fline += nlines; read_lines(); cap_cur_fline(nlines); buffer_fill_and_print(); }
static void buffer_up(int nlines) { cur_fline -= nlines; if (cur_fline < 0) cur_fline = 0; read_lines(); buffer_fill_and_print(); }
int main(int argc, char* argv[]) { // read first argument; must be a file path std::string filename = argv[1]; // parse lines from filename into a dictionary mapping from int->word std::map<int, icu::UnicodeString> dict = read_lines(filename); UErrorCode success = U_ZERO_ERROR; icu::NumberFormat *nf = icu::NumberFormat::createInstance(success); // seems to run faster when not absolutely enforcing min/max fractional digits //nf->setMinimumFractionDigits(0); //nf->setMaximumFractionDigits(0); nf->setGroupingUsed(false); // display entire map using iterators for (std::map<int, icu::UnicodeString>::iterator it = dict.begin(); it != dict.end(); ++it) { //std::cout << it->first << ": " << it->second << std::endl; icu::UnicodeString temp_ustring; std::cout << nf->format(it->first, temp_ustring) << ": " << it->second << std::endl; } return 0; }
int read_file(std::vector<Alarm> &alarms) { std::vector<std::string> lines; if (read_lines(lines) != 0) { return -1; } for (const std::string &str : lines) { Alarm alarm; if (alarm.read_file_str(str.c_str()) != 0) { return -1; } try { alarms.push_back(alarm); } catch (...) { fputs("Error: unable to allocate memory\n", stderr); return -1; } } return 0; }
/* Gera o arquivo de saida */ void gera_csv_reduzido(char fnamein[], char fnameout[]) { FILE *in, *out; int n, *campos; int columns, lines; int i, j; char **values; /* Abrindo os arquivos de entrada e saida */ in = fopen(fnamein, "r"); out = fopen(fnameout, "w"); /* Se nao conseguir abrir, retorna */ if ((in == NULL) || (out == NULL)) { return; } /* Quantidade de colunas */ columns = columns_file(in); /* Quantidade de linhas */ lines = lines_file(in); /* Alocacao da matriz que armazenara os campos em cada linha */ values = alloc_matrix(columns, MAX_CAMP); /* Quantidade de colunas que serao impressas no arquivo de saida */ scanf("%d", &n); /* Alocacao do vetor que armazenara quais colunas serao impressas */ campos = malloc(n * sizeof(int)); /* Leitura dos numeros das colunas a serem impressas */ for (i = 0; i < n; i++) scanf("%d", &campos[i]); /* Leitura das linhas do arquivo de entrada */ for (i = 0; i < lines; i++) { read_lines(in, columns, values); /* Impressao dessas linhas no arquivo de saida */ for (j = 0; j < n; j++) { fprintf(out, "%s", values[campos[j]-1]); if (j != n-1) fprintf(out, ","); } fprintf(out, "\n"); } /* Fechando os arquivos abertos pelo programa */ if (in) fclose(in); if (out) fclose(out); /* Liberando a memoria alocada pela matriz */ free_matrix(values, columns); }
static int read_file(char *filename, int quiet) { verify(filename != NULL, "null arg filename"); verify(filename[0] != '\0', "empty arg filename"); if (verbose > 0) { fprintf(stderr, "%s: read_file(%s)\n", prog, filename); } static struct list_names filenames; // file names come from -f and include static int init = 0; if (init == 0) { list_names_init(&filenames, "filenames"); init++; } if (verbose > 1) { list_names_print(&filenames); } // if (filename is on the list already) { return 1 } // else { put filename on the list and continue } if (list_names_append_if_new(&filenames, filename) == 1) { return 1; } if (verbose > 0) { list_names_print(&filenames); } if (strcmp(filename, "-") == 0) { read_lines("[stdin]", stdin); return 1; } FILE *fp = fopen(filename, "r"); if (fp == NULL) { if (quiet == 0) fprintf(stderr, "%s: could not open input file %s: %s\n", prog, filename, strerror(errno)); return 0; } read_lines(filename, fp); if (fclose(fp) != 0) { fprintf(stderr, "%s: could not close input file %s: %s\n", prog, filename, strerror(errno)); } return 1; }
int main() { int line_count; char storage[MAXLINELENGTH * MAXLINECOUNT]; char* lines[MAXLINECOUNT]; /* a list of pointers to locations in storage[] */ line_count = read_lines(storage, lines); qsort(lines, 0, line_count); write_lines(lines, line_count); return 0; }
int main(int argc, char** argv) { if(argc != 3) { std::fprintf(stderr, "usage: levelc [file]\n"); return EXIT_FAILURE; } std::vector<grid_t> levels; char* const in_filename = argv[1]; char* const out_filename = argv[2]; std::vector<std::string> lines = read_lines(in_filename); std::reverse(lines.begin(), lines.end()); int line_number = 1; while(!lines.empty() && lines.back().empty()) { lines.pop_back(); ++line_number; } while(lines.size() >= H) { grid_t new_level; for(int i = 0; i != H; ++i, ++line_number) { if(lines.back().length() < W) { std::fprintf(stderr, "parse error; line %i too short\n", line_number); return EXIT_FAILURE; } std::copy(lines.back().begin(), lines.back().end(), new_level[i].begin()); lines.pop_back(); } levels.push_back(new_level); while(!lines.empty() && lines.back().empty()) { lines.pop_back(); ++line_number; } } if(lines.size() > 1) { std::fprintf(stderr, "incomplete level at end\n"); return EXIT_FAILURE; } // Set this to true to make testing levels easier. constexpr bool reverse = 0; if(reverse) std::reverse(levels.begin(), levels.end()); write_levels(out_filename, levels, reverse); std::printf("finished!\n"); }
int main(int argc, char* argv[]) { int num_lines; char* lines[MAX_NUM_LINES]; bool sort_numerically = false; if (argc > 1) { for (int i = 1; i < argc; ++i) { if (strcmp(argv[i], SORT_NUMERICALLY) == 0) { sort_numerically = true; } else if (strcmp(argv[i], SORT_REVERSE) == 0) { sort_reverse = true; } else if (strcmp(argv[i], FOLD_CASE) == 0) { fold_case = true; } else if (strcmp(argv[i], SORT_BY_FIELD) == 0) { if (i == argc - 1) { printf("error: when sorting by field, you must specify the field to sort by\n" "example: ./exercise_5-16 -e 2\n"); } else { sort_by_field = true; field = atoi(argv[++i]); } } } } if ((num_lines = read_lines(lines)) >= 0) { quick_sort((void**) lines, 0, num_lines - 1, (int(*)(void*, void*))(sort_numerically ? numeric_cmp : lexicographic_cmp)); write_lines(lines, num_lines); return 0; } else { printf("error: input too large to sort\n"); return 1; } }
void mux(mux_ctx_t ctx) { /* init reader, we use prchunk here */ ctx->rdr = init_prchunk(ctx->infd); /* main loop */ while (fetch_lines(ctx)) { read_lines(ctx); } /* free prchunk resources */ free_prchunk(ctx->rdr); return; }
static void buffer_line(int linenum) { if (linenum < 0) linenum = 0; cur_fline = linenum; read_lines(); if (linenum + max_displayed_line > max_fline) linenum = max_fline - max_displayed_line + TILDES; if (linenum < 0) linenum = 0; cur_fline = linenum; buffer_fill_and_print(); }
double average_time(FILE *test, char *line_pointer_array[]) { double time_start, time_stop, time_total = 0.0; int element; for (element = 0; element < ITERATIONS_MAX; ++element) { time_start = (double)clock(); read_lines(line_pointer_array, test); time_stop = (double)clock(); time_total += time_stop - time_start; } return time_total; }
int load_translate_table(char ***table, char *file, int nr_trans) { SceUID fd; char linebuf[128]; char *read_alloc_buf; int i; if (table == NULL) { return -1; } *table = NULL; linebuf[sizeof(linebuf)-1] = '\0'; fd = sceIoOpen(file, PSP_O_RDONLY, 0); if(fd < 0) { return fd; } read_alloc_buf = vpl_alloc(READ_BUF_SIZE + 64); if(read_alloc_buf == NULL) { sceIoClose(fd); return -1; } read_buf = (void*)(((u32)read_alloc_buf & (~(64-1))) + 64); i = 0; while(i < nr_trans) { if (read_lines(fd, linebuf, sizeof(linebuf)-1) < 0) { break; } // printf("linebuf %s\n", linebuf); set_translate_table_item(table, linebuf, i, nr_trans); i++; } if (i < nr_trans) { sceIoClose(fd); vpl_free(read_alloc_buf); return -1; } sceIoClose(fd); vpl_free(read_alloc_buf); return 0; }
static void open_file_and_read_lines(void) { if (filename) { xmove_fd(xopen(filename, O_RDONLY), STDIN_FILENO); } else { /* "less" with no arguments in argv[] */ /* For status line only */ filename = xstrdup(bb_msg_standard_input); } readpos = 0; readeof = 0; last_line_pos = 0; terminated = 1; read_lines(); }
int pr8_read(char *file) { if (file == NULL) return 0; printf("file: %s\n", file); static struct list_names * filenames = NULL; if (filenames == NULL) filenames = list_names_allocate("filenames"); // by construction, filenames is now not NULL // if (file is on the list already) { return 1 } // else { put filename on the list and continue } if (list_names_append_if_new(filenames, file) == 1) { return 1; } if (strcmp(file, "-") == 0) { read_lines("[stdin]", stdin); return 1; } FILE *fp = fopen(file, "r"); if (fp == NULL) { // fprintf(stderr, "%s: could not open input file %s: %s\n", prog, file, strerror(errno)); return 0; } read_lines(file, fp); if (fclose(fp) != 0) { fprintf(stderr, "%s: could not close input file %s: %s\n", prog, file, strerror(errno)); } return 1; }
/* * Test the result for the bic calculator. */ int main(int argc, char** argv) { char** samples = read_lines(argv[1]); double c = strtod(argv[2], NULL); setup_BIC(samples, 5); Tau* tao = calculate_BIC(c); Tau_item* item = tao->item; while (item != NULL) { printf("%s ", item->string); item = item->next; } printf("\n"); }
int main() { int nlines; /* Number of lines */ char * plines[MAX_LINES]; /* Pointers to lines */ if ((nlines = read_lines(plines, MAX_LINES)) < 0) { fprintf(stderr, "Error: Lack of memory. Input is too large.\n"); return 1; } my_qsort(plines, 0, nlines-1); write_lines(plines, nlines); return 0; }
int main(int argc, char *argv[]) { if(argc != 3) { printf("usage: zad3.e m n\n"); return -1; } sscanf(argv[1], "%d", &m); sscanf(argv[2], "%d", &n); struct List* lines = read_lines(); lines = quicksort(lines); iterate(lines, print_str); iterate(lines, cleanup); return 0; }
static void open_file_and_read_lines(void) { if (filename) { int fd = xopen(filename, O_RDONLY); dup2(fd, 0); if (fd) close(fd); } else { /* "less" with no arguments in argv[] */ /* For status line only */ filename = xstrdup(bb_msg_standard_input); } readpos = 0; readeof = 0; linepos = 0; terminated = 1; read_lines(); }
static void goto_match(int match) { if (!pattern_valid) return; if (match < 0) match = 0; /* Try to find next match if eof isn't reached yet */ if (match >= num_matches && eof_error > 0) { wanted_match = match; /* "I want to read until I see N'th match" */ read_lines(); } if (num_matches) { normalize_match_pos(match); buffer_line(match_lines[match_pos]); } else { print_statusline("No matches found"); } }
unsigned char* read_image (const char *filename, int *width, int *height) { image_reader_t *reader = open_image_reading(filename); unsigned char *data; if (reader == 0) return 0; *width = reader->width; *height = reader->height; data = (unsigned char*)malloc(*width * *height * 3); read_lines(reader, data, *height); free_image_reader(reader); return data; }
static ssize_t getch_nowait(char* input, int sz) { ssize_t rd; struct pollfd pfd[2]; pfd[0].fd = STDIN_FILENO; pfd[0].events = POLLIN; pfd[1].fd = kbd_fd; pfd[1].events = POLLIN; again: tcsetattr(kbd_fd, TCSANOW, &term_less); /* NB: select/poll returns whenever read will not block. Therefore: * if eof is reached, select/poll will return immediately * because read will immediately return 0 bytes. * Even if select/poll says that input is available, read CAN block * (switch fd into O_NONBLOCK'ed mode to avoid it) */ rd = 1; if (max_fline <= cur_fline + max_displayed_line && eof_error > 0 /* did NOT reach eof yet */ ) { /* We are interested in stdin */ rd = 0; } /* position cursor if line input is done */ if (less_gets_pos >= 0) move_cursor(max_displayed_line + 2, less_gets_pos + 1); fflush(stdout); safe_poll(pfd + rd, 2 - rd, -1); input[0] = '\0'; rd = safe_read(kbd_fd, input, sz); /* NB: kbd_fd is in O_NONBLOCK mode */ if (rd < 0 && errno == EAGAIN) { /* No keyboard input -> we have input on stdin! */ read_lines(); buffer_fill_and_print(); goto again; } set_tty_cooked(); return rd; }