codegenerator.cs

来自「没的 没的 没的 没的 没的 没的 没的 没的 没的 没的 没的 没的 没的 没」· CS 代码 · 共 1,490 行 · 第 1/3 页

				else
				{
					throw new ArgumentException
						(S._("Arg_InvalidCodeDom"), "e");
				}
			}

	// Helper methods for line pragmas.
	private void LinePragmaStart(CodeLinePragma pragma)
			{
				if(pragma != null)
				{
					GenerateLinePragmaStart(pragma);
				}
			}
	private void LinePragmaEnd(CodeLinePragma pragma)
			{
				if(pragma != null)
				{
					GenerateLinePragmaEnd(pragma);
				}
			}

	// Generate code for namespace information.
	protected virtual void GenerateNamespace(CodeNamespace e)
			{
				GenerateCommentStatements(e.Comments);
				GenerateNamespaceStart(e);
				GenerateNamespaceImports(e);
				Output.WriteLine();
				GenerateTypes(e);
				GenerateNamespaceEnd(e);
			}
	protected void GenerateNamespaceImports(CodeNamespace e)
			{
				foreach(CodeNamespaceImport ns in e.Imports)
				{
					LinePragmaStart(ns.LinePragma);
					GenerateNamespaceImport(ns);
					LinePragmaEnd(ns.LinePragma);
				}
			}
	protected void GenerateNamespaces(CodeCompileUnit e)
			{
				foreach(CodeNamespace ns in e.Namespaces)
				{
					((ICodeGenerator)this).GenerateCodeFromNamespace
							(ns, writer.InnerWriter, Options);
				}
			}

	// Generate a parameter declaration expression.
	protected virtual void GenerateParameterDeclarationExpression
				(CodeParameterDeclarationExpression e)
			{
				if(e.CustomAttributes.Count != 0)
				{
					OutputAttributeDeclarations(e.CustomAttributes);
					Output.Write(" ");
				}
				OutputDirection(e.Direction);
				OutputTypeNamePair(e.Type, e.Name);
			}

	// Hex characters for encoding "char" constants.
	private static readonly String hexchars = "0123456789abcdef";

	// Generate code for a primitive expression.
	protected virtual void GeneratePrimitiveExpression
				(CodePrimitiveExpression e)
			{
				Object value = e.Value;
				if(value == null)
				{
					Output.Write(NullToken);
				}
				else if(value is String)
				{
					Output.Write(QuoteSnippetString((String)value));
				}
				else if(value is Char)
				{
					char ch = (char)value;
					String chvalue;
					switch(ch)
					{
						case '\'':	chvalue = "'\\''"; break;
						case '\\':	chvalue = "'\\\\'"; break;
						case '\n':	chvalue = "'\\n'"; break;
						case '\r':	chvalue = "'\\r'"; break;
						case '\t':	chvalue = "'\\t'"; break;
						case '\f':	chvalue = "'\\f'"; break;
						case '\v':	chvalue = "'\\v'"; break;
						case '\a':	chvalue = "'\\a'"; break;
						case '\b':	chvalue = "'\\b'"; break;
						default:
						{
							if(ch >= ' ' && ch <= 0x7E)
							{
								chvalue = "\"" + ch.ToString() + "\"";
							}
							else if(ch < 0x0100)
							{
								chvalue = "\"\\x" +
									hexchars[(ch >> 4) & 0x0F] +
									hexchars[ch & 0x0F] + "\"";
							}
							else
							{
								chvalue = "\"\\u" +
									hexchars[(ch >> 12) & 0x0F] +
									hexchars[(ch >> 8) & 0x0F] +
									hexchars[(ch >> 4) & 0x0F] +
									hexchars[ch & 0x0F] + "\"";
							}
						}
						break;
					}
					Output.Write(chvalue);
				}
				else if(value is SByte)
				{
					Output.Write((int)(sbyte)value);
				}
				else if(value is Byte)
				{
					Output.Write((int)(byte)value);
				}
				else if(value is Int16)
				{
					Output.Write((int)(short)value);
				}
				else if(value is UInt16)
				{
					Output.Write((int)(ushort)value);
				}
				else if(value is Int32)
				{
					Output.Write((int)value);
				}
				else if(value is UInt32)
				{
					Output.Write((uint)value);
				}
				else if(value is Int64)
				{
					Output.Write((long)value);
				}
				else if(value is UInt64)
				{
					Output.Write((ulong)value);
				}
				else if(value is Single)
				{
					GenerateSingleFloatValue((float)value);
				}
				else if(value is Double)
				{
					GenerateDoubleValue((double)value);
				}
				else if(value is Decimal)
				{
					GenerateDecimalValue((Decimal)value);
				}
				else if(value is Boolean)
				{
					if((bool)value)
					{
						Output.Write("true");
					}
					else
					{
						Output.Write("false");
					}
				}
				else
				{
					throw new ArgumentException
						(S._("Arg_InvalidCodeDom"), "e");
				}
			}

	// Generate a compile unit snippet.
	protected virtual void GenerateSnippetCompileUnit
				(CodeSnippetCompileUnit e)
			{
				LinePragmaStart(e.LinePragma);
				Output.WriteLine(e.Value);
				LinePragmaEnd(e.LinePragma);
			}

	// Generate a code statement snippet.
	protected virtual void GenerateSnippetStatement(CodeSnippetStatement e)
			{
				Output.WriteLine(e.Value);
			}

	// Generate code for a statement.
	protected void GenerateStatement(CodeStatement e)
			{
				LinePragmaStart(e.LinePragma);
				if(e is CodeAttachEventStatement)
				{
					GenerateAttachEventStatement
						((CodeAttachEventStatement)e);
				}
				else if(e is CodeCommentStatement)
				{
					GenerateCommentStatement
						((CodeCommentStatement)e);
				}
				else if(e is CodeConditionStatement)
				{
					GenerateConditionStatement
						((CodeConditionStatement)e);
				}
				else if(e is CodeRemoveEventStatement)
				{
					GenerateRemoveEventStatement
						((CodeRemoveEventStatement)e);
				}
				else if(e is CodeVariableDeclarationStatement)
				{
					GenerateVariableDeclarationStatement
						((CodeVariableDeclarationStatement)e);
				}
				else if(e is CodeAssignStatement)
				{
					GenerateAssignStatement
						((CodeAssignStatement)e);
				}
				else if(e is CodeExpressionStatement)
				{
					GenerateExpressionStatement
						((CodeExpressionStatement)e);
				}
				else if(e is CodeGotoStatement)
				{
					GenerateGotoStatement
						((CodeGotoStatement)e);
				}
				else if(e is CodeIterationStatement)
				{
					GenerateIterationStatement
						((CodeIterationStatement)e);
				}
				else if(e is CodeLabeledStatement)
				{
					GenerateLabeledStatement
						((CodeLabeledStatement)e);
				}
				else if(e is CodeMethodReturnStatement)
				{
					GenerateMethodReturnStatement
						((CodeMethodReturnStatement)e);
				}
				else if(e is CodeSnippetStatement)
				{
					GenerateSnippetStatement
						((CodeSnippetStatement)e);
				}
				else if(e is CodeThrowExceptionStatement)
				{
					GenerateThrowExceptionStatement
						((CodeThrowExceptionStatement)e);
				}
				else if(e is CodeTryCatchFinallyStatement)
				{
					GenerateTryCatchFinallyStatement
						((CodeTryCatchFinallyStatement)e);
				}
				else
				{
					throw new ArgumentException
						(S._("Arg_InvalidCodeDom"), "e");
				}
				LinePragmaEnd(e.LinePragma);
			}

	// Generate code for a statement collection.
	protected void GenerateStatements(CodeStatementCollection e)
			{
				if(e == null)
				{
					return;
				}
				foreach(CodeStatement stmt in e)
				{
					((ICodeGenerator)this).GenerateCodeFromStatement
							(stmt, writer.InnerWriter, Options);
				}
			}

	// Generate a typeof expression.
	protected virtual void GenerateTypeOfExpression
				(CodeTypeOfExpression e)
			{
				Output.Write("typeof(");
				OutputType(e.Type);
				Output.Write(")");
			}

	// Generate a type reference expression.
	protected virtual void GenerateTypeReferenceExpression
				(CodeTypeReferenceExpression e)
			{
				OutputType(e.Type);
			}

	// Generate various categories of type member.
	private void TypeMemberStart(CodeTypeMember member)
			{
				currentMember = member;
				if(options.BlankLinesBetweenMembers)
				{
					Output.WriteLine();
				}
				GenerateCommentStatements(member.Comments);
				LinePragmaStart(member.LinePragma);
			}
	private void TypeMemberEnd(CodeTypeMember member)
			{
				LinePragmaEnd(member.LinePragma);
				currentMember = null;
			}
	private void TypeFields(CodeTypeDeclaration e)
			{
				foreach(CodeTypeMember member in e.Members)
				{
					if(member is CodeMemberField)
					{
						TypeMemberStart(member);
						GenerateField((CodeMemberField)member);
						TypeMemberEnd(member);
					}
				}
			}
	private void TypeSnippets(CodeTypeDeclaration e)
			{
				foreach(CodeTypeMember member in e.Members)
				{
					if(member is CodeSnippetTypeMember)
					{
						TypeMemberStart(member);
						GenerateSnippetMember((CodeSnippetTypeMember)member);
						TypeMemberEnd(member);
					}
				}
			}
	private void TypeStaticConstructors(CodeTypeDeclaration e)
			{
				foreach(CodeTypeMember member in e.Members)
				{
					if(member is CodeTypeConstructor)
					{
						TypeMemberStart(member);
						GenerateTypeConstructor((CodeTypeConstructor)member);
						TypeMemberEnd(member);
					}
				}
			}
	private void TypeConstructors(CodeTypeDeclaration e)
			{
				foreach(CodeTypeMember member in e.Members)
				{
					if(member is CodeConstructor)
					{
						TypeMemberStart(member);
						GenerateConstructor((CodeConstructor)member, e);
						TypeMemberEnd(member);
					}
				}
			}
	private void TypeProperties(CodeTypeDeclaration e)
			{
				foreach(CodeTypeMember member in e.Members)
				{
					if(member is CodeMemberProperty)
					{
						TypeMemberStart(member);
						GenerateProperty((CodeMemberProperty)member, e);
						TypeMemberEnd(member);
					}
				}
			}
	private void TypeEvents(CodeTypeDeclaration e)
			{
				foreach(CodeTypeMember member in e.Members)
				{
					if(member is CodeMemberEvent)
					{
						TypeMemberStart(member);
						GenerateEvent((CodeMemberEvent)member, e);
						TypeMemberEnd(member);
					}
				}
			}
	private void TypeMethods(CodeTypeDeclaration e)
			{
				foreach(CodeTypeMember member in e.Members)
				{
					if(member is CodeMemberMethod &&
					   !(member is CodeConstructor) &&
					   !(member is CodeTypeConstructor))
					{
						TypeMemberStart(member);
						GenerateMethod((CodeMemberMethod)member, e);
						TypeMemberEnd(member);
					}
				}
			}
	private void TypeNestedTypes(CodeTypeDeclaration e)
			{
				foreach(CodeTypeMember member in e.Members)
				{
					if(member is CodeTypeDeclaration)
					{
						if(options.BlankLinesBetweenMembers)
						{
							Output.WriteLine();
						}
						((ICodeGenerator)this).GenerateCodeFromType
								((CodeTypeDeclaration)member,
								 writer.InnerWriter, Options);
					}
				}
				currentType = e;
			}

	// Generate a particular type declaration.
	private void GenerateType(CodeTypeDeclaration e)
			{
				currentType = e;
				GenerateCommentStatements(e.Comments);
				GenerateTypeStart(e);
				TypeFields(e);
				TypeSnippets(e);
				TypeStaticConstructors(e);
				TypeConstructors(e);
				TypeProperties(e);
				TypeEvents(e);
				TypeMethods(e);
				TypeNestedTypes(e);
				GenerateTypeEnd(e);
				currentType = null;
			}

	// Generate the types in a namespace.
	protected void GenerateTypes(CodeNamespace e)
			{
				foreach(CodeTypeDeclaration type in e.Types)
				{
					if(options.BlankLinesBetweenMembers)
					{
						Output.WriteLine();
					}
					((ICodeGenerator)this).GenerateCodeFromType
							(type, writer.InnerWriter, Options);
				}
			}

	// Determine if "value" is a valid identifier.
	protected abstract bool IsValidIdentifier(String value);

	// Output an attribute argument.
	protected virtual void OutputAttributeArgument
				(CodeAttributeArgument arg)
			{
				if(arg.Name != null)
				{
					OutputIdentifier(arg.Name);
					Output.Write("=");
				}
				((ICodeGenerator)this).GenerateCodeFromExpression
						(arg.Value, writer.InnerWriter, Options);
			}

	// Output attribute declarations.
	protected virtual void OutputAttributeDeclarations
				(CodeAttributeDeclarationCollection attributes)
			{
				OutputAttributeDeclarations(null, attributes);
			}
	internal void OutputAttributeDeclarations
				(String prefix, CodeAttributeDeclarationCollection attributes)
			{
				if(attributes.Count == 0)
				{
					return;
				}
				bool first = true;
				bool first2;
				CodeAttributeArgumentCollection args;
				GenerateAttributeDeclarationsStart(attributes);
				foreach(CodeAttributeDeclaration attr in attributes)
				{
					if(!first)