Beispiel #1
0
        //public Assigment ParseAssigment()
        //{

        //}

        public List <FullSignal> ParseSignals(string vhdl)
        {
            var signalSection         = Regex.Match(vhdl, signalSectionPattern).Value;
            List <FullSignal> signals = new List <FullSignal>();

            MatchesToStrings(Regex.Matches(signalSection, SignalPattern)).ForEach(x =>
            {
                Match pTypeMatch          = Regex.Match(x, PortType);
                var remainngWithValueType = x.Substring(pTypeMatch.Index + pTypeMatch.Length);
                var defaultPart           = Regex.Match(remainngWithValueType, Default).Value;
                var portEnumeration       = Regex.Match(remainngWithValueType, Enumeration).Value;

                var newSignal = new FullSignal()
                {
                    Name         = Regex.Match(x, PortName).Value,
                    ValueType    = pTypeMatch.Value,
                    DefaultValue = defaultPart != String.Empty ? Regex.Match(defaultPart, DefaultValue).Value : null,
                    Enumeration  = !String.IsNullOrWhiteSpace(portEnumeration) ? ParseEnumeration(portEnumeration) : null
                };

                signals.Add(newSignal);
            });

            return(signals);
        }
        public VHDLDocument Watermark(WatermarkOptions options)
        {
            //-----------------DECODER----------------------------------------
            FullSignal isWatermark = new FullSignal
            {
                Name        = "IS_WATERMARK",
                ValueType   = "STD_LOGIC",
                Enumeration = null
            };

            _document.AddSignal(isWatermark);

            Decoder decoder = new Decoder(isWatermark);

            decoder.CodedSignals.AddRange(options.WatermarkSettings.Where(x => x.IsUsed).ToList());
            //-----------------DECODER----------------------------------------

            _document.AddVHDLInBehaviorSection(decoder.ToString());

            FullSignal watermarkedSignal = new  FullSignal()
            {
                Name      = "WATERMARKED_OUT",
                ValueType = StdLogicVector,
            };


            List <PartialSignal> stSignalBits = new List <PartialSignal>();
            int i = 0;

            _document.FreeLuts.ForEach(lut =>
            {
                ChangeLutConstIputs(lut, isWatermark, _document.ConstValueGenerators);

                ChangeLutInitVector(lut, true);


                var newSignal = watermarkedSignal.CreatePartial(new SimpleIndex(i));
                stSignalBits.Add(newSignal);

                InjectLutOutput(lut, newSignal);

                i++;
            });

            watermarkedSignal.Enumeration = new ComplexEnumeration(stSignalBits.Sum(x => x.Bits),
                                                                   EnumerationDirections.Downto);


            _document.AddSignal(watermarkedSignal);

            i = 0;
            options.SignatureOutputSettings.Where(y => y.IsUsed).ToList().ForEach(x =>
            {
                FullSignal fictionOutSignal = new FullSignal()
                {
                    Name        = "FICTION_OUT" + i,
                    ValueType   = x.Port.ValueType,
                    Enumeration = x.Port.Enumeration
                };
                _document.AddSignal(fictionOutSignal);
                _document.Redirect(x.Port, fictionOutSignal);                                                                                                                                    //TODO
                _document.AddMuxAssigment(x.Port, isWatermark + " = '1'", watermarkedSignal.CreatePartial(new ComplexEnumeration(x.Port.Bits, EnumerationDirections.Downto)), fictionOutSignal); //TODO
                i++;
            });

            return(_document);
        }