Cursor TranslationUnit::cursor() const
{
return clang_getTranslationUnitCursor(cxTranslationUnit());
}
void IndexerJob::execute()
{
if (isAborted())
return;
mTimer.start();
mData.reset(new IndexData);
if (mType == Dump) {
assert(id() != -1);
if (shared_ptr<Project> p = project()) {
for (int i=0; i<mSourceInformation.builds.size(); ++i) {
parse(i);
if (mUnits.at(i).second) {
DumpUserData u = { 0, this, !(queryFlags() & QueryMessage::NoContext) };
clang_visitChildren(clang_getTranslationUnitCursor(mUnits.at(i).second),
IndexerJob::dumpVisitor, &u);
}
}
}
} else {
{
MutexLocker lock(&mMutex);
mStarted = true;
}
int errorCount = 0;
int unitCount = 0;
const int buildCount = mSourceInformation.builds.size();
for (int i=0; i<buildCount; ++i) {
if (!parse(i)) {
goto end;
}
if (mUnits.at(i).second)
++unitCount;
}
mParseTime = time(0);
for (int i=0; i<buildCount; ++i) {
int err = 0;
if (!visit(i) || !diagnose(i, &err))
goto end;
errorCount += err;
}
{
mData->message += mSourceInformation.sourceFile.toTilde();
if (buildCount > 1)
mData->message += String::format<16>(" (%d builds)", buildCount);
if (!unitCount) {
mData->message += " error";
} else if (unitCount != buildCount) {
mData->message += String::format<16>(" (%d errors, %d ok)", buildCount - unitCount, unitCount);
}
mData->message += String::format<16>(" in %sms. ", String::number(mTimer.elapsed()).constData());
if (unitCount) {
mData->message += String::format<1024>("(%d syms, %d symNames, %d refs, %d deps, %d files)",
mData->symbols.size(), mData->symbolNames.size(), mData->references.size(),
mData->dependencies.size(), mVisitedFiles.size());
} else if (mData->dependencies.size()) {
mData->message += String::format<16>("(%d deps)", mData->dependencies.size());
}
if (mType == Dirty)
mData->message += " (dirty)";
}
end:
shared_ptr<Project> p = project();
if (p) {
shared_ptr<IndexerJob> job = static_pointer_cast<IndexerJob>(shared_from_this());
p->onJobFinished(job);
}
}
for (int i=0; i<mUnits.size(); ++i) {
if (mUnits.at(i).first)
clang_disposeIndex(mUnits.at(i).first);
if (mUnits.at(i).second)
clang_disposeTranslationUnit(mUnits.at(i).second);
}
mUnits.clear();
}
cursor translation_unit::get_cursor()
{
return { clang_getTranslationUnitCursor(tu) };
}
CppInstr::eErrorTypes CppInstr::parse(OovStringRef const srcFn, OovStringRef const srcRootDir,
OovStringRef const outDir,
char const * const clang_args[], int num_clang_args)
{
eErrorTypes errType = ET_None;
mOutputFileContents.read(srcFn);
mTopParseFn.setPath(srcFn, FP_File);
FilePath rootDir(srcRootDir, FP_Dir);
setFileDefine(mTopParseFn, rootDir);
CXIndex index = clang_createIndex(1, 1);
// This doesn't appear to change anything.
// clang_toggleCrashRecovery(true);
// Get inclusion directives to be in AST.
unsigned options = 0;
CXTranslationUnit tu;
CXErrorCode errCode = clang_parseTranslationUnit2(index, srcFn,
clang_args, num_clang_args, 0, 0, options, &tu);
if(errCode == CXError_Success)
{
CXCursor rootCursor = clang_getTranslationUnitCursor(tu);
try
{
clang_visitChildren(rootCursor, ::visitTranslationUnit, this);
}
catch(...)
{
errType = ET_ParseError;
sCrashDiagnostics.setCrashed();
}
std::string outFileName;
for(int i=0; i<num_clang_args; i++)
{
std::string testArg = clang_args[i];
if(testArg.compare("-o") == 0)
{
if(i+1 < num_clang_args)
outFileName = clang_args[i+1];
}
}
try
{
mOutputFileContents.write(outFileName);
}
catch(...)
{
errType = ET_ParseError;
}
std::string outErrFileName = outFileName;
outErrFileName += "-err.txt";
size_t numDiags = clang_getNumDiagnostics(tu);
if(numDiags > 0 || sCrashDiagnostics.hasCrashed())
{
FILE *fp = fopen(outErrFileName.c_str(), "w");
if(fp)
{
sCrashDiagnostics.dumpCrashed(fp);
for (size_t i = 0; i<numDiags; i++)
{
CXDiagnostic diag = clang_getDiagnostic(tu, i);
CXDiagnosticSeverity sev = clang_getDiagnosticSeverity(diag);
if(errType == ET_None || errType == ET_CompileWarnings)
{
if(sev >= CXDiagnostic_Error)
errType = ET_CompileErrors;
else
errType = ET_CompileWarnings;
}
CXStringDisposer diagStr = clang_formatDiagnostic(diag,
clang_defaultDiagnosticDisplayOptions());
fprintf(fp, "%s\n", diagStr.c_str());
}
fprintf(fp, "Arguments: %s %s %s ", static_cast<char const *>(srcFn),
static_cast<char const *>(srcRootDir),
static_cast<char const *>(outDir));
for(int i=0 ; i<num_clang_args; i++)
{
fprintf(fp, "%s ", clang_args[i]);
}
fprintf(fp, "\n");
fclose(fp);
}
}
else
{
unlink(outErrFileName.c_str());
}
FilePath covDir(outDir, FP_Dir);
updateCoverageHeader(mTopParseFn, covDir, mInstrCount);
updateCoverageSource(mTopParseFn, covDir);
}
else
{
errType = ET_CLangError;
}
return errType;
}
void TokenizeSource(CXTranslationUnit tu)
{
CXSourceRange range =
clang_getCursorExtent( clang_getTranslationUnitCursor(tu) );
CXToken *tokens;
unsigned int token_count;
clang_tokenize( tu, range, &tokens, &token_count );
//CXCursor cursors[ token_count ];
//clang_annotateTokens( tu, tokens, token_count, cursors );
auto cursors = my_annotateTokens( tu, tokens, token_count );
for ( auto t = 0u; t < token_count; ++t ) {
auto tkind = clang_getTokenKind(tokens[t] );
auto tspelling = tkind == CXToken_Identifier ?
CursorKindSpelling( cursors[ t ] ) :
TokenKindSpelling( tkind );
auto textent = clang_getTokenExtent( tu, tokens[t] );
auto tstartloc = clang_getRangeStart( textent );
auto tendloc = clang_getRangeEnd( textent );
auto tokspell = clang_getTokenSpelling( tu, tokens[ t ] );
std::cout << "TokenSpelling: " << tokspell << "\n";
std::cout << "Cursor: " << cursors[ t ] << "\n";
// if ( !( cursors[t].kind >= CXCursor_FirstInvalid &&
// cursors[t].kind <= CXCursor_LastInvalid ) ) {
// auto rr = clang_getCursorExtent( cursors[ t ] );
// std::cout << "Range: " << rr << "\n";
// }
// std::cout << clang_getCursorDisplayName( cursors[ t ] ) << "\n";
// std::cout << "USR: "******"\n";
unsigned int startoffset, endoffset;
clang_getSpellingLocation( tstartloc, nullptr, nullptr, nullptr, &startoffset );
clang_getSpellingLocation( tendloc, nullptr, nullptr, nullptr, &endoffset );
// TODO: testing this hack for int -> identifier instead of keyword
// but this loses const to an identifier also! fvck!
if ( tspelling == "Keyword" ) {
auto type = clang_getCursorType( cursors[ t ] );
auto typekind = type.kind;
CXString typespelling;
if ( cursors[t].kind == CXCursor_FunctionDecl ||
cursors[t].kind == CXCursor_CXXMethod ) {
type = clang_getResultType( type );
typekind = type.kind;
typespelling = clang_getTypeSpelling( type );
}
else
typespelling = clang_getTypeSpelling( type );
// std::cout << "Type = " << type << " kind: " << typekind << "\n";
// std::cout << clang_getCString(typespelling) << " <-> " << clang_getCString(tokspell) << "\n";
// std::cout << " Const? " << clang_isConstQualifiedType( type ) << "\n";
if ( (( typekind >= CXType_FirstBuiltin && typekind <= CXType_LastBuiltin ) &&
( std::string(clang_getCString(typespelling)) ==
std::string(clang_getCString(tokspell) ) )) ||
// ( cursors[t].kind == CXCursor_VarDecl ) ||
( cursors[t].kind == CXCursor_ParmDecl ) )
tspelling = "Identifier";
}
//if ( tspelling != "Punctuation" )
std::cout
<< startoffset << ":" << endoffset << " @ "
<< tspelling << "\n";
clang_disposeString( tokspell );
}
std::cout << "\n" << end_pattern << "\n";
clang_disposeTokens( tu, tokens, token_count );
}
bool ReflectionParser::ProcessFile(std::string const & fileName, bool InProcessModule)
{
if (!InProcessModule && !m_sourceCache->RequestGenerate(fileName))
return true;
Clear();
m_currentFile = fileName;
m_index = clang_createIndex(true, false);
std::vector<const char *> arguments;
for (auto &argument : m_options.arguments)
{
// unescape flags
boost::algorithm::replace_all(argument, "\\-", "-");
arguments.emplace_back(argument.c_str());
}
m_translationUnit = clang_createTranslationUnitFromSourceFile(
m_index,
fileName.c_str(),
static_cast<int>(arguments.size()),
arguments.data(),
0,
nullptr
);
auto cursor = clang_getTranslationUnitCursor(m_translationUnit);
try
{
Namespace tempNamespace;
buildClasses(cursor, tempNamespace);
tempNamespace.clear();
if (ContainsModule() && !InProcessModule)
{
if (m_classes.size() > 1)
{
EMIT_ERROR("You can't implement any other classes in one file with module class");
}
return false;
}
if (RequestGenerate())
{
std::string fileId = GetFileID(fileName);
std::stringstream outCode;
// includes
outCode << "#include <memory>\n\n";
outCode << "#include \"sc-memory/cpp/sc_memory.hpp\"\n\n\n";
outCode << "#include \"sc-memory/cpp/sc_event.hpp\"\n\n\n";
for (auto it = m_classes.begin(); it != m_classes.end(); ++it)
{
Class const * klass = *it;
if (klass->ShouldGenerate())
{
klass->GenerateCode(fileId, outCode, this);
}
}
/// write ScFileID definition
outCode << "\n\n#undef ScFileID\n";
outCode << "#define ScFileID " << fileId;
// generate output file
boost::filesystem::path outputPath(m_options.outputPath);
outputPath /= boost::filesystem::path(GetOutputFileName(fileName));
std::ofstream outputFile(outputPath.string());
outputFile << outCode.str();
outputFile << std::endl << std::endl;
outputFile.close();
}
clang_disposeIndex(m_index);
clang_disposeTranslationUnit(m_translationUnit);
} catch (Exception e)
{
clang_disposeIndex(m_index);
clang_disposeTranslationUnit(m_translationUnit);
EMIT_ERROR(e.GetDescription());
}
return true;
}
Cursor::Cursor(TranslationUnit& unit) {
cursor_ = clang_getTranslationUnitCursor(unit.unit_);
}