void AnyOption::justValue( char *type ) { if ( strlen(chomp(type)) == 1 ){ /* this is a char option */ for( int i = 0 ; i < optchar_counter ; i++ ){ if( optionchars[i] == type[0] ){ /* match */ if( optchartype[i] == COMMON_FLAG || optchartype[i] == FILE_FLAG ) { setFlagOn( type[0] ); return; } } } } /* if no char options matched */ for( int i = 0 ; i < option_counter ; i++ ){ if( strcmp( options[i], type ) == 0 ){ /* match */ if( optiontype[i] == COMMON_FLAG || optiontype[i] == FILE_FLAG ) { setFlagOn( type ); return; } } } printVerbose( "Unknown option in resourcefile : " ); printVerbose( type ); printVerbose( ); }
int AnyOption::parseGNU( char *arg ) { int split_at = 0; /* if has a '=' sign get value */ for( unsigned int i = 0 ; i < strlen(arg) ; i++ ){ if(arg[i] == equalsign ){ split_at = i ; /* store index */ i = strlen(arg); /* get out of loop */ } } if( split_at > 0 ){ /* it is an option value pair */ char* tmp = (char*) malloc( (split_at+1)*sizeof(char) ); for( int i = 0 ; i < split_at ; i++ ) tmp[i] = arg[i]; tmp[split_at] = '\0'; if ( matchOpt( tmp ) >= 0 ){ setValue( options[matchOpt(tmp)] , arg+split_at+1 ); free (tmp); }else{ printVerbose( "Unknown command argument option : " ); printVerbose( arg ); printVerbose( ); printAutoUsage(); free (tmp); return -1; } }else{ /* regular options with no '=' sign */ return matchOpt(arg); } return -1; }
char AnyOption::parsePOSIX( char* arg ) { for( unsigned int i = 0 ; i < strlen(arg) ; i++ ){ char ch = arg[i] ; if( matchChar(ch) ) { /* keep matching flags till an option */ /*if last char argv[++i] is the value */ if( i == strlen(arg)-1 ){ return ch; }else{/* else the rest of arg is the value */ i++; /* skip any '=' and ' ' */ while( arg[i] == whitespace || arg[i] == equalsign ) i++; setValue( ch , arg+i ); return '0'; } } } printVerbose( "Unknown command argument option : " ); printVerbose( arg ); printVerbose( ); printAutoUsage(); return '0'; }
//return 0 on no error static int tskDataSourceOpen(ScalpelInputReader * const reader) { printVerbose("tskDataSourceOpen()\n"); JNIEnv * env = attachThread(); TskInputStreamSourceInfo * tskData = castTskDataSource(reader); if (!tskData) { setThrowScalpelException(* (env), "tskDataSourceOpen() - ERROR object not initialized"); detachThread(); return -1; } if (reader->isOpen) { fprintf(stdout, "tskDataSourceOpen() WARNING stream already open\n"); //already open, should really close first, reset jlong zerOff = env->CallLongMethod(tskData->jInputStream, tskData->jSeekMethodId, (jlong)0); fprintf(stdout, "tskDataSourceOpen() rewinded, new offset: %"PRI64 "\n", (long long) zerOff); } else if (!tskData->firstOpen) { //closed but had already been open, so need to rewind to start //const jlong jnewOff = jlong zerOff = env->CallLongMethod(tskData->jInputStream, tskData->jSeekMethodId, (jlong)0); fprintf(stdout, "tskDataSourceOpen() rewinded, new offset: %"PRI64 "\n", (long long) zerOff); } reader->isOpen = TRUE; tskData->firstOpen = FALSE; detachThread(); return 0; }
int scalpelInputRead(ScalpelInputReader * const reader, void * buf, size_t size, size_t count) { printVerbose("scalpelInputRead()\n"); return reader->read(reader, buf, size, count); }
int scalpelInputSeeko(ScalpelInputReader * const reader, long long offset, scalpel_SeekRel whence) { printVerbose("scalpelInputSeeko()\n"); return reader->seeko(reader, offset, whence); }
long long scalpelInputGetSize(ScalpelInputReader * const reader) { printVerbose("scalpelInputGetSize()\n"); if (!reader->open) { fprintf(stderr, "scalpelInputGetSize() - ERROR trying to get size on closed reader\n"); return -1; } return reader->getSize(reader); }
//return 0 on no-error static int tskDataSourceSeekO(ScalpelInputReader * const reader, long long offset, scalpel_SeekRel whence) { printVerbose("tskDataSourceSeekO()\n"); //fprintf (stdout, "tskDataSourceSeekO() offset: %"PRI64 "whence: %d\n", offset, whence); JNIEnv * env = attachThread(); const TskInputStreamSourceInfo * tskData = castTskDataSource(reader); if (!tskData) { setThrowScalpelException(* (env), "tskDataSourceSeekO() - ERROR object not initialized"); detachThread(); return -1; } jlong newOffset = 0; jlong joffRel = 0; switch (whence) { case SCALPEL_SEEK_SET: newOffset = offset; break; case SCALPEL_SEEK_CUR: //get cur joffRel = env->CallLongMethod(tskData->jInputStream, tskData->jGetPositionMethodId); newOffset = offset + joffRel; break; case SCALPEL_SEEK_END: //get size joffRel = env->CallLongMethod(tskData->jInputStream, tskData->jGetSizeMethodId); newOffset = joffRel - offset; //TODO verify if need -1 break; default: break; } if (newOffset < 0) { setThrowScalpelException(* (env), "tskDataSourceSeekO() - ERROR invalid negative resulting offset."); detachThread(); return -1; } //const jlong jnewOff = env->CallLongMethod(tskData->jInputStream, tskData->jSeekMethodId, newOffset); if (env->ExceptionCheck() ){ env->ExceptionDescribe(); env->ExceptionClear(); setThrowScalpelException(* (env), "tskDataSourceSeekO() - ERROR seek failed."); detachThread(); return -1; } detachThread(); //fprintf(stdout, "tskDataSourceSeekO() deltaOffset: %"PRI64", new offset: %"PRI64 "\n", newOffset, (long long) jnewOff); return 0; }
int AnyOption::matchOpt (char *opt) { for (int i = 0; i < option_counter; i++) { if (strcmp (options[i], opt) == 0) { if (optiontype[i] == COMMON_OPT || optiontype[i] == COMMAND_OPT) { /* found option return index */ return i; } else if (optiontype[i] == COMMON_FLAG || optiontype[i] == COMMAND_FLAG) { /* found flag, set it */ setFlagOn (opt); return -1; } } } printVerbose ("Unknown command argument option : "); printVerbose (opt); printVerbose (); printAutoUsage (); return -1; }
bool AnyOption::matchChar (char c) { for (int i = 0; i < optchar_counter; i++) { if (optionchars[i] == c) { /* found match */ if (optchartype[i] == COMMON_OPT || optchartype[i] == COMMAND_OPT) { /* an option store and stop scanning */ return true; } else if (optchartype[i] == COMMON_FLAG || optchartype[i] == COMMAND_FLAG) { /* a flag store and keep scanning */ setFlagOn (c); return false; } } } printVerbose ("Unknown command argument option : "); printVerbose (c); printVerbose (); printAutoUsage (); return false; }
void AnyOption::addOption (char opt, int type) { if (!POSIX ()) { printVerbose ("Ignoring the option character \""); printVerbose (opt); printVerbose ("\" ( POSIX options are turned off )"); printVerbose (); return; } if (optchar_counter >= max_char_options) { if (doubleCharStorage () == false) { addOptionError (opt); return; } } optionchars[optchar_counter] = opt; optchartype[optchar_counter] = type; optcharindex[optchar_counter] = g_value_counter; optchar_counter++; }
static void tskDataSourceClose(ScalpelInputReader * const reader) { printVerbose("tskDataSourceClose()\n"); //nothing to be done, client closed the stream on java side and reset pos if (! reader->isOpen) { return; } reader->isOpen = FALSE; return; }
void scalpelInputClose(ScalpelInputReader * const reader) { printVerbose("scalpelInputClose()\n"); if (!reader->isOpen) { fprintf(stderr, "scalpelInputClose() -- ERROR -- reader for %s is not open, can't close\n", reader->id); return; } reader->close(reader); reader->isOpen = 0; return; }
ScalpelInputReader * scalpel_createInputReaderFile(const char * const filePath) { printVerbose("createInputReaderFile()\n"); ScalpelInputReader * fileReader = (ScalpelInputReader *) malloc( sizeof(ScalpelInputReader)); if (!fileReader) { fprintf(stderr, "createInputReaderFile() - malloc() ERROR fileReader not created\n "); return NULL ; } //setup data size_t pathLen = strlen(filePath); fileReader->id = (char*) malloc((pathLen + 1) * sizeof(char)); strncpy(fileReader->id, filePath, pathLen); fileReader->id[pathLen] = '\0'; fileReader->dataSource = (void*) malloc(sizeof (FileDataSource) ); if (!fileReader->dataSource) { fprintf(stderr, "createInputReaderFile() - malloc() ERROR dataSource not created\n "); return NULL ; } FileDataSource * fileSource = (FileDataSource *) fileReader->dataSource; fileReader->isOpen = 0; fileSource->fileHandle = NULL; //set up functions fileReader->open = fileDataSourceOpen; fileReader->close = fileDataSourceClose; fileReader->getError = fileDataSourceGetError; fileReader->getSize = fileDataSourceGetSize; fileReader->seeko = fileDataSourceSeekO; fileReader->tello = fileDataSourceTellO; fileReader->read = fileDataSourceRead; printVerbose("createInputReaderFile -- input reader created\n"); return fileReader; }
//return size, or -1 on error static long long tskDataSourceGetSize(ScalpelInputReader * const reader) { printVerbose("tskDataSourceGetSize()\n"); JNIEnv * env = attachThread(); const TskInputStreamSourceInfo * tskData = castTskDataSource(reader); if (!tskData) { setThrowScalpelException(* (env), "tskDataSourceGetSize() - ERROR object not initialized"); detachThread(); return -1; } const jlong jsize = env->CallLongMethod(tskData->jInputStream, tskData->jGetSizeMethodId); detachThread(); return (long long) jsize; }
static unsigned long long tskDataSourceTellO(ScalpelInputReader * const reader) { printVerbose("tskDataSourceTellO()\n"); JNIEnv * env = attachThread(); const TskInputStreamSourceInfo * tskData = castTskDataSource(reader); if (!tskData) { setThrowScalpelException(*env, "tskDataSourceTellO() - ERROR object not initialized"); detachThread(); return 0; } const jlong joff = env->CallLongMethod(tskData->jInputStream, tskData->jGetPositionMethodId); detachThread(); fprintf(stdout, "tskDataSourceTellO() ret %"PRIu64 "\n", joff ); return (unsigned long long) joff; }
void readFile(char *file) { int fd; int num_files; header *fileHeader[1000]; if((fd = open(file, O_RDONLY)) == -1) { perror("open"); exit(EXIT_FAILURE); } num_files = readTar(fileHeader, fd); if(v_flag) printVerbose(fileHeader, num_files); else printFiles(fileHeader, num_files); return; }
void AnyOption::processCommandArgs() { if(!(valueStoreOK() && CommandSet())) { return; } if(max_legal_args == 0) { max_legal_args = argc; } new_argv = (int*) malloc((max_legal_args+1) * sizeof(int)); for(int i = 1 ; i < argc ; i++) { /* ignore first argv */ if(argv[i][0] == long_opt_prefix[0] && argv[i][1] == long_opt_prefix[1]) { /* long GNU option */ int match_at = parseGNU(argv[i]+2); /* skip -- */ if(match_at >= 0 && i < argc-1) { /* found match */ setValue(options[match_at], argv[++i]); } } else if(argv[i][0] == opt_prefix_char) { /* POSIX char */ if(POSIX()) { char ch = parsePOSIX(argv[i]+1); /* skip - */ if(ch != '0' && i < argc-1) { /* matching char */ setValue(ch, argv[++i]); } } else { /* treat it as GNU option with a - */ int match_at = parseGNU(argv[i]+1); /* skip - */ if(match_at >= 0 && i < argc-1) { /* found match */ setValue(options[match_at], argv[++i]); } } } else { /* not option but an argument keep index */ if(new_argc < max_legal_args) { new_argv[ new_argc ] = i ; new_argc++; } else { /* ignore extra arguments */ printVerbose("Ignoring extra argument: "); printVerbose(argv[i]); printVerbose(); printAutoUsage(); } printVerbose("Unknown command argument option : "); printVerbose(argv[i]); printVerbose(); printAutoUsage(); } } }
void scalpel_freeInputReaderFile(ScalpelInputReader * fileReader) { printVerbose("freeInputReaderFile()\n"); if (!fileReader) { return; } if (!fileReader->dataSource) { fprintf(stderr, "freeInputReaderFile() - ERROR dataSource not set, can't free\n "); return; //ERROR } FileDataSource * fileSource = (FileDataSource *) fileReader->dataSource; FILE * fileHandle = fileSource->fileHandle; if (fileReader->isOpen) { if (fileHandle) { fclose(fileHandle); fileReader->isOpen = 0; fileHandle = NULL; } else { //ERROR fprintf(stderr, "freeInputReaderFile() - WARNING reader open, but handle not set\n"); } } if (fileReader->id) { free(fileReader->id); fileReader->id = NULL; } free(fileReader->dataSource); fileReader->dataSource = NULL; free(fileReader); }
int flagOptions::completeTrade(pair<string, equityT*> op, bool x){ int returnValue = 0; bool trueOrFalse = true; orderLine* buyer; unsigned int zero = 0; orderLine* seller; if(op.second->empty() == true || op.first.empty() == true){ return returnValue; } while(trueOrFalse){ trueOrFalse = false; if(op.second->blimit >= op.second->slimit){ buyer = op.second->buy.top(); seller = op.second->sell.top(); pp.first = buyer->client_name; pp.second = seller->client_name; if(x == true){ buyer->timestamp = buyer->position; seller->timestamp = seller->position; } if(buyer->position < seller->position) xx.second = buyer->price; else if(buyer->position >= seller->position) xx.second = seller->price; if(buyer->quantity <= seller->quantity){ xx.first = buyer->quantity; } else if(buyer->quantity > seller->quantity) xx.first = seller->quantity; seller->quantity = (seller->quantity - xx.first); buyer->quantity = (buyer->quantity - xx.first); printVerbose(buyer, seller,xx); if(buyer->quantity == zero) { op.second->buy.pop(); if(op.second->buy.empty()) { op.second->blimit = zero; } else{ int cost = op.second->buy.top()->price; op.second->blimit = cost; } } else if(seller->quantity == zero) { op.second->sell.pop(); if(op.second->sell.empty()) op.second->slimit = INT_MAX; else{ int cost = op.second->sell.top()->price; op.second->slimit = cost; } } int zeroo = 0; trueOrFalse = true; if(xx.first > zeroo){ returnValue = 1; //Add Transfers //Add Summary addSummary(); medianMap[op.first].insertMedian(xx.second); } } else trueOrFalse = false; } return returnValue; }
int main(void){ FILE* fp = fopen("historicaldata.csv","r"); struct DailyData allData[3000]; struct DailyData yearData[366]; int numTotalRecords; numTotalRecords = readDailyData(fp, allData); int year; int reportType; struct MonthlyStatistic monthly[12]; printf("Please enter the year for the report: "); scanf("%d",&year); printf("Please enter the type of report you wish to generate:\n"); printf("1) summary\n"); printf("2) detailed\n"); scanf("%d",&reportType); int numDays = getRelevantRecords(year,allData,numTotalRecords,yearData); /*int j; printf("\nUNSORTED RECORDS\n"); for(j=0; j < numDays; j++){ //test getRelevantRecords output =OK printf("%d,%d,%d,%f,%f,%f,%c\n",yearData[j].year,yearData[j].month,yearData[j].day, yearData[j].high,yearData[j].low,yearData[j].precipitation, yearData[j].condition); }*/ sortYearData(yearData,numDays); /*printf("\nSORTED RECORDS\n"); for(j=0; j < numDays; j++){ //test sortYearData output = printf("%d,%d,%d,%f,%f,%f,%c\n",yearData[j].year,yearData[j].month,yearData[j].day, yearData[j].high,yearData[j].low,yearData[j].precipitation, yearData[j].condition); }*/ for(int i=0;i<12;i++){ getStats(i+1,yearData,numDays,&monthly[i]); //what does it mean &monthly[i]? } printf("\nWeather summary for %d\n\n",year); printf("|-----------|-------|-------|-------|---------|\n"); printf("| Month | High | Low | Avg | Precip |\n"); printf("|-----------|-------|-------|-------|---------|\n"); for(int i=0;i<12;i++){ printMonthlyStatistic(i+1,&monthly[i]); } printf("\n\n"); printf("Precipitation Graph\n\n"); for (int i=0;i<12;i++){ graphLine(i+1,&monthly[i]); } if(reportType == 2){ printf("\n\n"); printf("Detailed report:\n"); printVerbose(yearData,numDays); } return 0; }
static int tskDataSourceGetError(ScalpelInputReader * const reader) { printVerbose("tskDataSourceGetError()\n"); //not implemented return 0; }
static ScalpelInputReader * createInputReaderTsk(JNIEnv & env, const char * inputId, jobject jInputStream) { printVerbose("createInputReaderTsk()\n"); ScalpelInputReader * tskReader = (ScalpelInputReader *) malloc( sizeof(ScalpelInputReader)); if (!tskReader) { fprintf(stdout, "createInputReaderTsk() - malloc() ScalpelInputReader ERROR tskReader not created\n "); setThrowScalpelException(env, "createInputReaderTsk() - malloc() ScalpelInputReader ERROR tskReader not created"); return NULL ; } //setup data tskReader->id = const_cast<char*> (inputId); tskReader->dataSource = (TskInputStreamSourceInfo*) malloc(sizeof(TskInputStreamSourceInfo)); if (!tskReader->dataSource) { free(tskReader); tskReader = NULL; fprintf(stdout, "createInputReaderTsk() - malloc() TskInputStreamSourceInfo ERROR tskReader not created\n "); setThrowScalpelException(env, "createInputReaderTsk() - malloc() TskInputStreamSourceInfo ERROR tskReader not created"); return NULL ; } TskInputStreamSourceInfo* tskData = (TskInputStreamSourceInfo*) tskReader->dataSource; tskData->firstOpen = TRUE; tskData->jInputStream = jInputStream; //alloc java read buffer jbyteArray jReadBuffer = env.NewByteArray(JAVA_READ_BUFFER_SIZE); if (!jReadBuffer || env.ExceptionCheck()) { fprintf(stdout, "createInputReaderTsk() - ERROR allocating read buffer\n "); if (env.ExceptionCheck() ){ env.ExceptionDescribe(); } setThrowScalpelException(env, "createInputReaderTsk() - ERROR allocating read buffer"); tskData->jInputStream = NULL; free(tskReader->dataSource); tskReader->dataSource = NULL; free(tskReader); tskReader = NULL; return NULL ; } tskData->jReadBuffer = (jbyteArray) env.NewGlobalRef(jReadBuffer); if (! tskData->jReadBuffer) { fprintf(stdout, "createInputReaderTsk() - ERROR creating read buffer global ref\n "); if (env.ExceptionCheck() ){ env.ExceptionDescribe(); env.ExceptionClear(); } setThrowScalpelException(env, "createInputReaderTsk() - ERROR creating read buffer global ref"); jReadBuffer = NULL; // local ref will be automatically deleted anyways tskData->jInputStream = NULL; free(tskReader->dataSource); tskReader->dataSource = NULL; free(tskReader); tskReader = NULL; return NULL ; } tskReader->isOpen = 0; //initialize java method IDs jclass clazz = env.FindClass(TSK_INPUTSTREAM_CLASS); if (!clazz) { fprintf(stdout, "createInputReaderTsk() - ERROR cannot load java class\n "); setThrowScalpelException(env, "createInputReaderTsk() - ERROR cannot load java class"); env.DeleteGlobalRef(tskData->jReadBuffer); free(tskReader->dataSource); tskReader->dataSource = NULL; free(tskReader); tskReader = NULL; return NULL ; } //using disassembler to get the correct signatures like javap -s -p org.sleuthkit.datamodel.ReadContentInputStream tskData->jGetPositionMethodId = env.GetMethodID(clazz, "getCurPosition", "()J"); tskData->jGetSizeMethodId = env.GetMethodID(clazz, "getLength", "()J"); tskData->jReadMethodId = env.GetMethodID(clazz, "read", "([BII)I"); tskData->jSeekMethodId = env.GetMethodID(clazz, "seek", "(J)J"); if (!tskData->jGetPositionMethodId || !tskData->jGetSizeMethodId || !tskData->jReadMethodId || !tskData->jSeekMethodId || env.ExceptionCheck() ) { fprintf(stdout, "createInputReaderTsk() - ERROR getting java method ids for the input stream class, check API version\n "); if (env.ExceptionCheck()) { env.ExceptionDescribe(); env.ExceptionClear(); } setThrowScalpelException(env, "createInputReaderTsk() - ERROR getting java method ids for the input stream class, check API version"); env.DeleteGlobalRef(tskData->jReadBuffer); free(tskReader->dataSource); tskReader->dataSource = NULL; free(tskReader); tskReader = NULL; return NULL ; } //set up functions tskReader->open = tskDataSourceOpen; tskReader->close = tskDataSourceClose; tskReader->getError = tskDataSourceGetError; tskReader->getSize = tskDataSourceGetSize; tskReader->seeko = tskDataSourceSeekO; tskReader->tello = tskDataSourceTellO; tskReader->read = tskDataSourceRead; printVerbose("createInputReaderTsk -- input reader created\n"); return tskReader; }
static void freeInputReaderTsk(JNIEnv & env, ScalpelInputReader * tskReader) { printVerbose("freeInputReaderTsk()\n"); if (!tskReader) { return; } if (!tskReader->dataSource) { fprintf(stdout, "freeInputReaderTsk() - ERROR dataSource not set, can't free\n "); return; //ERROR } TskInputStreamSourceInfo* tskData = (TskInputStreamSourceInfo*) tskReader->dataSource; if (!tskData) { fprintf(stdout, "freeInputReaderTsk() - ERROR TskInputStreamSourceInfo not set, can't free\n "); free(tskReader); tskReader = NULL; return; //ERROR } if (tskData->jReadBuffer) { env.DeleteGlobalRef(tskData->jReadBuffer); tskData->jReadBuffer = NULL; } if (tskData->jInputStream) { //env.DeleteGlobalRef(tskData->jInputStream); //done by carveNat() tskData->jInputStream = NULL; } //tskData->env = NULL; //these do not need to be freed tskData->jGetPositionMethodId = NULL; tskData->jGetSizeMethodId = NULL; tskData->jReadMethodId = NULL; tskData->jSeekMethodId = NULL; //reset fn pointers tskReader->open = NULL; tskReader->close = NULL; tskReader->getError = NULL; tskReader->getSize = NULL; tskReader->seeko = NULL; tskReader->tello = NULL; tskReader->read = NULL; //java client side is responsible for closing the stream it created tskReader->isOpen = FALSE; tskReader->id = NULL; //freed by jni ReleaseStringUTFChars() free(tskReader->dataSource); tskReader->dataSource = NULL; free(tskReader); tskReader = NULL; }
int main(int argc, const char * argv[]) { int i; FILE *trace = NULL; for (i = 0; i < argc; i++) { char arg = *++argv[i]; switch (arg) { case 'h': help = 1; break; case 'v': verbose = 1; break; case 's': sbits = atoi(argv[i+1]); S = 1 << sbits; break; case 'E': E = atoi(argv[i+1]); break; case 'b': bbits = atoi(argv[i+1]); break; case 't': trace = fopen(argv[i+1], "r"); break; default: break; } } if (help == 1) { printHelpAndExit(argv[0]); } CacheSet cacheSets[S]; buildCache(cacheSets); if (trace != NULL) { long address; int bufLen = 30; char buffer[bufLen], instruction, blockSize; while (fgets(buffer, bufLen, trace) != NULL) { sscanf(buffer, " %c %lx,%c", &instruction, &address, &blockSize); if (instruction != INSTRUCTION) { for (i = 0; i < bufLen; i++) { if (buffer[i] == '\n') { buffer[i] = '\0'; } } char hitType = 0; if (instruction == MODIFY) { for (i = 0; i < 2; i++) { hitType += cacheOperation(cacheSets, address); } } else { hitType = cacheOperation(cacheSets, address); } if (verbose == 1) { printVerbose(hitType, buffer); } } } fclose(trace); } else { printf("Error: Must specify trace file, see usage\n"); printHelpAndExit(argv[0]); } for (i = 0; i < S; i++) { free(cacheSets[i].lines); } printSummary(hits, misses, evictions); return 0; }
int scalpelInputGetError(ScalpelInputReader * const reader) { printVerbose("scalpelInputGetError()\n"); return reader->getError(reader); }
const char * scalpelInputGetId (ScalpelInputReader * const reader) { printVerbose("scalpelInputGetId()\n"); return reader->id; }
const char scalpelInputIsOpen (ScalpelInputReader * const reader) { printVerbose("scalpelInputIsOpen()\n"); return reader->isOpen; }
int scalpelInputOpen(ScalpelInputReader * const reader) { printVerbose("scalpelInputOpen()\n"); return reader->open(reader); }
unsigned long long scalpelInputTello(ScalpelInputReader * const reader) { printVerbose("scalpelInputTello()\n"); return reader->tello(reader); }