main.cpp

/*
 * This file is part of clang-faces
 * 
 * clang-faces is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * clang-faces is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with clang-faces.  If not, see <http://www.gnu.org/licenses/>.
 * 
 */

/*
 * main.cpp
 * 
 * Author: Brian Fransioli <assem@terranpro.org>
 * Created: Tue Jul 18:55:32 KST 2013
 * Last modified: Thu Aug 15 23:53:20 KST 2013
 */

#include <iostream>
#include <vector>
#include <string>
#include <iterator>
#include <memory>

#include "clang-c/Index.h"

const auto end_pattern = "!!!!$$$$!!!!";

std::string TokenKindSpelling( CXTokenKind kind )
{
  switch( kind ) {
  case CXToken_Punctuation: return "Punctuation";

  case CXToken_Keyword: return "Keyword";
    
  case CXToken_Identifier: return "Identifier";
    
  case CXToken_Literal: return "Literal";
    
  case CXToken_Comment: return "Comment";
  default:
    break;
  }
  return {};
}

// std::ostream& operator<<( std::ostream &os, CXCursor cursor )
// {
//   auto spelling = clang_getCursorKindSpelling( cursor.kind );
//   os << clang_getCString( spelling );
//   clang_disposeString( spelling );
//   return os;
// }

std::ostream& operator<<( std::ostream &os, CXCursor cursor )
{
  auto spelling = clang_getCursorKindSpelling( cursor.kind );
  auto morespell = clang_getCursorSpelling( cursor );
  
  os << clang_getCString( spelling ) << ":"
     << clang_getCString( morespell ) << " ";

  clang_disposeString( spelling );
  clang_disposeString( morespell );

  auto refcursor = clang_getCursorReferenced( cursor );
  if ( clang_equalCursors( refcursor, clang_getNullCursor() )||
       clang_equalCursors( refcursor, cursor ) )
    return os;
    
  return os << " [ " << refcursor << " ] ";
}

std::ostream& operator<<( std::ostream& os, CXSourceLocation loc )
{
  CXFile cxfile;
  unsigned line, col, off;
  clang_getFileLocation( loc, &cxfile, &line, &col, &off );
  auto filestr = clang_getFileName( cxfile );
  os << clang_getCString( filestr ) << ":" << line << ":" << col;
  clang_disposeString( filestr );
  return os;
}

std::ostream& operator<<( std::ostream& os, CXSourceRange range )
{
  auto beg = clang_getRangeStart( range );
  auto end = clang_getRangeEnd( range );
  return os << beg << " -> " << end << "\n";
}

std::ostream& operator<<( std::ostream& os, CXType type )
{
  auto typestr = clang_getTypeSpelling( type );
  os << "Type: " << clang_getCString( typestr ) << "\n";
  clang_disposeString( typestr );
  return os;
}

std::ostream& operator<<( std::ostream& os, CXString str )
{
  os << clang_getCString( str );
  return os;
}

CXChildVisitResult
CallExprVisitor( CXCursor cursor, CXCursor parent, CXClientData d )
{
  std::string *result = reinterpret_cast<std::string *>( d );

  std::cout << "Child of CallExpr = " << cursor << "\n";

  if ( cursor.kind == CXCursor_TypeRef )
    *result = "Identifier";
    //    *result = "Variable";
  
  return CXChildVisit_Break;
}

std::string AdvancedCallExprHandler( CXCursor cursor )
{
  auto newcursor = clang_getCursorReferenced( cursor );
  std::string result = "Function";
  
  if ( newcursor.kind == CXCursor_Constructor )
    result = "Identifier";
  else 
    clang_visitChildren( cursor, CallExprVisitor,
			 reinterpret_cast<std::string *>(&result) );
  return result;
}


std::string CursorKindSpelling( CXCursor cursor )
{
  auto kind = cursor.kind;
  CXCursor newcursor;
  
  switch( kind ) {
  case CXCursor_DeclRefExpr:
  case CXCursor_MemberRefExpr:
    newcursor = clang_getCursorReferenced( cursor );
    std::cout << "NEW CURSOR: " << newcursor << "\n";
    return CursorKindSpelling( newcursor );

  case CXCursor_CallExpr:
    return AdvancedCallExprHandler( cursor );
    
  case CXCursor_CXXMethod:
  case CXCursor_FunctionDecl:
  case CXCursor_Constructor:
  case CXCursor_Destructor:
  case CXCursor_OverloadedDeclRef:
    return "Function";

  case CXCursor_ParmDecl:
  case CXCursor_VarDecl:
  case CXCursor_FieldDecl:
  case CXCursor_MemberRef:
  case CXCursor_VariableRef:
  case CXCursor_NonTypeTemplateParameter:
    return "Variable";

  case CXCursor_NamespaceRef:
    return "Namespace";
    
  default:
    return "Identifier";
  }

  return {};
}

