The Labs \ Source Viewer \ SSCLI \ System.CodeDom.Compiler \ CodeValidator

  1. //------------------------------------------------------------------------------
  2. // <copyright file="CodeGenerator.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.CodeDom.Compiler
  16. {
  17.     using System;
  18.     using System.CodeDom;
  19.     using System.Collections;
  20.     using System.Globalization;
  21.     using System.IO;
  22.    
  23.     // This is an internal helper class which walks the tree for the ValidateIdentifiers API in the CodeGenerator. For the most part the generator code has been copied and
  24.     // turned into validation code. This code will only validate identifiers and types to check that they are ok in a language
  25.     // independent manner. By default, this will not be turned on. This gives clients of codedom a mechanism to
  26.     // protect themselves against certain types of code injection attacks (using identifier and type names).
  27.     // You can pass in any node in the tree that is a subclass of CodeObject.
  28.     internal class CodeValidator
  29.     {
  30.         private static readonly char[] newLineChars = new char[] {'\r', '\n', '
', '
', '\u133'};
  31.        
  32.         internal void ValidateIdentifiers(CodeObject e)
  33.         {
  34.             if (e is CodeCompileUnit) {
  35.                 ValidateCodeCompileUnit((CodeCompileUnit)e);
  36.             }
  37.             else if (e is CodeComment) {
  38.                 ValidateComment((CodeComment)e);
  39.             }
  40.             else if (e is CodeExpression) {
  41.                 ValidateExpression((CodeExpression)e);
  42.             }
  43.             else if (e is CodeNamespace) {
  44.                 ValidateNamespace((CodeNamespace)e);
  45.             }
  46.             else if (e is CodeNamespaceImport) {
  47.                 ValidateNamespaceImport((CodeNamespaceImport)e);
  48.             }
  49.             else if (e is CodeStatement) {
  50.                 ValidateStatement((CodeStatement)e);
  51.             }
  52.             else if (e is CodeTypeMember) {
  53.                 ValidateTypeMember((CodeTypeMember)e);
  54.             }
  55.             else if (e is CodeTypeReference) {
  56.                 ValidateTypeReference((CodeTypeReference)e);
  57.             }
  58.             else if (e is CodeDirective) {
  59.                 ValidateCodeDirective((CodeDirective)e);
  60.             }
  61.             else {
  62.                 throw new ArgumentException(SR.GetString(SR.InvalidElementType, e.GetType().FullName), "e");
  63.             }
  64.         }
  65.        
  66.         private void ValidateTypeMember(CodeTypeMember e)
  67.         {
  68.             ValidateCommentStatements(e.Comments);
  69.             ValidateCodeDirectives(e.StartDirectives);
  70.             ValidateCodeDirectives(e.EndDirectives);
  71.             if (e.LinePragma != null)
  72.                 ValidateLinePragmaStart(e.LinePragma);
  73.            
  74.             if (e is CodeMemberEvent) {
  75.                 ValidateEvent((CodeMemberEvent)e);
  76.             }
  77.             else if (e is CodeMemberField) {
  78.                 ValidateField((CodeMemberField)e);
  79.             }
  80.             else if (e is CodeMemberMethod) {
  81.                 ValidateMemberMethod((CodeMemberMethod)e);
  82.             }
  83.             else if (e is CodeMemberProperty) {
  84.                 ValidateProperty((CodeMemberProperty)e);
  85.             }
  86.             else if (e is CodeSnippetTypeMember) {
  87.                 ValidateSnippetMember((CodeSnippetTypeMember)e);
  88.             }
  89.             else if (e is CodeTypeDeclaration) {
  90.                 ValidateTypeDeclaration((CodeTypeDeclaration)e);
  91.             }
  92.             else {
  93.                 throw new ArgumentException(SR.GetString(SR.InvalidElementType, e.GetType().FullName), "e");
  94.             }
  95.         }
  96.        
  97.         private void ValidateCodeCompileUnit(CodeCompileUnit e)
  98.         {
  99.             ValidateCodeDirectives(e.StartDirectives);
  100.             ValidateCodeDirectives(e.EndDirectives);
  101.             if (e is CodeSnippetCompileUnit) {
  102.                 ValidateSnippetCompileUnit((CodeSnippetCompileUnit)e);
  103.             }
  104.             else {
  105.                 ValidateCompileUnitStart(e);
  106.                 ValidateNamespaces(e);
  107.                 ValidateCompileUnitEnd(e);
  108.             }
  109.         }
  110.        
  111.         private void ValidateSnippetCompileUnit(CodeSnippetCompileUnit e)
  112.         {
  113.             if (e.LinePragma != null)
  114.                 ValidateLinePragmaStart(e.LinePragma);
  115.         }
  116.        
  117.         private void ValidateCompileUnitStart(CodeCompileUnit e)
  118.         {
  119.             if (e.AssemblyCustomAttributes.Count > 0) {
  120.                 ValidateAttributes(e.AssemblyCustomAttributes);
  121.             }
  122.         }
  123.        
  124.         private void ValidateCompileUnitEnd(CodeCompileUnit e)
  125.         {
  126.         }
  127.        
  128.         private void ValidateNamespaces(CodeCompileUnit e)
  129.         {
  130.             foreach (CodeNamespace n in e.Namespaces) {
  131.                 ValidateNamespace(n);
  132.             }
  133.         }
  134.        
  135.         private void ValidateNamespace(CodeNamespace e)
  136.         {
  137.             ValidateCommentStatements(e.Comments);
  138.             ValidateNamespaceStart(e);
  139.             ValidateNamespaceImports(e);
  140.             ValidateTypes(e);
  141.         }
  142.        
  143.        
  144.         private static void ValidateNamespaceStart(CodeNamespace e)
  145.         {
  146.             if (e.Name != null && e.Name.Length > 0) {
  147.                 ValidateTypeName(e, "Name", e.Name);
  148.             }
  149.         }
  150.        
  151.         private void ValidateNamespaceImports(CodeNamespace e)
  152.         {
  153.             IEnumerator en = e.Imports.GetEnumerator();
  154.             while (en.MoveNext()) {
  155.                 CodeNamespaceImport imp = (CodeNamespaceImport)en.Current;
  156.                 if (imp.LinePragma != null)
  157.                     ValidateLinePragmaStart(imp.LinePragma);
  158.                 ValidateNamespaceImport(imp);
  159.             }
  160.         }
  161.        
  162.         private static void ValidateNamespaceImport(CodeNamespaceImport e)
  163.         {
  164.             ValidateTypeName(e, "Namespace", e.Namespace);
  165.         }
  166.        
  167.         private void ValidateAttributes(CodeAttributeDeclarationCollection attributes)
  168.         {
  169.             if (attributes.Count == 0)
  170.                 return;
  171.             IEnumerator en = attributes.GetEnumerator();
  172.             while (en.MoveNext()) {
  173.                 CodeAttributeDeclaration current = (CodeAttributeDeclaration)en.Current;
  174.                 ValidateTypeName(current, "Name", current.Name);
  175.                 ValidateTypeReference(current.AttributeType);
  176.                
  177.                 foreach (CodeAttributeArgument arg in current.Arguments) {
  178.                     ValidateAttributeArgument(arg);
  179.                 }
  180.             }
  181.         }
  182.        
  183.         private void ValidateAttributeArgument(CodeAttributeArgument arg)
  184.         {
  185.             if (arg.Name != null && arg.Name.Length > 0) {
  186.                 ValidateIdentifier(arg, "Name", arg.Name);
  187.             }
  188.             ValidateExpression(arg.Value);
  189.         }
  190.        
  191.         private void ValidateTypes(CodeNamespace e)
  192.         {
  193.             foreach (CodeTypeDeclaration type in e.Types) {
  194.                 ValidateTypeDeclaration(type);
  195.             }
  196.         }
  197.        
  198.         private void ValidateTypeDeclaration(CodeTypeDeclaration e)
  199.         {
  200.             // This function can be called recursively and will modify the global variable currentClass
  201.             // We will save currentClass to a local, modify it to do whatever we want and restore it back when we exit so that it is re-entrant.
  202.             CodeTypeDeclaration savedClass = currentClass;
  203.             currentClass = e;
  204.            
  205.             ValidateTypeStart(e);
  206.             ValidateTypeParameters(e.TypeParameters);
  207.             ValidateTypeMembers(e);
  208.             // Recursive call can come from here.
  209.             ValidateTypeReferences(e.BaseTypes);
  210.            
  211.             currentClass = savedClass;
  212.         }
  213.        
  214.         private void ValidateTypeMembers(CodeTypeDeclaration e)
  215.         {
  216.             foreach (CodeTypeMember currentMember in e.Members) {
  217.                 ValidateTypeMember(currentMember);
  218.             }
  219.         }
  220.        
  221.         private void ValidateTypeParameters(CodeTypeParameterCollection parameters)
  222.         {
  223.             for (int i = 0; i < parameters.Count; i++) {
  224.                 ValidateTypeParameter(parameters[i]);
  225.             }
  226.         }
  227.        
  228.         private void ValidateTypeParameter(CodeTypeParameter e)
  229.         {
  230.             ValidateIdentifier(e, "Name", e.Name);
  231.             ValidateTypeReferences(e.Constraints);
  232.             ValidateAttributes(e.CustomAttributes);
  233.         }
  234.        
  235.         private void ValidateField(CodeMemberField e)
  236.         {
  237.            
  238.             if (e.CustomAttributes.Count > 0) {
  239.                 ValidateAttributes(e.CustomAttributes);
  240.             }
  241.            
  242.             ValidateIdentifier(e, "Name", e.Name);
  243.             if (!IsCurrentEnum) {
  244.                 ValidateTypeReference(e.Type);
  245.             }
  246.            
  247.             if (e.InitExpression != null) {
  248.                 ValidateExpression(e.InitExpression);
  249.             }
  250.         }
  251.        
  252.         private void ValidateConstructor(CodeConstructor e)
  253.         {
  254.             if (e.CustomAttributes.Count > 0) {
  255.                 ValidateAttributes(e.CustomAttributes);
  256.             }
  257.            
  258.             ValidateParameters(e.Parameters);
  259.            
  260.             CodeExpressionCollection baseArgs = e.BaseConstructorArgs;
  261.             CodeExpressionCollection thisArgs = e.ChainedConstructorArgs;
  262.            
  263.             if (baseArgs.Count > 0) {
  264.                 ValidateExpressionList(baseArgs);
  265.             }
  266.            
  267.             if (thisArgs.Count > 0) {
  268.                 ValidateExpressionList(thisArgs);
  269.             }
  270.            
  271.             ValidateStatements(e.Statements);
  272.         }
  273.        
  274.         private void ValidateProperty(CodeMemberProperty e)
  275.         {
  276.            
  277.             if (e.CustomAttributes.Count > 0) {
  278.                 ValidateAttributes(e.CustomAttributes);
  279.             }
  280.            
  281.             ValidateTypeReference(e.Type);
  282.             ValidateTypeReferences(e.ImplementationTypes);
  283.            
  284.             if (e.PrivateImplementationType != null && !IsCurrentInterface) {
  285.                 ValidateTypeReference(e.PrivateImplementationType);
  286.             }
  287.            
  288.             if (e.Parameters.Count > 0 && String.Compare(e.Name, "Item", StringComparison.OrdinalIgnoreCase) == 0) {
  289.                 ValidateParameters(e.Parameters);
  290.             }
  291.             else {
  292.                 ValidateIdentifier(e, "Name", e.Name);
  293.             }
  294.            
  295.             if (e.HasGet) {
  296.                 if (!(IsCurrentInterface || (e.Attributes & MemberAttributes.ScopeMask) == MemberAttributes.Abstract)) {
  297.                     ValidateStatements(e.GetStatements);
  298.                 }
  299.             }
  300.            
  301.             if (e.HasSet) {
  302.                 if (!(IsCurrentInterface || (e.Attributes & MemberAttributes.ScopeMask) == MemberAttributes.Abstract)) {
  303.                     ValidateStatements(e.SetStatements);
  304.                 }
  305.             }
  306.         }
  307.        
  308.         private void ValidateMemberMethod(CodeMemberMethod e)
  309.         {
  310.             ValidateCommentStatements(e.Comments);
  311.             if (e.LinePragma != null)
  312.                 ValidateLinePragmaStart(e.LinePragma);
  313.            
  314.             ValidateTypeParameters(e.TypeParameters);
  315.             ValidateTypeReferences(e.ImplementationTypes);
  316.            
  317.             if (e is CodeEntryPointMethod) {
  318.                 ValidateStatements(((CodeEntryPointMethod)e).Statements);
  319.             }
  320.             else if (e is CodeConstructor) {
  321.                 ValidateConstructor((CodeConstructor)e);
  322.             }
  323.             else if (e is CodeTypeConstructor) {
  324.                 ValidateTypeConstructor((CodeTypeConstructor)e);
  325.             }
  326.             else {
  327.                 ValidateMethod(e);
  328.             }
  329.         }
  330.        
  331.         private void ValidateTypeConstructor(CodeTypeConstructor e)
  332.         {
  333.             ValidateStatements(e.Statements);
  334.         }
  335.        
  336.         private void ValidateMethod(CodeMemberMethod e)
  337.         {
  338.            
  339.             if (e.CustomAttributes.Count > 0) {
  340.                 ValidateAttributes(e.CustomAttributes);
  341.             }
  342.             if (e.ReturnTypeCustomAttributes.Count > 0) {
  343.                 ValidateAttributes(e.ReturnTypeCustomAttributes);
  344.             }
  345.            
  346.             ValidateTypeReference(e.ReturnType);
  347.             if (e.PrivateImplementationType != null) {
  348.                 ValidateTypeReference(e.PrivateImplementationType);
  349.             }
  350.            
  351.             ValidateIdentifier(e, "Name", e.Name);
  352.             ValidateParameters(e.Parameters);
  353.            
  354.             if (!IsCurrentInterface && (e.Attributes & MemberAttributes.ScopeMask) != MemberAttributes.Abstract) {
  355.                 ValidateStatements(e.Statements);
  356.             }
  357.         }
  358.        
  359.         private void ValidateSnippetMember(CodeSnippetTypeMember e)
  360.         {
  361.         }
  362.        
  363.         private void ValidateTypeStart(CodeTypeDeclaration e)
  364.         {
  365.             ValidateCommentStatements(e.Comments);
  366.             if (e.CustomAttributes.Count > 0) {
  367.                 ValidateAttributes(e.CustomAttributes);
  368.             }
  369.            
  370.             ValidateIdentifier(e, "Name", e.Name);
  371.             if (IsCurrentDelegate) {
  372.                 CodeTypeDelegate del = (CodeTypeDelegate)e;
  373.                 ValidateTypeReference(del.ReturnType);
  374.                 ValidateParameters(del.Parameters);
  375.             }
  376.             else {
  377.                 foreach (CodeTypeReference typeRef in e.BaseTypes) {
  378.                     ValidateTypeReference(typeRef);
  379.                 }
  380.             }
  381.         }
  382.        
  383.         private void ValidateCommentStatements(CodeCommentStatementCollection e)
  384.         {
  385.             foreach (CodeCommentStatement comment in e) {
  386.                 ValidateCommentStatement(comment);
  387.             }
  388.         }
  389.        
  390.         private void ValidateCommentStatement(CodeCommentStatement e)
  391.         {
  392.             ValidateComment(e.Comment);
  393.         }
  394.        
  395.         private void ValidateComment(CodeComment e)
  396.         {
  397.         }
  398.        
  399.         private void ValidateStatement(CodeStatement e)
  400.         {
  401.             ValidateCodeDirectives(e.StartDirectives);
  402.             ValidateCodeDirectives(e.EndDirectives);
  403.            
  404.             if (e is CodeCommentStatement) {
  405.                 ValidateCommentStatement((CodeCommentStatement)e);
  406.             }
  407.             else if (e is CodeMethodReturnStatement) {
  408.                 ValidateMethodReturnStatement((CodeMethodReturnStatement)e);
  409.             }
  410.             else if (e is CodeConditionStatement) {
  411.                 ValidateConditionStatement((CodeConditionStatement)e);
  412.             }
  413.             else if (e is CodeTryCatchFinallyStatement) {
  414.                 ValidateTryCatchFinallyStatement((CodeTryCatchFinallyStatement)e);
  415.             }
  416.             else if (e is CodeAssignStatement) {
  417.                 ValidateAssignStatement((CodeAssignStatement)e);
  418.             }
  419.             else if (e is CodeExpressionStatement) {
  420.                 ValidateExpressionStatement((CodeExpressionStatement)e);
  421.             }
  422.             else if (e is CodeIterationStatement) {
  423.                 ValidateIterationStatement((CodeIterationStatement)e);
  424.             }
  425.             else if (e is CodeThrowExceptionStatement) {
  426.                 ValidateThrowExceptionStatement((CodeThrowExceptionStatement)e);
  427.             }
  428.             else if (e is CodeSnippetStatement) {
  429.                 ValidateSnippetStatement((CodeSnippetStatement)e);
  430.             }
  431.             else if (e is CodeVariableDeclarationStatement) {
  432.                 ValidateVariableDeclarationStatement((CodeVariableDeclarationStatement)e);
  433.             }
  434.             else if (e is CodeAttachEventStatement) {
  435.                 ValidateAttachEventStatement((CodeAttachEventStatement)e);
  436.             }
  437.             else if (e is CodeRemoveEventStatement) {
  438.                 ValidateRemoveEventStatement((CodeRemoveEventStatement)e);
  439.             }
  440.             else if (e is CodeGotoStatement) {
  441.                 ValidateGotoStatement((CodeGotoStatement)e);
  442.             }
  443.             else if (e is CodeLabeledStatement) {
  444.                 ValidateLabeledStatement((CodeLabeledStatement)e);
  445.             }
  446.             else {
  447.                 throw new ArgumentException(SR.GetString(SR.InvalidElementType, e.GetType().FullName), "e");
  448.             }
  449.         }
  450.        
  451.         private void ValidateStatements(CodeStatementCollection stms)
  452.         {
  453.             IEnumerator en = stms.GetEnumerator();
  454.             while (en.MoveNext()) {
  455.                 ValidateStatement((CodeStatement)en.Current);
  456.             }
  457.         }
  458.        
  459.         private void ValidateExpressionStatement(CodeExpressionStatement e)
  460.         {
  461.             ValidateExpression(e.Expression);
  462.         }
  463.        
  464.         private void ValidateIterationStatement(CodeIterationStatement e)
  465.         {
  466.             ValidateStatement(e.InitStatement);
  467.             ValidateExpression(e.TestExpression);
  468.             ValidateStatement(e.IncrementStatement);
  469.             ValidateStatements(e.Statements);
  470.         }
  471.        
  472.         private void ValidateThrowExceptionStatement(CodeThrowExceptionStatement e)
  473.         {
  474.             if (e.ToThrow != null) {
  475.                 ValidateExpression(e.ToThrow);
  476.             }
  477.         }
  478.        
  479.         private void ValidateMethodReturnStatement(CodeMethodReturnStatement e)
  480.         {
  481.             if (e.Expression != null) {
  482.                 ValidateExpression(e.Expression);
  483.             }
  484.         }
  485.        
  486.         private void ValidateConditionStatement(CodeConditionStatement e)
  487.         {
  488.             ValidateExpression(e.Condition);
  489.             ValidateStatements(e.TrueStatements);
  490.            
  491.             CodeStatementCollection falseStatemetns = e.FalseStatements;
  492.             if (falseStatemetns.Count > 0) {
  493.                 ValidateStatements(e.FalseStatements);
  494.             }
  495.         }
  496.        
  497.         private void ValidateTryCatchFinallyStatement(CodeTryCatchFinallyStatement e)
  498.         {
  499.             ValidateStatements(e.TryStatements);
  500.             CodeCatchClauseCollection catches = e.CatchClauses;
  501.             if (catches.Count > 0) {
  502.                 IEnumerator en = catches.GetEnumerator();
  503.                 while (en.MoveNext()) {
  504.                     CodeCatchClause current = (CodeCatchClause)en.Current;
  505.                     ValidateTypeReference(current.CatchExceptionType);
  506.                     ValidateIdentifier(current, "LocalName", current.LocalName);
  507.                     ValidateStatements(current.Statements);
  508.                 }
  509.             }
  510.            
  511.             CodeStatementCollection finallyStatements = e.FinallyStatements;
  512.             if (finallyStatements.Count > 0) {
  513.                 ValidateStatements(finallyStatements);
  514.             }
  515.         }
  516.        
  517.         private void ValidateAssignStatement(CodeAssignStatement e)
  518.         {
  519.             ValidateExpression(e.Left);
  520.             ValidateExpression(e.Right);
  521.         }
  522.        
  523.         private void ValidateAttachEventStatement(CodeAttachEventStatement e)
  524.         {
  525.             ValidateEventReferenceExpression(e.Event);
  526.             ValidateExpression(e.Listener);
  527.         }
  528.        
  529.         private void ValidateRemoveEventStatement(CodeRemoveEventStatement e)
  530.         {
  531.             ValidateEventReferenceExpression(e.Event);
  532.             ValidateExpression(e.Listener);
  533.         }
  534.        
  535.         private static void ValidateGotoStatement(CodeGotoStatement e)
  536.         {
  537.             ValidateIdentifier(e, "Label", e.Label);
  538.         }
  539.        
  540.         private void ValidateLabeledStatement(CodeLabeledStatement e)
  541.         {
  542.             ValidateIdentifier(e, "Label", e.Label);
  543.             if (e.Statement != null) {
  544.                 ValidateStatement(e.Statement);
  545.             }
  546.         }
  547.        
  548.         private void ValidateVariableDeclarationStatement(CodeVariableDeclarationStatement e)
  549.         {
  550.             ValidateTypeReference(e.Type);
  551.             ValidateIdentifier(e, "Name", e.Name);
  552.             if (e.InitExpression != null) {
  553.                 ValidateExpression(e.InitExpression);
  554.             }
  555.         }
  556.        
  557.         private void ValidateLinePragmaStart(CodeLinePragma e)
  558.         {
  559.         }
  560.        
  561.         private void ValidateEvent(CodeMemberEvent e)
  562.         {
  563.            
  564.             if (e.CustomAttributes.Count > 0) {
  565.                 ValidateAttributes(e.CustomAttributes);
  566.             }
  567.             if (e.PrivateImplementationType != null) {
  568.                 ValidateTypeReference(e.Type);
  569.                 ValidateIdentifier(e, "Name", e.Name);
  570.             }
  571.            
  572.             ValidateTypeReferences(e.ImplementationTypes);
  573.         }
  574.        
  575.         private void ValidateParameters(CodeParameterDeclarationExpressionCollection parameters)
  576.         {
  577.             IEnumerator en = parameters.GetEnumerator();
  578.             while (en.MoveNext()) {
  579.                 CodeParameterDeclarationExpression current = (CodeParameterDeclarationExpression)en.Current;
  580.                 ValidateParameterDeclarationExpression(current);
  581.             }
  582.         }
  583.        
  584.         private void ValidateSnippetStatement(CodeSnippetStatement e)
  585.         {
  586.         }
  587.        
  588.         private void ValidateExpressionList(CodeExpressionCollection expressions)
  589.         {
  590.             IEnumerator en = expressions.GetEnumerator();
  591.             while (en.MoveNext()) {
  592.                 ValidateExpression((CodeExpression)en.Current);
  593.             }
  594.         }
  595.        
  596.         private static void ValidateTypeReference(CodeTypeReference e)
  597.         {
  598.             string baseType = e.BaseType;
  599.             ValidateTypeName(e, "BaseType", baseType);
  600.             ValidateArity(e);
  601.             ValidateTypeReferences(e.TypeArguments);
  602.         }
  603.        
  604.         private static void ValidateTypeReferences(CodeTypeReferenceCollection refs)
  605.         {
  606.             for (int i = 0; i < refs.Count; i++) {
  607.                 ValidateTypeReference(refs[i]);
  608.             }
  609.         }
  610.        
  611.         private static void ValidateArity(CodeTypeReference e)
  612.         {
  613.             // Verify that the number of TypeArguments agrees with the arity on the type.
  614.             string baseType = e.BaseType;
  615.             int totalTypeArgs = 0;
  616.             for (int i = 0; i < baseType.Length; i++) {
  617.                 if (baseType[i] == '`') {
  618.                     i++;
  619.                     // skip the '
  620.                     int numTypeArgs = 0;
  621.                     while (i < baseType.Length && baseType[i] >= '0' && baseType[i] <= '9') {
  622.                         numTypeArgs = numTypeArgs * 10 + (baseType[i] - '0');
  623.                         i++;
  624.                     }
  625.                    
  626.                     totalTypeArgs += numTypeArgs;
  627.                 }
  628.             }
  629.            
  630.             // Check if we have zero type args for open types.
  631.             if ((totalTypeArgs != e.TypeArguments.Count) && (e.TypeArguments.Count != 0)) {
  632.                 throw new ArgumentException(SR.GetString(SR.ArityDoesntMatch, baseType, e.TypeArguments.Count));
  633.             }
  634.         }
  635.        
  636.         private static void ValidateTypeName(object e, string propertyName, string typeName)
  637.         {
  638.             if (!CodeGenerator.IsValidLanguageIndependentTypeName(typeName)) {
  639.                 string message = SR.GetString(SR.InvalidTypeName, typeName, propertyName, e.GetType().FullName);
  640.                 throw new ArgumentException(message, "typeName");
  641.             }
  642.         }
  643.        
  644.         private static void ValidateIdentifier(object e, string propertyName, string identifier)
  645.         {
  646.             if (!CodeGenerator.IsValidLanguageIndependentIdentifier(identifier)) {
  647.                 string message = SR.GetString(SR.InvalidLanguageIdentifier, identifier, propertyName, e.GetType().FullName);
  648.                 throw new ArgumentException(message, "identifier");
  649.             }
  650.         }
  651.        
  652.         private void ValidateExpression(CodeExpression e)
  653.         {
  654.             if (e is CodeArrayCreateExpression) {
  655.                 ValidateArrayCreateExpression((CodeArrayCreateExpression)e);
  656.             }
  657.             else if (e is CodeBaseReferenceExpression) {
  658.                 ValidateBaseReferenceExpression((CodeBaseReferenceExpression)e);
  659.             }
  660.             else if (e is CodeBinaryOperatorExpression) {
  661.                 ValidateBinaryOperatorExpression((CodeBinaryOperatorExpression)e);
  662.             }
  663.             else if (e is CodeCastExpression) {
  664.                 ValidateCastExpression((CodeCastExpression)e);
  665.             }
  666.             else if (e is CodeDefaultValueExpression) {
  667.                 ValidateDefaultValueExpression((CodeDefaultValueExpression)e);
  668.             }
  669.             else if (e is CodeDelegateCreateExpression) {
  670.                 ValidateDelegateCreateExpression((CodeDelegateCreateExpression)e);
  671.             }
  672.             else if (e is CodeFieldReferenceExpression) {
  673.                 ValidateFieldReferenceExpression((CodeFieldReferenceExpression)e);
  674.             }
  675.             else if (e is CodeArgumentReferenceExpression) {
  676.                 ValidateArgumentReferenceExpression((CodeArgumentReferenceExpression)e);
  677.             }
  678.             else if (e is CodeVariableReferenceExpression) {
  679.                 ValidateVariableReferenceExpression((CodeVariableReferenceExpression)e);
  680.             }
  681.             else if (e is CodeIndexerExpression) {
  682.                 ValidateIndexerExpression((CodeIndexerExpression)e);
  683.             }
  684.             else if (e is CodeArrayIndexerExpression) {
  685.                 ValidateArrayIndexerExpression((CodeArrayIndexerExpression)e);
  686.             }
  687.             else if (e is CodeSnippetExpression) {
  688.                 ValidateSnippetExpression((CodeSnippetExpression)e);
  689.             }
  690.             else if (e is CodeMethodInvokeExpression) {
  691.                 ValidateMethodInvokeExpression((CodeMethodInvokeExpression)e);
  692.             }
  693.             else if (e is CodeMethodReferenceExpression) {
  694.                 ValidateMethodReferenceExpression((CodeMethodReferenceExpression)e);
  695.             }
  696.             else if (e is CodeEventReferenceExpression) {
  697.                 ValidateEventReferenceExpression((CodeEventReferenceExpression)e);
  698.             }
  699.             else if (e is CodeDelegateInvokeExpression) {
  700.                 ValidateDelegateInvokeExpression((CodeDelegateInvokeExpression)e);
  701.             }
  702.             else if (e is CodeObjectCreateExpression) {
  703.                 ValidateObjectCreateExpression((CodeObjectCreateExpression)e);
  704.             }
  705.             else if (e is CodeParameterDeclarationExpression) {
  706.                 ValidateParameterDeclarationExpression((CodeParameterDeclarationExpression)e);
  707.             }
  708.             else if (e is CodeDirectionExpression) {
  709.                 ValidateDirectionExpression((CodeDirectionExpression)e);
  710.             }
  711.             else if (e is CodePrimitiveExpression) {
  712.                 ValidatePrimitiveExpression((CodePrimitiveExpression)e);
  713.             }
  714.             else if (e is CodePropertyReferenceExpression) {
  715.                 ValidatePropertyReferenceExpression((CodePropertyReferenceExpression)e);
  716.             }
  717.             else if (e is CodePropertySetValueReferenceExpression) {
  718.                 ValidatePropertySetValueReferenceExpression((CodePropertySetValueReferenceExpression)e);
  719.             }
  720.             else if (e is CodeThisReferenceExpression) {
  721.                 ValidateThisReferenceExpression((CodeThisReferenceExpression)e);
  722.             }
  723.             else if (e is CodeTypeReferenceExpression) {
  724.                 ValidateTypeReference(((CodeTypeReferenceExpression)e).Type);
  725.             }
  726.             else if (e is CodeTypeOfExpression) {
  727.                 ValidateTypeOfExpression((CodeTypeOfExpression)e);
  728.             }
  729.             else {
  730.                 if (e == null) {
  731.                     throw new ArgumentNullException("e");
  732.                 }
  733.                 else {
  734.                     throw new ArgumentException(SR.GetString(SR.InvalidElementType, e.GetType().FullName), "e");
  735.                 }
  736.             }
  737.         }
  738.        
  739.         private void ValidateArrayCreateExpression(CodeArrayCreateExpression e)
  740.         {
  741.             ValidateTypeReference(e.CreateType);
  742.             CodeExpressionCollection init = e.Initializers;
  743.             if (init.Count > 0) {
  744.                 ValidateExpressionList(init);
  745.             }
  746.             else {
  747.                 if (e.SizeExpression != null) {
  748.                     ValidateExpression(e.SizeExpression);
  749.                 }
  750.             }
  751.         }
  752.        
  753.         private void ValidateBaseReferenceExpression(CodeBaseReferenceExpression e)
  754.         {
  755.             // Nothing to validate
  756.         }
  757.        
  758.         private void ValidateBinaryOperatorExpression(CodeBinaryOperatorExpression e)
  759.         {
  760.             ValidateExpression(e.Left);
  761.             ValidateExpression(e.Right);
  762.         }
  763.        
  764.         private void ValidateCastExpression(CodeCastExpression e)
  765.         {
  766.             ValidateTypeReference(e.TargetType);
  767.             ValidateExpression(e.Expression);
  768.         }
  769.        
  770.         private static void ValidateDefaultValueExpression(CodeDefaultValueExpression e)
  771.         {
  772.             ValidateTypeReference(e.Type);
  773.         }
  774.        
  775.         private void ValidateDelegateCreateExpression(CodeDelegateCreateExpression e)
  776.         {
  777.             ValidateTypeReference(e.DelegateType);
  778.             ValidateExpression(e.TargetObject);
  779.             ValidateIdentifier(e, "MethodName", e.MethodName);
  780.         }
  781.        
  782.         private void ValidateFieldReferenceExpression(CodeFieldReferenceExpression e)
  783.         {
  784.             if (e.TargetObject != null) {
  785.                 ValidateExpression(e.TargetObject);
  786.             }
  787.             ValidateIdentifier(e, "FieldName", e.FieldName);
  788.         }
  789.        
  790.         private static void ValidateArgumentReferenceExpression(CodeArgumentReferenceExpression e)
  791.         {
  792.             ValidateIdentifier(e, "ParameterName", e.ParameterName);
  793.         }
  794.        
  795.         private static void ValidateVariableReferenceExpression(CodeVariableReferenceExpression e)
  796.         {
  797.             ValidateIdentifier(e, "VariableName", e.VariableName);
  798.         }
  799.        
  800.         private void ValidateIndexerExpression(CodeIndexerExpression e)
  801.         {
  802.             ValidateExpression(e.TargetObject);
  803.             foreach (CodeExpression exp in e.Indices) {
  804.                 ValidateExpression(exp);
  805.             }
  806.         }
  807.        
  808.         private void ValidateArrayIndexerExpression(CodeArrayIndexerExpression e)
  809.         {
  810.             ValidateExpression(e.TargetObject);
  811.             foreach (CodeExpression exp in e.Indices) {
  812.                 ValidateExpression(exp);
  813.             }
  814.         }
  815.        
  816.         private void ValidateSnippetExpression(CodeSnippetExpression e)
  817.         {
  818.         }
  819.        
  820.         private void ValidateMethodInvokeExpression(CodeMethodInvokeExpression e)
  821.         {
  822.             ValidateMethodReferenceExpression(e.Method);
  823.             ValidateExpressionList(e.Parameters);
  824.         }
  825.        
  826.         private void ValidateMethodReferenceExpression(CodeMethodReferenceExpression e)
  827.         {
  828.             if (e.TargetObject != null) {
  829.                 ValidateExpression(e.TargetObject);
  830.             }
  831.             ValidateIdentifier(e, "MethodName", e.MethodName);
  832.             ValidateTypeReferences(e.TypeArguments);
  833.         }
  834.        
  835.         private void ValidateEventReferenceExpression(CodeEventReferenceExpression e)
  836.         {
  837.             if (e.TargetObject != null) {
  838.                 ValidateExpression(e.TargetObject);
  839.             }
  840.             ValidateIdentifier(e, "EventName", e.EventName);
  841.         }
  842.        
  843.         private void ValidateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
  844.         {
  845.             if (e.TargetObject != null) {
  846.                 ValidateExpression(e.TargetObject);
  847.             }
  848.             ValidateExpressionList(e.Parameters);
  849.         }
  850.        
  851.         private void ValidateObjectCreateExpression(CodeObjectCreateExpression e)
  852.         {
  853.             ValidateTypeReference(e.CreateType);
  854.             ValidateExpressionList(e.Parameters);
  855.         }
  856.        
  857.         private void ValidateParameterDeclarationExpression(CodeParameterDeclarationExpression e)
  858.         {
  859.             if (e.CustomAttributes.Count > 0) {
  860.                 ValidateAttributes(e.CustomAttributes);
  861.             }
  862.            
  863.             ValidateTypeReference(e.Type);
  864.             ValidateIdentifier(e, "Name", e.Name);
  865.         }
  866.        
  867.         private void ValidateDirectionExpression(CodeDirectionExpression e)
  868.         {
  869.             ValidateExpression(e.Expression);
  870.         }
  871.        
  872.         private void ValidatePrimitiveExpression(CodePrimitiveExpression e)
  873.         {
  874.         }
  875.        
  876.         private void ValidatePropertyReferenceExpression(CodePropertyReferenceExpression e)
  877.         {
  878.             if (e.TargetObject != null) {
  879.                 ValidateExpression(e.TargetObject);
  880.             }
  881.             ValidateIdentifier(e, "PropertyName", e.PropertyName);
  882.         }
  883.        
  884.         private void ValidatePropertySetValueReferenceExpression(CodePropertySetValueReferenceExpression e)
  885.         {
  886.             // Do nothing
  887.         }
  888.        
  889.         private void ValidateThisReferenceExpression(CodeThisReferenceExpression e)
  890.         {
  891.             // Do nothing
  892.         }
  893.        
  894.         private static void ValidateTypeOfExpression(CodeTypeOfExpression e)
  895.         {
  896.             ValidateTypeReference(e.Type);
  897.         }
  898.        
  899.         private static void ValidateCodeDirectives(CodeDirectiveCollection e)
  900.         {
  901.             for (int i = 0; i < e.Count; i++)
  902.                 ValidateCodeDirective(e[i]);
  903.         }
  904.        
  905.         private static void ValidateCodeDirective(CodeDirective e)
  906.         {
  907.             if (e is CodeChecksumPragma)
  908.                 ValidateChecksumPragma((CodeChecksumPragma)e);
  909.             else if (e is CodeRegionDirective)
  910.                 ValidateRegionDirective((CodeRegionDirective)e);
  911.             else
  912.                 throw new ArgumentException(SR.GetString(SR.InvalidElementType, e.GetType().FullName), "e");
  913.         }
  914.        
  915.         private static void ValidateChecksumPragma(CodeChecksumPragma e)
  916.         {
  917.             if (e.FileName.IndexOfAny(Path.GetInvalidPathChars()) != -1)
  918.                 throw new ArgumentException(SR.GetString(SR.InvalidPathCharsInChecksum, e.FileName));
  919.         }
  920.        
  921.         private static void ValidateRegionDirective(CodeRegionDirective e)
  922.         {
  923.             if (e.RegionText.IndexOfAny(newLineChars) != -1)
  924.                 throw new ArgumentException(SR.GetString(SR.InvalidRegion, e.RegionText));
  925.         }
  926.        
  927.         private bool IsCurrentInterface {
  928.             get {
  929.                 if (currentClass != null && !(currentClass is CodeTypeDelegate)) {
  930.                     return currentClass.IsInterface;
  931.                 }
  932.                 return false;
  933.             }
  934.         }
  935.        
  936.         private bool IsCurrentEnum {
  937.             get {
  938.                 if (currentClass != null && !(currentClass is CodeTypeDelegate)) {
  939.                     return currentClass.IsEnum;
  940.                 }
  941.                 return false;
  942.             }
  943.         }
  944.        
  945.         private bool IsCurrentDelegate {
  946.             get {
  947.                 if (currentClass != null && currentClass is CodeTypeDelegate) {
  948.                     return true;
  949.                 }
  950.                 return false;
  951.             }
  952.         }
  953.        
  954.         private CodeTypeDeclaration currentClass;
  955.     }
  956. }

Developer Fusion