C# SymbolTable.Add方法代码示例

        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 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;
        }

        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));
 }

 /// <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);
 }