public static void Main(string[] args) {
try {
IDLLexer lexer = new IDLLexer(new ByteBuffer(Console.OpenStandardInput()));
IDLParser parser = new IDLParser(lexer);
parser.specification();
} catch(Exception e) {
Console.Error.WriteLine("exception: "+e);
}
}
public static void Main(string[] args)
{
try {
IDLLexer lexer = new IDLLexer(new ByteBuffer(Console.OpenStandardInput()));
IDLParser parser = new IDLParser(lexer);
parser.specification();
} catch (Exception e) {
Console.Error.WriteLine("exception: " + e);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Do the actual import
/// </summary>
/// <param name="usingNamespaces">Additional imported namespaces</param>
/// <param name="sFileName">Filename of the IDL file</param>
/// <param name="sXmlFile">Name of the XML config file</param>
/// <param name="sOutFile">Output</param>
/// <param name="sNamespace">Namespace</param>
/// <param name="idhFiles">Names of IDH file used to retrieve comments.</param>
/// <param name="referencedFiles">Names of files used to resolve references to
/// external types.</param>
/// <param name="fCreateComments"><c>true</c> to create XML comments</param>
/// <returns><c>true</c> if import successful, otherwise <c>false</c>.</returns>
/// ------------------------------------------------------------------------------------
public bool Import(List <string> usingNamespaces, string sFileName, string sXmlFile,
string sOutFile, string sNamespace, StringCollection idhFiles,
StringCollection referencedFiles, bool fCreateComments)
{
var fOk = true;
var codeNamespace = new CodeNamespace();
// Add additional using statements
foreach (var ns in usingNamespaces)
{
codeNamespace.Imports.Add(new CodeNamespaceImport(ns));
}
// Add types from referenced files so that we can resolve types that are not
// defined in this IDL file.
foreach (var refFile in referencedFiles)
{
var referencedNamespace = DeserializeData(refFile);
if (referencedNamespace == null)
{
continue;
}
foreach (string key in referencedNamespace.UserData.Keys)
{
codeNamespace.UserData[key] = referencedNamespace.UserData[key];
}
}
// Load the IDL conversion rules
if (sXmlFile == null)
{
var assembly = Assembly.GetExecutingAssembly();
sXmlFile = Path.ChangeExtension(assembly.Location, "xml");
}
var conversions = IDLConversions.Deserialize(sXmlFile);
conversions.Namespace = codeNamespace;
#if SINGLE_THREADED
ParseIdhFiles(idhFiles);
#else
_waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
ThreadPool.QueueUserWorkItem(ParseIdhFiles, idhFiles);
#endif
using (var stream = new FileStream(sFileName, FileMode.Open, FileAccess.Read))
{
var lexer = new IDLLexer(stream);
var parser = new IDLParser(lexer);
parser.setFilename(sFileName);
codeNamespace.Name = sNamespace;
codeNamespace.Comments.AddRange(AddFileBanner(sFileName, sOutFile));
codeNamespace.Imports.Add(new CodeNamespaceImport("System"));
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Runtime.InteropServices"));
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Runtime.InteropServices.ComTypes"));
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Runtime.CompilerServices"));
// And now parse the IDL file
parser.specification(codeNamespace, conversions);
// Merge properties
fOk = MergeProperties(codeNamespace);
IDLConversions.AdjustReferencesInEnums();
// Add XML comments
if (fCreateComments)
{
_waitHandle?.WaitOne();
AddComments(codeNamespace.Types);
}
// Serialize what we have so that we can re-use later if necessary
SerializeData(sFileName, codeNamespace);
// Finally, create the source code
GenerateCode(sOutFile, codeNamespace);
}
return(fOk);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Do the actual import
/// </summary>
/// <param name="usingNamespaces">Additional imported namespaces</param>
/// <param name="sFileName">Filename of the IDL file</param>
/// <param name="sXmlFile">Name of the XML config file</param>
/// <param name="sOutFile">Output</param>
/// <param name="sNamespace">Namespace</param>
/// <param name="idhFiles">Names of IDH file used to retrieve comments.</param>
/// <param name="referencedFiles">Names of files used to resolve references to
/// external types.</param>
/// <param name="fCreateComments"><c>true</c> to create XML comments</param>
/// <returns><c>true</c> if import successful, otherwise <c>false</c>.</returns>
/// ------------------------------------------------------------------------------------
public bool Import(List <string> usingNamespaces, string sFileName, string sXmlFile,
string sOutFile, string sNamespace, StringCollection idhFiles,
StringCollection referencedFiles, bool fCreateComments)
{
bool fOk = true;
CodeNamespace codeNamespace = new CodeNamespace();
// Add additional using statements
foreach (string ns in usingNamespaces)
{
codeNamespace.Imports.Add(new CodeNamespaceImport(ns));
}
// Add types from referenced files so that we can resolve types that are not
// defined in this IDL file.
foreach (string refFile in referencedFiles)
{
AddReferences(codeNamespace, refFile);
}
// Load the IDL conversion rules
if (sXmlFile == null)
{
Assembly assembly = Assembly.GetExecutingAssembly();
sXmlFile = Path.ChangeExtension(assembly.Location, "xml");
}
IDLConversions conversions = IDLConversions.Deserialize(sXmlFile);
conversions.Namespace = codeNamespace;
string outPath = Path.GetFullPath(Path.GetDirectoryName(sOutFile));
conversions.ResolveBaseType += (s, e) => {
string rFile = Path.Combine(outPath, e.TypeName + ".iip");
if (!AddReferences(e.NameSpace, rFile))
{
e.IdhFileName = rFile;
if (ResolveBaseType != null)
{
ResolveBaseType(this, e);
}
AddReferences(e.NameSpace, e.IdhFileName ?? rFile);
}
};
#if SINGLE_THREADED
ParseIdhFile(idhFiles);
#else
m_waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
ThreadPool.QueueUserWorkItem(new WaitCallback(ParseIdhFiles), idhFiles);
#endif
using (FileStream stream = new FileStream(sFileName, FileMode.Open, FileAccess.Read))
{
IDLLexer lexer = new IDLLexer(stream);
IDLParser parser = new IDLParser(lexer);
parser.setFilename(sFileName);
codeNamespace.Name = sNamespace;
codeNamespace.Comments.AddRange(AddFileBanner(sFileName, sOutFile));
codeNamespace.Imports.Add(new CodeNamespaceImport("System"));
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Runtime.InteropServices"));
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Runtime.InteropServices.ComTypes"));
codeNamespace.Imports.Add(new CodeNamespaceImport("System.Runtime.CompilerServices"));
// And now parse the IDL file
parser.specification(codeNamespace, conversions);
// Merge properties
fOk = MergeProperties(codeNamespace);
IDLConversions.AdjustReferencesInEnums();
// Add XML comments
if (fCreateComments)
{
if (m_waitHandle != null)
{
m_waitHandle.WaitOne();
}
AddComments(codeNamespace.Types);
}
// Serialize what we have so that we can re-use later if necessary
SerializeData(sFileName, codeNamespace);
// Finally, create the source code
GenerateCode(sOutFile, codeNamespace);
}
return(fOk);
}
