char *test_read_input() { FILE *f; /* open, read and parse some invalid xml */ f = fopen("test.invalid.xml", "r"); mu_assert("read invalid xml", read_input(f) == 0); fclose(f); mu_assert("parse invalid xml", xml_parse(buf) == XML_STATUS_INVALID); /* open, read and parse some valid xml */ f = fopen("test.xml", "r"); mu_assert("read valid xml", read_input(f) == 0); fclose(f); mu_assert("buffer contains request", strncmp(buf,"<request>", 9) == 0); mu_assert("parse some valid xml", xml_parse(buf) == XML_STATUS_OK); /* fetch value of an element */ char *value = xml_element("//username"); mu_assert("perform xpath search for element", value != NULL); mu_assert("get value of xml element", strcmp(value, "iamauser") == 0); xml_free(value); xml_cleanup(); return 0; }
int main(int argc, char **path, char ** envp) { struct stat st = { 0 }; char *home = getenv("HOME"); char *conf_path = (char *) malloc(sizeof(char) * (strlen(home))); strcpy(conf_path, home); strcat(conf_path, "/.shell"); if (stat(conf_path, &st) == -1) { mkdir(conf_path, 0700); } history_path = (char *) malloc(sizeof(char) * (strlen(conf_path) + 7)); log_path = (char *) malloc(sizeof(char) * (strlen(conf_path) + 4)); strcpy(history_path, conf_path); strcat(history_path, "/history"); strcpy(log_path, conf_path); strcat(log_path, "/log"); signal(SIGCHLD, handle_signal); fill_env_var(envp); fill_bin_paths(); if (argc == 1) { read_input(INTERACTIVE, ""); } else if (argc == 2) { read_input(BATCH, path[1]); } else { fprintf(stderr, "too much arguments\n"); } free_args(); free(line); printf("\n"); return 0; }
static void event_play_profile(char* infile) { FILE* in, * datain; char filename[4096], buffer[4096]; unsigned limit, data_read, amt; limit = 16*1024*1024; if (getenv("CHISTKA_PREREAD")) limit = atoi(getenv("CHISTKA_PREREAD"))*1024*1024; data_read = 0; if (in = fopen(infile, "r")) { while (data_read < limit && fgets(filename, sizeof(filename), in)) { read_input(); if (!filename[0]) continue; /* Remove trailing newline */ filename[strlen(filename)-1] = 0; dbgprintf(stderr, "daemon: replaying profile event: %s\n", filename); if (datain = fopen(filename, "r")) { do { read_input(); amt = fread(buffer, 1, sizeof(buffer), datain); data_read += amt; } while (amt == sizeof(buffer) && data_read < limit); fclose(datain); } } fclose(in); } /* Done reading those files, now open the profile output. */ profile_output = fopen(infile, "w"); }
/** * Tworzy żądanie, prosząc o odpowienie wpisy użytkownika. * Zwraca -1 jeśli nastąpił błąd lub 0 - jeśli proces przebiegł pomyślnie. */ int make_request(int *auth){ if(!*auth){ // autoryzuje do skutku char name[60], password[30]; printf("Imię: "); read_input(61,name); strcpy(tmp.message, name); strcat(tmp.message,"_"); printf("Nazwisko: "); read_input(60,name); strcat(tmp.message,name); printf("Hasło(jeśli puste wpisz \"\")[max. 30 zn]: "); read_input(30, password); if(strcmp(password,"\"\"") == 0) strcpy(password,""); strcat(tmp.message, ";"); strcat(tmp.message, password); printf("%s\n",tmp.message); tmp.command_type = 1; return 0; } printf("Command: "); int cmd = -1; char tab[40]; read_input(40,tab); cmd = parse_comand(tab); request_details(&cmd,auth); // tworzymy żądanie if(cmd < 0 || cmd > 14){ return -1; } tmp.command_type = cmd; return 0; }
int login_auth() { char user_name[16]={0}; char password[16]={0}; int ret; printf_to_fd(fd_pty_slave, "login:"******"password:"******"admin")==0 && strcmp(user_name, "admin")==0) { printf_to_fd(fd_pty_slave, "login success\n"); return 0; } printf_to_fd(fd_pty_slave, "username or password wrong\n"); return 1; }
int main(int argc, char* argv[]){ printf("Welcome to Title Case! Please enter your exceptions within square brackets, each word in single quotes, then enter your desired sentence, again in square brackets and single quotes\n"); struct value* exceptions = read_input(stdin); struct value* sentence = read_input(stdin); title_case(sentence, exceptions); return 0; }
bool DataFlashFileReader::update(char type[5]) { uint8_t hdr[3]; if (read_input(hdr, 3) != 3) { return false; } if (hdr[0] != HEAD_BYTE1 || hdr[1] != HEAD_BYTE2) { printf("bad log header\n"); return false; } if (hdr[2] == LOG_FORMAT_MSG) { struct log_Format f; memcpy(&f, hdr, 3); if (read_input(&f.type, sizeof(f)-3) != sizeof(f)-3) { return false; } memcpy(&formats[f.type], &f, sizeof(formats[f.type])); strncpy(type, "FMT", 3); type[3] = 0; message_count++; return handle_log_format_msg(f); } if (!done_format_msgs) { done_format_msgs = true; end_format_msgs(); } const struct log_Format &f = formats[hdr[2]]; if (f.length == 0) { // can't just throw these away as the format specifies the // number of bytes in the message ::printf("No format defined for type (%d)\n", hdr[2]); exit(1); } uint8_t msg[f.length]; memcpy(msg, hdr, 3); if (read_input(&msg[3], f.length-3) != f.length-3) { return false; } strncpy(type, f.name, 4); type[4] = 0; message_count++; return handle_msg(f,msg); }
static u8 handle_lasikbd_event(unsigned long hpa) { u8 status_keyb,status_mouse,scancode,id; extern void handle_at_scancode(int); /* in drivers/char/keyb_at.c */ /* Mask to get the base address of the PS/2 controller */ id = gsc_readb(hpa+LASI_ID) & 0x0f; if (id==1) hpa -= LASI_PSAUX_OFFSET; status_keyb = read_status(hpa); status_mouse = read_status(hpa+LASI_PSAUX_OFFSET); while ((status_keyb|status_mouse) & LASI_STAT_RBNE){ while (status_keyb & LASI_STAT_RBNE) { scancode = read_input(hpa); /* XXX don't know if this is a valid fix, but filtering * 0xfa avoids 'unknown scancode' errors on, eg, capslock * on some keyboards. */ if (scancode == AUX_REPLY_ACK) cmd_status=0; else if (scancode == AUX_RESEND) cmd_status=1; else handle_at_scancode(scancode); status_keyb =read_status(hpa); } #ifdef CONFIG_PSMOUSE while (status_mouse & LASI_STAT_RBNE) { scancode = read_input(hpa+LASI_PSAUX_OFFSET); handle_mouse_scancode(scancode); status_mouse = read_status(hpa+LASI_PSAUX_OFFSET); } status_mouse = read_status(hpa+LASI_PSAUX_OFFSET); #endif /* CONFIG_PSMOUSE */ status_keyb = read_status(hpa); } tasklet_schedule(&keyboard_tasklet); return (status_keyb|status_mouse); }
//read input int line_input(char *line_str) { if (get_buffer(line_str)) { return 1; } else if (check_input()) { read_input(); if (get_buffer(line_str)) { return 1; } else if (read_end == LINE_INPUT_MAX_CHAR) { memcpy(line_str, buffer, LINE_INPUT_MAX_CHAR - 1); line_str[LINE_INPUT_MAX_CHAR - 1] = '\0'; buffer[0] = buffer[LINE_INPUT_MAX_CHAR - 1]; read_end = 1; return 1; } else { return 0; } } else { return 0; } }
int main(void) { time_t t; int val, ans[7], sumof, ret; srand((int) time(&t)); while (1) { for (val=0; val<6; val++) { ans[val] = (rand() % 6 + 1); write(ans[val]); } count_pairs(ans); sumof = count(ans); printf("Sum of all dices: %i\n", sumof); ret = read_input(); if (ret == 1) { continue; } else { break; } } return 0; }
// INTERACT WITH USER AND SERVER IN ORDER TO CHOOSE ACTION void interact(int socket) { printf("---MENU---\n1: SHELL\n2: SCREENSHOT\n3: UPDATE\n---FIN---\n"); char *input; int choix = 0; int i; // GET INPUT FROM USER AND TRANSFORM IT TO AN INT while(choix == 0) { input = read_input(); for(i = 0; i < 4; i++) if(strchr(input, i + '0') != NULL) choix = i; } // TELL TO SERVER OUR CHOICE write(socket, input, BUF_SIZE); free(input); switch(choix) { case 1 : handle_shell(socket); break; case 2: get_screenshot(socket); break; case 3: send_update(socket); break; } // WE'RE DONE, BYE close(socket); }
void part2(){ int r[4] = {0, 0, 1, 0}; Vector v = read_input(); run(v, r); printf("%d\n", r['a' - 'a']); Vector_free(v); }
int main(int argc, char *argv[]) { const char *outfilename = "tinyL.out"; char *input; FILE *infile; printf("------------------------------------------------\n"); printf("CS314 compiler for tinyL\n Spring 2014\n"); printf("------------------------------------------------\n"); if (argc != 2) { ERROR("Use of command:\n compile <tinyL file>\n"); exit(EXIT_FAILURE); } infile = fopen(argv[1], "r"); if (!infile) { ERROR("Cannot open input file \"%s\"\n", argv[1]); exit(EXIT_FAILURE); } outfile = fopen(outfilename, "w"); if (!outfile) { ERROR("Cannot open output file \"%s\"\n", outfilename); exit(EXIT_FAILURE); } input = read_input(infile); buffer = input; program(); printf("\nCode written to file \"%s\".\n\n", outfilename); free(input); fclose(infile); fclose(outfile); return EXIT_SUCCESS; }
void read_username_password (char *pword, int flag) { int i = 0; int ch; while ((ch = read_input()) != '\n') { if (IS_BACK_SPACE(ch)) { if(pword[0] == '\0') continue; if (i > 0) { i--; pword[i] = '\0'; if (flag) write_string ("\b \b"); } } else { pword[i++] = (char)ch; if (flag) write_input_on_screen (ch); } } pword[i] = '\0'; return; }
int main(int argc, char * argv[]) { char current_path[] = "0:/"; printf(SHELL_BANNER",%s,v%d。\n", __DATE__, SHELL_VERSION); printf("输入help获取帮助.\n"); /* Loop to get char */ while(1) { int ch; /* 获取当前路径 */ /* 打印提示符 */ printf("[%s]#", current_path); ch = read_input(line_buffer, MAX_LINE_SIZE); printf("\n"); /* 回车键则执行命令 */ if (ch == SHELL_KEY_ENTER) { execute_cmd(line_buffer); } } return 0; }
static void irc_input_cb_ssl(gpointer data, PurpleSslConnection *gsc, PurpleInputCondition cond) { PurpleConnection *gc = data; struct irc_conn *irc = gc->proto_data; int len; if(!g_list_find(purple_connections_get_all(), gc)) { purple_ssl_close(gsc); return; } if (irc->inbuflen < irc->inbufused + IRC_INITIAL_BUFSIZE) { irc->inbuflen += IRC_INITIAL_BUFSIZE; irc->inbuf = g_realloc(irc->inbuf, irc->inbuflen); } len = purple_ssl_read(gsc, irc->inbuf + irc->inbufused, IRC_INITIAL_BUFSIZE - 1); if (len < 0 && errno == EAGAIN) { /* Try again later */ return; } else if (len < 0) { purple_connection_error(gc, _("Read error")); return; } else if (len == 0) { purple_connection_error(gc, _("Server has disconnected")); return; } read_input(irc, len); }
static int decipher(struct sc_pkcs15_object *obj) { u8 buf[1024], out[1024]; int r, c, len; if (opt_input == NULL) { fprintf(stderr, "No input file specified.\n"); return 2; } c = read_input(buf, sizeof(buf)); if (c < 0) return 2; len = sizeof(out); if (!((struct sc_pkcs15_prkey_info *) obj->data)->native) { fprintf(stderr, "Deprecated non-native key detected! Upgrade your smart cards.\n"); return SC_ERROR_NOT_SUPPORTED; } r = sc_pkcs15_decipher(p15card, obj, opt_crypt_flags & SC_ALGORITHM_RSA_PAD_PKCS1, buf, c, out, len); if (r < 0) { fprintf(stderr, "Decrypt failed: %s\n", sc_strerror(r)); return 1; } r = write_output(out, r); return 0; }
static void run(tool_options_t &opts) { netlist_tool_t nt; osd_ticks_t t = osd_ticks(); nt.m_opts = &opts; nt.init(); nt.read_netlist(filetobuf(opts.opt_file()), opts.opt_name()); plist_t<input_t> *inps = read_input(&nt, opts.opt_inp()); double ttr = opts.opt_ttr(); printf("startup time ==> %5.3f\n", (double) (osd_ticks() - t) / (double) osd_ticks_per_second() ); printf("runnning ...\n"); t = osd_ticks(); unsigned pos = 0; netlist::netlist_time nlt = netlist::netlist_time::zero; while (pos < inps->size() && (*inps)[pos].m_time < netlist::netlist_time::from_double(ttr)) { nt.process_queue((*inps)[pos].m_time - nlt); (*inps)[pos].setparam(); nlt = (*inps)[pos].m_time; pos++; } nt.process_queue(netlist::netlist_time::from_double(ttr) - nlt); nt.stop(); pfree(inps); double emutime = (double) (osd_ticks() - t) / (double) osd_ticks_per_second(); printf("%f seconds emulation took %f real time ==> %5.2f%%\n", ttr, emutime, ttr/emutime*100.0); }
int main(int argc, char *argv[]) { FILE *input = NULL; FILE *output = NULL; Edges edges = {0, NULL} ; double *shapley = NULL; long kernel_time = 0; long summary_time = 0; int n; Adjacency *adjacency; input = safeFopen(argv[1], "r"); output = safeFopen(argv[2], "w"); read_input(input, &edges); n = number_of_vertices(&edges); shapley = (double *) safeMalloc(n * sizeof(double)); adjacency = createAdjacency(n, &edges, n); compute_shapley(adjacency, n, shapley, function, &kernel_time, &summary_time); write_output(n, shapley, output); print_time("kernel", kernel_time); print_time("summary", summary_time); releaseAdjacency(adjacency); free(shapley); free(edges.list); fclose(input); fclose(output); return 0; }
int main(int argc, char ** argv) { //create_dummy_vol_file(); exit(0); holger_time_start(0, "Main"); holger_time(0, "OpenCL initialization"); read_input( "C:\\Master Holger\\Franks thumb drive\\UL\\Nevro_Spine\\SpineData\\ultrasoundSample5.mhd", "C:\\Master Holger\\Franks thumb drive\\UL\\Nevro_Spine\\SpineData\\ultrasoundSample5.pos", "C:\\Master Holger\\Franks thumb drive\\UL\\Nevro_Spine\\SpineData\\ultrasoundSample5.tim", "C:\\Master Holger\\Franks thumb drive\\UL\\Nevro_Spine\\SpineData\\ultrasoundSample5.msk", //"C:\\Master Holger\\Simple test input\\Lines\\lines.vol", "C:\\Master Holger\\Franks thumb drive\\UL\\Nevro_Spine\\SpineData\\ultrasoundSample5.vol", "C:\\Master Holger\\Franks thumb drive\\UL\\Nevro_Spine\\calibration_files\\M12L.cal" ); holger_time(0, "Read input files"); #pragma omp parallel num_threads(2) { int thread_idx = omp_get_thread_num(); if (thread_idx == 0) { printf("Reconstruct thread\n"); reconstruct(); } else if (thread_idx == 1) { printf("GUI thread\n"); gui(argc, argv); } } gui(argc, argv); holger_time(0, "Reconstruction"); holger_time_print(0); exit(0); }
int main(int argc, char *argv[]) { PetscErrorCode ierr; params params; Mat H; SlepcInitialize(&argc,&argv,(char*)0,help); ierr = PetscPrintf(PETSC_COMM_WORLD,"--------------------------------------------------------------------------------------\n");CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD," _______ __ __ _______ _______ ______ _______ \n");CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD," |__ __| \\/ |/ ____\\ \\ / /_ _| ____|__ __| \n");CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD," | | | \\ / | (___ \\ \\ /\\ / / | | | |__ | | \n");CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD," | | | |\\/| |\\___ \\ \\ \\/ \\/ / | | | __| | | \n");CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD," | | | | | |____) | \\ /\\ / _| |_| | | | \n");CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD," |_| |_| |_|_____/ \\/ \\/ |_____|_| |_| \n");CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD," True Muonium Solver with Iterative Front-Form Techniques \n");CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD," \n");CHKERRQ(ierr); ierr = PetscPrintf(PETSC_COMM_WORLD,"--------------------------------------------------------------------------------------\n");CHKERRQ(ierr); read_input(ierr,argv,¶ms); print_input(ierr,¶ms); if(check_file(params.hfile)) { PetscViewer viewer_H; PetscViewerBinaryOpen(PETSC_COMM_WORLD,params.hfile.c_str(),FILE_MODE_READ,&viewer_H); MatCreate(PETSC_COMM_WORLD,&H); MatSetFromOptions(H); MatLoad(H,viewer_H); PetscViewerDestroy(&viewer_H); }else { discretize(ierr,¶ms); // ierr = VecView(params.mu,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); // ierr = VecView(params.theta,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); write_output(ierr,¶ms); coulomb_trick(ierr,¶ms); // ierr = VecView(params.CT,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); ct_discrete(ierr,¶ms); // ierr = VecView(params.CT,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); hamiltonian(ierr,¶ms,H); // ierr = PetscViewerSetFormat(PETSC_VIEWER_STDOUT_WORLD,PETSC_VIEWER_ASCII_DENSE);//DENSE<-->COMMON // MatView(H,PETSC_VIEWER_STDOUT_WORLD); } cleanup(ierr,¶ms); eigensolver(ierr,¶ms,H,argc,argv); ierr = MatDestroy(&H);CHKERRQ(ierr); ierr = SlepcFinalize(); return 0; }
int main(int argc, char *argv[]) { const char *outfilename = "tinyL.out"; char *input; FILE *infile; printf("------------------------------------------------\n"); printf(" Compiler for tinyL\n Fall 2015\n"); printf("------------------------------------------------\n"); if (argc != 2) { ERROR("Use of command:\n compile <tinyL file>\n"); exit(EXIT_FAILURE); } infile = fopen(argv[1], "r"); if (!infile) { ERROR("Cannot open input file \"%s\"\n", argv[1]); exit(EXIT_FAILURE); } outfile = fopen(outfilename, "w"); if (!outfile) { ERROR("Cannot open output file \"%s\"\n", outfilename); exit(EXIT_FAILURE); } input = read_input(infile); buffer = input; CodeGen(LOADI, 1024, 0, EMPTY_FIELD); /* set base register to 1024 */ program(); printf("\nCode written to file \"%s\".\n\n", outfilename); free(input); fclose(infile); fclose(outfile); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { // Get the amount of change from user float amount; int cents_amount; int coins_total = 0; amount = read_input("O hai! How much change is owed?"); // Convert the amount of money to integer value of total cents cents_amount = round(amount * 100); // Now check how much quarters, dimes and nickels are needed coins_total = coins_total + get_quotient(¢s_amount, 25); coins_total = coins_total + get_quotient(¢s_amount, 10); coins_total = coins_total + get_quotient(¢s_amount, 5); coins_total = coins_total + cents_amount; // Only pennies are left // Now print the result printf("%d\n", coins_total); return 0; }
//begin public methods unsigned int Random::calibrate(){ unsigned int* bins = (unsigned int*)malloc(BINS_SIZE * sizeof(unsigned int)); //set all value counts to zero for(int i = 0; i < BINS_SIZE; i++) { bins[i] = 0; } //loop until i equals the calibration sample size for(unsigned int i = 0; i < CALIBRATION_SIZE; i++) { //get a sample byte adc_byte = read_input(); //add one count to the bin of the sample value bins[adc_byte]++; } //find the threshold _threshold = find_threshold(bins); free(bins); return _threshold; }
void run(t_params const* params) { int fd; pid_t master; pid_t ptyfk; struct termios term; fd = open(params->file, O_WRONLY | O_CREAT | (params->append == 1 ? O_APPEND : O_TRUNC), 0644); if (fd == -1) xperror(); ptyfk = my_forkpty(&master, NULL); if (ptyfk == -1) xperror(); if (ptyfk == 0) { dup2_fd(master); execl(params->shell, params->shell, NULL); exit(0); } update_win_size(master); signal(SIGWINCH, handle_resize); remove_block(master, 0); init_term(&term); printf("Script started, file is %s\n", params->file); read_input(ptyfk, master, fd); restore_term(&term); close(fd); printf("Script done, file is %s\n", params->file); }
int main(void) { // Read input file and get number of particles read_input(); read_nparts(); // Read list of files in ./output/part-*.*.cgns read_time(); // strrep part- and .cgns, save remainder to tName array // pare down tName array to ts < tName < te // pare down tName array to multiples of dt, or thereabouts // read first file, find nparts // construct part_struct[nparts].vec[length(tName)] // read part-*.** to part_struct array // loop over all r0 TODO: list r0, tol in input file // loop over all particles and find tetrad apirs // create *T struct with first tetrad pair // double n[0], n[1], n[2], n[3] // *prev = NULL // *next = // create a *T, loop over *prev, check if unique or not // if unique, change *T.next = *currT // *T = *currT // fill out V, R^2, etc. to *T // continue loops return EXIT_SUCCESS; }
parsed_line* input_process(input_state* input) { parsed_line* line; /* set term into unbuffered mode */ reset_term(input, false); /* terminal i/o */ if (!read_input(input, input->history_current->buffer)) { return NULL; } /* back to buffered */ reset_term(input, true); putc('\n', stdout); if (strlen(input->history_current->buffer) == 0) { print_prompt(); return NULL; } /* parse line */ line = parse_input(input->history_current); history_add(input); input->cursor = 0; return line; }
int main() { char* token; int num_paths = 0; int first = 1; char* input; input = read_input(); int paths_size = getPathsCount(input); paths = malloc(sizeof(char *) * paths_size); weights = malloc(sizeof(char *) * paths_size); token = strtok(input, TOK_DELIM); while (token != NULL) { if(first) { // getting first token from line, always weight weights[num_paths] = token; first = 0; } else { paths[num_paths] = token; first = 1; num_paths++; } token = strtok(NULL, TOK_DELIM); } orderPaths(num_paths); int i; for (i = 0; paths[i] != NULL; i++) { printf("%s, %s\n", weights[pathsOrdered[i]], paths[pathsOrdered[i]]); } }
__u16 capture_key( struct INPUT* input, int *x, int *y, int num_key, __u16 *keys ) { struct input_event *event; int got_x = 0; int got_y = 0; int got_key = 0; __u16 key; int key_index; do { event = read_input( input ); // DEBUG printf( // DEBUG "Event: time %ld.%06ld, type %d, code %d, value %d\n", // DEBUG event->time.tv_sec, // DEBUG event->time.tv_usec, // DEBUG event->type, // DEBUG event->code, // DEBUG event->value // DEBUG ); if( event->type == EV_ABS ) { // remember position switch( event->code ) { case ABS_X: case ABS_Z: /* Some tablets send ABS_Z instead of ABS_X */ got_x = 1; *x = event->value; break; case ABS_Y: case ABS_RX: /* Some tablets send ABS_RX instead of ABS_Y */ got_y = 1; *y = event->value; break; } } if( event->type == EV_KEY && ( !event->value ) && got_x && got_y ) { // some key released at some position key = event->code; for( key_index = 0; key_index < num_key; key_index++ ) { if( key == keys[key_index] ) { got_key = 1; break; } } } } while( !got_key ); return key; /* key code */ }
int main(int argc, char *argv[]) { if (argc != 4) invocation_error(argv[0], "[input file 1] [input file 2] [output file]"); char *output_filename = argv[3]; struct stat file1_stat, file2_stat; FileInfo larger, smaller; off_t record_size = (off_t)get_part_record_size(); validate_input_file(argv[1], &file1_stat, record_size); validate_input_file(argv[2], &file2_stat, record_size); sort_input_files(argv[1], &file1_stat, argv[2], &file2_stat, &larger, &smaller, record_size); Part out_buffer = (Part)malloc(larger.size + smaller.size); if (!out_buffer) memory_error(__FILE__, __LINE__, __func__); if (read_input(&larger, out_buffer, record_size) != 0) { free(out_buffer); exit(EXIT_FAILURE); } Part in_buffer = malloc(smaller.size); if (!in_buffer) { free(out_buffer); memory_error(__FILE__, __LINE__, __func__); } if (read_input(&smaller, in_buffer, record_size) != 0) { free(in_buffer); free(out_buffer); exit(EXIT_FAILURE); } size_t out_count = merge_buffers(in_buffer, smaller.count, out_buffer, larger.count); free(in_buffer); if (write_output(output_filename, out_buffer, out_count, record_size) != 0) { free(out_buffer); exit(EXIT_FAILURE); } free(out_buffer); return 0; }