Example #1
0
 public CompositionExp(FastToken func, BuiltinTransExp arg1, BuiltinTransExp arg2)
     : base(func, 2, BuiltinTransExpKind.Composition)
 {
     this.arg1 = arg1;
     this.arg2 = arg2;
 }
 internal static TreeTransducer getTreeAutomatonFromExpr(BuiltinTransExp expr, FastTransducerInstance fti, Dictionary<string, Def> defs)
 {
     Stopwatch stopwatch = new Stopwatch();
     switch (expr.kind)
     {
         case (BuiltinTransExpKind.Composition):
             {
                 var castExpr = expr as CompositionExp;
                 var a = getTreeAutomatonFromExpr(castExpr.arg1, fti, defs);
                 var b = getTreeAutomatonFromExpr(castExpr.arg2, fti, defs);
                 stopwatch.Start();
                 var comp = TreeTransducer.ComposeR(a, b).RemoveMultipleInitialStates();
                 stopwatch.Stop();
                 fti.fastLog.WriteLog(LogLevel.Normal, string.Format("compose of {0} and {1}: {2} ms", castExpr.arg1.ToString(), castExpr.arg2.ToString(), stopwatch.ElapsedMilliseconds));
                 return comp;
             }
         case (BuiltinTransExpKind.RestrictionInp):
             {
                 var castExpr = expr as RestrictionInpExp;
                 var a = getTreeAutomatonFromExpr(castExpr.arg1, fti, defs);
                 var b = getTreeAutomatonFromExpr(castExpr.arg2, fti, defs);
                 stopwatch.Start();
                 var res = a.RestrictDomain(b).RemoveMultipleInitialStates();
                 stopwatch.Stop();
                 fti.fastLog.WriteLog(LogLevel.Normal, string.Format("compose of {0} and {1}: {2} ms", castExpr.arg1.ToString(), castExpr.arg2.ToString(), stopwatch.ElapsedMilliseconds));
                 return res;
             }
         case (BuiltinTransExpKind.RestrictionOut):
             {
                 var castExpr = expr as RestrictionOutExp;
                 var a = getTreeAutomatonFromExpr(castExpr.arg1, fti, defs);
                 var b = getTreeAutomatonFromExpr(castExpr.arg2, fti, defs);
                 stopwatch.Start();
                 var res = a.RestrictRange(b).RemoveMultipleInitialStates();
                 stopwatch.Stop();
                 fti.fastLog.WriteLog(LogLevel.Normal, string.Format("compose of {0} and {1}: {2} ms", castExpr.arg1.ToString(), castExpr.arg2.ToString(), stopwatch.ElapsedMilliseconds));
                 return res;
             }
         case (BuiltinTransExpKind.Var):
             {
                 var castExpr = expr as TransNameExp;
                 return fti.treeDefinitions[castExpr.domain.name.text].transducers[castExpr.func.name.text];
             }
         default:
             {
                 throw new FastException(FastExceptionKind.NotImplemented);
             }
     }
     throw new FastException(FastExceptionKind.InternalError);
 }
Example #3
0
 public TreeAppDef(FastToken acc, FastToken alphabet, BuiltinTransExp tran, FExp tree)
     : base(acc, alphabet, TreeDefKind.Apply)
 {
     this.transducer = tran;
     this.expr = tree;
 }
Example #4
0
 public TypecheckQueryDef(FastToken isempty, BuiltinLangExp input, BuiltinTransExp trans, BuiltinLangExp output)
     : base(isempty)
 {
     this.trans = trans;
     this.input = input;
     this.output = output;
 }
Example #5
0
 public TransDefDef(FastToken name, FastToken alphabet1, FastToken alphabet2, BuiltinTransExp expr)
     : base(DefDefKind.Trans, new FastSort(alphabet1, FastSortKind.Tree))
 {
     this.func = new FuncSymbol(name, 1);
     range = new FastSort(alphabet2, FastSortKind.Tree);
     this.expr = expr;
 }
Example #6
0
 public TransEquivQueryDef(FastToken equiv, BuiltinTransExp trans1, BuiltinTransExp trans2)
     : base(equiv, trans1, trans2, true)
 {
     this.trans1 = trans1;
     this.trans2 = trans2;
 }
Example #7
0
 public RestrictionOutExp(FastToken func, BuiltinTransExp arg1, BuiltinLangExp arg2)
     : base(func, 2, BuiltinTransExpKind.RestrictionOut)
 {
     this.arg1 = arg1;
     this.arg2 = arg2;
 }
