internal CompilerMessageEventArgs(CompilerMessage message, FileLineNumber fileLineNumber) : this( message, fileLineNumber == null ? null : fileLineNumber.SourceFile, fileLineNumber == null ? 0 : fileLineNumber.LineNumber, fileLineNumber == null ? 0 : fileLineNumber.LinePosition) { }
public CompilerMessageEventArgs(CompilerMessage message, string fileName, int lineNumber, int linePosition, int?linePositionEnd = null) { this.Message = message; this.FileName = fileName; this.LineNumber = lineNumber; this.LinePosition = linePosition; this.LinePositionEnd = linePositionEnd; }
// NOTE: 'id' is ignored! public void OnError(object sender, int id, string fileName, string format, params object[] details) { if (this.MessageDelegate != null) { CompilerMessageEventArgs e = new CompilerMessageEventArgs(CompilerMessage.InternalError(String.Format(CultureInfo.InvariantCulture, format, details)), fileName, 0, 0); this.MessageDelegate(sender, e); } }
internal CompilerMessageEventArgs(CompilerMessage message, string sourceFile, Range range) : this( message, sourceFile == null ? null : sourceFile, range == null ? 0 : range.Start.Line, range == null ? 0 : range.Start.Column, range == null ? 0 : range.End.Column) { }
private static Assembly ExtensionLoadFrom(string assemblyName) { Assembly extensionAssembly = null; try { extensionAssembly = Assembly.LoadFrom(assemblyName); } catch (Exception e) { throw new CompilerException(new CompilerMessageEventArgs(CompilerMessage.InvalidExtension(assemblyName, e.Message), null, 0, 0), e); } return(extensionAssembly); }
public CompilerMessageEventArgs(CompilerMessage message, PackageItem item) : this(message, item.LineNumber) { }
/// <summary> /// Loads a CompilerExtension from a type description string. /// </summary> /// <param name="extension">The extension type description string.</param> /// <returns>The loaded CompilerExtension.</returns> /// <remarks> /// <paramref name="extension"/> can be in several different forms: /// <list type="number"> /// <item><term>AssemblyQualifiedName (TopNamespace.SubNameSpace.ContainingClass+NestedClass, MyAssembly, Version=1.3.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089)</term></item> /// <item><term>AssemblyName (MyAssembly, Version=1.3.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089)</term></item> /// <item><term>Absolute path to an assembly (C:\MyExtensions\ExtensionAssembly.dll)</term></item> /// <item><term>Filename of an assembly in the application directory (ExtensionAssembly.dll)</term></item> /// <item><term>Relative path to an assembly (..\..\MyExtensions\ExtensionAssembly.dll)</term></item> /// </list> /// To specify a particular class to use, prefix the fully qualified class name to the assembly and separate them with a comma. /// For example: "TopNamespace.SubNameSpace.ContainingClass+NestedClass, C:\MyExtensions\ExtensionAssembly.dll" /// </remarks> public static CompilerExtension Load(string extension) { Type extensionType = null; int commaIndex = extension.IndexOf(','); string className = String.Empty; string assemblyName = extension; if (0 <= commaIndex) { className = extension.Substring(0, commaIndex); assemblyName = (extension.Length <= commaIndex + 1 ? String.Empty : extension.Substring(commaIndex + 1)); } className = className.Trim(); assemblyName = assemblyName.Trim(); if (null == extensionType && 0 < assemblyName.Length) { Assembly extensionAssembly; // case 3: Absolute path to an assembly if (Path.IsPathRooted(assemblyName)) { extensionAssembly = ExtensionLoadFrom(assemblyName); } else { try { // case 2: AssemblyName extensionAssembly = Assembly.Load(assemblyName); } catch (IOException e) { if (e is FileLoadException || e is FileNotFoundException) { try { // case 4: Filename of an assembly in the application directory extensionAssembly = Assembly.Load(Path.GetFileNameWithoutExtension(assemblyName)); } catch (IOException innerE) { if (innerE is FileLoadException || innerE is FileNotFoundException) { // case 5: Relative path to an assembly // we want to use Assembly.Load when we can because it has some benefits over Assembly.LoadFrom // (see the documentation for Assembly.LoadFrom). However, it may fail when the path is a relative // path, so we should try Assembly.LoadFrom one last time. We could have detected a directory // separator character and used Assembly.LoadFrom directly, but dealing with path canonicalization // issues is something we don't want to deal with if we don't have to. extensionAssembly = ExtensionLoadFrom(assemblyName); } else { throw new CompilerException(new CompilerMessageEventArgs(CompilerMessage.InvalidExtension(assemblyName, innerE.Message), null, 0, 0), innerE); } } } else { throw new CompilerException(new CompilerMessageEventArgs(CompilerMessage.InvalidExtension(assemblyName, e.Message), null, 0, 0), e); } } } if (0 < className.Length) { try { // case 1: AssemblyQualifiedName extensionType = extensionAssembly.GetType(className, true, true); } catch (Exception e) { throw new CompilerException(new CompilerMessageEventArgs(CompilerMessage.InvalidExtensionClassName(assemblyName, className, e.Message), null, 0, 0), e); } } else { // if no class name was specified, then let's hope the assembly defined a default CompilerExtension DefaultCompilerExtensionAttribute extensionAttribute = (DefaultCompilerExtensionAttribute)Attribute.GetCustomAttribute(extensionAssembly, typeof(DefaultCompilerExtensionAttribute)); if (null != extensionAttribute) { extensionType = extensionAttribute.ExtensionType; } else { throw new CompilerException(new CompilerMessageEventArgs(CompilerMessage.ExpectedDefaultCompilerExtensionAttribute(assemblyName, typeof(DefaultCompilerExtensionAttribute)), null, 0, 0)); } } } if (extensionType.IsSubclassOf(typeof(CompilerExtension))) { return(Activator.CreateInstance(extensionType) as CompilerExtension); } else { throw new CompilerException(new CompilerMessageEventArgs(CompilerMessage.InvalidExtensionType(extension, extensionType, typeof(CompilerExtension)), null, 0, 0)); } }