Esempio n. 1
0
            public static string ComponentEventOutputs(IEnumerable <Connection> connections, bool useProcesses)
            {
                string outputsString = "-- ComponentEventOutputs\n";

                if (useProcesses)
                {
                    foreach (string output in _getInternalEventOutputStrings(connections))
                    {
                        outputsString += String.Format(Smv.NextVarAssignment, output, Smv.False);
                    }
                }
                else
                {
                    foreach (string output in _getInternalEventOutputs(connections))
                    {
                        string[] outpSplit = Smv.SplitConnectionVariableName(output);
                        bool     alreadyChecked;
                        string   varName = Smv.ConvertConnectionVariableName(output, Smv.ModuleParameters.Event, out alreadyChecked);

                        string setRule   = String.Format("\t{0}.{1}_set : {2};\n", outpSplit[0], Smv.ModuleParameters.Event(outpSplit[1]), Smv.True);
                        string resetRule = String.Format("\t{0} : {1};\n", Smv.True, Smv.False);
                        outputsString += String.Format(Smv.EmptyNextCaseBlock, varName, setRule + resetRule);
                    }
                }
                return(outputsString);
            }
Esempio n. 2
0
            public static string InternalEventConnections(IEnumerable <Connection> internalBuffers, bool useProcesses)
            {
                string            eventConnections    = "-- _internalEventConnections\n";
                MultiMap <string> eventConnectionsMap = _getEventConnectionsMap(internalBuffers);
                List <string>     definesList         = new List <string>();

                foreach (string dst in eventConnectionsMap.Keys)
                {
                    bool   dstComponent;
                    string dstSmvVar = Smv.ConvertConnectionVariableName(dst, Smv.ModuleParameters.Event, out dstComponent);

                    string srcString = "\t("; //+ srcSmvVar + " : " + Smv.True + ";\n";
                    foreach (string src in eventConnectionsMap[dst])
                    {
                        bool   srcComponent;
                        string srcSmvVar = Smv.ConvertConnectionVariableName(src, Smv.ModuleParameters.Event, out srcComponent);
                        if (srcComponent)
                        {
                            srcString += srcSmvVar + " | ";
                        }
                        else
                        {
                            srcString += String.Format("({0} & {1}) | ", srcSmvVar, Smv.Alpha);
                        }
                    }

                    srcString = srcString.TrimEnd(Smv.OrTrimChars) + ")";
                    if (useProcesses)
                    {
                        srcString        += " : " + Smv.True + ";\n";
                        eventConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar, srcString);
                    }
                    else
                    {
                        string reset_string;
                        if (dstComponent)
                        {
                            string[] connectionDst = Smv.SplitConnectionVariableName(dst);
                            reset_string      = String.Format("\t({0}.{1}_reset) : {2};\n", connectionDst[0], Smv.ModuleParameters.Event(connectionDst[1]), Smv.False);
                            srcString        += " : " + Smv.True + ";\n";
                            eventConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar, srcString + reset_string);
                        }
                        else
                        {
                            //reset_string = String.Format("\t{0} : {1};\n", Smv.True, Smv.False);
                            //srcString = srcString.TrimEnd(Smv.OrTrimChars) + ") : " + Smv.True + ";\n";
                            //eventConnections += String.Format(Smv.EmptyNextCaseBlock + "\n", dstSmvVar, srcString + reset_string);
                            dstSmvVar += "_set";
                            definesList.Add(String.Format(Smv.DefineBlock, dstSmvVar, srcString));
                        }
                    }
                }

                foreach (string def in definesList)
                {
                    eventConnections += def;
                }
                return(eventConnections);
            }
Esempio n. 3
0
            private static Variable _findVariable(string connectionPoint, IEnumerable <Variable> allVariables, IEnumerable <FBInstance> instances)
            {
                string[]   nameSplit = Smv.SplitConnectionVariableName(connectionPoint);
                FBInstance fbInst    = instances.FirstOrDefault(inst => inst.Name == nameSplit[0]);
                Variable   foundVar  = allVariables.FirstOrDefault(v => v.FBType == fbInst.InstanceType && v.Name == nameSplit[1]);

                return(foundVar);
            }