vbnetvisitor.cs

c#源代码

			                     checkedExpression.Expression.AcceptVisitor(this, data));
		}
		
		public override object Visit(UncheckedExpression uncheckedExpression, object data)
		{
			return String.Concat("'Unhecked expression (can't convert):",
			                     uncheckedExpression.Expression.AcceptVisitor(this, data));
		}
		
		public override object Visit(PointerReferenceExpression pointerReferenceExpression, object data)
		{
			errors.Error(-1, -1, String.Format("pointer reference (->) not suported by VB.NET"));
			return String.Empty;
		}
		
		public override object Visit(CastExpression castExpression, object data)
		{
			DebugOutput(castExpression);
			return String.Format("CType({0}, {1})",
			                     castExpression.Expression.AcceptVisitor(this, data).ToString(),
			                     GetTypeString(castExpression.CastTo));
		}
		
		public override object Visit(StackAllocExpression stackAllocExpression, object data)
		{
			errors.Error(-1, -1, String.Format("stack alloc expression not suported by VB.NET"));
			return String.Empty;
		}
		
		public override object Visit(IndexerExpression indexerExpression, object data)
		{
			DebugOutput(indexerExpression);
			return String.Concat(indexerExpression.TargetObject.AcceptVisitor(this, data),
			                     GetParameters(indexerExpression.Indices));
		}
		
		public override object Visit(ThisReferenceExpression thisReferenceExpression, object data)
		{
			DebugOutput(thisReferenceExpression);
			return "Me";
		}
		
		public override object Visit(BaseReferenceExpression baseReferenceExpression, object data)
		{
			DebugOutput(baseReferenceExpression);
			return "MyBase";
		}
		
		public override object Visit(ObjectCreateExpression objectCreateExpression, object data)
		{
			DebugOutput(objectCreateExpression);
			if (IsEventHandlerCreation(objectCreateExpression)) {
				Expression expr = (Expression)objectCreateExpression.Parameters[0];
				string handler;
				if (expr is FieldReferenceExpression) {
					handler = ((FieldReferenceExpression)expr).FieldName;
				} else {
					handler = expr.AcceptVisitor(this, data).ToString();
				}
				return String.Format("AddressOf {0}", handler);
			}
			return String.Format("New {0}{1}",
			                     GetTypeString(objectCreateExpression.CreateType),
			                     GetParameters(objectCreateExpression.Parameters)
			                     );
		}
		
		public override object Visit(ArrayCreateExpression ace, object data)
		{
			DebugOutput(ace);
			string arrayInitializer = String.Empty;
			string arrayParameters  = String.Empty;
			
			arrayInitializer += "{";
			if (ace.ArrayInitializer != null && ace.ArrayInitializer.CreateExpressions != null) {
				arrayInitializer += GetExpressionList(ace.ArrayInitializer.CreateExpressions);
			}
			arrayInitializer += "}";
			
			if (ace.Parameters != null && ace.Parameters.Count > 0) {
				foreach (ArrayCreationParameter param in ace.Parameters) {
					// TODO: multidimensional arrays ?
					arrayParameters += String.Concat("(",
				    	                             GetExpressionList(param.Expressions),
				                           			 ")");
				}
			} else {
				arrayParameters = "()";
			}
			
			return String.Format("New {0}{1} {2}",
			                     GetTypeString(ace.CreateType),
			                     arrayParameters,
			                     arrayInitializer
			                     );
		}
		
		public override object Visit(ParameterDeclarationExpression parameterDeclarationExpression, object data)
		{
			// should never be called:
			throw new System.NotImplementedException();
		}
		
		public override object Visit(FieldReferenceExpression fieldReferenceExpression, object data)
		{
			DebugOutput(fieldReferenceExpression);
			if (fieldReferenceExpression.TargetObject is ObjectCreateExpression) {
				return String.Concat("(",
				                     fieldReferenceExpression.TargetObject.AcceptVisitor(this, data),
				                     ").",
				                     fieldReferenceExpression.FieldName);
			}
			return String.Concat(fieldReferenceExpression.TargetObject.AcceptVisitor(this, data),
			                     ".",
			                     fieldReferenceExpression.FieldName);
		}
		
		public override object Visit(DirectionExpression directionExpression, object data)
		{
			DebugOutput(directionExpression);
			string fieldDirection = String.Empty;
			// TODO: is this correct that there is nothing in a VB.NET method call for out & ref ?
//			switch (directionExpression.FieldDirection) {
//				case FieldDirection.Out:
//					break;
//				case FieldDirection.Ref:
//					break;
//			}
			return String.Concat(fieldDirection, directionExpression.Expression.AcceptVisitor(this, data));
		}
		
		public override object Visit(ArrayInitializerExpression arrayInitializerExpression, object data)
		{
			return String.Concat(" {",
			                     GetExpressionList(arrayInitializerExpression.CreateExpressions),
			                     "}");
		}
		
		public override object Visit(ConditionalExpression conditionalExpression, object data)
		{
			return String.Concat("Microsoft.VisualBasic.IIf(",
				conditionalExpression.TestCondition.AcceptVisitor(this, data),
				",",
				conditionalExpression.TrueExpression.AcceptVisitor(this, data),
				",",
				conditionalExpression.FalseExpression.AcceptVisitor(this, data),
				")");
		}
