// Generate a codedom exception handler statement
public static CodeStatement Emit(ExceptionHandler ex)
{
// Create the codedom exception handler statement
var codeTry = new CodeTryCatchFinallyStatement();
// Add the statements in the try block
foreach (var e in ex.Try.ChildExpressions)
codeTry.TryStatements.Add(CodeDomEmitter.EmitCodeStatement(e));
// Add all the catch clauses.
foreach (var c in ex.CatchClauses)
{
// Create the codedom catch statement.
var catchClause = new CodeCatchClause();
// To do: replace with non-test code
catchClause.CatchExceptionType = new CodeTypeReference("System.Exception");
catchClause.LocalName = "ex";
codeTry.CatchClauses.Add(catchClause);
// Add the statemnts in the catch block
foreach(var e in c.ChildExpressions)
catchClause.Statements.Add(CodeDomEmitter.EmitCodeStatement(e));
}
// Add the statements in the finally block.
foreach (var e in ex.Finally.ChildExpressions)
codeTry.FinallyStatements.Add(CodeDomEmitter.EmitCodeStatement(e));
return codeTry;
}
public void Constructor0 ()
{
CodeCatchClause ccc = new CodeCatchClause ();
Assert.IsNotNull (ccc.CatchExceptionType, "#1");
Assert.AreEqual (typeof(Exception).FullName, ccc.CatchExceptionType.BaseType, "#2");
Assert.IsNotNull (ccc.LocalName, "#3");
Assert.AreEqual (string.Empty, ccc.LocalName, "#4");
Assert.IsNotNull (ccc.Statements, "#5");
Assert.AreEqual (0, ccc.Statements.Count, "#6");
ccc.LocalName = null;
Assert.IsNotNull (ccc.LocalName, "#7");
Assert.AreEqual (string.Empty, ccc.LocalName, "#8");
string localName = "mono";
ccc.LocalName = localName;
Assert.AreSame (localName, ccc.LocalName, "#9");
ccc.CatchExceptionType = null;
Assert.IsNotNull (ccc.CatchExceptionType, "#10");
Assert.AreEqual (typeof(Exception).FullName, ccc.CatchExceptionType.BaseType, "#11");
CodeTypeReference cet = new CodeTypeReference("SomeException");
ccc.CatchExceptionType = cet;
Assert.AreSame (cet, ccc.CatchExceptionType, "#12");
}
public CodeTryCatchFinallyStatement (CodeStatement [] tryStatements,
CodeCatchClause [] catchClauses,
CodeStatement [] finallyStatements)
{
TryStatements.AddRange( tryStatements );
CatchClauses.AddRange( catchClauses );
FinallyStatements.AddRange( finallyStatements );
}
public CodeTryCatchFinallyStatement(CodeStatement[] tryStatements, CodeCatchClause[] catchClauses)
{
this.tryStatments = new CodeStatementCollection();
this.finallyStatments = new CodeStatementCollection();
this.catchClauses = new CodeCatchClauseCollection();
this.TryStatements.AddRange(tryStatements);
this.CatchClauses.AddRange(catchClauses);
}
/// <devdoc>
/// <para>Copies the elements of an array to the end of the <see cref='System.CodeDom.CodeCatchClauseCollection'/>.</para>
/// </devdoc>
public void AddRange(CodeCatchClause[] value) {
if (value == null) {
throw new ArgumentNullException("value");
}
for (int i = 0; ((i) < (value.Length)); i = ((i) + (1))) {
this.Add(value[i]);
}
}
public void Constructor1_NullItem ()
{
CodeCatchClause[] catchClauses = new CodeCatchClause[] {
new CodeCatchClause (), null };
CodeCatchClauseCollection coll = new CodeCatchClauseCollection (
catchClauses);
}
public void Constructor1_Deny_Unrestricted ()
{
CodeCatchClause ccc = new CodeCatchClause ("mono");
Assert.AreEqual ("System.Exception", ccc.CatchExceptionType.BaseType, "CatchExceptionType.BaseType");
ccc.CatchExceptionType = new CodeTypeReference ("System.Void");
Assert.AreEqual ("mono", ccc.LocalName, "LocalName");
ccc.LocalName = String.Empty;
Assert.AreEqual (0, ccc.Statements.Count, "Statements");
}
public static CodeCatchClause Clone(this CodeCatchClause clause)
{
if (clause == null) return null;
CodeCatchClause c = new CodeCatchClause();
c.CatchExceptionType = clause.CatchExceptionType.Clone();
c.LocalName = clause.LocalName;
c.Statements.AddRange(clause.Statements.Clone());
return c;
}
public void Constructor1_Deny_Unrestricted ()
{
CodeStatement[] try_statements = new CodeStatement[1] { new CodeStatement () };
CodeCatchClause[] catch_clauses = new CodeCatchClause[1] { new CodeCatchClause () };
CodeTryCatchFinallyStatement ctcfs = new CodeTryCatchFinallyStatement (try_statements, catch_clauses);
Assert.AreEqual (1, ctcfs.CatchClauses.Count, "CatchClauses");
Assert.AreEqual (0, ctcfs.FinallyStatements.Count, "FinallyStatements");
Assert.AreEqual (1, ctcfs.TryStatements.Count, "TryStatements");
}
private static CodeCatchClause Catch(System.Type type, string name, CodeStatement catchStmnt)
{
CodeCatchClause clause = new CodeCatchClause {
CatchExceptionType = Type(type),
LocalName = name
};
clause.Statements.Add(catchStmnt);
return clause;
}
public void AddRange (CodeCatchClause [] value)
{
if (value == null) {
throw new ArgumentNullException ("value");
}
for (int i = 0; i < value.Length; i++) {
Add (value[i]);
}
}
public CodeDomStatments PushCatch(string localName)
{
Pop();
var SS = _Data.Peek();
var S = SS[SS.Count - 1] as CodeTryCatchFinallyStatement;
var c = new CodeCatchClause(localName);
S.CatchClauses.Add(c);
_Data.Push(c.Statements);
return this;
}
internal static CodeCatchClause Catch(CodeTypeReference type, string name, CodeStatement catchStmnt)
{
CodeCatchClause clause = new CodeCatchClause {
CatchExceptionType = type,
LocalName = name
};
if (catchStmnt != null)
{
clause.Statements.Add(catchStmnt);
}
return clause;
}
public void Constructor1 ()
{
CodeCatchClause cc1 = new CodeCatchClause ();
CodeCatchClause cc2 = new CodeCatchClause ();
CodeCatchClause[] catchClauses = new CodeCatchClause[] { cc1, cc2 };
CodeCatchClauseCollection coll = new CodeCatchClauseCollection (
catchClauses);
Assert.AreEqual (2, coll.Count, "#1");
Assert.AreEqual (0, coll.IndexOf (cc1), "#2");
Assert.AreEqual (1, coll.IndexOf (cc2), "#3");
}
public void Constructor2 ()
{
CodeCatchClause cc1 = new CodeCatchClause ();
CodeCatchClause cc2 = new CodeCatchClause ();
CodeCatchClauseCollection c = new CodeCatchClauseCollection ();
c.Add (cc1);
c.Add (cc2);
CodeCatchClauseCollection coll = new CodeCatchClauseCollection (c);
Assert.AreEqual (2, coll.Count, "#1");
Assert.AreEqual (0, coll.IndexOf (cc1), "#2");
Assert.AreEqual (1, coll.IndexOf (cc2), "#3");
}
/// <summary>
///
/// </summary>
/// <param name="member"></param>
/// <param name="inner"></param>
/// <param name="attrs"></param>
/// <returns></returns>
public CodeTypeMember CreateMember(MemberInfo member, CodeFieldReferenceExpression inner, MemberAttributes attrs)
{
Debug.Assert(member is MethodInfo);
MethodInfo method = member as MethodInfo;
CodeMemberMethod codeMethod = new CodeMemberMethod();
codeMethod.Name = method.Name;
codeMethod.ReturnType = new CodeTypeReference(method.ReturnType);
codeMethod.Attributes = attrs;
// try
CodeTryCatchFinallyStatement tryCode = new CodeTryCatchFinallyStatement();
// decleare parameters
List<CodeArgumentReferenceExpression> codeParamiteRefrs = new List<CodeArgumentReferenceExpression>();
foreach (ParameterInfo codeParameter in method.GetParameters()) {
CodeParameterDeclarationExpression codeParameterDeclare = new CodeParameterDeclarationExpression(codeParameter.ParameterType, codeParameter.Name);
codeMethod.Parameters.Add(codeParameterDeclare);
codeParamiteRefrs.Add(new CodeArgumentReferenceExpression(codeParameter.Name));
}
// invoke
CodeMethodInvokeExpression invokeMethod = new CodeMethodInvokeExpression(
inner, method.Name, codeParamiteRefrs.ToArray());
if (method.ReturnType.Name.ToLower() == "void") {
tryCode.TryStatements.Add(invokeMethod);
} else {
CodeVariableDeclarationStatement var = new CodeVariableDeclarationStatement(method.ReturnType, "returnObject", invokeMethod);
//CodeAssignStatement assign = new CodeAssignStatement(var, invokeMethod);
tryCode.TryStatements.Add(var);
CodeCommentStatement todo = new CodeCommentStatement("TODO: your code", false);
tryCode.TryStatements.Add(todo);
CodeVariableReferenceExpression varRef = new CodeVariableReferenceExpression("returnObject");
CodeMethodReturnStatement codeReturn = new CodeMethodReturnStatement(varRef);
tryCode.TryStatements.Add(codeReturn);
}
// catch
CodeTypeReference codeTypeRef = new CodeTypeReference(typeof(Exception));
CodeCatchClause catchClause = new CodeCatchClause("ex", codeTypeRef);
catchClause.Statements.Add(new CodeThrowExceptionStatement());
tryCode.CatchClauses.Add(catchClause);
codeMethod.Statements.Add(tryCode);
return codeMethod;
}
public void Constructor1 () {
string localName = "mono";
CodeCatchClause ccc = new CodeCatchClause (localName);
Assert.IsNotNull (ccc.CatchExceptionType, "#1");
Assert.AreEqual (typeof(Exception).FullName, ccc.CatchExceptionType.BaseType, "#2");
Assert.IsNotNull (ccc.LocalName, "#3");
Assert.AreEqual (localName, ccc.LocalName, "#4");
Assert.AreSame (localName, ccc.LocalName, "#5");
Assert.IsNotNull (ccc.Statements, "#6");
Assert.AreEqual (0, ccc.Statements.Count, "#7");
ccc.LocalName = null;
Assert.IsNotNull (ccc.LocalName, "#8");
Assert.AreEqual (string.Empty, ccc.LocalName, "#9");
ccc = new CodeCatchClause ((string) null);
Assert.IsNotNull (ccc.LocalName, "#10");
Assert.AreEqual (string.Empty, ccc.LocalName, "#22");
}
public void Remove ()
{
CodeCatchClause ccc1 = new CodeCatchClause ();
CodeCatchClause ccc2 = new CodeCatchClause ();
CodeCatchClauseCollection coll = new CodeCatchClauseCollection ();
coll.Add (ccc1);
coll.Add (ccc2);
Assert.AreEqual (2, coll.Count, "#1");
Assert.AreEqual (0, coll.IndexOf (ccc1), "#2");
Assert.AreEqual (1, coll.IndexOf (ccc2), "#3");
coll.Remove (ccc1);
Assert.AreEqual (1, coll.Count, "#4");
Assert.AreEqual (-1, coll.IndexOf (ccc1), "#5");
Assert.AreEqual (0, coll.IndexOf (ccc2), "#6");
}
/// <summary>
/// Gets the throw clause.
/// </summary>
/// <returns>return catch...throw statment</returns>
internal static CodeCatchClause[] GetThrowClause()
{
var catchStatmanents = new CodeStatementCollection();
catchStatmanents.Add(new CodeThrowExceptionStatement(new CodeVariableReferenceExpression("ex")));
var catchClause = new CodeCatchClause(
"ex",
new CodeTypeReference(typeof(Exception)),
catchStatmanents.ToArray());
var catchClauses = new[] { catchClause };
return catchClauses;
}
public override object Visit(TryCatchStatement tryCatchStatement, object data)
{
ProcessSpecials(tryCatchStatement.Specials);
// add a try-catch-finally
CodeTryCatchFinallyStatement tryStmt = new CodeTryCatchFinallyStatement();
codeStack.Push(tryStmt.TryStatements);
ProcessSpecials(tryCatchStatement.StatementBlock.Specials);
tryCatchStatement.StatementBlock.AcceptChildren(this, data);
codeStack.Pop();
if (tryCatchStatement.FinallyBlock != null)
{
codeStack.Push(tryStmt.FinallyStatements);
ProcessSpecials(tryCatchStatement.FinallyBlock.Specials);
tryCatchStatement.FinallyBlock.AcceptChildren(this,data);
codeStack.Pop();
}
if (tryCatchStatement.CatchClauses != null)
{
foreach (CatchClause clause in tryCatchStatement.CatchClauses)
{
CodeCatchClause catchClause = new CodeCatchClause(clause.VariableName);
catchClause.CatchExceptionType = new CodeTypeReference(clause.Type);
tryStmt.CatchClauses.Add(catchClause);
codeStack.Push(catchClause.Statements);
ProcessSpecials(clause.StatementBlock.Specials);
clause.StatementBlock.AcceptChildren(this, data);
codeStack.Pop();
}
}
// Add Statement to Current Statement Collection
AddStmt(tryStmt);
return tryStmt;
}
public CodeExpression GenerateLoadPixbuf (string name, Gtk.IconSize size)
{
bool found = false;
foreach (CodeTypeDeclaration t in cns.Types) {
if (t.Name == "IconLoader") {
found = true;
break;
}
}
if (!found)
{
CodeTypeDeclaration cls = new CodeTypeDeclaration ("IconLoader");
cls.Attributes = MemberAttributes.Private;
cls.TypeAttributes = System.Reflection.TypeAttributes.NestedAssembly;
cns.Types.Add (cls);
CodeMemberMethod met = new CodeMemberMethod ();
cls.Members.Add (met);
met.Attributes = MemberAttributes.Public | MemberAttributes.Static;
met.Name = "LoadIcon";
met.Parameters.Add (new CodeParameterDeclarationExpression (typeof(Gtk.Widget), "widget"));
met.Parameters.Add (new CodeParameterDeclarationExpression (typeof(string), "name"));
met.Parameters.Add (new CodeParameterDeclarationExpression (typeof(Gtk.IconSize), "size"));
met.ReturnType = new CodeTypeReference (typeof(Gdk.Pixbuf));
CodeExpression widgetExp = new CodeVariableReferenceExpression ("widget");
CodeExpression nameExp = new CodeVariableReferenceExpression ("name");
CodeExpression sizeExp = new CodeVariableReferenceExpression ("size");
CodeExpression szExp = new CodeVariableReferenceExpression ("sz");
CodeExpression mgExp = new CodeBinaryOperatorExpression (szExp, CodeBinaryOperatorType.Divide, new CodePrimitiveExpression (4));
CodeExpression pmapExp = new CodeVariableReferenceExpression ("pmap");
CodeExpression gcExp = new CodeVariableReferenceExpression ("gc");
CodeExpression szM1Exp = new CodeBinaryOperatorExpression (szExp, CodeBinaryOperatorType.Subtract, new CodePrimitiveExpression (1));
CodeExpression zeroExp = new CodePrimitiveExpression (0);
CodeExpression resExp = new CodeVariableReferenceExpression ("res");
met.Statements.Add (
new CodeVariableDeclarationStatement (typeof(Gdk.Pixbuf), "res",
new CodeMethodInvokeExpression (
widgetExp,
"RenderIcon",
nameExp,
sizeExp,
new CodePrimitiveExpression (null)
)
)
);
CodeConditionStatement nullcheck = new CodeConditionStatement ();
met.Statements.Add (nullcheck);
nullcheck.Condition = new CodeBinaryOperatorExpression (
resExp,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression (null)
);
nullcheck.TrueStatements.Add (new CodeMethodReturnStatement (resExp));
// int sz, h;
// Gtk.Icon.SizeLookup (size, out sz, out h);
nullcheck.FalseStatements.Add (new CodeVariableDeclarationStatement (typeof(int), "sz"));
nullcheck.FalseStatements.Add (new CodeVariableDeclarationStatement (typeof(int), "sy"));
nullcheck.FalseStatements.Add (new CodeMethodInvokeExpression (
new CodeTypeReferenceExpression (typeof(Gtk.Icon).ToGlobalTypeRef ()),
"SizeLookup",
sizeExp,
new CodeDirectionExpression (FieldDirection.Out, szExp),
new CodeDirectionExpression (FieldDirection.Out, new CodeVariableReferenceExpression ("sy"))
));
CodeTryCatchFinallyStatement trycatch = new CodeTryCatchFinallyStatement ();
nullcheck.FalseStatements.Add (trycatch);
trycatch.TryStatements.Add (
new CodeMethodReturnStatement (
new CodeMethodInvokeExpression (
new CodePropertyReferenceExpression (
new CodeTypeReferenceExpression (new CodeTypeReference (typeof(Gtk.IconTheme))),
"Default"
),
"LoadIcon",
nameExp,
szExp,
zeroExp
)
)
);
CodeCatchClause ccatch = new CodeCatchClause ();
trycatch.CatchClauses.Add (ccatch);
CodeConditionStatement cond = new CodeConditionStatement ();
ccatch.Statements.Add (cond);
cond.Condition = new CodeBinaryOperatorExpression (
nameExp,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression ("gtk-missing-image")
);
cond.TrueStatements.Add (
new CodeMethodReturnStatement (
new CodeMethodInvokeExpression (
new CodeTypeReferenceExpression (cns.Name + "." + cls.Name),
"LoadIcon",
widgetExp,
new CodePrimitiveExpression ("gtk-missing-image"),
sizeExp
)
)
);
CodeStatementCollection stms = cond.FalseStatements;
stms.Add (
new CodeVariableDeclarationStatement (typeof(Gdk.Pixmap), "pmap",
new CodeObjectCreateExpression (
typeof(Gdk.Pixmap),
new CodePropertyReferenceExpression (
new CodePropertyReferenceExpression (
new CodeTypeReferenceExpression (typeof(Gdk.Screen)),
"Default"
),
"RootWindow"
),
szExp,
szExp
)
)
);
stms.Add (
new CodeVariableDeclarationStatement (typeof(Gdk.GC), "gc",
new CodeObjectCreateExpression (typeof(Gdk.GC), pmapExp)
)
);
stms.Add (
new CodeAssignStatement (
new CodePropertyReferenceExpression (
gcExp,
"RgbFgColor"
),
new CodeObjectCreateExpression (
typeof(Gdk.Color),
new CodePrimitiveExpression (255),
new CodePrimitiveExpression (255),
new CodePrimitiveExpression (255)
)
)
);
stms.Add (
new CodeMethodInvokeExpression (
pmapExp,
"DrawRectangle",
gcExp,
new CodePrimitiveExpression (true),
zeroExp,
zeroExp,
szExp,
szExp
)
);
stms.Add (
new CodeAssignStatement (
new CodePropertyReferenceExpression (
gcExp,
"RgbFgColor"
),
new CodeObjectCreateExpression (
typeof(Gdk.Color),
zeroExp, zeroExp, zeroExp
)
)
);
stms.Add (
new CodeMethodInvokeExpression (
pmapExp,
"DrawRectangle",
gcExp,
new CodePrimitiveExpression (false),
zeroExp,
zeroExp,
szM1Exp,
szM1Exp
)
);
stms.Add (
new CodeMethodInvokeExpression (
gcExp,
"SetLineAttributes",
new CodePrimitiveExpression (3),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression (typeof(Gdk.LineStyle)), "Solid"),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression (typeof(Gdk.CapStyle)), "Round"),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression (typeof(Gdk.JoinStyle)), "Round")
)
);
stms.Add (
new CodeAssignStatement (
new CodePropertyReferenceExpression (
gcExp,
"RgbFgColor"
),
new CodeObjectCreateExpression (
typeof(Gdk.Color),
new CodePrimitiveExpression (255),
zeroExp,
zeroExp
)
)
);
stms.Add (
new CodeMethodInvokeExpression (
pmapExp,
"DrawLine",
gcExp,
mgExp,
mgExp,
new CodeBinaryOperatorExpression (szM1Exp, CodeBinaryOperatorType.Subtract, mgExp),
new CodeBinaryOperatorExpression (szM1Exp, CodeBinaryOperatorType.Subtract, mgExp)
)
);
stms.Add (
new CodeMethodInvokeExpression (
pmapExp,
"DrawLine",
gcExp,
new CodeBinaryOperatorExpression (szM1Exp, CodeBinaryOperatorType.Subtract, mgExp),
mgExp,
mgExp,
new CodeBinaryOperatorExpression (szM1Exp, CodeBinaryOperatorType.Subtract, mgExp)
)
);
stms.Add (
new CodeMethodReturnStatement (
new CodeMethodInvokeExpression (
new CodeTypeReferenceExpression (typeof(Gdk.Pixbuf)),
"FromDrawable",
pmapExp,
new CodePropertyReferenceExpression (pmapExp, "Colormap"),
zeroExp, zeroExp, zeroExp, zeroExp, szExp, szExp
)
)
);
}
int sz, h;
Gtk.Icon.SizeLookup (size, out sz, out h);
return new CodeMethodInvokeExpression (
new CodeTypeReferenceExpression (new CodeTypeReference (cns.Name + ".IconLoader", CodeTypeReferenceOptions.GlobalReference)),
"LoadIcon",
rootObject,
new CodePrimitiveExpression (name),
new CodeFieldReferenceExpression (
new CodeTypeReferenceExpression (new CodeTypeReference (typeof(Gtk.IconSize), CodeTypeReferenceOptions.GlobalReference)),
size.ToString ()
)
);
}
public void Insert(int index, CodeCatchClause value)
{
throw new NotImplementedException();
}
public bool Contains(CodeCatchClause value)
{
throw new NotImplementedException();
}
public void Insert(int index, CodeCatchClause value) => List.Insert(index, value);
/// <devdoc>
/// <para>Copies the <see cref='System.CodeDom.CodeCatchClauseCollection'/> values to a one-dimensional <see cref='System.Array'/> instance at the
/// specified index.</para>
/// </devdoc>
public void CopyTo(CodeCatchClause[] array, int index) {
List.CopyTo(array, index);
}
public void Remove(CodeCatchClause value)
{
}
public void Insert(int index, CodeCatchClause value)
{
}
public int IndexOf(CodeCatchClause value)
{
return(default(int));
}
public bool Contains(CodeCatchClause value)
{
return(default(bool));
}
public int Add(CodeCatchClause value)
{
return(default(int));
}
//
// Methods
//
public int Add(CodeCatchClause value)
{
return(List.Add(value));
}
public int IndexOf(CodeCatchClause value)
{
return(List.IndexOf(value));
}
public void Remove(CodeCatchClause value)
{
base.List.Remove(value);
}
public void Remove(CodeCatchClause value) => List.Remove(value);
/// <devdoc>
/// <para>Inserts a <see cref='System.CodeDom.CodeCatchClause'/> into the <see cref='System.CodeDom.CodeCatchClauseCollection'/> at the specified index.</para>
/// </devdoc>
public void Insert(int index, CodeCatchClause value) {
List.Insert(index, value);
}
public int IndexOf(CodeCatchClause value)
{
throw new NotImplementedException();
}
/// <devdoc>
/// <para> Removes a specific <see cref='System.CodeDom.CodeCatchClause'/> from the
/// <see cref='System.CodeDom.CodeCatchClauseCollection'/> .</para>
/// </devdoc>
public void Remove(CodeCatchClause value) {
List.Remove(value);
}
public void Remove(CodeCatchClause value)
{
throw new NotImplementedException();
}
/// <devdoc>
/// <para>
/// Initializes a new instance of <see cref='System.CodeDom.CodeCatchClauseCollection'/> containing any array of <see cref='System.CodeDom.CodeCatchClause'/> objects.
/// </para>
/// </devdoc>
public CodeCatchClauseCollection(CodeCatchClause[] value) {
this.AddRange(value);
}
// Add a new vertex method to the DryadLinq vertex class
internal CodeMemberMethod AddVertexMethod(DLinqQueryNode node)
{
CodeMemberMethod vertexMethod = new CodeMemberMethod();
vertexMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static;
vertexMethod.ReturnType = new CodeTypeReference(typeof(int));
vertexMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "args"));
vertexMethod.Name = MakeUniqueName(node.NodeType.ToString());
CodeTryCatchFinallyStatement tryBlock = new CodeTryCatchFinallyStatement();
string startedMsg = "DryadLinqLog.AddInfo(\"Vertex " + vertexMethod.Name +
" started at {0}\", DateTime.Now.ToString(\"MM/dd/yyyy HH:mm:ss.fff\"))";
vertexMethod.Statements.Add(new CodeSnippetExpression(startedMsg));
// We need to add a call to CopyResources()
vertexMethod.Statements.Add(new CodeSnippetExpression("CopyResources()"));
if (StaticConfig.LaunchDebugger)
{
// If static config requests it, we do an unconditional Debugger.Launch() at vertex entry.
// Currently this isn't used because StaticConfig.LaunchDebugger is hardcoded to false
System.Console.WriteLine("Launch debugger: may block application");
CodeExpression launchExpr = new CodeSnippetExpression("System.Diagnostics.Debugger.Launch()");
vertexMethod.Statements.Add(new CodeExpressionStatement(launchExpr));
}
else
{
// Otherwise (the default behavior), we check an environment variable to decide whether
// to launch the debugger, wait for a manual attach or simply skip straigt into vertex code.
CodeMethodInvokeExpression debuggerCheckExpr = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(HelperClassName),
DebugHelperMethodName));
vertexMethod.Statements.Add(new CodeExpressionStatement(debuggerCheckExpr));
}
vertexMethod.Statements.Add(MakeVertexParamsDecl(node));
vertexMethod.Statements.Add(SetVertexParamField("VertexStageName", vertexMethod.Name));
vertexMethod.Statements.Add(SetVertexParamField("UseLargeBuffer", node.UseLargeWriteBuffer));
Int32[] portCountArray = node.InputPortCounts();
bool[] keepPortOrderArray = node.KeepInputPortOrders();
for (int i = 0; i < node.InputArity; i++)
{
CodeExpression setParamsExpr = new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(VertexParamName),
"SetInputParams",
new CodePrimitiveExpression(i),
new CodePrimitiveExpression(portCountArray[i]),
new CodePrimitiveExpression(keepPortOrderArray[i]));
vertexMethod.Statements.Add(new CodeExpressionStatement(setParamsExpr));
}
// YY: We could probably do better here.
for (int i = 0; i < node.GetReferencedQueries().Count; i++)
{
CodeExpression setParamsExpr = new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(VertexParamName),
"SetInputParams",
new CodePrimitiveExpression(i + node.InputArity),
new CodePrimitiveExpression(1),
new CodePrimitiveExpression(false));
vertexMethod.Statements.Add(new CodeExpressionStatement(setParamsExpr));
}
// Push the parallel-code settings into DryadLinqVertex
bool multiThreading = this.m_context.EnableMultiThreadingInVertex;
vertexMethod.Statements.Add(SetVertexParamField("MultiThreading", multiThreading));
vertexMethod.Statements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(DLVTypeExpr, "s_multiThreading"),
new CodePrimitiveExpression(multiThreading)));
vertexMethod.Statements.Add(MakeVertexEnvDecl(node));
Type[] outputTypes = node.OutputTypes;
string[] writerNames = new string[outputTypes.Length];
for (int i = 0; i < outputTypes.Length; i++)
{
CodeVariableDeclarationStatement
writerDecl = MakeVertexWriterDecl(outputTypes[i], this.GetStaticFactoryName(outputTypes[i]));
vertexMethod.Statements.Add(writerDecl);
writerNames[i] = writerDecl.Name;
}
// Add side readers:
node.AddSideReaders(vertexMethod);
// Generate code based on the node type:
switch (node.NodeType)
{
case QueryNodeType.Where:
case QueryNodeType.OrderBy:
case QueryNodeType.Distinct:
case QueryNodeType.Skip:
case QueryNodeType.SkipWhile:
case QueryNodeType.Take:
case QueryNodeType.TakeWhile:
case QueryNodeType.Merge:
case QueryNodeType.Select:
case QueryNodeType.SelectMany:
case QueryNodeType.Zip:
case QueryNodeType.GroupBy:
case QueryNodeType.BasicAggregate:
case QueryNodeType.Aggregate:
case QueryNodeType.Contains:
case QueryNodeType.Join:
case QueryNodeType.GroupJoin:
case QueryNodeType.Union:
case QueryNodeType.Intersect:
case QueryNodeType.Except:
case QueryNodeType.RangePartition:
case QueryNodeType.HashPartition:
case QueryNodeType.Apply:
case QueryNodeType.Fork:
case QueryNodeType.Dynamic:
{
Type[] inputTypes = node.InputTypes;
string[] sourceNames = new string[inputTypes.Length];
for (int i = 0; i < inputTypes.Length; i++)
{
CodeVariableDeclarationStatement
readerDecl = MakeVertexReaderDecl(inputTypes[i], this.GetStaticFactoryName(inputTypes[i]));
vertexMethod.Statements.Add(readerDecl);
sourceNames[i] = readerDecl.Name;
}
string sourceToSink = this.m_vertexCodeGen.AddVertexCode(node, vertexMethod, sourceNames, writerNames);
if (sourceToSink != null)
{
CodeExpression sinkExpr = new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(writerNames[0]),
"WriteItemSequence",
new CodeVariableReferenceExpression(sourceToSink));
vertexMethod.Statements.Add(sinkExpr);
}
break;
}
case QueryNodeType.Super:
{
string sourceToSink = this.m_vertexCodeGen.AddVertexCode(node, vertexMethod, null, writerNames);
if (sourceToSink != null)
{
CodeExpression sinkExpr = new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(writerNames[0]),
"WriteItemSequence",
new CodeVariableReferenceExpression(sourceToSink));
vertexMethod.Statements.Add(sinkExpr);
}
break;
}
default:
{
//@@TODO: this should not be reachable. could change to Assert/InvalidOpEx
throw new DryadLinqException(DryadLinqErrorCode.Internal,
String.Format(SR.AddVertexNotHandled, node.NodeType));
}
}
string completedMsg = "DryadLinqLog.AddInfo(\"Vertex " + vertexMethod.Name +
" completed at {0}\", DateTime.Now.ToString(\"MM/dd/yyyy HH:mm:ss.fff\"))";
vertexMethod.Statements.Add(new CodeSnippetExpression(completedMsg));
// add a catch block
CodeCatchClause catchBlock = new CodeCatchClause("e");
CodeTypeReferenceExpression errorReportClass = new CodeTypeReferenceExpression("VertexEnv");
CodeMethodReferenceExpression
errorReportMethod = new CodeMethodReferenceExpression(errorReportClass, "ReportVertexError");
CodeVariableReferenceExpression exRef = new CodeVariableReferenceExpression(catchBlock.LocalName);
catchBlock.Statements.Add(new CodeMethodInvokeExpression(errorReportMethod, exRef));
tryBlock.CatchClauses.Add(catchBlock);
// wrap the entire vertex method in a try/catch block
tryBlock.TryStatements.AddRange(vertexMethod.Statements);
vertexMethod.Statements.Clear();
vertexMethod.Statements.Add(tryBlock);
// Always add "return 0", to make CLR hosting happy...
vertexMethod.Statements.Add(new CodeMethodReturnStatement(ZeroExpr));
this.m_dryadVertexClass.Members.Add(vertexMethod);
return vertexMethod;
}
/// <devdoc>
/// <para>Adds a <see cref='System.CodeDom.CodeCatchClause'/> with the specified value to the
/// <see cref='System.CodeDom.CodeCatchClauseCollection'/> .</para>
/// </devdoc>
public int Add(CodeCatchClause value) {
return List.Add(value);
}
/// <summary>
/// Return catch statments
/// </summary>
/// <returns>CodeCatchClause statments</returns>
internal static CodeCatchClause[] GetCatchClause()
{
var catchStatmanents = new CodeStatement[2];
catchStatmanents[0] = new CodeAssignStatement(
new CodeVariableReferenceExpression("exception"),
new CodeVariableReferenceExpression("ex"));
catchStatmanents[1] = GetReturnFalse();
var catchClause = new CodeCatchClause(
"ex",
new CodeTypeReference(typeof(Exception)),
catchStatmanents);
var catchClauses = new[] { catchClause };
return catchClauses;
}
public int Add(CodeCatchClause value) => List.Add(value);
public void AddRange ()
{
CodeCatchClause cc1 = new CodeCatchClause ();
CodeCatchClause cc2 = new CodeCatchClause ();
CodeCatchClause cc3 = new CodeCatchClause ();
CodeCatchClauseCollection coll1 = new CodeCatchClauseCollection ();
coll1.Add (cc1);
coll1.Add (cc2);
CodeCatchClauseCollection coll2 = new CodeCatchClauseCollection ();
coll2.Add (cc3);
coll2.AddRange (coll1);
Assert.AreEqual (3, coll2.Count, "#1");
Assert.AreEqual (1, coll2.IndexOf (cc1), "#2");
Assert.AreEqual (2, coll2.IndexOf (cc2), "#3");
Assert.AreEqual (0, coll2.IndexOf (cc3), "#4");
CodeCatchClauseCollection coll3 = new CodeCatchClauseCollection ();
coll3.Add (cc3);
coll3.AddRange (new CodeCatchClause[] { cc1, cc2 });
Assert.AreEqual (3, coll2.Count, "#5");
Assert.AreEqual (1, coll2.IndexOf (cc1), "#6");
Assert.AreEqual (2, coll2.IndexOf (cc2), "#7");
Assert.AreEqual (0, coll2.IndexOf (cc3), "#8");
}
public bool Contains(CodeCatchClause value) => List.Contains(value);
public async System.Threading.Tasks.Task GCode_CodeDom_GenerateMethodCode(CodeTypeDeclaration codeClass, LinkPinControl element, GenerateCodeContext_Class context, MethodGenerateData data)
{
var csParam = CSParam as MethodOverrideConstructParam;
Type[] paramTypes = new Type[csParam.MethodInfo.Params.Count];
for (int i = 0; i < paramTypes.Length; i++)
{
switch (csParam.MethodInfo.Params[i].FieldDirection)
{
case FieldDirection.In:
if (csParam.MethodInfo.Params[i].IsParamsArray)
{
throw new InvalidOperationException("未实现");
}
else
{
paramTypes[i] = csParam.MethodInfo.Params[i].ParameterType;
}
break;
case FieldDirection.Out:
case FieldDirection.Ref:
if (csParam.MethodInfo.Params[i].IsParamsArray)
{
throw new InvalidOperationException("未实现");
}
else
{
paramTypes[i] = csParam.MethodInfo.Params[i].ParameterType.MakeByRefType();
}
break;
}
}
EngineNS.Editor.MacrossMemberAttribute.enMacrossType macrossType = EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Overrideable;
if (csParam.MethodInfo.IsFromMacross)
{
macrossType |= EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Callable;
}
else
{
var methodInfo = csParam.MethodInfo.ParentClassType.GetMethod(csParam.MethodInfo.MethodName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static, null, paramTypes, null);
var atts = methodInfo.GetCustomAttributes(typeof(EngineNS.Editor.MacrossMemberAttribute), false);
if (atts.Length > 0)
{
var macrossMemberAtt = atts[0] as EngineNS.Editor.MacrossMemberAttribute;
macrossType = macrossMemberAtt.MacrossType;
}
}
if (element == null || element == mCtrlMethodPin_Next)
{
var methodCode = new CodeGenerateSystem.CodeDom.CodeMemberMethod();
methodCode.Attributes = MemberAttributes.Override;
//if (mMethodInfo != null)
//{
if (csParam.MethodInfo.IsFamily)
{
methodCode.Attributes |= MemberAttributes.Family;
}
if (csParam.MethodInfo.IsFamilyAndAssembly)
{
methodCode.Attributes |= MemberAttributes.FamilyAndAssembly;
}
if (csParam.MethodInfo.IsFamilyOrAssembly)
{
methodCode.Attributes |= MemberAttributes.FamilyOrAssembly;
}
if (csParam.MethodInfo.IsPublic)
{
methodCode.Attributes |= MemberAttributes.Public;
}
//}
//else
// methodCode.Attributes |= MemberAttributes.Public;
methodCode.Name = NodeName;
var mcType = EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unknow;
if (csParam.MethodInfo.MC_Callable)
{
mcType = mcType | EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Callable;
}
if (csParam.MethodInfo.MC_Overrideable)
{
mcType = mcType | EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Overrideable;
}
if (mcType != EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unknow)
{
methodCode.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(EngineNS.Editor.MacrossMemberAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression(mcType))));
}
if (data != null)
{
foreach (var localParam in data.LocalParams)
{
var defVal = CodeGenerateSystem.Program.GetDefaultValueFromType(localParam.ParamType);
var initExp = Program.GetValueCode(methodCode.Statements, localParam.ParamType, defVal);
methodCode.Statements.Add(new CodeVariableDeclarationStatement(localParam.ParamType, localParam.ParamName, initExp));
}
}
string paramPreStr = "temp___";
//bool needUnsafeFlag = false;
string catchParamName = "(";
foreach (var paramNode in mChildNodes)
{
var paramExp = new System.CodeDom.CodeParameterDeclarationExpression();
if (paramNode is MethodInvokeParameterControl)
{
var pm = paramNode as MethodInvokeParameterControl;
var pmParam = pm.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams;
paramExp.Direction = pm.ParamFlag;
if (pmParam.ParamInfo.ParameterDisplayType != null)
{
paramExp.Name = paramPreStr + pmParam.ParamInfo.ParamName;
paramExp.Type = new CodeTypeReference(pmParam.ParamInfo.ParameterType);
}
else
{
paramExp.Name = pmParam.ParamInfo.ParamName;
paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType);
}
//if (pm.ParamType.IsPointer)
// needUnsafeFlag = true;
}
else if (paramNode is ParamParameterControl)
{
var pm = paramNode as ParamParameterControl;
paramExp.Name = pm.ParamName;
paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType);
//if (pm.ParamType.IsPointer)
// needUnsafeFlag = true;
}
else if (paramNode is MethodInvoke_DelegateControl)
{
var pm = paramNode as MethodInvoke_DelegateControl;
paramExp.Name = pm.ParamName;
paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType);
}
methodCode.Parameters.Add(paramExp);
catchParamName += paramExp.Type + " " + paramExp.Name + ",";
}
// 所有函数全部unsafe
//if (needUnsafeFlag)
{
//var typeName = MethodReturnType.FullName;
methodCode.ReturnType = new CodeTypeReference(MethodReturnType);
if (MethodReturnType == typeof(System.Threading.Tasks.Task) || MethodReturnType.BaseType == typeof(System.Threading.Tasks.Task))
{
methodCode.IsAsync = true;
}
else
{
if (EngineNS.Editor.MacrossMemberAttribute.HasType(macrossType, EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unsafe))
{
methodCode.IsUnsafe = true;
}
}
}
//else
// methodCode.ReturnType = new CodeTypeReference(MethodReturnType);
catchParamName = catchParamName.TrimEnd(',');
catchParamName += ")";
var tryCatchExp = new System.CodeDom.CodeTryCatchFinallyStatement();
tryCatchExp.TryStatements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeVariableReferenceExpression(context.ScopFieldName), "Begin", new CodeExpression[0]));
var exName = "ex_" + EngineNS.Editor.Assist.GetValuedGUIDString(Id);
var cah = new System.CodeDom.CodeCatchClause(exName);
cah.Statements.Add(new System.CodeDom.CodeExpressionStatement(
new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(
new System.CodeDom.CodeSnippetExpression("EngineNS.Profiler.Log"), "WriteException",
new System.CodeDom.CodeVariableReferenceExpression(exName),
new CodePrimitiveExpression("Macross异常"))));
tryCatchExp.CatchClauses.Add(cah);
tryCatchExp.FinallyStatements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeVariableReferenceExpression(context.ScopFieldName), "End", new CodeExpression[0]));
string paramComment = "";
// 设置out参数默认值
foreach (var param in csParam.MethodInfo.Params)
{
if (param.ParameterDisplayType != null)
{
if (param.FieldDirection == FieldDirection.Out)
{
methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(paramPreStr + param.ParamName),
new CodePrimitiveExpression(CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParameterType))));
}
methodCode.Statements.Add(new CodeVariableDeclarationStatement(param.ParameterDisplayType, param.ParamName, new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterDisplayType, new CodeVariableReferenceExpression(paramPreStr + param.ParamName))));
}
else
{
if (param.FieldDirection == FieldDirection.Out)
{
methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(param.ParamName),
new CodePrimitiveExpression(CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParameterType))));
}
}
paramComment += param.FieldDirection + "," + param.ParameterType.FullName + "|";
}
paramComment = paramComment.TrimEnd('|');
methodCode.Statements.Add(tryCatchExp);
foreach (var param in csParam.MethodInfo.Params)
{
// ref或out，需要将displayType造成的临时变量再赋给原函数参数
if ((param.FieldDirection == FieldDirection.Out || param.FieldDirection == FieldDirection.Ref) && param.ParameterDisplayType != null)
{
methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(paramPreStr + param.ParamName), new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterType, new CodeVariableReferenceExpression(param.ParamName))));
}
}
if (csParam.MethodInfo.ReturnType != typeof(void) && csParam.MethodInfo.ReturnType != typeof(System.Threading.Tasks.Task))
{
var retVal = CodeGenerateSystem.Program.GetDefaultValueFromType(csParam.MethodInfo.ReturnType);
methodCode.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(retVal)));
}
if (csParam.MethodInfo.IsFromMacross)
{
codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideStart {csParam.MethodInfo.FuncId.ToString()} {NodeName} {paramComment}"));
codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning disable 1998"));
codeClass.Members.Add(methodCode);
codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning restore 1998"));
codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideEnd {csParam.MethodInfo.FuncId.ToString()} {NodeName}"));
}
else
{
codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideStart {NodeName} {paramComment}"));
codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning disable 1998"));
codeClass.Members.Add(methodCode);
codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning restore 1998"));
codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideEnd {NodeName}"));
}
var methodContext = new CodeGenerateSystem.Base.GenerateCodeContext_Method(context, methodCode);
// 收集用于调试的数据的代码
var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(tryCatchExp.TryStatements);
foreach (var paramNode in mChildNodes)
{
if (paramNode is MethodInvokeParameterControl)
{
var paramCtrl = paramNode as MethodInvokeParameterControl;
CodeDomNode.BreakPoint.GetGatherDataValueCodeStatement(debugCodes, paramCtrl.ParamPin.GetLinkPinKeyName(), paramCtrl.GCode_CodeDom_GetValue(paramCtrl.ParamPin, methodContext), paramCtrl.GCode_GetTypeString(paramCtrl.ParamPin, methodContext), methodContext);
}
else if (paramNode is ParamParameterControl)
{
throw new InvalidOperationException();
}
}
// 断点
var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id);
// 设置数据
foreach (var paramNode in mChildNodes)
{
if (paramNode is MethodInvokeParameterControl)
{
var paramCtrl = paramNode as MethodInvokeParameterControl;
CodeDomNode.BreakPoint.GetSetDataValueCodeStatement(breakCondStatement.TrueStatements, paramCtrl.ParamPin.GetLinkPinKeyName(), paramCtrl.GCode_CodeDom_GetValue(paramCtrl.ParamPin, methodContext), paramCtrl.GCode_GetType(paramCtrl.ParamPin, methodContext));
}
else if (paramNode is ParamParameterControl)
{
throw new InvalidOperationException();
}
}
CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(tryCatchExp.TryStatements, debugCodes);
if (mCtrlMethodPin_Next.HasLink)
{
methodContext.ReturnValueType = MethodReturnType;
await mCtrlMethodPin_Next.GetLinkedObject(0, false).GCode_CodeDom_GenerateCode(codeClass, tryCatchExp.TryStatements, mCtrlMethodPin_Next.GetLinkedPinControl(0, false), methodContext);
}
}
}
public int IndexOf(CodeCatchClause value) => List.IndexOf(value);
/// <devdoc>
/// <para>Returns the index of a <see cref='System.CodeDom.CodeCatchClause'/> in
/// the <see cref='System.CodeDom.CodeCatchClauseCollection'/> .</para>
/// </devdoc>
public int IndexOf(CodeCatchClause value) {
return List.IndexOf(value);
}
public bool Contains(CodeCatchClause value)
{
return(List.Contains(value));
}
