public void SymbolTable_Basics() { var st = new SymbolTable <string, string>(parent: null) { { "bar", "foo" }, { "baz", "qux" }, }; Assert.IsNull(st.Parent); Assert.ThrowsException <InvalidOperationException>(() => st.Add("bar", "qux")); Assert.IsTrue(st.TryGetValue("bar", out Indexed <string> foo)); Assert.AreEqual("foo", foo.Value); Assert.AreEqual(0, foo.Index); Assert.AreEqual(foo, st["bar"]); Assert.IsTrue(st.TryGetValue("baz", out Indexed <string> qux)); Assert.AreEqual("qux", qux.Value); Assert.AreEqual(1, qux.Index); Assert.IsFalse(st.TryGetValue("foo", out Indexed <string> unk)); Assert.IsTrue(st.ToArray().SequenceEqual(new[] { new Indexed <KeyValuePair <string, string> >(new KeyValuePair <string, string>("bar", "foo"), 0), new Indexed <KeyValuePair <string, string> >(new KeyValuePair <string, string>("baz", "qux"), 1) })); Assert.IsNotNull(((IEnumerable)st).GetEnumerator()); CollectionAssert.AreEqual(new[] { "bar", "baz" }, st.Symbols.ToArray()); }
sunStorableSymbol AddSystemVariable(string name) { var symbol = Scopes.DeclareVariable(MangleSystemSymbol(name)); SymbolTable.Add(symbol); return(symbol); }
public override void VisitEnter(Line line) { if (line.Type == LineType.Label) { _symbolTable.Add(new Symbol(line.Label, SymbolType.Label, _address)); } }
sunCallableSymbol AddSystemBuiltin(string name) { var symbol = new sunBuiltinSymbol(name, SymbolTable.Count); SymbolTable.Add(symbol); return(symbol); }
void HandleTcpMessage(ITcpMessage msg) { switch (msg) { case ObjectCreatedMessage objMsg: { var id = objMsg.ObjectId; Objects[id] = new SyncObject(this, id, objMsg.OriginalNodeId); if (creationQueue.Count > 0 && objMsg.OriginalNodeId == NodeId) { lock (creationQueue) { creationQueue.Dequeue().SetResult(id); } } Logger.Debug("Client", $"Received ObjectId={id}"); InvokeObjectCreated(id); break; } case ObjectDeletedMessage delMsg: { var id = delMsg.ObjectId; Objects.Remove(id); Logger.Debug("Client", $"Received Deletion of ObjectId={id}"); InvokeObjectDeleted(id); break; } case SymbolRegisteredMessage symMsg: { SymbolTable.Add(symMsg.Symbol, symMsg.SymbolId); if (symbolNotifier.IsWaiting(symMsg.Symbol)) { symbolNotifier.Notify(symMsg.Symbol, symMsg.SymbolId); } Logger.Debug("Client", $"Received Symbol {symMsg.Symbol}->{symMsg.SymbolId}"); break; } case EventSentMessage eventSentMessage: { HandleEventSentMessage( eventSentMessage.Name, eventSentMessage.Sender, eventSentMessage.Receiver, eventSentMessage.Args ); break; } } }
InterfaceType GetInterface(System.Type type, SymbolTable bindings) { string name = GetName(type); InterfaceType t = new InterfaceType(new InputElement(name), bindings); bindings.Add(t.Name, t); return((InterfaceType)FillIn(t, type)); }
public void FourSymbolsTwoDuplicatedOnce_WillReturnTwoEntries() { // Arrange var symbolTable = new SymbolTable(); symbolTable.Add(new Symbol("a", QLType.Decimal, null)); symbolTable.Add(new Symbol("a", QLType.Decimal, null)); symbolTable.Add(new Symbol("d", QLType.Decimal, null)); symbolTable.Add(new Symbol("d", QLType.Boolean, null)); // Act & Assert var duplicateDetector = new DuplicateSymbolDetectionPipelineElement(); var task = new ParsingTask(""); task.SymbolTable = symbolTable; Assert.AreEqual(2, duplicateDetector.Process(task).Errors.Count); }
StructType GetStruct(System.Type type, SymbolTable bindings) { string name = GetName(type); StructType t = new StructType(new InputElement(name), bindings); bindings.Add(t.Name, t); return((StructType)FillIn(t, type)); }
ClassType GetClass(System.Type type, SymbolTable bindings) { string name = GetName(type); ClassType t = new ClassType(new InputElement(name), bindings); bindings.Add(t.Name, t); return(FillIn(t, type)); }
public void UnknownIdentifierWithTypoTests() { SymbolTable.Add("soldHouseIn2010", QValueType.Boolean); QLSNode node = QLSParserHelper.Parse(simpleWithTypoInQLS); var analyser = new UnknownIdentifiersAnalyser(); var isValid = analyser.Analyse(node); Assert.IsFalse(isValid); }
private int AddKey(T v) { int vertexIndex = SymbolTable.Count; v.Id = vertexIndex; SymbolTable.Add(v, vertexIndex); Keys.Add(vertexIndex, v); return(vertexIndex); }
public override void WriteToTable(SymbolTable table) { table.Add(this); foreach (var item in _types) { item.WriteToTable(table); } }
public void NoIdentifiersAreUsed() { SymbolTable.Add("soldHouseIn2010", QValueType.Boolean); QLSNode node = QLSParserHelper.Parse(simpleWithouIdentifiersQLS); var analyser = new AllIdentifiersAreUsedAnalyser(); var result = analyser.Analyse(node); Assert.IsFalse(result); }
public override void VisitEnter(Line line) { if (line.Type == LineType.Label) { var pseudoAddress = 0; // just a filler _symbolTable.Add(new MSILSymbol(line.Label, SymbolType.Label, pseudoAddress, _gen.DefineLabel())); } }
public override void WriteToTable(SymbolTable table) { table.Add(this); foreach (var item in _members) { item.definition.WriteToTable(table); } }
public static EvalResult add_definition(SymbolTable symbols, FunCall val) { var new_fun_name = val.args[0].args.First().value.value; var parameters = FunCall.id_list(val.args[0].flattened_args().Skip(1).ToList()); var fun_body = val.args[1]; symbols.Add(new_fun_name, FunCall.id_list(new List<FunCall> { parameters, fun_body })); return new EvalResult(new EvalT(symbols, new FunCall(Token.symbol("Function Defined")))); }
public bool AddVariable(string id, QValueType type) { if (!SymbolTable.Add(id, type)) { Analyser.AddMessage(string.Format("Duplicate identifier {0} {1}", id, type), MessageType.ERROR); return(false); } return(true); }
public override bool TrySetSymbol(AstSymbol?symbol) { var success = base.TrySetSymbol(symbol); if (success) { symbol !.SymbolTable.Add(FunctionType); } return(success); }
public static SymbolTable AddExtensionSymbols(this SymbolTable t) { // Add lock here to ensure thread safety when modifying a symbol table lock (_lock) { // Check whether extension method already exists if (t.Filter("nodesByType", 2).Count() == 0) { t.Add("nodesByType", (IEnumerable <ITypedElement> f, string typeName) => NodesByType(f, typeName), doNullProp: true); } if (t.Filter("nodesByName", 2).Count() == 0) { t.Add("nodesByName", (IEnumerable <ITypedElement> f, string name) => NodesByName(f, name), doNullProp: true); } } return(t); }
private bool AddVariable(string id, QValueType type) { VisitedIDs.Add(id); if (!SymbolTable.Add(id, type)) { Analyser.AddMessage(string.Format("Duplicate identifier {0} {1}", id, type), Language.QL, MessageType.ERROR); return(false); } return(true); }
// callables public sunBuiltinSymbol DeclareBuiltin(sunBuiltinDeclaration node) { if (SymbolTable.Get <sunCallableSymbol>().Any(i => i.Name == node.Name.Value)) { throw new sunRedeclaredBuiltinException(node); } var symbol = new sunBuiltinSymbol(node.Name.Value, node.Parameters.ParameterInfo, SymbolTable.Count); SymbolTable.Add(symbol); return(symbol); }
public Block Build() { SymbolTable symbols = new SymbolTable(); for (int i = this.symbolStart; i < this.symbols.Symbols.Count; i++) { symbols.Add(this.symbols.Symbols[i]); } return(new Block(this.index, symbols, this.context, this.facts, this.rules, this.checks)); }
public static SymbolTable AddFhirExtensions(this SymbolTable t) { t.Add("hasValue", (ITypedElement f) => f.HasValue(), doNullProp: false); t.Add("resolve", (ITypedElement f, EvaluationContext ctx) => resolver(f, ctx), doNullProp: false); t.Add("htmlchecks", (ITypedElement f) => f.HtmlChecks(), doNullProp: false); return(t); ITypedElement resolver(ITypedElement f, EvaluationContext ctx) { if (ctx is FhirEvaluationContext fctx) { return(f.Resolve(fctx.ElementResolver)); } else { return(f.Resolve()); } } }
public override IValue Evaluate() { // 3.4.1: If <cc-var-lhs> is a <TYPED-NAME> with a <type-suffix>, the <type-suffix> is ignored. var identifier = _identifier.Evaluate().AsString; var constantValue = _expression.Evaluate(); _symbolTable.Add(identifier, constantValue); return(new LivelinessExpression( isAlive: new ConstantExpression(new BoolValue(false)), code: _tokenText).Evaluate()); }
public void TestStr() { World w = new World(); SymbolTable syms = new SymbolTable(); ID app_0 = syms.Add("app_0"); ID app_1 = syms.Add("app_1"); ID app_2 = syms.Add("app_2"); ulong route = syms.Insert("route"); ulong suff = syms.Insert("route suffix"); w.AddFact(new Fact(new Predicate(route, Arrays.AsList(new ID.Integer(0), app_0, new ID.Str("example.com"))))); w.AddFact(new Fact(new Predicate(route, Arrays.AsList(new ID.Integer(1), app_1, new ID.Str("test.com"))))); w.AddFact(new Fact(new Predicate(route, Arrays.AsList(new ID.Integer(2), app_2, new ID.Str("test.fr"))))); w.AddFact(new Fact(new Predicate(route, Arrays.AsList(new ID.Integer(3), app_0, new ID.Str("www.example.com"))))); w.AddFact(new Fact(new Predicate(route, Arrays.AsList(new ID.Integer(4), app_1, new ID.Str("mx.example.com"))))); HashSet <Fact> res = TestSuffix(w, syms, suff, route, ".fr"); foreach (Fact f in res) { Console.WriteLine("\t" + syms.PrintFact(f)); } var expected = new HashSet <Fact>(Arrays.AsList(new Fact(new Predicate(suff, Arrays.AsList(app_2, new ID.Str("test.fr")))))); Assert.IsTrue(expected.SequenceEqual(res)); res = TestSuffix(w, syms, suff, route, "example.com"); foreach (Fact f in res) { Console.WriteLine("\t" + syms.PrintFact(f)); } expected = new HashSet <Fact>(Arrays.AsList(new Fact(new Predicate(suff, Arrays.AsList( app_0, new ID.Str("example.com")))), new Fact(new Predicate(suff, Arrays.AsList(app_0, new ID.Str("www.example.com")))), new Fact(new Predicate(suff, Arrays.AsList(app_1, new ID.Str("mx.example.com")))))); Assert.IsTrue(expected.SequenceEqual(res)); }
public CSScanner(SymbolTable <TRecord, TType> .CreateRecordDelegate createSymbolRecord, CreateSrcObjDelegate createSourceObject, TType[] types) { m_symbolTable = new SymbolTable <TRecord, TType>(createSymbolRecord); CreateSourceObject += createSourceObject; m_typeList = types; foreach (string symbol in Settings.Default.Keywords.Split(' ')) { m_symbolTable.Add(symbol, types[0]); } foreach (string symbol in Settings.Default.Modifiers.Split(' ')) { m_symbolTable.Add(symbol, types[1]); } foreach (string symbol in Settings.Default.Operators.Split(' ')) { m_symbolTable.Add(symbol, types[2]); } }
public void InValidBoolComparisonTest() { SymbolTable.Add("TestBool", QValueType.Boolean); var left = new IdentifierNode(new Location(0, 0), "TestBool"); var right = new LiteralNode(new Location(0, 0), "false", QValueType.Integer); var comparisonNode = new LogicalExpressionNode(new Location(0, 0), left, LogicalOperator.Or, right); var analyser = new StatementTypeAnalyser(); var result = analyser.Analyse(comparisonNode); Assert.IsFalse(result); }
public void TestResource() { World w = new World(); SymbolTable syms = new SymbolTable(); ID authority = syms.Add("authority"); ID ambient = syms.Add("ambient"); ulong resource = syms.Insert("resource"); ulong operation = syms.Insert("operation"); ulong right = syms.Insert("right"); ID file1 = syms.Add("file1"); ID file2 = syms.Add("file2"); ID read = syms.Add("read"); ID write = syms.Add("write"); w.AddFact(new Fact(new Predicate(resource, Arrays.AsList(ambient, file2)))); w.AddFact(new Fact(new Predicate(operation, Arrays.AsList(ambient, write)))); w.AddFact(new Fact(new Predicate(right, Arrays.AsList(authority, file1, read)))); w.AddFact(new Fact(new Predicate(right, Arrays.AsList(authority, file2, read)))); w.AddFact(new Fact(new Predicate(right, Arrays.AsList(authority, file1, write)))); ulong caveat1 = syms.Insert("caveat1"); //r1: caveat2(#file1) <- resource(#ambient, #file1) Rule r1 = new Rule( new Predicate(caveat1, Arrays.AsList(file1)), Arrays.AsList(new Predicate(resource, Arrays.AsList(ambient, file1)) ), new List <Biscuit.Datalog.Expressions.Expression>()); Console.WriteLine("testing caveat 1(should return nothing): " + syms.PrintRule(r1)); var res = w.QueryRule(r1); Console.WriteLine(res); foreach (Fact f in res) { Console.WriteLine("\t" + syms.PrintFact(f)); } Assert.IsTrue(res.IsEmpty()); ulong caveat2 = syms.Insert("caveat2"); ulong var0_id = syms.Insert("var0"); ID var0 = new ID.Variable(var0_id); //r2: caveat1(0?) <- resource(#ambient, 0?) && operation(#ambient, #read) && right(#authority, 0?, #read) Rule r2 = new Rule( new Predicate(caveat2, Arrays.AsList(var0)), Arrays.AsList( new Predicate(resource, Arrays.AsList(ambient, var0)), new Predicate(operation, Arrays.AsList(ambient, read)), new Predicate(right, Arrays.AsList(authority, var0, read)) ), new List <Biscuit.Datalog.Expressions.Expression>()); Console.WriteLine("testing caveat 2: " + syms.PrintRule(r2)); res = w.QueryRule(r2); Console.WriteLine(res); foreach (Fact f in res) { Console.WriteLine("\t" + syms.PrintFact(f)); } Assert.IsTrue(res.IsEmpty()); }
public void InitializeSymbols() { ImportedMethod currentMethod = Scope.TryImportCurrentMethod(); if (currentMethod == null) { return; // Nothing to evaluate if we can't get the current method } // Add compiler intrinsics AddIntrinsics(); // Add debugger intrinsics // (Not implemented yet) // Add globals ImportedType type = currentMethod.DeclaringType; foreach (ImportedField importedfield in type.GetFields()) { IrisType irisType = importedfield.FieldType; if (irisType != IrisType.Invalid) { SymbolTable.Add(importedfield.Name, irisType, StorageClass.Global, importedfield); } } // Add methods foreach (ImportedMethod importedMethod in type.GetMethods()) { Method method = importedMethod.ConvertToIrisMethod(); if (IsValidMethod(method)) { SymbolTable.Add(importedMethod.Name, method, StorageClass.Global, importedMethod); } } // Create symbol for query method and transition the SymbolTable to method scope _irisMethod = currentMethod.ConvertToIrisMethod(); SymbolTable.OpenMethod("$.query", _irisMethod); // Add symbols for parameters foreach (Variable param in _irisMethod.GetParameters()) { SymbolTable.Add(param.Name, param.Type, StorageClass.Argument); } // Add symbols for local variables foreach (LocalVariable local in Scope.GetLocals()) { SymbolTable.Add(local.Name, local.Type, StorageClass.Local, local.Slot); } }
AddNewSymbolRec(SymbolTableRecord newRec) { Debug.Assert(m_trans != null); ObjectId tblId = Utils.SymTbl.GetSymbolTableId(newRec.GetType(), m_db); SymbolTable tbl = (SymbolTable)m_trans.GetObject(tblId, OpenMode.ForWrite); Debug.Assert(tbl.Has(newRec.Name) == false); tbl.Add(newRec); m_trans.AddNewlyCreatedDBObject(newRec, true); }
public Label AddLabel(InputElement label, MessageWriter msg) { Label t = LookupLabel(label); if (t != null) { msg.Error(label, "label '{0}' already defined at {1}", label.str, new Coordinate(t.id).ToString()); } t = new Label(label, labels); labels.Add(label.str, t); return(t); }
public CiParser() { SymbolTable globals = new SymbolTable(); globals.Add(CiBoolType.Value); globals.Add(CiByteType.Value); globals.Add(CiIntType.Value); globals.Add(CiStringPtrType.Value); globals.Add(new CiConst { Name = "true", Value = true, Type = CiBoolType.Value }); globals.Add(new CiConst { Name = "false", Value = false, Type = CiBoolType.Value }); globals.Add(new CiConst { Name = "null", Value = null, Type = CiType.Null }); this.Symbols = new SymbolTable { Parent = globals }; }
public static SymbolTable Refactor(this SymbolTable table, string function) { var st = new SymbolTable(null); foreach (var item in table) { var parts = item.Key.Split('_'); if (int.Parse(parts[2]) == 0) st.Add(SymbolTable.BuildSymbolId(function, parts[1], int.Parse(parts[2])), new Symbol { Function = function, Name = parts[1], Value = item.Value }); } return st; }
/// <summary> /// Initializes a struct declaration by passing a dictionary as the current members. /// </summary> /// <param name="theMembers">The dictionary with keyvaluepairs you know</param> internal StructDeclSymbol(Dictionary<string, Symbol> theMembers) : base() { members = new SymbolTable(); members.Add(theMembers); }
public static EvalResult evaluate_User_Function(SymbolTable symbols, FunCall fun_call) { FunCall definition = symbols[fun_call.value.value]; FunCall funArgs = definition.args[0]; FunCall funBody = definition.args[1]; if (fun_call.args.Count != funArgs.args.Count) return gen_function_call_error(fun_call, funArgs.args.Count); var arg_pairs = funArgs.args.Zip(fun_call.args, (a, b) => new Tuple<FunCall, FunCall>(a, b)); // Bind args and add to symbol table foreach (var arg_pair in arg_pairs) symbols.Add(arg_pair.Item1.value.value, arg_pair.Item2); return evaluate_FunCall(symbols, funBody); }
public void NullObjectsCannotBeAdded() { SymbolTable table = new SymbolTable(); Assert.Throws<NullReferenceException>(() => table.Add(null)); }