int getepvariablesFMU( char* const fileName, char* const myOutputVarsName, char* const myOutputVarsType, int* const myNumOutputVars, char* const myInputKeys, int* const myNumInputKeys, char* const myInputVars, int* const myNumInputVars, int* const myInputVarsType, int* const myStrLen){ FILE * fd; XML_Parser p; int i, j, count, ret; //ret = check_variable_cfg_Validate(fileName); //if(-1 == ret) //return -1; fd = fopen(fileName, "r"); if(!fd){ fprintf(stderr, "Error: Could not open file '%s' when getting EnergyPlus variables.\n", fileName); return -1; } p = XML_ParserCreate(NULL); if(!p){ fprintf(stderr, "Error: Could not allocate memory for parser in function 'getepvariables'.\n"); return -1; } outputVarsName = myOutputVarsName; outputVarsType = myOutputVarsType; numOutputVars = myNumOutputVars; inputVars = myInputVars; inputVarsType = myInputVarsType; numInputVars = myNumInputVars; numInputKeys = *myNumInputKeys; strLen = myStrLen; i=0; j=0; count=0; inputKeys = NULL; while(1){ if(myInputKeys[count] == '\0') { if(inputKeys[i][j] != '\0') inputKeys[i][j] = '\0'; break; } if(myInputKeys[count] == ','){ inputKeys[i][j]='\0'; i++; j=0; count++; } else { if(j == 0) { inputKeys = (char**) realloc(inputKeys, sizeof(char*) * (i+1) ); if(inputKeys == NULL) { fprintf(stderr, "Error: Memory allocation failed in 'utilXml.c'\n"); return -1; } inputKeys[i] = NULL; } inputKeys[i] = (char*)realloc(inputKeys[i], sizeof(char) * (j+2) ); if(inputKeys[i] == NULL) { fprintf(stderr, "Error: Memory allocation failed in 'utilXml.c'.\n"); return -1; } inputKeys[i][j] = myInputKeys[count]; j++; count++; } } if((i+1) != *myNumInputKeys ){ fprintf(stderr, "Error: Number of input variables keys found does not match:\nFound %d, expected %d\n", i+1, * myNumInputKeys); freeResource(inputKeys, i+1); return -1; } *numOutputVars = 0; *numInputVars = 0; outputVarsName[0] = '\0'; outputVarsType[0] = '\0'; inputVars[0] = '\0'; source = -1; ERROR_STATUS = 0; XML_SetElementHandler(p, EPstart, EPend); for (;;) { int done; int len; len = (int)fread(Buff, 1, BUFFSIZE, fd); if (ferror(fd)) { fprintf(stderr, "Error when reading xml variables in '%s'.\n", fileName); freeResource(inputKeys, numInputKeys); return -1; } done = feof(fd); if (XML_Parse(p, Buff, len, done) == XML_STATUS_ERROR || ERROR_STATUS == 1) { fprintf(stderr, "Error: Parser error in file '%s':\n%s\n", fileName, XML_ErrorString(XML_GetErrorCode(p))); freeResource(inputKeys, numInputKeys); return -1; } if (done) break; } XML_ParserFree(p); fclose(fd); freeResource(inputKeys, numInputKeys); return 0; }
int main (int argc, char *argv[]) { wchar_t *tprev, *tthis; FILE *ifp, *ofp; int ch, comp; size_t prevbuflen, thisbuflen, b1; char *prevline, *thisline, *p; const char *ifn; cap_rights_t rights; (void) setlocale(LC_ALL, ""); obsolete(argv); while ((ch = getopt(argc, argv, "cdif:s:u")) != -1) switch (ch) { case 'c': cflag = 1; break; case 'd': dflag = 1; break; case 'i': iflag = 1; break; case 'f': numfields = strtol(optarg, &p, 10); if (numfields < 0 || *p) errx(1, "illegal field skip value: %s", optarg); break; case 's': numchars = strtol(optarg, &p, 10); if (numchars < 0 || *p) errx(1, "illegal character skip value: %s", optarg); break; case 'u': uflag = 1; break; case '?': default: usage(); } argc -= optind; argv += optind; if (argc > 2) usage(); ifp = stdin; ifn = "stdin"; ofp = stdout; if (argc > 0 && strcmp(argv[0], "-") != 0) ifp = file(ifn = argv[0], "r"); cap_rights_init(&rights, CAP_FSTAT, CAP_READ); if (cap_rights_limit(fileno(ifp), &rights) < 0 && errno != ENOSYS) err(1, "unable to limit rights for %s", ifn); cap_rights_init(&rights, CAP_FSTAT, CAP_WRITE); if (argc > 1) ofp = file(argv[1], "w"); else cap_rights_set(&rights, CAP_IOCTL); if (cap_rights_limit(fileno(ofp), &rights) < 0 && errno != ENOSYS) { err(1, "unable to limit rights for %s", argc > 1 ? argv[1] : "stdout"); } if (cap_rights_is_set(&rights, CAP_IOCTL)) { unsigned long cmd; cmd = TIOCGETA; /* required by isatty(3) in printf(3) */ if (cap_ioctls_limit(fileno(ofp), &cmd, 1) < 0 && errno != ENOSYS) { err(1, "unable to limit ioctls for %s", argc > 1 ? argv[1] : "stdout"); } } strerror_init(); if (cap_enter() < 0 && errno != ENOSYS) err(1, "unable to enter capability mode"); prevbuflen = thisbuflen = 0; prevline = thisline = NULL; if (getline(&prevline, &prevbuflen, ifp) < 0) { if (ferror(ifp)) err(1, "%s", ifn); exit(0); } tprev = convert(prevline); tthis = NULL; while (getline(&thisline, &thisbuflen, ifp) >= 0) { if (tthis != NULL) free(tthis); tthis = convert(thisline); if (tthis == NULL && tprev == NULL) comp = inlcmp(thisline, prevline); else if (tthis == NULL || tprev == NULL) comp = 1; else comp = wcscoll(tthis, tprev); if (comp) { /* If different, print; set previous to new value. */ show(ofp, prevline); p = prevline; b1 = prevbuflen; prevline = thisline; prevbuflen = thisbuflen; if (tprev != NULL) free(tprev); tprev = tthis; thisline = p; thisbuflen = b1; tthis = NULL; repeats = 0; } else ++repeats; } if (ferror(ifp)) err(1, "%s", ifn); show(ofp, prevline); exit(0); }
/** @brief Get the icewm style. * * When icewm changes the style, it writes the new style to the ~/.icewm/theme * or $ICEWM_PRIVCFG/theme file and then restarts. The ~/.icewm/theme file * looks like: * * Theme="Penguins/default.theme" * #Theme="Airforce/default.theme" * ##Theme="Penguins/default.theme" * ###Theme="Pedestals/default.theme" * ####Theme="Penguins/default.theme" * #####Theme="Airforce/default.theme" * ######Theme="Archlinux/default.theme" * #######Theme="Airforce/default.theme" * ########Theme="Airforce/default.theme" * #########Theme="Airforce/default.theme" * ##########Theme="Penguins/default.theme" * */ static char * get_style_ICEWM() { FILE *f; struct stat st; char *stylefile, *themerc, *buf, *pos, *trm; int i, len, beg, end; size_t read, total; get_rcfile_ICEWM(); len = strlen(wm->pdir) + strlen("/theme") + 1; themerc = calloc(len, sizeof(*themerc)); snprintf(themerc, len, "%s/theme", wm->pdir); if (!(f = fopen(themerc, "r"))) { EPRINTF("%s: %s\n", themerc, strerror(errno)); goto no_themerc; } if (fstat(fileno(f), &st)) { EPRINTF("%s: %s\n", themerc, strerror(errno)); goto no_stat; } buf = calloc(st.st_size + 1, sizeof(*buf)); /* read entire file into buffer */ total = 0; while (total < st.st_size) { read = fread(buf + total, 1, st.st_size - total, f); total += read; if (total >= st.st_size) break; if (ferror(f)) { EPRINTF("%s: %s\n", themerc, strerror(errno)); goto no_buf; } if (feof(f)) break; } pos = trm = buf; if (strncmp(pos, "Theme=\"", 7) != 0) { EPRINTF("no theme at start of rc file\n"); goto no_theme; } pos += 7; if (!(trm = strchr(pos, '"'))) { EPRINTF("no theme at start of rc file\n"); goto no_theme; } *trm = '\0'; free(wm->stylename); wm->stylename = strdup(pos); stylefile = calloc(PATH_MAX, sizeof(*stylefile)); if (options.user && !options.system) { beg = 0; end = 2; } else if (options.system && !options.user) { beg = 2; end = CHECK_DIRS; } else { beg = 0; end = CHECK_DIRS; } for (i = beg; i < end; i++) { if (!wm->dirs[i] || !wm->dirs[i][0]) continue; snprintf(stylefile, PATH_MAX, "%s/themes/%s", wm->dirs[i], wm->stylename); if (xde_check_file(stylefile)) break; } if (i < end) { free(wm->style); wm->style = strdup(stylefile); } free(stylefile); return wm->style; no_theme: no_buf: free(buf); no_stat: fclose(f); no_themerc: free(themerc); return NULL; }
int main (int argc, char *argv[]) { const char *program = raptor_basename(argv[0]); const char *filename; FILE *fh; int rc = 0; unsigned int line = 1; size_t max_c2_len = 0; size_t max_c4_len = 0; int passes = 0; int fails = 0; if(argc != 2) { fprintf(stderr, "USAGE %s [path to NormalizationTest.txt]\n" "Get it at http://unicode.org/Public/UNIDATA/NormalizationTest.txt\n", program); return 1; } filename = argv[1]; fh = fopen(filename, "r"); if(!fh) { fprintf(stderr, "%s: file '%s' open failed - %s\n", program, filename, strerror(errno)); return 1; } #define LINE_BUFFER_SIZE 1024 /* FIXME big enough for Unicode 4 (c2 max 16; c4 max 33) */ #define UNISTR_SIZE 40 for(;!feof(fh); line++) { char buffer[LINE_BUFFER_SIZE]; char *p, *start; unsigned char column2[UNISTR_SIZE]; unsigned char column4[UNISTR_SIZE]; size_t column2_len, column4_len; int nfc_rc; int error; p = fgets(buffer, LINE_BUFFER_SIZE, fh); if(!p) { if(ferror(fh)) { fprintf(stderr, "%s: file '%s' read failed - %s\n", program, filename, strerror(errno)); rc = 1; break; } /* assume feof */ break; }; #if 0 fprintf(stderr, "%s:%d: line '%s'\n", program, line, buffer); #endif /* skip lines */ if(*p == '@' || *p == '#') continue; if(line != 56) continue; /* skip column 1 */ while(*p++ != ';') ; /* read column 2 into column2, column2_len */ start = p; /* find end column 2 */ while(*p++ != ';') ; column2_len = decode_to_utf8(column2, UNISTR_SIZE, start, p-1); if(column2_len > max_c2_len) max_c2_len = column2_len; /* skip column 3 */ while(*p++ != ';') ; /* read column 4 into column4, column4_len */ start = p; /* find end column 4 */ while(*p++ != ';') ; column4_len = decode_to_utf8(column4, UNISTR_SIZE, start, p-1); if(column4_len > max_c4_len) max_c4_len = column4_len; if(!raptor_unicode_check_utf8_string(column2, column2_len)) { fprintf(stderr, "%s:%d: UTF8 column 2 failed on: '", filename, line); utf8_print(column2, column2_len, stderr); fputs("'\n", stderr); fails++; } else passes++; /* Column 2 must be NFC */ nfc_rc = raptor_nfc_check(column2, column2_len, &error); if(!nfc_rc) { fprintf(stderr, "%s:%d: NFC column 2 failed on: '", filename, line); utf8_print(column2, column2_len, stderr); fprintf(stderr, "' at byte %d of %d\n", error, (int)column2_len); fails++; } else passes++; if(column2_len == column4_len && !memcmp(column2, column4, column2_len)) continue; if(!raptor_unicode_check_utf8_string(column4, column4_len)) { fprintf(stderr, "%s:%d: UTF8 column 4 failed on: '", filename, line); utf8_print(column4, column4_len, stderr); fputs("'\n", stderr); fails++; } else passes++; /* Column 4 must be in NFC */ nfc_rc = raptor_nfc_check(column4, column4_len, &error); if(!nfc_rc) { fprintf(stderr, "%s:%d: NFC column 4 failed on: '", filename, line); utf8_print(column4, column4_len, stderr); fprintf(stderr, "' at byte %d of %d\n", error, (int)column4_len); fails++; } else passes++; } fclose(fh); fprintf(stderr, "%s: max column 2 len: %d, max column 4 len: %d\n", program, (int)max_c2_len, (int)max_c4_len); fprintf(stderr, "%s: passes: %d fails: %d\n", program, passes, fails); return rc; }
int list(void) { ARCHD *arcn; int res; time_t now; arcn = &archd; /* * figure out archive type; pass any format specific options to the * archive option processing routine; call the format init routine. We * also save current time for ls_list() so we do not make a system * call for each file we need to print. If verbose (vflag) start up * the name and group caches. */ if ((get_arc() < 0) || ((*frmt->options)() < 0) || ((*frmt->st_rd)() < 0)) return 1; now = time(NULL); /* * step through the archive until the format says it is done */ while (next_head(arcn) == 0) { if (arcn->type == PAX_GLL || arcn->type == PAX_GLF) { /* * we need to read, to get the real filename */ off_t cnt; if (!(*frmt->rd_data)(arcn, -arcn->type, &cnt)) (void)rd_skip(cnt + arcn->pad); continue; } /* * check for pattern, and user specified options match. * When all patterns are matched we are done. */ if ((res = pat_match(arcn)) < 0) break; if ((res == 0) && (sel_chk(arcn) == 0)) { /* * pattern resulted in a selected file */ if (pat_sel(arcn) < 0) break; /* * modify the name as requested by the user if name * survives modification, do a listing of the file */ if ((res = mod_name(arcn, RENM)) < 0) break; if (res == 0) { if (arcn->name[0] == '/' && !check_Aflag()) { memmove(arcn->name, arcn->name + 1, strlen(arcn->name)); } ls_list(arcn, now, stdout); } /* * if there's an error writing to stdout then we must * stop now -- we're probably writing to a pipe that * has been closed by the reader. */ if (ferror(stdout)) { syswarn(1, errno, "Listing incomplete."); break; } } /* * skip to next archive format header using values calculated * by the format header read routine */ if (rd_skip(arcn->skip + arcn->pad) == 1) break; } /* * all done, let format have a chance to cleanup, and make sure that * the patterns supplied by the user were all matched */ (void)(*frmt->end_rd)(); (void)sigprocmask(SIG_BLOCK, &s_mask, NULL); ar_close(); pat_chk(); return 0; }
/** * Print information about each option. * * @param[in] opts the program options * @param[in] exit_code whether or not there was a usage error reported. * used to select full usage versus abbreviated. */ static void print_usage_details(tOptions * opts, int exit_code) { { char const * pOptTitle = NULL; int flen; /* * Determine which header and which option formatting strings to use */ if (do_gnu_usage(opts)) { flen = setGnuOptFmts(opts, &pOptTitle); sprintf(line_fmt_buf, zFmtFmt, flen); fputc(NL, option_usage_fp); } else { flen = setStdOptFmts(opts, &pOptTitle); sprintf(line_fmt_buf, zFmtFmt, flen); /* * When we exit with EXIT_SUCCESS and the first option is a doc * option, we do *NOT* want to emit the column headers. * Otherwise, we do. */ if ( (exit_code != EXIT_SUCCESS) || ((opts->pOptDesc->fOptState & OPTST_DOCUMENT) == 0) ) fputs(pOptTitle, option_usage_fp); } flen = 4 - ((flen + 15) / 8); if (flen > 0) tab_skip_ct = flen; prt_opt_usage(opts, exit_code, pOptTitle); } /* * Describe the mechanics of denoting the options */ switch (opts->fOptSet & OPTPROC_L_N_S) { case OPTPROC_L_N_S: fputs(zFlagOkay, option_usage_fp); break; case OPTPROC_SHORTOPT: break; case OPTPROC_LONGOPT: fputs(zNoFlags, option_usage_fp); break; case 0: fputs(zOptsOnly, option_usage_fp); break; } if ((opts->fOptSet & OPTPROC_NUM_OPT) != 0) fputs(zNumberOpt, option_usage_fp); if ((opts->fOptSet & OPTPROC_REORDER) != 0) fputs(zReorder, option_usage_fp); if (opts->pzExplain != NULL) fputs(opts->pzExplain, option_usage_fp); /* * IF the user is asking for help (thus exiting with SUCCESS), * THEN see what additional information we can provide. */ if (exit_code == EXIT_SUCCESS) prt_prog_detail(opts); /* * Give bug notification preference to the packager information */ if (HAS_pzPkgDataDir(opts) && (opts->pzPackager != NULL)) fputs(opts->pzPackager, option_usage_fp); else if (opts->pzBugAddr != NULL) fprintf(option_usage_fp, zPlsSendBugs, opts->pzBugAddr); fflush(option_usage_fp); if (ferror(option_usage_fp) != 0) fserr_exit(opts->pzProgName, zwriting, (option_usage_fp == stderr) ? zstderr_name : zstdout_name); }
cct_status _cct_source_subrip_read(cct_source_ctx *ctx, cct_sub_entry **entry, unsigned int *eos) { (*entry) = NULL; *eos = 0; cct_source_subrip_ctx *sctx = (cct_source_subrip_ctx *) ctx->ctx_data; char buffer[SRT_MAX_LINE_LENGTH]; if (!fgets(buffer, SRT_MAX_LINE_LENGTH, sctx->file)) { if (feof(sctx->file)) { *eos = 1; return CCT_OK; } else if (ferror(sctx->file)) { perror("_cct_subrip_source_read: can't read entry counter"); return CCT_FATAL; } fprintf(stderr, "_cct_subrip_source_read: unhandled branch for counter\n"); return CCT_FATAL; } unsigned long counter = 0; sctx->counter++; sscanf(buffer, "%lu", &counter); if (counter != sctx->counter) { fprintf(stderr, "_cct_subrip_source_read: counter missing: expected %lu, got %lu\n", sctx->counter, counter); sctx->counter = counter; } if (!fgets(buffer, SRT_MAX_LINE_LENGTH, sctx->file)) { if (feof(sctx->file)) { fprintf(stderr, "_cct_subrip_source_read: premature end of file (time)\n"); return CCT_FATAL; } else if (ferror(sctx->file)) { perror("_cct_subrip_source_read: can't read time"); return CCT_FATAL; } fprintf(stderr, "_cct_subrip_source_read: unhandled branch for time\n"); return CCT_FATAL; } unsigned int st_h, st_m, st_s, st_ms, et_h, et_m, et_s, et_ms; unsigned long start_time, end_time; sscanf(buffer, "%u:%u:%u,%u --> %u:%u:%u,%u", //TODO add display coords handling &st_h, &st_m, &st_s, &st_ms, &et_h, &et_m, &et_s, &et_ms); start_time = st_ms + (st_s * 1000) + (st_m * 1000 * 60) + (st_h * 1000 * 60 * 60); end_time = et_ms + (et_s * 1000) + (et_m * 1000 * 60) + (et_h * 1000 * 60 * 60); unsigned int lines_count = 0; char lines_buffer[SRT_MAX_LINES][SRT_MAX_LINE_LENGTH]; memset(lines_buffer, 0, SRT_MAX_LINES * SRT_MAX_LINE_LENGTH * sizeof(char)); while (fgets(lines_buffer[lines_count], SRT_MAX_LINE_LENGTH, sctx->file) && lines_count < SRT_MAX_LINES) { //removing trailing \r\n or \n first char *c_ptr = strrchr(lines_buffer[lines_count], '\n'); if (c_ptr) { *c_ptr = '\0'; } c_ptr = strrchr(lines_buffer[lines_count], '\r'); if (c_ptr) { *c_ptr = '\0'; } if (!strlen(lines_buffer[lines_count])) { if (lines_count == 0) { fprintf(stderr, "_cct_subrip_source_read: unexpected empty line\n"); } //done reading entry break; } lines_count++; } if (lines_count == SRT_MAX_LINES) { fprintf(stdout, "_cct_subrip_source_read: too much lines\n"); return CCT_FATAL; } if (feof(sctx->file) && lines_count == 0) { fprintf(stderr, "_cct_subrip_source_read: premature end of file (lines)\n"); return CCT_FATAL; } if (ferror(sctx->file)) { perror("_cct_subrip_source_read: cant read lines"); return CCT_FATAL; } cct_sub_entry *new_entry = malloc(sizeof(cct_sub_entry)); if (!new_entry) { perror("_cct_subrip_source_read: malloc() new_entry failed"); return CCT_FATAL; } new_entry->counter = counter; new_entry->start_time = start_time; new_entry->end_time = end_time; new_entry->lines_count = lines_count; new_entry->lines = (char **) malloc(new_entry->lines_count * sizeof(char*)); if (!new_entry->lines) { perror("_cct_subrip_source_read: malloc() new_entry->lines failed"); return CCT_FATAL; } for (unsigned int i = 0; i < lines_count; i++) { new_entry->lines[i] = strdup(lines_buffer[i]); if (!new_entry->lines[i]) { perror("_cct_subrip_source_read: strdup() new_entry->lines[i] failed"); return CCT_FATAL; } } (*entry) = new_entry; return CCT_OK; }
/* Find an appropriate scope fits to given conditions */ static Dwarf_Die *find_best_scope(struct probe_finder *pf, Dwarf_Die *die_mem) { struct find_scope_param fsp = { .function = pf->pev->point.function, .file = pf->fname, .line = pf->lno, .diff = INT_MAX, .die_mem = die_mem, .found = false, }; cu_walk_functions_at(&pf->cu_die, pf->addr, find_best_scope_cb, &fsp); return fsp.found ? die_mem : NULL; } static int probe_point_line_walker(const char *fname, int lineno, Dwarf_Addr addr, void *data) { struct probe_finder *pf = data; Dwarf_Die *sc_die, die_mem; int ret; if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0) return 0; pf->addr = addr; sc_die = find_best_scope(pf, &die_mem); if (!sc_die) { pr_warning("Failed to find scope of probe point.\n"); return -ENOENT; } ret = call_probe_finder(sc_die, pf); /* Continue if no error, because the line will be in inline function */ return ret < 0 ? ret : 0; } /* Find probe point from its line number */ static int find_probe_point_by_line(struct probe_finder *pf) { return die_walk_lines(&pf->cu_die, probe_point_line_walker, pf); } /* Find lines which match lazy pattern */ static int find_lazy_match_lines(struct list_head *head, const char *fname, const char *pat) { FILE *fp; char *line = NULL; size_t line_len; ssize_t len; int count = 0, linenum = 1; fp = fopen(fname, "r"); if (!fp) { pr_warning("Failed to open %s: %s\n", fname, strerror(errno)); return -errno; } while ((len = getline(&line, &line_len, fp)) > 0) { if (line[len - 1] == '\n') line[len - 1] = '\0'; if (strlazymatch(line, pat)) { line_list__add_line(head, linenum); count++; } linenum++; } if (ferror(fp)) count = -errno; free(line); fclose(fp); if (count == 0) pr_debug("No matched lines found in %s.\n", fname); return count; }
static void check_flo(file_list **lst, char *nm) { FILE *fp; off_t off; struct flock fl; char buf[PATH_MAX], buf2[PATH_MAX], *p, *q; int disposition; struct stat stbuf; if ((fp = fopen(nm,"r+")) == NULL) { /* * If no flo file, return. */ return; } Syslog('o', "check_flo(\"%s\")",FTND_SS(nm)); fl.l_type = F_RDLCK; fl.l_whence = 0; fl.l_start = 0L; fl.l_len = 0L; if (fcntl(fileno(fp), F_SETLK, &fl) != 0) { if (errno != EAGAIN) WriteError("$Can't read-lock \"%s\"", FTND_SS(nm)); else Syslog('o',"flo file busy"); fclose(fp); return; } if (stat(nm, &stbuf) != 0) { WriteError("$Can't access \"%s\"", FTND_SS(nm)); fclose(fp); return; } while (!feof(fp) && !ferror(fp)) { off = ftell(fp); if (fgets(buf, sizeof(buf)-1, fp) == NULL) continue; if (buf[0] == '~') continue; /* skip sent files */ if (*(p=buf + strlen(buf) -1) == '\n') *p-- = '\0'; if (*p == '\r') *p = '\0'; switch (buf[0]) { case '#': p=buf+1; disposition=TFS; break; case '-': case '^': p=buf+1; disposition=KFS; break; case '@': p=buf+1; disposition=LEAVE; break; case 0: continue; default: p=buf; disposition=LEAVE; break; } memset(&buf2, 0, sizeof(buf2)); if (strlen(CFG.dospath)) { if (strncasecmp(p, CFG.dospath, strlen(CFG.dospath)) == 0) { strcpy(buf2,uxoutbound); for (p+=strlen(CFG.dospath), q=buf2+strlen(buf2); *p; p++, q++) *q = ((*p) == '\\')?'/':tolower(*p); *q = '\0'; p = buf2; } } if ((q=strrchr(p,'/'))) q++; else q = p; add_list(lst, p, q, disposition, off, fp, 1); } /* * Add flo file to file list */ add_list(lst, nm, NULL, KFS, -1L, fp, 1); /* here, we leave .flo file open, it will be closed by */ /* execute_disposition */ return; }
static int add_mount( const char *what, const char *where, const char *fstype, const char *opts, int passno, bool noauto, bool nofail, bool automount, const char *post, const char *source) { _cleanup_free_ char *name = NULL, *unit = NULL, *lnk = NULL, *automount_name = NULL, *automount_unit = NULL, *filtered = NULL; _cleanup_fclose_ FILE *f = NULL; int r; assert(what); assert(where); assert(opts); assert(source); if (streq_ptr(fstype, "autofs")) return 0; if (!is_path(where)) { log_warning("Mount point %s is not a valid path, ignoring.", where); return 0; } if (mount_point_is_api(where) || mount_point_ignore(where)) return 0; if (path_equal(where, "/")) { /* The root disk is not an option */ automount = false; noauto = false; nofail = false; } name = unit_name_from_path(where, ".mount"); if (!name) return log_oom(); unit = strjoin(arg_dest, "/", name, NULL); if (!unit) return log_oom(); f = fopen(unit, "wxe"); if (!f) { if (errno == EEXIST) log_error("Failed to create mount unit file %s, as it already exists. Duplicate entry in /etc/fstab?", unit); else log_error_errno(errno, "Failed to create unit file %s: %m", unit); return -errno; } fprintf(f, "# Automatically generated by systemd-fstab-generator\n\n" "[Unit]\n" "SourcePath=%s\n" "Documentation=man:fstab(5) man:systemd-fstab-generator(8)\n", source); if (post && !noauto && !nofail && !automount) fprintf(f, "Before=%s\n", post); if (passno != 0) { r = generator_write_fsck_deps(f, arg_dest, what, where, fstype); if (r < 0) return r; } fprintf(f, "\n" "[Mount]\n" "What=%s\n" "Where=%s\n", what, where); if (!isempty(fstype) && !streq(fstype, "auto")) fprintf(f, "Type=%s\n", fstype); r = generator_write_timeouts(arg_dest, what, where, opts, &filtered); if (r < 0) return r; if (!isempty(filtered) && !streq(filtered, "defaults")) fprintf(f, "Options=%s\n", filtered); fflush(f); if (ferror(f)) return log_error_errno(errno, "Failed to write unit file %s: %m", unit); if (!noauto && post) { lnk = strjoin(arg_dest, "/", post, nofail || automount ? ".wants/" : ".requires/", name, NULL); if (!lnk) return log_oom(); mkdir_parents_label(lnk, 0755); if (symlink(unit, lnk) < 0) return log_error_errno(errno, "Failed to create symlink %s: %m", lnk); } if (automount) { automount_name = unit_name_from_path(where, ".automount"); if (!automount_name) return log_oom(); automount_unit = strjoin(arg_dest, "/", automount_name, NULL); if (!automount_unit) return log_oom(); fclose(f); f = fopen(automount_unit, "wxe"); if (!f) return log_error_errno(errno, "Failed to create unit file %s: %m", automount_unit); fprintf(f, "# Automatically generated by systemd-fstab-generator\n\n" "[Unit]\n" "SourcePath=%s\n" "Documentation=man:fstab(5) man:systemd-fstab-generator(8)\n", source); if (post) fprintf(f, "Before=%s\n", post); fprintf(f, "[Automount]\n" "Where=%s\n", where); fflush(f); if (ferror(f)) return log_error_errno(errno, "Failed to write unit file %s: %m", automount_unit); free(lnk); lnk = strjoin(arg_dest, "/", post, nofail ? ".wants/" : ".requires/", automount_name, NULL); if (!lnk) return log_oom(); mkdir_parents_label(lnk, 0755); if (symlink(automount_unit, lnk) < 0) return log_error_errno(errno, "Failed to create symlink %s: %m", lnk); } return 0; }
void buildOpenCLKernels_tea_leaf_zeqxty_kernel(int xdim0, int xdim1, int xdim2) { // int ocl_fma = OCL_FMA; if (!isbuilt_tea_leaf_zeqxty_kernel) { buildOpenCLKernels(); // clSafeCall( clUnloadCompiler() ); cl_int ret; char *source_filename[1] = {(char *)"./OpenCL/tea_leaf_zeqxty_kernel.cl"}; // Load the kernel source code into the array source_str FILE *fid; char *source_str[1]; size_t source_size[1]; for (int i = 0; i < 1; i++) { fid = fopen(source_filename[i], "r"); if (!fid) { fprintf(stderr, "Can't open the kernel source file!\n"); exit(1); } source_str[i] = (char *)malloc(4 * 0x1000000); source_size[i] = fread(source_str[i], 1, 4 * 0x1000000, fid); if (source_size[i] != 4 * 0x1000000) { if (ferror(fid)) { printf("Error while reading kernel source file %s\n", source_filename[i]); exit(-1); } if (feof(fid)) printf("Kernel source file %s succesfuly read.\n", source_filename[i]); // printf("%s\n",source_str[i]); } fclose(fid); } printf("Compiling tea_leaf_zeqxty_kernel %d source -- start \n", OCL_FMA); // Create a program from the source OPS_opencl_core.program = clCreateProgramWithSource( OPS_opencl_core.context, 1, (const char **)&source_str, (const size_t *)&source_size, &ret); clSafeCall(ret); // Build the program char buildOpts[255 * 3]; char *pPath = NULL; pPath = getenv("OPS_INSTALL_PATH"); if (pPath != NULL) if (OCL_FMA) sprintf(buildOpts, "-cl-mad-enable -DOCL_FMA -I%s/c/include " "-DOPS_WARPSIZE=%d " "-Dxdim0_tea_leaf_zeqxty_kernel=%d " "-Dxdim1_tea_leaf_zeqxty_kernel=%d " "-Dxdim2_tea_leaf_zeqxty_kernel=%d ", pPath, 32, xdim0, xdim1, xdim2); else sprintf(buildOpts, "-cl-mad-enable -I%s/c/include -DOPS_WARPSIZE=%d " "-Dxdim0_tea_leaf_zeqxty_kernel=%d " "-Dxdim1_tea_leaf_zeqxty_kernel=%d " "-Dxdim2_tea_leaf_zeqxty_kernel=%d ", pPath, 32, xdim0, xdim1, xdim2); else { sprintf((char *)"Incorrect OPS_INSTALL_PATH %s\n", pPath); exit(EXIT_FAILURE); } ret = clBuildProgram(OPS_opencl_core.program, 1, &OPS_opencl_core.device_id, buildOpts, NULL, NULL); if (ret != CL_SUCCESS) { char *build_log; size_t log_size; clSafeCall(clGetProgramBuildInfo( OPS_opencl_core.program, OPS_opencl_core.device_id, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size)); build_log = (char *)malloc(log_size + 1); clSafeCall(clGetProgramBuildInfo( OPS_opencl_core.program, OPS_opencl_core.device_id, CL_PROGRAM_BUILD_LOG, log_size, build_log, NULL)); build_log[log_size] = '\0'; fprintf( stderr, "=============== OpenCL Program Build Info ================\n\n%s", build_log); fprintf(stderr, "\n========================================================= \n"); free(build_log); exit(EXIT_FAILURE); } printf("compiling tea_leaf_zeqxty_kernel -- done\n"); // Create the OpenCL kernel OPS_opencl_core.kernel[41] = clCreateKernel( OPS_opencl_core.program, "ops_tea_leaf_zeqxty_kernel", &ret); clSafeCall(ret); isbuilt_tea_leaf_zeqxty_kernel = true; } }
// initialize the auto update system, start the downloading void init_update() { FILE *fp; if(update_busy){ return; } // initialize variables update_busy++; update_attempt_count= 0; // no downloads have been attempted temp_counter= 0; //start with download name with 0 restart_required= 0; // no restart needed yet allow_restart= 1; // automated restart allowed // create the mutex & init the download que if(!download_mutex){ // file_update_clear_old(); // There is no reason to delete all the previous files. We only remove the ones out of date. download_mutex= SDL_CreateMutex(); download_queue_size= 0; memset(download_queue, 0, sizeof(download_queue)); download_cur_file= NULL; download_cur_md5= NULL; } // load the server list num_update_servers= 0; update_server[0]= '\0'; fp = open_file_data("mirrors.lst", "r"); if(fp == NULL){ LOG_ERROR("%s: %s \"mirrors.lst\": %s\n", reg_error_str, cant_open_file, strerror(errno)); } else { char buffer[1024]; char *ptr; ptr= fgets(buffer, sizeof(buffer), fp); while(ptr && !ferror(fp) && num_update_servers < sizeof(update_servers)){ int len= strlen(buffer); // is this line worth handling? if(len > 6 && *buffer > ' ' && *buffer != '#'){ while(isspace(buffer[len-1])){ buffer[len-1]= '\0'; len--; } if(len > 6){ update_servers[num_update_servers++]= strdup(buffer); } } // read the next line ptr= fgets(buffer, sizeof(buffer), fp); } if(fp){ fclose(fp); } } if(!num_update_servers) { // oops, no mirror file, no downloading update_servers[0]= ""; return; } // start the process if(download_mutex){ strcpy(files_lst, "files.lst"); is_this_files_lst= 1; handle_update_download(NULL); } }
char *file2strl( const char *path, unsigned int *file_len_out ) { FILE *file; if (!(file = fopen(path, "rb"))) { fprintf(stderr, "Unable to open file %s\n", path); return NULL; } if (-1 == fseek(file, 0, SEEK_END)) { fprintf(stderr, "Unable to seek file %s\n", path); fclose(file); return NULL; } unsigned long file_len; unsigned long bytes_read; if (-1 == (file_len = ftell(file))) { fprintf(stderr, "Unable to ftell() file %s\n", path); fclose(file); return NULL; } if (-1 == fseek(file, 0, SEEK_SET)) { fprintf(stderr, "Unable to seek file %s\n", path); fclose(file); return NULL; } char *contents; if (!(contents = malloc(file_len + 1))) { fprintf(stderr, "Memory error!\n"); fclose(file); return NULL; } bytes_read = fread(contents, file_len, 1, file); if(bytes_read == 0 && ferror(file)) { fprintf(stderr, "Read error"); free(contents); fclose(file); return NULL; } fclose(file); contents[file_len] = '\0'; if (file_len_out) *file_len_out = file_len + 1; return contents; }
//////////////////////////////////////////////////////////////// /// This is a general function that returns the value according to \c exp /// /// \c exp mimics the xPath expression. /// Its format is //el1/../eln[@attr] /// which will return the \c attr value of \c eln, /// where \c eln is the n-th child of \c el1 /// /// Example: //variable/EnergyPlus[@name] will return the name attributes of EnergyPlus /// which is equivalent to //EnergyPlus[@name] /// ///\param fileName the xml file name. ///\param exp the xPath expression. ///\param myVals string to store the found values, semicolon separated. ///\param mynumVals number of values found. ///\param myStrLen length of the string that is passed. //////////////////////////////////////////////////////////////// int getxmlvalues(char* const fileName, char* const exp, char* const myVals, int* const myNumVals, int const myStrLen){ char* temp; int i,j; FILE * fd; XML_Parser p; vals = myVals; numVals = myNumVals; *numVals = 0; strLen = &myStrLen; att = NULL; expStk.head = NULL; expStk.top = -1; expStk.cur = -1; fd = fopen(fileName, "r"); if(!fd) { fprintf(stderr, "Error: Could not open file '%s'.\n", fileName); return -1; } p = XML_ParserCreate(NULL); if (!p) { fprintf(stderr, "Error: Could not allocate memory for parser in function 'getxmlvalue'.\n"); return -1; } i=2; j=0; if(!exp || '\0' == exp[0]) return -1; if( exp[0] != '/' || exp[1] != '/') return -1; temp = NULL; while(exp[i] != '\0'){ if( exp[i] == '/' || exp[i] == '[' || exp[i] == ']') { if(0==j && 0==expStk.top) { fprintf(stderr, "Error when parsing expression in 'utilXml.c'.\n"); return -1; } i++; if(strchr(temp, '@')) break; stackPushBCVTB(temp); free(temp); temp = NULL; j=0; } else { j++; temp = (char*) realloc(temp, sizeof(char)*(j+1)); if(temp == NULL) { fprintf(stderr, "Error: Memory allocation failed in 'utilXml.c'.\n"); return -1; } temp[j-1]=exp[i]; temp[j]='\0'; i++; } } if(temp[0] == '@'){ att = (char*) malloc(sizeof(char) * (strlen(temp) ) ); if(att == NULL) { fprintf(stderr, "Error: Memory allocation failed in 'utilXml.c'.\n"); free(temp); return -1; } for(i=1; i<strlen(temp); i++) att[i-1] = temp[i]; att[i-1]='\0'; free(temp); } else { fprintf(stderr, "Error when parsing expression in 'utilXml.c'.\n"); free(temp); free(att); while(i!= -1) stackPopBCVTB(); return -1; } expStk.cur = 0; if(1 == PARSEVALUE) vals[0]='\0'; *numVals = 0; XML_SetElementHandler(p, start, end); for (;;) { int done; int len; len = (int)fread(Buff, 1, BUFFSIZE, fd); if (ferror(fd)) { fprintf(stderr, "Error when reading xml variables in '%s'.\n", fileName); return -1; } done = feof(fd); if (XML_Parse(p, Buff, len, done) == XML_STATUS_ERROR) { fprintf(stderr, "Error: Parse error in file '%s':\n%s\n", fileName, XML_ErrorString(XML_GetErrorCode(p))); return -1; } if (done) break; } if( 0 == *numVals ){ fprintf(stderr, "Error: Did not find xml value\n for expression '%s'.\n in file '%s'\n", exp, fileName); } while( i != -1 ) i = stackPopBCVTB(); att = NULL; XML_ParserFree(p); fclose(fd); return 0; }
void process(const char *name) { char *cp; int c; int incomm = 0; int ret; printf("extern char\txstr[];\n"); for (;;) { if (fgets(linebuf, sizeof linebuf, stdin) == NULL) { if (ferror(stdin)) err(3, "%s", name); break; } if (linebuf[0] == '#') { if (linebuf[1] == ' ' && isdigit(linebuf[2])) printf("#line%s", &linebuf[1]); else printf("%s", linebuf); continue; } for (cp = linebuf; (c = *cp++);) switch (c) { case '"': if (incomm) goto def; if ((ret = (int) yankstr(&cp)) == -1) goto out; printf("(&xstr[%d])", ret); break; case '\'': if (incomm) goto def; putchar(c); if (*cp) putchar(*cp++); break; case '/': if (incomm || *cp != '*') goto def; incomm = 1; cp++; printf("/*"); continue; case '*': if (incomm && *cp == '/') { incomm = 0; cp++; printf("*/"); continue; } goto def; def: default: putchar(c); break; } } out: if (ferror(stdout)) warn("x.c"), onintr(0); }
void execute_disposition(file_list *fl) { FILE *fp=NULL; char *nm, tpl='~'; Syslog('o', "execute_disposition(%s)", fl->local); nm = fl->local; if (fl->flofp) { /* * Check for special case: flo-file */ if (fl->floff == -1) { /* * We check if there are any files left for transmission * in the flo-file to decide whether to remove or leave * it on disk. */ char buf[PATH_MAX]; int files_remain = 0; if (fseek(fl->flofp, 0L, 0) == 0) { while (!feof(fl->flofp) && !ferror(fl->flofp)) { if (fgets(buf, sizeof(buf)-1, fl->flofp) == NULL) continue; /* * Count nr of files which haven't been sent yet */ if (buf[0] != '~') files_remain++; } } else { WriteError("$Error seeking in .flo to 0"); files_remain = -1; /* Keep flo-file */ } if (files_remain) { Syslog('o', "Leaving flo-file \"%s\", %d files remaining", FTND_SS(nm), files_remain); fl->disposition = LEAVE; } else { fl->disposition = KFS; } } else { /* * Mark files as sent in flo-file */ if (fseek(fl->flofp, fl->floff, 0) == 0) { if (fwrite(&tpl,1,1,fl->flofp) != 1) { WriteError("$Error writing '~' to .flo at %u", (unsigned int)fl->floff); } else { Syslog('o', "Marked file \"%s\" as sent", FTND_SS(nm)); } fflush(fl->flofp); #ifdef HAVE_FDATASYNC fdatasync(fileno(fl->flofp)); #else #ifdef HAVE_FSYNC fsync(fileno(fl->flofp)); #endif #endif } else WriteError("$error seeking in .flo to %u", (unsigned int)fl->floff); } } switch (fl->disposition) { case DSF: case LEAVE: break; case TFS: Syslog('o', "Truncating sent file \"%s\"",FTND_SS(nm)); if ((fp=fopen(nm,"w"))) fclose(fp); else WriteError("$Cannot truncate file \"%s\"",FTND_SS(nm)); break; case KFS: Syslog('o', "Removing sent file \"%s\"",FTND_SS(nm)); if (unlink(nm) != 0) { if (errno == ENOENT) Syslog('o', "Cannot unlink nonexistent file \"%s\"", FTND_SS(nm)); else WriteError("$Cannot unlink file \"%s\"", FTND_SS(nm)); } break; default: WriteError("execute_disposition: unknown disp %d for \"%s\"", fl->disposition,FTND_SS(nm)); break; } return; }
int main(int argc, char* argv[]) { // Set the character locale, so we can produce proper output. setlocale(LC_CTYPE, ""); // Create the pool that is used to allocate everything GuPool* pool = gu_new_pool(); int status = EXIT_SUCCESS; if (argc != 4) { fprintf(stderr, "usage: %s pgf cat from_lang\n", argv[0]); status = EXIT_FAILURE; goto fail; } char* filename = argv[1]; GuString cat = gu_str_string(argv[2], pool); GuString from_lang = gu_str_string(argv[3], pool); // Create an exception frame that catches all errors. GuExn* err = gu_new_exn(NULL, gu_kind(type), pool); // Read the PGF grammar. PgfPGF* pgf = pgf_read(filename, pool, err); // If an error occured, it shows in the exception frame if (!gu_ok(err)) { fprintf(stderr, "Reading PGF failed\n"); status = EXIT_FAILURE; goto fail; } pgf_load_meta_child_probs(pgf, "../../../treebanks/PennTreebank/ParseEngAbs3.probs", pool, err); if (!gu_ok(err)) { fprintf(stderr, "Loading meta child probs failed\n"); status = EXIT_FAILURE; goto fail; } // Look up the source and destination concrete categories PgfConcr* from_concr = pgf_get_language(pgf, from_lang); if (!from_concr) { fprintf(stderr, "Unknown language\n"); status = EXIT_FAILURE; goto fail_concr; } // Register a callback for the literal category Symbol pgf_parser_add_literal(from_concr, gu_str_string("Symb", pool), &pgf_nerc_literal_callback); // We will keep the latest results in the 'ppool' and // we will iterate over them by using 'result'. GuPool* ppool = NULL; // The interactive translation loop. // XXX: This currently reads stdin directly, so it doesn't support // encodings properly. TODO: use a locale reader for input while (true) { char buf[4096]; char* line = fgets(buf, sizeof(buf), stdin); if (line == NULL) { if (ferror(stdin)) { fprintf(stderr, "Input error\n"); status = EXIT_FAILURE; } break; } else if (strcmp(line, "") == 0) { // End nicely on empty input break; } // We create a temporary pool for translating a single // sentence, so our memory usage doesn't increase over time. ppool = gu_new_pool(); GuReader *rdr = gu_string_reader(gu_str_string(line, ppool), ppool); PgfLexer *lexer = pgf_new_simple_lexer(rdr, ppool); pgf_print_chunks(from_concr, cat, lexer, ppool); // Free all resources allocated during parsing and linearization gu_pool_free(ppool); } fail_concr: fail: gu_pool_free(pool); return status; }
void print_results( FILE *stream, AS_INF *inf_ptr, BIRTH_DB *data, AS_INF_EXT *aie_ptr, BITS mode, NUM house_mode, DATA_PACKET *dpk, char *comment ) { COUNT i; AS_INF *inf; AS_INF_EXT *aiep; char buf1[60]; const char *report; NUM maxp, file = -1, aspfile = -1, hsfile = -1, midfile = -1; int sign, cusp, k, global = -1, table = -1, ruler; static char fmt8[] = { "<%s:>\x80" }; if ( mode & ASTEROID ) maxp = CHIRON; else if ( mode & VERT_EAST ) maxp = EAST_POINT; else maxp = PART_FORTU; if ( mode & TEXT ) { if ( mode & ASPECTS ) aspfile = open_asp_files( ASPECT_FILE ); file = open_files( PLANET_FILE ); if ( mode & HOUSES ) hsfile = open_files( HOUSE_FILE ); if ( mode & (BASE_MID|HALF_MID|FULL_MID) ) midfile = open_asp_files( MIDPOINT_SIGN ); } if ( mode & NOBIRTHTIM && ( dpk->rdp->rect_system == SOLARCHART || dpk->rdp->rect_system == FLATCHART ) ) house_mode = EQUAL; table = get_tables( REPORT_NAME, &global ); if ( table == -1 ) { er_close1: close_files( file ); close_files_asp( aspfile ); close_files( hsfile ); close_files( midfile ); return; } if ( dpk->chart_code & RELOC_CH ) k = CHH_RELOC; else k = CHH_TITLE; if ( ( report = get_report( table, global, k ) ) == NULL ) { goto er_close1; } else output_title( stream, data->name, comment, "", (char *)report ); if ( output_birth_head_group( stream, mode, data, table, house_mode, comment, dpk, global ) ) { goto er_close1; } rppl = get_report( table, global, CH__PLANET ); rphs = get_report( table, global, CH__PLAN_HOUSE ); rpah = get_report( table, global, CH__ASPECT_HD ); rpas = get_report( table, global, CH__ASPECT ); rpmsc = get_report( table, global, CH__MISC ); if ( rppl == NULL || rphs == NULL || rpas == NULL || rpah == NULL || rpmsc == NULL ) { er_close2: close_tables( table, global ); close_files( file ); close_files_asp( aspfile ); close_files( hsfile ); close_files( midfile ); return; } fputs("\n\n", stream ); if ( ferror( stream ) ) { goto er_close2; } for ( i = 0, aiep = aie_ptr, inf = inf_ptr; i <= maxp; ++i, ++inf, ++aiep ) { if ( !inf->calced ) continue; if ( x_kb_check() ) break; print_entry( stream, inf, i, mode, file, aspfile, hsfile, midfile, aiep, data->name, comment, table, global ); if ( ferror( stream ) ) { goto er_close2; } } if ( mode & TEXT ) { close_files( file ); close_files_asp( aspfile ); close_files( hsfile ); close_files( midfile ); } if ( x_kb_check() ) return; if ( mode & HOUSES ) { if ( mode & TEXT ) { if ( ( hsfile = open_files( SIGN_HOUSE_FILE ) ) == -1 ) mode &= ( 0xffff ^ TEXT ); } if ( mode & HOUSES ) out_do_house_cusps(stream,data->name, comment, "", table, global, house_cusps, CH__HOUSE_HEAD ); if ( ( report = get_report( table, global, CH__HS_SGN_HED ) ) == NULL ) { er_close3: close_tables( table, global ); close_files( hsfile ); return; } else output_title( stream, data->name, comment, "", (char *)report ); if ( ( report = get_report( table, global, CH__HOUSE_SIGN ) ) == NULL ) { goto er_close3; } if ( ( rphs = strdup( report )) == NULL ) goto er_close3; for ( i = 1; i <= 12; ++i ) { if ( x_kb_check() ) break; output_house_sign( stream, i, house_cusps[i], &cusp, &sign, data->name, (char *)rphs ); ruler = sign_rulers[sign]; if ( cusp == -1 ) { if ( mode & TEXT ) get_transfer_text( sign, i, hsfile, stream ); get_transfer_text( ruler, 13, hsfile, stream ); } else { if ( mode & TEXT ) { fprintf( stream, (char *)fmt8, sign_str( sign ) ); get_transfer_text( sign, i, hsfile, stream ); fprintf( stream, (char *)fmt8, sign_str( cusp ) ); get_transfer_text( cusp, i, hsfile, stream ); get_transfer_text( ruler, 13, hsfile, stream ); } } } if ( mode & TEXT ) close_files( hsfile ); } if ( x_kb_check() ) { close_tables( table, global ); return; } close_tables( table, global ); table = get_tables( SUMMARY_NAME, &global ); if ( table == -1 ) return; if ( mode & SUMMARY ) print_summary(stream, mode, table, global, data->name, comment ); close_tables( table, global ); }
/*=export_func optionUsage * private: * * what: Print usage text * arg: + tOptions * + opts + program options descriptor + * arg: + int + exitCode + exit code for calling exit(3) + * * doc: * This routine will print usage in both GNU-standard and AutoOpts-expanded * formats. The descriptor specifies the default, but AUTOOPTS_USAGE will * over-ride this, providing the value of it is set to either "gnu" or * "autoopts". This routine will @strong{not} return. * * If "exitCode" is "AO_EXIT_REQ_USAGE" (normally 64), then output will to * to stdout and the actual exit code will be "EXIT_SUCCESS". =*/ void optionUsage(tOptions * opts, int usage_exit_code) { int exit_code = (usage_exit_code == AO_EXIT_REQ_USAGE) ? EXIT_SUCCESS : usage_exit_code; displayEnum = false; set_usage_flags(opts, NULL); /* * Paged usage will preset option_usage_fp to an output file. * If it hasn't already been set, then set it to standard output * on successful exit (help was requested), otherwise error out. * * Test the version before obtaining pzFullUsage or pzShortUsage. * These fields do not exist before revision 30. */ { char const * pz; if (exit_code == EXIT_SUCCESS) { pz = (opts->structVersion >= 30 * 4096) ? opts->pzFullUsage : NULL; if (option_usage_fp == NULL) option_usage_fp = print_exit ? stderr : stdout; } else { pz = (opts->structVersion >= 30 * 4096) ? opts->pzShortUsage : NULL; if (option_usage_fp == NULL) option_usage_fp = stderr; } if (((opts->fOptSet & OPTPROC_COMPUTE) == 0) && (pz != NULL)) { if ((opts->fOptSet & OPTPROC_TRANSLATE) != 0) optionPrintParagraphs(pz, true, option_usage_fp); else fputs(pz, option_usage_fp); goto flush_and_exit; } } fprintf(option_usage_fp, opts->pzUsageTitle, opts->pzProgName); if ((exit_code == EXIT_SUCCESS) || (! skip_misuse_usage(opts))) print_usage_details(opts, usage_exit_code); else print_offer_usage(opts); flush_and_exit: fflush(option_usage_fp); if (ferror(option_usage_fp) != 0) fserr_exit(opts->pzProgName, zwriting, (option_usage_fp == stdout) ? zstdout_name : zstderr_name); option_exits(exit_code); }
int load_env_file(const char *fname, char ***rl) { _cleanup_fclose_ FILE *f; _cleanup_strv_free_ char **m = NULL; _cleanup_free_ char *c = NULL; assert(fname); assert(rl); /* This reads an environment file, but will not complain about * any invalid assignments, that needs to be done by the * caller */ f = fopen(fname, "re"); if (!f) return -errno; while (!feof(f)) { char l[LINE_MAX], *p, *cs, *b; if (!fgets(l, sizeof(l), f)) { if (ferror(f)) return -errno; /* The previous line was a continuation line? * Let's process it now, before we leave the * loop */ if (c) goto process; break; } /* Is this a continuation line? If so, just append * this to c, and go to next line right-away */ cs = endswith(l, "\\\n"); if (cs) { *cs = '\0'; b = strappend(c, l); if (!b) return -ENOMEM; free(c); c = b; continue; } /* If the previous line was a continuation line, * append the current line to it */ if (c) { b = strappend(c, l); if (!b) return -ENOMEM; free(c); c = b; } process: p = strstrip(c ? c : l); if (*p && !strchr(COMMENTS, *p)) { _cleanup_free_ char *u; int k; u = normalize_env_assignment(p); if (!u) return -ENOMEM; k = strv_extend(&m, u); if (k < 0) return -ENOMEM; } free(c); c = NULL; } *rl = m; m = NULL; return 0; }
MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file, const MagickBooleanType verbose) { #define IdentifyFormat " %s:\n min: " QuantumFormat \ " (%g)\n max: " QuantumFormat " (%g)\n" \ " mean: %g (%g)\n standard deviation: %g (%g)\n" \ " kurtosis: %g\n skewness: %g\n" char color[MaxTextExtent], format[MaxTextExtent], key[MaxTextExtent]; ColorspaceType colorspace; const char *artifact, *name, *property, *registry, *value; const MagickInfo *magick_info; const PixelPacket *pixels; double elapsed_time, user_time; ExceptionInfo *exception; ImageType type; long y; MagickBooleanType ping; register long i, x; unsigned long scale; assert(image != (Image *) NULL); assert(image->signature == MagickSignature); if (image->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); if (file == (FILE *) NULL) file=stdout; *format='\0'; elapsed_time=GetElapsedTime(&image->timer); user_time=GetUserTime(&image->timer); GetTimerInfo(&image->timer); if (verbose == MagickFalse) { /* Display summary info about the image. */ if (*image->magick_filename != '\0') if (LocaleCompare(image->magick_filename,image->filename) != 0) (void) fprintf(file,"%s=>",image->magick_filename); if ((GetPreviousImageInList(image) == (Image *) NULL) && (GetNextImageInList(image) == (Image *) NULL) && (image->scene == 0)) (void) fprintf(file,"%s ",image->filename); else (void) fprintf(file,"%s[%lu] ",image->filename,image->scene); (void) fprintf(file,"%s ",image->magick); if ((image->magick_columns != 0) || (image->magick_rows != 0)) if ((image->magick_columns != image->columns) || (image->magick_rows != image->rows)) (void) fprintf(file,"%lux%lu=>",image->magick_columns, image->magick_rows); (void) fprintf(file,"%lux%lu ",image->columns,image->rows); if ((image->page.width != 0) || (image->page.height != 0) || (image->page.x != 0) || (image->page.y != 0)) (void) fprintf(file,"%lux%lu%+ld%+ld ",image->page.width, image->page.height,image->page.x,image->page.y); (void) fprintf(file,"%lu-bit ",image->depth); if (image->type != UndefinedType) (void) fprintf(file,"%s ",MagickOptionToMnemonic(MagickTypeOptions, (long) image->type)); if (image->storage_class == DirectClass) { (void) fprintf(file,"DirectClass "); if (image->total_colors != 0) { (void) FormatMagickSize(image->total_colors,MagickFalse,format); (void) fprintf(file,"%s ",format); } } else if (image->total_colors <= image->colors) (void) fprintf(file,"PseudoClass %luc ",image->colors); else (void) fprintf(file,"PseudoClass %lu=>%luc ",image->total_colors, image->colors); if (image->error.mean_error_per_pixel != 0.0) (void) fprintf(file,"%ld/%f/%fdb ",(long) (image->error.mean_error_per_pixel+0.5), image->error.normalized_mean_error, image->error.normalized_maximum_error); if (GetBlobSize(image) != 0) { (void) FormatMagickSize(GetBlobSize(image),MagickFalse,format); (void) fprintf(file,"%s ",format); } (void) fprintf(file,"%0.3fu %ld:%02ld.%03ld",user_time,(long) (elapsed_time/60.0),(long) floor(fmod(elapsed_time,60.0)), (long) (1000.0*(elapsed_time-floor(elapsed_time)))); (void) fprintf(file,"\n"); (void) fflush(file); return(ferror(file) != 0 ? MagickFalse : MagickTrue); } /* Display verbose info about the image. */ exception=AcquireExceptionInfo(); pixels=GetVirtualPixels(image,0,0,1,1,exception); exception=DestroyExceptionInfo(exception); ping=pixels == (const PixelPacket *) NULL ? MagickTrue : MagickFalse; type=GetImageType(image,&image->exception); (void) SignatureImage(image); (void) fprintf(file,"Image: %s\n",image->filename); if (*image->magick_filename != '\0') if (LocaleCompare(image->magick_filename,image->filename) != 0) { char filename[MaxTextExtent]; GetPathComponent(image->magick_filename,TailPath,filename); (void) fprintf(file," Base filename: %s\n",filename); } magick_info=GetMagickInfo(image->magick,&image->exception); if ((magick_info == (const MagickInfo *) NULL) || (*GetMagickDescription(magick_info) == '\0')) (void) fprintf(file," Format: %s\n",image->magick); else (void) fprintf(file," Format: %s (%s)\n",image->magick, GetMagickDescription(magick_info)); (void) fprintf(file," Class: %s\n",MagickOptionToMnemonic(MagickClassOptions, (long) image->storage_class)); (void) fprintf(file," Geometry: %lux%lu%+ld%+ld\n",image->columns, image->rows,image->tile_offset.x,image->tile_offset.y); if ((image->magick_columns != 0) || (image->magick_rows != 0)) if ((image->magick_columns != image->columns) || (image->magick_rows != image->rows)) (void) fprintf(file," Base geometry: %lux%lu\n",image->magick_columns, image->magick_rows); if ((image->x_resolution != 0.0) && (image->y_resolution != 0.0)) { (void) fprintf(file," Resolution: %gx%g\n",image->x_resolution, image->y_resolution); (void) fprintf(file," Print size: %gx%g\n",(double) image->columns/ image->x_resolution,(double) image->rows/image->y_resolution); } (void) fprintf(file," Units: %s\n",MagickOptionToMnemonic( MagickResolutionOptions,(long) image->units)); (void) fprintf(file," Type: %s\n",MagickOptionToMnemonic(MagickTypeOptions, (long) type)); if (image->type != UndefinedType) (void) fprintf(file," Base type: %s\n",MagickOptionToMnemonic( MagickTypeOptions,(long) image->type)); (void) fprintf(file," Endianess: %s\n",MagickOptionToMnemonic( MagickEndianOptions,(long) image->endian)); /* Detail channel depth and extrema. */ (void) fprintf(file," Colorspace: %s\n",MagickOptionToMnemonic( MagickColorspaceOptions,(long) image->colorspace)); if (ping == MagickFalse) { ChannelStatistics *channel_statistics; unsigned long depth; depth=GetImageDepth(image,&image->exception); if (image->depth == depth) (void) fprintf(file," Depth: %lu-bit\n",image->depth); else (void) fprintf(file," Depth: %lu/%lu-bit\n",image->depth,depth); channel_statistics=GetImageChannelStatistics(image,&image->exception); (void) fprintf(file," Channel depth:\n"); colorspace=image->colorspace; if (IsGrayImage(image,&image->exception) != MagickFalse) colorspace=GRAYColorspace; switch (colorspace) { case RGBColorspace: default: { (void) fprintf(file," red: %lu-bit\n", channel_statistics[RedChannel].depth); (void) fprintf(file," green: %lu-bit\n", channel_statistics[GreenChannel].depth); (void) fprintf(file," blue: %lu-bit\n", channel_statistics[BlueChannel].depth); if (image->matte != MagickFalse) (void) fprintf(file," alpha: %lu-bit\n", channel_statistics[OpacityChannel].depth); break; } case CMYKColorspace: { (void) fprintf(file," cyan: %lu-bit\n", channel_statistics[CyanChannel].depth); (void) fprintf(file," magenta: %lu-bit\n", channel_statistics[MagentaChannel].depth); (void) fprintf(file," yellow: %lu-bit\n", channel_statistics[YellowChannel].depth); (void) fprintf(file," black: %lu-bit\n", channel_statistics[BlackChannel].depth); if (image->matte != MagickFalse) (void) fprintf(file," alpha: %lu-bit\n", channel_statistics[OpacityChannel].depth); break; } case GRAYColorspace: { (void) fprintf(file," gray: %lu-bit\n", channel_statistics[GrayChannel].depth); if (image->matte != MagickFalse) (void) fprintf(file," alpha: %lu-bit\n", channel_statistics[OpacityChannel].depth); break; } } scale=1; if (image->depth <= MAGICKCORE_QUANTUM_DEPTH) scale=QuantumRange/((unsigned long) QuantumRange >> ((unsigned long) MAGICKCORE_QUANTUM_DEPTH-image->depth)); (void) fprintf(file," Channel statistics:\n"); switch (colorspace) { case RGBColorspace: default: { (void) fprintf(file,IdentifyFormat,"red",(Quantum) (channel_statistics[RedChannel].minima/scale),(double) channel_statistics[RedChannel].minima/(double) QuantumRange, (Quantum) (channel_statistics[RedChannel].maxima/scale),(double) channel_statistics[RedChannel].maxima/(double) QuantumRange, channel_statistics[RedChannel].mean/(double) scale, channel_statistics[RedChannel].mean/(double) QuantumRange, channel_statistics[RedChannel].standard_deviation/(double) scale, channel_statistics[RedChannel].standard_deviation/(double) QuantumRange,channel_statistics[RedChannel].kurtosis, channel_statistics[RedChannel].skewness); (void) fprintf(file,IdentifyFormat,"green",(Quantum) (channel_statistics[GreenChannel].minima/scale),(double) channel_statistics[GreenChannel].minima/(double) QuantumRange, (Quantum) (channel_statistics[GreenChannel].maxima/scale),(double) channel_statistics[GreenChannel].maxima/(double) QuantumRange, channel_statistics[GreenChannel].mean/(double) scale, channel_statistics[GreenChannel].mean/(double) QuantumRange, channel_statistics[GreenChannel].standard_deviation/(double) scale, channel_statistics[GreenChannel].standard_deviation/(double) QuantumRange, channel_statistics[GreenChannel].kurtosis, channel_statistics[GreenChannel].skewness); (void) fprintf(file,IdentifyFormat,"blue",(Quantum) (channel_statistics[BlueChannel].minima/scale),(double) channel_statistics[BlueChannel].minima/(double) QuantumRange, (Quantum) (channel_statistics[BlueChannel].maxima/scale),(double) channel_statistics[BlueChannel].maxima/(double) QuantumRange, channel_statistics[BlueChannel].mean/(double) scale, channel_statistics[BlueChannel].mean/(double) QuantumRange, channel_statistics[BlueChannel].standard_deviation/(double) scale, channel_statistics[BlueChannel].standard_deviation/(double) QuantumRange,channel_statistics[BlueChannel].kurtosis, channel_statistics[BlueChannel].skewness); break; } case CMYKColorspace: { (void) fprintf(file,IdentifyFormat,"cyan",(Quantum) (channel_statistics[CyanChannel].minima/scale),(double) channel_statistics[CyanChannel].minima/(double) QuantumRange, (Quantum) (channel_statistics[CyanChannel].maxima/scale),(double) channel_statistics[CyanChannel].maxima/(double) QuantumRange, channel_statistics[CyanChannel].mean/(double) scale, channel_statistics[CyanChannel].mean/(double) QuantumRange, channel_statistics[CyanChannel].standard_deviation/(double) scale, channel_statistics[CyanChannel].standard_deviation/(double) QuantumRange,channel_statistics[CyanChannel].kurtosis, channel_statistics[CyanChannel].skewness); (void) fprintf(file,IdentifyFormat,"magenta",(Quantum) (channel_statistics[MagentaChannel].minima/scale),(double) channel_statistics[MagentaChannel].minima/(double) QuantumRange, (Quantum) (channel_statistics[MagentaChannel].maxima/scale),(double) channel_statistics[MagentaChannel].maxima/(double) QuantumRange, channel_statistics[MagentaChannel].mean/(double) scale, channel_statistics[MagentaChannel].mean/(double) QuantumRange, channel_statistics[MagentaChannel].standard_deviation/(double) scale,channel_statistics[MagentaChannel].standard_deviation/(double) QuantumRange,channel_statistics[MagentaChannel].kurtosis, channel_statistics[MagentaChannel].skewness); (void) fprintf(file,IdentifyFormat,"yellow",(Quantum) (channel_statistics[YellowChannel].minima/scale),(double) channel_statistics[YellowChannel].minima/(double) QuantumRange, (Quantum) (channel_statistics[YellowChannel].maxima/scale),(double) channel_statistics[YellowChannel].maxima/(double) QuantumRange, channel_statistics[YellowChannel].mean/(double) scale, channel_statistics[YellowChannel].mean/(double) QuantumRange, channel_statistics[YellowChannel].standard_deviation/(double) scale, channel_statistics[YellowChannel].standard_deviation/(double) QuantumRange,channel_statistics[YellowChannel].kurtosis, channel_statistics[YellowChannel].skewness); (void) fprintf(file,IdentifyFormat,"black",(Quantum) (channel_statistics[BlackChannel].minima/scale),(double) channel_statistics[BlackChannel].minima/(double) QuantumRange, (Quantum) (channel_statistics[BlackChannel].maxima/scale),(double) channel_statistics[BlackChannel].maxima/(double) QuantumRange, channel_statistics[BlackChannel].mean/(double) scale, channel_statistics[BlackChannel].mean/(double) QuantumRange, channel_statistics[BlackChannel].standard_deviation/(double) scale, channel_statistics[BlackChannel].standard_deviation/(double) QuantumRange,channel_statistics[BlackChannel].kurtosis, channel_statistics[BlackChannel].skewness); break; } case GRAYColorspace: { (void) fprintf(file,IdentifyFormat,"gray",(Quantum) (channel_statistics[GrayChannel].minima/scale),(double) channel_statistics[GrayChannel].minima/(double) QuantumRange, (Quantum) (channel_statistics[GrayChannel].maxima/scale),(double) channel_statistics[GrayChannel].maxima/(double) QuantumRange, channel_statistics[GrayChannel].mean/(double) scale, channel_statistics[GrayChannel].mean/(double) QuantumRange, channel_statistics[GrayChannel].standard_deviation/(double) scale, channel_statistics[GrayChannel].standard_deviation/(double) QuantumRange,channel_statistics[GrayChannel].kurtosis, channel_statistics[GrayChannel].skewness); break; } } if (image->matte != MagickFalse) (void) fprintf(file,IdentifyFormat,"alpha",(Quantum) ((QuantumRange-channel_statistics[AlphaChannel].maxima)/scale), (double) (QuantumRange-channel_statistics[AlphaChannel].maxima)/ (double) QuantumRange, (Quantum) ((QuantumRange- channel_statistics[AlphaChannel].minima)/scale),(double) (QuantumRange-channel_statistics[AlphaChannel].minima)/(double) QuantumRange,(QuantumRange-channel_statistics[AlphaChannel].mean)/ (double) scale,(QuantumRange-channel_statistics[AlphaChannel].mean)/ (double) QuantumRange, channel_statistics[AlphaChannel].standard_deviation/(double) scale, channel_statistics[AlphaChannel].standard_deviation/(double) QuantumRange,channel_statistics[AlphaChannel].kurtosis, channel_statistics[AlphaChannel].skewness); if (colorspace != GRAYColorspace) { (void) fprintf(file," Image statistics:\n"); (void) fprintf(file,IdentifyFormat,"Overall",(Quantum) (channel_statistics[AllChannels].minima/scale),(double) channel_statistics[AllChannels].minima/(double) QuantumRange, (Quantum) (channel_statistics[AllChannels].maxima/scale),(double) channel_statistics[AllChannels].maxima/(double) QuantumRange, channel_statistics[AllChannels].mean/(double) scale, channel_statistics[AllChannels].mean/(double) QuantumRange, channel_statistics[AllChannels].standard_deviation/(double) scale, channel_statistics[AllChannels].standard_deviation/(double) QuantumRange,channel_statistics[AllChannels].kurtosis, channel_statistics[AllChannels].skewness); } channel_statistics=(ChannelStatistics *) RelinquishMagickMemory( channel_statistics); if (image->colorspace == CMYKColorspace) (void) fprintf(file," Total ink density: %.0f%%\n",100.0* GetImageTotalInkDensity(image)/(double) QuantumRange); x=0; if (image->matte != MagickFalse) { register const IndexPacket *indexes; register const PixelPacket *p; p=(PixelPacket *) NULL; indexes=(IndexPacket *) NULL; for (y=0; y < (long) image->rows; y++) { p=GetVirtualPixels(image,0,y,image->columns,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (long) image->columns; x++) { if (p->opacity == (Quantum) TransparentOpacity) break; p++; } if (x < (long) image->columns) break; } if ((x < (long) image->columns) || (y < (long) image->rows)) { char tuple[MaxTextExtent]; MagickPixelPacket pixel; GetMagickPixelPacket(image,&pixel); SetMagickPixelPacket(image,p,indexes+x,&pixel); (void) QueryMagickColorname(image,&pixel,SVGCompliance,tuple, &image->exception); (void) fprintf(file," Alpha: %s ",tuple); GetColorTuple(&pixel,MagickTrue,tuple); (void) fprintf(file," %s\n",tuple); } } if (ping == MagickFalse) { artifact=GetImageArtifact(image,"identify:unique"); if ((artifact != (const char *) NULL) && (IsMagickTrue(artifact) != MagickFalse)) (void) fprintf(file," Colors: %lu\n",GetNumberColors(image, (FILE *) NULL,&image->exception)); if (IsHistogramImage(image,&image->exception) != MagickFalse) { (void) fprintf(file," Histogram:\n"); (void) GetNumberColors(image,file,&image->exception); } } }
/* Decompress from file source to file dest until stream ends or EOF. inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be allocated for processing, Z_DATA_ERROR if the deflate data is invalid or incomplete, Z_VERSION_ERROR if the version of zlib.h and the version of the library linked do not match, or Z_ERRNO if there is an error reading or writing the files. */ static int inf(FILE *source, FILE *dest, z_stream *strm, unsigned char *in, unsigned char *out) { int ret = Z_OK; int rc; long start_offs; long read_offs = 0; long have; strm->avail_in = 0; strm->next_in = Z_NULL; start_offs = ftell(source); read_offs = 0; /* decompress until deflate stream ends or end of file */ do { strm->avail_in = fread(in, 1, CHUNK_i, source); if (ferror(source)) { fprintf(stderr, "fread error\n"); return Z_ERRNO; } if (0 == strm->avail_in) break; strm->next_in = in; __more_inf: /* run inflate() on input until output buffer not full */ do { strm->avail_out = CHUNK_o; strm->next_out = out; ret = inflate(strm, Z_NO_FLUSH /* Z_SYNC_FLUSH */); assert(ret != Z_STREAM_ERROR); /* not clobbered */ switch (ret) { case Z_OK: /* Need to continue with Read more data */ break; case Z_STREAM_END: read_offs += strm->total_in; break; case Z_NEED_DICT: fprintf(stderr, "NEED Dict........\n"); ret = Z_DATA_ERROR; /* and fall through */ case Z_DATA_ERROR: case Z_MEM_ERROR: fprintf(stderr, "Fault..... %d\n", ret); return ret; } have = CHUNK_o - strm->avail_out; if (fwrite(out, 1, have, dest) != (size_t)have || ferror(dest)) { fprintf(stderr, "fwrite fault\n"); return Z_ERRNO; } } while (strm->avail_out == 0); /* done when inflate() says it's done */ } while (ret != Z_STREAM_END); /* FIXME: this goto and the limit check is not nice. */ if (strm->avail_in > (16 * 1024)) { inflateReset(strm); /* reset and continue */ goto __more_inf; } /* Set the file position right after the absorbed input */ start_offs += read_offs; /* Add to seek offset */ rc = fseek(source, start_offs, SEEK_SET); if (rc == -1) fprintf(stderr, "err: fseek rc=%d\n", rc); inflateReset(strm); return ret; }
/* * ex_mkexrc -- :mkexrc[!] [file] * * Create (or overwrite) a .exrc file with the current info. * * PUBLIC: int ex_mkexrc __P((SCR *, EXCMD *)); */ int ex_mkexrc(SCR *sp, EXCMD *cmdp) { struct stat sb; FILE *fp; int fd, sverrno; char *fname; size_t flen; switch (cmdp->argc) { case 0: fname = _PATH_EXRC; break; case 1: INT2CHAR(sp, cmdp->argv[0]->bp, cmdp->argv[0]->len + 1, fname, flen); set_alt_name(sp, fname); break; default: abort(); } if (!FL_ISSET(cmdp->iflags, E_C_FORCE) && !stat(fname, &sb)) { msgq_str(sp, M_ERR, fname, "137|%s exists, not written; use ! to override"); return (1); } /* Create with max permissions of rw-r--r--. */ if ((fd = open(fname, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) < 0) { msgq_str(sp, M_SYSERR, fname, "%s"); return (1); } if ((fp = fdopen(fd, "w")) == NULL) { sverrno = errno; (void)close(fd); goto e2; } if (seq_save(sp, fp, "abbreviate ", SEQ_ABBREV) || ferror(fp)) goto e1; if (seq_save(sp, fp, "map ", SEQ_COMMAND) || ferror(fp)) goto e1; if (seq_save(sp, fp, "map! ", SEQ_INPUT) || ferror(fp)) goto e1; if (opts_save(sp, fp) || ferror(fp)) goto e1; if (fclose(fp)) { sverrno = errno; goto e2; } msgq_str(sp, M_INFO, fname, "138|New exrc file: %s"); return (0); e1: sverrno = errno; (void)fclose(fp); e2: errno = sverrno; msgq_str(sp, M_SYSERR, fname, "%s"); return (1); }
/** * FIXME Verbose mode missing yet. */ static int do_list_contents(FILE *fp, char *out_f, int list_contents) { int rc; struct stat st; uint32_t d, crc32, size, compressed_size; float ratio = 0.0; z_stream strm; uint8_t in[4096]; uint8_t out[4096]; gz_header head; uint8_t extra[64 * 1024]; uint8_t comment[1024]; uint8_t name[1024]; int window_bits = 31; /* GZIP */ const char *mon[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; rc = fstat(fileno(fp), &st); if (rc != 0) return rc; memset(&strm, 0, sizeof(strm)); strm.avail_in = 0; strm.next_in = Z_NULL; rc = inflateInit2(&strm, window_bits); if (Z_OK != rc) return rc; strm.next_out = out; strm.avail_out = sizeof(out); strm.next_in = in; strm.avail_in = fread(in, 1, sizeof(in), fp); if (ferror(fp)) return Z_ERRNO; head.extra = extra; head.extra_len = 0; head.extra_max = sizeof(extra); head.comment = comment; head.comm_max = sizeof(comment); head.name = name; head.name_max = sizeof(name); rc = inflateGetHeader(&strm, &head); if (Z_OK != rc) { fprintf(stderr, "err: Cannot read gz header! rc=%d\n", rc); return rc; } rc = inflate(&strm, Z_BLOCK); if (Z_OK != rc) { fprintf(stderr, "err: inflate(Z_BLOCK) failed rc=%d\n", rc); return rc; } if (head.done == 0) { fprintf(stderr, "err: gzip header not entirely decoded! " "total_in=%ld total_out=%ld head.done=%d\n", strm.total_in, strm.total_out, head.done); return Z_DATA_ERROR; } rc = fseek(fp, st.st_size - 2 * sizeof(uint32_t), SEEK_SET); if (rc != 0) return rc; rc = fread(&d, sizeof(d), 1, fp); if (rc != 1) return -1; crc32 = __le32_to_cpu(d); rc = fread(&d, sizeof(d), 1, fp); if (rc != 1) return -1; size = __le32_to_cpu(d); /* Compressed size is total file size reduced by gzip header size and 8 bytes for the gzip trailer. */ compressed_size = st.st_size - strm.total_in - 8; if (size) ratio = 100 - (float)compressed_size * 100 / size; if (!verbose) { fprintf(stderr, " compressed uncompressed ratio " "uncompressed_name\n" "%19lld %19d %2.2f%% %s\n", (long long)st.st_size, size, ratio, out_f); } else { time_t t = time(NULL); struct tm *tm = localtime(&t); /* (const time_t *)&head.time */ fprintf(stderr, "method crc date time " "compressed uncompressed ratio " "uncompressed_name\n" "%s %x %s %2d %d:%d %19lld %19d %2.2f%% %s\n", "defla", crc32, mon[tm->tm_mon], tm->tm_mday, tm->tm_hour, tm->tm_min, (long long)st.st_size, size, ratio, out_f); } if (list_contents > 1) do_print_gzip_hdr(&head, stderr); return 0; }
int main(int argc, char **argv) { isc_result_t result; isc_mem_t *mctx = NULL; isc_log_t *lctx = NULL; isc_logconfig_t *lcfg = NULL; isc_logdestination_t destination; cfg_parser_t *pctx = NULL; cfg_obj_t *cfg = NULL; cfg_type_t *type = NULL; isc_boolean_t grammar = ISC_FALSE; isc_boolean_t memstats = ISC_FALSE; char *filename = NULL; RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS); result = isc_log_create(mctx, &lctx, &lcfg); check_result(result, "isc_log_create()"); isc_log_setcontext(lctx); /* * Create and install the default channel. */ destination.file.stream = stderr; destination.file.name = NULL; destination.file.versions = ISC_LOG_ROLLNEVER; destination.file.maximum_size = 0; result = isc_log_createchannel(lcfg, "_default", ISC_LOG_TOFILEDESC, ISC_LOG_DYNAMIC, &destination, ISC_LOG_PRINTTIME); check_result(result, "isc_log_createchannel()"); result = isc_log_usechannel(lcfg, "_default", NULL, NULL); check_result(result, "isc_log_usechannel()"); /* * Set the initial debug level. */ isc_log_setdebuglevel(lctx, 2); if (argc < 3) usage(); while (argc > 1) { if (strcmp(argv[1], "--grammar") == 0) { grammar = ISC_TRUE; } else if (strcmp(argv[1], "--memstats") == 0) { memstats = ISC_TRUE; } else if (strcmp(argv[1], "--named") == 0) { type = &cfg_type_namedconf; } else if (strcmp(argv[1], "--rndc") == 0) { type = &cfg_type_rndcconf; } else if (argv[1][0] == '-') { usage(); } else { filename = argv[1]; } argv++, argc--; } if (grammar) { if (type == NULL) usage(); cfg_print_grammar(type, output, NULL); } else { if (type == NULL || filename == NULL) usage(); RUNTIME_CHECK(cfg_parser_create(mctx, lctx, &pctx) == ISC_R_SUCCESS); result = cfg_parse_file(pctx, filename, type, &cfg); fprintf(stderr, "read config: %s\n", isc_result_totext(result)); if (result != ISC_R_SUCCESS) exit(1); cfg_print(cfg, output, NULL); cfg_obj_destroy(pctx, &cfg); cfg_parser_destroy(&pctx); } isc_log_destroy(&lctx); if (memstats) isc_mem_stats(mctx, stderr); isc_mem_destroy(&mctx); fflush(stdout); if (ferror(stdout)) { fprintf(stderr, "write error\n"); return (1); } else return (0); }
/* compress or decompress from stdin to stdout */ int main(int argc, char **argv) { int rc = Z_OK; bool compress = true; int list_contents = 0; bool force = false; bool quiet __attribute__((unused)) = false; int window_bits = 31; /* GZIP */ int level = Z_DEFAULT_COMPRESSION; char *prog = basename(argv[0]); const char *in_f = NULL; char out_f[PATH_MAX]; FILE *i_fp = stdin; FILE *o_fp = NULL; const char *suffix = "gz"; int force_software = 0; int cpu = -1; unsigned char *in = NULL; unsigned char *out = NULL; z_stream strm; const char *name = NULL; char *comment = NULL; const char *extra_fname = NULL; uint8_t *extra = NULL; int extra_len = 0; struct stat s; const char *accel = "GENWQE"; const char *accel_env = getenv("ZLIB_ACCELERATOR"); int card_no = 0; const char *card_no_env = getenv("ZLIB_CARD"); /* Use environment variables as defaults. Command line options can than overrule this. */ if (accel_env != NULL) accel = accel_env; if (card_no_env != NULL) card_no = atoi(card_no_env); /* avoid end-of-line conversions */ SET_BINARY_MODE(stdin); SET_BINARY_MODE(stdout); if (strstr(prog, "gunzip") != 0) compress = false; while (1) { int ch; int option_index = 0; static struct option long_options[] = { { "stdout", no_argument, NULL, 'c' }, { "decompress", no_argument, NULL, 'd' }, { "force", no_argument, NULL, 'f' }, { "help", no_argument, NULL, 'h' }, /* list */ { "list", no_argument, NULL, 'l' }, { "license", no_argument, NULL, 'L' }, { "suffix", required_argument, NULL, 'S' }, { "verbose", no_argument, NULL, 'v' }, { "version", no_argument, NULL, 'V' }, { "fast", no_argument, NULL, '1' }, { "best", no_argument, NULL, '9' }, /* our own options */ { "cpu", required_argument, NULL, 'X' }, { "accelerator-type", required_argument, NULL, 'A' }, { "card_no", required_argument, NULL, 'B' }, { "software", no_argument, NULL, 's' }, { "extra", required_argument, NULL, 'E' }, { "name", required_argument, NULL, 'N' }, { "comment", required_argument, NULL, 'C' }, { "i_bufsize", required_argument, NULL, 'i' }, { "o_bufsize", required_argument, NULL, 'o' }, { 0, no_argument, NULL, 0 }, }; ch = getopt_long(argc, argv, "E:N:C:cdfqhlLsS:vV123456789?i:o:X:A:B:", long_options, &option_index); if (ch == -1) /* all params processed ? */ break; switch (ch) { case 'X': cpu = strtoul(optarg, NULL, 0); break; case 'A': accel = optarg; break; case 'B': card_no = strtol(optarg, (char **)NULL, 0); break; case 'E': extra_fname = optarg; break; case 'N': name = optarg; break; case 'C': comment = optarg; break; case 'd': compress = false; break; case 'f': force = true; break; case 'q': /* Currently does nothing, zless needs it */ quiet = true; break; case 'c': o_fp = stdout; break; case 'S': suffix = optarg; break; case 's': force_software = true; break; case 'l': list_contents++; break; case '1': level = Z_BEST_SPEED; break; case '2': level = 2; break; case '3': level = 3; break; case '4': level = 4; break; case '5': level = 5; break; case '6': level = 6; break; case '7': level = 7; break; case '8': level = 8; break; case '9': level = Z_BEST_COMPRESSION; break; case 'v': verbose++; break; case 'V': fprintf(stdout, "%s\n", version); exit(EXIT_SUCCESS); break; case 'i': CHUNK_i = str_to_num(optarg); break; case 'o': CHUNK_o = str_to_num(optarg); break; case 'L': userinfo(stdout, prog, version); exit(EXIT_SUCCESS); break; case 'h': case '?': usage(stdout, prog, argc, argv); exit(EXIT_SUCCESS); break; } } if (cpu != -1) pin_to_cpu(cpu); if (force_software) { zlib_set_inflate_impl(ZLIB_SW_IMPL); zlib_set_deflate_impl(ZLIB_SW_IMPL); } else { zlib_set_accelerator(accel, card_no); zlib_set_inflate_impl(ZLIB_HW_IMPL); zlib_set_deflate_impl(ZLIB_HW_IMPL); } /* FIXME loop over this ... */ if (optind < argc) { /* input file */ in_f = argv[optind++]; i_fp = fopen(in_f, "r"); if (!i_fp) { pr_err("%s\n", strerror(errno)); print_args(stderr, argc, argv); exit(EX_ERRNO); } rc = lstat(in_f, &s); if ((rc == 0) && S_ISLNK(s.st_mode)) { pr_err("%s: Too many levels of symbolic links\n", in_f); exit(EXIT_FAILURE); } if (list_contents) { rc = strip_ending(out_f, in_f, PATH_MAX, suffix); if (rc < 0) { pr_err("No .%s file!\n", suffix); print_args(stderr, argc, argv); exit(EXIT_FAILURE); } rc = do_list_contents(i_fp, out_f, list_contents); if (rc != 0) { pr_err("Unable to list contents.\n"); print_args(stderr, argc, argv); exit(EXIT_FAILURE); } fclose(i_fp); exit(EXIT_SUCCESS); } } if (in_f == NULL) o_fp = stdout; /* should not be a terminal! */ if (o_fp == NULL) { if (compress) snprintf(out_f, PATH_MAX, "%s.%s", in_f, suffix); else { rc = strip_ending(out_f, in_f, PATH_MAX, suffix); if (rc < 0) { pr_err("No .%s file!\n", suffix); print_args(stderr, argc, argv); exit(EXIT_FAILURE); } } rc = stat(out_f, &s); if (!force && (rc == 0)) { pr_err("File %s already exists!\n", out_f); print_args(stderr, argc, argv); exit(EX_ERRNO); } o_fp = fopen(out_f, "w+"); if (!o_fp) { pr_err("Cannot open output file %s: %s\n", out_f, strerror(errno)); print_args(stderr, argc, argv); exit(EX_ERRNO); } /* get mode settings for existing file and ... */ rc = fstat(fileno(i_fp), &s); if (rc == 0) { rc = fchmod(fileno(o_fp), s.st_mode); if (rc != 0) { pr_err("Cannot set mode %s: %s\n", out_f, strerror(errno)); exit(EX_ERRNO); } } else /* else ignore ... */ pr_err("Cannot set mode %s: %s\n", out_f, strerror(errno)); /* If output does not go to stdout and a filename is given, set it */ if (name == NULL) name = in_f; } if (isatty(fileno(o_fp))) { pr_err("Output must not be a terminal!\n"); print_args(stderr, argc, argv); exit(EXIT_FAILURE); } if (optind != argc) { /* now it must fit */ usage(stderr, prog, argc, argv); exit(EXIT_FAILURE); } in = malloc(CHUNK_i); /* This is the bigger Buffer by default */ if (NULL == in) { pr_err("%s\n", strerror(errno)); print_args(stderr, argc, argv); exit(EXIT_FAILURE); } out = malloc(CHUNK_o); /* This is the smaller Buffer by default */ if (NULL == out) { pr_err("%s\n", strerror(errno)); print_args(stderr, argc, argv); exit(EXIT_FAILURE); } /* allocate inflate state */ memset(&strm, 0, sizeof(strm)); strm.zalloc = Z_NULL; strm.zfree = Z_NULL; strm.opaque = Z_NULL; if (compress) { gz_header head; struct timeval tv; if (extra_fname) { extra_len = file_size(extra_fname); if (extra_len <= 0) { rc = extra_len; goto err_out; } extra = malloc(extra_len); if (extra == NULL) { rc = -ENOMEM; goto err_out; } rc = file_read(extra_fname, extra, extra_len); if (rc != 1) { fprintf(stderr, "err: Unable to read extra " "data rc=%d\n", rc); free(extra); goto err_out; } hexdump(stderr, extra, extra_len); } /* --------------- DEFALTE ----------------- */ rc = deflateInit2(&strm, level, Z_DEFLATED, window_bits, 8, Z_DEFAULT_STRATEGY); if (Z_OK != rc) goto err_out; memset(&head, 0, sizeof(head)); gettimeofday(&tv, NULL); head.time = tv.tv_sec; head.os = 0x03; if (extra != NULL) { head.extra = extra; head.extra_len = extra_len; head.extra_max = extra_len; } if (comment != NULL) { head.comment = (Bytef *)comment; head.comm_max = strlen(comment) + 1; } if (name != NULL) { head.name = (Bytef *)name; head.name_max = strlen(name) + 1; } rc = deflateSetHeader(&strm, &head); if (Z_OK != rc) { fprintf(stderr, "err: Cannot set gz header! rc=%d\n", rc); deflateEnd(&strm); goto err_out; } /* do compression if no arguments */ rc = def(i_fp, o_fp, &strm, in, out); if (Z_OK != rc) zerr(rc); if (extra != NULL) free(extra); deflateEnd(&strm); } else { /* --------------- INFALTE ----------------- */ strm.avail_in = 0; strm.next_in = Z_NULL; rc = inflateInit2(&strm, window_bits); if (Z_OK != rc) goto err_out; do { rc = inf(i_fp, o_fp, &strm, in, out); if (Z_STREAM_END != rc) { zerr(rc); break; } } while (!feof(i_fp) && !ferror(i_fp)); inflateEnd(&strm); } err_out: /* Delete the input file, only if input is not stdin and if output is not stdout */ if ((rc == EXIT_SUCCESS) && (i_fp != stdin) && (o_fp != stdout)) { rc = unlink(in_f); if (rc != 0) { pr_err("%s\n", strerror(errno)); print_args(stderr, argc, argv); exit(EXIT_FAILURE); } } fclose(i_fp); fclose(o_fp); free(in); free(out); exit(rc); }
static profile_param_info_t *ParseParams (char *profile_datadir) { struct stat stat_buf; char line[512], path[MAXPATHLEN], *p, *q, *s; profile_param_info_t *profile_list; profile_param_info_t **list = &profile_list; profile_list = NULL; while ( ( fgets(line, 512, stdin) != NULL )) { LogInfo("Process line '%s'\n", line); line[511] = '\0'; if ( *list == NULL ) *list = (profile_param_info_t *)malloc(sizeof(profile_param_info_t)); // else we come from a continue statement with illegal data - overwrite if ( !*list) { LogError("malloc() error in %s line %d: %s\n", __FILE__, __LINE__, strerror(errno) ); return NULL; } (*list)->next = NULL; (*list)->profilegroup = NULL; (*list)->profilename = NULL; (*list)->channelname = NULL; (*list)->channel_sourcelist = NULL; (*list)->profiletype = 0; // delete '\n' at the end of line // format of stdin config line: // <profilegroup>#<profilename>#<profiletype>#<channelname>#<channel_sourcelist> p = strchr(line, '\n'); if ( p ) *p = '\0'; q = line; p = strchr(q, '#'); if ( p ) *p = '\0'; s = line; // savety check: if no separator found loop to next line if ( !p ) { LogError("Incomplete line - channel skipped.\n"); continue; } q = p; q++; p = strchr(q, '#'); if ( p ) *p = '\0'; snprintf(path, MAXPATHLEN-1, "%s/%s/%s", profile_datadir, s, q); path[MAXPATHLEN-1] = '\0'; if ( stat(path, &stat_buf) || !S_ISDIR(stat_buf.st_mode) ) { LogError("profile '%s' not found in group %s. Skipped.\n", q, s); continue; } (*list)->profilegroup = strdup(s); (*list)->profilename = strdup(q); // savety check: if no separator found loop to next line if ( !p ) { LogError("Incomplete line - channel skipped.\n"); continue; } q = p; q++; p = strchr(q, '#'); if ( p ) *p = '\0'; s = q; while ( *s ) { if ( *s < '0' || *s > '9' ) { LogError("Not a valid number: %s\n", q); s = NULL; break; } s++; } if ( s == NULL ) continue; (*list)->profiletype = (int)strtol(q, (char **)NULL, 10); // savety check: if no separator found loop to next line if ( !p ) { LogError("Incomplete line - channel skipped.\n"); continue; } q = p; q++; p = strchr(q, '#'); if ( p ) *p = '\0'; snprintf(path, MAXPATHLEN-1, "%s/%s/%s/%s", profile_datadir, (*list)->profilegroup, (*list)->profilename, q); path[MAXPATHLEN-1] = '\0'; if ( stat(path, &stat_buf) || !S_ISDIR(stat_buf.st_mode) ) { LogError("channel '%s' in profile '%s' not found. Skipped.\n", q, (*list)->profilename); continue; } (*list)->channelname = strdup(q); if ( !p ) { LogError("Incomplete line - Skipped.\n"); continue; } q = p; q++; p = strchr(q, '#'); if ( p ) *p = '\0'; // Skip leading '| chars while ( *q && *q == '|' ) { q++; } s = q; // if q is already empty ( '\0' ) loop is not processed while ( *s ) { // as s[0] is not '\0' s[1] may be '\0' but still valid and in range if ( s[0] == '|' && s[1] == '|' ) { char *t = s; t++; while ( *t ) { // delete this empty channel name t[0] = t[1]; t++; } } else s++; } // we have no doublicate '|' here any more // check if last char is an extra '|' if ( *q && (q[strlen(q)-1] == '|') ) q[strlen(q)-1] = '\0'; if ( *q && (strcmp(q, "*") != 0) ) (*list)->channel_sourcelist = strdup(q); list = &((*list)->next); } if ( *list != NULL ) { free(*list); *list = NULL; } if ( ferror(stdin) ) { LogError("fgets() error: %s", strerror(errno)); return NULL; } return profile_list; } // End of ParseParams
/********************************************************************** * * S i g n F i l e */ static int SignFile(FILE *outFile, FILE *inFile, CERTCertificate *cert) { int nb; char ibuf[4096], digestdata[32]; const SECHashObject *hashObj; void *hashcx; unsigned int len; SECItem digest; SEC_PKCS7ContentInfo *cinfo; SECStatus rv; if (outFile == NULL || inFile == NULL || cert == NULL) return -1; /* XXX probably want to extend interface to allow other hash algorithms */ hashObj = HASH_GetHashObject(HASH_AlgSHA1); hashcx = (*hashObj->create)(); if (hashcx == NULL) return -1; (*hashObj->begin)(hashcx); for (;;) { if (feof(inFile)) break; nb = fread(ibuf, 1, sizeof(ibuf), inFile); if (nb == 0) { if (ferror(inFile)) { PORT_SetError(SEC_ERROR_IO); (*hashObj->destroy)(hashcx, PR_TRUE); return -1; } /* eof */ break; } (*hashObj->update)(hashcx, (unsigned char *)ibuf, nb); } (*hashObj->end)(hashcx, (unsigned char *)digestdata, &len, 32); (*hashObj->destroy)(hashcx, PR_TRUE); digest.data = (unsigned char *)digestdata; digest.len = len; cinfo = SEC_PKCS7CreateSignedData(cert, certUsageObjectSigner, NULL, SEC_OID_SHA1, &digest, NULL, NULL); if (cinfo == NULL) return -1; rv = SEC_PKCS7IncludeCertChain(cinfo, NULL); if (rv != SECSuccess) { SEC_PKCS7DestroyContentInfo(cinfo); return -1; } if (no_time == 0) { rv = SEC_PKCS7AddSigningTime(cinfo); if (rv != SECSuccess) { /* don't check error */ } } rv = SEC_PKCS7Encode(cinfo, SignOut, outFile, NULL, NULL, &pwdata); SEC_PKCS7DestroyContentInfo(cinfo); if (rv != SECSuccess) return -1; return 0; }
/** @brief Set the icewm style. * * When icewm changes the style, it writes the new style to the ~/.icewm/theme * or $ICEWM_PRIVCFG/theme file and then restarts. The ~/.icewm/theme file * looks like: * * Theme="Penguins/default.theme" * #Theme="Airforce/default.theme" * ##Theme="Penguins/default.theme" * ###Theme="Pedestals/default.theme" * ####Theme="Penguins/default.theme" * #####Theme="Airforce/default.theme" * ######Theme="Archlinux/default.theme" * #######Theme="Airforce/default.theme" * ########Theme="Airforce/default.theme" * #########Theme="Airforce/default.theme" * ##########Theme="Penguins/default.theme" * * icewm cannot distinguish between system an user styles. The theme name * specifies a directory in the /usr/share/icewm/themes, ~/.icewm/themes or * $ICEWM_PRIVCFG/themes subdirectories. * * When xde-session runs, it sets the ICEWM_PRIVCFG environment variable. * xde-session and associated tools will always set this environment variable * before launching icewm. icewm respects this environment variable and no * special options are necessary when launching icewm. * * The default configuration directory when ICEWM_PRIVCFG is not specified is * ~/.icewm. The location of all other icewm configuration files are in this * directory. xde-session typically sets ICEWM_PRIVCFG to * $XDG_CONFIG_HOME/icewm. */ static void set_style_ICEWM() { FILE *f; struct stat st; char *stylefile, *themerc, *buf, *pos, *end, *line; int n, len; size_t read, total; if (!(stylefile = find_style_ICEWM())) { EPRINTF("cannot find style '%s'\n", options.style); goto no_stylefile; } free(stylefile); len = strlen(wm->pdir) + strlen("/theme") + 1; themerc = calloc(len, sizeof(*themerc)); snprintf(themerc, len, "%s/theme", wm->pdir); if (!(f = fopen(themerc, "r"))) { EPRINTF("%s: %s\n", themerc, strerror(errno)); goto no_themerc; } if (fstat(fileno(f), &st)) { EPRINTF("%s: %s\n", themerc, strerror(errno)); goto no_stat; } buf = calloc(st.st_size + 1, sizeof(*buf)); /* read entire file into buffer */ total = 0; while (total < st.st_size) { read = fread(buf + total, 1, st.st_size - total, f); total += read; if (total >= st.st_size) break; if (ferror(f)) { EPRINTF("%s: %s\n", themerc, strerror(errno)); goto no_buf; } if (feof(f)) break; } len = strlen(options.style) + strlen("Theme=\"\"") + 1; line = calloc(len, sizeof(*line)); snprintf(line, len, "Theme=\"%s\"", options.style); if (strncmp(buf, line, strlen(line)) == 0) { OPRINTF("style %s did not change\n", line); goto no_change; } if (options.dryrun) { } else { OPRINTF("writing new style %s\n", options.style); if (!(f = freopen(themerc, "w", f))) { EPRINTF("%s: %s\n", themerc, strerror(errno)); goto no_change; } fprintf(f, "Theme=\"%s\"\n", options.style); for (n = 0, pos = buf, end = buf + st.st_size; pos < end && n < 10; n++, pos = pos + strlen(pos) + 1) { *strchrnul(pos, '\n') = '\0'; fprintf(f, "#%s\n", pos); } if (options.reload) reload_style_ICEWM(); } no_change: free(line); no_buf: free(buf); no_stat: fclose(f); no_themerc: free(themerc); no_stylefile: return; }
gint32 Mono_Posix_Stdlib_ferror (void* stream) { return ferror (((FILE*) stream)); }