public async Task<IHttpActionResult> PutMemberAccess(int id, MemberAccess memberAccess)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != memberAccess.MemberAccessNo)
{
return BadRequest();
}
db.Entry(memberAccess).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MemberAccessExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
private void BindToProperty(PropertyInfo property)
{
if (property.GetSetMethod(true) == null)
{
this.MemberAccess = MemberAccess.Create(AccessStrategy.NoSetter, TryToFindFieldNamingStrategy(property));
}
}
private async Task AddMemberAccess(string memberID, string result)
{
MemberAccess memberAccess = new MemberAccess();
memberAccess.MemberID = memberID;
memberAccess.AccessResult = result;
memberAccess.DateCreated = DateTime.Now;
db.MemberAccesses.Add(memberAccess);
await db.SaveChangesAsync();
}
public void BindToMember(MemberInfo member)
{
this.MappedMember = member;
if (member.MemberType == MemberTypes.Field)
this.MemberAccess = MemberAccess.Create(AccessStrategy.Field, NamingStrategy.None);
if(member.MemberType == MemberTypes.Property)
BindToProperty((PropertyInfo)member);
}
public async Task<IHttpActionResult> PostMemberAccess(MemberAccess memberAccess)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
db.MemberAccesses.Add(memberAccess);
await db.SaveChangesAsync();
return CreatedAtRoute("DefaultApi", new { id = memberAccess.MemberAccessNo }, memberAccess);
}
public AnimatedElement(MemberAccess member, object defaultValue)
{
this.Member = member;
this.DefaultValue = defaultValue;
Type t = defaultValue.GetType();
if (t == typeof(Color))
{
this.Tweening = new ColorTweener();
}
else if (t == typeof(Font))
{
this.Tweening = new FontTweener();
}
else
{
this.Tweening = new NumericTweener();
}
}
// TODO move to after-typing validation eventually
public EfektException ExtensionFuncHasNoParameters(Fn extFn, MemberAccess ma)
{
return(fail(extFn, "Function must accept at least 1 parameter to be an extension function."));
}
public void VisitMemberAccess(MemberAccess memberAccess)
{
memberAccess.Member.Visit(this);
}
public ArrayInitializer CreateDynamicBinderArguments(ResolveContext rc)
{
Location loc = Location.Null;
var all = new ArrayInitializer(args.Count, loc);
MemberAccess binder = DynamicExpressionStatement.GetBinderNamespace(loc);
foreach (Argument a in args)
{
Arguments dargs = new Arguments(2);
// CSharpArgumentInfoFlags.None = 0
const string info_flags_enum = "CSharpArgumentInfoFlags";
Expression info_flags = new IntLiteral(rc.BuiltinTypes, 0, loc);
if (a.Expr is Constant)
{
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "Constant", loc));
}
else if (a.ArgType == Argument.AType.Ref)
{
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "IsRef", loc));
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "UseCompileTimeType", loc));
}
else if (a.ArgType == Argument.AType.Out)
{
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "IsOut", loc));
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "UseCompileTimeType", loc));
}
else if (a.ArgType == Argument.AType.DynamicTypeName)
{
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "IsStaticType", loc));
}
var arg_type = a.Expr.Type;
if (arg_type.BuiltinType != BuiltinTypeSpec.Type.Dynamic && arg_type != InternalType.NullLiteral)
{
MethodGroupExpr mg = a.Expr as MethodGroupExpr;
if (mg != null)
{
rc.Report.Error(1976, a.Expr.Location,
"The method group `{0}' cannot be used as an argument of dynamic operation. Consider using parentheses to invoke the method",
mg.Name);
}
else if (arg_type == InternalType.AnonymousMethod)
{
rc.Report.Error(1977, a.Expr.Location,
"An anonymous method or lambda expression cannot be used as an argument of dynamic operation. Consider using a cast");
}
else if (arg_type.Kind == MemberKind.Void || arg_type == InternalType.Arglist || arg_type.IsPointer)
{
rc.Report.Error(1978, a.Expr.Location,
"An expression of type `{0}' cannot be used as an argument of dynamic operation",
arg_type.GetSignatureForError());
}
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "UseCompileTimeType", loc));
}
string named_value;
NamedArgument na = a as NamedArgument;
if (na != null)
{
info_flags = new Binary(Binary.Operator.BitwiseOr, info_flags,
new MemberAccess(new MemberAccess(binder, info_flags_enum, loc), "NamedArgument", loc));
named_value = na.Name;
}
else
{
named_value = null;
}
dargs.Add(new Argument(info_flags));
dargs.Add(new Argument(new StringLiteral(rc.BuiltinTypes, named_value, loc)));
all.Add(new Invocation(new MemberAccess(new MemberAccess(binder, "CSharpArgumentInfo", loc), "Create", loc), dargs));
}
return(all);
}
private DynamicMetaObject/*!*/ MakeMemberAccess(DynamicMetaObjectBinder/*!*/ member, string name, MemberAccess access, params DynamicMetaObject/*!*/[]/*!*/ args) {
DynamicMetaObject self = Restrict(typeof(OldInstance));
CustomOldClassDictionaryStorage dict;
int key = GetCustomStorageSlot(name, out dict);
if (key == -1) {
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "OldInstance " + access + " NoOptimized");
return MakeDynamicMemberAccess(member, name, access, args);
}
ParameterExpression tmp = Ast.Variable(typeof(object), "dict");
Expression target;
ValidationInfo test = new ValidationInfo(
Ast.NotEqual(
Ast.Assign(
tmp,
Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceGetOptimizedDictionary"),
self.Expression,
AstUtils.Constant(dict.KeyVersion)
)
),
AstUtils.Constant(null)
)
);
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "OldInstance " + access + " Optimized");
switch (access) {
case MemberAccess.Invoke:
ParameterExpression value = Ast.Variable(typeof(object), "value");
target = Ast.Block(
new[] { value },
Ast.Condition(
Ast.Call(
typeof(PythonOps).GetMethod("TryOldInstanceDictionaryGetValueHelper"),
tmp,
Ast.Constant(key),
AstUtils.Convert(Expression, typeof(object)),
value
),
AstUtils.Convert(
((InvokeMemberBinder)member).FallbackInvoke(new DynamicMetaObject(value, BindingRestrictions.Empty), args, null).Expression,
typeof(object)
),
AstUtils.Convert(
((InvokeMemberBinder)member).FallbackInvokeMember(self, args).Expression,
typeof(object)
)
)
);
break;
case MemberAccess.Get:
// BUG: There's a missing Fallback path here that's always been present even
// in the version that used rules.
target = Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceDictionaryGetValueHelper"),
tmp,
AstUtils.Constant(key),
AstUtils.Convert(Expression, typeof(object))
);
break;
case MemberAccess.Set:
target = Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceDictionarySetExtraValue"),
tmp,
AstUtils.Constant(key),
AstUtils.Convert(args[1].Expression, typeof(object))
);
break;
case MemberAccess.Delete:
target = Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceDeleteCustomMember"),
AstUtils.Constant(PythonContext.GetPythonContext(member).SharedContext),
AstUtils.Convert(Expression, typeof(OldInstance)),
AstUtils.Constant(name)
);
break;
default:
throw new InvalidOperationException();
}
return BindingHelpers.AddDynamicTestAndDefer(
member,
new DynamicMetaObject(
target,
BindingRestrictions.Combine(args).Merge(self.Restrictions)
),
args,
test,
tmp
);
}
void case_476()
#line 3554 "cs-parser.jay"
{
var lt = (LocatedToken) yyVals[-1+yyTop];
yyVal = new MemberAccess (new SimpleName ("await", ((LocatedToken) yyVals[-3+yyTop]).Location), lt.Value, (TypeArguments) yyVals[0+yyTop], lt.Location);
lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]));
}
public static String GetMemberAccessName(MemberAccess access) {
return access.ToString().ToLower();
}
protected override bool DoDefineMembers ()
{
if (!base.DoDefineMembers ())
return false;
Location loc = Location;
var equals_parameters = ParametersCompiled.CreateFullyResolved (
new Parameter (new TypeExpression (Compiler.BuiltinTypes.Object, loc), "obj", 0, null, loc), Compiler.BuiltinTypes.Object);
Method equals = new Method (this, new TypeExpression (Compiler.BuiltinTypes.Bool, loc),
Modifiers.PUBLIC | Modifiers.OVERRIDE | Modifiers.DEBUGGER_HIDDEN, new MemberName ("Equals", loc),
equals_parameters, null);
equals_parameters[0].Resolve (equals, 0);
Method tostring = new Method (this, new TypeExpression (Compiler.BuiltinTypes.String, loc),
Modifiers.PUBLIC | Modifiers.OVERRIDE | Modifiers.DEBUGGER_HIDDEN, new MemberName ("ToString", loc),
ParametersCompiled.EmptyReadOnlyParameters, null);
ToplevelBlock equals_block = new ToplevelBlock (Compiler, equals.ParameterInfo, loc);
TypeExpr current_type;
if (CurrentTypeParameters != null) {
var targs = new TypeArguments ();
for (int i = 0; i < CurrentTypeParameters.Count; ++i) {
targs.Add (new TypeParameterExpr (CurrentTypeParameters[i], Location));
}
current_type = new GenericTypeExpr (Definition, targs, loc);
} else {
current_type = new TypeExpression (Definition, loc);
}
var li_other = LocalVariable.CreateCompilerGenerated (CurrentType, equals_block, loc);
equals_block.AddStatement (new BlockVariable (new TypeExpression (li_other.Type, loc), li_other));
var other_variable = new LocalVariableReference (li_other, loc);
MemberAccess system_collections_generic = new MemberAccess (new MemberAccess (
new QualifiedAliasMember ("global", "System", loc), "Collections", loc), "Generic", loc);
Expression rs_equals = null;
Expression string_concat = new StringConstant (Compiler.BuiltinTypes, "{", loc);
Expression rs_hashcode = new IntConstant (Compiler.BuiltinTypes, -2128831035, loc);
for (int i = 0; i < parameters.Count; ++i) {
var p = parameters [i];
var f = (Field) Members [i * 2];
MemberAccess equality_comparer = new MemberAccess (new MemberAccess (
system_collections_generic, "EqualityComparer",
new TypeArguments (new SimpleName (CurrentTypeParameters [i].Name, loc)), loc),
"Default", loc);
Arguments arguments_equal = new Arguments (2);
arguments_equal.Add (new Argument (new MemberAccess (new This (f.Location), f.Name)));
arguments_equal.Add (new Argument (new MemberAccess (other_variable, f.Name)));
Expression field_equal = new Invocation (new MemberAccess (equality_comparer,
"Equals", loc), arguments_equal);
Arguments arguments_hashcode = new Arguments (1);
arguments_hashcode.Add (new Argument (new MemberAccess (new This (f.Location), f.Name)));
Expression field_hashcode = new Invocation (new MemberAccess (equality_comparer,
"GetHashCode", loc), arguments_hashcode);
IntConstant FNV_prime = new IntConstant (Compiler.BuiltinTypes, 16777619, loc);
rs_hashcode = new Binary (Binary.Operator.Multiply,
new Binary (Binary.Operator.ExclusiveOr, rs_hashcode, field_hashcode),
FNV_prime);
Expression field_to_string = new Conditional (new BooleanExpression (new Binary (Binary.Operator.Inequality,
new MemberAccess (new This (f.Location), f.Name), new NullLiteral (loc))),
new Invocation (new MemberAccess (
new MemberAccess (new This (f.Location), f.Name), "ToString"), null),
new StringConstant (Compiler.BuiltinTypes, string.Empty, loc), loc);
if (rs_equals == null) {
rs_equals = field_equal;
string_concat = new Binary (Binary.Operator.Addition,
string_concat,
new Binary (Binary.Operator.Addition,
new StringConstant (Compiler.BuiltinTypes, " " + p.Name + " = ", loc),
field_to_string));
continue;
}
//
// Implementation of ToString () body using string concatenation
//
string_concat = new Binary (Binary.Operator.Addition,
new Binary (Binary.Operator.Addition,
string_concat,
new StringConstant (Compiler.BuiltinTypes, ", " + p.Name + " = ", loc)),
field_to_string);
rs_equals = new Binary (Binary.Operator.LogicalAnd, rs_equals, field_equal);
}
string_concat = new Binary (Binary.Operator.Addition,
string_concat,
new StringConstant (Compiler.BuiltinTypes, " }", loc));
//
// Equals (object obj) override
//
var other_variable_assign = new TemporaryVariableReference (li_other, loc);
equals_block.AddStatement (new StatementExpression (
new SimpleAssign (other_variable_assign,
new As (equals_block.GetParameterReference (0, loc),
current_type, loc), loc)));
Expression equals_test = new Binary (Binary.Operator.Inequality, other_variable, new NullLiteral (loc));
if (rs_equals != null)
equals_test = new Binary (Binary.Operator.LogicalAnd, equals_test, rs_equals);
equals_block.AddStatement (new Return (equals_test, loc));
equals.Block = equals_block;
equals.Define ();
Members.Add (equals);
//
// GetHashCode () override
//
Method hashcode = new Method (this, new TypeExpression (Compiler.BuiltinTypes.Int, loc),
Modifiers.PUBLIC | Modifiers.OVERRIDE | Modifiers.DEBUGGER_HIDDEN,
new MemberName ("GetHashCode", loc),
ParametersCompiled.EmptyReadOnlyParameters, null);
//
// Modified FNV with good avalanche behavior and uniform
// distribution with larger hash sizes.
//
// const int FNV_prime = 16777619;
// int hash = (int) 2166136261;
// foreach (int d in data)
// hash = (hash ^ d) * FNV_prime;
// hash += hash << 13;
// hash ^= hash >> 7;
// hash += hash << 3;
// hash ^= hash >> 17;
// hash += hash << 5;
ToplevelBlock hashcode_top = new ToplevelBlock (Compiler, loc);
Block hashcode_block = new Block (hashcode_top, loc, loc);
hashcode_top.AddStatement (new Unchecked (hashcode_block, loc));
var li_hash = LocalVariable.CreateCompilerGenerated (Compiler.BuiltinTypes.Int, hashcode_top, loc);
hashcode_block.AddStatement (new BlockVariable (new TypeExpression (li_hash.Type, loc), li_hash));
LocalVariableReference hash_variable_assign = new LocalVariableReference (li_hash, loc);
hashcode_block.AddStatement (new StatementExpression (
new SimpleAssign (hash_variable_assign, rs_hashcode)));
var hash_variable = new LocalVariableReference (li_hash, loc);
hashcode_block.AddStatement (new StatementExpression (
new CompoundAssign (Binary.Operator.Addition, hash_variable,
new Binary (Binary.Operator.LeftShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 13, loc)))));
hashcode_block.AddStatement (new StatementExpression (
new CompoundAssign (Binary.Operator.ExclusiveOr, hash_variable,
new Binary (Binary.Operator.RightShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 7, loc)))));
hashcode_block.AddStatement (new StatementExpression (
new CompoundAssign (Binary.Operator.Addition, hash_variable,
new Binary (Binary.Operator.LeftShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 3, loc)))));
hashcode_block.AddStatement (new StatementExpression (
new CompoundAssign (Binary.Operator.ExclusiveOr, hash_variable,
new Binary (Binary.Operator.RightShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 17, loc)))));
hashcode_block.AddStatement (new StatementExpression (
new CompoundAssign (Binary.Operator.Addition, hash_variable,
new Binary (Binary.Operator.LeftShift, hash_variable, new IntConstant (Compiler.BuiltinTypes, 5, loc)))));
hashcode_block.AddStatement (new Return (hash_variable, loc));
hashcode.Block = hashcode_top;
hashcode.Define ();
Members.Add (hashcode);
//
// ToString () override
//
ToplevelBlock tostring_block = new ToplevelBlock (Compiler, loc);
tostring_block.AddStatement (new Return (string_concat, loc));
tostring.Block = tostring_block;
tostring.Define ();
Members.Add (tostring);
return true;
}
Method GenerateNumberMatcher ()
{
var loc = Location;
var parameters = ParametersCompiled.CreateFullyResolved (
new [] {
new Parameter (new TypeExpression (Compiler.BuiltinTypes.Object, loc), "obj", 0, null, loc),
new Parameter (new TypeExpression (Compiler.BuiltinTypes.Object, loc), "value", 0, null, loc),
new Parameter (new TypeExpression (Compiler.BuiltinTypes.Bool, loc), "enumType", 0, null, loc),
},
new [] {
Compiler.BuiltinTypes.Object,
Compiler.BuiltinTypes.Object,
Compiler.BuiltinTypes.Bool
});
var m = new Method (this, new TypeExpression (Compiler.BuiltinTypes.Bool, loc),
Modifiers.PUBLIC | Modifiers.STATIC | Modifiers.DEBUGGER_HIDDEN, new MemberName ("NumberMatcher", loc),
parameters, null);
parameters [0].Resolve (m, 0);
parameters [1].Resolve (m, 1);
parameters [2].Resolve (m, 2);
ToplevelBlock top_block = new ToplevelBlock (Compiler, parameters, loc);
m.Block = top_block;
//
// if (enumType)
// return Equals (obj, value);
//
var equals_args = new Arguments (2);
equals_args.Add (new Argument (top_block.GetParameterReference (0, loc)));
equals_args.Add (new Argument (top_block.GetParameterReference (1, loc)));
var if_type = new If (
top_block.GetParameterReference (2, loc),
new Return (new Invocation (new SimpleName ("Equals", loc), equals_args), loc),
loc);
top_block.AddStatement (if_type);
//
// if (obj is Enum || obj == null)
// return false;
//
var if_enum = new If (
new Binary (Binary.Operator.LogicalOr,
new Is (top_block.GetParameterReference (0, loc), new TypeExpression (Compiler.BuiltinTypes.Enum, loc), loc),
new Binary (Binary.Operator.Equality, top_block.GetParameterReference (0, loc), new NullLiteral (loc))),
new Return (new BoolLiteral (Compiler.BuiltinTypes, false, loc), loc),
loc);
top_block.AddStatement (if_enum);
var system_convert = new MemberAccess (new QualifiedAliasMember ("global", "System", loc), "Convert", loc);
var expl_block = new ExplicitBlock (top_block, loc, loc);
//
// var converted = System.Convert.ChangeType (obj, System.Convert.GetTypeCode (value));
//
var lv_converted = LocalVariable.CreateCompilerGenerated (Compiler.BuiltinTypes.Object, top_block, loc);
var arguments_gettypecode = new Arguments (1);
arguments_gettypecode.Add (new Argument (top_block.GetParameterReference (1, loc)));
var gettypecode = new Invocation (new MemberAccess (system_convert, "GetTypeCode", loc), arguments_gettypecode);
var arguments_changetype = new Arguments (1);
arguments_changetype.Add (new Argument (top_block.GetParameterReference (0, loc)));
arguments_changetype.Add (new Argument (gettypecode));
var changetype = new Invocation (new MemberAccess (system_convert, "ChangeType", loc), arguments_changetype);
expl_block.AddStatement (new StatementExpression (new SimpleAssign (new LocalVariableReference (lv_converted, loc), changetype, loc)));
//
// return converted.Equals (value)
//
var equals_arguments = new Arguments (1);
equals_arguments.Add (new Argument (top_block.GetParameterReference (1, loc)));
var equals_invocation = new Invocation (new MemberAccess (new LocalVariableReference (lv_converted, loc), "Equals"), equals_arguments);
expl_block.AddStatement (new Return (equals_invocation, loc));
var catch_block = new ExplicitBlock (top_block, loc, loc);
catch_block.AddStatement (new Return (new BoolLiteral (Compiler.BuiltinTypes, false, loc), loc));
top_block.AddStatement (new TryCatch (expl_block, new List<Catch> () {
new Catch (catch_block, loc)
}, loc, false));
m.Define ();
m.PrepareEmit ();
AddMember (m);
return m;
}
public DynamicEnumType HasClassAccess(MemberAccess access)
{
TypeAccess = access;
return(this);
}
public DynamicStructuralType HasClassAccess(MemberAccess access)
{
TypeAccess = access;
return(this);
}
public DynamicProperty HasSetterAccess(MemberAccess access)
{
SetterAccess = access;
return(this);
}
private static FuncInfo GetInfo(string name, MemberAccess access, List <FuncDefParam> defParams, XMLBlock xml, ParsingInfo parsingInfo, FuncDef funcDef)
{
string summary = string.Empty;
string returns = string.Empty;
string self = string.Empty;
string example = string.Empty;
List <FuncParamInfo> xmlParams = new List <FuncParamInfo>();
if (xml != null)
{
string str = xml.GetStringContent();
if (str.Length > 0 && str[0] != '<')
{
summary = str;
}
else
{
str = "<root>" + str + "</root>";
XmlDocument doc = new XmlDocument();
try
{
doc.LoadXml(str);
foreach (XmlNode n in doc.ChildNodes[0].ChildNodes)
{
XmlElement e = (XmlElement)n;
if (e.Name == "summary")
{
summary = e.InnerText.Trim();
}
else if (e.Name == "returns")
{
returns = e.InnerText.Trim();
}
else if (e.Name == "self")
{
self = e.InnerText.Trim();
}
else if (e.Name == "example")
{
example = e.InnerText.Trim();
}
else if (e.Name == "param")
{
string paramName = e.GetAttribute("name");
if (!String.IsNullOrEmpty(paramName))
{
FuncDefParam defParam = defParams.Find(a => a.Name.EqualCode(paramName));
xmlParams.Add(new FuncParamInfo(paramName, e.InnerText.Trim(), false, defParam.Optional));
}
}
}
}
catch
{
summary = "Could not parse XML.";
}
}
}
FuncInfo funcInfo = new FuncInfo(parsingInfo.SF, name, access, summary, returns, self, example, funcDef);
bool anyOptional = false;
foreach (FuncDefParam param in defParams)
{
if (param.Optional)
{
anyOptional = true;
}
FuncParamInfo paramInfo = xmlParams.Find(a => a.Name.EqualCode(param.Name));
if (paramInfo == null)
{
paramInfo = new FuncParamInfo(param.Name, "", false, anyOptional);
}
else
{
paramInfo.IsOpt = anyOptional; // update in FuncParamInfos from XML
}
funcInfo.AddParam(paramInfo);
}
return(funcInfo);
}
public Word Visit(MemberAccess memberAccess)
{
var segmentResult = memberAccess.FirstSegment.Accept(this);
if (IsError(segmentResult))
{
return(segmentResult);
}
PyObj pyObj;
var segment = (Segment)segmentResult;
var segmentType = segment.GetSegmentType();
Word getSegmentResult;
switch (segmentType)
{
case SegmentType.Identifier:
{
string id = ((IdentifierSegment)segment).Id;
getSegmentResult = CurrentScope.Get(id);
if (IsError(getSegmentResult)) //Revisa si esta entre las definiciones estaticas
{
getSegmentResult = StaticEntity.GetMember((IdentifierSegment)segment);
if (IsError(getSegmentResult))
{
return(ErrorFactory.Create(memberAccess.FirstSegment, (MyError)getSegmentResult));
}
}
pyObj = ((MemoryBlock)getSegmentResult).Value;
}
break;
case SegmentType.Procedure: //pyObj en este caso es un pyObj o null (i.e. void)
{
getSegmentResult = InvokeProcedure((ProcedureSegment)segment);
if (IsError(getSegmentResult)) //Revisa si esta entre las definiciones estaticas
{
getSegmentResult = StaticEntity.GetMember((ProcedureSegment)segment);
if (IsError(getSegmentResult))
{
return(ErrorFactory.Create(memberAccess.FirstSegment, (MyError)getSegmentResult));
}
}
pyObj = (PyObj)getSegmentResult;
}
break;
case SegmentType.Expr:
{
getSegmentResult = ((ExprSegment)segment).Expr;
if (IsError(getSegmentResult))
{
return(getSegmentResult);
}
if (IsMemoryBlock(getSegmentResult)) //comentar ese if else si se hace la desereferencia en atomic expr.
{
pyObj = ((MemoryBlock)getSegmentResult).Value;
}
else
{
pyObj = (PyObj)getSegmentResult;
}
}
break;
default:
throw new Exception("Tipo de segmento no reconocido: " + segmentType.ToString());
}
MemberSegment memberSegment;
foreach (var optionalSegment in memberAccess.OptionalSegments)
{
segmentResult = optionalSegment.Accept(this);
if (IsError(segmentResult))
{
return(segmentResult);
}
memberSegment = (MemberSegment)segmentResult;
if (pyObj == null)
{
return(ErrorFactory.VoidGetMember(optionalSegment));
}
getSegmentResult = pyObj.GetMember(memberSegment);
if (IsError(getSegmentResult))
{
return(ErrorFactory.Create(optionalSegment, (MyError)getSegmentResult));
}
if (IsMemoryBlock(getSegmentResult))
{
pyObj = ((MemoryBlock)getSegmentResult).Value;
}
else
{
pyObj = (PyObj)getSegmentResult;
}
}
return(getSegmentResult);
}
//
// Query parameter reference can include transparent parameters
//
protected override Expression GetParameterReferenceExpression (string name, Location loc)
{
Expression expr = base.GetParameterReferenceExpression (name, loc);
if (expr != null)
return expr;
TransparentParameter tp = parameters [0] as TransparentParameter;
while (tp != null) {
if (tp.Identifier == name)
break;
TransparentParameter tp_next = tp.Parent [0] as TransparentParameter;
if (tp_next == null) {
if (tp.Parent.GetParameterIndexByName (name) >= 0)
break;
}
tp = tp_next;
}
if (tp != null) {
expr = new SimpleName (parameters[0].Name, loc);
TransparentParameter tp_cursor = (TransparentParameter) parameters[0];
while (tp_cursor != tp) {
tp_cursor = (TransparentParameter) tp_cursor.Parent[0];
expr = new MemberAccess (expr, tp_cursor.Name);
}
return new MemberAccess (expr, name);
}
return null;
}
public override bool check(CodeContext context)
{
if (is_checked)
{
return(!error);
}
is_checked = true;
if (!value_type.check(context))
{
error = true;
return(false);
}
var old_symbol = context.analyzer.current_symbol;
context.analyzer.current_symbol = this;
if (writable || construction)
{
value_parameter = new Parameter("value", value_type, source_reference);
}
if (prop.source_type == SourceFileType.SOURCE)
{
if (body == null && !prop.interface_only && !prop.is_abstract)
{
/* no accessor body specified, insert default body */
automatic_body = true;
body = new Block(source_reference);
var ma = MemberAccess.simple("_%s".printf(prop.name), source_reference);
if (readable)
{
body.add_statement(new ReturnStatement(ma, source_reference));
}
else
{
Expression value = MemberAccess.simple("value", source_reference);
if (value_type.value_owned)
{
value = new ReferenceTransferExpression(value, source_reference);
}
var assignment = new Assignment(ma, value, AssignmentOperator.SIMPLE, source_reference);
body.add_statement(new ExpressionStatement(assignment));
}
}
}
if ((prop.is_abstract || prop.is_virtual || prop.overrides) && access == SymbolAccessibility.PRIVATE)
{
error = true;
Report.error(source_reference, "Property `%s' with private accessor cannot be marked as abstract, virtual or override".printf(prop.get_full_name()));
return(false);
}
if (body != null)
{
if (writable || construction)
{
body.scope.add(value_parameter.name, value_parameter);
}
body.check(context);
foreach (DataType body_error_type in body.get_error_types())
{
if (!((ErrorType)body_error_type).dynamic_error)
{
Report.warning(body_error_type.source_reference, "unhandled error `%s'".printf(body_error_type.ToString()));
}
}
}
context.analyzer.current_symbol = old_symbol;
return(!error);
}
/// <summary>
/// 设置访问修饰符(Access Modifiers)
/// </summary>
/// <param name="access">标记</param>
/// <returns></returns>
public virtual TBuilder WithAccess(MemberAccess access = MemberAccess.Default)
{
_member.Access = RoslynHelper.GetName(access);
return(_TBuilder);
}
public override bool Resolve(BlockContext bc)
{
if (bc.CurrentBlock is Linq.QueryBlock)
{
bc.Report.Error(1995, loc,
"The `await' operator may only be used in a query expression within the first collection expression of the initial `from' clause or within the collection expression of a `join' clause");
return(false);
}
if (!base.Resolve(bc))
{
return(false);
}
type = expr.Type;
Arguments args = new Arguments(0);
//
// The await expression is of dynamic type
//
if (type.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
{
result_type = type;
expr = new Invocation(new MemberAccess(expr, "GetAwaiter"), args).Resolve(bc);
return(true);
}
//
// Check whether the expression is awaitable
//
Expression ama = new AwaitableMemberAccess(expr).Resolve(bc);
if (ama == null)
{
return(false);
}
var errors_printer = new SessionReportPrinter();
var old = bc.Report.SetPrinter(errors_printer);
ama = new Invocation(ama, args).Resolve(bc);
bc.Report.SetPrinter(old);
if (errors_printer.ErrorsCount > 0 || !MemberAccess.IsValidDotExpression(ama.Type))
{
bc.Report.Error(1986, expr.Location,
"The `await' operand type `{0}' must have suitable GetAwaiter method",
expr.Type.GetSignatureForError());
return(false);
}
var awaiter_type = ama.Type;
awaiter_definition = bc.Module.GetAwaiter(awaiter_type);
if (!awaiter_definition.IsValidPattern)
{
Error_WrongAwaiterPattern(bc, awaiter_type);
return(false);
}
if (!awaiter_definition.INotifyCompletion)
{
bc.Report.Error(4027, loc, "The awaiter type `{0}' must implement interface `{1}'",
awaiter_type.GetSignatureForError(), bc.Module.PredefinedTypes.INotifyCompletion.GetSignatureForError());
return(false);
}
expr = ama;
result_type = awaiter_definition.GetResult.ReturnType;
return(true);
}
void case_433()
#line 3223 "cs-parser.jay"
{
var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
yyVal = new MemberAccess ((Expression) yyVals[-3+yyTop], lt.Value, (TypeArguments) yyVals[0+yyTop], lt.Location) {
DotLocation = GetLocation (yyVals[-2+yyTop])
};
}
void case_472()
#line 3527 "cs-parser.jay"
{
var lt = (LocatedToken) yyVals[-1+yyTop];
yyVal = new MemberAccess ((Expression) yyVals[-3+yyTop], lt.Value, (int) yyVals[0+yyTop], lt.Location);
lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]));
}
void case_435()
#line 3237 "cs-parser.jay"
{
var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
yyVal = new MemberAccess (new BaseThis (GetLocation (yyVals[-3+yyTop])), lt.Value, (TypeArguments) yyVals[0+yyTop], lt.Location) {
DotLocation = GetLocation (yyVals[-2+yyTop])
};
}
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
Arguments binder_args = new Arguments (4);
MemberAccess sle = new MemberAccess (new MemberAccess (
new QualifiedAliasMember (QualifiedAliasMember.GlobalAlias, "System", loc), "Linq", loc), "Expressions", loc);
var flags = ec.HasSet (ResolveContext.Options.CheckedScope) ? CSharpBinderFlags.CheckedContext : 0;
binder_args.Add (new Argument (new BinderFlags (flags, this)));
binder_args.Add (new Argument (new MemberAccess (new MemberAccess (sle, "ExpressionType", loc), name, loc)));
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
return new Invocation (GetBinder ("UnaryOperation", loc), binder_args);
}
/// <summary>
/// 设置访问修饰符(Access Modifiers)
/// </summary>
/// <param name="access">标记</param>
/// <returns></returns>
public virtual TBuilder WithAccess(MemberAccess access = MemberAccess.Default)
{
_member.Access = EnumCache.GetValue(access);
return(_TBuilder);
}
void case_533()
#line 3841 "cs-parser.jay"
{
var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
yyVal = new MemberAccess ((Expression) yyVals[-2+yyTop], lt.Value, lt.Location) {
DotLocation = GetLocation (yyVals[-1+yyTop])
};
}
static CodeBlock WriteNode(
Variable <JsonWriter> jsonWriter,
TypedExpression <string> baseUri,
ResourceModel model,
Expression resource,
MemberAccess <Func <object, string> > uriGenerator,
MemberAccess <Func <object, string> > typeGenerator,
IMetaModelRepository models,
Variable <HydraJsonFormatterResolver> jsonFormatterResolver,
NodeProperty[] existingNodeProperties = null,
Stack <ResourceModel> recursionDefender = null)
{
recursionDefender = recursionDefender ?? new Stack <ResourceModel>();
var resourceType = model.ResourceType;
if (recursionDefender.Contains(model))
{
throw new InvalidOperationException(
$"Detected recursion, already processing {resourceType?.Name}: {string.Join("->", recursionDefender.Select(m => m.ResourceType?.Name).Where(n => n != null))}");
}
recursionDefender.Push(model);
var resourceRegistrationHydraType = HydraTextExtensions.GetHydraTypeName(model);
var resourceUri = uriGenerator.Invoke(resource);
List <NodeProperty> nodeProperties =
new List <NodeProperty>(existingNodeProperties ?? Enumerable.Empty <NodeProperty>());
nodeProperties.AddRange(GetNodeProperties(
jsonWriter,
baseUri,
model,
resource,
uriGenerator,
typeGenerator,
models,
recursionDefender,
jsonFormatterResolver,
resourceType,
resourceUri,
resourceRegistrationHydraType));
var collectionItemTypes = HydraTextExtensions.CollectionItemTypes(resourceType).ToList();
Type collectionItemType = null;
var isHydraCollection = collectionItemTypes.Count == 1 &&
models.TryGetResourceModel(collectionItemType = collectionItemTypes.First(), out _);
IEnumerable <AnyExpression> render()
{
if (isHydraCollection)
{
var collectionType = HydraTypes.Collection.MakeGenericType(collectionItemType);
var collectionCtor =
collectionType.GetConstructor(new[] { typeof(IEnumerable <>).MakeGenericType(collectionItemType) });
var collection = Expression.Variable(collectionType);
yield return(collection);
var instantiateCollection = Expression.Assign(collection, Expression.New(collectionCtor, resource));
yield return(instantiateCollection);
resource = collection;
// if we have a generic list of sort, we hydra:Collection instead
if (resourceType.IsGenericType) // IEnum<T>, List<T> etc
{
resourceRegistrationHydraType = "hydra:Collection";
}
resourceType = collectionType;
// Remove existing id and type if already defined
nodeProperties.RemoveAll(p => p.Name == "@id" || p.Name == "@type");
nodeProperties.AddRange(GetNodeProperties(jsonWriter, baseUri, model, resource, uriGenerator, typeGenerator,
models,
recursionDefender,
jsonFormatterResolver, resourceType, resourceUri, resourceRegistrationHydraType));
}
if (nodeProperties.Any())
{
yield return(WriteNodeProperties(jsonWriter, nodeProperties));
}
}
recursionDefender.Pop();
return(new CodeBlock(render()));
}
static NodeProperty WriteNodeProperty(
Variable <JsonWriter> jsonWriter,
TypedExpression <string> baseUri,
Expression resource,
MemberAccess <Func <object, string> > uriGenerator,
MemberAccess <Func <object, string> > typeGenerator,
IMetaModelRepository models,
Stack <ResourceModel> recursionDefender,
PropertyInfo pi,
Variable <HydraJsonFormatterResolver> jsonFormatterResolver)
{
// var propertyValue;
var propertyValue = Expression.Variable(pi.PropertyType, $"val{pi.DeclaringType.Name}{pi.Name}");
// propertyValue = resource.Property;
var propertyValueAssignment = Expression.Assign(propertyValue, Expression.MakeMemberAccess(resource, pi));
var preamble = new InlineCode(new Expression[] { propertyValue, propertyValueAssignment });
if (models.TryGetResourceModel(pi.PropertyType, out var propertyResourceModel))
{
var jsonPropertyName = HydraTextExtensions.GetJsonPropertyName(pi);
return(new NodeProperty(jsonPropertyName)
{
Preamble = preamble,
Code = new InlineCode(new[]
{
jsonWriter.WritePropertyName(jsonPropertyName),
jsonWriter.WriteBeginObject(),
WriteNode(jsonWriter, baseUri, propertyResourceModel, propertyValue,
uriGenerator, typeGenerator, models, jsonFormatterResolver, recursionDefender: recursionDefender),
jsonWriter.WriteEndObject()
}),
Conditional = Expression.NotEqual(propertyValue, Expression.Default(pi.PropertyType))
});
}
var itemTypes = (from i in pi.PropertyType.GetInterfaces()
.Concat(pi.PropertyType.IsInterface ? new[] { pi.PropertyType } : Array.Empty <Type>())
where i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable <>)
let itemType = i.GetGenericArguments()[0]
where itemType != typeof(object)
select itemType).ToList();
// not an iri node itself, but is it a list of nodes?
var itemResourceRegistrations = (
from itemType in itemTypes
let resourceModels = models.ResourceRegistrations.Where(r =>
r.ResourceType != null && itemType.IsAssignableFrom(r.ResourceType)).ToList()
where resourceModels.Any()
orderby resourceModels.Count() descending
select
(
itemType,
(from possible in resourceModels
orderby possible.ResourceType.GetInheritanceDistance(itemType)
select possible).ToList()
)).ToList <(Type itemType, List <ResourceModel> models)>();
if (itemResourceRegistrations.Any() == false)
{
// not a list of iri or blank nodes
var propValue = WriteNodePropertyValue(jsonWriter, pi, jsonFormatterResolver, resource);
propValue.Preamble = preamble;
propValue.Conditional = Expression.NotEqual(propertyValue, Expression.Default(pi.PropertyType));
return(propValue);
}
// it's a list of nodes
return(WriteNodeList(jsonWriter, baseUri, uriGenerator, typeGenerator, models, recursionDefender, pi,
jsonFormatterResolver,
itemResourceRegistrations, propertyValue, preamble));
}
void case_534()
#line 3849 "cs-parser.jay"
{
var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
var ma = new MemberAccess ((Expression) yyVals[-3+yyTop], lt.Value, (int) yyVals[0+yyTop], lt.Location) {
DotLocation = GetLocation (yyVals[-2+yyTop])
};
yyVal = ma;
lbag.AddLocation (ma.TypeArguments, Lexer.GetGenericDimensionLocations ());
}
/// <summary>
/// This function computes the Base class and also the
/// list of interfaces that the class or struct @c implements.
///
/// The return value is an array (might be null) of
/// interfaces implemented (as Types).
///
/// The @base_class argument is set to the base object or null
/// if this is `System.Object'.
/// </summary>
protected virtual TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
{
// PlayScript will default to the "_root.Object" base class.. not null.
if (this.Location.SourceFile != null &&
this.Location.SourceFile.FileType == SourceFileType.PlayScript &&
this is Class && !this.IsStatic) {
base_class = new MemberAccess(new SimpleName(PsConsts.PsRootNamespace, Location), "Object");
base_type = base_class.ResolveAsType (new BaseContext (this));
if (base_type == null)
base_class = null;
} else {
base_class = null;
}
if (type_bases == null)
return null;
int count = type_bases.Count;
TypeSpec[] ifaces = null;
var base_context = new BaseContext (this);
for (int i = 0, j = 0; i < count; i++){
FullNamedExpression fne = type_bases [i];
var fne_resolved = fne.ResolveAsType (base_context);
if (fne_resolved == null)
continue;
if (i == 0 && Kind == MemberKind.Class && !fne_resolved.IsInterface) {
if (fne_resolved.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
Report.Error (1965, Location, "Class `{0}' cannot derive from the dynamic type",
GetSignatureForError ());
continue;
}
base_type = fne_resolved;
base_class = fne;
continue;
}
if (ifaces == null)
ifaces = new TypeSpec [count - i];
if (fne_resolved.IsInterface) {
for (int ii = 0; ii < j; ++ii) {
if (fne_resolved == ifaces [ii]) {
Report.Error (528, Location, "`{0}' is already listed in interface list",
fne_resolved.GetSignatureForError ());
break;
}
}
if (Kind == MemberKind.Interface && !IsAccessibleAs (fne_resolved)) {
Report.Error (61, fne.Location,
"Inconsistent accessibility: base interface `{0}' is less accessible than interface `{1}'",
fne_resolved.GetSignatureForError (), GetSignatureForError ());
}
} else {
Report.SymbolRelatedToPreviousError (fne_resolved);
if (Kind != MemberKind.Class) {
Report.Error (527, fne.Location, "Type `{0}' in interface list is not an interface", fne_resolved.GetSignatureForError ());
} else if (base_class != null)
Report.Error (1721, fne.Location, "`{0}': Classes cannot have multiple base classes (`{1}' and `{2}')",
GetSignatureForError (), base_class.GetSignatureForError (), fne_resolved.GetSignatureForError ());
else {
Report.Error (1722, fne.Location, "`{0}': Base class `{1}' must be specified as first",
GetSignatureForError (), fne_resolved.GetSignatureForError ());
}
}
ifaces [j++] = fne_resolved;
}
return ifaces;
}
void case_535()
#line 3859 "cs-parser.jay"
{
var tne = (ATypeNameExpression) yyVals[-3+yyTop];
if (tne.HasTypeArguments)
Error_TypeExpected (GetLocation (yyVals[0+yyTop]));
var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
var ma = new MemberAccess (tne, lt.Value, (int) yyVals[0+yyTop], lt.Location) {
DotLocation = GetLocation (yyVals[-2+yyTop])
};
yyVal = ma;
lbag.AddLocation (ma.TypeArguments, Lexer.GetGenericDimensionLocations ());
}
public override bool check(CodeContext context)
{
// convert to simple loop
var block = new Block(source_reference);
// initializer
foreach (var init_expr in initializer)
{
block.add_statement(new ExpressionStatement(init_expr, init_expr.source_reference));
}
// do not generate if block if condition is always true
if (condition == null || always_true(condition))
{
}
else if (always_false(condition))
{
// do not generate if block if condition is always false
body.insert_statement(0, new BreakStatement(condition.source_reference));
}
else
{
// condition
var if_condition = new UnaryExpression(UnaryOperator.LOGICAL_NEGATION, condition, condition.source_reference);
var true_block = new Block(condition.source_reference);
true_block.add_statement(new BreakStatement(condition.source_reference));
var if_stmt = new IfStatement(if_condition, true_block, null, condition.source_reference);
body.insert_statement(0, if_stmt);
}
// iterator
var first_local = new LocalVariable(context.analyzer.bool_type.copy(), get_temp_name(), new BooleanLiteral(true, source_reference), source_reference);
block.add_statement(new DeclarationStatement(first_local, source_reference));
var iterator_block = new Block(source_reference);
foreach (var it_expr in iterator)
{
iterator_block.add_statement(new ExpressionStatement(it_expr, it_expr.source_reference));
}
var first_if = new IfStatement(new UnaryExpression(UnaryOperator.LOGICAL_NEGATION, MemberAccess.simple(first_local.name, source_reference), source_reference), iterator_block, null, source_reference);
body.insert_statement(0, first_if);
body.insert_statement(1, new ExpressionStatement(new Assignment(MemberAccess.simple(first_local.name, source_reference), new BooleanLiteral(false, source_reference), AssignmentOperator.SIMPLE, source_reference), source_reference));
block.add_statement(new Loop(body, source_reference));
var parent_block = (Block)parent_node;
parent_block.replace_statement(this, block);
return(block.check(context));
}
public virtual void VisitMemberAccess(MemberAccess node)
{
node.Expression.Accept(this);
}
public EfektException OnlyObjectsCanHaveMembers(MemberAccess ma, Spec spec)
{
return(fail(ma.Exp, "Only objects can have members. Expression is of type " + spec.ToCodeString() + "."));
}
public override bool check(CodeContext context)
{
// convert to simple loop
// do not generate variable and if block if condition is always true
if (always_true(condition))
{
var loop = new Loop(body, source_reference);
var _parent_block = parent_node as Block;
_parent_block.replace_statement(this, loop);
return(loop.check(context));
}
var block = new Block(source_reference);
var first_local = new LocalVariable(context.analyzer.bool_type.copy(), get_temp_name(), new BooleanLiteral(true, source_reference), source_reference);
block.add_statement(new DeclarationStatement(first_local, source_reference));
var if_condition = new UnaryExpression(UnaryOperator.LOGICAL_NEGATION, condition, condition.source_reference);
var true_block = new Block(condition.source_reference);
true_block.add_statement(new BreakStatement(condition.source_reference));
var if_stmt = new IfStatement(if_condition, true_block, null, condition.source_reference);
var condition_block = new Block(condition.source_reference);
condition_block.add_statement(if_stmt);
var first_if = new IfStatement(new UnaryExpression(UnaryOperator.LOGICAL_NEGATION, MemberAccess.simple(first_local.name, source_reference), source_reference), condition_block, null, source_reference);
body.insert_statement(0, first_if);
body.insert_statement(1, new ExpressionStatement(new Assignment(MemberAccess.simple(first_local.name, source_reference), new BooleanLiteral(false, source_reference), AssignmentOperator.SIMPLE, source_reference), source_reference));
block.add_statement(new Loop(body, source_reference));
var parent_block = (Block)parent_node;
parent_block.replace_statement(this, block);
return(block.check(context));
}
public override AstNode Visit(MemberAccess node)
{
return(node);
}
public override Expression CreateExpressionTree (ResolveContext ec)
{
MemberAccess ma = new MemberAccess (new MemberAccess (new QualifiedAliasMember ("global", "System", loc), "Delegate", loc), "CreateDelegate", loc);
Arguments args = new Arguments (3);
args.Add (new Argument (new TypeOf (type, loc)));
if (method_group.InstanceExpression == null)
args.Add (new Argument (new NullLiteral (loc)));
else
args.Add (new Argument (method_group.InstanceExpression));
args.Add (new Argument (method_group.CreateExpressionTree (ec)));
Expression e = new Invocation (ma, args).Resolve (ec);
if (e == null)
return null;
e = Convert.ExplicitConversion (ec, e, type, loc);
if (e == null)
return null;
return e.CreateExpressionTree (ec);
}
private void Format_Member_Access_Expression(StringBuilder sb, MemberAccess mac)
{
sb.Append(FormatExpression(mac.Expression)).Append(".").Append(mac.MemberName.Text);
Process_Generic_Type_Arguments(sb, mac.GenericTypeArguments);
}
public virtual object Visit (MemberAccess memberAccess)
{
return null;
}
Method GenerateNumberMatcher()
{
var loc = Location;
var parameters = ParametersCompiled.CreateFullyResolved(
new [] {
new Parameter(new TypeExpression(Compiler.BuiltinTypes.Object, loc), "obj", 0, null, loc),
new Parameter(new TypeExpression(Compiler.BuiltinTypes.Object, loc), "value", 0, null, loc),
new Parameter(new TypeExpression(Compiler.BuiltinTypes.Bool, loc), "enumType", 0, null, loc),
},
new [] {
Compiler.BuiltinTypes.Object,
Compiler.BuiltinTypes.Object,
Compiler.BuiltinTypes.Bool
});
var m = new Method(this, new TypeExpression(Compiler.BuiltinTypes.Bool, loc),
Modifiers.PUBLIC | Modifiers.STATIC | Modifiers.DEBUGGER_HIDDEN, new MemberName("NumberMatcher", loc),
parameters, null);
parameters [0].Resolve(m, 0);
parameters [1].Resolve(m, 1);
parameters [2].Resolve(m, 2);
ToplevelBlock top_block = new ToplevelBlock(Compiler, parameters, loc);
m.Block = top_block;
//
// if (enumType)
// return Equals (obj, value);
//
var equals_args = new Arguments(2);
equals_args.Add(new Argument(top_block.GetParameterReference(0, loc)));
equals_args.Add(new Argument(top_block.GetParameterReference(1, loc)));
var if_type = new If(
top_block.GetParameterReference(2, loc),
new Return(new Invocation(new SimpleName("Equals", loc), equals_args), loc),
loc);
top_block.AddStatement(if_type);
//
// if (obj is Enum || obj == null)
// return false;
//
var if_enum = new If(
new Binary(Binary.Operator.LogicalOr,
new Is(top_block.GetParameterReference(0, loc), new TypeExpression(Compiler.BuiltinTypes.Enum, loc), loc),
new Binary(Binary.Operator.Equality, top_block.GetParameterReference(0, loc), new NullLiteral(loc))),
new Return(new BoolLiteral(Compiler.BuiltinTypes, false, loc), loc),
loc);
top_block.AddStatement(if_enum);
var system_convert = new MemberAccess(new QualifiedAliasMember("global", "System", loc), "Convert", loc);
var expl_block = new ExplicitBlock(top_block, loc, loc);
//
// var converted = System.Convert.ChangeType (obj, System.Convert.GetTypeCode (value));
//
var lv_converted = LocalVariable.CreateCompilerGenerated(Compiler.BuiltinTypes.Object, top_block, loc);
var arguments_gettypecode = new Arguments(1);
arguments_gettypecode.Add(new Argument(top_block.GetParameterReference(1, loc)));
var gettypecode = new Invocation(new MemberAccess(system_convert, "GetTypeCode", loc), arguments_gettypecode);
var arguments_changetype = new Arguments(1);
arguments_changetype.Add(new Argument(top_block.GetParameterReference(0, loc)));
arguments_changetype.Add(new Argument(gettypecode));
var changetype = new Invocation(new MemberAccess(system_convert, "ChangeType", loc), arguments_changetype);
expl_block.AddStatement(new StatementExpression(new SimpleAssign(new LocalVariableReference(lv_converted, loc), changetype, loc)));
//
// return converted.Equals (value)
//
var equals_arguments = new Arguments(1);
equals_arguments.Add(new Argument(top_block.GetParameterReference(1, loc)));
var equals_invocation = new Invocation(new MemberAccess(new LocalVariableReference(lv_converted, loc), "Equals"), equals_arguments);
expl_block.AddStatement(new Return(equals_invocation, loc));
var catch_block = new ExplicitBlock(top_block, loc, loc);
catch_block.AddStatement(new Return(new BoolLiteral(Compiler.BuiltinTypes, false, loc), loc));
top_block.AddStatement(new TryCatch(expl_block, new List <Catch> ()
{
new Catch(catch_block, loc)
}, loc, false));
m.Define();
m.PrepareEmit();
AddMember(m);
return(m);
}
public override void visit_member_access(MemberAccess expr)
{
CCodeExpression pub_inst = null;
if (expr.inner != null)
{
pub_inst = get_cvalue(expr.inner);
}
var array_type = expr.value_type as ArrayType;
var delegate_type = expr.value_type as DelegateType;
if (expr.symbol_reference is Method)
{
var m = (Method)expr.symbol_reference;
if (!(m is DynamicMethod || m is ArrayMoveMethod || m is ArrayResizeMethod || m is ArrayCopyMethod))
{
generate_method_declaration(m, cfile);
if (!m.external && m.external_package)
{
// internal VAPI methods
// only add them once per source file
if (add_generated_external_symbol(m))
{
visit_method(m);
}
}
}
if (expr.inner is BaseAccess)
{
if (m.base_method != null)
{
var base_class = (Class)m.base_method.parent_symbol;
var vcast = new CCodeFunctionCall(new CCodeIdentifier("%s_CLASS".printf(get_ccode_upper_case_name(base_class, null))));
vcast.add_argument(new CCodeIdentifier("%s_parent_class".printf(get_ccode_lower_case_name(current_class, null))));
set_cvalue(expr, CCodeMemberAccess.pointer(vcast, get_ccode_vfunc_name(m)));
return;
}
else if (m.base_interface_method != null)
{
var base_iface = (Interface)m.base_interface_method.parent_symbol;
string parent_iface_var = "%s_%s_parent_iface".printf(get_ccode_lower_case_name(current_class), get_ccode_lower_case_name(base_iface));
set_cvalue(expr, CCodeMemberAccess.pointer(new CCodeIdentifier(parent_iface_var), get_ccode_vfunc_name(m)));
return;
}
}
if (m.base_method != null)
{
if (!method_has_wrapper(m.base_method))
{
var base_class = (Class)m.base_method.parent_symbol;
var vclass = new CCodeFunctionCall(new CCodeIdentifier("%s_GET_CLASS".printf(get_ccode_upper_case_name(base_class))));
vclass.add_argument(pub_inst);
set_cvalue(expr, CCodeMemberAccess.pointer(vclass, get_ccode_vfunc_name(m)));
}
else
{
set_cvalue(expr, new CCodeIdentifier(get_ccode_name(m.base_method)));
}
}
else if (m.base_interface_method != null)
{
set_cvalue(expr, new CCodeIdentifier(get_ccode_name(m.base_interface_method)));
}
else if (m is CreationMethod)
{
set_cvalue(expr, new CCodeIdentifier(get_ccode_real_name(m)));
}
else
{
set_cvalue(expr, new CCodeIdentifier(get_ccode_name(m)));
}
set_delegate_target_destroy_notify(expr, new CCodeConstant("NULL"));
if (m.binding == MemberBinding.STATIC)
{
set_delegate_target(expr, new CCodeConstant("NULL"));
}
else if (m.is_async_callback)
{
if (current_method.closure)
{
var block = ((Method)m.parent_symbol).body;
set_delegate_target(expr, CCodeMemberAccess.pointer(get_variable_cexpression("_data%d_".printf(get_block_id(block))), "_async_data_"));
}
else
{
set_delegate_target(expr, new CCodeIdentifier("_data_"));
}
}
else if (expr.inner != null && !expr.prototype_access)
{
// expr.inner is null in the special case of referencing the method in a constant initializer
var delegate_target = (CCodeExpression)get_ccodenode(expr.inner);
delegate_type = expr.target_type as DelegateType;
if ((expr.value_type.value_owned || (delegate_type != null && delegate_type.is_called_once)) && expr.inner.value_type.data_type != null && is_reference_counting(expr.inner.value_type.data_type))
{
var ref_call = new CCodeFunctionCall(get_dup_func_expression(expr.inner.value_type, expr.source_reference));
ref_call.add_argument(delegate_target);
delegate_target = ref_call;
set_delegate_target_destroy_notify(expr, get_destroy_func_expression(expr.inner.value_type));
}
set_delegate_target(expr, delegate_target);
}
}
else if (expr.symbol_reference is ArrayLengthField)
{
if (expr.value_type is ArrayType && !(expr.parent_node is ElementAccess))
{
Report.error(expr.source_reference, "unsupported use of length field of multi-dimensional array");
}
set_cvalue(expr, get_array_length_cexpression(expr.inner, 1));
}
else if (expr.symbol_reference is Field)
{
var field = (Field)expr.symbol_reference;
if (expr.lvalue)
{
expr.target_value = get_field_cvalue(field, expr.inner != null ? expr.inner.target_value : null);
}
else
{
expr.target_value = load_field(field, expr.inner != null ? expr.inner.target_value : null);
}
}
else if (expr.symbol_reference is EnumValue)
{
var ev = (EnumValue)expr.symbol_reference;
generate_enum_declaration((ValaEnum)ev.parent_symbol, cfile);
set_cvalue(expr, new CCodeConstant(get_ccode_name(ev)));
}
else if (expr.symbol_reference is Constant)
{
var c = (Constant)expr.symbol_reference;
generate_constant_declaration(c, cfile,
c.source_reference != null && expr.source_reference != null &&
c.source_reference.file == expr.source_reference.file);
string fn = c.get_full_name();
if (fn == "GLib.Log.FILE")
{
string s = Path.GetFileName(expr.source_reference.file.filename);
set_cvalue(expr, new CCodeConstant("\"%s\"".printf(s)));
}
else if (fn == "GLib.Log.LINE")
{
int i = expr.source_reference.begin.line;
set_cvalue(expr, new CCodeConstant("%d".printf(i)));
}
else if (fn == "GLib.Log.METHOD")
{
string s = "";
if (current_method != null)
{
s = current_method.get_full_name();
}
set_cvalue(expr, new CCodeConstant("\"%s\"".printf(s)));
}
else
{
set_cvalue(expr, new CCodeIdentifier(get_ccode_name(c)));
}
if (array_type != null)
{
var ccall = new CCodeFunctionCall(new CCodeIdentifier("G_N_ELEMENTS"));
ccall.add_argument(new CCodeIdentifier(get_ccode_name(c)));
append_array_length(expr, ccall);
}
}
else if (expr.symbol_reference is Property)
{
var prop = (Property)expr.symbol_reference;
if (!(prop is DynamicProperty))
{
generate_property_accessor_declaration(prop.get_accessor, cfile);
if (!prop.external && prop.external_package)
{
// internal VAPI properties
// only add them once per source file
if (add_generated_external_symbol(prop))
{
visit_property(prop);
}
}
}
if (expr.inner is BaseAccess)
{
var base_prop = prop;
if (prop.base_property != null)
{
base_prop = prop.base_property;
}
else if (prop.base_interface_property != null)
{
base_prop = prop.base_interface_property;
}
if (base_prop.parent_symbol is Class)
{
var base_class = (Class)base_prop.parent_symbol;
var vcast = new CCodeFunctionCall(new CCodeIdentifier("%s_CLASS".printf(get_ccode_upper_case_name(base_class, null))));
vcast.add_argument(new CCodeIdentifier("%s_parent_class".printf(get_ccode_lower_case_name(current_class, null))));
var ccall = new CCodeFunctionCall(CCodeMemberAccess.pointer(vcast, "get_%s".printf(prop.name)));
ccall.add_argument(get_cvalue(expr.inner));
if (prop.property_type.is_real_non_null_struct_type())
{
var temp_value = (GLibValue)create_temp_value(prop.get_accessor.value_type, false, expr);
expr.target_value = load_temp_value(temp_value);
var ctemp = get_cvalue_(temp_value);
ccall.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, ctemp));
ccode.add_expression(ccall);
}
else
{
set_cvalue(expr, ccall);
}
}
else if (base_prop.parent_symbol is Interface)
{
var base_iface = (Interface)base_prop.parent_symbol;
string parent_iface_var = "%s_%s_parent_iface".printf(get_ccode_lower_case_name(current_class), get_ccode_lower_case_name(base_iface));
var ccall = new CCodeFunctionCall(CCodeMemberAccess.pointer(new CCodeIdentifier(parent_iface_var), "get_%s".printf(prop.name)));
ccall.add_argument(get_cvalue(expr.inner));
if (prop.property_type.is_real_non_null_struct_type())
{
var temp_value = (GLibValue)create_temp_value(prop.get_accessor.value_type, false, expr);
expr.target_value = load_temp_value(temp_value);
var ctemp = get_cvalue_(temp_value);
ccall.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, ctemp));
ccode.add_expression(ccall);
}
else
{
set_cvalue(expr, ccall);
}
}
}
else if (prop.binding == MemberBinding.INSTANCE &&
prop.get_accessor.automatic_body &&
!prop.get_accessor.value_type.value_owned &&
current_type_symbol == prop.parent_symbol &&
current_type_symbol is Class &&
prop.base_property == null &&
prop.base_interface_property == null &&
!(prop.property_type is ArrayType || prop.property_type is DelegateType))
{
CCodeExpression inst;
inst = CCodeMemberAccess.pointer(pub_inst, "priv");
set_cvalue(expr, CCodeMemberAccess.pointer(inst, get_ccode_name(prop.field)));
}
else if (!get_ccode_no_accessor_method(prop))
{
string getter_cname;
if (prop is DynamicProperty)
{
getter_cname = get_dynamic_property_getter_cname((DynamicProperty)prop);
}
else
{
getter_cname = get_ccode_name(prop.get_accessor);
}
var ccall = new CCodeFunctionCall(new CCodeIdentifier(getter_cname));
if (prop.binding == MemberBinding.INSTANCE)
{
if (prop.parent_symbol is Struct && !((Struct)prop.parent_symbol).is_simple_type())
{
// we need to pass struct instance by reference
var instance = expr.inner.target_value;
if (!get_lvalue(instance))
{
instance = store_temp_value(instance, expr);
}
pub_inst = new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, get_cvalue_(instance));
}
ccall.add_argument(pub_inst);
}
bool prop_is_real_non_null_struct_type = prop.property_type.is_real_non_null_struct_type();
var temp_value = (GLibValue)create_temp_value(prop.get_accessor.value_type, prop_is_real_non_null_struct_type, expr);
expr.target_value = load_temp_value(temp_value);
var ctemp = get_cvalue_(temp_value);
// Property access to real struct types is handled differently
// The value is returned by out parameter
if (prop_is_real_non_null_struct_type)
{
ccall.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, ctemp));
ccode.add_expression(ccall);
}
else
{
ccode.add_assignment(ctemp, ccall);
array_type = prop.property_type as ArrayType;
if (array_type != null)
{
if (get_ccode_array_null_terminated(prop))
{
requires_array_length = true;
var len_call = new CCodeFunctionCall(new CCodeIdentifier("_vala_array_length"));
len_call.add_argument(ctemp);
ccode.add_assignment(temp_value.array_length_cvalues[0], len_call);
}
else if (get_ccode_array_length(prop))
{
for (int dim = 1; dim <= array_type.rank; dim++)
{
ccall.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, get_array_length_cvalue(temp_value, dim)));
}
}
}
else
{
delegate_type = prop.property_type as DelegateType;
if (delegate_type != null && delegate_type.delegate_symbol.has_target)
{
ccall.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, get_delegate_target_cvalue(temp_value)));
}
}
}
}
else
{
var ccall = new CCodeFunctionCall(new CCodeIdentifier("g_object_get"));
ccall.add_argument(pub_inst);
// property name is second argument of g_object_get
ccall.add_argument(get_property_canonical_cconstant(prop));
// g_object_get always returns owned values
// therefore, property getters of properties
// without accessor methods need to be marked as owned
if (!prop.get_accessor.value_type.value_owned)
{
// only report error for types where there actually
// is a difference between `owned' and `unowned'
var owned_value_type = prop.get_accessor.value_type.copy();
owned_value_type.value_owned = true;
if (requires_copy(owned_value_type))
{
Report.error(prop.get_accessor.source_reference, "unowned return value for getter of property `%s' not supported without accessor".printf(prop.get_full_name()));
}
}
if (expr.value_type.is_real_struct_type())
{
// gobject allocates structs on heap
expr.value_type.nullable = true;
}
var temp_var = get_temp_variable(expr.value_type);
var ctemp = get_variable_cexpression(temp_var.name);
emit_temp_var(temp_var);
ccall.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, ctemp));
ccall.add_argument(new CCodeConstant("NULL"));
ccode.add_expression(ccall);
set_cvalue(expr, ctemp);
}
expr.target_value.value_type = expr.value_type;
expr.target_value = store_temp_value(expr.target_value, expr);
}
else if (expr.symbol_reference is LocalVariable)
{
var local = (LocalVariable)expr.symbol_reference;
if (expr.parent_node is ReturnStatement &&
current_return_type.value_owned &&
local.variable_type.value_owned &&
!local.captured &&
!variable_accessible_in_finally(local) &&
!(local.variable_type is ArrayType && ((ArrayType)local.variable_type).inline_allocated))
{
/* return expression is local variable taking ownership and
* current method is transferring ownership */
// don't ref expression
expr.value_type.value_owned = true;
// don't unref variable
local.active = false;
var glib_value = (GLibValue)get_local_cvalue(local);
expr.target_value = glib_value;
if (glib_value.delegate_target_cvalue == null)
{
glib_value.delegate_target_cvalue = new CCodeConstant("NULL");
}
if (glib_value.delegate_target_destroy_notify_cvalue == null)
{
glib_value.delegate_target_destroy_notify_cvalue = new CCodeConstant("NULL");
}
}
else
{
if (expr.lvalue)
{
expr.target_value = get_local_cvalue(local);
}
else
{
expr.target_value = load_local(local);
}
}
}
else if (expr.symbol_reference is Parameter)
{
var param = (Parameter)expr.symbol_reference;
if (expr.lvalue)
{
expr.target_value = get_parameter_cvalue(param);
}
else
{
expr.target_value = load_parameter(param);
}
}
}
public virtual void Visit(MemberAccess node)
{
DefaultVisit(node);
}
public void SetUp()
{
_sut = new MemberAccess();
_mapper = new MemberMap();
}
public ATypeNameExpression MakeTypeNameExpression(Location loc)
{
string[] names = Name.Split(new [] {'.'});
ATypeNameExpression exp = null;
for (var i = 0; i < names.Length; i++) {
var name = names[i];
if (exp == null) {
exp = new SimpleName (name, loc);
} else {
exp = new MemberAccess(exp, name, loc);
}
}
return exp;
}
public void TearDown()
{
_sut = null;
}
void case_382()
#line 3169 "cs-parser.jay"
{
var lt = (LocatedToken) yyVals[-2+yyTop];
yyVal = new MemberAccess ((ATypeNameExpression) yyVals[-3+yyTop], lt.Value, (TypeArguments) yyVals[-1+yyTop], lt.Location);
lbag.AddLocation (yyVal, GetLocation (yyVals[0+yyTop]));
}
public override void visit_member_access(MemberAccess expr)
{
expr.accept_children(this);
}
void case_475()
#line 3548 "cs-parser.jay"
{
var lt = (LocatedToken) yyVals[-1+yyTop];
yyVal = new MemberAccess (new BaseThis (GetLocation (yyVals[-3+yyTop])), lt.Value, (TypeArguments) yyVals[0+yyTop], lt.Location);
lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]));
}
private DynamicMetaObject /*!*/ MakeMemberAccess(DynamicMetaObjectBinder /*!*/ member, string name, MemberAccess access, params DynamicMetaObject /*!*/[] /*!*/ args)
{
DynamicMetaObject self = Restrict(typeof(OldInstance));
CustomInstanceDictionaryStorage dict;
int key = GetCustomStorageSlot(name, out dict);
if (key == -1)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "OldInstance " + access + " NoOptimized");
return(MakeDynamicMemberAccess(member, name, access, args));
}
ParameterExpression tmp = Ast.Variable(typeof(object), "dict");
Expression target;
ValidationInfo test = new ValidationInfo(
Ast.NotEqual(
Ast.Assign(
tmp,
Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceGetOptimizedDictionary"),
self.Expression,
AstUtils.Constant(dict.KeyVersion)
)
),
AstUtils.Constant(null)
)
);
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "OldInstance " + access + " Optimized");
switch (access)
{
case MemberAccess.Invoke:
ParameterExpression value = Ast.Variable(typeof(object), "value");
target = Ast.Block(
new[] { value },
Ast.Condition(
Ast.Call(
typeof(PythonOps).GetMethod("TryOldInstanceDictionaryGetValueHelper"),
tmp,
Ast.Constant(key),
AstUtils.Convert(Expression, typeof(object)),
value
),
AstUtils.Convert(
((InvokeMemberBinder)member).FallbackInvoke(new DynamicMetaObject(value, BindingRestrictions.Empty), args, null).Expression,
typeof(object)
),
AstUtils.Convert(
((InvokeMemberBinder)member).FallbackInvokeMember(self, args).Expression,
typeof(object)
)
)
);
break;
case MemberAccess.Get:
// BUG: There's a missing Fallback path here that's always been present even
// in the version that used rules.
target = Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceDictionaryGetValueHelper"),
tmp,
AstUtils.Constant(key),
AstUtils.Convert(Expression, typeof(object))
);
break;
case MemberAccess.Set:
target = Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceDictionarySetExtraValue"),
tmp,
AstUtils.Constant(key),
AstUtils.Convert(args[1].Expression, typeof(object))
);
break;
case MemberAccess.Delete:
target = Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceDeleteCustomMember"),
AstUtils.Constant(PythonContext.GetPythonContext(member).SharedContext),
AstUtils.Convert(Expression, typeof(OldInstance)),
AstUtils.Constant(name)
);
break;
default:
throw new InvalidOperationException();
}
return(BindingHelpers.AddDynamicTestAndDefer(
member,
new DynamicMetaObject(
target,
BindingRestrictions.Combine(args).Merge(self.Restrictions)
),
args,
test,
tmp
));
}
void case_588()
#line 4285 "cs-parser.jay"
{
var lt = (LocatedToken) yyVals[-1+yyTop];
yyVal = new MemberAccess (new Indirection ((Expression) yyVals[-3+yyTop], GetLocation (yyVals[-2+yyTop])), lt.Value, (TypeArguments) yyVals[0+yyTop], lt.Location);
}
private DynamicMetaObject /*!*/ MakeDynamicMemberAccess(DynamicMetaObjectBinder /*!*/ member, string /*!*/ name, MemberAccess access, DynamicMetaObject /*!*/[] /*!*/ args)
{
DynamicMetaObject self = Restrict(typeof(OldInstance));
Expression target;
ParameterExpression tmp = Ast.Variable(typeof(object), "result");
switch (access)
{
case MemberAccess.Invoke:
target = Ast.Block(
new ParameterExpression[] { tmp },
Ast.Condition(
Expression.Not(
Expression.TypeIs(
Expression.Assign(
tmp,
Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceTryGetBoundCustomMember"),
AstUtils.Constant(PythonContext.GetPythonContext(member).SharedContext),
self.Expression,
AstUtils.Constant(name)
)
),
typeof(OperationFailed)
)
),
((InvokeMemberBinder)member).FallbackInvoke(new DynamicMetaObject(tmp, BindingRestrictions.Empty), args, null).Expression,
AstUtils.Convert(
((InvokeMemberBinder)member).FallbackInvokeMember(this, args).Expression,
typeof(object)
)
)
);
break;
case MemberAccess.Get:
target = Ast.Block(
new ParameterExpression[] { tmp },
Ast.Condition(
Expression.Not(
Expression.TypeIs(
Expression.Assign(
tmp,
Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceTryGetBoundCustomMember"),
AstUtils.Constant(PythonContext.GetPythonContext(member).SharedContext),
self.Expression,
AstUtils.Constant(name)
)
),
typeof(OperationFailed)
)
),
tmp,
AstUtils.Convert(
FallbackGet(member, args),
typeof(object)
)
)
);
break;
case MemberAccess.Set:
target = Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceSetCustomMember"),
AstUtils.Constant(PythonContext.GetPythonContext(member).SharedContext),
self.Expression,
AstUtils.Constant(name),
AstUtils.Convert(args[1].Expression, typeof(object))
);
break;
case MemberAccess.Delete:
target = Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceDeleteCustomMember"),
AstUtils.Constant(PythonContext.GetPythonContext(member).SharedContext),
self.Expression,
AstUtils.Constant(name)
);
break;
default:
throw new InvalidOperationException();
}
return(new DynamicMetaObject(
target,
self.Restrictions.Merge(BindingRestrictions.Combine(args))
));
}
public override object Visit (MemberAccess memberAccess)
{
Expression result;
if (memberAccess.LeftExpression is Indirection) {
var ind = memberAccess.LeftExpression as Indirection;
result = new PointerReferenceExpression ();
result.AddChild ((Expression)ind.Expr.Accept (this), Roles.TargetExpression);
result.AddChild (new CSharpTokenNode (Convert (ind.Location), PointerReferenceExpression.ArrowRole), PointerReferenceExpression.ArrowRole);
} else {
result = new MemberReferenceExpression ();
if (memberAccess.LeftExpression != null) {
var leftExpr = memberAccess.LeftExpression.Accept (this);
result.AddChild ((Expression)leftExpr, Roles.TargetExpression);
}
if (!memberAccess.DotLocation.IsNull) {
result.AddChild (new CSharpTokenNode (Convert (memberAccess.DotLocation), Roles.Dot), Roles.Dot);
}
}
result.AddChild (Identifier.Create (memberAccess.Name, Convert (memberAccess.Location)), Roles.Identifier);
AddTypeArguments (result, memberAccess);
return result;
}
public virtual object Visit(MemberAccess memberAccess)
{
return(null);
}
private DynamicMetaObject/*!*/ MakeDynamicMemberAccess(DynamicMetaObjectBinder/*!*/ member, string/*!*/ name, MemberAccess access, DynamicMetaObject/*!*/[]/*!*/ args) {
DynamicMetaObject self = Restrict(typeof(OldInstance));
Expression target;
ParameterExpression tmp = Ast.Variable(typeof(object), "result");
switch (access) {
case MemberAccess.Invoke:
target = Ast.Block(
new ParameterExpression[] { tmp },
Ast.Condition(
Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceTryGetBoundCustomMember"),
Ast.Constant(PythonContext.GetPythonContext(member).SharedContext),
self.Expression,
AstUtils.Constant(name),
tmp
),
((InvokeMemberBinder)member).FallbackInvoke(new DynamicMetaObject(tmp, BindingRestrictions.Empty), args, null).Expression,
AstUtils.Convert(
((InvokeMemberBinder)member).FallbackInvokeMember(this, args).Expression,
typeof(object)
)
)
);
break;
case MemberAccess.Get:
target = Ast.Block(
new ParameterExpression[] { tmp },
Ast.Condition(
Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceTryGetBoundCustomMember"),
AstUtils.Constant(PythonContext.GetPythonContext(member).SharedContext),
self.Expression,
AstUtils.Constant(name),
tmp
),
tmp,
AstUtils.Convert(
FallbackGet(member, args),
typeof(object)
)
)
);
break;
case MemberAccess.Set:
target = Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceSetCustomMember"),
AstUtils.Constant(PythonContext.GetPythonContext(member).SharedContext),
self.Expression,
AstUtils.Constant(name),
AstUtils.Convert(args[1].Expression, typeof(object))
);
break;
case MemberAccess.Delete:
target = Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceDeleteCustomMember"),
AstUtils.Constant(PythonContext.GetPythonContext(member).SharedContext),
self.Expression,
AstUtils.Constant(name)
);
break;
default:
throw new InvalidOperationException();
}
return new DynamicMetaObject(
target,
self.Restrictions.Merge(BindingRestrictions.Combine(args))
);
}
private static void ReadFunc(ScriptInfo SI, XmlElement funcElem)
{
string name = string.Empty;
MemberAccess access = MemberAccess.Public;
string returns = string.Empty;
string summary = string.Empty;
string self = string.Empty;
string example = string.Empty;
List <FuncParamInfo> parameters = new List <FuncParamInfo>();
name = funcElem.GetAttribute("name");
access = (MemberAccess)Enum.Parse(typeof(MemberAccess), funcElem.GetAttribute("access"));
foreach (XmlNode curNode in funcElem)
{
if (!(curNode is XmlElement))
{
continue;
}
XmlElement curElem = (XmlElement)curNode;
if (curElem.Name == "summary")
{
summary = curElem.InnerText;
}
else if (curElem.Name == "returns")
{
returns = curElem.InnerText;
}
else if (curElem.Name == "self")
{
self = curElem.InnerText;
}
else if (curElem.Name == "example")
{
example = curElem.InnerText;
}
else if (curElem.Name == "param")
{
string isOut = curElem.GetAttribute("out");
string isOpt = curElem.GetAttribute("opt");
bool isOutBool = String.IsNullOrEmpty(isOut) ? false : Boolean.Parse(isOut);
bool isOptBool = String.IsNullOrEmpty(isOpt) ? false : Boolean.Parse(isOpt);
parameters.Add(new FuncParamInfo(curElem.GetAttribute("name"), curElem.InnerText, isOutBool, isOptBool));
}
else
{
throw new XmlException("Unknown ScriptInfo func node '" + curElem.Name + "'");
}
}
FuncInfo funcInfo = new FuncInfo(SI.SF, name, access, summary, returns, self, example, null);
foreach (FuncParamInfo param in parameters)
{
funcInfo.AddParam(param);
}
SI.AddFunction(funcInfo);
}
static IEnumerable <NodeProperty> GetNodeProperties(
Variable <JsonWriter> jsonWriter,
TypedExpression <string> baseUri,
ResourceModel model,
Expression resource,
MemberAccess <Func <object, string> > uriGenerator,
MemberAccess <Func <object, string> > typeGenerator,
IMetaModelRepository models,
Stack <ResourceModel> recursionDefender,
Variable <HydraJsonFormatterResolver> jsonFormatterResolver,
Type resourceType,
TypedExpression <string> resourceUri,
string resourceRegistrationHydraType)
{
var publicProperties = resourceType
.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(HydraTextExtensions.IsNotIgnored)
.ToList();
var propNames = publicProperties.Select(HydraTextExtensions.GetJsonPropertyName);
var overridesId = propNames.Any(name => name == "@id");
var overridesType = propNames.Any(name => name == "@type");
if (overridesId == false && model.Uris.Any())
{
yield return(WriteId(jsonWriter, resourceUri));
}
if (overridesType == false)
{
var typePropertyFactory = model.Hydra().TypeFunc;
if (typePropertyFactory == null)
{
yield return(WriteType(jsonWriter, resourceRegistrationHydraType));
}
else
{
yield return(WriteType(jsonWriter, StringMethods.Concat(baseUri, typeGenerator.Invoke(resource))));
}
}
foreach (var pi in publicProperties)
{
if (pi.GetIndexParameters().Any())
{
continue;
}
if (pi.PropertyType == typeof(string) ||
(pi.PropertyType.IsValueType && Nullable.GetUnderlyingType(pi.PropertyType) == null))
{
var nodePropertyValue = WriteNodePropertyValue(
jsonWriter,
pi,
jsonFormatterResolver,
resource);
yield return(nodePropertyValue);
continue;
}
yield return(WriteNodeProperty(
jsonWriter, baseUri, resource, uriGenerator, typeGenerator, models, recursionDefender, pi,
jsonFormatterResolver));
}
foreach (var link in model.Links)
{
yield return(WriteNodeLink(jsonWriter, link.Relationship, link.Uri, resourceUri, link));
}
}
/// <summary>
/// Visit operation called for member access expressions.
///
/// <param name="expr">a member access expression</param>
/// </summary>
public virtual void visit_member_access(MemberAccess expr)
{
}
