[svn] r7613: vs-plugin/trunk/Nemerle.Compiler.Utils:
FormCodeDomParser.n Nemerle.Completion2/Engine/Engine...
VladD2
svnadmin at nemerle.org
Mon Apr 23 11:30:06 CEST 2007
Log:
Work on CodeDomParser (WinForms designer).
Author: VladD2
Date: Mon Apr 23 11:30:04 2007
New Revision: 7613
Modified:
vs-plugin/trunk/Nemerle.Compiler.Utils/FormCodeDomParser.n
vs-plugin/trunk/Nemerle.Compiler.Utils/Nemerle.Completion2/Engine/Engine.Properties.n
vs-plugin/trunk/Nemerle.Compiler.Utils/NemerleCodeParser.n
Modified: vs-plugin/trunk/Nemerle.Compiler.Utils/FormCodeDomParser.n
==============================================================================
--- vs-plugin/trunk/Nemerle.Compiler.Utils/FormCodeDomParser.n (original)
+++ vs-plugin/trunk/Nemerle.Compiler.Utils/FormCodeDomParser.n Mon Apr 23 11:30:04 2007
@@ -213,28 +213,6 @@
protected mutable cachedObjs : NC.Hashtable[string,CodeExpression];
- protected override CreateStatements(expr : TExpr, statements: CodeStatementCollection) : void
- {
- | (TExpr.DefValIn(name,val,body),_) // name : LocalValue; val : TExpr; mutable body : TExpr; }
- when (name.Name.StartsWith("_N_cached_obj")) =>
- def initExpr = CreateExpression(val);
- cachedObjs.Add(name.Name,initExpr);
- // TODO: Should we include temporary object declaration?
- //_ = statements.Add( CodeVariableDeclarationStatement(name.Type.SystemType, name.Name, initExpr) );
- CreateStatements(body,statements);
-
- | _ =>
- base.CreateStatements(expr,statements);
- }
-
- protected override CreateExpression(expr : TExpr) : CodeExpression
- {
- | TExpr.LocalRef(decl) when (decl.Name.StartsWith("_N_cached_obj")) => //{ decl : LocalValue; }
- cachedObjs[decl.Name]
- | _ =>
- base.CreateExpression(expr)
- }
-
#endregion
}
}
Modified: vs-plugin/trunk/Nemerle.Compiler.Utils/Nemerle.Completion2/Engine/Engine.Properties.n
==============================================================================
--- vs-plugin/trunk/Nemerle.Compiler.Utils/Nemerle.Completion2/Engine/Engine.Properties.n (original)
+++ vs-plugin/trunk/Nemerle.Compiler.Utils/Nemerle.Completion2/Engine/Engine.Properties.n Mon Apr 23 11:30:04 2007
@@ -65,7 +65,8 @@
[Accessor] static _topKeywords : array[CompletionElem];
[Accessor] static _expressionDefaultKeywords : array[CompletionElem];
static _expressionKeywords : array[string]
- = array["mutable", "def", "array", "true", "false", "null", "#if", "#region"];
+ = array["mutable", "typeof", "def", "array", "true", "false", "null", "throw",
+ "#if", "#region"];
#pragma warning disable 618 // Obsolete
public Project : Project
Modified: vs-plugin/trunk/Nemerle.Compiler.Utils/NemerleCodeParser.n
==============================================================================
--- vs-plugin/trunk/Nemerle.Compiler.Utils/NemerleCodeParser.n (original)
+++ vs-plugin/trunk/Nemerle.Compiler.Utils/NemerleCodeParser.n Mon Apr 23 11:30:04 2007
@@ -238,24 +238,44 @@
_currentMethod = method;
method.EnsureCompiled(); // we need PExpr & TExpr
-
- match(methodDecl)
- {
- | m is CodeConstructor => CreateCtorStatements(m, method.BodyTyped);
- | _ =>
methodDecl.Statements.AddRange(ToStatements(method.BodyParsed).ToArray());
- }
Debug.Print($" method.BodyTyped.Location (col = $(method.BodyTyped.Location.Column), line = $(method.BodyTyped.Location.Line))");
methodDecl
}
+
ToTypeRefExpression(typeInfo : Nemerle.Compiler.TypeInfo, typeParaams : list[TyVar]) : CodeTypeReferenceExpression
{
CodeTypeReferenceExpression(ToTypeRef(typeInfo, typeParaams))
}
+ ToTypeRef(tyVar : TyVar) : CodeTypeReference
+ {
+ def ty = tyVar.Fix();
+
+ if (ty.IsFixed)
+ {
+ def makeTypeArgs(args) { args.MapToArray(ToTypeRef) }
+
+ match (ty)
+ {
+ | Class(tycon, args) => ToTypeRef(tycon, args)
+ | TyVarRef(tyvar) => CodeTypeReference(tyvar.Name)
+ | Fun(_from, _to) => CodeTypeReference(typeof(object)) // HACK: Not supported by C#
+ | Tuple(args) =>
+ CodeTypeReference("Nemerle.Builtins.Tuple", makeTypeArgs(args))
+ | Array(tyVar, rank) => CodeTypeReference(ToTypeRef(tyVar), rank)
+ | Void => CodeTypeReference(typeof(void))
+ | Ref(_tyVar)
+ | Out(_tyVar) => throw ApplicationException("Ref/Out not supported")
+ | Intersection(_types) => CodeTypeReference(typeof(object))
+ }
+ }
+ else CodeTypeReference(typeof(object))
+ }
+
ToTypeRef(typeInfo : Nemerle.Compiler.TypeInfo, typeParaams : list[TyVar]) : CodeTypeReference
{
Trace.Assert(typeInfo.TyparmsCount == 0); // TODO: Add support for type parametrs!
@@ -269,23 +289,30 @@
protected virtual ToExpression(expr : PExpr) : CodeExpression
{
- def createBinOper(expr1, op, expr2)
+ match (expr)
{
+ | <[ $expr1 && $expr2 ]> with op = BooleanAnd
+ | <[ $expr1 || $expr2 ]> with op = BooleanOr
+ | <[ $expr1 != $expr2 ]> with op = IdentityInequality
+ | <[ $expr1 == $expr2 ]> with op = IdentityEquality
+ | <[ $expr1 & $expr2 ]> with op = BitwiseAnd
+ | <[ $expr1 | $expr2 ]> with op = BitwiseOr
+ | <[ $expr1 + $expr2 ]> with op = Add
+ | <[ $expr1 - $expr2 ]> with op = Subtract
+ | <[ $expr1 / $expr2 ]> with op = Divide
+ | <[ $expr1 * $expr2 ]> with op = Multiply =>
CodeBinaryOperatorExpression(ToExpression(expr1), op, ToExpression(expr2))
- }
- match (expr)
- {
- | <[ $expr1 && $expr2 ]> => createBinOper(expr1, BooleanAnd, expr2);
- | <[ $expr1 || $expr2 ]> => createBinOper(expr1, BooleanOr, expr2);
- | <[ $expr1 != $expr2 ]> => createBinOper(expr1, IdentityInequality, expr2);
- | <[ $expr1 == $expr2 ]> => createBinOper(expr1, IdentityEquality, expr2);
- | <[ $expr1 & $expr2 ]> => createBinOper(expr1, BitwiseAnd, expr2);
- | <[ $expr1 | $expr2 ]> => createBinOper(expr1, BitwiseOr, expr2);
- | <[ $expr1 + $expr2 ]> => createBinOper(expr1, Add, expr2);
- | <[ $expr1 - $expr2 ]> => createBinOper(expr1, Subtract, expr2);
- | <[ $expr1 / $expr2 ]> => createBinOper(expr1, Divide, expr2);
- | <[ $expr1 * $expr2 ]> => createBinOper(expr1, Multiply, expr2);
+ | <[ array[..$parms] ]> as ary =>
+ def tExpr = ary.TypedObject :> TExpr;
+ match (tExpr)
+ {
+ | TExpr.Array(_args, dimensions) =>
+ Trace.Assert(dimensions is [_]);
+ CodeArrayCreateExpression(
+ ToTypeRef(tExpr.MType), parms.MapToArray(ToExpression))
+ | _ => NotSuportedExpression(ary)
+ }
| <[ $obj.$func(..$parms) ]> as call =>
_ = call;
@@ -313,17 +340,20 @@
| <[ $obj.$prop ]> when prop.TypedObject is IProperty =>
CodePropertyReferenceExpression(ToExpression(obj), prop.TypedObject.Name);
- | <[ $_.$_ ]> as mem when mem.TypedObject is TExpr =>
+ | <[ $obj.$_ ]> as mem when mem.TypedObject is TExpr =>
match (mem.TypedObject)
{
| TExpr.StaticRef(_from, mem, type_parms) when mem.IsStatic =>
CodeFieldReferenceExpression(
ToTypeRefExpression(mem.DeclaringType, type_parms), mem.Name)
- //| TExpr.MethodRef(obj, meth, _type_parms, _notvirtual) =>
- // ToExpression(obj), meth.Name
-
- | xxx => _ = xxx; NotSuportedExpression(expr)
+ | TExpr.MethodRef(_tObj, meth, typeParms, _notvirtual) =>
+ CodeMethodReferenceExpression(ToExpression(obj), meth.Name,
+ typeParms.MapToArray(param => ToTypeRef(param)))
+
+ | xxx =>
+ _ = xxx;
+ NotSuportedExpression(expr)
}
| PExpr.Ref(name) => CodeVariableReferenceExpression(name.ToString())
@@ -344,8 +374,13 @@
CodeFieldReferenceExpression(CodeTypeReferenceExpression(ty.FullName), field.Name)
}
+ | <[ $sourceExpr :> $_ ]> =>
+ def tExpr = expr.TypedObject :> TExpr.TypeConversion;
+ CodeCastExpression(ToTypeRef(tExpr.MType), ToExpression(sourceExpr))
+
| <[ base ]> => CodeBaseReferenceExpression()
| <[ this ]> => CodeThisReferenceExpression()
+ | <[ typeof($typeExpr) ]> => CodeTypeOfExpression(typeExpr.ToString()) // TODO: Test it
| null => CodeSnippetExpression("");
| _ => NotSuportedExpression(expr)
}
@@ -353,7 +388,7 @@
NotSuportedExpression(expr : PExpr) : CodeExpression
{
- Debug.Assert(false, $"Not suported expression: '$expr' ($(expr.GetType().Name))");
+ Debug.WriteLine($"[Form Designer]: Not suported expression: '$expr' ($(expr.GetType().Name))");
CodeSnippetExpression(expr.ToString())
}
@@ -390,345 +425,5 @@
| _ => yield CodeExpressionStatement(ToExpression(expr))
}
}
-
- protected virtual CreateStatement(expr : TExpr) : CodeStatement
- {
- Debug.Print($" CreateStatement : from expr of type $(expr.GetType())");
-
- match(expr) // TODO: this is temporary
- {
- | TExpr.Assign(target,source) => // target : TExpr; source : TExpr; }
- CodeAssignStatement(CreateExpression(target), CreateExpression(source))
-
- | TExpr.Call(func,parms,_) when(parms.Length == 1) =>// mutable func : TExpr; mutable parms : list [Parm]; _ }
- def s = TryCreateEventAction(func,parms);
- if (s != null) s else CodeExpressionStatement(CreateExpression(expr))// standard way
-
- | TExpr.Throw(exn) => // exn : TExpr; }
- CodeThrowExceptionStatement(CreateExpression(exn))
-
- | TExpr.TryFinally(body,handler) => // body : TExpr; handler : TExpr; }
- match(body)
- {
- | TExpr.Try(body,cases) =>
- CodeTryCatchFinallyStatement( CreateStatements(body),
- cases.MapToArray( CreateCatchClause(_) ),
- CreateStatements(handler))
- | _ =>
- CodeTryCatchFinallyStatement( CreateStatements(body),
- null,
- CreateStatements(handler))
- }
-
-
- | TExpr.Try(body,cases) => // body : TExpr; mutable cases : list [Try_case]; }
- CodeTryCatchFinallyStatement( CreateStatements(body),
- cases.MapToArray( CreateCatchClause(_) ),
- null)
-
- /*
- | TExpr.OpCode // name : string; }
- */
- | TExpr.MacroEnvelope as expr => // original : Parsetree.PExpr; the_macro : IMacro; expanded : TExpr; }
- ProcessMacroStatement(expr)
-
- | TExpr.If(cond, e_then, e_else) => // { cond : TExpr; e_then : TExpr; e_else : TExpr; }
- CodeConditionStatement(CreateExpression(cond),
- CreateStatements(e_then),
- CreateStatements(e_else))
-
- | _ =>
- CodeExpressionStatement(CreateExpression(expr))
- /*{ Debug.Print($"Ignored: expr of type $(expr.GetType()) = $expr ");
- CodeCommentStatement("dummy") }
- */
- }
-
- //CodeCommentStatement("dummy")
- }
-
- protected CreateParamsArray(parms : list [Parm]) : array[CodeExpression]
- {
- | [] => array[CodeSnippetExpression("")]
- | _ => parms.MapToArray(p => CreateExpression(p.expr));
- }
-
- protected CreateCtorStatements(ctor : CodeConstructor, expr : TExpr) : void
- {
- // TODO : now base(..) or this(...) constructor calls are supposed to be the first calls
- // in the ctor body.
- match(expr)
- {
- | TExpr.Sequence(e1,e2) =>
- { CreateCtorStatements(ctor,e1); CreateStatements(e2,ctor.Statements); }
- | TExpr.Call(func,parms,_) when (func is TExpr.Base) =>
- ctor.BaseConstructorArgs.AddRange(CreateParamsArray(parms));
- | TExpr.Call(func,parms,_) when (func is TExpr.This) =>
- ctor.ChainedConstructorArgs.AddRange(CreateParamsArray(parms));
- | _ =>
- CreateStatements(expr,ctor.Statements);
- }
- }
-
- protected virtual CreateStatements(expr : TExpr, statements: CodeStatementCollection) : void
- {
- match(expr)
- {
- | TExpr.Sequence(e1,e2) =>
- { CreateStatements(e1,statements); CreateStatements(e2,statements); }
-
- | TExpr.MacroEnvelope(original,the_macro,_) as expr => // original : Parsetree.PExpr; the_macro : IMacro; expanded : TExpr; }
- // TODO: may be ignore or make code snippet?
- Debug.Print($"--Expanding macro $(CodeDomHelper.PrintMacro(the_macro)),\n--- original:$original");
- ProcessMacroStatements(expr,statements)
- //CreateStatements(expanded,statements);
-
- | TExpr.DefValIn(name,val,body) => // name : LocalValue; val : TExpr; mutable body : TExpr; }
- _ = statements.Add( CodeVariableDeclarationStatement(name.Type.SystemType, name.Name, CreateExpression(val)) );
- CreateStatements(body,statements);
-
- | _ =>
- _ = statements.Add(CreateStatement(expr))
- }
- }
-
- protected virtual ProcessMacroStatements(macroEnvelope : TExpr.MacroEnvelope, statements: CodeStatementCollection) : void
- {
- | (TExpr.MacroEnvelope(original,the_macro,expanded),_) => // original : Parsetree.PExpr; the_macro : IMacro; expanded : TExpr; }
- Debug.Print($" ProcessMacroStatements ($(the_macro.GetName())) :\n original=$original,\n"
- "expanded = $expanded\n");
- CreateStatements(expanded,statements)
- }
-
- protected CreateStatements(expr : TExpr) : array[CodeStatement]
- {
- def statements = CodeStatementCollection();
- CreateStatements(expr,statements);
- def statementsArray = array(statements.Count);
- statements.CopyTo(statementsArray, 0);
- statementsArray
- }
-
- protected TryCreateEventAction(func : TExpr, parms : list[Parm]) : CodeStatement
- {
- def eventActionAndName(name)
- {
- Debug.Print($"Checking for event attachment for $func Name = $name");
- regexp match(name)
- {
- | @"add_(?<name>\w+)" =>
- Debug.Print($"Looks like we've found an event attachment: $name");
- ("add",name)
-
- | @"remove_(?<name>\w+)" =>
- Debug.Print($"Looks like we've found an event remove: $name");
- ("remove",name)
-
- | _ =>
- (null,null)
- }
- }
-
- def (objType,obj,(eventAction,eventName)) = match(func)
- {
- | TExpr.StaticRef(from,mem,_) when (mem is IMethod) =>
- (from.SystemType,
- lazy(CodeTypeReferenceExpression(from.SystemType)),
- eventActionAndName(mem.Name))
-
- // TODO: Are typed events possible?
- | TExpr.MethodRef(obj,meth,_,_) => // obj : TExpr; meth : IMethod; type_parms : list [TyVar]; _; }
- (obj.SystemType,
- lazy(CreateExpression(obj)),
- eventActionAndName(meth.Name))
-
- | _ => (null,null,(null,null))
- }
- if (eventAction != null && objType.GetEvent(eventName) != null)
- if (eventAction == "add")
- CodeAttachEventStatement(obj, eventName, CreateExpression(parms.Head.expr))
- else // eventAction == "remove"
- CodeRemoveEventStatement(obj, eventName, CreateExpression(parms.Head.expr))
- else null
- }
-
- protected virtual ProcessMacroStatement(macroEnvelope : TExpr.MacroEnvelope) : CodeStatement
- {
- | (original,the_macro,expanded) => // original : Parsetree.PExpr; the_macro : IMacro; expanded : TExpr; }
- Debug.Print($" ProcessMacroStatement ($(the_macro.GetName())) :\n original=$original,\n"
- "expanded = $expanded\n");
- CreateStatement(expanded)
- }
-
- protected virtual CreateExpression(expr : TExpr) : CodeExpression
- {
- Debug.Print($" CreateExpression : from expr of type $(expr.GetType())");
-
- match(expr) // TODO: this is temporary
- {
- | TExpr.StaticRef(from,mem,type_parms) => //{ from : MType.Class; mem : IMember; type_parms : list [TyVar]; }
- match(mem)
- {
- | mem is TypeInfo =>
- Debug.Print($"TypeInfo of type $(mem.SystemType)");
- CodeTypeReferenceExpression(mem.SystemType) // TODO - does it always work?
- | _ =>
- {
- def classType = CodeTypeReferenceExpression(from.SystemType);
- match(mem)
- {
- | mem is IMethod =>
- CodeMethodReferenceExpression(classType,
- mem.Name,
- type_parms.MapToArray(t => CodeTypeReference(t.SystemType)))
- | mem is IField =>
- CodeFieldReferenceExpression(classType, mem.Name)
- | mem is IEvent =>
- CodeEventReferenceExpression(classType, mem.Name)
- | mem is IProperty =>
- CodePropertyReferenceExpression(classType, mem.Name)
- | _ =>
- throw CodeDomSerializerException($"TExpr.StaticRef member $mem is of unknown type",
- CodeLinePragma(mem.Location.File,mem.Location.Line));
- }
- }
- }
-
- | TExpr.LocalRef(decl) => //{ decl : LocalValue; }
- // TODO: is it always correct?
- if(decl.Name == "_N_closurised_this_ptr") CodeThisReferenceExpression ()
- else CodeVariableReferenceExpression(decl.Name)
-
- // | TExpr.ImplicitValueTypeCtor
- | TExpr.FieldMember(obj,fld) => // obj : TExpr; fld : IField; }
- CodeFieldReferenceExpression(CreateExpression(obj), fld.Name)
-
- | TExpr.MethodRef(obj,meth,type_parms,_) => // obj : TExpr; meth : IMethod; type_parms : list [TyVar]; notvirtual : bool; }
- CodeMethodReferenceExpression(CreateExpression(obj),
- meth.Name,
- type_parms.MapToArray(t => CodeTypeReference(t.SystemType)))
-
- | TExpr.Call(func,parms,_) => // mutable func : TExpr; mutable parms : list [Parm]; mutable is_tail : bool; }
- Debug.Print($"TExpr.Call of $func of type $(func.GetType().ToString()) with params $parms");
- def parmArray = parms.MapToArray(p => CreateExpression(p.expr));
- match(func)
- {
- | TExpr.StaticRef(from,mem,_) when(mem.Name == ".ctor") =>
- CodeObjectCreateExpression(from.SystemType, parmArray)
- | op is TExpr.OpCode when(parmArray.Length == 2) => // name : string; }
- CreateBinaryOperator(op,parmArray)
- | _ =>
- CodeMethodInvokeExpression(CreateExpression(func) :> CodeMethodReferenceExpression, parmArray)
- }
-
- | TExpr.Literal(val) => // val : Nemerle.Compiler.Literal; }
- if(val is Literal.Void) CodeSnippetExpression("") else
- CodePrimitiveExpression(val.AsObject(_manager.InternalType))
-
- | TExpr.This =>
- CodeThisReferenceExpression()
-
- | TExpr.Base => // base_ctor : IMethod; }
- CodeBaseReferenceExpression()
-
- | TExpr.TypeConversion(expr,target_type,_,_) => // mutable expr : TExpr; target_type : TyVar; kind : ConversionKind; target_type_location : Location; }
- CodeCastExpression(target_type.SystemType, CreateExpression(expr)) // TODO: what about kind?
-
- /*
- | TExpr.Tuple // args : list [TExpr]; }
- */
-
- | TExpr.Array(args,dimensions) => // args : list [TExpr]; dimensions : list [TExpr]; }
- {
- def elemType = (expr.Type.Fix() :> MType.Array).t.SystemType;
- if (args != [])
- CodeArrayCreateExpression( elemType,
- args.MapToArray(CreateExpression(_)))
- else match(dimensions)
- {
- | [dim] => CodeArrayCreateExpression(elemType,CreateExpression(dim))
- | [] =>
- throw CodeDomSerializerException("Array is 0-dimensional!",
- CodeDomHelper.GetLinePragma(expr));
- | _ =>
- throw CodeDomSerializerException("CodeDom doesn't support multidimensional arrays!",
- CodeDomHelper.GetLinePragma(expr));
- }
- }
-
- | TExpr.TypeOf(target_type) => // target_type : TyVar; }
- CodeTypeOfExpression( target_type.SystemType )
-
- | TExpr.ArrayIndexer(obj,args) => // obj : TExpr; args : list [TExpr]; }
- if (obj.Type.Fix() is MType.Array)
- CodeArrayIndexerExpression(CreateExpression(obj), args.MapToArray( CreateExpression(_)))
- else
- CodeIndexerExpression(CreateExpression(obj), args.MapToArray( CreateExpression(_)))
-
- /*
- | TExpr.TupleIndexer // obj : TExpr; pos : int; len : int; } // 0-based
- | TExpr.OpCode // name : string; }
- */
- | TExpr.MacroEnvelope as expr => // original : Parsetree.PExpr; the_macro : IMacro; expanded : TExpr; }
- ProcessMacroExpression(expr)
-
- | _ =>
- {Debug.Print($"Ignored: expr of type $(expr.GetType()) = $expr,\n--Creating CodeSnippet ");
- CodeSnippetExpression($"$expr") }
- }
- }
-
- protected virtual ProcessMacroExpression(macroEnvelope : TExpr.MacroEnvelope) : CodeExpression
- {
- | (original,the_macro,expanded) => // original : Parsetree.PExpr; the_macro : IMacro; expanded : TExpr; }
- Debug.Print($" ProcessMacroExpression ($(the_macro.GetName())) :\n original=$original,\n"
- "expanded = $expanded\n");
- CreateExpression(expanded)
- }
-
- protected CreateCatchClause(tryCase: Try_case) : CodeCatchClause
- {
- // TODO : is this the right interpretation?
- | Fault(handler) => //{ handler : TExpr; }
- CodeCatchClause("ex",CodeTypeReference(typeof(System.Exception)),CreateStatements(handler))
-
- | Catch(exn, handler) => // { exn : LocalValue; handler : TExpr; }
- CodeCatchClause(exn.Name,CodeTypeReference(exn.Type.SystemType),CreateStatements(handler))
-
- | Filter(exn, filter, handler) => // { exn : LocalValue; filter : TExpr; handler : TExpr; }
- Debug.WriteLine($"Ignored: Try_case.Filter( $exn, $filter, $handler )");
- CodeCatchClause()
- }
-
- protected CreateBinaryOperator(op: TExpr.OpCode, parms: array[CodeExpression]): CodeBinaryOperatorExpression
- {
- CodeBinaryOperatorExpression( parms[0],
- match(op.name)
- {
- | "+" => CodeBinaryOperatorType.Add
- | "=" => CodeBinaryOperatorType.Assign
- | "&" => CodeBinaryOperatorType.BitwiseAnd
- | "|" => CodeBinaryOperatorType.BitwiseOr
- | "&&" => CodeBinaryOperatorType.BooleanAnd
- | "||" => CodeBinaryOperatorType.BooleanOr
- | @"\" => CodeBinaryOperatorType.Divide
- | ">" => CodeBinaryOperatorType.GreaterThan
- | ">=" => CodeBinaryOperatorType.GreaterThanOrEqual
- | "==" => CodeBinaryOperatorType.IdentityEquality
- | "!=" => CodeBinaryOperatorType.IdentityInequality
- | "<" => CodeBinaryOperatorType.LessThan
- | "<=" => CodeBinaryOperatorType.LessThanOrEqual
- | "%" => CodeBinaryOperatorType.Modulus
- | "*" => CodeBinaryOperatorType.Multiply
- | "-" => CodeBinaryOperatorType.Subtract
- | "===" => CodeBinaryOperatorType.ValueEquality
- | name =>
- throw CodeDomSerializerException($"CodeDom cannot create $name operator!",
- CodeDomHelper.GetLinePragma(op));
- },
- parms[1]
- )
- }
-
}
}
More information about the svn
mailing list