std::vector<CXCursor>
my_annotateTokens( CXTranslationUnit tu, CXToken *tokens,
		   unsigned token_count )
{
  std::vector<CXCursor> cursors( token_count );
  for ( auto n = 0u; n < token_count; ++n ) {
    auto location = clang_getTokenLocation( tu, tokens[ n ] );
    cursors[n] = ( clang_getCursor( tu, location ) );
  }
  
  return cursors;
}

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: " << clang_getCursorUSR( cursors[ t ] ) << "\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 );
}

std::vector<char> ReparseSource()
{
  //std::cout << "Entered ReparseSource!\n";
  std::vector<char> buffer;
  std::string input;
  auto buffer_ins = std::back_inserter( buffer );
  
  while( 1 ) {
    if ( !std::getline( std::cin, input ) )
      return buffer;

    if ( input == end_pattern )
      break;

    std::copy( input.begin(), input.end(),
	       buffer_ins );
    *buffer_ins++ = '\n';
  }

  //*buffer_ins++ = '\0';
  std::cout << "Leaving Reparse Source w/buffer size: "
	    << buffer.size();
  return buffer;
}

struct ArgList 
{
  std::vector<std::string> args;
  std::unique_ptr<const char *> c_args;
  
  ArgList(int argc, char **argv)
    : args( argv, argv+argc ), c_args( new const char *[argc] )
  { build_c_args(); }

  ArgList( std::vector<std::string> vargs )
    : args( vargs ), c_args( new const char *[ args.size() ] )
  { build_c_args(); }
    
  void build_c_args()
  {
    auto i = 0u;
    for ( auto s : args )
      std::cout << s << " ";
    std::cout << std::endl;
    
    for ( auto &s : args )
      (c_args.get())[ i++ ] = s.c_str();
  }
  
  operator const char **()
  {
    return c_args.get();
  }

  std::size_t count() const
  { return args.size(); }
};
    
struct TUnit 
{
  CXIndex index;
  CXTranslationUnit unit;
  std::string filename;
  bool valid;
  unsigned const options = clang_defaultEditingTranslationUnitOptions();
  int orig_argc;
  const char **orig_argv;
  
  TUnit( CXIndex idx, std::string file )
    : index( idx ), filename(  file )
  { std::cout << "File: " << filename << "\n"; }

  ~TUnit()
  { clang_disposeTranslationUnit( unit ); }
  
  bool parse( int argc, const char **argv,
	      CXUnsavedFile *unsaved_files = nullptr,
	      unsigned int unsaved_file_count = 0 )
  {
    orig_argc = argc;
    orig_argv = argv;
    for ( auto i = 0; i < argc; ++i )
      std::cout << argv[i] << " ";
    std::cout << "\n";
    
    unit = clang_parseTranslationUnit( index,
				       filename.c_str(),
				       argv,
				       argc,
				       unsaved_files,
				       unsaved_file_count,
				       options );
    return valid = (unit != NULL);
  }

  CXTranslationUnit handle()
  { return unit; }

  bool parse( std::vector<CXUnsavedFile> unsavedfiles )
  {
    if ( !valid ) {
      std::cout << "Warning, not valid!\n";
      if ( !parse( orig_argc, orig_argv,
		   unsavedfiles.data(),
		   unsavedfiles.size() ) )
	return false;
    }
    
    valid = !clang_reparseTranslationUnit( unit,
					   unsavedfiles.size(),
					   unsavedfiles.data(),
					   options );
    
    return valid;
  }
};
    
int main(int argc, char *argv[])
{
  auto index = clang_createIndex(0, 0);
  std::vector<std::string> default_args = { {"-x"}, {"c++"}, {"-std=c++11"} };
  std::string filename;
  ArgList arglist( default_args );

  if ( argc > 1 ) {
    arglist = ArgList( argc - 2, argv + 1 );
    filename = argv[argc - 1];
  } else {
    filename = argv[1];
  }
      
  TUnit tu( index, filename );
  
  if ( !tu.parse( arglist.count(), arglist ) ) {
    std::cout << "Translation Unit Initial Parse Failed!\n";
  }

  std::string input;
  std::vector<char> filebuffer;
  while( std::getline( std::cin, input ) ) {
    if ( input == "REPARSE" ) {
      filebuffer = ReparseSource();

      CXUnsavedFile unsaved_file = { filename.c_str(),
				     filebuffer.data(),
				     filebuffer.size() };

      // std::cout << "Size = " << filebuffer.size()
      // 		<< "Contents:\n" << filebuffer.data()
      // 		<< "\n";

      if ( tu.parse( std::vector<CXUnsavedFile>( 1, unsaved_file ) ) ) {
	TokenizeSource( tu.handle() );
      } else {
	std::cout << "Reparse FAILED!\n" << end_pattern << "\n";
      }
    }
  }

  clang_disposeIndex( index );
  return 0;
}