Example #8
0
 public PreimageExp(FastToken func, BuiltinTransExp arg1, BuiltinLangExp arg2)
     : base(func, 2, BuiltinLangExpKind.Preimage)
 {
     this.arg1 = arg1;
     this.arg2 = arg2;
 }
Example #9
0
 public IsEmptyTransQueryDef(FastToken isempty, BuiltinTransExp trans)
     : base(isempty, trans, true)
 {
     this.trans = trans;
 }
Example #10
0
 public DomainExp(FastToken func, BuiltinTransExp arg1)
     : base(func, 1, BuiltinLangExpKind.Domain)
 {
     this.arg1 = arg1;
 }
        //Generate CSharp for trans expr inside a definition
        private static bool GenerateDefExpr(BuiltinTransExp expr, StringBuilder sb, string tree, int varIndex, out int nextVar)
        {
            switch (expr.kind)
            {
                case (BuiltinTransExpKind.Composition):
                    {
                        var ce = expr as CompositionExp;

                        int x, y;
                        sb.AppendLine(string.Format("List<Tree{0}> o{1} = new List<Tree{0}>();", ce.arg1.range.name, varIndex+1));
                        GenerateDefExpr(ce.arg1, sb, tree, varIndex+1, out x);

                        sb.AppendLine(string.Format("List<Tree{0}> o{1} = new List<Tree{0}>();", ce.arg2.range.name, x));
                        sb.Append(string.Format("foreach(var v1 in o{0})",varIndex+1));
                        sb.AppendLine("{");
                        GenerateDefExpr(ce.arg2, sb, "v1",x, out y);
                        sb.AppendLine("}");

                        if (varIndex == 0)
                            sb.AppendLine(string.Format("return o{0};", x));
                        else
                            sb.AppendLine(string.Format("o{0}=o{1};",varIndex, x));

                        nextVar = y;
                        break;
                    }
                case (BuiltinTransExpKind.RestrictionInp):
                    {
                        var ce = expr as RestrictionInpExp;

                        int x, y;

                        sb.AppendLine(string.Format("bool b{0};", varIndex + 1));
                        GenerateDefExpr(ce.arg2, sb, tree, varIndex + 1, out x);

                        sb.AppendLine(string.Format("List<Tree{0}> o{1} = new List<Tree{0}>();", ce.arg1.range.name, x));
                        sb.AppendLine(string.Format("if(b{0})", varIndex + 1));
                        sb.AppendLine("{");
                        GenerateDefExpr(ce.arg1, sb, tree, x, out y);
                        sb.AppendLine("}");

                        if (varIndex == 0)
                            sb.AppendLine(string.Format("return o{0};", x));
                        else
                            sb.AppendLine(string.Format("o{0}=o{1};", varIndex, x));

                        nextVar = y;
                        break;
                    }
                case (BuiltinTransExpKind.RestrictionOut):
                    {
                        var ce = expr as RestrictionOutExp;

                        int x, y;

                        sb.AppendLine(string.Format("List<Tree{0}> o{1} = new List<Tree{0}>();", ce.arg1.range.name, varIndex + 1));
                        GenerateDefExpr(ce.arg1, sb, tree, varIndex + 1, out x);

                        sb.Append(string.Format("foreach(var v1 in o{0})", varIndex + 1));
                        sb.AppendLine("{");
                        sb.AppendLine(string.Format("bool b{0};", x));
                        GenerateDefExpr(ce.arg2, sb, "v1", x, out y);
                        sb.AppendLine(string.Format("if(b{0})", x));
                        if (varIndex == 0)
                            sb.AppendLine(string.Format("yield return v1;"));
                        else
                            sb.AppendLine(string.Format("o{0}.Add(v1);", varIndex));
                        sb.AppendLine("}");

                        nextVar = y;
                        break;
                    }
                case (BuiltinTransExpKind.Var):
                    {
                        if(varIndex==0)
                            sb.AppendLine(string.Format("return {0}.{1}();", tree, expr.func.name.text));
                        else
                            sb.AppendLine(string.Format("o{0}.AddRange({1}.{2}());", varIndex, tree, expr.func.name.text));

                        nextVar = varIndex + 1;
                        break;
                    }
                default:
                    {
                        throw new FastException(FastExceptionKind.NotImplemented);
                    }

            }
            return true;
        }