Changeset 841


Ignore:
Timestamp:
Nov 12, 2009, 10:30:43 PM (12 years ago)
Author:
Sören Rinne
Message:
  • some changes in BM, BFP, LFSR, NLFSR
  • BFP now accepts x*.* instead of i_*.*
  • added 2 function parsers
Location:
trunk/CrypPlugins
Files:
13 added
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/BerlekampMassey/BerlekampMasseySettings.cs

    r304 r841  
    214214    public class BerlekampMasseySettings : ISettings
    215215    {
     216        #region Private variables
     217
     218        private bool hasChanges = false;
     219
     220        #endregion
     221
    216222        #region Public Xor specific interface
    217223
     
    242248        #endregion
    243249
    244         #region Private variables
    245 
    246         private bool hasChanges;
    247 
    248         #endregion
    249 
    250 
    251250        #region INotifyPropertyChanged Members
    252251
  • trunk/CrypPlugins/BooleanFunctionParser/BooleanFunctionParser.cs

    r832 r841  
    2323using System.Windows.Threading;
    2424using System.Threading;
     25// MathParser
     26using Cryptool.MathParser;
     27// RPNExpression
     28using Cryptool.RPNExpression;
    2529
    2630namespace Cryptool.BooleanFunctionParser
     
    5559        //public int inputThreeFlag = 0;
    5660        public int[] additionalInputsFlag = null;
     61        public TimeSpan maxDuration = TimeSpan.Parse("00.00:00:00");
     62        public TimeSpan overallDuration = TimeSpan.Parse("00.00:00:00");
     63        public int requests = 0;
     64        public MathParser.Parser p = new MathParser.Parser();
     65        public RPNExpr expr = new RPNExpr();
    5766
    5867        #endregion
     
    7382            booleanFunctionParserPresentation.textBoxInputFunction.TextChanged += textBoxInput_TextChanged;
    7483            booleanFunctionParserPresentation.textBoxInputData.TextChanged += textBoxInput_TextChanged;
     84            booleanFunctionParserPresentation.textBoxInputFunction2.TextChanged += textBoxInput_TextChanged;
     85            booleanFunctionParserPresentation.textBoxInputData2.TextChanged += textBoxInput_TextChanged;
    7586
    7687            CanChangeDynamicProperty = true;
     
    311322        public void PostExecution()
    312323        {
     324            //string temp = string.Format("{0:000}", overallDuration.Milliseconds);
     325            double ms_per_req = (double)(Convert.ToInt32(overallDuration.Seconds.ToString() + string.Format( "{0:000}", overallDuration.Milliseconds ))) / (double)requests;
     326            GuiLogMessage("Overall time used: " + overallDuration + ", which is " + overallDuration.Seconds + "s:" + string.Format( "{0:000}",overallDuration.Milliseconds) + "ms (for all requests)\nMaximum time used: " + maxDuration + ", which is " + maxDuration.Seconds + "s:" + string.Format( "{0:000}",maxDuration.Milliseconds) + "ms (for one request)\nOverall requests: " + requests + "\nTime used per request: " + string.Format("{0:F3}", ms_per_req) + "ms", NotificationLevel.Info);
    313327           
     328            requests = 0;
     329            maxDuration = TimeSpan.Parse("00.00:00:00");
     330            overallDuration = TimeSpan.Parse("00.00:00:00");
    314331        }
    315332
    316333        public void PreExecution()
    317334        {
    318            
     335            overallDuration = TimeSpan.Parse("00.00:00:00");
    319336        }
    320337
     
    375392
    376393            // replace variables with data
     394            // start counter
     395            DateTime startTime = DateTime.Now;
    377396            string strExpression = ReplaceVariables(function, inputVariables, dataTwo);
    378397            // test if function is valid
    379398            string strExpressionTested = TestFunction(strExpression);
    380             if (strExpressionTested == "foo")
     399            int outputInt = 0;
     400            if (strExpressionTested == null)
    381401            {
    382402                GuiLogMessage(strExpression + " is not a binary expression (e.g. 1 + 0 * 1). Aborting now.", NotificationLevel.Error);
     
    386406            {
    387407                //GuiLogMessage("Your expression with variables replaced: " + strExpression, NotificationLevel.Info);
    388                 output = EvaluateString(strExpressionTested);
    389             }
    390             // Just testing
    391             //bool[] test = (bool[])getCurrentValue("Input 2");
    392             //GuiLogMessage("InputTest: " + test[0].ToString(), NotificationLevel.Info);
    393 
    394             return Convert.ToInt32(output);
     408                //output = EvaluateString(strExpressionTested);
     409               
     410                // testing myself
     411                // start counter
     412                //DateTime startTime = DateTime.Now;
     413
     414                //for (int i = 65536; i > 0; i--)
     415                {
     416                    outputInt = Convert.ToInt32(EvaluateString(strExpressionTested));
     417                }
     418
     419                // stop counter
     420                DateTime stopTime = DateTime.Now;
     421                // compute timespan
     422                TimeSpan duration = stopTime - startTime;
     423                // compute overall time
     424                overallDuration += duration;
     425                if (maxDuration.CompareTo(duration) < 0)
     426                {
     427                    maxDuration = duration;
     428                    //GuiLogMessage("Time max used: " + maxDuration + ", which is " + maxDuration.Seconds + "s:" + maxDuration.Milliseconds + "ms", NotificationLevel.Info);
     429                }
     430                /*
     431                // testing MathParser
     432                if (p.Evaluate(strExpressionTested))
     433                {
     434                    // start counter
     435                    //startTime = DateTime.Now;
     436
     437                    //for (int i = 65536; i > 0; i--)
     438                    {
     439                        outputInt = Convert.ToInt32(p.Result);
     440                    }
     441
     442                    // stop counter
     443                    DateTime stopTime = DateTime.Now;
     444                    // compute timespan
     445                    TimeSpan duration = stopTime - startTime;
     446                    // compute overall time
     447                    overallDuration += duration;
     448                    if (maxDuration.CompareTo(duration) < 0)
     449                    {
     450                        maxDuration = duration;
     451                        //GuiLogMessage("Time max used: " + maxDuration + ", which is " + maxDuration.Seconds + "s:" + maxDuration.Milliseconds + "ms", NotificationLevel.Info);
     452                    }
     453                }
     454                else
     455                    GuiLogMessage("Parsing of function failed.", NotificationLevel.Error);
     456                *//*
     457                // testing RPNExpression
     458                ExprEnvironment environment = new ExprEnvironment();
     459                RPNFunctionUtils.RegisterFunctions(environment);
     460                expr.Environment = environment;
     461                expr.expression = strExpressionTested;
     462                try
     463                {
     464                    expr.Prepare();
     465                }
     466                catch (Exception ex)
     467                {
     468                    GuiLogMessage("Preparation for parsing failed: " + ex, NotificationLevel.Error);
     469                }
     470                //GuiLogMessage("Zeichenfolge: " + expr.GetValue().ToString(), NotificationLevel.Info);
     471                try
     472                {
     473                    // start counter
     474                    //DateTime startTime = DateTime.Now;
     475
     476                    for (int i = 65536; i > 0; i--)
     477                    {
     478                        outputInt = Convert.ToInt32(expr.GetValue());
     479                    }
     480
     481                    // stop counter
     482                    DateTime stopTime = DateTime.Now;
     483                    // compute timespan
     484                    TimeSpan duration = stopTime - startTime;
     485                    // compute overall time
     486                    overallDuration += duration;
     487                    if (maxDuration.CompareTo(duration) < 0)
     488                    {
     489                        maxDuration = duration;
     490                        //GuiLogMessage("Time max used: " + maxDuration + ", which is " + maxDuration.Seconds + "s:" + maxDuration.Milliseconds + "ms", NotificationLevel.Info);
     491                    }
     492                }
     493                catch (Exception ex)
     494                {
     495                    GuiLogMessage("Converting to Int32 failed: " + ex, NotificationLevel.Error);
     496                }
     497                */
     498                // count the requests
     499                requests++;
     500            }
     501
     502            //return Convert.ToInt32(output);
     503            return outputInt;
    395504        }
    396505
     
    409518        private string ReplaceVariables(string strExpressionWithVariables, bool[] externDataOne, bool []externDataTwo)
    410519        {
     520            // convert string into StringBuilder
     521            //StringBuilder strExpression = new StringBuilder(strExpressionWithVariables);
    411522            // remove spaces
    412523            string strExpression = strExpressionWithVariables.Replace(" ", "");
     524            //strExpression.Replace(" ", "");
    413525            // add * if there aren't any (and should be)
    414526            // example: x^2+x^2x^3 ==> x^2+x^2*x^3
    415             Regex makeStars = new Regex("([0-9])i");
    416             strExpression = makeStars.Replace(strExpression, new MatchEvaluator(makeStarsInText));
    417 
    418             // replace variables with value and get numeric values from boolean inputs (if there are any)
    419             /*if (inputOneFlag == 1 && inputVariableOne != null)
    420             {
    421                 char[] strInputVariableOne = new char[inputVariableOne.Length];
    422                 for (int i = inputVariableOne.Length - 1; i >= 0; i--)
    423                 {
    424                     // get numeric values from bool inputs
    425                     strInputVariableOne[i] = inputVariableOne[i] ? '1' : '0';
    426                     // replace variables with value
    427                     string replacement = "i_1." + i;
    428                     strExpression = strExpression.Replace(replacement, strInputVariableOne[i].ToString());
    429                 }
    430             }
    431             if (inputTwoFlag == 1 && inputVariableTwo != null)
    432             {
    433                 char[] strInputVariableTwo = new char[inputVariableTwo.Length];
    434                 for (int i = inputVariableTwo.Length - 1; i >= 0; i--)
    435                 {
    436                     // get numeric values from bool inputs
    437                     strInputVariableTwo[i] = inputVariableTwo[i] ? '1' : '0';
    438                     string replacement = "i_2." + i;
    439                     strExpression = strExpression.Replace(replacement, strInputVariableTwo[i].ToString());
    440                 }
    441             }
    442             if (inputThreeFlag == 1 && inputVariableThree != null)
    443             {
    444                 char[] strInputVariableThree = new char[inputVariableThree.Length];
    445                 for (int i = inputVariableThree.Length - 1; i >= 0; i--)
    446                 {
    447                     // get numeric values from bool inputs
    448                     strInputVariableThree[i] = inputVariableThree[i] ? '1' : '0';
    449                     string replacement = "i_3." + i;
    450                     strExpression = strExpression.Replace(replacement, strInputVariableThree[i].ToString());
    451                 }
    452             }*/
     527            //Regex makeStars = new Regex("([0-9])x");
     528            //strExpression = makeStars.Replace(strExpression, new MatchEvaluator(makeStarsInText));
     529           
    453530            // replace additional inputs data (if there are any)
     531            TokenList tokens = new TokenList();
    454532            for (int i = 0; i < inputs; i++)
    455533            {
     
    457535                {
    458536                    bool[] additionalTempValueBool = (bool[])methodGetValue("Input " + i);
    459                     char[] strInputVariableAditionalTemp = new char[additionalTempValueBool.Length];
     537                    //char[] strInputVariableAditionalTemp = new char[additionalTempValueBool.Length];
    460538                    for (int j = additionalTempValueBool.Length - 1; j >= 0; j--)
    461539                    {
    462540                        // get numeric values from bool inputs
    463                         strInputVariableAditionalTemp[j] = additionalTempValueBool[j] ? '1' : '0';
    464                         string replacement = "i_" + (i) + "." + j;
    465                         strExpression = strExpression.Replace(replacement, strInputVariableAditionalTemp[j].ToString());
     541                        //strInputVariableAditionalTemp[j] = additionalTempValueBool[j] ? '1' : '0';
     542                        //string replacement = "x" + (i) + "." + j;
     543                        //strExpression = strExpression.Replace(replacement, strInputVariableAditionalTemp[j].ToString());
     544                        tokens.Add("x" + (i) + "." + j, additionalTempValueBool[j] ? "1" : "0");
    466545                    }
    467546                }
    468547            }
    469             // replace extern data (i_0.*) (if there is any)
     548            // replace extern data (x0.*) (if there is any)
    470549            if (externDataOne != null && externDataOne.Length != 0)
    471550            {
    472                 char[] strInputVariableExtern = new char[externDataOne.Length];
    473                 for (int i = strInputVariableExtern.Length - 1; i >= 0; i--)
     551                //char[] strInputVariableExtern = new char[externDataOne.Length];
     552                for (int i = externDataOne.Length - 1; i >= 0; i--)
    474553                {
    475554                    // get numeric values from bool inputs
    476                     strInputVariableExtern[i] = externDataOne[i] ? '1' : '0';
    477                     string replacement = "i_0." + i;
    478                     strExpression = strExpression.Replace(replacement, strInputVariableExtern[i].ToString());
    479                 }
    480             }
    481             // replace quickwatch data (i_q.*) (if there is any)
     555                    //strInputVariableExtern[i] = externDataOne[i] ? '1' : '0';
     556                    //string replacement = "x0." + i;
     557                    //strExpression = strExpression.Replace(replacement, strInputVariableExtern[i].ToString());
     558                    tokens.Add("x0." + i, externDataOne[i] ? "1" : "0");
     559                }
     560            }
     561            // replace quickwatch data (xq.*) (if there is any)
    482562            if (settings.UseBFPforCube == false)
    483563            {
     
    488568                if (quickwatchData != null && quickwatchData != string.Empty)
    489569                {
    490                     char[] strInputVariableQuickwatch = new char[quickwatchData.Length];
    491                     strInputVariableQuickwatch = quickwatchData.ToCharArray();
    492                     for (int i = strInputVariableQuickwatch.Length - 1; i >= 0 ; i--)
     570                    //char[] strInputVariableQuickwatch = new char[quickwatchData.Length];
     571                    char [] strInputVariableQuickwatch = quickwatchData.ToCharArray();
     572                    for (int i = quickwatchData.Length - 1; i >= 0; i--)
    493573                    {
    494                         string replacement = "i_q." + i;
    495                         strExpression = strExpression.Replace(replacement, strInputVariableQuickwatch[i].ToString());
     574                        //string replacement = "xq." + i;
     575                        //strExpression = strExpression.Replace(replacement, strInputVariableQuickwatch[i].ToString());
     576                        tokens.Add("xq." + i, strInputVariableQuickwatch[i].ToString());
    496577                    }
    497578                }
     
    505586                if (externDataTwo != null && externDataTwo.Length != 0)
    506587                {
    507                     char[] strInputVariableExtern = new char[externDataOne.Length];
    508                     for (int i = strInputVariableExtern.Length - 1; i >= 0; i--)
     588                    //char[] strInputVariableExtern = new char[externDataOne.Length];
     589                    for (int i = externDataOne.Length - 1; i >= 0; i--)
    509590                    {
    510591                        // get numeric values from bool inputs
    511                         strInputVariableExtern[i] = externDataTwo[i] ? '1' : '0';
    512                         string replacement = "i_q." + i;
    513                         strExpression = strExpression.Replace(replacement, strInputVariableExtern[i].ToString());
     592                        //strInputVariableExtern[i] = externDataTwo[i] ? '1' : '0';
     593                        //string replacement = "xq." + i;
     594                        //strExpression = strExpression.Replace(replacement, strInputVariableExtern[i].ToString());
     595                        tokens.Add("xq." + i, externDataTwo[i] ? "1" : "0");
    514596                    }
    515597                }
     
    517599                else if (quickwatchDataCube != null && quickwatchDataCube != string.Empty)
    518600                {
    519                     char[] strInputVariableQuickwatch = new char[quickwatchDataCube.Length];
    520                     strInputVariableQuickwatch = quickwatchDataCube.ToCharArray();
    521                     for (int i = strInputVariableQuickwatch.Length - 1; i >= 0; i--)
     601                    char[] strInputVariableQuickwatch = quickwatchDataCube.ToCharArray();
     602                    for (int i = quickwatchDataCube.Length - 1; i >= 0; i--)
    522603                    {
    523                         string replacement = "i_q." + i;
    524                         strExpression = strExpression.Replace(replacement, strInputVariableQuickwatch[i].ToString());
     604                        //string replacement = "xq." + i;
     605                        //strExpression = strExpression.Replace(replacement, strInputVariableQuickwatch[i].ToString());
     606                        tokens.Add("xq." + i, strInputVariableQuickwatch[i].ToString());
    525607                    }
    526608                }
     
    530612
    531613            // replace AND, NAND, OR, NOR, XOR, NXOR with symbols
    532             // NAND => -
    533             //strExpression = strExpression.Replace("NAND", "-");
    534614            // AND => *
    535             strExpression = strExpression.Replace("AND", "*");
    536 
    537             // NOR => _
    538             //strExpression = strExpression.Replace("NOR", "_");
    539 
    540             // NXOR => °
    541             //strExpression = strExpression.Replace("NXOR", "°");
    542             // XOR => *
    543             strExpression = strExpression.Replace("XOR", "+");
    544 
    545             // OR => |
    546             //strExpression = strExpression.Replace("OR", "|");
    547 
    548             // replace ^ and & with symbols
    549             // ^ => XOR => +
    550             //strExpression = strExpression.Replace("^", "+");
    551 
    552             // & => AND => *
    553             //strExpression = strExpression.Replace("&", "*");
     615            //strExpression.Replace("AND", "*");
     616            tokens.Add("AND", "*");
     617            // XOR => +
     618            //strExpression.Replace("XOR", "+");
     619            tokens.Add("XOR", "+");
     620
     621            strExpression = tokens.Replace(strExpression);
     622            //GuiLogMessage("#tokens: " + tokens.Count, NotificationLevel.Info);
     623            tokens.RemoveRange(0, tokens.Count);
    554624
    555625            return strExpression;
     
    570640            {
    571641                GuiLogMessage("The count of ( is not equal to the count of )", NotificationLevel.Error);
    572                 return "foo";
     642                return null;
    573643            }
    574644
    575645            // test expression
    576             Regex objBoolExpression = new Regex(@"([\(]?[\!]?)([0-1]([\\*]|[\\+]|[\\|]|[\\-]|[_]|[°]|[v]|[\\^]|[\\!])+[0-1]{1})");
     646            // deleted after '[\\+]': |[\\|]|[\\-]|[_]|[°]|[v]|[\\^]|[\\!]
     647            Regex objBoolExpression = new Regex(@"([\(]?[\!]?)([0-1]([\\*]|[\\+])+[0-1]{1})");
    577648            if (!objBoolExpression.IsMatch(strExpressionNormalized))
    578649            {
    579650                GuiLogMessage("That's not a legal function", NotificationLevel.Error);
    580                 return "foo";
     651                return null;
    581652            }
    582653            else
     
    590661        {
    591662            string temp;
     663            StringBuilder functionBuilder = new StringBuilder(function);
    592664
    593665            // test for parenthesis
     
    602674                //GuiLogMessage("New function: " + temp, NotificationLevel.Debug);
    603675                bool parenthesisResult = EvaluateString(temp);
    604                 function = function.Remove(positionLeftParenthesis, positionRightParenthesis - positionLeftParenthesis + 1);
    605                 function = function.Insert(positionLeftParenthesis, Convert.ToInt32(parenthesisResult).ToString());
    606             }
     676                functionBuilder.Remove(positionLeftParenthesis, positionRightParenthesis - positionLeftParenthesis + 1);
     677                functionBuilder.Insert(positionLeftParenthesis, Convert.ToInt32(parenthesisResult).ToString());
     678            }
     679
     680            function = functionBuilder.ToString();
    607681
    608682            //GuiLogMessage("Function after '(':  " + function, NotificationLevel.Debug);
     
    616690
    617691                // remove exclamation mark
    618                 function = function.Remove(positionExclamationMark, 1);
     692                functionBuilder.Remove(positionExclamationMark, 1);
    619693
    620694                // invert the binary digit following the excl. mark
     
    625699                else toInvert = "1";
    626700                // remove old value
    627                 function = function.Remove(positionExclamationMark, 1);
     701                functionBuilder.Remove(positionExclamationMark, 1);
    628702                // insert new value
    629                 function = function.Insert(positionExclamationMark, toInvert);
     703                functionBuilder.Insert(positionExclamationMark, toInvert);
     704
     705                function = functionBuilder.ToString();
    630706
    631707                // any other NOTs in there?
     
    662738
    663739                // remove old values
    664                 function = function.Remove(positionAND - 1, 3);
     740                functionBuilder.Remove(positionAND - 1, 3);
    665741
    666742                // insert new value
    667                 function = function.Insert(positionAND - 1, sum);
     743                functionBuilder.Insert(positionAND - 1, sum);
    668744                //GuiLogMessage("function: " + function, NotificationLevel.Debug);
     745
     746                function = functionBuilder.ToString();
    669747
    670748                // any other ANDs in there?
     
    689767
    690768                // remove old values
    691                 function = function.Remove(positionXOR - 1, 3);
     769                functionBuilder.Remove(positionXOR - 1, 3);
    692770
    693771                // insert new value
    694                 function = function.Insert(positionXOR - 1, product);
     772                functionBuilder.Insert(positionXOR - 1, product);
    695773                //GuiLogMessage("function: " + function, NotificationLevel.Debug);
     774
     775                function = functionBuilder.ToString();
    696776
    697777                // any other XORs in there?
     
    893973
    894974    #endregion
     975
     976    #region Token
     977
     978    public class Token
     979    {
     980
     981        public string Text { get; private set; }
     982        public string Replacement { get; private set; }
     983        public int Index { get; set; }
     984
     985        public Token(string text, string replacement)
     986        {
     987            Text = text;
     988            Replacement = replacement;
     989        }
     990
     991    }
     992
     993    public class TokenList : List<Token>
     994    {
     995
     996        public void Add(string text, string replacement)
     997        {
     998            Add(new Token(text, replacement));
     999        }
     1000
     1001        private Token GetFirstToken()
     1002        {
     1003            Token result = null;
     1004            int index = int.MaxValue;
     1005            foreach (Token token in this)
     1006            {
     1007                if (token.Index != -1 && token.Index < index)
     1008                {
     1009                    index = token.Index;
     1010                    result = token;
     1011                }
     1012            }
     1013            return result;
     1014        }
     1015
     1016        public string Replace(string text)
     1017        {
     1018            StringBuilder result = new StringBuilder();
     1019            foreach (Token token in this)
     1020            {
     1021                token.Index = text.IndexOf(token.Text);
     1022            }
     1023            int index = 0;
     1024            Token next;
     1025            while ((next = GetFirstToken()) != null)
     1026            {
     1027                if (index < next.Index)
     1028                {
     1029                    result.Append(text, index, next.Index - index);
     1030                    index = next.Index;
     1031                }
     1032                result.Append(next.Replacement);
     1033                index += next.Text.Length;
     1034                next.Index = text.IndexOf(next.Text, index);
     1035            }
     1036            if (index < text.Length)
     1037            {
     1038                result.Append(text, index, text.Length - index);
     1039            }
     1040            return result.ToString();
     1041        }
     1042
     1043    }
     1044
     1045    #endregion
    8951046}
  • trunk/CrypPlugins/BooleanFunctionParser/BooleanFunctionParser.csproj

    r832 r841  
    105105      <Name>CubeAttackController</Name>
    106106    </ProjectReference>
     107    <ProjectReference Include="..\MathParser\MathParser.csproj">
     108      <Project>{0AE1DE18-FDAA-489A-B658-80F0837E3587}</Project>
     109      <Name>MathParser</Name>
     110    </ProjectReference>
     111    <ProjectReference Include="..\RPNExpression\RPNExpression.csproj">
     112      <Project>{21CF7D7A-50AC-45CF-AA87-E7ADF4201B85}</Project>
     113      <Name>RPNExpression</Name>
     114    </ProjectReference>
    107115  </ItemGroup>
    108116  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  • trunk/CrypPlugins/CLK/CLK.cs

    r651 r841  
    6969      if (e.PropertyName == "SetClockToTrue")
    7070      {
    71         output = settings.SetClockToTrue;
     71        output = Convert.ToBoolean(settings.SetClockToTrue);
    7272        if (output)
    7373        {
     
    145145    public void PreExecution()
    146146    {
    147         if (settings.SetClockToTrue)
     147        if (Convert.ToBoolean(settings.SetClockToTrue))
    148148        {
    149149            StatusChanged((int)CLKImage.True);
     
    191191                process(settings.CLKTimeout);
    192192                //change picture
    193                 if (settings.SetClockToTrue) StatusChanged((int)CLKImage.True);
     193                if (Convert.ToBoolean(settings.SetClockToTrue)) StatusChanged((int)CLKImage.True);
    194194                else StatusChanged((int)CLKImage.False);
    195195            }
     
    254254    public void Initialize()
    255255    {
    256         output = settings.SetClockToTrue;
     256        output = Convert.ToBoolean(settings.SetClockToTrue);
    257257        if (output) StatusChanged((int)CLKImage.True);
    258258        else StatusChanged((int)CLKImage.False);
  • trunk/CrypPlugins/CLK/CLKSettings.cs

    r651 r841  
    1515    # region private variables
    1616    private bool hasChanges = false;
    17     private bool setClockToTrue = true;
     17    private int setClockToTrue = 1;
    1818    private bool useEvent = false;
    1919    private int clkTimeout = 2000;
     
    2828    }
    2929
    30     [ContextMenu("Set clock to true", " yes / no ", 0, DisplayLevel.Beginner, ContextMenuControlType.CheckBox, null, "Set clock to true")]
    31     [TaskPaneAttribute("Set clock to true", " yes / no ", "", 0, true, DisplayLevel.Beginner, ControlType.CheckBox, null)]
    32     public bool SetClockToTrue
     30    [ContextMenu("Set clock output to", " true / false ", 0, DisplayLevel.Beginner, ContextMenuControlType.ComboBox, null, new string[] { "false", "true"})]
     31    [TaskPaneAttribute("Set clock output to", " true / false ", "", 0, true, DisplayLevel.Beginner, ControlType.RadioButton, new string[] { "False", "True" })]
     32    public int SetClockToTrue
    3333    {
    34         get { return this.setClockToTrue; }
     34        get
     35        {
     36            return this.setClockToTrue;
     37        }
    3538        set
    3639        {
  • trunk/CrypPlugins/LFSR/LFSR.cs

    r832 r841  
    185185        }
    186186
    187         [PropertyInfo(Direction.OutputData, "Clocking Bit Output", "Clocking Bit Output.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     187        [PropertyInfo(Direction.OutputData, "Additional Output Bit", "Additional Output Bit.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    188188        public bool OutputClockingBit
    189189        {
  • trunk/CrypPlugins/LFSR/LFSRPresentation.xaml.cs

    r371 r841  
    4242        public void DrawLFSR(char[] state, char[] tapSequence, int clockingBit)
    4343        {
    44             Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     44            try
    4545            {
    46                 // hide initial textbox
    47                 infoText.Visibility = Visibility.Hidden;
    48                 polynomialText.Visibility = Visibility.Visible;
    49 
    50                 // add lines and triangles
    51                 Line HoriLine1 = new Line();
    52                 HoriLine1.X1 = 5;
    53                 HoriLine1.Y1 = 18;
    54                 HoriLine1.X2 = 60 + state.Length * 30;
    55                 HoriLine1.Y2 = 18;
    56                 HoriLine1.Stroke = Brushes.Black;
    57                 HoriLine1.StrokeThickness = 1;
    58                 myGrid.Children.Add(HoriLine1);
    59 
    60                 Line HoriLine2 = new Line();
    61                 HoriLine2.X1 = 5;
    62                 HoriLine2.Y1 = 47;
    63                 HoriLine2.X2 = 35 + (state.Length - 1) * 29;
    64                 HoriLine2.Y2 = 47;
    65                 HoriLine2.Stroke = Brushes.Black;
    66                 HoriLine1.StrokeThickness = 1;
    67                 myGrid.Children.Add(HoriLine2);
    68 
    69                 Line VertLine1 = new Line();
    70                 VertLine1.X1 = 5;
    71                 VertLine1.Y1 = 17.5;
    72                 VertLine1.X2 = 5;
    73                 VertLine1.Y2 = 47.5;
    74                 VertLine1.Stroke = Brushes.Black;
    75                 VertLine1.StrokeThickness = 1;
    76                 myGrid.Children.Add(VertLine1);
    77 
    78                 Line VertLine2 = new Line();
    79                 VertLine2.X1 = 35 + (state.Length - 1) * 29;
    80                 VertLine2.Y1 = 32;
    81                 VertLine2.X2 = 35 + (state.Length - 1) * 29;
    82                 VertLine2.Y2 = 47;
    83                 VertLine2.Stroke = Brushes.Black;
    84                 VertLine2.StrokeThickness = 1;
    85                 myGrid.Children.Add(VertLine2);
    86 
    87                 // add connection circle
    88                 /*Ellipse ConnectionCircle = new Ellipse();
    89                 ConnectionCircle.HorizontalAlignment = HorizontalAlignment.Left;
    90                 ConnectionCircle.VerticalAlignment = VerticalAlignment.Top;
    91                 ConnectionCircle.Fill = Brushes.Black;
    92                 ConnectionCircle.Width = 4;
    93                 ConnectionCircle.Height = 4;
    94                 ConnectionCircle.Margin = new Thickness(27.5 + state.Length * 30, 15.5, 0, 0);
    95                 myGrid.Children.Add(ConnectionCircle);*/
    96 
    97                 // add left triangle ////////////////////
    98                 // Create a path to draw a geometry with.
    99                 Path leftTriangle = new Path();
    100                 leftTriangle.Stroke = Brushes.Black;
    101                 leftTriangle.StrokeThickness = 1;
    102                 leftTriangle.Fill = Brushes.Black;
    103 
    104                 // Create a StreamGeometry to use to specify myPath.
    105                 StreamGeometry geometryLT = new StreamGeometry();
    106                 geometryLT.FillRule = FillRule.EvenOdd;
    107 
    108                 // Open a StreamGeometryContext that can be used to describe this StreamGeometry
    109                 // object's contents.
    110                 using (StreamGeometryContext ctx = geometryLT.Open())
     46                Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    11147                {
    112 
    113                     // Begin the triangle at the point specified. Notice that the shape is set to
    114                     // be closed so only two lines need to be specified below to make the triangle.
    115                     ctx.BeginFigure(new Point(13, 15), true /* is filled */, true /* is closed */);
    116 
    117                     // Draw a line to the next specified point.
    118                     ctx.LineTo(new Point(13, 21), true /* is stroked */, false /* is smooth join */);
    119 
    120                     // Draw another line to the next specified point.
    121                     ctx.LineTo(new Point(20, 18), true /* is stroked */, false /* is smooth join */);
    122                 }
    123 
    124                 // Freeze the geometry (make it unmodifiable)
    125                 // for additional performance benefits.
    126                 geometryLT.Freeze();
    127 
    128                 // Specify the shape (triangle) of the Path using the StreamGeometry.
    129                 leftTriangle.Data = geometryLT;
    130 
    131                 myGrid.Children.Add(leftTriangle);
    132 
    133                 // add right triangle ///////////////////
    134                 // Create a path to draw a geometry with.
    135                 Path rightTriangle = new Path();
    136                 rightTriangle.Stroke = Brushes.Black;
    137                 rightTriangle.StrokeThickness = 1;
    138                 rightTriangle.Fill = Brushes.Black;
    139 
    140                 // Create a StreamGeometry to use to specify myPath.
    141                 StreamGeometry geometryRT = new StreamGeometry();
    142                 geometryRT.FillRule = FillRule.EvenOdd;
    143 
    144                 // Open a StreamGeometryContext that can be used to describe this StreamGeometry
    145                 // object's contents.
    146                 using (StreamGeometryContext ctx = geometryRT.Open())
    147                 {
    148 
    149                     // Begin the triangle at the point specified. Notice that the shape is set to
    150                     // be closed so only two lines need to be specified below to make the triangle.
    151                     ctx.BeginFigure(new Point(60 + state.Length * 30, 15), true /* is filled */, true /* is closed */);
    152 
    153                     // Draw a line to the next specified point.
    154                     ctx.LineTo(new Point(60 + state.Length * 30, 21), true /* is stroked */, false /* is smooth join */);
    155 
    156                     // Draw another line to the next specified point.
    157                     ctx.LineTo(new Point(67 + state.Length * 30, 18), true /* is stroked */, false /* is smooth join */);
    158                 }
    159 
    160                 // Freeze the geometry (make it unmodifiable)
    161                 // for additional performance benefits.
    162                 geometryRT.Freeze();
    163 
    164                 // Specify the shape (triangle) of the Path using the StreamGeometry.
    165                 rightTriangle.Data = geometryRT;
    166 
    167                 // Data="M180,14 L180,22 L187,18 Z"
    168                 myGrid.Children.Add(rightTriangle);
    169 
    170 
    171 
    172                 TextBox[] myTextBoxes = new TextBox[state.Length];
    173                 Grid[] myGrids = new Grid[state.Length];
    174                 Ellipse[] myEllipses = new Ellipse[state.Length];
    175                 Line[] myLinesVert = new Line[state.Length];
    176                 Line[] myLinesVertRed = new Line[state.Length];
    177                 Line[] myLinesHori = new Line[state.Length];
    178 
    179                 // add TextBoxes
    180                 int i;
    181                 double left;
    182                 for (i = 0; i < state.Length; i++)
    183                 {
    184                     // add textboxes
    185                     left = (double)i * 29 + 20;
    186                     myTextBoxes[i] = new TextBox();
    187                     myTextBoxes[i].Margin = new Thickness(left, 3, 0, 0);
    188                     myTextBoxes[i].Width = 30;
    189                     myTextBoxes[i].Height = 30;
    190                     myTextBoxes[i].HorizontalAlignment = HorizontalAlignment.Left;
    191                     myTextBoxes[i].VerticalAlignment = VerticalAlignment.Top;
    192                     myTextBoxes[i].Name = "textBoxBit" + i;
    193                     myTextBoxes[i].Visibility = Visibility.Visible;
    194                     myTextBoxes[i].BorderThickness = new Thickness(1);
    195                     myTextBoxes[i].IsReadOnly = true;
    196                     myTextBoxes[i].TextAlignment = TextAlignment.Center;
    197                     myTextBoxes[i].VerticalContentAlignment = VerticalAlignment.Center;
    198                     myTextBoxes[i].BorderBrush = Brushes.Black;
    199                     //if (tapSequence[i] == '1') myTextBoxes[i].Background = Brushes.DodgerBlue;
    200                     if (clockingBit == i) myTextBoxes[i].Background = Brushes.Orange;
    201 
    202                     myGrid.Children.Add(myTextBoxes[i]);
    203 
    204                     // add XORs
    205                     myGrids[i] = new Grid();
    206                     myGrids[i].Name = "XORGrid" + i;
    207                     myGrids[i].Height = 30;
    208                     myGrids[i].Width = 30;
    209                     myGrids[i].HorizontalAlignment = HorizontalAlignment.Left;
    210                     myGrids[i].VerticalAlignment = VerticalAlignment.Top;
    211                     myGrids[i].Margin = new Thickness(left, 32, 0, 0);
    212 
    213                     myGrid.Children.Add(myGrids[i]);
    214 
    215                     if (tapSequence[i] == '0') myGrids[i].Visibility = Visibility.Hidden;
    216                     else
     48                    // hide initial textbox
     49                    infoText.Visibility = Visibility.Hidden;
     50                    polynomialText.Visibility = Visibility.Visible;
     51
     52                    // add lines and triangles
     53                    Line HoriLine1 = new Line();
     54                    HoriLine1.X1 = 5;
     55                    HoriLine1.Y1 = 18;
     56                    HoriLine1.X2 = 60 + state.Length * 30;
     57                    HoriLine1.Y2 = 18;
     58                    HoriLine1.Stroke = Brushes.Black;
     59                    HoriLine1.StrokeThickness = 1;
     60                    myGrid.Children.Add(HoriLine1);
     61
     62                    Line HoriLine2 = new Line();
     63                    HoriLine2.X1 = 5;
     64                    HoriLine2.Y1 = 47;
     65                    HoriLine2.X2 = 35 + (state.Length - 1) * 29;
     66                    HoriLine2.Y2 = 47;
     67                    HoriLine2.Stroke = Brushes.Black;
     68                    HoriLine1.StrokeThickness = 1;
     69                    myGrid.Children.Add(HoriLine2);
     70
     71                    Line VertLine1 = new Line();
     72                    VertLine1.X1 = 5;
     73                    VertLine1.Y1 = 17.5;
     74                    VertLine1.X2 = 5;
     75                    VertLine1.Y2 = 47.5;
     76                    VertLine1.Stroke = Brushes.Black;
     77                    VertLine1.StrokeThickness = 1;
     78                    myGrid.Children.Add(VertLine1);
     79
     80                    Line VertLine2 = new Line();
     81                    VertLine2.X1 = 35 + (state.Length - 1) * 29;
     82                    VertLine2.Y1 = 32;
     83                    VertLine2.X2 = 35 + (state.Length - 1) * 29;
     84                    VertLine2.Y2 = 47;
     85                    VertLine2.Stroke = Brushes.Black;
     86                    VertLine2.StrokeThickness = 1;
     87                    myGrid.Children.Add(VertLine2);
     88
     89                    // add connection circle
     90                    /*Ellipse ConnectionCircle = new Ellipse();
     91                    ConnectionCircle.HorizontalAlignment = HorizontalAlignment.Left;
     92                    ConnectionCircle.VerticalAlignment = VerticalAlignment.Top;
     93                    ConnectionCircle.Fill = Brushes.Black;
     94                    ConnectionCircle.Width = 4;
     95                    ConnectionCircle.Height = 4;
     96                    ConnectionCircle.Margin = new Thickness(27.5 + state.Length * 30, 15.5, 0, 0);
     97                    myGrid.Children.Add(ConnectionCircle);*/
     98
     99                    // add left triangle ////////////////////
     100                    // Create a path to draw a geometry with.
     101                    Path leftTriangle = new Path();
     102                    leftTriangle.Stroke = Brushes.Black;
     103                    leftTriangle.StrokeThickness = 1;
     104                    leftTriangle.Fill = Brushes.Black;
     105
     106                    // Create a StreamGeometry to use to specify myPath.
     107                    StreamGeometry geometryLT = new StreamGeometry();
     108                    geometryLT.FillRule = FillRule.EvenOdd;
     109
     110                    // Open a StreamGeometryContext that can be used to describe this StreamGeometry
     111                    // object's contents.
     112                    using (StreamGeometryContext ctx = geometryLT.Open())
    217113                    {
    218                         myEllipses[i] = new Ellipse();
    219                         myEllipses[i].Name = "ellipseXOR" + i;
    220                         myEllipses[i].Stroke = Brushes.DodgerBlue;
    221                         myEllipses[i].Margin = new Thickness(9, 9, 9, 9);
    222 
    223                         myLinesVert[i] = new Line();
    224                         myLinesVert[i].Name = "VertLineXOR" + i;
    225                         myLinesVert[i].Stroke = Brushes.Black;
    226                         myLinesVert[i].StrokeThickness = 1;
    227                         myLinesVert[i].X1 = 15;
    228                         myLinesVert[i].Y1 = 0.5;
    229                         myLinesVert[i].X2 = 15;
    230                         myLinesVert[i].Y2 = 9;
    231 
    232                         myLinesVertRed[i] = new Line();
    233                         myLinesVertRed[i].Name = "VertLineXORRed" + i;
    234                         myLinesVertRed[i].Stroke = Brushes.DodgerBlue;
    235                         myLinesVertRed[i].StrokeThickness = 1;
    236                         myLinesVertRed[i].X1 = 15;
    237                         myLinesVertRed[i].Y1 = 9;
    238                         myLinesVertRed[i].X2 = 15;
    239                         myLinesVertRed[i].Y2 = 20;
    240 
    241                         myLinesHori[i] = new Line();
    242                         myLinesHori[i].Name = "HoriLineXOR" + i;
    243                         myLinesHori[i].Stroke = Brushes.DodgerBlue;
    244                         myLinesHori[i].StrokeThickness = 1;
    245                         myLinesHori[i].X1 = 9;
    246                         myLinesHori[i].Y1 = 15;
    247                         myLinesHori[i].X2 = 20;
    248                         myLinesHori[i].Y2 = 15;
    249 
    250                         myGrids[i].Children.Add(myEllipses[i]);
    251                         myGrids[i].Children.Add(myLinesVert[i]);
    252                         myGrids[i].Children.Add(myLinesVertRed[i]);
    253                         myGrids[i].Children.Add(myLinesHori[i]);
     114
     115                        // Begin the triangle at the point specified. Notice that the shape is set to
     116                        // be closed so only two lines need to be specified below to make the triangle.
     117                        ctx.BeginFigure(new Point(13, 15), true /* is filled */, true /* is closed */);
     118
     119                        // Draw a line to the next specified point.
     120                        ctx.LineTo(new Point(13, 21), true /* is stroked */, false /* is smooth join */);
     121
     122                        // Draw another line to the next specified point.
     123                        ctx.LineTo(new Point(20, 18), true /* is stroked */, false /* is smooth join */);
    254124                    }
    255                 }
    256                 // disable /*last*/ and first XOR
    257                 //myGrids[0].Visibility = Visibility.Hidden;
    258                 myGrids[state.Length - 1].Visibility = Visibility.Hidden;
    259 
    260                 // add output bit label
    261                 Label outPutLabel = new Label();
    262                 left = (double)i * 30 + 65;
    263                 outPutLabel.Margin = new Thickness(left, 3, 0, 0);
    264                 outPutLabel.Width = 30;
    265                 outPutLabel.Height = 30;
    266                 outPutLabel.HorizontalContentAlignment = HorizontalAlignment.Center;
    267                 outPutLabel.VerticalContentAlignment = VerticalAlignment.Center;
    268                 outPutLabel.HorizontalAlignment = HorizontalAlignment.Left;
    269                 outPutLabel.VerticalAlignment = VerticalAlignment.Top;
    270                 outPutLabel.Name = "outputLabel";
    271                 myGrid.Children.Add(outPutLabel);
    272 
    273             }, null);
     125
     126                    // Freeze the geometry (make it unmodifiable)
     127                    // for additional performance benefits.
     128                    geometryLT.Freeze();
     129
     130                    // Specify the shape (triangle) of the Path using the StreamGeometry.
     131                    leftTriangle.Data = geometryLT;
     132
     133                    myGrid.Children.Add(leftTriangle);
     134
     135                    // add right triangle ///////////////////
     136                    // Create a path to draw a geometry with.
     137                    Path rightTriangle = new Path();
     138                    rightTriangle.Stroke = Brushes.Black;
     139                    rightTriangle.StrokeThickness = 1;
     140                    rightTriangle.Fill = Brushes.Black;
     141
     142                    // Create a StreamGeometry to use to specify myPath.
     143                    StreamGeometry geometryRT = new StreamGeometry();
     144                    geometryRT.FillRule = FillRule.EvenOdd;
     145
     146                    // Open a StreamGeometryContext that can be used to describe this StreamGeometry
     147                    // object's contents.
     148                    using (StreamGeometryContext ctx = geometryRT.Open())
     149                    {
     150
     151                        // Begin the triangle at the point specified. Notice that the shape is set to
     152                        // be closed so only two lines need to be specified below to make the triangle.
     153                        ctx.BeginFigure(new Point(60 + state.Length * 30, 15), true /* is filled */, true /* is closed */);
     154
     155                        // Draw a line to the next specified point.
     156                        ctx.LineTo(new Point(60 + state.Length * 30, 21), true /* is stroked */, false /* is smooth join */);
     157
     158                        // Draw another line to the next specified point.
     159                        ctx.LineTo(new Point(67 + state.Length * 30, 18), true /* is stroked */, false /* is smooth join */);
     160                    }
     161
     162                    // Freeze the geometry (make it unmodifiable)
     163                    // for additional performance benefits.
     164                    geometryRT.Freeze();
     165
     166                    // Specify the shape (triangle) of the Path using the StreamGeometry.
     167                    rightTriangle.Data = geometryRT;
     168
     169                    // Data="M180,14 L180,22 L187,18 Z"
     170                    myGrid.Children.Add(rightTriangle);
     171
     172
     173
     174                    TextBox[] myTextBoxes = new TextBox[state.Length];
     175                    Grid[] myGrids = new Grid[state.Length];
     176                    Ellipse[] myEllipses = new Ellipse[state.Length];
     177                    Line[] myLinesVert = new Line[state.Length];
     178                    Line[] myLinesVertRed = new Line[state.Length];
     179                    Line[] myLinesHori = new Line[state.Length];
     180
     181                    // add TextBoxes
     182                    int i;
     183                    double left;
     184                    for (i = 0; i < state.Length; i++)
     185                    {
     186                        // add textboxes
     187                        left = (double)i * 29 + 20;
     188                        myTextBoxes[i] = new TextBox();
     189                        myTextBoxes[i].Margin = new Thickness(left, 3, 0, 0);
     190                        myTextBoxes[i].Width = 30;
     191                        myTextBoxes[i].Height = 30;
     192                        myTextBoxes[i].HorizontalAlignment = HorizontalAlignment.Left;
     193                        myTextBoxes[i].VerticalAlignment = VerticalAlignment.Top;
     194                        myTextBoxes[i].Name = "textBoxBit" + i;
     195                        myTextBoxes[i].Visibility = Visibility.Visible;
     196                        myTextBoxes[i].BorderThickness = new Thickness(1);
     197                        myTextBoxes[i].IsReadOnly = true;
     198                        myTextBoxes[i].TextAlignment = TextAlignment.Center;
     199                        myTextBoxes[i].VerticalContentAlignment = VerticalAlignment.Center;
     200                        myTextBoxes[i].BorderBrush = Brushes.Black;
     201                        //if (tapSequence[i] == '1') myTextBoxes[i].Background = Brushes.DodgerBlue;
     202                        if (clockingBit == i) myTextBoxes[i].Background = Brushes.Orange;
     203
     204                        myGrid.Children.Add(myTextBoxes[i]);
     205
     206                        // add XORs
     207                        myGrids[i] = new Grid();
     208                        myGrids[i].Name = "XORGrid" + i;
     209                        myGrids[i].Height = 30;
     210                        myGrids[i].Width = 30;
     211                        myGrids[i].HorizontalAlignment = HorizontalAlignment.Left;
     212                        myGrids[i].VerticalAlignment = VerticalAlignment.Top;
     213                        myGrids[i].Margin = new Thickness(left, 32, 0, 0);
     214
     215                        myGrid.Children.Add(myGrids[i]);
     216
     217                        if (tapSequence[i] == '0') myGrids[i].Visibility = Visibility.Hidden;
     218                        else
     219                        {
     220                            myEllipses[i] = new Ellipse();
     221                            myEllipses[i].Name = "ellipseXOR" + i;
     222                            myEllipses[i].Stroke = Brushes.DodgerBlue;
     223                            myEllipses[i].Margin = new Thickness(9, 9, 9, 9);
     224
     225                            myLinesVert[i] = new Line();
     226                            myLinesVert[i].Name = "VertLineXOR" + i;
     227                            myLinesVert[i].Stroke = Brushes.Black;
     228                            myLinesVert[i].StrokeThickness = 1;
     229                            myLinesVert[i].X1 = 15;
     230                            myLinesVert[i].Y1 = 0.5;
     231                            myLinesVert[i].X2 = 15;
     232                            myLinesVert[i].Y2 = 9;
     233
     234                            myLinesVertRed[i] = new Line();
     235                            myLinesVertRed[i].Name = "VertLineXORRed" + i;
     236                            myLinesVertRed[i].Stroke = Brushes.DodgerBlue;
     237                            myLinesVertRed[i].StrokeThickness = 1;
     238                            myLinesVertRed[i].X1 = 15;
     239                            myLinesVertRed[i].Y1 = 9;
     240                            myLinesVertRed[i].X2 = 15;
     241                            myLinesVertRed[i].Y2 = 20;
     242
     243                            myLinesHori[i] = new Line();
     244                            myLinesHori[i].Name = "HoriLineXOR" + i;
     245                            myLinesHori[i].Stroke = Brushes.DodgerBlue;
     246                            myLinesHori[i].StrokeThickness = 1;
     247                            myLinesHori[i].X1 = 9;
     248                            myLinesHori[i].Y1 = 15;
     249                            myLinesHori[i].X2 = 20;
     250                            myLinesHori[i].Y2 = 15;
     251
     252                            myGrids[i].Children.Add(myEllipses[i]);
     253                            myGrids[i].Children.Add(myLinesVert[i]);
     254                            myGrids[i].Children.Add(myLinesVertRed[i]);
     255                            myGrids[i].Children.Add(myLinesHori[i]);
     256                        }
     257                    }
     258                    // disable /*last*/ and first XOR
     259                    //myGrids[0].Visibility = Visibility.Hidden;
     260                    myGrids[state.Length - 1].Visibility = Visibility.Hidden;
     261
     262                    // add output bit label
     263                    Label outPutLabel = new Label();
     264                    left = (double)i * 30 + 65;
     265                    outPutLabel.Margin = new Thickness(left, 3, 0, 0);
     266                    outPutLabel.Width = 30;
     267                    outPutLabel.Height = 30;
     268                    outPutLabel.HorizontalContentAlignment = HorizontalAlignment.Center;
     269                    outPutLabel.VerticalContentAlignment = VerticalAlignment.Center;
     270                    outPutLabel.HorizontalAlignment = HorizontalAlignment.Left;
     271                    outPutLabel.VerticalAlignment = VerticalAlignment.Top;
     272                    outPutLabel.Name = "outputLabel";
     273                    myGrid.Children.Add(outPutLabel);
     274
     275                }, null);
     276            }
     277            catch (Exception ex)
     278            {
     279
     280            }
    274281
    275282        }
  • trunk/CrypPlugins/NLFSR/NLFSR.cs

    r689 r841  
    2121// for RegEx
    2222using System.Text.RegularExpressions;
     23// MathParser
     24using Cryptool.MathParser;
    2325
    2426namespace Cryptool.NLFSR
     
    8385            if (e.PropertyName == "InitNLFSR")
    8486                preprocessNLFSR();
     87            if (e.PropertyName == "SaveCurrentState")
     88            {
     89                if (settings.SaveCurrentState)
     90                    settings.CurrentState = seedbuffer;
     91                else
     92                    settings.CurrentState = null;
     93            }
    8594        }
    8695
     
    215224        }
    216225
    217         [PropertyInfo(Direction.OutputData, "Clocking Bit Output", "Clocking Bit Output.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     226        [PropertyInfo(Direction.OutputData, "Additional Output Bit", "Additional Output Bit.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    218227        public bool OutputClockingBit
    219228        {
     
    434443            for (int i = strFSRValues.Length - 1; i >= 0; i--)
    435444            {
    436                 replacement = "x^" + i;
     445                replacement = "x" + i;
    437446                strExpression = strExpression.Replace(replacement, temp[i].ToString());
    438447                //GuiLogMessage("temp[i-1]: " + temp[i - 1].ToString(), NotificationLevel.Info);
     
    442451            // replace AND, NAND, OR, NOR, XOR, NXOR with symbols
    443452            // NAND => -
    444             strExpression = strExpression.Replace("NAND", "-");
     453            //strExpression = strExpression.Replace("NAND", "-");
    445454            // AND => +
    446455            strExpression = strExpression.Replace("AND", "+");
    447456
    448457            // NOR => _
    449             strExpression = strExpression.Replace("NOR", "_");
     458            //strExpression = strExpression.Replace("NOR", "_");
    450459
    451460            // NXOR => °
    452             strExpression = strExpression.Replace("NXOR", "°");
     461            //strExpression = strExpression.Replace("NXOR", "°");
    453462            // XOR => *
    454463            strExpression = strExpression.Replace("XOR", "*");
    455464
    456465            // OR => |
    457             strExpression = strExpression.Replace("OR", "|");
     466            //strExpression = strExpression.Replace("OR", "|");
    458467
    459468            // replace ^ and v with symbols
    460469            // ^ => AND => +
    461             strExpression = strExpression.Replace("^", "+");
     470            //strExpression = strExpression.Replace("^", "+");
    462471
    463472            // v => OR => |
    464             strExpression = strExpression.Replace("v", "|");
     473            //strExpression = strExpression.Replace("v", "|");
    465474
    466475            //GuiLogMessage("strExpression w/o vars: " + strExpression, NotificationLevel.Info);
     
    559568
    560569            //read seed
    561             if (settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0))
     570            if (settings.CurrentState != null && settings.CurrentState.Length != 0)
     571                seedbuffer = settings.CurrentState;
     572            else if (settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0))
    562573                seedbuffer = inputSeed;
    563574            else
     
    593604                }
    594605                // create tapSequence for drawing NLFSR
    595                 string temp = "x^" + z;
     606                string temp = "x" + z;
    596607                if (tapSequencebuffer.Contains(temp))
    597608                {
     
    736747
    737748                        bool resultBool = true;
    738                         resultBool = EvaluateString(tapPolynomial);
     749                        //resultBool = EvaluateString(tapPolynomial);
     750                        MathParser.Parser p = new MathParser.Parser();
     751                        if (p.Evaluate(tapPolynomial))
     752                        {
     753                            resultBool = Convert.ToBoolean(p.Result);
     754                        }
     755                        else
     756                            GuiLogMessage("Parsing of function failed.", NotificationLevel.Error);
    739757
    740758                        //GuiLogMessage("resultBool is: " + resultBool, NotificationLevel.Info);
     
    895913        public void PostExecution()
    896914        {
     915            if (settings.SaveCurrentState)
     916                settings.CurrentState = seedbuffer;
     917            else
     918                settings.CurrentState = null;
    897919            Dispose();
    898920        }
  • trunk/CrypPlugins/NLFSR/NLFSR.csproj

    r371 r841  
    8282      <Name>CrypPluginBase</Name>
    8383    </ProjectReference>
     84    <ProjectReference Include="..\MathParser\MathParser.csproj">
     85      <Project>{0AE1DE18-FDAA-489A-B658-80F0837E3587}</Project>
     86      <Name>MathParser</Name>
     87    </ProjectReference>
    8488  </ItemGroup>
    8589  <ItemGroup>
  • trunk/CrypPlugins/NLFSR/NLFSRPresentation.xaml.cs

    r645 r841  
    282282                functionTextBox.TextAlignment = TextAlignment.Center;
    283283                functionTextBox.VerticalContentAlignment = VerticalAlignment.Center;
    284                 functionTextBox.BorderBrush = Brushes.LightGray;
    285                 functionTextBox.Foreground = Brushes.LightGray;
     284                functionTextBox.BorderBrush = Brushes.DodgerBlue;
     285                functionTextBox.Foreground = Brushes.Black;
    286286
    287287                myGrid.Children.Add(functionTextBox);
  • trunk/CrypPlugins/NLFSR/NLFSRSettings.cs

    r752 r841  
    2424        private bool hasChanges = false;
    2525
     26        private string currentState = null;
     27        public string CurrentState
     28        {
     29            get { return currentState; }
     30            set
     31            {
     32                if (value != currentState) hasChanges = true;
     33                currentState = value;
     34            }
     35        }
     36
    2637        [TaskPane("Draw NLFSR", "Initializes NLFSR and draws the presentation. This is used to view the NLFSR before pressing play.", null, 0, false, DisplayLevel.Beginner, ControlType.Button)]
    2738        public void initNLFSR()
     
    4051                this.rounds = value;
    4152                OnPropertyChanged("Rounds");
    42                 HasChanges = true;
     53                if (value != rounds) HasChanges = true;
    4354            }
    4455        }
     
    5364                this.polynomial = value;
    5465                OnPropertyChanged("Polynomial");
    55                 HasChanges = true;
     66                if (value != polynomial) HasChanges = true;
    5667            }
    5768        }
     
    6677                this.seed = value;
    6778                OnPropertyChanged("Seed");
    68                 HasChanges = true;
     79                if (value != seed) HasChanges = true;
    6980            }
    7081        }
     
    7283        private bool noQuickwatch = false;
    7384        [ContextMenu("Do not display Quickwatch", "With this checkbox enabled, no quickwatch will be generated for better performance.", 0, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Display Quickwatch?" })]
    74         [TaskPane("Do not display Quickwatch", "With this checkbox enabled, no quickwatch will be generated for better performance.", null, 1, true, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
     85        [TaskPane("Do not display Quickwatch", "With this checkbox enabled, no quickwatch will be generated for better performance.", null, 3, true, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
    7586        public bool NoQuickwatch
    7687        {
     
    8091                this.noQuickwatch = (bool)value;
    8192                OnPropertyChanged("NoQuickwatch");
    82                 HasChanges = true;
     93                if ((bool)value != noQuickwatch) HasChanges = true;
     94            }
     95        }
     96
     97        private bool saveCurrentState = false;
     98        [ContextMenu("Save the state of the NLFSR", "With this checkbox enabled, the current state will be restored after opening a .cte.", 0, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Save current state?" })]
     99        [TaskPane("Save the state of the NLFSR", "With this checkbox enabled, the current state will be restored after opening a .cte.", null, 3, true, DisplayLevel.Experienced, ControlType.CheckBox, "", null)]
     100        public bool SaveCurrentState
     101        {
     102            get { return this.saveCurrentState; }
     103            set
     104            {
     105                this.saveCurrentState = (bool)value;
     106                OnPropertyChanged("SaveCurrentState");
     107                if ((bool)value != saveCurrentState) HasChanges = true;
    83108            }
    84109        }
     
    94119                this.useClockingBit = (bool)value;
    95120                OnPropertyChanged("UseClockingBit");
    96                 HasChanges = true;
     121                if ((bool)value != useClockingBit) HasChanges = true;
    97122                if (this.useClockingBit)
    98123                    SettingChanged("ClockingBit", Visibility.Visible);
     
    111136                this.clockingBit = value;
    112137                OnPropertyChanged("ClockingBit");
    113                 HasChanges = true;
     138                if (value != clockingBit) HasChanges = true;
    114139            }
    115140        }
     
    125150                this.useBoolClock = (bool)value;
    126151                OnPropertyChanged("UseBoolClock");
    127                 HasChanges = true;
     152                if ((bool)value != useBoolClock) HasChanges = true;
    128153                if (this.useBoolClock)
    129154                    SettingChanged("Rounds", Visibility.Collapsed);
     
    143168                this.alwaysCreateOutput = (bool)value;
    144169                OnPropertyChanged("AlwaysCreateOutput");
    145                 HasChanges = true;
    146             }
    147         }
    148 
    149         private bool createDirtyOutputOnFalseClock = false;
    150         [ContextMenu("Create dirty output on false clock", "With this checkbox enabled, an the output is the dirty (-1) if the clock is set to false.", 2, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Create dirty output?" })]
    151         [TaskPane("Create dirty output on false clock", "With this checkbox enabled, an the output is the dirty (-1) if the clock is set to false.", "Clock Properties", 2, false, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
    152         public bool CreateDirtyOutputOnFalseClock
    153         {
    154             get { return this.createDirtyOutputOnFalseClock; }
    155             set
    156             {
    157                 this.createDirtyOutputOnFalseClock = (bool)value;
    158                 OnPropertyChanged("CreateDirtyOutputOnFalseClock");
    159                 HasChanges = true;
     170                if ((bool)value != alwaysCreateOutput) HasChanges = true;
    160171            }
    161172        }
Note: See TracChangeset for help on using the changeset viewer.