internal static CodeObjectCreateExpression CreateSetCreateExpression(Set <int> set)
        {
            CodeObjectCreateExpression createSet =
                new CodeObjectCreateExpression(
                    CodeDomHelper.CreateGenericTypeReference("Set", new string[] { Constants.Int }));

            CodeExpressionCollection parameters = createSet.Parameters;

            if (set.Count == 1)
            {
                foreach (int i in set)
                {
                    parameters.Add(new CodePrimitiveExpression(i));
                }
            }
            else if (set.Count > 1)
            {
                CodeArrayCreateExpression array = new CodeArrayCreateExpression();
                array.CreateType = CodeDomHelper.CreateTypeReference(Constants.Int);

                CodeExpressionCollection initializers = array.Initializers;
                foreach (int i in set)
                {
                    initializers.Add(new CodePrimitiveExpression(i));
                }

                parameters.Add(array);
            }

            return(createSet);
        }
        internal static void CreateFSMStmt(FSM fsm, CodeStatementCollection stmts)
        {
            //First create: Dictionary<int, Transitions> transitions = new Dictionary<int,Transitions>();
            //Then create: transitions.Add(0, new Transitions(...));
            //Last: fsm = new DFA(start, new Set<int>(end), transitions);
            CodeTypeReference typeRef =
                CodeDomHelper.CreateGenericTypeReference("Dictionary", new string[] { Constants.Int, "Transitions" });

            stmts.Add(new CodeVariableDeclarationStatement(typeRef, Constants.TransitionsVar,
                                                           new CodeObjectCreateExpression(typeRef, new CodeExpression[] { })));

            //Then add all transitions
            Set <int> visited = new Set <int>();

            AddTransitions(fsm, fsm.Start, stmts, visited);

            //Clean up accept states
            Set <int> reachableAccept = new Set <int>();

            foreach (int state in fsm.Accept)
            {
                if (visited.Contains(state))
                {
                    reachableAccept.Add(state);
                }
            }

            stmts.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(Constants.FSMMember),
                                              new CodeObjectCreateExpression(new CodeTypeReference(Constants.FSMClass),
                                                                             new CodePrimitiveExpression(fsm.Start),
                                                                             CreateSetCreateExpression(reachableAccept),
                                                                             new CodeVariableReferenceExpression(Constants.TransitionsVar))));
        }
        internal static CodeObjectCreateExpression CreateSetCreateExpression(Set <int> set)
        {
            string[] strArrays = new string[] { "System.Int32" };
            CodeObjectCreateExpression createSet  = new CodeObjectCreateExpression(CodeDomHelper.CreateGenericTypeReference("Set", strArrays), new CodeExpression[0]);
            CodeExpressionCollection   parameters = createSet.Parameters;

            if (set.Count == 1)
            {
                foreach (int num in set)
                {
                    parameters.Add(new CodePrimitiveExpression((object)num));
                }
            }
            else if (set.Count > 1)
            {
                CodeArrayCreateExpression array = new CodeArrayCreateExpression()
                {
                    CreateType = CodeDomHelper.CreateTypeReference("System.Int32")
                };
                CodeExpressionCollection initializers = array.Initializers;
                foreach (int i in set)
                {
                    initializers.Add(new CodePrimitiveExpression((object)i));
                }
                parameters.Add(array);
            }
            return(createSet);
        }
Пример #4
0
        public static CodeTypeReference CreateGenericTypeReference(string type, string[] typeStrParams)
        {
            CodeTypeReference[] typeParams = new CodeTypeReference[(int)typeStrParams.Length];
            int index = 0;

            string[] strArrays = typeStrParams;
            for (int i = 0; i < (int)strArrays.Length; i++)
            {
                string str = strArrays[i];
                int    num = index;
                index           = num + 1;
                typeParams[num] = new CodeTypeReference(str);
            }
            return(CodeDomHelper.CreateGenericTypeReference(type, typeParams));
        }
        internal static void CreateFSMStmt(FSM fsm, CodeStatementCollection stmts)
        {
            string[]          strArrays = new string[] { "System.Int32", "Transitions" };
            CodeTypeReference typeRef   = CodeDomHelper.CreateGenericTypeReference("Dictionary", strArrays);

            stmts.Add(new CodeVariableDeclarationStatement(typeRef, "transitions", new CodeObjectCreateExpression(typeRef, new CodeExpression[0])));
            Set <int> visited = new Set <int>();

            FSMCodeDomHelper.AddTransitions(fsm, fsm.Start, stmts, visited);
            Set <int> reachableAccept = new Set <int>();

            foreach (int state in fsm.Accept)
            {
                if (visited.Contains(state))
                {
                    reachableAccept.Add(state);
                }
            }
            CodeVariableReferenceExpression codeVariableReferenceExpression = new CodeVariableReferenceExpression("validationStates");
            CodeTypeReference codeTypeReference = new CodeTypeReference("FSM");

            CodeExpression[] codePrimitiveExpression = new CodeExpression[] { new CodePrimitiveExpression((object)fsm.Start), FSMCodeDomHelper.CreateSetCreateExpression(reachableAccept), new CodeVariableReferenceExpression("transitions") };
            stmts.Add(new CodeAssignStatement(codeVariableReferenceExpression, new CodeObjectCreateExpression(codeTypeReference, codePrimitiveExpression)));
        }