private void registerMethod(IMethodDeclaration method, Context context) { IDeclaration actual; if (method is SetterMethodDeclaration) { if (methodsMap.TryGetValue("setter:" + method.GetName(), out actual)) { throw new SyntaxError("Duplicate setter: \"" + method.GetName() + "\""); } methodsMap["setter:" + method.GetName()] = method; } else if (method is GetterMethodDeclaration) { if (methodsMap.TryGetValue("getter:" + method.GetName(), out actual)) { throw new SyntaxError("Duplicate getter: \"" + method.GetName() + "\""); } methodsMap["getter:" + method.GetName()] = method; } else { if (!methodsMap.TryGetValue(method.GetName(), out actual)) { actual = new MethodDeclarationMap(method.GetName()); methodsMap[method.GetName()] = (MethodDeclarationMap)actual; } ((MethodDeclarationMap)actual).register(method, context); } }
private static IType getTargetAtomicType(Context context, IType type) { IDeclaration decl = context.getRegisteredDeclaration <IDeclaration>(type.GetTypeName()); if (decl == null) { throw new SyntaxError("Unknown identifier: " + type.GetTypeName()); } else if (decl is MethodDeclarationMap) { MethodDeclarationMap map = (MethodDeclarationMap)decl; if (map.Count == 1) { return(new MethodType(map.GetFirst())); } else { throw new SyntaxError("Ambiguous identifier: " + type.GetTypeName()); } } else { return(decl.GetIType(context)); } }
public override ISet <IMethodDeclaration> GetMethodDeclarations(Context context) { HashSet <IMethodDeclaration> result = new HashSet <IMethodDeclaration>(); foreach (IType type in types) { if (type is MethodType) { MethodDeclarationMap decls = context.getRegisteredDeclaration <MethodDeclarationMap>(type.GetTypeName()); if (decls != null) { foreach (IMethodDeclaration decl in decls.Values) { result.Add(decl); } } } } if (result.Count > 0) { return(result); } else { return(base.GetMethodDeclarations(context)); } }
public override MethodDeclarationMap getMemberMethods(Context context, String name) { registerMethods(context); MethodDeclarationMap result = new MethodDeclarationMap(name); registerMemberMethods(context, result); return(result); }
private void registerDerivedMemberMethods(Context context, MethodDeclarationMap result) { if (derivedFrom == null) { return; } foreach (String ancestor in derivedFrom) { registerAncestorMemberMethods(ancestor, context, result); } }
public override ISet <IMethodDeclaration> GetMethodDeclarations(Context context) { if (type is MethodType) { MethodDeclarationMap decls = context.getRegisteredDeclaration <MethodDeclarationMap>(type.GetTypeName()); if (decls != null) { return(new HashSet <IMethodDeclaration>(decls.Values.Select(m => m.AsReference()))); } } return(base.GetMethodDeclarations(context)); }
private void registerAncestorMemberMethods(String ancestor, Context context, MethodDeclarationMap result) { IDeclaration actual = context.getRegisteredDeclaration <IDeclaration>(ancestor); if (actual == null || !(actual is ConcreteCategoryDeclaration)) { return; } ConcreteCategoryDeclaration cd = (ConcreteCategoryDeclaration)actual; cd.registerMemberMethods(context, result); }
private IMethodDeclaration getAbstractMethodDeclaration(Context context) { MethodDeclarationMap methods = context.getRegisteredDeclaration <MethodDeclarationMap>(type.GetTypeName()); if (methods != null) { return(methods.Values.FirstOrDefault(decl => decl.isAbstract())); } else { return(null); } }
private bool globalMethodExists(Context context, String name) { MethodDeclarationMap methods = context.getRegisteredDeclaration <MethodDeclarationMap>(name); if (methods == null) { return(false); } else { return(methods.ContainsKey(this.GetTypeName())); } }
private IDeclaration resolveUnresolvedMember(InstanceContext context, String name) { ConcreteCategoryDeclaration decl = context.getRegisteredDeclaration <ConcreteCategoryDeclaration>(context.getInstanceType().GetTypeName()); MethodDeclarationMap methods = decl.getMemberMethods(context, name); if (methods != null && methods.Count > 0) { return(methods); } else { return(null); } }
private IMethodDeclaration getDeclaration(Context context) { MethodDeclarationMap methods = context.getRegisteredDeclaration <MethodDeclarationMap>(name); if (methods != null) { IEnumerator <IMethodDeclaration> values = methods.Values.GetEnumerator(); values.MoveNext(); return(values.Current); } else { return(null); } }
private void registerThisMemberMethods(Context context, MethodDeclarationMap result) { if (methodsMap == null) { return; } IDeclaration actual; if (!methodsMap.TryGetValue(result.GetName(), out actual)) { return; } if (!(actual is MethodDeclarationMap)) { throw new SyntaxError("Not a member method!"); } foreach (IMethodDeclaration method in ((MethodDeclarationMap)actual).Values) { result.registerIfMissing(method, context); } }
public override IValue interpretReference(Context context) { // resolve parent to keep clarity IExpression parent = resolveParent(context); IValue instance = parent.interpret(context); if (instance == null || instance == NullValue.Instance) { throw new NullReferenceError(); } else if (instance is IInstance) { CategoryDeclaration category = ((IInstance)instance).getDeclaration(); MethodDeclarationMap methods = category.getMemberMethods(context, name); IMethodDeclaration method = methods.GetFirst(); // TODO check prototype return(new ClosureValue(context.newInstanceContext((IInstance)instance, true), new MethodType(method))); } else { throw new SyntaxError("Should never get here!"); } }
private IMethodDeclaration getDeclaration(Context context) { IExpression expression = this.expression; if (expression is UnresolvedSelector) { IExpression parent = ((UnresolvedSelector)expression).getParent(); if (parent != null) { IType type = parent.check(context); if (type is CategoryType) { expression = new UnresolvedIdentifier(((UnresolvedSelector)expression).getName(), Dialect.O); context = context.newInstanceContext((CategoryType)type, true); } else { return(null); // TODO report problem } } } if (expression is UnresolvedIdentifier) { String name = ((UnresolvedIdentifier)expression).ToString(); MethodDeclarationMap methods = context.getRegisteredDeclaration <MethodDeclarationMap>(name); if (methods != null) { return(methods.GetFirst()); } else { return(null); } } else { throw new NotImplementedException(); } }
public void testBreakpoint() { debugResource("debug/stack.pec"); thread.Start(); waitBlocked(); Assert.AreEqual(Status.SUSPENDED, debugger.getStatus()); Assert.AreEqual(MAIN_LINE, debugger.getLine()); MethodDeclarationMap mdm = context.getRegisteredDeclaration <MethodDeclarationMap>("printLevel2"); IEnumerator <IMethodDeclaration> emd = mdm.Values.GetEnumerator(); emd.MoveNext(); ConcreteMethodDeclaration cmd = (ConcreteMethodDeclaration)emd.Current; ISection section = cmd.getStatements()[0]; Assert.AreEqual(LEVEL_2_LINE + 1, section.Start.Line); section.Breakpoint = true; debugger.resume(); waitBlocked(); Assert.AreEqual(Status.SUSPENDED, debugger.getStatus()); Assert.AreEqual(LEVEL_2_LINE + 1, debugger.getLine()); debugger.resume(); thread.Join(); Assert.AreEqual("test123-ok", Out.read()); }
private void registerMemberMethods(Context context, MethodDeclarationMap result) { registerThisMemberMethods(context, result); registerDerivedMemberMethods(context, result); }