void ScanForFunctions(CLanguageProxy& proxy) { const char* text = proxy.Text(), *max = text + proxy.Size(); char* scope = (char*)"file"; if (*max != 0) return; while (text < max) { text = comment(text, false); switch (*text) { case 0: return; case '\'': text = skip(text + 1, '\''); break; case '"': text = skip(text + 1, '"'); break; case '(': case '{': case '[': text = parens(text + 1, *text); break; case '#': text = preprocessor(text + 1, proxy); break; default: if (isidentf(*text)) text = ident(text, proxy, scope); else text++; break; } } } /* ScanForFunctions */
int main() { clang::DiagnosticOptions diagnosticOptions; clang::TextDiagnosticPrinter *pTextDiagnosticPrinter = new clang::TextDiagnosticPrinter( llvm::outs(), &diagnosticOptions); llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> pDiagIDs; clang::DiagnosticsEngine *pDiagnosticsEngine = new clang::DiagnosticsEngine(pDiagIDs, &diagnosticOptions, pTextDiagnosticPrinter); clang::LangOptions languageOptions; clang::FileSystemOptions fileSystemOptions; clang::FileManager fileManager(fileSystemOptions); clang::SourceManager sourceManager( *pDiagnosticsEngine, fileManager); clang::TargetOptions targetOptions; targetOptions.Triple = llvm::sys::getDefaultTargetTriple(); clang::TargetInfo *pTargetInfo = clang::TargetInfo::CreateTargetInfo( *pDiagnosticsEngine, &targetOptions); llvm::IntrusiveRefCntPtr<clang::HeaderSearchOptions> hso(new clang::HeaderSearchOptions()); clang::HeaderSearch headerSearch(hso, fileManager, *pDiagnosticsEngine, languageOptions, pTargetInfo); clang::CompilerInstance compInst; llvm::IntrusiveRefCntPtr<clang::PreprocessorOptions> pOpts; clang::Preprocessor preprocessor( pOpts, *pDiagnosticsEngine, languageOptions, pTargetInfo, sourceManager, headerSearch, compInst); clang::PreprocessorOptions preprocessorOptions; clang::FrontendOptions frontendOptions; clang::InitializePreprocessor( preprocessor, preprocessorOptions, *hso, frontendOptions); // Note: Changed the file from tutorial2. const clang::FileEntry *pFile = fileManager.getFile("../Resources/testInclude.c"); sourceManager.createMainFileID(pFile); preprocessor.EnterMainSourceFile(); pTextDiagnosticPrinter->BeginSourceFile(languageOptions, &preprocessor); clang::Token token; do { preprocessor.Lex(token); if( pDiagnosticsEngine->hasErrorOccurred()) { break; } preprocessor.DumpToken(token); std::cerr << std::endl; } while( token.isNot(clang::tok::eof)); pTextDiagnosticPrinter->EndSourceFile(); return 0; }
static int bpf_program__load(struct bpf_program *prog, char *license, u32 kern_version) { int err = 0, fd, i; if (prog->instances.nr < 0 || !prog->instances.fds) { if (prog->preprocessor) { pr_warning("Internal error: can't load program '%s'\n", prog->section_name); return -LIBBPF_ERRNO__INTERNAL; } prog->instances.fds = malloc(sizeof(int)); if (!prog->instances.fds) { pr_warning("Not enough memory for BPF fds\n"); return -ENOMEM; } prog->instances.nr = 1; prog->instances.fds[0] = -1; } if (!prog->preprocessor) { if (prog->instances.nr != 1) { pr_warning("Program '%s' is inconsistent: nr(%d) != 1\n", prog->section_name, prog->instances.nr); } err = load_program(prog->insns, prog->insns_cnt, license, kern_version, &fd); if (!err) prog->instances.fds[0] = fd; goto out; } for (i = 0; i < prog->instances.nr; i++) { struct bpf_prog_prep_result result; bpf_program_prep_t preprocessor = prog->preprocessor; bzero(&result, sizeof(result)); err = preprocessor(prog, i, prog->insns, prog->insns_cnt, &result); if (err) { pr_warning("Preprocessing the %dth instance of program '%s' failed\n", i, prog->section_name); goto out; } if (!result.new_insn_ptr || !result.new_insn_cnt) { pr_debug("Skip loading the %dth instance of program '%s'\n", i, prog->section_name); prog->instances.fds[i] = -1; if (result.pfd) *result.pfd = -1; continue; } err = load_program(result.new_insn_ptr, result.new_insn_cnt, license, kern_version, &fd); if (err) { pr_warning("Loading the %dth instance of program '%s' failed\n", i, prog->section_name); goto out; } if (result.pfd) *result.pfd = fd; prog->instances.fds[i] = fd; } out: if (err) pr_warning("failed to load program '%s'\n", prog->section_name); zfree(&prog->insns); prog->insns_cnt = 0; return err; }
unsigned int CppCheck::processFile() { exitcode = 0; // only show debug warnings for C/C++ source files (don't fix // debug warnings for java/c#/etc files) if (!Path::acceptFile(_filename)) _settings.debugwarnings = false; // TODO: Should this be moved out to its own function so all the files can be // analysed before any files are checked? if (_settings.test_2_pass && _settings._jobs == 1) { const std::string printname = Path::toNativeSeparators(_filename); reportOut("Analysing " + printname + "..."); std::ifstream f(_filename.c_str()); analyseFile(f, _filename); } _errout.str(""); if (_settings.terminated()) return exitcode; if (_settings._errorsOnly == false) { std::string fixedpath(_filename); fixedpath = Path::simplifyPath(fixedpath.c_str()); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + std::string("...")); } try { Preprocessor preprocessor(&_settings, this); std::list<std::string> configurations; std::string filedata = ""; if (!_fileContent.empty()) { // File content was given as a string std::istringstream iss(_fileContent); preprocessor.preprocess(iss, filedata, configurations, _filename, _settings._includePaths); } else { // Only file name was given, read the content from file std::ifstream fin(_filename.c_str()); Timer t("Preprocessor::preprocess", _settings._showtime, &S_timerResults); preprocessor.preprocess(fin, filedata, configurations, _filename, _settings._includePaths); } if (_settings.checkConfiguration) { return 0; } _settings.ifcfg = bool(configurations.size() > 1); if (!_settings.userDefines.empty()) { configurations.clear(); configurations.push_back(_settings.userDefines); } int checkCount = 0; for (std::list<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it) { // Check only a few configurations (default 12), after that bail out, unless --force // was used. if (!_settings._force && checkCount >= _settings._maxConfigs) { const std::string fixedpath = Path::toNativeSeparators(_filename); ErrorLogger::ErrorMessage::FileLocation location; location.setfile(fixedpath); std::list<ErrorLogger::ErrorMessage::FileLocation> loclist; loclist.push_back(location); const std::string msg("Interrupted checking because of too many #ifdef configurations.\n" "The checking of the file was interrupted because there were too many " "#ifdef configurations. Checking of all #ifdef configurations can be forced " "by --force command line option or from GUI preferences. However that may " "increase the checking time."); ErrorLogger::ErrorMessage errmsg(loclist, Severity::information, msg, "toomanyconfigs", false); if (!_settings.nomsg.isSuppressedLocal(errmsg._id, fixedpath, location.line)) { reportErr(errmsg); } break; } cfg = *it; Timer t("Preprocessor::getcode", _settings._showtime, &S_timerResults); const std::string codeWithoutCfg = preprocessor.getcode(filedata, *it, _filename); t.Stop(); // If only errors are printed, print filename after the check if (_settings._errorsOnly == false && it != configurations.begin()) { std::string fixedpath = Path::simplifyPath(_filename.c_str()); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + ": " + cfg + std::string("...")); } const std::string &appendCode = _settings.append(); if (_settings.debugFalsePositive) { if (findError(codeWithoutCfg + appendCode, _filename.c_str())) { return exitcode; } } else { checkFile(codeWithoutCfg + appendCode, _filename.c_str()); } ++checkCount; } } catch (std::runtime_error &e) { // Exception was thrown when checking this file.. const std::string fixedpath = Path::toNativeSeparators(_filename); _errorLogger.reportOut("Bailing out from checking " + fixedpath + ": " + e.what()); } if (!_settings._errorsOnly) reportUnmatchedSuppressions(_settings.nomsg.getUnmatchedLocalSuppressions(_filename)); _errorList.clear(); return exitcode; }
unsigned int CppCheck::processFile(const std::string& filename, const std::string& fileContent) { exitcode = 0; // only show debug warnings for accepted C/C++ source files if (!Path::acceptFile(filename)) _settings.debugwarnings = false; if (_settings.terminated()) return exitcode; if (_settings._errorsOnly == false) { std::string fixedpath = Path::simplifyPath(filename); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + std::string("...")); } try { Preprocessor preprocessor(&_settings, this); std::list<std::string> configurations; std::string filedata = ""; if (!fileContent.empty()) { // File content was given as a string (democlient) std::istringstream iss(fileContent); preprocessor.preprocess(iss, filedata, configurations, filename, _settings._includePaths); } else { // Only file name was given, read the content from file std::ifstream fin(filename.c_str()); Timer t("Preprocessor::preprocess", _settings._showtime, &S_timerResults); preprocessor.preprocess(fin, filedata, configurations, filename, _settings._includePaths); } if (_settings.checkConfiguration) { return 0; } // Run rules on this code for (std::list<Settings::Rule>::const_iterator it = _settings.rules.begin(); it != _settings.rules.end(); ++it) { if (it->tokenlist == "define") { Tokenizer tokenizer2(&_settings, this); std::istringstream istr2(filedata); tokenizer2.list.createTokens(istr2, filename); for (const Token *tok = tokenizer2.list.front(); tok; tok = tok->next()) { if (tok->str() == "#define") { std::string code = std::string(tok->linenr()-1U, '\n'); for (const Token *tok2 = tok; tok2 && tok2->linenr() == tok->linenr(); tok2 = tok2->next()) code += " " + tok2->str(); Tokenizer tokenizer3(&_settings, this); std::istringstream istr3(code); tokenizer3.list.createTokens(istr3, tokenizer2.list.file(tok)); executeRules("define", tokenizer3); } } break; } } if (!_settings.userDefines.empty() && _settings._maxConfigs==1U) { configurations.clear(); configurations.push_back(_settings.userDefines); } if (!_settings._force && configurations.size() > _settings._maxConfigs) { if (_settings.isEnabled("information")) { tooManyConfigsError(Path::toNativeSeparators(filename),configurations.size()); } else { tooManyConfigs = true; } } unsigned int checkCount = 0; for (std::list<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it) { // Check only a few configurations (default 12), after that bail out, unless --force // was used. if (!_settings._force && ++checkCount > _settings._maxConfigs) break; cfg = *it; // If only errors are printed, print filename after the check if (_settings._errorsOnly == false && it != configurations.begin()) { std::string fixedpath = Path::simplifyPath(filename); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + ": " + cfg + std::string("...")); } if (!_settings.userDefines.empty()) { if (!cfg.empty()) cfg = ";" + cfg; cfg = _settings.userDefines + cfg; } Timer t("Preprocessor::getcode", _settings._showtime, &S_timerResults); const std::string codeWithoutCfg = preprocessor.getcode(filedata, cfg, filename); t.Stop(); const std::string &appendCode = _settings.append(); if (_settings.debugFalsePositive) { if (findError(codeWithoutCfg + appendCode, filename.c_str())) { return exitcode; } } else { checkFile(codeWithoutCfg + appendCode, filename.c_str()); } } } catch (const std::runtime_error &e) { internalError(filename, e.what()); } catch (const InternalError &e) { internalError(filename, e.errorMessage); } if (_settings.isEnabled("information") || _settings.checkConfiguration) reportUnmatchedSuppressions(_settings.nomsg.getUnmatchedLocalSuppressions(filename)); _errorList.clear(); return exitcode; }
int main() { clang::DiagnosticOptions diagnosticOptions; clang::TextDiagnosticPrinter *pTextDiagnosticPrinter = new clang::TextDiagnosticPrinter( llvm::outs(), &diagnosticOptions); llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> pDiagIDs; clang::DiagnosticsEngine *pDiagnosticsEngine = new clang::DiagnosticsEngine(pDiagIDs, &diagnosticOptions, pTextDiagnosticPrinter); clang::LangOptions languageOptions; clang::FileSystemOptions fileSystemOptions; clang::FileManager fileManager(fileSystemOptions); clang::SourceManager sourceManager( *pDiagnosticsEngine, fileManager); const std::shared_ptr<clang::TargetOptions> targetOptions = std::make_shared<clang::TargetOptions>(); targetOptions->Triple = llvm::sys::getDefaultTargetTriple(); clang::TargetInfo *pTargetInfo = clang::TargetInfo::CreateTargetInfo( *pDiagnosticsEngine, targetOptions); llvm::IntrusiveRefCntPtr<clang::HeaderSearchOptions> hso(new clang::HeaderSearchOptions()); clang::HeaderSearch headerSearch(hso, sourceManager, *pDiagnosticsEngine, languageOptions, pTargetInfo); clang::CompilerInstance compInst; llvm::IntrusiveRefCntPtr<clang::PreprocessorOptions> pOpts(new clang::PreprocessorOptions); clang::Preprocessor preprocessor( pOpts, *pDiagnosticsEngine, languageOptions, sourceManager, headerSearch, compInst); preprocessor.Initialize(*pTargetInfo); // disable predefined Macros so that you only see the tokens from your // source file. Note, this has some nasty side-effects like also undefning // your archictecture and things like that. //preprocessorOptions.UsePredefines = false; clang::FrontendOptions frontendOptions; clang::InitializePreprocessor( preprocessor, *pOpts, frontendOptions); clang::ApplyHeaderSearchOptions( preprocessor.getHeaderSearchInfo(), compInst.getHeaderSearchOpts(), preprocessor.getLangOpts(), preprocessor.getTargetInfo().getTriple()); // Note: Changed the file from tutorial2. const clang::FileEntry *pFile = fileManager.getFile("testInclude.c"); sourceManager.setMainFileID( sourceManager.createFileID( pFile, clang::SourceLocation(), clang::SrcMgr::C_User)); preprocessor.EnterMainSourceFile(); pTextDiagnosticPrinter->BeginSourceFile(languageOptions, &preprocessor); clang::Token token; do { preprocessor.Lex(token); if( pDiagnosticsEngine->hasErrorOccurred()) { break; } preprocessor.DumpToken(token); std::cerr << std::endl; } while( token.isNot(clang::tok::eof)); pTextDiagnosticPrinter->EndSourceFile(); return 0; }
unsigned int CppCheck::processFile(const std::string& filename,bool flag) // TSC from 20140117 { time_t ts,te; exitcode = 0; // only show debug warnings for accepted C/C++ source files if (!Path::acceptFile(filename)) _settings.debugwarnings = false; if (_settings.terminated()) return exitcode; if (_settings._errorsOnly == false) { std::string fixedpath = Path::simplifyPath(filename.c_str()); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + std::string("...")); } try { Preprocessor preprocessor(&_settings, this); std::list<std::string> configurations; std::string filedata = ""; TIMELOG( if (!_fileContent.empty()) { // File content was given as a string std::istringstream iss(_fileContent); preprocessor.preprocess(flag,iss, filedata, configurations, filename, _settings._includePaths); // TSC:from 20140117 } else { // Only file name was given, read the content from file std::ifstream fin(filename.c_str()); Timer t("Preprocessor::preprocess", _settings._showtime, &S_timerResults); preprocessor.preprocess(flag,fin, filedata, configurations, filename, _settings._includePaths); // TSC:from 20140117 } std::stringstream ss; ss << filedata.size(); std::string filesize = ss.str(); ,filename+" "+filesize+" preprocess ",logfile) if (_settings.checkConfiguration) { return 0; } if (!_settings.userDefines.empty()) { configurations.clear(); configurations.push_back(_settings.userDefines); } if (!_settings._force && configurations.size() > _settings._maxConfigs) { const std::string fixedpath = Path::toNativeSeparators(filename); ErrorLogger::ErrorMessage::FileLocation location; location.setfile(fixedpath); const std::list<ErrorLogger::ErrorMessage::FileLocation> loclist(1, location); std::ostringstream msg; msg << "Too many #ifdef configurations - cppcheck will only check " << _settings._maxConfigs << " of " << configurations.size() << ".\n" "The checking of the file will be interrupted because there are too many " "#ifdef configurations. Checking of all #ifdef configurations can be forced " "by --force command line option or from GUI preferences. However that may " "increase the checking time."; } TIMELOG( Timer t("Preprocessor::getcode", _settings._showtime, &S_timerResults); const std::string codeWithoutCfg = preprocessor.getcode(filedata, "", filename, _settings.userDefines.empty()); t.Stop(); ," getcode ",logfile)
unsigned int CppCheck::processFile() { exitcode = 0; // TODO: Should this be moved out to its own function so all the files can be // analysed before any files are checked? if (_settings.test_2_pass && _settings._jobs == 1) { const std::string printname = Path::toNativeSeparators(_filename); reportOut("Analysing " + printname + "..."); std::ifstream f(_filename.c_str()); analyseFile(f, _filename); } _errout.str(""); if (_settings.terminated()) return exitcode; if (_settings._errorsOnly == false) { std::string fixedpath(_filename); fixedpath = Path::simplifyPath(fixedpath.c_str()); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + std::string("...")); } try { Preprocessor preprocessor(&_settings, this); std::list<std::string> configurations; std::string filedata = ""; if (!_fileContent.empty()) { // File content was given as a string std::istringstream iss(_fileContent); preprocessor.preprocess(iss, filedata, configurations, _filename, _settings._includePaths); } else { // Only file name was given, read the content from file std::ifstream fin(_filename.c_str()); Timer t("Preprocessor::preprocess", _settings._showtime, &S_timerResults); preprocessor.preprocess(fin, filedata, configurations, _filename, _settings._includePaths); } if (_settings.checkConfiguration) { return 0; } _settings.ifcfg = bool(configurations.size() > 1); if (!_settings.userDefines.empty()) { configurations.clear(); configurations.push_back(_settings.userDefines); } int checkCount = 0; for (std::list<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it) { // Check only 12 first configurations, after that bail out, unless --force // was used. if (!_settings._force && checkCount > 11) { const std::string fixedpath = Path::toNativeSeparators(_filename); ErrorLogger::ErrorMessage::FileLocation location; location.setfile(fixedpath); std::list<ErrorLogger::ErrorMessage::FileLocation> loclist; loclist.push_back(location); const std::string msg("Interrupted checking because of too many #ifdef configurations.\n" "The checking of the file was interrupted because there were too many " "#ifdef configurations. Checking of all #ifdef configurations can be forced " "by --force command line option or from GUI preferences. However that may " "increase the checking time."); ErrorLogger::ErrorMessage errmsg(loclist, Severity::information, msg, "toomanyconfigs", false); _errorLogger.reportErr(errmsg); break; } cfg = *it; Timer t("Preprocessor::getcode", _settings._showtime, &S_timerResults); const std::string codeWithoutCfg = Preprocessor::getcode(filedata, *it, _filename, &_settings, &_errorLogger); t.Stop(); // If only errors are printed, print filename after the check if (_settings._errorsOnly == false && it != configurations.begin()) { std::string fixedpath = Path::simplifyPath(_filename.c_str()); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + ": " + cfg + std::string("...")); } std::string appendCode = _settings.append(); if (!appendCode.empty()) Preprocessor::preprocessWhitespaces(appendCode); checkFile(codeWithoutCfg + appendCode, _filename.c_str()); ++checkCount; } } catch (std::runtime_error &e) { // Exception was thrown when checking this file.. const std::string fixedpath = Path::toNativeSeparators(_filename); _errorLogger.reportOut("Bailing out from checking " + fixedpath + ": " + e.what()); } reportUnmatchedSuppressions(_settings.nomsg.getUnmatchedLocalSuppressions(_filename)); // This generates false positives - especially for libraries const bool verbose_orig = _settings._verbose; _settings._verbose = false; if (_settings.isEnabled("unusedFunction") && _settings._jobs == 1) { _errout.str(""); if (_settings._errorsOnly == false) _errorLogger.reportOut("Checking usage of global functions.."); _checkUnusedFunctions.check(this); } _settings._verbose = verbose_orig; _errorList.clear(); return exitcode; }
void SimplePreprocessorTest::preprocess(const char *input, const pp::PreprocessorSettings &settings) { pp::Preprocessor preprocessor(&mDiagnostics, &mDirectiveHandler, settings); preprocess(input, nullptr, &preprocessor); }
int main() { clang::DiagnosticOptions diagnosticOptions; clang::TextDiagnosticPrinter *pTextDiagnosticPrinter = new clang::TextDiagnosticPrinter( llvm::outs(), diagnosticOptions); llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> pDiagIDs; clang::Diagnostic diagnostic(pDiagIDs, pTextDiagnosticPrinter); clang::LangOptions languageOptions; clang::FileSystemOptions fileSystemOptions; clang::FileManager fileManager(fileSystemOptions); clang::SourceManager sourceManager( diagnostic, fileManager); clang::HeaderSearch headerSearch(fileManager); clang::HeaderSearchOptions headerSearchOptions; clang::TargetOptions targetOptions; targetOptions.Triple = llvm::sys::getHostTriple(); clang::TargetInfo *pTargetInfo = clang::TargetInfo::CreateTargetInfo( diagnostic, targetOptions); clang::ApplyHeaderSearchOptions( headerSearch, headerSearchOptions, languageOptions, pTargetInfo->getTriple()); clang::Preprocessor preprocessor( diagnostic, languageOptions, *pTargetInfo, sourceManager, headerSearch); clang::PreprocessorOptions preprocessorOptions; // disable predefined Macros so that you only see the tokens from your // source file. preprocessorOptions.UsePredefines = false; clang::FrontendOptions frontendOptions; clang::InitializePreprocessor( preprocessor, preprocessorOptions, headerSearchOptions, frontendOptions); const clang::FileEntry *pFile = fileManager.getFile( "test.c"); sourceManager.createMainFileID(pFile); preprocessor.EnterMainSourceFile(); pTextDiagnosticPrinter->BeginSourceFile(languageOptions, &preprocessor); clang::Token token; do { preprocessor.Lex(token); if( diagnostic.hasErrorOccurred()) { break; } preprocessor.DumpToken(token); std::cerr << std::endl; } while( token.isNot(clang::tok::eof)); pTextDiagnosticPrinter->EndSourceFile(); return 0; }
void token_next() { static int i, len; static char buffer[1024]; char * buffer_ptr = buffer; if ( !source_ptr ) { token.type = NOTOKEN; return; } if ( use_saved ) { token = token_saved; line_count = token.line; current_file = token.file; use_saved = 0; return; } token.line = line_count; token.file = current_file; token_prev = token; while ( 1 ) { SKIP_SPACES; if ( !disable_prepro && *source_ptr == '#' ) { int line; const char * old_source_ptr; identifiers_as_strings = 0; /* Comandos de preprocesador */ source_ptr++; line = line_count; SKIP_SPACES_UNTIL_LF_AND_COUNT_LINES; if ( *source_ptr == '\n' ) { token.code = identifier_search_or_add( "#" ); token.type = IDENTIFIER; line_count = line; compile_error( MSG_IDENTIFIER_EXP ); } old_source_ptr = source_ptr; if ( ISWORDFIRST( *source_ptr ) ) { GET_NEXT_TOKEN_IN_TMPBUFFER; /* #include "file.h" */ if ( token.code == identifier_include && !use_saved ) { include_file( 1 ); return; } source_ptr = old_source_ptr; } preprocessor(); buffer_ptr = buffer; *buffer_ptr = '\0'; continue; } if ( !*source_ptr ) { /* Casos de bloques manuales */ if ( current_file == -1 ) { token_endfile(); token.type = NOTOKEN; return; } while ( !*source_ptr ) { if ( sources == 0 ) { token.type = NOTOKEN; return; } token_endfile(); if ( !source_ptr ) { token.type = NOTOKEN; return; } } continue; } /* Ignora comentarios */ SKIP_COMMENTS; if ( !*source_ptr ) { token.type = NOTOKEN; return; } /* Cadenas */ if ( *source_ptr == '"' || *source_ptr == '\'' ) { token.type = STRING; token.code = string_compile( &source_ptr ); token.line = line_count; token.file = current_file; return; } /* Operadores de más de un caracter */ len = 0; if ( *source_ptr == '<' ) { if ( source_ptr[1] == '<' ) { if ( source_ptr[2] == '=' ) len = 3; else len = 2; } else if ( source_ptr[1] == '>' ) len = 2; else if ( source_ptr[1] == '=' ) len = 2; else len = 1; } else if ( *source_ptr == '>' ) { if ( source_ptr[1] == '>' ) { if ( source_ptr[2] == '=' ) len = 3; else len = 2; } else if ( source_ptr[1] == '=' ) len = 2; else if ( source_ptr[1] == '>' ) len = 2; else len = 1; } else if ( *source_ptr == '|' ) { if ( source_ptr[1] == '|' ) { if ( source_ptr[2] == '=' ) len = 3; else len = 2; } else if ( source_ptr[1] == '=' ) len = 2; else len = 1; } else if ( *source_ptr == '=' ) { if ( source_ptr[1] == '=' ) len = 2; else if ( source_ptr[1] == '>' ) len = 2; else if ( source_ptr[1] == '<' ) len = 2; else len = 1; } else if ( *source_ptr == '.' ) { if ( source_ptr[1] == '.' ) len = 2; else len = 1; } else if ( strchr( "!&^%*+-/", *source_ptr ) ) { if ( source_ptr[1] == '=' ) len = 2; else if ( strchr( "+-&^", *source_ptr ) && source_ptr[1] == *source_ptr ) len = 2; else len = 1; } if ( len ) { strncpy( buffer, source_ptr, len ); buffer[len] = 0; source_ptr += len; token.code = identifier_search_or_add( buffer ); token.type = IDENTIFIER; token.line = line_count; token.file = current_file; return; } /* Numbers */ if ( ISNUM( *source_ptr ) ) { const char * ptr; double num = 0, dec; int base = 10; /* Hex/Bin/Octal numbers with the h/b/o sufix */ ptr = source_ptr; while ( ISNUM( *ptr ) || ( *ptr >= 'a' && *ptr <= 'f' ) || ( *ptr >= 'A' && *ptr <= 'F' ) ) ptr++; if ( *ptr != 'h' && *ptr != 'H' && *ptr != 'o' && *ptr != 'O' && ( ptr[-1] == 'b' || ptr[-1] == 'B' ) ) ptr--; if ( *ptr == 'b' || *ptr == 'B' ) base = 2; if ( *ptr == 'h' || *ptr == 'H' ) base = 16; if ( *ptr == 'o' || *ptr == 'O' ) base = 8; token.code = 0 ; /* for ints values */ /* Calculate the number value */ while ( ISNUM( *source_ptr ) || ( base > 10 && ISALNUM( *source_ptr ) ) ) { if ( base == 2 && *source_ptr != '0' && *source_ptr != '1' ) break; if ( base == 8 && ( *source_ptr < '0' || *source_ptr > '7' ) ) break; if ( base == 10 && !ISNUM( *source_ptr ) ) break; if ( base == 16 && !ISNUM( *source_ptr ) && ( TOUPPER( *source_ptr ) < 'A' || TOUPPER( *source_ptr ) > 'F' ) ) break; if ( ISNUM( *source_ptr ) ) { num = num * base + ( *source_ptr - '0' ); token.code = token.code * base + ( *source_ptr - '0' ); source_ptr++; continue; } if ( *source_ptr >= 'a' && *source_ptr <= 'f' && base > 10 ) { num = num * base + ( *source_ptr - 'a' + 10 ); token.code = token.code * base + ( *source_ptr - 'a' + 10 ); source_ptr++; continue; } if ( *source_ptr >= 'A' && *source_ptr <= 'F' && base > 10 ) { num = num * base + ( *source_ptr - 'A' + 10 ); token.code = token.code * base + ( *source_ptr - 'A' + 10 ); source_ptr++; continue; } } token.type = NUMBER; token.value = ( float )num; /* We have the integer part now - convert to int/float */ if ( *source_ptr == '.' && base == 10 ) { source_ptr++; if ( !ISNUM( *source_ptr ) ) source_ptr--; else { dec = 1.0 / ( double )base; while ( ISNUM( *source_ptr ) || ( base > 100 && ISALNUM( *source_ptr ) ) ) { if ( ISNUM( *source_ptr ) ) num = num + dec * ( *source_ptr++ - '0' ); if ( *source_ptr >= 'a' && *source_ptr <= 'f' && base > 10 ) num = num + dec * ( *source_ptr++ - 'a' + 10 ); if ( *source_ptr >= 'A' && *source_ptr <= 'F' && base > 10 ) num = num + dec * ( *source_ptr++ - 'A' + 10 ); dec /= ( double )base; } token.type = FLOAT; token.value = ( float )num; } } /* Skip the base sufix */ if ( base == 16 && ( *source_ptr == 'h' || *source_ptr == 'H' ) ) source_ptr++; if ( base == 8 && ( *source_ptr == 'o' || *source_ptr == 'O' ) ) source_ptr++; if ( base == 2 && ( *source_ptr == 'b' || *source_ptr == 'B' ) ) source_ptr++; token.line = line_count; token.file = current_file; return; } /* Identificadores */ if ( ISWORDFIRST( *source_ptr ) ) { int maybe_label = source_ptr[-1] == '\n'; GET_NEXT_TOKEN_IN_TMPBUFFER; token.line = line_count; token.file = current_file; if ( maybe_label && *source_ptr == ':' ) { source_ptr++; token.code = identifier_search_or_add( buffer ); token.type = LABEL; return; } /* Search for #define constant inclusion at this point */ if ( !disable_expand_defines ) { if ( !strcmp( buffer, "__FILE__" ) ) { token.type = STRING; token.code = string_new(( current_file != -1 && files[current_file] && *files[current_file] ) ? files[current_file] : "N/A" ); token.line = line_count; token.file = current_file; return; } if ( !strcmp( buffer, "__LINE__" ) ) { token.type = NUMBER; token.code = ( int )line_count; token.value = ( float )line_count; token.line = line_count; token.file = current_file; return; } for ( i = 0; i < defines_count; i++ ) { if ( defines[i].code == token.code ) { preprocessor_expand( &defines[i] ); token_next(); token.line = line_count; token.file = current_file; return; } } } /* In a #if, all identifiers are strings */ if ( identifiers_as_strings ) { token.type = STRING; token.code = string_new( buffer ); token.line = line_count; token.file = current_file; return; } /* Include */ if ( !disable_prepro && token.code == identifier_include && !use_saved ) { include_file( 0 ); return; } return; } /* 1-char operator or invalid symbol */ if ( !*source_ptr ) break; if ( *source_ptr > 0 && *source_ptr < 32 ) compile_error( MSG_INVALID_CHAR ); *buffer_ptr++ = *source_ptr++; *buffer_ptr = 0; token.code = identifier_search_or_add( buffer ); token.type = IDENTIFIER; token.line = line_count; token.file = current_file; return; } token.type = NOTOKEN; return; /* End-of-file */ }
int main(int argc, const char **argv, char * const *envp) { // Path void *MainAddr = (void*) (intptr_t) GetExecutablePath; llvm::sys::Path Path = GetExecutablePath(argv[0]); // DiagnosticOptions DiagnosticOptions diagnosticOptions; // DiagnosticClient TextDiagnosticPrinter *DiagClient = new TextDiagnosticPrinter(llvm::outs(), diagnosticOptions); // Diagnostic llvm::IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); Diagnostic diagnostic(DiagID, DiagClient); //DiagnosticOptions DiagOpts; //llvm::IntrusiveRefCntPtr<Diagnostic> diagnostic = CompilerInstance::createDiagnostics(DiagOpts, argc, argv); // LangOptions LangOptions langOptions; langOptions.CPlusPlus = 1; langOptions.CPlusPlus0x = 1; langOptions.Microsoft = 1; langOptions.Bool = 1; langOptions.Exceptions = 1; langOptions.CXXExceptions = 1; langOptions.EmitAllDecls = 1; // FileManager FileSystemOptions fileSystemOptions; FileManager fileManager(fileSystemOptions); // SourceManager SourceManager sourceManager(diagnostic, fileManager); // HeadderSearch HeaderSearch headerSearch(fileManager); // TargetOptions TargetOptions targetOptions; targetOptions.Triple = llvm::sys::getHostTriple(); // TargetInfo TargetInfo *pTargetInfo = TargetInfo::CreateTargetInfo( diagnostic, targetOptions); // HeaderSearchOptions HeaderSearchOptions headerSearchOptions; ApplyHeaderSearchOptions( headerSearch, headerSearchOptions, langOptions, pTargetInfo->getTriple()); // Preprocessor Preprocessor preprocessor( diagnostic, langOptions, *pTargetInfo, sourceManager, headerSearch); // PreprocessorOptions PreprocessorOptions preprocessorOptions; preprocessorOptions.DetailedRecord = true; preprocessor.createPreprocessingRecord(); // FrontendOptions FrontendOptions frontendOptions; // InitializePreprocessor InitializePreprocessor( preprocessor, preprocessorOptions, headerSearchOptions, frontendOptions); //preprocessor.SetCommentRetentionState(true, true); // Tutorial const FileEntry *pFile = fileManager.getFile( "test.cpp", true); sourceManager.createMainFileID(pFile); /*preprocessor.EnterMainSourceFile(); Token Tok; do { preprocessor.Lex(Tok); // read one token //if (context.diags.hasErrorOccurred()) // stop lexing/pp on error // break; preprocessor.DumpToken(Tok); // outputs to cerr std::cerr << std::endl; } while (Tok.isNot(tok::eof));*/ const TargetInfo &targetInfo = *pTargetInfo; IdentifierTable identifierTable(langOptions); SelectorTable selectorTable; Builtin::Context builtinContext(targetInfo); ASTContext astContext( langOptions, sourceManager, targetInfo, identifierTable, selectorTable, builtinContext, 0 /* size_reserve*/); // ASTConsumer astConsumer; MyASTConsumer astConsumer; astConsumer.sourceManager = &sourceManager; astConsumer.html = new ClangDocHTML; astConsumer.html->astConsumer = &astConsumer; preprocessor.addPPCallbacks(astConsumer.html); preprocessor.AddCommentHandler(astConsumer.html); Sema sema( preprocessor, astContext, astConsumer); sema.Initialize(); //MySemanticAnalisys mySema( preprocessor, astContext, astConsumer); //Parser parser( preprocessor, sema); //parser.ParseTranslationUnit(); astConsumer.preprocessor = &sema.PP; ParseAST(preprocessor, &astConsumer, astContext); return 0; }
unsigned int CppCheck::processFile(const std::string& filename) { exitcode = 0; // only show debug warnings for accepted C/C++ source files if (!Path::acceptFile(filename)) _settings.debugwarnings = false; if (_settings.terminated()) return exitcode; if (_settings._errorsOnly == false) { std::string fixedpath = Path::simplifyPath(filename.c_str()); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + std::string("...")); } try { Preprocessor preprocessor(&_settings, this); std::list<std::string> configurations; std::string filedata = ""; if (!_fileContent.empty()) { // File content was given as a string std::istringstream iss(_fileContent); preprocessor.preprocess(iss, filedata, configurations, filename, _settings._includePaths); } else { // Only file name was given, read the content from file std::ifstream fin(filename.c_str()); Timer t("Preprocessor::preprocess", _settings._showtime, &S_timerResults); preprocessor.preprocess(fin, filedata, configurations, filename, _settings._includePaths); } if (_settings.checkConfiguration) { return 0; } if (!_settings.userDefines.empty()) { configurations.clear(); configurations.push_back(_settings.userDefines); } if (!_settings._force && configurations.size() > _settings._maxConfigs) { const std::string fixedpath = Path::toNativeSeparators(filename); ErrorLogger::ErrorMessage::FileLocation location; location.setfile(fixedpath); const std::list<ErrorLogger::ErrorMessage::FileLocation> loclist(1, location); std::ostringstream msg; msg << "Too many #ifdef configurations - cppcheck will only check " << _settings._maxConfigs << " of " << configurations.size() << ".\n" "The checking of the file will be interrupted because there are too many " "#ifdef configurations. Checking of all #ifdef configurations can be forced " "by --force command line option or from GUI preferences. However that may " "increase the checking time."; ErrorLogger::ErrorMessage errmsg(loclist, Severity::information, msg.str(), "toomanyconfigs", false); reportErr(errmsg); } unsigned int checkCount = 0; for (std::list<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it) { // Check only a few configurations (default 12), after that bail out, unless --force // was used. if (!_settings._force && checkCount >= _settings._maxConfigs) { const std::string fixedpath = Path::toNativeSeparators(filename); ErrorLogger::ErrorMessage::FileLocation location; location.setfile(fixedpath); std::list<ErrorLogger::ErrorMessage::FileLocation> loclist; loclist.push_back(location); ErrorLogger::ErrorMessage errmsg(loclist, Severity::information, "Interrupted checking because of too many #ifdef configurations.", "toomanyconfigs", false); reportInfo(errmsg); break; } cfg = *it; // If only errors are printed, print filename after the check if (_settings._errorsOnly == false && it != configurations.begin()) { std::string fixedpath = Path::simplifyPath(filename.c_str()); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + ": " + cfg + std::string("...")); } Timer t("Preprocessor::getcode", _settings._showtime, &S_timerResults); const std::string codeWithoutCfg = preprocessor.getcode(filedata, *it, filename, _settings.userDefines.empty()); t.Stop(); const std::string &appendCode = _settings.append(); if (_settings.debugFalsePositive) { if (findError(codeWithoutCfg + appendCode, filename.c_str())) { return exitcode; } } else { checkFile(codeWithoutCfg + appendCode, filename.c_str()); } ++checkCount; } } catch (const std::runtime_error &e) { // Exception was thrown when checking this file.. const std::string fixedpath = Path::toNativeSeparators(filename); _errorLogger.reportOut("Bailing out from checking " + fixedpath + ": " + e.what()); } if (!_settings._errorsOnly) reportUnmatchedSuppressions(_settings.nomsg.getUnmatchedLocalSuppressions(filename)); _errorList.clear(); return exitcode; }
TestResult check(const TestEntry & entry) { try { DB::Context context; auto storage_distributed_visits = StorageDistributedFake::create("remote_db", "remote_visits", entry.shard_count); auto storage_distributed_hits = StorageDistributedFake::create("distant_db", "distant_hits", entry.shard_count); DB::DatabasePtr database = std::make_shared<DB::DatabaseOrdinary>("test", "./metadata/test/"); context.addDatabase("test", database); database->attachTable("visits_all", storage_distributed_visits); database->attachTable("hits_all", storage_distributed_hits); context.setCurrentDatabase("test"); auto & settings = context.getSettingsRef(); settings.distributed_product_mode = entry.mode; /// Парсить и обработать входящий запрос. DB::ASTPtr ast_input; if (!parse(ast_input, entry.input)) return TestResult(false, "parse error"); auto select_query = typeid_cast<DB::ASTSelectQuery *>(&*ast_input); bool success = true; try { DB::InJoinSubqueriesPreprocessor<StorageDistributedFake> preprocessor(select_query, context, storage_distributed_visits); preprocessor.perform(); } catch (const DB::Exception & ex) { if (ex.code() == DB::ErrorCodes::DISTRIBUTED_IN_JOIN_SUBQUERY_DENIED) success = false; else throw; } catch (...) { throw; } if (success != entry.expected_success) return TestResult(false, "unexpected result"); /// Парсить ожидаемый результат. DB::ASTPtr ast_expected; if (!parse(ast_expected, entry.expected_output)) return TestResult(false, "parse error"); /// Сравнить обработанный запрос и ожидаемый результат. bool res = equals(ast_input, ast_expected); std::string output = DB::queryToString(ast_input); return TestResult(res, output); } catch (DB::Exception & e) { return TestResult(false, e.displayText()); } }
int main() { clang::DiagnosticOptions diagnosticOptions; clang::TextDiagnosticPrinter *pTextDiagnosticPrinter = new clang::TextDiagnosticPrinter( llvm::outs(), diagnosticOptions); llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> pDiagIDs; // THis cannot be right clang::DiagnosticsEngine *pDiagnosticsEngine = new clang::DiagnosticsEngine(pDiagIDs, pTextDiagnosticPrinter); clang::LangOptions languageOptions; clang::FileSystemOptions fileSystemOptions; clang::FileManager fileManager(fileSystemOptions); clang::SourceManager sourceManager( *pDiagnosticsEngine, fileManager); clang::TargetOptions targetOptions; targetOptions.Triple = llvm::sys::getDefaultTargetTriple(); clang::TargetInfo *pTargetInfo = clang::TargetInfo::CreateTargetInfo( *pDiagnosticsEngine, targetOptions); clang::HeaderSearch headerSearch(fileManager, *pDiagnosticsEngine, languageOptions, pTargetInfo); clang::CompilerInstance compInst; clang::Preprocessor preprocessor( *pDiagnosticsEngine, languageOptions, pTargetInfo, sourceManager, headerSearch, compInst); const clang::FileEntry *pFile = fileManager.getFile("test.c"); sourceManager.createMainFileID(pFile); preprocessor.EnterMainSourceFile(); pTextDiagnosticPrinter->BeginSourceFile(languageOptions, &preprocessor); clang::Token token; do { preprocessor.Lex(token); if( pDiagnosticsEngine->hasErrorOccurred()) { break; } preprocessor.DumpToken(token); std::cerr << std::endl; } while( token.isNot(clang::tok::eof)); pTextDiagnosticPrinter->EndSourceFile(); return 0; }
int main() { clang::DiagnosticOptions diagnosticOptions; clang::TextDiagnosticPrinter *pTextDiagnosticPrinter = new clang::TextDiagnosticPrinter( llvm::outs(), diagnosticOptions); llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> pDiagIDs; clang::DiagnosticsEngine *pDiagnosticsEngine = new clang::DiagnosticsEngine(pDiagIDs, pTextDiagnosticPrinter); clang::LangOptions languageOptions; clang::FileSystemOptions fileSystemOptions; clang::FileManager fileManager(fileSystemOptions); clang::SourceManager sourceManager( *pDiagnosticsEngine, fileManager); clang::HeaderSearchOptions headerSearchOptions; // <Warning!!> -- Platform Specific Code lives here // This depends on A) that you're running linux and // B) that you have the same GCC LIBs installed that // I do. // Search through Clang itself for something like this, // go on, you won't find it. The reason why is Clang // has its own versions of std* which are installed under // /usr/local/lib/clang/<version>/include/ // See somewhere around Driver.cpp:77 to see Clang adding // its version of the headers to its include path. headerSearchOptions.AddPath("/usr/include/linux", clang::frontend::Angled, false, false, false); headerSearchOptions.AddPath("/usr/include/c++/4.4/tr1", clang::frontend::Angled, false, false, false); headerSearchOptions.AddPath("/usr/include/c++/4.4", clang::frontend::Angled, false, false, false); // </Warning!!> -- End of Platform Specific Code clang::TargetOptions targetOptions; targetOptions.Triple = llvm::sys::getDefaultTargetTriple(); clang::TargetInfo *pTargetInfo = clang::TargetInfo::CreateTargetInfo( *pDiagnosticsEngine, targetOptions); clang::HeaderSearch headerSearch(fileManager, *pDiagnosticsEngine, languageOptions, pTargetInfo); clang::CompilerInstance compInst; clang::Preprocessor preprocessor( *pDiagnosticsEngine, languageOptions, pTargetInfo, sourceManager, headerSearch, compInst); clang::PreprocessorOptions preprocessorOptions; clang::FrontendOptions frontendOptions; clang::InitializePreprocessor( preprocessor, preprocessorOptions, headerSearchOptions, frontendOptions); const clang::FileEntry *pFile = fileManager.getFile( "input04.c"); sourceManager.createMainFileID(pFile); const clang::TargetInfo &targetInfo = *pTargetInfo; clang::IdentifierTable identifierTable(languageOptions); clang::SelectorTable selectorTable; clang::Builtin::Context builtinContext; builtinContext.InitializeTarget(targetInfo); clang::ASTContext astContext( languageOptions, sourceManager, pTargetInfo, identifierTable, selectorTable, builtinContext, 0 /* size_reserve*/); MyASTConsumer astConsumer; clang::Sema sema( preprocessor, astContext, astConsumer); pTextDiagnosticPrinter->BeginSourceFile(languageOptions, &preprocessor); clang::ParseAST(preprocessor, &astConsumer, astContext); pTextDiagnosticPrinter->EndSourceFile(); return 0; }
unsigned int CppCheck::processFile(const std::string& filename, const std::string &cfgname, std::istream& fileStream) { exitcode = 0; // only show debug warnings for accepted C/C++ source files if (!Path::acceptFile(filename)) _settings.debugwarnings = false; if (_settings.terminated()) return exitcode; if (!_settings.quiet) { std::string fixedpath = Path::simplifyPath(filename); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + ' ' + cfgname + std::string("...")); if (_settings.verbose) { _errorLogger.reportOut("Defines: " + _settings.userDefines); std::string includePaths; for (std::list<std::string>::const_iterator I = _settings.includePaths.begin(); I != _settings.includePaths.end(); ++I) includePaths += " -I" + *I; _errorLogger.reportOut("Includes:" + includePaths); _errorLogger.reportOut(std::string("Platform:") + _settings.platformString()); } } if (plistFile.is_open()) { plistFile << ErrorLogger::plistFooter(); plistFile.close(); } CheckUnusedFunctions checkUnusedFunctions(nullptr, nullptr, nullptr); bool internalErrorFound(false); try { Preprocessor preprocessor(_settings, this); std::set<std::string> configurations; simplecpp::OutputList outputList; std::vector<std::string> files; simplecpp::TokenList tokens1(fileStream, files, filename, &outputList); // If there is a syntax error, report it and stop for (simplecpp::OutputList::const_iterator it = outputList.begin(); it != outputList.end(); ++it) { bool err; switch (it->type) { case simplecpp::Output::ERROR: case simplecpp::Output::INCLUDE_NESTED_TOO_DEEPLY: case simplecpp::Output::SYNTAX_ERROR: case simplecpp::Output::UNHANDLED_CHAR_ERROR: err = true; break; case simplecpp::Output::WARNING: case simplecpp::Output::MISSING_HEADER: case simplecpp::Output::PORTABILITY_BACKSLASH: err = false; break; }; if (err) { const ErrorLogger::ErrorMessage::FileLocation loc1(it->location.file(), it->location.line); std::list<ErrorLogger::ErrorMessage::FileLocation> callstack; callstack.push_back(loc1); ErrorLogger::ErrorMessage errmsg(callstack, "", Severity::error, it->msg, "syntaxError", false); _errorLogger.reportErr(errmsg); return 1; } } preprocessor.loadFiles(tokens1, files); if (!_settings.plistOutput.empty()) { std::string filename2; if (filename.find('/') != std::string::npos) filename2 = filename.substr(filename.rfind('/') + 1); else filename2 = filename; filename2 = _settings.plistOutput + filename2.substr(0, filename2.find('.')) + ".plist"; plistFile.open(filename2); plistFile << ErrorLogger::plistHeader(version(), files); } // write dump file xml prolog std::ofstream fdump; if (_settings.dump) { const std::string dumpfile(_settings.dumpFile.empty() ? (filename + ".dump") : _settings.dumpFile); fdump.open(dumpfile.c_str()); if (fdump.is_open()) { fdump << "<?xml version=\"1.0\"?>" << std::endl; fdump << "<dumps>" << std::endl; fdump << " <platform" << " name=\"" << _settings.platformString() << '\"' << " char_bit=\"" << _settings.char_bit << '\"' << " short_bit=\"" << _settings.short_bit << '\"' << " int_bit=\"" << _settings.int_bit << '\"' << " long_bit=\"" << _settings.long_bit << '\"' << " long_long_bit=\"" << _settings.long_long_bit << '\"' << " pointer_bit=\"" << (_settings.sizeof_pointer * _settings.char_bit) << '\"' << "/>\n"; fdump << " <rawtokens>" << std::endl; for (unsigned int i = 0; i < files.size(); ++i) fdump << " <file index=\"" << i << "\" name=\"" << ErrorLogger::toxml(files[i]) << "\"/>" << std::endl; for (const simplecpp::Token *tok = tokens1.cfront(); tok; tok = tok->next) { fdump << " <tok " << "fileIndex=\"" << tok->location.fileIndex << "\" " << "linenr=\"" << tok->location.line << "\" " << "str=\"" << ErrorLogger::toxml(tok->str) << "\"" << "/>" << std::endl; } fdump << " </rawtokens>" << std::endl; } } // Parse comments and then remove them preprocessor.inlineSuppressions(tokens1); tokens1.removeComments(); preprocessor.removeComments(); if (!_settings.buildDir.empty()) { // Get toolinfo std::string toolinfo; toolinfo += CPPCHECK_VERSION_STRING; toolinfo += _settings.isEnabled(Settings::WARNING) ? 'w' : ' '; toolinfo += _settings.isEnabled(Settings::STYLE) ? 's' : ' '; toolinfo += _settings.isEnabled(Settings::PERFORMANCE) ? 'p' : ' '; toolinfo += _settings.isEnabled(Settings::PORTABILITY) ? 'p' : ' '; toolinfo += _settings.isEnabled(Settings::INFORMATION) ? 'i' : ' '; toolinfo += _settings.userDefines; // Calculate checksum so it can be compared with old checksum / future checksums const unsigned int checksum = preprocessor.calculateChecksum(tokens1, toolinfo); std::list<ErrorLogger::ErrorMessage> errors; if (!analyzerInformation.analyzeFile(_settings.buildDir, filename, cfgname, checksum, &errors)) { while (!errors.empty()) { reportErr(errors.front()); errors.pop_front(); } return exitcode; // known results => no need to reanalyze file } } // Get directives preprocessor.setDirectives(tokens1); preprocessor.simplifyPragmaAsm(&tokens1); preprocessor.setPlatformInfo(&tokens1); // Get configurations.. if (_settings.userDefines.empty() || _settings.force) { Timer t("Preprocessor::getConfigs", _settings.showtime, &S_timerResults); configurations = preprocessor.getConfigs(tokens1); } else { configurations.insert(_settings.userDefines); } if (_settings.checkConfiguration) { for (std::set<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it) (void)preprocessor.getcode(tokens1, *it, files, true); return 0; } // Run define rules on raw code for (std::list<Settings::Rule>::const_iterator it = _settings.rules.begin(); it != _settings.rules.end(); ++it) { if (it->tokenlist != "define") continue; std::string code; const std::list<Directive> &directives = preprocessor.getDirectives(); for (std::list<Directive>::const_iterator dir = directives.begin(); dir != directives.end(); ++dir) { if (dir->str.compare(0,8,"#define ") == 0) code += "#line " + MathLib::toString(dir->linenr) + " \"" + dir->file + "\"\n" + dir->str + '\n'; } Tokenizer tokenizer2(&_settings, this); std::istringstream istr2(code); tokenizer2.list.createTokens(istr2); executeRules("define", tokenizer2); break; } if (!_settings.force && configurations.size() > _settings.maxConfigs) { if (_settings.isEnabled(Settings::INFORMATION)) { tooManyConfigsError(Path::toNativeSeparators(filename),configurations.size()); } else { tooManyConfigs = true; } } std::set<unsigned long long> checksums; unsigned int checkCount = 0; for (std::set<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it) { // bail out if terminated if (_settings.terminated()) break; // Check only a few configurations (default 12), after that bail out, unless --force // was used. if (!_settings.force && ++checkCount > _settings.maxConfigs) break; cfg = *it; // If only errors are printed, print filename after the check if (!_settings.quiet && (!cfg.empty() || it != configurations.begin())) { std::string fixedpath = Path::simplifyPath(filename); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut("Checking " + fixedpath + ": " + cfg + "..."); } if (!_settings.userDefines.empty()) { if (!cfg.empty()) cfg = ";" + cfg; cfg = _settings.userDefines + cfg; } if (_settings.preprocessOnly) { Timer t("Preprocessor::getcode", _settings.showtime, &S_timerResults); std::string codeWithoutCfg = preprocessor.getcode(tokens1, cfg, files, true); t.Stop(); if (codeWithoutCfg.compare(0,5,"#file") == 0) codeWithoutCfg.insert(0U, "//"); std::string::size_type pos = 0; while ((pos = codeWithoutCfg.find("\n#file",pos)) != std::string::npos) codeWithoutCfg.insert(pos+1U, "//"); pos = 0; while ((pos = codeWithoutCfg.find("\n#endfile",pos)) != std::string::npos) codeWithoutCfg.insert(pos+1U, "//"); pos = 0; while ((pos = codeWithoutCfg.find(Preprocessor::macroChar,pos)) != std::string::npos) codeWithoutCfg[pos] = ' '; reportOut(codeWithoutCfg); continue; } Tokenizer _tokenizer(&_settings, this); if (_settings.showtime != SHOWTIME_NONE) _tokenizer.setTimerResults(&S_timerResults); try { bool result; // Create tokens, skip rest of iteration if failed Timer timer("Tokenizer::createTokens", _settings.showtime, &S_timerResults); const simplecpp::TokenList &tokensP = preprocessor.preprocess(tokens1, cfg, files); _tokenizer.createTokens(&tokensP); timer.Stop(); if (tokensP.empty()) continue; // skip rest of iteration if just checking configuration if (_settings.checkConfiguration) continue; // Check raw tokens checkRawTokens(_tokenizer); // Simplify tokens into normal form, skip rest of iteration if failed Timer timer2("Tokenizer::simplifyTokens1", _settings.showtime, &S_timerResults); result = _tokenizer.simplifyTokens1(cfg); timer2.Stop(); if (!result) continue; // dump xml if --dump if (_settings.dump && fdump.is_open()) { fdump << "<dump cfg=\"" << ErrorLogger::toxml(cfg) << "\">" << std::endl; preprocessor.dump(fdump); _tokenizer.dump(fdump); fdump << "</dump>" << std::endl; } // Skip if we already met the same simplified token list if (_settings.force || _settings.maxConfigs > 1) { const unsigned long long checksum = _tokenizer.list.calculateChecksum(); if (checksums.find(checksum) != checksums.end()) { if (_settings.isEnabled(Settings::INFORMATION) && (_settings.debug || _settings.verbose)) purgedConfigurationMessage(filename, cfg); continue; } checksums.insert(checksum); } // Check normal tokens checkNormalTokens(_tokenizer); // Analyze info.. if (!_settings.buildDir.empty()) checkUnusedFunctions.parseTokens(_tokenizer, filename.c_str(), &_settings, false); // simplify more if required, skip rest of iteration if failed if (_simplify) { // if further simplification fails then skip rest of iteration Timer timer3("Tokenizer::simplifyTokenList2", _settings.showtime, &S_timerResults); result = _tokenizer.simplifyTokenList2(); timer3.Stop(); if (!result) continue; // Check simplified tokens checkSimplifiedTokens(_tokenizer); } } catch (const InternalError &e) { internalErrorFound=true; std::list<ErrorLogger::ErrorMessage::FileLocation> locationList; ErrorLogger::ErrorMessage::FileLocation loc; if (e.token) { loc.line = e.token->linenr(); const std::string fixedpath = Path::toNativeSeparators(_tokenizer.list.file(e.token)); loc.setfile(fixedpath); } else { ErrorLogger::ErrorMessage::FileLocation loc2; loc2.setfile(Path::toNativeSeparators(filename)); locationList.push_back(loc2); loc.setfile(_tokenizer.list.getSourceFilePath()); } locationList.push_back(loc); ErrorLogger::ErrorMessage errmsg(locationList, _tokenizer.list.getSourceFilePath(), Severity::error, e.errorMessage, e.id, false); reportErr(errmsg); } } // dumped all configs, close root </dumps> element now if (_settings.dump && fdump.is_open()) fdump << "</dumps>" << std::endl; } catch (const std::runtime_error &e) { internalError(filename, e.what()); } catch (const std::bad_alloc &e) { internalError(filename, e.what()); } catch (const InternalError &e) { internalError(filename, e.errorMessage); exitcode=1; // e.g. reflect a syntax error } analyzerInformation.setFileInfo("CheckUnusedFunctions", checkUnusedFunctions.analyzerInfo()); analyzerInformation.close(); // In jointSuppressionReport mode, unmatched suppressions are // collected after all files are processed if (!_settings.jointSuppressionReport && (_settings.isEnabled(Settings::INFORMATION) || _settings.checkConfiguration)) { reportUnmatchedSuppressions(_settings.nomsg.getUnmatchedLocalSuppressions(filename, isUnusedFunctionCheckEnabled())); } _errorList.clear(); if (internalErrorFound && (exitcode==0)) { exitcode=1; } return exitcode; }
unsigned int CppCheck::processFile(const std::string& filename, std::istream& fileStream) { exitcode = 0; // only show debug warnings for accepted C/C++ source files if (!Path::acceptFile(filename)) _settings.debugwarnings = false; if (_settings.terminated()) return exitcode; if (_settings.quiet == false) { std::string fixedpath = Path::simplifyPath(filename); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + std::string("...")); } bool internalErrorFound(false); try { Preprocessor preprocessor(_settings, this); std::list<std::string> configurations; std::string filedata; { Timer t("Preprocessor::preprocess", _settings.showtime, &S_timerResults); preprocessor.preprocess(fileStream, filedata, configurations, filename, _settings.includePaths); } if (_settings.checkConfiguration) { return 0; } // Run define rules on raw code for (std::list<Settings::Rule>::const_iterator it = _settings.rules.begin(); it != _settings.rules.end(); ++it) { if (it->tokenlist == "define") { Tokenizer tokenizer2(&_settings, this); std::istringstream istr2(filedata); tokenizer2.list.createTokens(istr2, filename); for (const Token *tok = tokenizer2.list.front(); tok; tok = tok->next()) { if (tok->str() == "#define") { std::string code = std::string(tok->linenr()-1U, '\n'); for (const Token *tok2 = tok; tok2 && tok2->linenr() == tok->linenr(); tok2 = tok2->next()) code += " " + tok2->str(); Tokenizer tokenizer3(&_settings, this); std::istringstream istr3(code); tokenizer3.list.createTokens(istr3, tokenizer2.list.file(tok)); executeRules("define", tokenizer3); } } break; } } if (!_settings.userDefines.empty() && _settings.maxConfigs==1U) { configurations.clear(); configurations.push_back(_settings.userDefines); } if (!_settings.force && configurations.size() > _settings.maxConfigs) { if (_settings.isEnabled("information")) { tooManyConfigsError(Path::toNativeSeparators(filename),configurations.size()); } else { tooManyConfigs = true; } } // write dump file xml prolog std::ofstream fdump; if (_settings.dump) { const std::string dumpfile(filename + ".dump"); fdump.open(dumpfile.c_str()); if (fdump.is_open()) { fdump << "<?xml version=\"1.0\"?>" << std::endl; fdump << "<dumps>" << std::endl; } } std::set<unsigned long long> checksums; unsigned int checkCount = 0; for (std::list<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it) { // bail out if terminated if (_settings.terminated()) break; // Check only a few configurations (default 12), after that bail out, unless --force // was used. if (!_settings.force && ++checkCount > _settings.maxConfigs) break; cfg = *it; // If only errors are printed, print filename after the check if (_settings.quiet == false && it != configurations.begin()) { std::string fixedpath = Path::simplifyPath(filename); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut("Checking " + fixedpath + ": " + cfg + "..."); } if (!_settings.userDefines.empty()) { if (!cfg.empty()) cfg = ";" + cfg; cfg = _settings.userDefines + cfg; } Timer t("Preprocessor::getcode", _settings.showtime, &S_timerResults); std::string codeWithoutCfg = preprocessor.getcode(filedata, cfg, filename); t.Stop(); codeWithoutCfg += _settings.append(); if (_settings.preprocessOnly) { if (codeWithoutCfg.compare(0,5,"#file") == 0) codeWithoutCfg.insert(0U, "//"); std::string::size_type pos = 0; while ((pos = codeWithoutCfg.find("\n#file",pos)) != std::string::npos) codeWithoutCfg.insert(pos+1U, "//"); pos = 0; while ((pos = codeWithoutCfg.find("\n#endfile",pos)) != std::string::npos) codeWithoutCfg.insert(pos+1U, "//"); pos = 0; while ((pos = codeWithoutCfg.find(Preprocessor::macroChar,pos)) != std::string::npos) codeWithoutCfg[pos] = ' '; reportOut(codeWithoutCfg); continue; } Tokenizer _tokenizer(&_settings, this); if (_settings.showtime != SHOWTIME_NONE) _tokenizer.setTimerResults(&S_timerResults); try { // Create tokens, skip rest of iteration if failed std::istringstream istr(codeWithoutCfg); Timer timer("Tokenizer::createTokens", _settings.showtime, &S_timerResults); bool result = _tokenizer.createTokens(istr, filename.c_str()); timer.Stop(); if (!result) continue; // skip rest of iteration if just checking configuration if (_settings.checkConfiguration) continue; // Check raw tokens checkRawTokens(_tokenizer); // Simplify tokens into normal form, skip rest of iteration if failed Timer timer2("Tokenizer::simplifyTokens1", _settings.showtime, &S_timerResults); result = _tokenizer.simplifyTokens1(cfg); timer2.Stop(); if (!result) continue; // dump xml if --dump if (_settings.dump && fdump.is_open()) { fdump << "<dump cfg=\"" << cfg << "\">" << std::endl; preprocessor.dump(fdump); _tokenizer.dump(fdump); fdump << "</dump>" << std::endl; } // Skip if we already met the same simplified token list if (_settings.force || _settings.maxConfigs > 1) { const unsigned long long checksum = _tokenizer.list.calculateChecksum(); if (checksums.find(checksum) != checksums.end()) continue; checksums.insert(checksum); } // Check normal tokens checkNormalTokens(_tokenizer); // simplify more if required, skip rest of iteration if failed if (_simplify) { // if further simplification fails then skip rest of iteration Timer timer3("Tokenizer::simplifyTokenList2", _settings.showtime, &S_timerResults); result = _tokenizer.simplifyTokenList2(); timer3.Stop(); if (!result) continue; // Check simplified tokens checkSimplifiedTokens(_tokenizer); } } catch (const InternalError &e) { if (_settings.isEnabled("information") && (_settings.debug || _settings.verbose)) purgedConfigurationMessage(filename, cfg); internalErrorFound=true; std::list<ErrorLogger::ErrorMessage::FileLocation> locationList; ErrorLogger::ErrorMessage::FileLocation loc; if (e.token) { loc.line = e.token->linenr(); const std::string fixedpath = Path::toNativeSeparators(_tokenizer.list.file(e.token)); loc.setfile(fixedpath); } else { ErrorLogger::ErrorMessage::FileLocation loc2; loc2.setfile(Path::toNativeSeparators(filename.c_str())); locationList.push_back(loc2); loc.setfile(_tokenizer.list.getSourceFilePath()); } locationList.push_back(loc); const ErrorLogger::ErrorMessage errmsg(locationList, Severity::error, e.errorMessage, e.id, false); reportErr(errmsg); } } // dumped all configs, close root </dumps> element now if (_settings.dump && fdump.is_open()) fdump << "</dumps>" << std::endl; } catch (const std::runtime_error &e) { internalError(filename, e.what()); } catch (const InternalError &e) { internalError(filename, e.errorMessage); exitcode=1; // e.g. reflect a syntax error } // In jointSuppressionReport mode, unmatched suppressions are // collected after all files are processed if (!_settings.jointSuppressionReport && (_settings.isEnabled("information") || _settings.checkConfiguration)) { reportUnmatchedSuppressions(_settings.nomsg.getUnmatchedLocalSuppressions(filename, unusedFunctionCheckIsEnabled())); } _errorList.clear(); if (internalErrorFound && (exitcode==0)) { exitcode=1; } return exitcode; }
unsigned int CppCheck::processFile(const std::string& filename) { exitcode = 0; // only show debug warnings for accepted C/C++ source files if (!Path::acceptFile(filename)) _settings.debugwarnings = false; if (_settings.terminated()) return exitcode; if (_settings._errorsOnly == false) { std::string fixedpath = Path::simplifyPath(filename.c_str()); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + std::string("...")); } try { Preprocessor preprocessor(&_settings, this); std::list<std::string> configurations; std::string filedata = ""; if (!_fileContent.empty()) { // File content was given as a string std::istringstream iss(_fileContent); preprocessor.preprocess(iss, filedata, configurations, filename, _settings._includePaths); } else { // Only file name was given, read the content from file std::ifstream fin(filename.c_str()); Timer t("Preprocessor::preprocess", _settings._showtime, &S_timerResults); preprocessor.preprocess(fin, filedata, configurations, filename, _settings._includePaths); } if (_settings.checkConfiguration) { return 0; } if (!_settings.userDefines.empty()) { configurations.clear(); configurations.push_back(_settings.userDefines); } if (!_settings._force && configurations.size() > _settings._maxConfigs) { if (_settings.isEnabled("information")) { tooManyConfigsError(Path::toNativeSeparators(filename),configurations.size()); } else { tooManyConfigs = true; } } unsigned int checkCount = 0; for (std::list<std::string>::const_iterator it = configurations.begin(); it != configurations.end(); ++it) { // Check only a few configurations (default 12), after that bail out, unless --force // was used. if (!_settings._force && ++checkCount > _settings._maxConfigs) break; cfg = *it; // If only errors are printed, print filename after the check if (_settings._errorsOnly == false && it != configurations.begin()) { std::string fixedpath = Path::simplifyPath(filename.c_str()); fixedpath = Path::toNativeSeparators(fixedpath); _errorLogger.reportOut(std::string("Checking ") + fixedpath + ": " + cfg + std::string("...")); } Timer t("Preprocessor::getcode", _settings._showtime, &S_timerResults); const std::string codeWithoutCfg = preprocessor.getcode(filedata, *it, filename, _settings.userDefines.empty()); t.Stop(); const std::string &appendCode = _settings.append(); if (_settings.debugFalsePositive) { if (findError(codeWithoutCfg + appendCode, filename.c_str())) { return exitcode; } } else { checkFile(codeWithoutCfg + appendCode, filename.c_str()); } } } catch (const std::runtime_error &e) { internalError(filename, e.what()); } catch (const InternalError &e) { internalError(filename, e.errorMessage); } if (!_settings._errorsOnly) reportUnmatchedSuppressions(_settings.nomsg.getUnmatchedLocalSuppressions(filename)); _errorList.clear(); return exitcode; }
std::vector<std::string> getLocalizedStringFromFile(std::string filename, std::string triple, std::vector<std::string> includepaths) { clang::DiagnosticOptions diagnosticOptions; clang::TextDiagnosticPrinter *pTextDiagnosticPrinter = new clang::TextDiagnosticPrinter( llvm::outs(), &diagnosticOptions); llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> pDiagIDs; clang::DiagnosticsEngine *pDiagnosticsEngine = new clang::DiagnosticsEngine(pDiagIDs, &diagnosticOptions, pTextDiagnosticPrinter); clang::LangOptions languageOptions; clang::FileSystemOptions fileSystemOptions; clang::FileManager fileManager(fileSystemOptions); clang::SourceManager sourceManager( *pDiagnosticsEngine, fileManager); const std::shared_ptr<clang::TargetOptions> targetOptions = std::make_shared<clang::TargetOptions>(); targetOptions->Triple = triple;//"arm-apple-darwin11";//llvm::sys::getDefaultTargetTriple(); clang::TargetInfo *pTargetInfo = clang::TargetInfo::CreateTargetInfo( *pDiagnosticsEngine, targetOptions ); llvm::IntrusiveRefCntPtr<clang::HeaderSearchOptions> headerSearchOptions(new clang::HeaderSearchOptions()); for(unsigned long i = 0 ; i < includepaths.size(); i++) { headerSearchOptions->AddPath(includepaths.at(i), clang::frontend::Angled, false, false); } clang::HeaderSearch headerSearch(headerSearchOptions, sourceManager, *pDiagnosticsEngine, languageOptions, pTargetInfo); /* headerSearchOptions->AddPath("/usr/share/iPhoneOS5.0.sdk/usr/include/c++/4.2.1/tr1/", clang::frontend::Angled, false, false, false); headerSearchOptions->AddPath("/usr/share/iPhoneOS5.0.sdk/usr/include/c++/4.2.1", clang::frontend::Angled, false, false, false); */ clang::CompilerInstance compInst; llvm::IntrusiveRefCntPtr<clang::PreprocessorOptions> pOpts (new clang::PreprocessorOptions()); clang::Preprocessor preprocessor( pOpts, *pDiagnosticsEngine, languageOptions, sourceManager, headerSearch, compInst); preprocessor.Initialize(*pTargetInfo); clang::FrontendOptions frontendOptions; clang::RawPCHContainerReader Reader; clang::InitializePreprocessor( preprocessor, *pOpts, Reader, frontendOptions); clang::ApplyHeaderSearchOptions( headerSearch,//preprocessor.getHeaderSearchInfo(), *headerSearchOptions,//compInst.getHeaderSearchOpts(), preprocessor.getLangOpts(), preprocessor.getTargetInfo().getTriple()); const clang::FileEntry *pFile = fileManager.getFile(filename); //sourceManager.setMainFileID( sourceManager.createFileID( pFile, clang::SourceLocation(), clang::SrcMgr::C_System)); sourceManager.setMainFileID( sourceManager.createFileID( pFile, clang::SourceLocation(), clang::SrcMgr::C_User)); //sourceManager.createMainFileID(pFile); preprocessor.EnterMainSourceFile(); pTextDiagnosticPrinter->BeginSourceFile(languageOptions, &preprocessor); /* * identifier 'localizedStringForKey' * colon ':' * l_paren '(' * unknown '@' * string_literal '"UIAlertView"' * r_paren ')' * */ int found = 0; std::string trans_str; std::vector<std::string> trans_list; clang::Token token; do { preprocessor.Lex(token); if( pDiagnosticsEngine->hasErrorOccurred()) { break; } // if we meet localizedStringForKey, that means we need record it params. if(token.is(clang::tok::identifier) && token.isNot(clang::tok::raw_identifier)) { const clang::IdentifierInfo *II = token.getIdentifierInfo(); if ( II && (strcmp(II->getName().data(), "localizedStringForKey") == 0)) found = 1; } // only string literal we should handle. if(found == 1 && token.is(clang::tok::string_literal)) { std::string got = preprocessor.getSpelling(token); //here, we got a string with "" got = got.substr(1,got.length()-2); //remove "" trans_str += got; // string may split to multiline, we save them all. } // when match ), that means we got what we need. // push it to vector and wait next found == 1; if(found == 1 && token.is(clang::tok::r_paren) && token.isNot(clang::tok::raw_identifier)) { trans_list.push_back(trans_str); trans_str.clear(); found = 0; } } while( token.isNot(clang::tok::eof)); pTextDiagnosticPrinter->EndSourceFile(); /*for(int i = 0; i < trans_list.size(); i++) std::cout<<trans_list[i]<<std::endl; */ return trans_list; }
const string ShaderPreCompiler::LoadAndCompileShader( const string& current_file, string const* current_dir ) { string path; if(!current_dir) path = SolvePath(current_file); else path = *current_dir+"\\"+current_file; File f(path); if(shader_map.find(path) != shader_map.end()) return shader_map[path]; ifstream stream(path); std::stringstream buffer; char cbuffer = 0; std::string _path = f.Path(); try { while (stream.read(&cbuffer,1) > 0) { std::string instruction = ""; std::string value = ""; switch(cbuffer) { case '#': while(stream.read(&cbuffer,1) > 0 && cbuffer != ' ') instruction += cbuffer; while(stream.read(&cbuffer,1) > 0 && cbuffer != '\n') value += cbuffer; value += '\n'; switch(preprocessor(instruction)) { case PREPROCESSOR_INCLUDE: if(value.find_first_of('"') != std::string::npos) buffer << LoadAndCompileShader(value.substr(value.find_first_of('"')+1, value.find_last_of('"')-1),&_path); else if(value.find_first_of('<') != std::string::npos) buffer << LoadAndCompileShader(value.substr(value.find_first_of('<')+1, value.find_last_of('>')-1),NULL); break; default: buffer << "#" << instruction << " " << value << "\n"; break; } break; case '\n': buffer << cbuffer; break; case ' ': case '\t': case '\r': continue; default: buffer << cbuffer; while(stream.read(&cbuffer,1) > 0 && cbuffer != '\n') buffer <<cbuffer; buffer << '\n'; break; } } } catch (std::exception e) { printf("ex %s",e.what()); } return buffer.str(); }