/// <summary>
/// Parses a C++ source file to a translation unit.
/// </summary>
public ParserResult ParseSourceFile(SourceFile file)
{
var options = file.Options;
options.ASTContext = ASTContext;
options.FileName = file.Path;
var result = Parser.ClangParser.ParseHeader(options);
SourceParsed(file, result);
return result;
}
/// <summary>
/// Parses a C++ source file to a translation unit.
/// </summary>
private ParserResult ParseSourceFile(SourceFile file)
{
var options = file.Options;
options.ASTContext = ASTContext;
options.AddSourceFiles(file.Path);
var result = Parser.ClangParser.ParseHeader(options);
SourcesParsed(new[] { file }, result);
return result;
}
void OnSourceFileParsed(SourceFile file, ParserResult result)
{
OnFileParsed(file.Path, result);
}
public ParserOptions BuildParseOptions(SourceFile file)
{
var options = new ParserOptions
{
FileName = file.Path,
Abi = Options.Abi,
ToolSetToUse = Options.ToolSetToUse,
TargetTriple = Options.TargetTriple,
NoStandardIncludes = Options.NoStandardIncludes,
NoBuiltinIncludes = Options.NoBuiltinIncludes,
MicrosoftMode = Options.MicrosoftMode,
Verbose = Options.Verbose,
LanguageVersion = Options.LanguageVersion
};
// This eventually gets passed to Clang's MSCompatibilityVersion, which
// is in turn used to derive the value of the built-in define _MSC_VER.
// It used to receive a 4-digit based identifier but now expects a full
// version MSVC digit, so check if we still have the old version and
// convert to the right format.
if (Options.ToolSetToUse.ToString(CultureInfo.InvariantCulture).Length == 4)
Options.ToolSetToUse *= 100000;
for (uint i = 0; i < Options.ArgumentsCount; ++i)
{
var arg = Options.getArguments(i);
options.addArguments(arg);
}
for (uint i = 0; i < Options.IncludeDirsCount; ++i)
{
var include = Options.getIncludeDirs(i);
options.addIncludeDirs(include);
}
for (uint i = 0; i < Options.SystemIncludeDirsCount; ++i)
{
var include = Options.getSystemIncludeDirs(i);
options.addSystemIncludeDirs(include);
}
for (uint i = 0; i < Options.DefinesCount; ++i)
{
var define = Options.getDefines(i);
options.addDefines(define);
}
for (uint i = 0; i < Options.UndefinesCount; ++i)
{
var define = Options.getUndefines(i);
options.addUndefines(define);
}
for (uint i = 0; i < Options.LibraryDirsCount; ++i)
{
var lib = Options.getLibraryDirs(i);
options.addLibraryDirs(lib);
}
return options;
}
/// <summary>
/// Adds a new source file to the project.
/// </summary>
public SourceFile AddFile(string path)
{
var sourceFile = new SourceFile(path);
Sources.Add(sourceFile);
return sourceFile;
}
/// <summary>
/// Adds a new source file to the project.
/// </summary>
public void AddFolder(string path)
{
var sourceFile = new SourceFile(path);
Sources.Add(sourceFile);
}
ParserOptions BuildParseOptions(SourceFile file)
{
var options = new ParserOptions
{
FileName = file.Path,
#if OLD_PARSER
Arguments = Options.Arguments,
IncludeDirs = Options.IncludeDirs,
SystemIncludeDirs = Options.SystemIncludeDirs,
Defines = Options.Defines,
LibraryDirs = Options.LibraryDirs,
#endif
Abi = Options.Abi,
ToolSetToUse = Options.ToolSetToUse,
TargetTriple = Options.TargetTriple,
NoStandardIncludes = Options.NoStandardIncludes,
NoBuiltinIncludes = Options.NoBuiltinIncludes,
MicrosoftMode = Options.MicrosoftMode,
Verbose = Options.Verbose,
};
#if !OLD_PARSER
for (uint i = 0; i < Options.ArgumentsCount; ++i)
{
var arg = Options.getArguments(i);
options.addArguments(arg);
}
for (uint i = 0; i < Options.IncludeDirsCount; ++i)
{
var include = Options.getIncludeDirs(i);
options.addIncludeDirs(include);
}
for (uint i = 0; i < Options.SystemIncludeDirsCount; ++i)
{
var include = Options.getSystemIncludeDirs(i);
options.addSystemIncludeDirs(include);
}
for (uint i = 0; i < Options.DefinesCount; ++i)
{
var define = Options.getDefines(i);
options.addDefines(define);
}
for (uint i = 0; i < Options.LibraryDirsCount; ++i)
{
var lib = Options.getLibraryDirs(i);
options.addLibraryDirs(lib);
}
#endif
return options;
}
public ParserOptions BuildParseOptions(SourceFile file)
{
var options = new ParserOptions
{
FileName = file.Path,
Abi = Options.Abi,
ToolSetToUse = Options.ToolSetToUse,
TargetTriple = Options.TargetTriple,
NoStandardIncludes = Options.NoStandardIncludes,
NoBuiltinIncludes = Options.NoBuiltinIncludes,
MicrosoftMode = Options.MicrosoftMode,
Verbose = Options.Verbose,
LanguageVersion = Options.LanguageVersion
};
// This eventually gets passed to Clang's MSCompatibilityVersion, which
// is in turn used to derive the value of the built-in define _MSC_VER.
// It used to receive a 4-digit based identifier but now expects a full
// version MSVC digit, so check if we still have the old version and
// convert to the right format.
if (Options.ToolSetToUse.ToString(CultureInfo.InvariantCulture).Length == 4)
{
Options.ToolSetToUse *= 100000;
}
for (uint i = 0; i < Options.ArgumentsCount; ++i)
{
var arg = Options.getArguments(i);
options.addArguments(arg);
}
for (uint i = 0; i < Options.IncludeDirsCount; ++i)
{
var include = Options.getIncludeDirs(i);
options.addIncludeDirs(include);
}
for (uint i = 0; i < Options.SystemIncludeDirsCount; ++i)
{
var include = Options.getSystemIncludeDirs(i);
options.addSystemIncludeDirs(include);
}
for (uint i = 0; i < Options.DefinesCount; ++i)
{
var define = Options.getDefines(i);
options.addDefines(define);
}
for (uint i = 0; i < Options.UndefinesCount; ++i)
{
var define = Options.getUndefines(i);
options.addUndefines(define);
}
for (uint i = 0; i < Options.LibraryDirsCount; ++i)
{
var lib = Options.getLibraryDirs(i);
options.addLibraryDirs(lib);
}
return(options);
}
void OnSourceFileParsed(SourceFile file, ParserResult result)
{
OnFileParsed(file.Path, result);
}
public ParserOptions BuildParserOptions(SourceFile file = null)
{
var options = new ParserOptions
{
Abi = ParserOptions.Abi,
ToolSetToUse = ParserOptions.ToolSetToUse,
TargetTriple = ParserOptions.TargetTriple,
NoStandardIncludes = ParserOptions.NoStandardIncludes,
NoBuiltinIncludes = ParserOptions.NoBuiltinIncludes,
MicrosoftMode = ParserOptions.MicrosoftMode,
Verbose = ParserOptions.Verbose,
LanguageVersion = ParserOptions.LanguageVersion
};
// This eventually gets passed to Clang's MSCompatibilityVersion, which
// is in turn used to derive the value of the built-in define _MSC_VER.
// It used to receive a 4-digit based identifier but now expects a full
// version MSVC digit, so check if we still have the old version and
// convert to the right format.
if (ParserOptions.ToolSetToUse.ToString(CultureInfo.InvariantCulture).Length == 4)
{
ParserOptions.ToolSetToUse *= 100000;
}
for (uint i = 0; i < ParserOptions.ArgumentsCount; ++i)
{
var arg = ParserOptions.GetArguments(i);
options.AddArguments(arg);
}
for (uint i = 0; i < ParserOptions.IncludeDirsCount; ++i)
{
var include = ParserOptions.GetIncludeDirs(i);
options.AddIncludeDirs(include);
}
for (uint i = 0; i < ParserOptions.SystemIncludeDirsCount; ++i)
{
var include = ParserOptions.GetSystemIncludeDirs(i);
options.AddSystemIncludeDirs(include);
}
for (uint i = 0; i < ParserOptions.DefinesCount; ++i)
{
var define = ParserOptions.GetDefines(i);
options.AddDefines(define);
}
for (uint i = 0; i < ParserOptions.UndefinesCount; ++i)
{
var define = ParserOptions.GetUndefines(i);
options.AddUndefines(define);
}
for (uint i = 0; i < ParserOptions.LibraryDirsCount; ++i)
{
var lib = ParserOptions.GetLibraryDirs(i);
options.AddLibraryDirs(lib);
}
foreach (var module in Options.Modules.Where(
m => file == null || m.Headers.Contains(file.Path)))
{
foreach (var include in module.IncludeDirs)
{
options.AddIncludeDirs(include);
}
foreach (var define in module.Defines)
{
options.AddDefines(define);
}
foreach (var undefine in module.Undefines)
{
options.AddUndefines(undefine);
}
foreach (var libraryDir in module.LibraryDirs)
{
options.AddLibraryDirs(libraryDir);
}
}
return(options);
}
/// <summary>
/// Adds a new source file to the project.
/// </summary>
public void AddFolder(string path)
{
var sourceFile = new SourceFile(path);
Sources.Add(sourceFile);
}
ParserOptions BuildParseOptions(SourceFile file)
{
var options = new ParserOptions
{
FileName = file.Path,
#if OLD_PARSER
IncludeDirs = Options.IncludeDirs,
SystemIncludeDirs = Options.SystemIncludeDirs,
Defines = Options.Defines,
LibraryDirs = Options.LibraryDirs,
#endif
Abi = Options.Abi,
ToolSetToUse = Options.ToolSetToUse,
TargetTriple = Options.TargetTriple,
NoStandardIncludes = Options.NoStandardIncludes,
NoBuiltinIncludes = Options.NoBuiltinIncludes,
MicrosoftMode = Options.MicrosoftMode,
Verbose = Options.Verbose,
};
return options;
}
public ParserOptions BuildParseOptions(SourceFile file)
{
var options = new ParserOptions
{
FileName = file.Path,
Abi = Options.Abi,
ToolSetToUse = Options.ToolSetToUse,
TargetTriple = Options.TargetTriple,
NoStandardIncludes = Options.NoStandardIncludes,
NoBuiltinIncludes = Options.NoBuiltinIncludes,
MicrosoftMode = Options.MicrosoftMode,
Verbose = Options.Verbose,
LanguageVersion = Options.LanguageVersion
};
for (uint i = 0; i < Options.ArgumentsCount; ++i)
{
var arg = Options.getArguments(i);
options.addArguments(arg);
}
for (uint i = 0; i < Options.IncludeDirsCount; ++i)
{
var include = Options.getIncludeDirs(i);
options.addIncludeDirs(include);
}
for (uint i = 0; i < Options.SystemIncludeDirsCount; ++i)
{
var include = Options.getSystemIncludeDirs(i);
options.addSystemIncludeDirs(include);
}
for (uint i = 0; i < Options.DefinesCount; ++i)
{
var define = Options.getDefines(i);
options.addDefines(define);
}
for (uint i = 0; i < Options.LibraryDirsCount; ++i)
{
var lib = Options.getLibraryDirs(i);
options.addLibraryDirs(lib);
}
return options;
}
static void Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine(help);
return;
}
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "--include")
{
if (args.Length == i)
{
Console.WriteLine(help);
return;
}
string includePath = args[i + 1];
DirectoryInfo d = new DirectoryInfo(includePath);
includes.Add(d.FullName);
includePath = Environment.CurrentDirectory + "\\" + includePath;
i++;
}
if (args[i] == "--namespace")
{
if (args.Length == i)
{
Console.WriteLine(help);
return;
}
nameSpace = args[i + 1];
i++;
}
if (args[i] == "--class")
{
if (args.Length == i)
{
Console.WriteLine(help);
return;
}
className = args[i + 1];
i++;
}
if (args[i] == "--dll")
{
if (args.Length == i)
{
Console.WriteLine(help);
return;
}
dllName = args[i + 1];
i++;
}
}
sourceFile = args[args.Length - 1];
if (includes.Count == 0 ||
string.IsNullOrEmpty(nameSpace) ||
string.IsNullOrEmpty(className) ||
string.IsNullOrEmpty(dllName))
{
Console.WriteLine(help);
return;
}
string srcFile = Environment.CurrentDirectory + "\\" + sourceFile;
if(!File.Exists(srcFile))
{
Console.WriteLine("Can not find file {0}, working directory {1}", srcFile, Environment.CurrentDirectory);
}
ParserOptions options = new ParserOptions();
options.IncludeDirs.AddRange(includes);
options.MicrosoftMode = true;
options.ASTContext = new CppSharp.AST.ASTContext();
options.FileName = srcFile;
options.Defines.Add("__STDC_CONSTANT_MACROS");
SourceFile source = new SourceFile(options.FileName);
parser = new ClangParser();
//parser.ASTContext = new CppSharp.AST.ASTContext();
result = parser.ParseSourceFile(source, options);
if (result.Kind != ParserResultKind.Success)
{
Console.WriteLine("Error: {0}", result.Kind.ToString());
foreach (var diag in result.Diagnostics)
Console.WriteLine(diag.FileName + "(" + diag.LineNumber.ToString() + "):" + diag.Message);
}
GenerateInteropFiles(result);
}
