public CodeStatement[] GenerateForPropertyGet()
{
var exceptionCopyStatement = new CodeVariableDeclarationStatement(
typeof(Exception), VariableNames.ExceptionCopy,
new CodeVariableReferenceExpression(VariableNames.Exception));
var aspectInvocationExpression = this.GenerateAspectInvocationForProperty(true);
var throwCopyStatement = new CodeThrowExceptionStatement(
new CodeVariableReferenceExpression(VariableNames.ExceptionCopy));
var throwOriginalStatement = new CodeThrowExceptionStatement();
var compareCopyExpression = new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression(VariableNames.Exception),
CodeBinaryOperatorType.IdentityEquality,
new CodeVariableReferenceExpression(VariableNames.ExceptionCopy));
var compareAndThrowStatement = new CodeConditionStatement(
compareCopyExpression, new CodeStatement[] { throwOriginalStatement },
new CodeStatement[] { throwCopyStatement });
var aspectInvokeAndThrowStatement = new CodeConditionStatement(
aspectInvocationExpression, compareAndThrowStatement);
return(new CodeStatement[] { exceptionCopyStatement, aspectInvokeAndThrowStatement });
}
public CodeThrowExceptionStatement throwEx(CodeExpression expression)
{
CodeThrowExceptionStatement stat = new CodeThrowExceptionStatement(expression);
_enter(stat);
return(stat);
}
public CodeThrowExceptionStatement Throw(CodeExpression expr)
{
CodeThrowExceptionStatement st = new CodeThrowExceptionStatement(expr);
csc.Add(st);
return(st);
}
public override void apply(CodeTypeDeclaration mock, Type target)
{
CodeTypeMemberCollection mockMethods = mock.Members;
foreach (CodeTypeMember member in mockMethods)
{
if (member is CodeMemberMethod)
{
CodeMemberMethod method = (CodeMemberMethod)member;
CodeStatementCollection statements = method.Statements;
if (statements.Count > 0)
{
CodeStatement lastStatement = statements[statements.Count - 1];
if (lastStatement is CodeMethodReturnStatement)
{
statements.Remove(lastStatement);
}
}
CodeTypeReference typeToThrow = new CodeTypeReference(typeof(System.NotSupportedException));
CodeObjectCreateExpression createExpression = new CodeObjectCreateExpression(typeToThrow, new CodeExpression[] {});
CodeThrowExceptionStatement throwStatement = new CodeThrowExceptionStatement(createExpression);
statements.Add(throwStatement);
}
}
}
private void ValidateThrowExceptionStatement(CodeThrowExceptionStatement e)
{
if (e.ToThrow != null)
{
this.ValidateExpression(e.ToThrow);
}
}
public CodeStatement[] GenerateForMethod()
{
var methodInfo = this.memberInfo as MethodInfo;
if (methodInfo == null)
{
throw new InvalidOperationException();
}
var returnsValue = methodInfo.ReturnType != typeof(void);
var exceptionCopyStatement = new CodeVariableDeclarationStatement(
typeof(Exception), VariableNames.ExceptionCopy,
new CodeVariableReferenceExpression(VariableNames.Exception));
var aspectInvocationExpression = this.GenerateAspectInvocationForMethod(returnsValue);
var throwCopyStatement = new CodeThrowExceptionStatement(
new CodeVariableReferenceExpression(VariableNames.ExceptionCopy));
var throwOriginalStatement = new CodeThrowExceptionStatement();
var compareCopyExpression = new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression(VariableNames.Exception),
CodeBinaryOperatorType.IdentityEquality,
new CodeVariableReferenceExpression(VariableNames.ExceptionCopy));
var compareAndThrowStatement = new CodeConditionStatement(
compareCopyExpression, new CodeStatement[] { throwOriginalStatement },
new CodeStatement[] { throwCopyStatement });
var aspectInvokeAndThrowStatement = new CodeConditionStatement(
aspectInvocationExpression, compareAndThrowStatement);
return(new CodeStatement[] { exceptionCopyStatement, aspectInvokeAndThrowStatement });
}
private static CodeThrowExceptionStatement GenerateThrowNotImplementedExceptionStatement()
{
CodeThrowExceptionStatement exceptionStatement = new CodeThrowExceptionStatement();
exceptionStatement.ToThrow = new CodeObjectCreateExpression(typeof(NotImplementedException));
return(exceptionStatement);
}
private CodeThrowExceptionStatement GenerateExceptionStatement(GenerateErrorActivity activity)
{
var parameters =
AbstractActivityBuilder.GenerateParameters(
new List <string> {
@"""Message : {0}\nMessage code : {1} """
},
activity);
var stringFormatCall = new CodeMethodInvokeExpression();
stringFormatCall.Parameters.AddRange(parameters);
var formatMethod = new CodeMethodReferenceExpression {
MethodName = "Format"
};
var stringObject = new CodeVariableReferenceExpression {
VariableName = "String"
};
formatMethod.TargetObject = stringObject;
stringFormatCall.Method = formatMethod;
var throwException =
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(new CodeTypeReference(typeof(System.Exception)), stringFormatCall));
return(throwException);
}
public void Constructor0_Deny_Unrestricted()
{
CodeThrowExceptionStatement ctes = new CodeThrowExceptionStatement();
Assert.IsNull(ctes.ToThrow, "ToThrow");
ctes.ToThrow = new CodeExpression();
}
CodeMemberMethod ImplementEnsureView()
{
CodeMemberMethod method = CreateMethod("__EnsureView", MethodAccessibility.Private, MethodScope.Final);
// T __EnsureView <T> (Func<T> creator, ref T field) where T: class
var typeParam = new CodeTypeParameter("T");
typeParam.Constraints.Add(" class"); // Hack: CodeDOM doesn't support the "class" constraint
// and not passing the leading whitespace would result
// in @class being output in generated code
method.TypeParameters.Add(typeParam);
var tRef = new CodeTypeReference(typeParam);
var funcRef = new CodeTypeReference(typeof(Func <>), CodeTypeReferenceOptions.GlobalReference);
funcRef.TypeArguments.Add(tRef);
method.Parameters.Add(new CodeParameterDeclarationExpression(funcRef, "creator"));
method.Parameters.Add(
new CodeParameterDeclarationExpression(tRef, "field")
{
Direction = FieldDirection.Ref
}
);
method.ReturnType = tRef;
// if (field != null)
// return field;
var fieldVarRef = new CodeVariableReferenceExpression("field");
var ifFieldNotNull = new CodeConditionStatement(
new CodeBinaryOperatorExpression(fieldVarRef, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)),
new [] { new CodeMethodReturnStatement(fieldVarRef) }
);
method.Statements.Add(ifFieldNotNull);
// if (creator == null)
// throw new ArgumentNullException (nameof (creator));
var creatorVarRef = new CodeVariableReferenceExpression("creator");
var argNullEx = new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
new CodeTypeReference(typeof(ArgumentNullException), CodeTypeReferenceOptions.GlobalReference),
new [] { new CodeSnippetExpression("nameof (creator)") }
)
);
var ifCreatorNull = new CodeConditionStatement(
new CodeBinaryOperatorExpression(creatorVarRef, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)),
new [] { argNullEx }
);
method.Statements.Add(ifCreatorNull);
// field = creator ();
method.Statements.Add(new CodeAssignStatement(fieldVarRef, new CodeDelegateInvokeExpression(creatorVarRef)));
// return field;
method.Statements.Add(new CodeMethodReturnStatement(fieldVarRef));
return(method);
}
private static void PrintThrowExceptionStatement(TextWriter output, CodeThrowExceptionStatement statement)
{
output.Write("throw ");
if (statement.ToThrow != null)
{
PrintExpression(output, statement.ToThrow);
}
}
public static void ReplaceType(this CodeThrowExceptionStatement statement, string oldType, string newType)
{
if (statement == null)
{
return;
}
statement.ToThrow.ReplaceType(oldType, newType);
}
/// <summary>
/// Inspects the specified code unit.
/// </summary>
/// <param name="unit">The code unit.</param>
/// <param name="ns">The code namespace declaration.</param>
/// <param name="type">The code type declaration.</param>
/// <param name="executeMethod">The code method declaration for the Execute method.</param>
public void Inspect(CodeCompileUnit unit, CodeNamespace ns, CodeTypeDeclaration type, CodeMemberMethod executeMethod)
{
var statement = new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
new CodeTypeReference(typeof(System.InvalidOperationException)), new CodeExpression[] {}));
executeMethod.Statements.Insert(0, statement);
}
private bool HandleDynamic(CodeThrowExceptionStatement obj, Context ctx)
{
return(HandleIfTrue(() =>
{
ctx.Writer.Write($"{ThrowKeyword} ");
ctx.HandlerProvider.ExpressionHandler.Handle(obj.ToThrow, ctx);
}, obj, ctx, !string.IsNullOrEmpty(ThrowKeyword)));
}
// Generate a codedom throw statement
public static CodeStatement Emit(Throw th)
{
var codeThrow = new CodeThrowExceptionStatement();
codeThrow.ToThrow = CodeDomEmitter.EmitCodeExpression(th.ChildExpressions[0]);
return(codeThrow);
}
public void Constructor1_Deny_Unrestricted()
{
CodeExpression to_throw = new CodeExpression();
CodeThrowExceptionStatement ctes = new CodeThrowExceptionStatement(to_throw);
Assert.AreSame(to_throw, ctes.ToThrow, "ToThrow");
ctes.ToThrow = new CodeExpression();
}
private static void GenerateConstructors(Type t, CodeTypeDeclaration codeType)
{
CodeFieldReferenceExpression omObjectFieldReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), OmObject);
ConstructorInfo[] constructors = t.GetConstructors();
ConstructorInfo publicParameterless = null;
ConstructorInfo publicSystemParams = null;
ConstructorInfo publicEnumParams = null;
List <ConstructorInfo> publicGeneralParams = new List <ConstructorInfo>();
foreach (ConstructorInfo con in constructors.Where(c => c.IsPublic || c.IsStatic))
{
ParameterInfo[] parameters = con.GetParameters();
if (parameters == null || parameters.Length == 0)
{
publicParameterless = con;
}
else if (con.IsStatic)
{
}
else
{
publicGeneralParams.Add(con);
}
}
if (publicParameterless != null)
{
CodeConstructor constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public;
CodeObjectCreateExpression createExpression = new CodeObjectCreateExpression(t);
constructor.Statements.Add(new CodeAssignStatement(omObjectFieldReference, createExpression));
codeType.Members.Add(constructor);
}
foreach (ConstructorInfo c in publicGeneralParams)
{
AddConstructorWithCopiedParameters(codeType, t, omObjectFieldReference, c);
}
// Default internal constructor that accepts the OM object to wrap
CodeConstructor defaultConstructor = new CodeConstructor();
defaultConstructor.Attributes = MemberAttributes.Assembly;
CodeParameterDeclarationExpression omObjectParameter = new CodeParameterDeclarationExpression(t, OmObject);
defaultConstructor.Parameters.Add(omObjectParameter);
CodeArgumentReferenceExpression omObjectArgumentReference = new CodeArgumentReferenceExpression(OmObject);
CodeObjectCreateExpression createException = new CodeObjectCreateExpression(typeof(ArgumentNullException), new CodePrimitiveExpression(OmObject));
CodeThrowExceptionStatement throwException = new CodeThrowExceptionStatement(createException);
CodeBinaryOperatorExpression nullCheck = new CodeBinaryOperatorExpression(omObjectArgumentReference, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
// if the parameter is null, throw an exception
defaultConstructor.Statements.Add(new CodeConditionStatement(nullCheck, throwException));
defaultConstructor.Statements.Add(new CodeAssignStatement(omObjectFieldReference, omObjectArgumentReference));
codeType.Members.Add(defaultConstructor);
}
public override object Visit(ThrowStatement throwStatement, object data)
{
CodeThrowExceptionStatement throwStmt = new CodeThrowExceptionStatement((CodeExpression)throwStatement.Expression.AcceptVisitor(this, data));
// Add Statement to Current Statement Collection
AddStmt(throwStmt);
return(throwStmt);
}
public static CodeThrowExceptionStatement ThrowExceptionStatement(CodeExpression toThrow, CodeDirective[] startDirectives, CodeDirective[] endDirectives, CodeLinePragma linePragma)
{
var result = new CodeThrowExceptionStatement(toThrow);
result.StartDirectives.AddRange(startDirectives);
result.EndDirectives.AddRange(endDirectives);
result.LinePragma = linePragma;
return(result);
}
public TypescriptThrowExceptionStatement(
IExpressionFactory expressionFactory,
CodeThrowExceptionStatement statement,
CodeGeneratorOptions options)
{
_expressionFactory = expressionFactory;
_statement = statement;
_options = options;
}
private void GenerateThrowExceptionStatement(CodeThrowExceptionStatement e)
{
output.Write("throw");
if (e.ToThrow != null)
{
output.Write(" ");
GenerateExpression(e.ToThrow);
}
output.WriteLine(";");
}
private CodeThrowExceptionStatement CreateNotImplementedStatement()
{
CodeThrowExceptionStatement result =
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
new CodeTypeReference(typeof(System.NotImplementedException)),
new CodeExpression[] {}));
return(result);
}
protected override void GenerateThrowExceptionStatement(CodeThrowExceptionStatement statement)
{
Output.Write("raise");
if (statement.ToThrow != null)
{
Output.Write(' ');
GenerateExpression(statement.ToThrow);
}
Output.WriteLine();
}
private static void ReplaceControlCreateStatement(Type ctrlType, CodeAssignStatement objAssignStatement, CodeStatementCollection statements)
{
/* Generate code like below
*
* IServiceProvider __activator = HttpRuntime.WebObjectActivator;
*
* if (activator != null) {
* _ctrl = (ctrlType)activator.GetService(ctrlType);
* }
*
* // if default c-tor exists
* else {
* _ctrl = new ....
* }
* // if no default c-tor
* else {
* throw new InvalidOperationException(SR.GetString(SR.Could_not_create_type_instance, ctrlType))
* }
*
*/
var webObjectActivatorExpr = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("System.Web.HttpRuntime"), "WebObjectActivator");
var activatorRefExpr = new CodeVariableReferenceExpression("__activator");
var getServiceExpr = new CodeMethodInvokeExpression(webObjectActivatorExpr, "GetService", new CodeTypeOfExpression(ctrlType));
var castExpr = new CodeCastExpression(new CodeTypeReference(ctrlType), getServiceExpr);
var createObjectStatement = new CodeConditionStatement()
{
Condition = new CodeBinaryOperatorExpression(activatorRefExpr,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null))
};
createObjectStatement.TrueStatements.Add(new CodeAssignStatement(objAssignStatement.Left, castExpr));
// If default c-tor exists
if (DoesTypeHaveDefaultCtor(ctrlType))
{
createObjectStatement.FalseStatements.Add(objAssignStatement);
}
else
{
var throwExceptionStatement = new CodeThrowExceptionStatement(new CodeObjectCreateExpression(
new CodeTypeReference(typeof(System.InvalidOperationException)),
new CodeExpression[] { new CodePrimitiveExpression(SR.GetString(SR.Could_not_create_type_instance, ctrlType)) }));
createObjectStatement.FalseStatements.Add(throwExceptionStatement);
}
// replace the old assign statement
var indexOfStatement = statements.IndexOf(objAssignStatement);
statements.Insert(indexOfStatement, createObjectStatement);
statements.Insert(indexOfStatement, new CodeAssignStatement(activatorRefExpr, webObjectActivatorExpr));
statements.Insert(indexOfStatement, new CodeVariableDeclarationStatement(typeof(IServiceProvider), "__activator"));
statements.Remove(objAssignStatement);
}
private void Generate(CodeThrowExceptionStatement statement)
{
this.Write("throw ");
if (statement.ToThrow != null)
{
this.Generate(statement.ToThrow);
}
this.WriteLine(";");
}
static bool WriteCodeThrowExceptionStatement(CodeThrowExceptionStatement throwExceptionStatement, TextWriter w, CodeGeneratorOptions o)
{
if (throwExceptionStatement == null)
{
return(false);
}
w.Write(o.IndentString + "throw ");
GenerateCodeFromExpression(throwExceptionStatement.ToThrow, w, o);
return(true);
}
public void CodeThrowExceptionStatementTest()
{
CodeThrowExceptionStatement ctet = new CodeThrowExceptionStatement();
statement = ctet;
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"Throw{0}", NewLine), Generate(), "#1");
ctet.ToThrow = new CodeSnippetExpression("whatever");
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"Throw whatever{0}", NewLine), Generate(), "#2");
}
/// <summary>
/// body of public PropertyBufferPtr GetProperty(string bufferName, string varNameInShader)
/// </summary>
/// <param name="method"></param>
private void GetPropertyBody(CodeMemberMethod method, DataStructure dataStructure)
{
foreach (var item in dataStructure.PropertyList)
{
// if (bufferName == position)
var ifStatement = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression(bufferName),
CodeBinaryOperatorType.IdentityEquality,
new CodeVariableReferenceExpression(item.NameInModel)));
method.Statements.Add(ifStatement);
// if (positionBufferPtr != null)
var ifStatement2 = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression(item.BufferPtrName),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)));
ifStatement.TrueStatements.Add(ifStatement2);
// using (var buffer = new PropertyBuffer<vec3>(varNameInShader))
var usingBegin = new CodeSnippetStatement(string.Format(" using(var buffer = new PropertyBuffer<{0}>({1}))", item.PropertyType, varNameInShader));
ifStatement2.TrueStatements.Add(usingBegin);
ifStatement2.TrueStatements.Add(new CodeSnippetStatement(" {// begin of using"));
var create = new CodeSnippetStatement(" buffer.Create();");
ifStatement2.TrueStatements.Add(create);
// unsafe {
ifStatement2.TrueStatements.Add(new CodeSnippetStatement(" unsafe"));
ifStatement2.TrueStatements.Add(new CodeSnippetStatement(" {// begin of unsafe"));
// var array = (vec3*)buffer.Header.ToPointer();
ifStatement2.TrueStatements.Add(new CodeSnippetStatement(string.Format(" var array = ({0}*)buffer.Header.ToPointer();", item.PropertyType)));
// array[0] = ...;;
ifStatement2.TrueStatements.Add(new CodeSnippetStatement(string.Format(" // TODO: set array's values: array[0] = ...;")));
// }
ifStatement2.TrueStatements.Add(new CodeSnippetStatement(" }// end of unsafe"));
ifStatement2.TrueStatements.Add(new CodeSnippetStatement(string.Format(" {0} = buffer.GetBufferPtr() as PropertyBufferPtr;", item.BufferPtrName)));
ifStatement2.TrueStatements.Add(new CodeSnippetStatement(" }// end of using"));
ifStatement.TrueStatements.Add(new CodeMethodReturnStatement(
new CodeVariableReferenceExpression(item.BufferPtrName)));
}
// throw new NotImplementedException();
{
// This CodeThrowExceptionStatement throws a new System.Exception.
var throwException = new CodeThrowExceptionStatement(
// codeExpression parameter indicates the exception to throw.
// You must use an object create expression to new an exception here.
new CodeObjectCreateExpression(
// createType parameter inidicates the type of object to create.
new CodeTypeReference(typeof(System.ArgumentException)),
// parameters parameter indicates the constructor parameters.
new CodeExpression[] { new CodePrimitiveExpression(bufferName) }));
method.Statements.Add(throwException);
}
}
protected override void GenerateThrowExceptionStatement
(CodeThrowExceptionStatement e)
{
if (e.ToThrow != null)
{
Output.Write("throw ");
GenerateExpression(e.ToThrow);
Output.WriteLine(";");
}
else
{
Output.WriteLine("throw;");
}
}
public static CodeThrowExceptionStatement Clone(this CodeThrowExceptionStatement statement)
{
if (statement == null)
{
return(null);
}
CodeThrowExceptionStatement s = new CodeThrowExceptionStatement();
s.EndDirectives.AddRange(statement.EndDirectives);
s.LinePragma = statement.LinePragma;
s.StartDirectives.AddRange(statement.StartDirectives);
s.ToThrow = statement.ToThrow.Clone();
s.UserData.AddRange(statement.UserData);
return(s);
}
private void GenerateThrowExceptionStatement(CodeThrowExceptionStatement e)
{
Output.Write("throw");
if (e.ToThrow != null)
{
Output.Write(" ");
GenerateExpression(e.ToThrow);
}
Output.WriteLine(";");
}
public void Visit(CodeThrowExceptionStatement o)
{
g.GenerateThrowExceptionStatement(o);
}
protected override void GenerateThrowExceptionStatement
(CodeThrowExceptionStatement e)
{
if(e.ToThrow != null)
{
Output.Write("throw ");
GenerateExpression(e.ToThrow);
Output.WriteLine(";");
}
else
{
Output.WriteLine("throw;");
}
}
protected override void GenerateThrowExceptionStatement
(CodeThrowExceptionStatement e)
{
CodeExpression expr = e.ToThrow;
if(expr == null)
{
Output.WriteLine("Throw");
}
else
{
Output.Write("Throw ");
GenerateExpression(expr);
Output.WriteLine();
}
}
internal CodeThrowExceptionStatement Throw(CodeExpression codeExpression)
{
var t = new CodeThrowExceptionStatement(codeExpression);
Scope.Add(t);
return t;
}
private void ValidateThrowExceptionStatement(CodeThrowExceptionStatement e)
{
if (e.ToThrow != null)
{
ValidateExpression(e.ToThrow);
}
}
protected abstract void GenerateThrowExceptionStatement(CodeThrowExceptionStatement e);
internal CodeThrowExceptionStatement Throw()
{
var t = new CodeThrowExceptionStatement();
Scope.Add(t);
return t;
}