#endregion

		string ConvertTypeString(string typeString)
		{
			switch (typeString) {
				case "bool":
					return "Boolean";
				case "string":
					return "String";
				case "char":
					return "Char";
				case "double":
					return "Double";
				case "float":
					return "Single";
				case "decimal":
					return "Decimal";
				case "System.DateTime":
					return "Date";
				case "long":
					return "Long";
				case "int":
					return "Integer";
				case "short":
					return "Short";
				case "byte":
					return "Byte";
				case "void":
					return "Void";
				case "object":
					return "Object";
				case "ulong":
					return "System.UInt64";
				case "uint":
					return "System.UInt32";
				case "ushort":
					return "System.UInt16";
			}
			return typeString;
		}

		string GetTypeString(TypeReference typeRef)
		{
			if (typeRef == null) {
				errors.Error(-1, -1, String.Format("Got empty type string (internal error, check generated source code for empty types"));
				return String.Empty;
			}
			
			string typeStr = ConvertTypeString(typeRef.Type);
		
			StringBuilder arrays = new StringBuilder();
			if (typeRef.RankSpecifier != null) {
				for (int i = 0; i < typeRef.RankSpecifier.Length; ++i) {
					arrays.Append("(");
					for (int j = 1; j < typeRef.RankSpecifier[i]; ++j) {
						arrays.Append(",");
					}
					arrays.Append(")");
				}
			}
			
			if (typeRef.PointerNestingLevel > 0) {
				errors.Error(-1, -1, String.Format("Pointer types are not suported by VB.NET"));
			}
			
			return typeStr + arrays.ToString();
		}
		
		string GetModifier(Modifier modifier)
		{
			StringBuilder builder = new StringBuilder();
			
			if ((modifier & Modifier.Public) == Modifier.Public) {
				builder.Append("Public ");
			} else if ((modifier & Modifier.Private) == Modifier.Private) {
				builder.Append("Private ");
			} else if ((modifier & (Modifier.Protected | Modifier.Internal)) == (Modifier.Protected | Modifier.Internal)) {
				builder.Append("Protected Friend ");
			} else if ((modifier & Modifier.Internal) == Modifier.Internal) {
				builder.Append("Friend ");
			} else if ((modifier & Modifier.Protected) == Modifier.Protected) {
				builder.Append("Protected ");
			}
			
			if ((modifier & Modifier.Static) == Modifier.Static) {
				builder.Append("Shared ");
			}
			if ((modifier & Modifier.Virtual) == Modifier.Virtual) {
				builder.Append("Overridable ");
			}
			if ((modifier & Modifier.Abstract) == Modifier.Abstract) {
				builder.Append("MustOverride ");
			}
			if ((modifier & Modifier.Override) == Modifier.Override) {
				builder.Append("Overloads Overrides ");
			}
			if ((modifier & Modifier.New) == Modifier.New) {
				builder.Append("Shadows ");
			}
			
			if ((modifier & Modifier.Sealed) == Modifier.Sealed) {
				builder.Append("NotInheritable ");
			}
			
			if ((modifier & Modifier.Readonly) == Modifier.Readonly) {
				builder.Append("ReadOnly ");
			}
			if ((modifier & Modifier.Const) == Modifier.Const) {
				builder.Append("Const ");
			}
			
			// TODO : Extern 
			if ((modifier & Modifier.Extern) == Modifier.Extern) {
				errors.Error(-1, -1, String.Format("'Extern' modifier not convertable"));
			}
			// TODO : Volatile 
			if ((modifier & Modifier.Volatile) == Modifier.Volatile) {
				errors.Error(-1, -1, String.Format("'Volatile' modifier not convertable"));
			}
			// TODO : Unsafe 
			if ((modifier & Modifier.Unsafe) == Modifier.Unsafe) {
				errors.Error(-1, -1, String.Format("'Unsafe' modifier not convertable"));
			}
			return builder.ToString();
		}
		
		string GetParameters(ArrayList list)
		{
			if (list == null || list.Count == 0) {
				return String.Empty;
			}
			return String.Concat("(",
			                     GetExpressionList(list),
			                     ")");
		}
		
		string GetExpressionList(ArrayList list)
		{
			StringBuilder sb = new StringBuilder();
			if (list != null) {
				for (int i = 0; i < list.Count; ++i) {
					Expression exp = (Expression)list[i];
					sb.Append(exp.AcceptVisitor(this, null));
					if (i + 1 < list.Count) {
						sb.Append(", ");
					}
				}
			}
			return sb.ToString();
		}

		public void AppendParameters(ArrayList parameters)
		{
			if (parameters == null) {
				return;
			}
			for (int i = 0; i < parameters.Count; ++i) {
				ParameterDeclarationExpression pde = (ParameterDeclarationExpression)parameters[i];
				AppendAttributes(pde.Attributes);
				if ((pde.ParamModifiers & ParamModifiers.Ref) == ParamModifiers.Ref) {
					sourceText.Append("ByRef ");
				} else if ((pde.ParamModifiers & ParamModifiers.Out) == ParamModifiers.Out) {
					// TODO : is ByRef correct for out parameters ?
					sourceText.Append("ByRef ");
				} else {
					sourceText.Append("ByVal ");
				}
				if ((pde.ParamModifiers & ParamModifiers.Params) == ParamModifiers.Params) {
					sourceText.Append("ParamArray ");
				}
				sourceText.Append(pde.ParameterName);
				sourceText.Append(" As ");
				sourceText.Append(GetTypeString(pde.TypeReference));
				if (i + 1 < parameters.Count) {
					sourceText.Append(", ");
				}
			}
		}

		public void AppendAttributes(ArrayList attr)
		{
			if (attr != null) {
				foreach (AttributeSection section in attr) {
					section.AcceptVisitor(this, null);
				}
			}
		}
		
		InvocationExpression GetEventHandlerRaise(IfStatement ifStatement)
		{
			BinaryOperatorExpression op = ifStatement.Condition as BinaryOperatorExpression;
			if (op != null && op.Op == BinaryOperatorType.InEquality) {
				if (op.Left is IdentifierExpression && op.Right is PrimitiveExpression && ((PrimitiveExpression)op.Right).Value == null) {
					string identifier = ((IdentifierExpression)op.Left).Identifier;
					StatementExpression se = null;
					if (ifStatement.EmbeddedStatement is StatementExpression) {
						se = (StatementExpression)ifStatement.EmbeddedStatement;
					} else if (ifStatement.EmbeddedStatement.Children.Count == 1) {
						se = ifStatement.EmbeddedStatement.Children[0] as StatementExpression;
					}
					if (se != null) {
						InvocationExpression ie = se.Expression as InvocationExpression;
						if (ie != null) {
							Expression ex = ie.TargetObject;
							string methodName = null;
							if (ex is IdentifierExpression) {
								methodName = ((IdentifierExpression)ex).Identifier;
							} else if (ex is FieldReferenceExpression) {
								FieldReferenceExpression fre = (FieldReferenceExpression)ex;
								if (fre.TargetObject is ThisReferenceExpression) {
									methodName = fre.FieldName;
								}
							}
							if (methodName != null && methodName == identifier) {
								foreach (object o in this.currentType.Children) {
									EventDeclaration ed = o as EventDeclaration;
									if (ed != null) {
										if (ed.Name == methodName) {
											return ie;
										}
										if (ed.VariableDeclarators != null) {
										foreach (VariableDeclaration field in ed.VariableDeclarators) {
											if (field.Name == methodName) {
												return ie;
											}
										}
										}
									}
								}
							}
						}
					}
				}
			}
			return null;
		}
		
		bool IsEventHandlerCreation(Expression expr)
		{
			if (expr is ObjectCreateExpression) {
				ObjectCreateExpression oce = (ObjectCreateExpression) expr;
				if (oce.Parameters.Count == 1) {
					expr = (Expression)oce.Parameters[0];
					string methodName = null;
					if (expr is IdentifierExpression) {
						methodName = ((IdentifierExpression)expr).Identifier;
					} else if (expr is FieldReferenceExpression) {
						methodName = ((FieldReferenceExpression)expr).FieldName;
					}
					if (methodName != null) {
						foreach (object o in this.currentType.Children) {
							if (o is MethodDeclaration && ((MethodDeclaration)o).Name == methodName) {
								return true;
							}
						}
					}
					
				}
			}
			
			return false;
		}

		bool TypeHasOnlyStaticMembers(TypeDeclaration typeDeclaration)
		{
			foreach (object o in typeDeclaration.Children) {
				if (o is MethodDeclaration) {
					if ((((MethodDeclaration)o).Modifier & Modifier.Static) != Modifier.Static) {
						return false;
					}
				} else if (o is PropertyDeclaration) {
					if ((((PropertyDeclaration)o).Modifier & Modifier.Static) != Modifier.Static) {
						return false;
					}
				} else if (o is FieldDeclaration) {
					if ((((FieldDeclaration)o).Modifier & Modifier.Static) != Modifier.Static) {
						return false;
					}
				}else if (o is EventDeclaration) {
					if ((((EventDeclaration)o).Modifier & Modifier.Static) != Modifier.Static) {
						return false;
					}
				}
			}
			return true;
		}
		
	
	}
}