public void Constructor1 () { string fileName = "mono"; Guid algorithmId = Guid.NewGuid(); byte[] data = new byte[] {0,1}; CodeChecksumPragma ccp = new CodeChecksumPragma (fileName, algorithmId, data); Assert.AreEqual (algorithmId, ccp.ChecksumAlgorithmId, "#1"); Assert.AreEqual (data, ccp.ChecksumData, "#2"); Assert.AreEqual (fileName, ccp.FileName, "#3"); Assert.AreSame (data, ccp.ChecksumData, "#4"); Assert.AreSame (fileName, ccp.FileName, "#5"); ccp.ChecksumAlgorithmId = Guid.Empty; Assert.AreEqual (Guid.Empty, ccp.ChecksumAlgorithmId, "#6"); ccp.ChecksumData = null; Assert.IsNull (ccp.ChecksumData, "#7"); ccp.FileName = null; Assert.IsNotNull (ccp.FileName, "#8"); Assert.AreEqual (string.Empty, ccp.FileName, "#9"); ccp = new CodeChecksumPragma ((string) null, Guid.Empty, (byte[]) null); Assert.AreEqual (Guid.Empty, ccp.ChecksumAlgorithmId, "#10"); Assert.IsNull (ccp.ChecksumData, "#11"); Assert.IsNotNull (ccp.FileName, "#12"); Assert.AreEqual (string.Empty, ccp.FileName, "#13"); }
public void Constructor0_Deny_Unrestricted () { CodeChecksumPragma ccp = new CodeChecksumPragma (); Assert.AreEqual (Guid.Empty, ccp.ChecksumAlgorithmId, "ChecksumAlgorithmId"); ccp.ChecksumAlgorithmId = Guid.NewGuid (); Assert.IsNull (ccp.ChecksumData, "ChecksumData"); ccp.ChecksumData = new byte [1]; Assert.AreEqual (String.Empty, ccp.FileName, "FileName"); }
public void Constructor1_Deny_Unrestricted () { Guid g = Guid.NewGuid (); CodeChecksumPragma ccp = new CodeChecksumPragma ("mono", g, new byte [1]); Assert.AreEqual (g, ccp.ChecksumAlgorithmId, "ChecksumAlgorithmId"); ccp.ChecksumAlgorithmId = Guid.Empty; Assert.AreEqual (1, ccp.ChecksumData.Length, "ChecksumData"); ccp.ChecksumData = new byte[0]; Assert.AreEqual ("mono", ccp.FileName, "FileName"); }
public void Constructor0 () { CodeChecksumPragma ccp = new CodeChecksumPragma (); Assert.AreEqual (Guid.Empty, ccp.ChecksumAlgorithmId, "#1"); Assert.IsNull (ccp.ChecksumData, "#2"); Assert.IsNotNull (ccp.FileName, "#3"); Assert.AreEqual (string.Empty, ccp.FileName, "#4"); ccp.FileName = null; Assert.IsNotNull (ccp.FileName, "#5"); Assert.AreEqual (string.Empty, ccp.FileName, "#6"); }
private void GenerateSource() { Debug.Assert(_codeContexts.Count == 0); CodeNamespace cnsImports = IsLanguageCSharp ? new CodeNamespace() : _ccRoot.CodeNS; if (IsCodeNeeded) { cnsImports.Imports.Add(new CodeNamespaceImport("System")); if (_usingNS != null) { foreach (string u in _usingNS) { cnsImports.Imports.Add(new CodeNamespaceImport(u)); } _usingNS.Clear(); _usingNS = null; } // } end SubClass _ccRoot.CodeNS.Types.Add(_ccRoot.CodeClass); } if (IsCompilingEntryPointClass) { GenerateAppEntryPoint(); } if (IsCodeNeeded) { MemoryStream codeMemStream = new MemoryStream(); // using Disposes the StreamWriter when it ends. Disposing the StreamWriter // also closes the underlying MemoryStream. Furthermore, don't add BOM here since // TaskFileService.WriteGeneratedCodeFileFile adds it. using (StreamWriter codeStreamWriter = new StreamWriter(codeMemStream, new UTF8Encoding(false))) { CodeGeneratorOptions o = new CodeGeneratorOptions(); // } end namespace CodeCompileUnit ccu = new CodeCompileUnit(); // generate pragma checksum data if (s_md5HashAlgorithm == null) { s_md5HashAlgorithm = new MD5CryptoServiceProvider(); s_hashMD5Guid = new Guid(0x406ea660, 0x64cf, 0x4c82, 0xb6, 0xf0, 0x42, 0xd4, 0x81, 0x72, 0xa7, 0x99); } CodeChecksumPragma csPragma = new CodeChecksumPragma(); csPragma.FileName = ParentFolderPrefix + SourceFileInfo.RelativeSourceFilePath + XAML; csPragma.ChecksumAlgorithmId = s_hashMD5Guid; csPragma.ChecksumData = TaskFileService.GetChecksum(SourceFileInfo.OriginalFilePath, s_hashMD5Guid); ccu.StartDirectives.Add(csPragma); if (cnsImports != _ccRoot.CodeNS) { ccu.Namespaces.Add(cnsImports); } ccu.Namespaces.Add(_ccRoot.CodeNS); CodeDomProvider codeProvider = EnsureCodeProvider(); if (codeProvider.Supports(GeneratorSupport.PartialTypes) && _ccRoot.SubClass.Length == 0) { _ccRoot.CodeClass.IsPartial = true; } codeProvider.GenerateCodeFromCompileUnit(ccu, codeStreamWriter, o); codeStreamWriter.Flush(); TaskFileService.WriteGeneratedCodeFile(codeMemStream.ToArray(), TargetPath + SourceFileInfo.RelativeSourceFilePath, SharedStrings.GeneratedExtension, SharedStrings.IntellisenseGeneratedExtension, LanguageSourceExtension); } } // Generate the InternalTypeHelper class in a separate code file only once and on an as // needed basis for the current assembly being built. This class provides support for // accessing legitimate internal types and properties that are present in the same (local) // or a friend assembly and it is generated only when any such internals are actually // encountered in any of the xaml files in the project. GenerateInternalTypeHelperImplementation(); }
private void GenerateChecksumPragma(CodeChecksumPragma checksumPragma) { base.Output.Write("#ExternalChecksum(\""); base.Output.Write(checksumPragma.FileName); base.Output.Write("\",\""); base.Output.Write(checksumPragma.ChecksumAlgorithmId.ToString("B", CultureInfo.InvariantCulture)); base.Output.Write("\",\""); if (checksumPragma.ChecksumData != null) { foreach (byte num in checksumPragma.ChecksumData) { base.Output.Write(num.ToString("X2", CultureInfo.InvariantCulture)); } } base.Output.WriteLine("\")"); }
internal void ConstructType () { unit = new CodeCompileUnit (); byte[] md5checksum = parser.MD5Checksum; if (md5checksum != null) { CodeChecksumPragma pragma = new CodeChecksumPragma (); pragma.FileName = parser.InputFile; pragma.ChecksumAlgorithmId = HashMD5; pragma.ChecksumData = md5checksum; unit.StartDirectives.Add (pragma); } if (parser.IsPartial) { string partialns = null; string partialclasstype = parser.PartialClassName; int partialdot = partialclasstype.LastIndexOf ('.'); if (partialdot != -1) { partialns = partialclasstype.Substring (0, partialdot); partialclasstype = partialclasstype.Substring (partialdot + 1); } CodeNamespace partialNS = new CodeNamespace (partialns); partialClass = new CodeTypeDeclaration (partialclasstype); partialClass.IsPartial = true; partialClassExpr = new CodeTypeReferenceExpression (parser.PartialClassName); unit.Namespaces.Add (partialNS); partialClass.TypeAttributes = TypeAttributes.Public; partialNS.Types.Add (partialClass); } string mainclasstype = parser.ClassName; string mainns = DEFAULT_NAMESPACE; int maindot = mainclasstype.LastIndexOf ('.'); if (maindot != -1) { mainns = mainclasstype.Substring (0, maindot); mainclasstype = mainclasstype.Substring (maindot + 1); } mainNS = new CodeNamespace (mainns); mainClass = new CodeTypeDeclaration (mainclasstype); CodeTypeReference baseTypeRef; if (partialClass != null) { baseTypeRef = new CodeTypeReference (parser.PartialClassName); baseTypeRef.Options |= CodeTypeReferenceOptions.GlobalReference; } else { baseTypeRef = new CodeTypeReference (parser.BaseType.FullName); if (parser.BaseTypeIsGlobal) baseTypeRef.Options |= CodeTypeReferenceOptions.GlobalReference; } mainClass.BaseTypes.Add (baseTypeRef); mainClassExpr = new CodeTypeReferenceExpression (mainns + "." + mainclasstype); unit.Namespaces.Add (mainNS); mainClass.TypeAttributes = TypeAttributes.Public; mainNS.Types.Add (mainClass); foreach (object o in parser.Imports.Keys) { if (o is string) mainNS.Imports.Add (new CodeNamespaceImport ((string) o)); } // StringCollection.Contains has O(n) complexity, but // considering the number of comparisons we make on // average and the fact that using an intermediate array // would be even more costly, this is fine here. StringCollection refAsm = unit.ReferencedAssemblies; string asmName; if (parser.Assemblies != null) { foreach (object o in parser.Assemblies) { asmName = o as string; if (asmName != null && !refAsm.Contains (asmName)) refAsm.Add (asmName); } } ArrayList al = WebConfigurationManager.ExtraAssemblies; if (al != null && al.Count > 0) { foreach (object o in al) { asmName = o as string; if (asmName != null && !refAsm.Contains (asmName)) refAsm.Add (asmName); } } IList list = BuildManager.CodeAssemblies; if (list != null && list.Count > 0) { Assembly asm; foreach (object o in list) { asm = o as Assembly; if (o == null) continue; asmName = asm.Location; if (asmName != null && !refAsm.Contains (asmName)) refAsm.Add (asmName); } } // Late-bound generators specifics (as for MonoBASIC/VB.NET) unit.UserData["RequireVariableDeclaration"] = parser.ExplicitOn; unit.UserData["AllowLateBound"] = !parser.StrictOn; InitializeType (); AddInterfaces (); AddClassAttributes (); CreateStaticFields (); AddApplicationAndSessionObjects (); AddScripts (); CreateMethods (); CreateConstructor (null, null); }
private void GenerateChecksumPragma(CodeChecksumPragma checksumPragma) { Output.Write("#pragma checksum \""); Output.Write(checksumPragma.FileName); Output.Write("\" \""); Output.Write(checksumPragma.ChecksumAlgorithmId.ToString("B", CultureInfo.InvariantCulture)); Output.Write("\" \""); if (checksumPragma.ChecksumData != null) { foreach(Byte b in checksumPragma.ChecksumData) { Output.Write(b.ToString("X2", CultureInfo.InvariantCulture)); } } Output.WriteLine("\""); }
private static void ValidateChecksumPragma(CodeChecksumPragma e) { if (e.FileName.IndexOfAny(Path.GetInvalidPathChars()) != -1) throw new ArgumentException(SR.GetString(SR.InvalidPathCharsInChecksum, e.FileName)); }
void GenerateCodeChecksumPragma (CodeChecksumPragma pragma) { Output.Write ("#pragma checksum "); Output.Write (QuoteSnippetString (pragma.FileName)); Output.Write (" \""); Output.Write (pragma.ChecksumAlgorithmId.ToString ("B")); Output.Write ("\" \""); if (pragma.ChecksumData != null) { foreach (byte b in pragma.ChecksumData) { Output.Write (b.ToString ("X2")); } } Output.WriteLine ("\""); }
// Create a CodeDOM graph. static void CreateGraph(CodeCompileUnit cu) { cu.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Compile Unit Region")); cu.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeChecksumPragma pragma1 = new CodeChecksumPragma(); pragma1.FileName = "c:\\temp\\test\\OuterLinePragma.txt"; pragma1.ChecksumAlgorithmId = HashMD5; pragma1.ChecksumData = new byte[] { 0xAA, 0xAA }; cu.StartDirectives.Add(pragma1); CodeChecksumPragma pragma2 = new CodeChecksumPragma("test.txt", HashSHA1, new byte[] { 0xBB, 0xBB, 0xBB }); cu.StartDirectives.Add(pragma2); CodeNamespace ns = new CodeNamespace("Namespace1"); ns.Imports.Add(new CodeNamespaceImport("System")); ns.Imports.Add(new CodeNamespaceImport("System.IO")); cu.Namespaces.Add(ns); ns.Comments.Add(new CodeCommentStatement("Namespace Comment")); CodeTypeDeclaration cd = new CodeTypeDeclaration("Class1"); ns.Types.Add(cd); cd.Comments.Add(new CodeCommentStatement("Outer Type Comment")); cd.LinePragma = new CodeLinePragma("c:\\temp\\test\\OuterLinePragma.txt", 300); CodeMemberMethod method1 = new CodeMemberMethod(); method1.Name = "Method1"; method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; CodeMemberMethod method2 = new CodeMemberMethod(); method2.Name = "Method2"; method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; method2.Comments.Add(new CodeCommentStatement("Method 2 Comment")); cd.Members.Add(method1); cd.Members.Add(method2); cd.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Outer Type Region")); cd.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeMemberField field1 = new CodeMemberField(typeof(String), "field1"); cd.Members.Add(field1); field1.Comments.Add(new CodeCommentStatement("Field 1 Comment")); CodeRegionDirective codeRegionDirective1 = new CodeRegionDirective(CodeRegionMode.Start, "Field Region"); field1.StartDirectives.Add(codeRegionDirective1); CodeRegionDirective codeRegionDirective2 = new CodeRegionDirective(CodeRegionMode.End, ""); codeRegionDirective2.RegionMode = CodeRegionMode.End; codeRegionDirective2.RegionText = string.Empty; field1.EndDirectives.Add(codeRegionDirective2); CodeSnippetStatement snippet1 = new CodeSnippetStatement(); snippet1.Value = " Console.WriteLine(field1);"; CodeRegionDirective regionStart = new CodeRegionDirective(CodeRegionMode.End, ""); regionStart.RegionText = "Snippet Region"; regionStart.RegionMode = CodeRegionMode.Start; snippet1.StartDirectives.Add(regionStart); snippet1.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); // CodeStatement example CodeConstructor constructor1 = new CodeConstructor(); constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; CodeStatement codeAssignStatement1 = new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "field1"), new CodePrimitiveExpression("value1")); codeAssignStatement1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Statements Region")); cd.Members.Add(constructor1); codeAssignStatement1.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); method2.Statements.Add(codeAssignStatement1); method2.Statements.Add(snippet1); }
private void GenerateChecksumPragma(CodeChecksumPragma checksumPragma) { // the syntax is: #ExternalChecksum("FileName","GuidChecksum","ChecksumValue") Output.Write("#ExternalChecksum(\""); Output.Write(checksumPragma.FileName); Output.Write("\",\""); Output.Write(checksumPragma.ChecksumAlgorithmId.ToString("B", CultureInfo.InvariantCulture)); Output.Write("\",\""); if (checksumPragma.ChecksumData != null) { foreach(Byte b in checksumPragma.ChecksumData) { Output.Write(b.ToString("X2", CultureInfo.InvariantCulture)); } } Output.WriteLine("\")"); }
// Add a checksum pragma. This is used for improved debugging experience. private void AddChecksumPragma(BuildProvider buildProvider, CodeCompileUnit compileUnit) { // If we can't get a virtual path, do nothing if (buildProvider == null || buildProvider.VirtualPath == null) return; // Only do this if we're compiling in debug mode if (!_compilerType.CompilerParameters.IncludeDebugInformation) return; string physicalPath = HostingEnvironment.MapPathInternal(buildProvider.VirtualPath); // Only do this is the file physically exists, which it would not in the // case of a non-file based VirtualPathProvider. In such case, there is // no point in putting the pragma, since the debugger could not locate // the file anyway. if (!File.Exists(physicalPath)) return; CodeChecksumPragma pragma = new CodeChecksumPragma() { ChecksumAlgorithmId = s_codeChecksumSha1Id }; if (_compConfig.UrlLinePragmas) { pragma.FileName = ErrorFormatter.MakeHttpLinePragma(buildProvider.VirtualPathObject.VirtualPathString); } else { pragma.FileName = physicalPath; } // Generate a SHA1 hash from the contents of the file // The VS debugger uses a cryptographic hash of the file being debugged so that it doesn't accidentally // display to the user the wrong version of the file. This is merely a convenience feature for debugging // purposes and is not security-related in any way. Since VS only supports MD5 and SHA1 hashes, we just // use SHA1 and suppress the [Obsolete] warning. #pragma warning disable 618 using (Stream stream = new FileStream(physicalPath, FileMode.Open, FileAccess.Read, FileShare.Read)) { using (SHA1 hashAlgorithm = CryptoAlgorithms.CreateSHA1()) { pragma.ChecksumData = hashAlgorithm.ComputeHash(stream); } } #pragma warning restore 618 // Add the pragma to the CodeCompileUnit compileUnit.StartDirectives.Add(pragma); }
protected virtual CodeChecksumPragma Rewrite(CodeChecksumPragma source, ref bool didRewrite) { if (source == null) { return source; } bool didChildRewrite = false; CodeChecksumPragma result = new CodeChecksumPragma(); result.FileName = source.FileName; result.ChecksumAlgorithmId = source.ChecksumAlgorithmId; result.ChecksumData = source.ChecksumData; this.Rewrite(result.UserData, source.UserData, ref didChildRewrite); if (didChildRewrite) { didRewrite = true; return result; } else { return source; } }
private void AddChecksumPragma(System.Web.Compilation.BuildProvider buildProvider, CodeCompileUnit compileUnit) { if (((buildProvider != null) && (buildProvider.VirtualPath != null)) && this._compilerType.CompilerParameters.IncludeDebugInformation) { string path = HostingEnvironment.MapPathInternal(buildProvider.VirtualPath); if (File.Exists(path)) { if (!s_hashMD5Guid.HasValue) { s_hashMD5Guid = new Guid(0x406ea660, 0x64cf, 0x4c82, 0xb6, 240, 0x42, 0xd4, 0x81, 0x72, 0xa7, 0x99); } CodeChecksumPragma pragma = new CodeChecksumPragma(); if (this._compConfig.UrlLinePragmas) { pragma.FileName = ErrorFormatter.MakeHttpLinePragma(buildProvider.VirtualPathObject.VirtualPathString); } else { pragma.FileName = path; } pragma.ChecksumAlgorithmId = s_hashMD5Guid.Value; using (Stream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read)) { pragma.ChecksumData = this.ComputeHash(stream); } compileUnit.StartDirectives.Add(pragma); } } }
/// <summary> /// Visits a <see cref="CodeChecksumPragma"/>. /// </summary> /// <param name="codeChecksumPragma">The <see cref="CodeChecksumPragma"/> to visit.</param> protected virtual void VisitCodeChecksumPragma(CodeChecksumPragma codeChecksumPragma) { }