[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Dotgnu-pnet-commits] CVS: pnetlib/System/CodeDom/Compiler Validator.cs,
|
From: |
Rhys Weatherley <address@hidden> |
|
Subject: |
[Dotgnu-pnet-commits] CVS: pnetlib/System/CodeDom/Compiler Validator.cs, NONE, 1.1 CodeGenerator.cs, 1.4, 1.5 |
|
Date: |
Mon, 21 Jul 2003 06:12:01 -0400 |
Update of /cvsroot/dotgnu-pnet/pnetlib/System/CodeDom/Compiler
In directory subversions:/tmp/cvs-serv1942/System/CodeDom/Compiler
Modified Files:
CodeGenerator.cs
Added Files:
Validator.cs
Log Message:
Implement identifier validation for the System.CodeDom routines.
--- NEW FILE ---
/*
* Validator.cs - Implementation of the
* System.CodeDom.Compiler.Validator class.
*
* Copyright (C) 2002, 2003 Southern Storm Software, Pty Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
namespace System.CodeDom.Compiler
{
#if CONFIG_CODEDOM
using System.IO;
using System.Reflection;
using System.Globalization;
using System.Collections;
// Helper class for validating the contents of a CodeDom tree.
internal sealed class Validator
{
// Validate an identifier.
private static void ValidateIdentifier(String value)
{
if(!CodeGenerator.IsValidLanguageIndependentIdentifier(value))
{
throw new
ArgumentException(S._("Arg_InvalidIdentifier"));
}
}
// Validate a qualified identifier.
private static void ValidateQualifiedIdentifier
(String value, bool canBeNull)
{
if(value == null)
{
if(!canBeNull)
{
throw new ArgumentException
(S._("Arg_InvalidIdentifier"));
}
}
else
{
int posn = 0;
int index;
String component;
while((index = value.IndexOf('.',
posn)) != -1)
{
component =
value.Substring(posn, index - posn);
ValidateIdentifier(component);
posn = index + 1;
}
component = value.Substring(posn);
ValidateIdentifier(component);
}
}
// Validate a code object.
public static void Validate(Object e)
{
if(e == null)
{
// Nothing to do here.
}
else if(e is ICollection)
{
IEnumerator e =
((ICollection)e).GetEnumerator();
while(e.MoveNext())
{
Validate(e.Current);
}
}
else if(e is CodeArrayCreateExpression)
{
Validate(((CodeArrayCreateExpression)e).CreateType);
Validate(((CodeArrayCreateExpression)e).Initializers);
Validate(((CodeArrayCreateExpression)e).SizeExpression);
}
else if(e is CodeAttachEventStatement)
{
Validate(((CodeAttachEventStatement)e).Event);
Validate(((CodeAttachEventStatement)e).Listener);
}
else if(e is CodeCastExpression)
{
Validate(((CodeCastExpression)e).TargetType);
Validate(((CodeCastExpression)e).Expression);
}
else if(e is CodeCatchClause)
{
ValidateIdentifier(((CodeCatchClause)e).LocalName);
Validate(((CodeCatchClause)e).CatchExceptionType);
Validate(((CodeCatchClause)e).Statements);
}
else if(e is CodeConditionStatement)
{
Validate(((CodeConditionStatement)e).Condition);
Validate(((CodeConditionStatement)e).TrueStatements);
Validate(((CodeConditionStatement)e).FalseStatements);
}
else if(e is CodeGotoStatement)
{
ValidateIdentifier(((CodeGotoStatement)e).Label);
}
else if(e is CodeMemberEvent)
{
Validate(((CodeMemberEvent)e).CustomAttributes);
ValidateIdentifier(((CodeMemberEvent)e).Name);
Validate(((CodeMemberEvent)e).ImplementationTypes);
Validate(((CodeMemberEvent)e).PrivateImplementationType);
Validate(((CodeMemberEvent)e).Type);
}
else if(e is CodeMemberField)
{
Validate(((CodeMemberField)e).CustomAttributes);
ValidateIdentifier(((CodeMemberField)e).Name);
Validate(((CodeMemberField)e).Type);
Validate(((CodeMemberField)e).InitExpression);
}
else if(e is CodeConstructor)
{
Validate(((CodeConstructor)e).CustomAttributes);
ValidateIdentifier(((CodeConstructor)e).Name);
Validate(((CodeConstructor)e).ImplementationTypes);
Validate(((CodeConstructor)e).Parameters);
Validate(((CodeConstructor)e).PrivateImplementationType);
Validate(((CodeConstructor)e).ReturnType);
Validate(((CodeConstructor)e).ReturnTypeCustomAttributes);
Validate(((CodeConstructor)e).Statements);
Validate(((CodeConstructor)e).BaseConstructorArgs);
Validate(((CodeConstructor)e).ChainedConstructorArgs);
}
else if(e is CodeMemberMethod)
{
Validate(((CodeMemberMethod)e).CustomAttributes);
ValidateIdentifier(((CodeMemberMethod)e).Name);
Validate(((CodeMemberMethod)e).ImplementationTypes);
Validate(((CodeMemberMethod)e).Parameters);
Validate(((CodeMemberMethod)e).PrivateImplementationType);
Validate(((CodeMemberMethod)e).ReturnType);
Validate(((CodeMemberMethod)e).ReturnTypeCustomAttributes);
Validate(((CodeMemberMethod)e).Statements);
}
else if(e is CodeMemberProperty)
{
Validate(((CodeMemberProperty)e).CustomAttributes);
ValidateIdentifier(((CodeMemberProperty)e).Name);
Validate(((CodeMemberProperty)e).GetStatements);
Validate(((CodeMemberProperty)e).ImplementationTypes);
Validate(((CodeMemberProperty)e).Parameters);
Validate(((CodeMemberProperty)e).PrivateImplementationType);
Validate(((CodeMemberProperty)e).SetStatements);
Validate(((CodeMemberProperty)e).Type);
}
else if(e is CodeMethodInvokeExpression)
{
Validate(((CodeMethodInvokeExpression)e).Method);
Validate(((CodeMethodInvokeExpression)e).Parameters);
}
else if(e is CodeNamespace)
{
Validate(((CodeNamespace)e).Imports);
ValidateQualifiedIdentifier(((CodeNamespace)e).Name, false);
Validate(((CodeNamespace)e).Types);
}
else if(e is CodeNamespaceImport)
{
ValidateQualifiedIdentifier
(((CodeNamespaceImport)e).Namespace, false);
}
else if(e is CodeObjectCreateExpression)
{
Validate(((CodeObjectCreateExpression)e).CreateType);
Validate(((CodeObjectCreateExpression)e).Parameters);
}
else if(e is CodeParameterDeclarationExpression)
{
Validate(((CodeParameterDeclarationExpression)e)
.CustomAttributes);
ValidateIdentifier
(((CodeParameterDeclarationExpression)e).Name);
Validate(((CodeParameterDeclarationExpression)e).Type);
}
else if(e is CodeRemoveEventStatement)
{
Validate(((CodeRemoveEventStatement)e).Event);
Validate(((CodeRemoveEventStatement)e).Listener);
}
else if(e is CodeTypeDelegate)
{
Validate(((CodeTypeDelegate)e).CustomAttributes);
ValidateIdentifier(((CodeTypeDelegate)e).Name);
Validate(((CodeTypeDelegate)e).BaseTypes);
Validate(((CodeTypeDelegate)e).Members);
Validate(((CodeTypeDelegate)e).Parameters);
Validate(((CodeTypeDelegate)e).ReturnType);
}
else if(e is CodeTypeDeclaration)
{
Validate(((CodeTypeDeclaration)e).CustomAttributes);
ValidateIdentifier(((CodeTypeDeclaration)e).Name);
Validate(((CodeTypeDeclaration)e).BaseTypes);
Validate(((CodeTypeDeclaration)e).Members);
}
else if(e is CodeTypeOfExpression)
{
Validate(((CodeTypeOfExpression)e).Type);
}
else if(e is CodeTypeReference)
{
Validate(((CodeTypeReference)e).ArrayElementType);
ValidateQualifiedIdentifier
(((CodeTypeReference)e).BaseType, true);
}
else if(e is CodeTypeReferenceExpression)
{
Validate(((CodeTypeReferenceExpression)e).Type);
}
else if(e is CodeVariableDeclarationStatement)
{
Validate
(((CodeVariableDeclarationStatement)e).InitExpression);
ValidateIdentifier
(((CodeVariableDeclarationStatement)e).Name);
Validate(((CodeVariableDeclarationStatement)e).Type);
}
else if(e is CodeArgumentReferenceExpression)
{
ValidateIdentifier
(((CodeArgumentReferenceExpression)e).ParameterName);
}
else if(e is CodeArrayIndexerExpression)
{
Validate(((CodeArrayIndexerExpression)e).TargetObject);
Validate(((CodeArrayIndexerExpression)e).Indices);
}
else if(e is CodeAssignStatement)
{
Validate(((CodeAssignStatement)e).Left);
Validate(((CodeAssignStatement)e).Right);
}
else if(e is CodeAttributeArgument)
{
ValidateIdentifier(((CodeAttributeArgument)e).Name);
Validate(((CodeAttributeArgument)e).Value);
}
else if(e is CodeAttributeDeclaration)
{
ValidateIdentifier(((CodeAttributeDeclaration)e).Name);
Validate(((CodeAttributeDeclaration)e).Arguments);
}
else if(e is CodeBinaryOperatorExpression)
{
Validate(((CodeBinaryOperatorExpression)e).Left);
Validate(((CodeBinaryOperatorExpression)e).Right);
}
else if(e is CodeCompileUnit)
{
Validate(((CodeCompileUnit)e).AssemblyCustomAttributes);
Validate(((CodeCompileUnit)e).Namespaces);
}
else if(e is CodeDelegateCreateExpression)
{
Validate(((CodeDelegateCreateExpression)e).DelegateType);
Validate(((CodeDelegateCreateExpression)e).TargetObject);
ValidateIdentifier
(((CodeDelegateCreateExpression)e).MethodName);
}
else if(e is CodeDelegateInvokeExpression)
{
Validate(((CodeDelegateInvokeExpression)e).TargetObject);
Validate(((CodeDelegateInvokeExpression)e).Parameters);
}
else if(e is CodeDirectionExpression)
{
Validate(((CodeDirectionExpression)e).Expression);
}
else if(e is CodeEventReferenceExpression)
{
Validate(((CodeEventReferenceExpression)e).TargetObject);
ValidateIdentifier
(((CodeEventReferenceExpression)e).EventName);
}
else if(e is CodeExpressionStatement)
{
Validate(((CodeExpressionStatement)e).Expression);
}
else if(e is CodeFieldReferenceExpression)
{
Validate(((CodeFieldReferenceExpression)e).TargetObject);
ValidateIdentifier
(((CodeFieldReferenceExpression)e).FieldName);
}
else if(e is CodeIndexerExpression)
{
Validate(((CodeIndexerExpression)e).TargetObject);
Validate(((CodeIndexerExpression)e).Indices);
}
else if(e is CodeIterationStatement)
{
Validate(((CodeIterationStatement)e).InitStatement);
Validate(((CodeIterationStatement)e).TestExpression);
Validate(((CodeIterationStatement)e).IncrementStatement);
Validate(((CodeIterationStatement)e).Statements);
}
else if(e is CodeLabeledStatement)
{
ValidateIdentifier(((CodeLabeledStatement)e).Label);
Validate(((CodeLabeledStatement)e).Statement);
}
else if(e is CodeMethodReferenceExpression)
{
Validate(((CodeMethodReferenceExpression)e).TargetObject);
ValidateIdentifier
(((CodeMethodReferenceExpression)e).MethodName);
}
else if(e is CodeMethodReturnStatement)
{
Validate(((CodeMethodReturnStatement)e).Expression);
}
else if(e is CodePropertyReferenceExpression)
{
Validate(((CodePropertyReferenceExpression)e).TargetObject);
ValidateIdentifier
(((CodePropertyReferenceExpression)e).PropertyName);
}
else if(e is CodeThrowExceptionStatement)
{
Validate(((CodeThrowExceptionStatement)e).ToThrow);
}
else if(e is CodeTryCatchFinallyStatement)
{
Validate(((CodeTryCatchFinallyStatement)e).TryStatements);
Validate(((CodeTryCatchFinallyStatement)e).CatchClauses);
Validate
(((CodeTryCatchFinallyStatement)e).FinallyStatements);
}
else if(e is CodeVariableReferenceExpression)
{
ValidateIdentifier
(((CodeVariableReferenceExpression)e).VariableName);
}
}
}; // class Validator
#endif // CONFIG_CODEDOM
}; // namespace System.CodeDom.Compiler
Index: CodeGenerator.cs
===================================================================
RCS file:
/cvsroot/dotgnu-pnet/pnetlib/System/CodeDom/Compiler/CodeGenerator.cs,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -r1.4 -r1.5
*** CodeGenerator.cs 29 May 2003 01:22:39 -0000 1.4
--- CodeGenerator.cs 21 Jul 2003 10:11:58 -0000 1.5
***************
*** 1300,1307 ****
// Validate all identifiers in a CodeDom tree.
- [TODO]
public static void ValidateIdentifiers(CodeObject e)
{
! // TODO
}
--- 1300,1306 ----
// Validate all identifiers in a CodeDom tree.
public static void ValidateIdentifiers(CodeObject e)
{
! Validator.Validate(e);
}
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Dotgnu-pnet-commits] CVS: pnetlib/System/CodeDom/Compiler Validator.cs, NONE, 1.1 CodeGenerator.cs, 1.4, 1.5,
Rhys Weatherley <address@hidden> <=