/* finishing... */ VOID fini_stride(INT32 code, VOID* v){ int i; UINT64 cum; if(interval_size == -1){ output_file_stride.open(mkfilename("stride_full_int"), ios::out|ios::trunc); } else{ output_file_stride.open(mkfilename("stride_phases_int"), ios::out|ios::app); } output_file_stride << numReadInstrsAnalyzed; /* local read distribution */ cum = 0; for(i = 0; i < MAX_DISTR; i++){ cum += localReadDistrib[i]; if( (i == 0) || (i == 8) || (i == 64) || (i == 512) || (i == 4096) || (i == 32768) || (i == 262144) ){ output_file_stride << " " << cum; } if(i == 262144) break; } /* global read distribution */ cum = 0; for(i = 0; i < MAX_DISTR; i++){ cum += globalReadDistrib[i]; if( (i == 0) || (i == 8) || (i == 64) || (i == 512) || (i == 4096) || (i == 32768) || (i == 262144) ){ output_file_stride << " " << cum; } if(i == 262144) break; } output_file_stride << " " << numWriteInstrsAnalyzed; /* local write distribution */ cum = 0; for(i = 0; i < MAX_DISTR; i++){ cum += localWriteDistrib[i]; if( (i == 0) || (i == 8) || (i == 64) || (i == 512) || (i == 4096) || (i == 32768) || (i == 262144) ){ output_file_stride << " " << cum; } if(i == 262144) break; } /* global write distribution */ cum = 0; for(i = 0; i < MAX_DISTR; i++){ cum += globalWriteDistrib[i]; if( (i == 0) || (i == 8) || (i == 64) || (i == 512) || (i == 4096) || (i == 32768) ){ output_file_stride << " " << cum; } if(i == 262144){ output_file_stride << " " << cum << endl; break; } } output_file_stride << "number of instructions: " << total_ins_count_for_hpc_alignment << endl; output_file_stride.close(); }
/* finishing... */ VOID fini_reg(INT32 code, VOID* v){ if(interval_size == -1){ output_file_reg.open(mkfilename("reg_full_int"), ios::out|ios::trunc); output_file_reg << total_ins_count; } else{ output_file_reg.open(mkfilename("reg_phases_int"), ios::out|ios::app); output_file_reg << interval_ins_count; } int i; UINT64 totNumOps = 0; UINT64 num; /* total number of operands */ for(i = 1; i < MAX_NUM_OPER; i++){ totNumOps += opCounts[i]*i; } output_file_reg << " " << totNumOps; // ** average degree of use ** num = 0; for(i = 0; i < MAX_REG_USE; i++){ num += regUseDistr[i]; } output_file_reg << " " << num; num = 0; for(i = 0; i < MAX_REG_USE; i++){ num += i * regUseDistr[i]; } output_file_reg << " " << num; // ** register dependency distributions ** num = 0; for(i = 0; i < MAX_COMM_DIST; i++){ num += regAgeDistr[i]; } output_file_reg << " " << num; num = 0; for(i = 0; i < MAX_COMM_DIST; i++){ num += regAgeDistr[i]; if( (i == 1) || (i == 2) || (i == 4) || (i == 8) || (i == 16) || (i == 32) || (i == 64)){ output_file_reg << " " << num; } } output_file_reg << endl; output_file_reg << "number of instructions: " << total_ins_count_for_hpc_alignment << endl; output_file_reg.close(); }
/* initializing */ void init_reg(){ int i; /* initializing total instruction counts is done in mica.cpp */ /* allocate memory */ opCounts = (UINT64*) checked_malloc(MAX_NUM_OPER * sizeof(UINT64)); regRef = (BOOL*) checked_malloc(MAX_NUM_REGS * sizeof(BOOL)); PCTable = (INT64*) checked_malloc(MAX_NUM_REGS * sizeof(INT64)); regUseCnt = (INT64*) checked_malloc(MAX_NUM_REGS * sizeof(INT64)); regUseDistr = (INT64*) checked_malloc(MAX_REG_USE * sizeof(INT64)); regAgeDistr = (INT64*) checked_malloc(MAX_COMM_DIST * sizeof(INT64)); /* initialize */ for(i = 0; i < MAX_NUM_OPER; i++){ opCounts[i] = 0; } for(i = 0; i < MAX_NUM_REGS; i++){ regRef[i] = false; PCTable[i] = 0; regUseCnt[i] = 0; } for(i = 0; i < MAX_REG_USE; i++){ regUseDistr[i] = 0; } for(i = 0; i < MAX_COMM_DIST; i++){ regAgeDistr[i] = 0; } if(interval_size != -1){ output_file_reg.open(mkfilename("reg_phases_int"), ios::out|ios::trunc); output_file_reg.close(); } }
unsigned long getSeq() { char seqfile[FILENAME_MAX]; FILE *stream; unsigned long seq = 0; mkfilename(seqfile, E_spooldir, SFILENAME); if ((stream = FOPEN(seqfile, "r+", IMAGE_MODE)) == nil(FILE)) { printerr( seqfile ); if ((stream = FOPEN(seqfile, "w", IMAGE_MODE)) == nil(FILE)) { printerr( seqfile ); panic(); } } else { if ( fread( &seq, sizeof seq, 1, stream ) != 1 ) printerr( seqfile ); } /*--------------------------------------------------------------------*/ /* Generate a new seed for our sequence if we can't read one */ /*--------------------------------------------------------------------*/ if ( ! seq++ ) { seq = ((unsigned long) getpid()) % 10000000; /* Start number small, semi-unique*/ printmsg(0,"Resetting sequence number to %lu (0x%08lx)", seq, seq ); } /*--------------------------------------------------------------------*/ /* Update sequence number */ /*--------------------------------------------------------------------*/ rewind( stream ); if ((fwrite( &seq, sizeof seq, 1, stream ) != 1) || fclose(stream)) { printerr( seqfile ); panic(); } #ifdef UDEBUG printmsg(8, "getseq: seq#=%ld", seq); #endif return seq; } /* getseq */
void RollingFileAppender::doRotate() { closeFile(); // ignore unlink- and rename-errors. In case of failure the // original file is reopened std::string newfilename = mkfilename(_maxbackupindex); ::unlink(newfilename.c_str()); for (unsigned idx = _maxbackupindex; idx > 0; --idx) { std::string oldfilename = mkfilename(idx - 1); ::rename(oldfilename.c_str(), newfilename.c_str()); newfilename = oldfilename; } ::rename(fname().c_str(), newfilename.c_str()); openFile(); _fsize = 0; }
VOID stride_instr_interval_output(){ int i; UINT64 cum; output_file_stride.open(mkfilename("stride_phases_int"), ios::out|ios::app); output_file_stride << numReadInstrsAnalyzed; /* local read distribution */ cum = 0; for(i = 0; i < MAX_DISTR; i++){ cum += localReadDistrib[i]; if( (i == 0) || (i == 8) || (i == 64) || (i == 512) || (i == 4096) || (i == 32768) || (i == 262144) ){ output_file_stride << " " << cum; } if(i == 262144) break; } /* global read distribution */ cum = 0; for(i = 0; i < MAX_DISTR; i++){ cum += globalReadDistrib[i]; if( (i == 0) || (i == 8) || (i == 64) || (i == 512) || (i == 4096) || (i == 32768) || (i == 262144) ){ output_file_stride << " " << cum; } if(i == 262144) break; } output_file_stride << " " << numWriteInstrsAnalyzed; /* local write distribution */ cum = 0; for(i = 0; i < MAX_DISTR; i++){ cum += localWriteDistrib[i]; if( (i == 0) || (i == 8) || (i == 64) || (i == 512) || (i == 4096) || (i == 32768) || (i == 262144) ){ output_file_stride << " " << cum; } if(i == 262144) break; } /* global write distribution */ cum = 0; for(i = 0; i < MAX_DISTR; i++){ cum += globalWriteDistrib[i]; if( (i == 0) || (i == 8) || (i == 64) || (i == 512) || (i == 4096) || (i == 32768) ){ output_file_stride << " " << cum; } if(i == 262144){ output_file_stride << " " << cum << endl; break; } } output_file_stride.close(); }
void LoggerImpl::doRotate() { outfile.clear(); outfile.close(); // ignore unlink- and rename-errors. In case of failure the // original file is reopened std::string newfilename = mkfilename(maxbackupindex); ::unlink(newfilename.c_str()); for (unsigned idx = maxbackupindex; idx > 0; --idx) { std::string oldfilename = mkfilename(idx - 1); ::rename(oldfilename.c_str(), newfilename.c_str()); newfilename = oldfilename; } ::rename(fname.c_str(), newfilename.c_str()); outfile.open(fname.c_str(), std::ios::out | std::ios::app); counter.resetCount(outfile.tellp()); }
/* initializing */ void init_stride(){ int i; /* initializing total instruction counts is done in mica.cpp */ /* initial sizes */ numRead = 1024; numWrite = 1024; /* allocate memory */ instrRead = (ADDRINT*) checked_malloc(numRead * sizeof(ADDRINT)); instrWrite = (ADDRINT*) checked_malloc(numWrite * sizeof(ADDRINT)); /* initialize */ readIndex = 1; writeIndex = 1; for (i = 0; i < (int)numRead; i++) instrRead[i] = 0; for (i = 0; i < (int)numWrite; i++) instrWrite[i] = 0; lastReadAddr = 0; lastWriteAddr = 0; for (i = 0; i < MAX_DISTR; i++) { localReadDistrib[i] = 0; localWriteDistrib[i] = 0; globalReadDistrib[i] = 0; globalWriteDistrib[i] = 0; } numInstrsAnalyzed = 0; numReadInstrsAnalyzed = 0; numWriteInstrsAnalyzed = 0; indices_memRead_size = 1024; indices_memRead = (ADDRINT*) checked_malloc(indices_memRead_size*sizeof(ADDRINT)); for (i = 0; i < (int)indices_memRead_size; i++) indices_memRead[i] = 0; indices_memWrite_size = 1024; indices_memWrite = (ADDRINT*) checked_malloc(indices_memWrite_size*sizeof(ADDRINT)); for (i = 0; i < (int)indices_memWrite_size; i++) indices_memWrite[i] = 0; if(interval_size != -1){ output_file_stride.open(mkfilename("stride_phases_int"), ios::out|ios::trunc); output_file_stride.close(); } }
VOID reg_instr_interval_output(){ int i; output_file_reg.open(mkfilename("reg_phases_int"), ios::out|ios::app); UINT64 totNumOps = 0; UINT64 num; /* total number of operands */ for(i = 1; i < MAX_NUM_OPER; i++){ totNumOps += opCounts[i]*i; } output_file_reg << interval_size << " " << totNumOps; /* average degree of use */ num = 0; for(i = 0; i < MAX_REG_USE; i++){ num += regUseDistr[i]; } output_file_reg << " " << num; num = 0; for(i = 0; i < MAX_REG_USE; i++){ num += i * regUseDistr[i]; } output_file_reg << " " << num; /* register dependency distributions */ num = 0; for(i = 0; i < MAX_COMM_DIST; i++){ num += regAgeDistr[i]; } output_file_reg << " " << num; num = 0; for(i = 0; i < MAX_COMM_DIST; i++){ num += regAgeDistr[i]; if( (i == 1) || (i == 2) || (i == 4) || (i == 8) || (i == 16) || (i == 32) || (i == 64)){ output_file_reg << " " << num; } } output_file_reg << endl; output_file_reg.close(); }
char *mkmailbox(char *buf, const char *userid) { KWBoolean append = (KWBoolean) (( E_mailext != NULL ) ? KWTrue : KWFalse); if (buf == NULL) /* Do we need to allocate buffer? */ { buf = malloc( FILENAME_MAX ); checkref(buf); } /* if */ if (bflag[F_DIRECT]) { sprintf(buf,"%s%c%.8s%c%s", E_maildir, SEPCHAR, userid, SEPCHAR,"newmail"); } /* if (bflag[F_DIRECT]) */ else { char tuser[FILENAME_MAX]; strcpy( tuser, userid ); if (strchr(userid, '.') == NULL ) tuser[8] = '\0'; /* Auto-truncate mbox name */ else append = KWFalse; mkfilename(buf, E_maildir, tuser); } /* else */ /*--------------------------------------------------------------------*/ /* If we need a mailbox extension, add one */ /*--------------------------------------------------------------------*/ if ( append ) strcat( strcat(buf,".") , E_mailext ); return buf; } /* mkmailbox */
static void InitAlias( void ) { char buf[BUFSIZ]; int subscript = -1; size_t maxmimumAliases = 64; KWBoolean inAlias = KWFalse; FILE *stream; long here; /*--------------------------------------------------------------------*/ /* Build the file name and try to open the file */ /*--------------------------------------------------------------------*/ mkfilename( buf, E_confdir, "aliases" ); SysAliases = newstr( buf ); stream = FOPEN( SysAliases , "r", TEXT_MODE ); if ( stream == NULL ) { if (debuglevel > 1) printerr( SysAliases ); return; } /* if */ /*--------------------------------------------------------------------*/ /* The file is open, allocate a table */ /*--------------------------------------------------------------------*/ aliasTable = malloc( sizeof *aliasTable * maxmimumAliases ); checkref(aliasTable); here = ftell( stream ); /* Remember location in file */ /*--------------------------------------------------------------------*/ /* Begin loop to process names */ /*--------------------------------------------------------------------*/ while (fgets( buf , BUFSIZ , stream ) != NULL ) { char *s = buf; /*--------------------------------------------------------------------*/ /* Ignore comments, lines that begin with whitespace, and empty */ /* lines */ /*--------------------------------------------------------------------*/ while( *s && ! isgraph( *s )) s++; if (*s == '#') { /* Comment, no operation */ } else if ( ! *s ) /* Empty line? */ { /* Yes --> 'tis end of alias */ if ( inAlias ) { inAlias = KWFalse; if (aliasTable[subscript].start == -1 ) printmsg(0,"%s: Invalid alias %s, no data defined!", SysAliases, aliasTable[subscript].alias ); else aliasTable[subscript].end = here; } } /* if ( ! *s ) */ else if (inAlias) { if (aliasTable[subscript].start == -1 ) aliasTable[subscript].start = here + (s - buf); } else { /* Start of a new alias */ char *colon = strchr( s, ':' ); if (s != buf ) printmsg(0,"%s: Error aliases must begin in column 1", SysAliases ); if (colon == NULL ) { printmsg(0,"%s: No colon after alias %s", SysAliases, s); continue; } if ( subscript+2 == (int) maxmimumAliases ) { maxmimumAliases *= 2; aliasTable = realloc( aliasTable, maxmimumAliases * sizeof *aliasTable ); checkref( aliasTable ); } *colon = '\0'; /* Terminate the name */ aliasTable[++subscript].alias = newstr(strtok(s,WHITESPACE)); /* Save name of alias */ s = strtok( colon+1, WHITESPACE); /* Find next token */ if ((s == NULL) || (*s == '#')) /* Any alias on same? */ aliasTable[subscript].start = -1; /* No--> Look for it later */ else aliasTable[subscript].start = here + ( s - buf ); aliasTable[subscript].end = -1; aliasTable[subscript].recurse = KWFalse; inAlias = KWTrue; } /* if */ here = ftell( stream ); /* Remember start of next line */ } /* while */ /*--------------------------------------------------------------------*/ /* Clean up and return to caller */ /*--------------------------------------------------------------------*/ if ( inAlias ) aliasTable[subscript].end = LONG_MAX; aliases = (size_t) subscript + 1; if ( aliases == 0 ) free( aliasTable ); else { aliasTable = realloc( aliasTable, aliases * sizeof *aliasTable ); checkref(aliasTable); } printmsg(2,"InitAlias: Loaded %d system aliases from %s", aliases, SysAliases); fclose( stream ); } /* InitAlias */
//--------------------------------------------------------------------------- // mode & 1 = test only, don't create dirs QString TSatScript::getcommand(QString script, QStringList *args, bool *error, int mode) { QString rc, arg; QString out_file, frames_dir, frames_ext; QString baseband_dir, baseband_ext; int i, index, len; *error = true; if(script.isEmpty()) return "Error: No script file!"; #if 0 QFileInfo fi(script); if(!fi.exists()) return "Error: File not found: " + script; #endif if(!args->count()) return "Error: No arguments: " + script; *error = false; rc = script; assign_constants(); for(i=0; i<args->count(); i++) { arg = args->at(i); if(arg.contains("~")) arg.replace("~", QDir::homePath()); arg = parse_argument(arg, error, mode); arg = arg.trimmed(); if(arg.isEmpty()) continue; if(*error) { rc += " " + arg; rc += "\n\nError!"; return rc; } index = getcommand_index(arg); if(index < 0) { rc += " " + arg; continue; } len = commands->at(index).length() + 1; // qDebug("\narg: %s, [%s:%d]\n", arg.toStdString().c_str(), __FILE__, __LINE__); switch(index) { case SS_CMD_OUT_FILE: { out_file = arg.remove(0, len); out_file = out_file.trimmed(); } break; case SS_CMD_BASEBAND_DIR: { //qDebug("\nbaseband dir arg: %s, [%s:%d]", arg.toStdString().c_str(), __FILE__, __LINE__); baseband_dir = arg.remove(0, len); baseband_dir = baseband_dir.trimmed(); //qDebug("baseband dir: %s, [%s:%d]", baseband_dir.toStdString().c_str(), __FILE__, __LINE__); // remove the trailing slash if(baseband_dir.endsWith('/') || baseband_dir.endsWith('\\')) baseband_dir.remove(baseband_dir.length() - 1, 1); //qDebug("baseband dir: %s, [%s:%d]\n", baseband_dir.toStdString().c_str(), __FILE__, __LINE__); } break; case SS_CMD_BASEBAND_EXT: { baseband_ext = arg.remove(0, len); baseband_ext = baseband_ext.trimmed(); } break; case SS_CMD_FRAMES_DIR: { frames_dir = arg.remove(0, len); frames_dir = frames_dir.trimmed(); // remove the trailing slash if(frames_dir.endsWith('/') || frames_dir.endsWith('\\')) frames_dir.remove(frames_dir.length() - 1, 1); } break; case SS_CMD_FRAMES_EXT: { frames_ext = arg.remove(0, len); frames_ext = frames_ext.trimmed(); } break; default: continue; } } free_private(); #if 0 // TODO: add no-outfile option if(out_file.isEmpty()) { *error = true; rc += "\n\nError: No out-file"; return rc; } #endif if(!frames_dir.isEmpty() && !frames_ext.isEmpty()) _frames_filename = mkfilename(frames_dir, out_file, frames_ext); if(!baseband_dir.isEmpty() && !baseband_ext.isEmpty()) _baseband_filename = mkfilename(baseband_dir, out_file, baseband_ext); if(!_frames_filename.isEmpty()) rc += " --frames-file " + _frames_filename; if(!_baseband_filename.isEmpty()) rc += " --baseband-file " + _baseband_filename; #if 0 qDebug("frames file: %s:%d", _frames_filename.toStdString().c_str(), __LINE__); qDebug("baseband file: %s:%d", _baseband_filename.toStdString().c_str(), __LINE__); #endif return rc; }
void openlog(const char *log) { char *newLogName; FILE *stream = NULL; int saveDebuglevel = debuglevel; /*--------------------------------------------------------------------*/ /* Housekeeping */ /*--------------------------------------------------------------------*/ if (E_logdir == NULL) /* We DID call configure, didn't we? */ panic(); /* Ooopps --> I guess not. */ MKDIR(E_logdir); /* Make sure directory exists! */ /*--------------------------------------------------------------------*/ /* If we already had a log file, spin it off and copy it */ /*--------------------------------------------------------------------*/ if (permanentLogName != NULL) copylog(); /*--------------------------------------------------------------------*/ /* Create the final log name for later */ /*--------------------------------------------------------------------*/ if ((log != NULL) || (permanentLogName == NULL)) { char fname[FILENAME_MAX]; char *newName = (char*) ((log == NULL) ? compilen : log); char *period = strchr(newName, '.'); mkfilename(fname, E_logdir, newName); if (period == NULL) strcat(fname, ".log"); newLogName = newstr(fname); } else newLogName = permanentLogName; /*--------------------------------------------------------------------*/ /* Create temporary log file name */ /*--------------------------------------------------------------------*/ if (bflag[F_MULTITASK]) { char fname[FILENAME_MAX]; short retries = 15; while ((stream == NULL) && retries--) { mkdirfilename(fname, E_logdir, "log"); /* Get a temp log file name */ denormalize(fname); stream = fopen(fname, "a+"); if (stream == NULL) printerr(fname); } /* while */ currentLogName = newstr(fname); /* Save name we log to for posterity */ } /* if */ else { currentLogName = newLogName; /* Log directly to true log file */ stream = FOPEN(currentLogName , "a",TEXT_MODE); /* We append in case we are not in multitask mode and we do not want to clobber the real log! */ } /* else */ if (stream == NULL) { printmsg(0,"Cannot open any log file!"); panic(); } full_log_file_name = currentLogName; /* Tell printmsg() what our log file name is */ logfile = stream; /* And of the the stream itself */ /*--------------------------------------------------------------------*/ /* Request the copy function be run later */ /*--------------------------------------------------------------------*/ if (permanentLogName == NULL) atexit(copylog); /*--------------------------------------------------------------------*/ /* Tag the new log file with the current time and program date. */ /*--------------------------------------------------------------------*/ debuglevel = 0; /* Insure we time stamp */ printmsg(-1,"%s: %s %s (%s %s)", compilen, compilep, compilev, compiled, compilet); debuglevel = saveDebuglevel; if (ferror(logfile)) { printerr(currentLogName); panic(); } /*--------------------------------------------------------------------*/ /* Save log file name for latter reference and as a flag */ /* that we were called */ /*--------------------------------------------------------------------*/ permanentLogName = newLogName; } /* openlog */
FTSENT * fts_read(FTS *fts) { struct dirent *dirent; int rc; char *name; char buf[1024]; if(fts->ftsent.fts_path) { free(fts->ftsent.fts_path); fts->ftsent.fts_path = NULL; } if(fts->dname) { free(fts->dname); fts->dname = NULL; } again: dirent = readdir(fts->dir[fts->depth]); if(dirent == NULL) { char *newcwd = NULL; closedir(fts->dir[fts->depth]); fts->dir[fts->depth] = NULL; fts->depth--; if(fts->depth >= 0) { fts->dname = basename_a(fts->cwd); if(fts->dname == NULL) goto error; newcwd = dirname_a(fts->cwd); if(newcwd == NULL) goto error; } if(fts->cwd) free(fts->cwd); fts->cwd = NULL; if(fts->depth < 0) return NULL; rc = change_to_dir(fts->dir[fts->depth]); if(rc < 0) { free(newcwd); goto error; } fts->cwd = newcwd; name = fts->dname; fts->ftsent.fts_info = FTS_DP; goto done; } name = dirent->d_name; again2: rc = stat(name, &fts->stat); if(rc < 0) { fts->ftsent.fts_info = FTS_NS; goto error2; } if(S_ISDIR(fts->stat.st_mode)) { char *newcwd; DIR *dir; if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) goto again; if(fts->depth >= FTS_MAX_DEPTH) { errno = ENFILE; goto error; } dir = opendir(dirent->d_name); if(dir == NULL) { if(errno == EACCES) { fts->ftsent.fts_info = FTS_DNR; goto error2; } else goto error; } newcwd = mkfilename(fts->cwd, dirent->d_name); rc = change_to_dir(dir); if(rc < 0) { free(newcwd); goto error; } free(fts->cwd); fts->cwd = newcwd; fts->ftsent.fts_info = FTS_D; fts->depth++; fts->dir[fts->depth] = dir; goto done; } else if(S_ISREG(fts->stat.st_mode)) { fts->ftsent.fts_info = FTS_F; goto done; #ifdef S_ISLNK } else if(S_ISLNK(fts->stat.st_mode)) { int rc; rc = readlink(name, buf, 1024); if(rc < 0) goto error; if(rc >= 1023) { errno = ENAMETOOLONG; goto error; } buf[rc] = '\0'; name = buf; if(access(buf, F_OK) >= 0) goto again2; fts->ftsent.fts_info = FTS_SLNONE; goto done; #endif } else { fts->ftsent.fts_info = FTS_DEFAULT; goto done; } done: if(fts->cwd == NULL) fts->cwd = getcwd_a(); if(fts->cwd == NULL) goto error; fts->ftsent.fts_path = mkfilename(fts->cwd, name); if(fts->ftsent.fts_path == NULL) goto error; fts->ftsent.fts_accpath = name; fts->ftsent.fts_statp = &fts->stat; return &fts->ftsent; error: fts->ftsent.fts_info = FTS_ERR; error2: fts->ftsent.fts_errno = errno; return &fts->ftsent; }
KWBoolean init_sys( void ) { FILE *sysFileStream = NULL; char sysFileName[ FILENAME_MAX ]; char line[ LINESIZ ]; char *t; char buf[ INITSIZ ]; KWBoolean wantMore = KWTrue; KWBoolean success = KWTrue; mkfilename(sysFileName, E_confdir, "SYS"); /*--------------------------------------------------------------------*/ /* Generate a new SYS file if we need to */ /*--------------------------------------------------------------------*/ if ( stater( sysFileName, 0 ) == -1 ) bootStrap( sysFileName ); sysFileStream = fopen(sysFileName, "rb"); if ( sysFileStream == NULL ) { printerr(sysFileName); panic(); } printmsg(3, "init_sys: reading system file %s", sysFileName); memset(buf, 0, INITSIZ); while (fgets(line, LINESIZ, sysFileStream) != NULL) { /*--------------------------------------------------------------------*/ /* Trim trailing spaces and cr/lf. (Prevents empty lines in */ /* the log file). */ /*--------------------------------------------------------------------*/ t = line + strlen(line) - 1; while ((t >= line) && isspace(*t)) *t-- = '\0'; /*--------------------------------------------------------------------*/ /* Also trim leading spaces */ /*--------------------------------------------------------------------*/ t = line; while (t && isspace(*t)) t++; printmsg(6, "init_sys: read line length %u, \"%s\"", strlen(t), t); /*--------------------------------------------------------------------*/ /* Process any buffered data if this line is empty (which */ /* terminates the entry) */ /*--------------------------------------------------------------------*/ if ( *buf && (! strlen(t) || ! wantMore )) /* Previous entry complete? */ { if (! process_sys( buf )) /* Yes --> end of entry, process */ success = KWFalse; *buf = '\0'; /* Also, reset buffer to empty */ } /*--------------------------------------------------------------------*/ /* Buffer the new data if this is not a comment line */ /*--------------------------------------------------------------------*/ if (*t != '#') /* Comment line? */ { /* No --> Add it to our buffer */ if ( t[ strlen(t) - 1 ] == '\\' ) wantMore = KWTrue; else wantMore = KWFalse; strcat(buf, t); } /* else if (*t != '#') */ } /* while (fgets(line, LINESIZ, sysFileStream) != NULL) */ /*--------------------------------------------------------------------*/ /* Process the final system entry, if any */ /*--------------------------------------------------------------------*/ if (( *buf ) && ! process_sys( buf ) ) success = KWFalse; fclose( sysFileStream ); /*--------------------------------------------------------------------*/ /* Create a cache buffer for use by check_sys */ /*--------------------------------------------------------------------*/ if ( cacheLength ) { cache = (char *) malloc( cacheLength ); checkref( cache ); } /*--------------------------------------------------------------------*/ /* Report if we had any problems processing the SYS file to */ /* our caller */ /*--------------------------------------------------------------------*/ return success; } /* init_sys */