Beispiel #1
0
        protected override Expression compileBody(
            Dictionary <INode, string> symbols,
            Dictionary <INode, List <INode> > letEntries,
            HashSet <string> initializedIds,
            HashSet <string> conditionalIds)
        {
            var testBranch = arguments[_test].compile(symbols, letEntries, initializedIds, conditionalIds);

            var trueSet  = new HashSet <string>(initializedIds);
            var falseSet = new HashSet <string>(initializedIds);

            var trueCond  = new HashSet <string>(conditionalIds);
            var falseCond = new HashSet <string>(conditionalIds);

            var trueBranch  = arguments[_true].compile(symbols, letEntries, trueSet, trueCond);
            var falseBranch = arguments[_false].compile(symbols, letEntries, falseSet, falseCond);

            var alwaysInitialized = trueSet.Intersect(falseSet).ToList();

            conditionalIds.UnionWith(trueCond.Union(falseCond));
            conditionalIds.UnionWith(trueSet.Union(falseSet).Except(alwaysInitialized));

            initializedIds.UnionWith(alwaysInitialized);

            return(Expression.NewIf(testBranch, trueBranch, falseBranch));
        }
Beispiel #2
0
        private Expression __compileBody(
            Dictionary <INode, string> symbols,
            Dictionary <INode, List <INode> > letEntries,
            HashSet <string> initializedIds,
            HashSet <string> conditionalIds)
        {
            string symbol;

            if (symbols.TryGetValue(this, out symbol))
            {
                var body = Expression.NewId(symbol);
                if (conditionalIds.Contains(symbol))
                {
                    symbols.Remove(this);
                    var binding = compile(symbols, letEntries, initializedIds, conditionalIds);
                    symbols[this] = symbol;

                    body = Expression.NewIf(
                        Expression.NewId(symbol + "-init"),
                        body,
                        Expression.NewBegin(
                            Utils.MakeFSharpList(
                                Expression.NewSetId(symbol, binding),
                                Expression.NewSetId(symbol + "-init", Expression.NewNumber_E(1)),
                                body)));
                }
                else if (!initializedIds.Contains(symbol))
                {
                    symbols.Remove(this);
                    var binding = compile(symbols, letEntries, initializedIds, conditionalIds);
                    symbols[this] = symbol;

                    body = Expression.NewBegin(
                        Utils.MakeFSharpList(
                            Expression.NewSetId(symbol, binding),
                            Expression.NewSetId(symbol + "-init", Expression.NewNumber_E(1)),
                            body));

                    initializedIds.Add(symbol);
                }
                return(body);
            }
            else
            {
                return(compileBody(symbols, letEntries, initializedIds, conditionalIds));
            }
        }