public void CreateCompiler_ReturnsSame()
{
VBCodeProvider provider = new VBCodeProvider();
#pragma warning disable 0618
Assert.Same(provider.CreateCompiler(), provider.CreateCompiler());
#pragma warning restore 0618
}
public void Deny_Unrestricted ()
{
VBCodeProvider vbprov = new VBCodeProvider ();
Assert.AreEqual ("vb", vbprov.FileExtension, "FileExtension");
Assert.AreEqual (LanguageOptions.CaseInsensitive, vbprov.LanguageOptions, "LanguageOptions");
Assert.IsNotNull (vbprov.CreateCompiler (), "CreateCompiler");
Assert.IsNotNull (vbprov.CreateGenerator (), "CreateGenerator");
try {
Assert.IsNotNull (vbprov.GetConverter (typeof (string)), "GetConverter");
}
catch (NotImplementedException) {
// mono
}
#if NET_2_0
CodeTypeMember ctm = new CodeTypeMember ();
StringWriter sw = new StringWriter ();
CodeGeneratorOptions cgo = new CodeGeneratorOptions ();
try {
vbprov.GenerateCodeFromMember (ctm, sw, cgo);
}
catch (NotImplementedException) {
// mono
}
#endif
}
public void Ctor_IDictionaryStringString(IDictionary<string, string> providerOptions)
{
VBCodeProvider provider = new VBCodeProvider();
#pragma warning disable 0618
Assert.NotNull(provider.CreateGenerator());
Assert.Same(provider.CreateGenerator(), provider.CreateCompiler());
#pragma warning restore 0618
}
public void Ctor_Default()
{
VBCodeProvider provider = new VBCodeProvider();
#pragma warning disable 0618
Assert.NotNull(provider.CreateGenerator());
Assert.Same(provider.CreateGenerator(), provider.CreateCompiler());
#pragma warning restore 0618
}
static TestUtilities()
{
cSharpCompiler = new CSharpCodeProvider();
compiler = cSharpCompiler.CreateCompiler();
compileParameters = new CompilerParameters();
vbCompilerProvider = new VBCodeProvider();
vbCompiler = vbCompilerProvider.CreateCompiler();
vbCompileParameters = new CompilerParameters();
}
private static CompilerResults CompileVBScripts(ICollection fileColl,
string assemblyFile,
LibraryConfig libConfig,
bool debug)
{
VBCodeProvider provider = new VBCodeProvider();
ICodeCompiler compiler = provider.CreateCompiler();
string[] files = new string[fileColl.Count];
fileColl.CopyTo(files, 0);
Console.Write("{0}[VB,{1}", libConfig.Name, files.Length);
CompilerResults results = compiler.CompileAssemblyFromFileBatch( new CompilerParameters( GetReferenceAssemblies(), assemblyFile, true ), files );
m_AdditionalReferences.Add(assemblyFile);
if ( results.Errors.Count > 0 )
{
int errorCount = 0, warningCount = 0;
foreach ( CompilerError e in results.Errors )
{
if ( e.IsWarning )
++warningCount;
else
++errorCount;
}
Console.WriteLine();
if ( errorCount > 0 )
Console.WriteLine( "failed ({0} errors, {1} warnings)", errorCount, warningCount );
else
Console.WriteLine( "done ({0} errors, {1} warnings)", errorCount, warningCount );
foreach ( CompilerError e in results.Errors )
{
Console.WriteLine( " - {0}: {1}: {2}: (line {3}, column {4}) {5}", e.IsWarning ? "Warning" : "Error", e.FileName, e.ErrorNumber, e.Line, e.Column, e.ErrorText );
}
}
else
{
Console.Write("] ");
}
return results;
}
private void CompileRunningVB()
{
string name2 = name;
if (name == "") name2 = "DotNetProcessing.Running";
else name2 = name2 + "Sketch";
// Generamos DotNetProcessing.Running.dll
VBCodeProvider vbCompiler;
ICodeCompiler iCodeCompiler;
CompilerParameters compilerParams;
CompilerResults cr;
vbCompiler = new VBCodeProvider();
iCodeCompiler = vbCompiler.CreateCompiler();
compilerParams = new CompilerParameters();
compilerParams.OutputAssembly = apppath + name2 + ".dll";
compilerParams.ReferencedAssemblies.Add("System.dll");
compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
compilerParams.ReferencedAssemblies.Add("System.Core.dll");
compilerParams.ReferencedAssemblies.Add("System.Drawing.dll");
compilerParams.ReferencedAssemblies.Add("System.Windows.Forms.dll");
compilerParams.ReferencedAssemblies.Add(apppath + "DotNetProcessing.Kernel.dll");
compilerParams.ReferencedAssemblies.Add(apppath + "DotNetProcessing.AbstractRunning.dll");
compilerParams.GenerateExecutable = false;
cr = iCodeCompiler.CompileAssemblyFromFile(compilerParams, apppath + "DotNetProcessing.Running" + sep + "RunnerCopy.vb");
if( cr.Errors.Count > 0 )
{
string er = "";
for( int i=0; i<cr.Errors.Count; i++ )
{
StreamReader srerrors = File.OpenText(apppath + "DotNetProcessing.Running" + sep + "RunnerCopy.vb");
for (int j=0; j<cr.Errors[i].Line-1; j++) srerrors.ReadLine();
er = er + "ERROR:\t" + cr.Errors[i].ErrorText + "\r\n" + "LINE:\t" + srerrors.ReadLine().Trim() + "\r\nCOLUMN:\t" + cr.Errors[i].Column + "\r\n\r\n";
srerrors.Close();
}
try
{
DelFileWrapper(apppath + "Input.pde");
DelFileWrapper(apppath + "DotNetProcessing.Running" + sep + "RunnerCopy.vb");
}
catch
{}
throw new DNPParseException(er);
}
}
private static CompilerResults CompileVBScripts(ICollection fileColl,
string assemblyFile,
Config.Library libConfig,
bool debug) {
VBCodeProvider provider = new VBCodeProvider();
ICodeCompiler compiler = provider.CreateCompiler();
string[] files = new string[fileColl.Count];
fileColl.CopyTo(files, 0);
log.InfoFormat("Compiling library {0}, {1} C# sources",
libConfig.Name, files.Length);
CompilerResults results = compiler.CompileAssemblyFromFileBatch( new CompilerParameters( GetReferenceAssemblies(), assemblyFile, true ), files );
m_AdditionalReferences.Add(assemblyFile);
if ( results.Errors.Count > 0 )
{
int errorCount = 0, warningCount = 0;
foreach ( CompilerError e in results.Errors )
{
if ( e.IsWarning )
++warningCount;
else
++errorCount;
}
if ( errorCount > 0 )
log.ErrorFormat("Compilation failed ({0} errors, {1} warnings)",
errorCount, warningCount);
else
log.InfoFormat("Compilation complete ({0} warnings)", warningCount);
foreach ( CompilerError e in results.Errors )
{
String msg = String.Format("{0}: {1}: (line {2}, column {3}) {4}",
e.FileName, e.ErrorNumber, e.Line, e.Column, e.ErrorText);
if (e.IsWarning)
log.Warn(msg);
else
log.Error(msg);
}
}
else
{
log.Info("Compilation complete");
}
return results;
}
static void Main(string[] args)
{
// Prompt for target language.
Console.Write("Do you want to generate C# or VB .NET code? ");
syntaxTarget = Console.ReadLine();
// Get ICodeGenerator interface.
switch(syntaxTarget.ToUpper())
{
case "C#":
case "CSharp":
case "CS":
syntaxTarget = "cs";
CSharpCodeProvider cdp = new CSharpCodeProvider();
itfCG = cdp.CreateGenerator();
itfCC = cdp.CreateCompiler();
break;
case "VB .NET":
case "VB.NET":
case "VB":
syntaxTarget = "vb";
VBCodeProvider vbdp = new VBCodeProvider();
itfCG = vbdp.CreateGenerator();
itfCC = vbdp.CreateCompiler();
break;
default:
Console.WriteLine("Sorry...can't do it...");
syntaxTarget = null;
break;
}
// Only proceed if they picked a valid language
// supported by System.CodeDOM.
if(syntaxTarget != null)
{
// Now create the file and generate the code!
TextWriter txtWriter = CreateFile(syntaxTarget);
PopulateNamespace(itfCG, txtWriter);
txtWriter.Close();
Console.WriteLine("Done!");
// Now compile the code into a .NET DLL.
Console.WriteLine("Compiling code...");
CompileCode(itfCC, syntaxTarget);
// Now launch the application!
Console.Write("Enter your message: ");
string msg = Console.ReadLine();
LoadAndRunAsm(msg);
Console.WriteLine("Thanks for playing...");
}
}
public string CompileAssemblyFromDomBatch (string tempDir)
{
CompilerParameters options = new CompilerParameters ();
options.GenerateExecutable = false;
options.GenerateInMemory = false;
options.TempFiles = new TempFileCollection (tempDir);
VBCodeProvider codeProvider = new VBCodeProvider ();
ICodeCompiler compiler = codeProvider.CreateCompiler ();
CompilerResults results = compiler.CompileAssemblyFromDomBatch (options, new CodeCompileUnit[] { new CodeCompileUnit (), new CodeCompileUnit () });
// verify compilation was successful
AssertCompileResults (results, true);
if (results.CompiledAssembly.Location.Length == 0)
throw new Exception ("Location should not be empty string");
if (results.PathToAssembly == null)
throw new Exception ("PathToAssembly should not be null");
return results.PathToAssembly;
}
public string CompileAssemblyFromDom (string tempDir)
{
CompilerParameters options = new CompilerParameters ();
options.GenerateExecutable = false;
options.GenerateInMemory = false;
options.TempFiles = new TempFileCollection (tempDir);
VBCodeProvider codeProvider = new VBCodeProvider ();
ICodeCompiler compiler = codeProvider.CreateCompiler ();
CompilerResults results = compiler.CompileAssemblyFromDom (options, new CodeCompileUnit ());
// verify compilation was successful
AssertCompileResults (results, true);
Assert.IsTrue (results.CompiledAssembly.Location.Length != 0,
"Location should not be empty string");
Assert.IsNotNull (results.PathToAssembly, "PathToAssembly should not be null");
return results.PathToAssembly;
}
private static CompilerResults CompileVBScripts(bool debug)
{
VBCodeProvider provider = new VBCodeProvider();
ICodeCompiler compiler = provider.CreateCompiler();
Console.Write("Scripts: Compiling VB.net scripts...");
string[] files = GetScripts("*.vb");
if (files.Length == 0)
{
Console.WriteLine("no files found.");
return null;
}
string path = GetUnusedPath("Scripts.VB");
CompilerResults results = compiler.CompileAssemblyFromFileBatch(new CompilerParameters(GetReferenceAssemblies(), path, true), files);
m_AdditionalReferences.Add(path);
if (results.Errors.Count > 0)
{
int errorCount = 0, warningCount = 0;
foreach (CompilerError e in results.Errors)
{
if (e.IsWarning)
++warningCount;
else
++errorCount;
}
if (errorCount > 0)
Console.WriteLine("failed ({0} errors, {1} warnings)", errorCount, warningCount);
else
Console.WriteLine("done ({0} errors, {1} warnings)", errorCount, warningCount);
foreach (CompilerError e in results.Errors)
{
Console.WriteLine(" - {0}: {1}: {2}: (line {3}, column {4}) {5}", e.IsWarning ? "Warning" : "Error", e.FileName, e.ErrorNumber, e.Line, e.Column, e.ErrorText);
}
}
else
{
Console.WriteLine("done (0 errors, 0 warnings)");
}
return results;
}
