private static void ProcessStmt(IEnumerable stmts, LinqToCodedom.CodeDomGenerator.Language language)
{
foreach (CodeStatement stmt in stmts)
{
ProcessStmt(stmt, language);
}
}
private static void ProcessExpr(IEnumerable codeExpressions, LinqToCodedom.CodeDomGenerator.Language language)
{
foreach (CodeExpression exp in codeExpressions)
{
ProcessExpr(exp, language);
}
}
public IEnumerable <System.CodeDom.CodeCompileUnit> CreateCompileUnits(WXMLModel model)
{
WXMLCodeDomGeneratorSettings settings = new WXML.CodeDom.WXMLCodeDomGeneratorSettings();
CodeCompileUnit modificationTracketUnit = GenerateModificationTracker(model, settings);
LinqCodeDomGenerator gen = new LinqCodeDomGenerator(model, settings);
LinqToCodedom.CodeDomGenerator.Language lang = LinqToCodedom.CodeDomGenerator.Language.CSharp;
return(new CodeCompileUnit[] { gen.GetCompileUnit(lang), modificationTracketUnit });
}
private static CodeTypeMember ProcessMember(CodeTypeMember m, LinqToCodedom.CodeDomGenerator.Language language)
{
foreach (CodeDirective directive in m.StartDirectives)
{
ProcessDirective(directive, language);
}
foreach (CodeDirective directive in m.EndDirectives)
{
ProcessDirective(directive, language);
}
if (typeof(CodeMemberMethod).IsAssignableFrom(m.GetType()))
{
foreach (CodeStatement stmt in ((CodeMemberMethod)m).Statements)
{
ProcessStmt(stmt, language);
}
}
else if (typeof(CodeMemberProperty).IsAssignableFrom(m.GetType()))
{
foreach (CodeStatement stmt in ((CodeMemberProperty)m).GetStatements)
{
ProcessStmt(stmt, language);
}
foreach (CodeStatement stmt in ((CodeMemberProperty)m).SetStatements)
{
ProcessStmt(stmt, language);
}
}
else if (typeof(CodeConstructor).IsAssignableFrom(m.GetType()))
{
ProcessExpr(((CodeConstructor)m).BaseConstructorArgs, language);
ProcessExpr(((CodeConstructor)m).ChainedConstructorArgs, language);
ProcessStmt(((CodeConstructor)m).Statements, language);
}
else if (typeof(CodeMemberField).IsAssignableFrom(m.GetType()))
{
ProcessExpr(((CodeMemberField)m).InitExpression, language);
}
else if (typeof(CodeTypeDeclaration).IsAssignableFrom(m.GetType()))
{
CodeTypeDeclaration td = (CodeTypeDeclaration)m;
ProcessTypeDeclaration(td, language);
foreach (CodeTypeMember ms in td.Members)
{
ProcessMember(ms, language);
}
}
ICustomCodeDomObject co = m as ICustomCodeDomObject;
if (co != null)
{
co.GenerateCode(language);
}
if (typeof(CodeMemberMethod).IsAssignableFrom(m.GetType()))
{
return(ProcessMethod(m as CodeMemberMethod, language));
}
return(m);
}
private static CodeMemberMethod ProcessMethod(CodeMemberMethod method, LinqToCodedom.CodeDomGenerator.Language language)
{
if (method.TypeParameters.Count > 0)
{
foreach (CodeTypeParameter genericParam in method.TypeParameters)
{
for (int i = 0; i < genericParam.Constraints.Count; i++)
{
if (genericParam.Constraints[i].BaseType == typeof(object).ToString())
{
if (language == LinqToCodedom.CodeDomGenerator.Language.CSharp)
{
genericParam.Constraints[i] = new CodeTypeReference(" class");
}
else if (language == LinqToCodedom.CodeDomGenerator.Language.VB)
{
genericParam.Constraints[i] = new CodeTypeReference(" Class");
}
}
else if (genericParam.Constraints[i].BaseType == typeof(ValueType).ToString())
{
if (language == LinqToCodedom.CodeDomGenerator.Language.CSharp)
{
genericParam.Constraints[i] = new CodeTypeReference(" struct");
}
else if (language == LinqToCodedom.CodeDomGenerator.Language.VB)
{
genericParam.Constraints[i] = new CodeTypeReference(" Structure");
}
}
}
}
}
if (language == LinqToCodedom.CodeDomGenerator.Language.VB)
{
if (method.PrivateImplementationType != null)
{
CodeMemberMethod newMethod = method.Clone() as CodeMemberMethod;
newMethod.ImplementationTypes.Add(method.PrivateImplementationType);
newMethod.PrivateImplementationType = null;
return(newMethod);
}
}
//object o = method.UserData["linq2codedom:partial"];
//if (o != null)
//{
// bool partial = (bool)o;
//if (partial)
//{
// string typeStr = null;
// switch (language)
// {
// case CodeDomGenerator.Language.CSharp:
// using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
// {
// System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
// using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
// {
// provider.(method.ReturnType, tw, opts);
// typeStr = tw.InnerWriter.ToString();
// }
// }
// break;
// case CodeDomGenerator.Language.VB:
// using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
// {
// System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
// using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
// {
// tw.Write("(");
// provider.GenerateCodeFromExpression(Left, tw, opts);
// tw.Write(" Xor ");
// provider.GenerateCodeFromExpression(Right, tw, opts);
// tw.Write(")");
// Value = tw.InnerWriter.ToString();
// }
// }
// break;
// default:
// throw new NotImplementedException(language.ToString());
// }
//}
//}
return(method);
}
private static void ProcessStmt(CodeStatement stmt, LinqToCodedom.CodeDomGenerator.Language language)
{
if (stmt == null)
{
return;
}
foreach (CodeDirective directive in stmt.StartDirectives)
{
ProcessDirective(directive, language);
}
foreach (CodeDirective directive in stmt.EndDirectives)
{
ProcessDirective(directive, language);
}
if (typeof(CodeAssignStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessExpr(((CodeAssignStatement)stmt).Left, language);
ProcessExpr(((CodeAssignStatement)stmt).Right, language);
}
else if (typeof(CodeAttachEventStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessExpr(((CodeAttachEventStatement)stmt).Listener, language);
}
else if (typeof(CodeCommentStatement).IsAssignableFrom(stmt.GetType()))
{
}
else if (typeof(CodeConditionStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessExpr(((CodeConditionStatement)stmt).Condition, language);
ProcessStmt(((CodeConditionStatement)stmt).TrueStatements, language);
ProcessStmt(((CodeConditionStatement)stmt).FalseStatements, language);
}
else if (typeof(CodeExpressionStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessExpr(((CodeExpressionStatement)stmt).Expression, language);
}
else if (typeof(CodeGotoStatement).IsAssignableFrom(stmt.GetType()))
{
}
else if (typeof(CodeIterationStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessStmt(((CodeIterationStatement)stmt).IncrementStatement, language);
ProcessStmt(((CodeIterationStatement)stmt).InitStatement, language);
ProcessStmt(((CodeIterationStatement)stmt).Statements, language);
ProcessExpr(((CodeIterationStatement)stmt).TestExpression, language);
}
else if (typeof(CodeLabeledStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessStmt(((CodeLabeledStatement)stmt).Statement, language);
}
else if (typeof(CodeMethodReturnStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessExpr(((CodeMethodReturnStatement)stmt).Expression, language);
}
else if (typeof(CodeRemoveEventStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessExpr(((CodeRemoveEventStatement)stmt).Listener, language);
}
else if (typeof(CodeThrowExceptionStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessExpr(((CodeThrowExceptionStatement)stmt).ToThrow, language);
}
else if (typeof(CodeTryCatchFinallyStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessStmt(((CodeTryCatchFinallyStatement)stmt).FinallyStatements, language);
ProcessStmt(((CodeTryCatchFinallyStatement)stmt).TryStatements, language);
foreach (CodeCatchClause c in ((CodeTryCatchFinallyStatement)stmt).CatchClauses)
{
ProcessStmt(c.Statements, language);
}
}
else if (typeof(CodeVariableDeclarationStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessExpr(((CodeVariableDeclarationStatement)stmt).InitExpression, language);
}
else if (typeof(CodeUsingStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessStmt(((CodeUsingStatement)stmt).Statements, language);
ProcessExpr(((CodeUsingStatement)stmt).UsingExpression, language);
}
else if (typeof(CodeForeachStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessStmt(((CodeForeachStatement)stmt).Statements, language);
ProcessExpr(((CodeForeachStatement)stmt).IterExpression, language);
}
else if (typeof(CodeDoStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessStmt(((CodeDoStatement)stmt).Statements, language);
ProcessExpr(((CodeDoStatement)stmt).TestExpression, language);
}
else if (typeof(CodeWhileStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessStmt(((CodeWhileStatement)stmt).Statements, language);
ProcessExpr(((CodeWhileStatement)stmt).TestExpression, language);
}
else if (typeof(CodeSwitchStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessExpr(((CodeSwitchStatement)stmt).SwitchExpression, language);
foreach (CodeSwitchStatement.CaseBlock cb in ((CodeSwitchStatement)stmt).Cases)
{
ProcessExpr(cb.CaseExpression, language);
ProcessStmt(cb.Statements, language);
}
}
else if (typeof(CodeLockStatement).IsAssignableFrom(stmt.GetType()))
{
ProcessExpr(((CodeLockStatement)stmt).LockExpression, language);
ProcessStmt(((CodeLockStatement)stmt).Statements, language);
}
ICustomCodeDomObject co = stmt as ICustomCodeDomObject;
if (co != null)
{
co.GenerateCode(language);
}
}
internal static CodeTypeMember ProcessMember(CodeTypeMember m, LinqToCodedom.CodeDomGenerator.Language language)
{
foreach (CodeDirective directive in m.StartDirectives)
{
ProcessDirective(directive, language);
}
foreach (CodeDirective directive in m.EndDirectives)
{
ProcessDirective(directive, language);
}
if (typeof(CodeMemberMethod).IsAssignableFrom(m.GetType()))
{
foreach (CodeStatement stmt in ((CodeMemberMethod)m).Statements)
{
ProcessStmt(stmt, language);
}
}
else if (typeof(CodeMemberProperty).IsAssignableFrom(m.GetType()))
{
foreach (CodeStatement stmt in ((CodeMemberProperty)m).GetStatements)
{
ProcessStmt(stmt, language);
}
foreach (CodeStatement stmt in ((CodeMemberProperty)m).SetStatements)
{
ProcessStmt(stmt, language);
}
}
else if (typeof(CodeConstructor).IsAssignableFrom(m.GetType()))
{
ProcessExpr(((CodeConstructor)m).BaseConstructorArgs, language);
ProcessExpr(((CodeConstructor)m).ChainedConstructorArgs, language);
ProcessStmt(((CodeConstructor)m).Statements, language);
}
else if (typeof(CodeMemberField).IsAssignableFrom(m.GetType()))
{
ProcessExpr(((CodeMemberField)m).InitExpression, language);
}
else if (typeof(CodeTypeDeclaration).IsAssignableFrom(m.GetType()))
{
CodeTypeDeclaration td = (CodeTypeDeclaration)m;
ProcessTypeDeclaration(td, language);
foreach (CodeTypeMember ms in td.Members)
{
ProcessMember(ms, language);
}
}
else if (typeof(CodeDefaultProperty).IsAssignableFrom(m.GetType()))
{
ProcessMember((m as CodeDefaultProperty).Property, language);
foreach (CodeExpression p in (m as CodeDefaultProperty).Parameters)
{
ProcessExpr(p, language);
}
}
else if (typeof(CodeReadOnlyField).IsAssignableFrom(m.GetType()))
{
ProcessMember((m as CodeReadOnlyField).Field, language);
}
else if (typeof(CodePropertyImplementsInterface).IsAssignableFrom(m.GetType()))
{
ProcessMember((m as CodePropertyImplementsInterface).Property, language);
}
else if (typeof(CodePartialMethod).IsAssignableFrom(m.GetType()))
{
ProcessMember((m as CodePartialMethod).Method, language);
}
else if (typeof(CodeMemberOperatorOverride).IsAssignableFrom(m.GetType()))
{
foreach (CodeExpression p in (m as CodeMemberOperatorOverride).Parameters)
{
ProcessExpr(p, language);
}
}
else if (typeof(CodeCustomEvent).IsAssignableFrom(m.GetType()))
{
var ce = m as CodeCustomEvent;
ProcessMember(ce.Event, language);
ProcessMember(ce.AddMethod, language);
ProcessMember(ce.RemoveMethod, language);
ProcessMember(ce.RaiseMethod, language);
}
ICustomCodeDomObject co = m as ICustomCodeDomObject;
if (co != null)
{
co.GenerateCode(language);
}
if (typeof(CodeMemberMethod).IsAssignableFrom(m.GetType()))
{
return(ProcessMethod(m as CodeMemberMethod, language));
}
return(m);
}
