Exemplo n.º 1
0
        /// <summary>
        /// Extracts the constant from a condition
        /// </summary>
        /// <returns>The extracted variable</returns>
        public int?GetConstFromCondition()
        {
            Validate();
            System.Collections.Specialized.StringCollection refvarIDs = new System.Collections.Specialized.StringCollection();
            Match matchResult = Regex.Match(TACtext, "ID_[A-F0-9]{8}(?:-[A-F0-9]{4}){3}-[A-F0-9]{12}", RegexOptions.None);

            while (matchResult.Success)
            {
                refvarIDs.Add(matchResult.Value);
                matchResult = matchResult.NextMatch();
            }
            if (refvarIDs.Count == 3)
            {
                return(null);
            }
            else
            {
                return(Convert.ToInt32(TACtext.Split(' ')[3]));
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Modifies the TAC text of instruction: replaces numerical constant to variable name
        /// </summary>
        /// <param name="variable">Variable containing constant</param>
        /// <param name="value">Constant number to be replaced</param>
        public void ModifyConstInstruction(Variable variable, int?value)
        {
            if (variable == null || value == null)
            {
                throw new ObjectException("Wrong parameter passing.");
            }
            RefVariables.Add(variable);
            string TACtext_new = string.Empty;

            for (int i = 0; i < TACtext.Split(' ').Length; i++)
            {
                if (TACtext.Split(' ')[i] != value.ToString())
                {
                    TACtext_new = string.Join(" ", TACtext_new, TACtext.Split(' ')[i]);
                }
                else
                {
                    TACtext_new = string.Join(" ", TACtext_new, variable.name);
                }
            }
            TACtext = TACtext_new.Trim();
        }
Exemplo n.º 3
0
        /// <summary>
        /// Determines the new state of a dead variable (a pointer) as a result of the instruction
        /// </summary>
        /// <param name="variable">A variable or a pointer</param>
        /// <returns>A list of states. For variable: 1 - variable, 2 - empty. For pointer: 1-pointer, 2 - variable. Empty list if nothing has changed.</returns>
        public List <Variable.State> GetChangedStates(Variable variable)
        {
            if (string.IsNullOrWhiteSpace(TACtext))
            {
                throw new ObjectException("TAC text is empty. Instruction: " + ID);
            }
            if (RefVariables.Count == 0 || !RefVariables.Contains(variable))
            {
                throw new ObjectException("No referenced variables found in instruction " + ID);
            }
            List <Variable.State> var_states = new List <Variable.State>();
            string right = string.Empty, left = string.Empty;

            if (TACtext.Split('=').Length == 2)
            {
                right = TACtext.Split('=')[1];
                left  = TACtext.Split('=')[0];
            }
            switch (statementType)
            {
            case Common.StatementType.FullAssignment:
            case Common.StatementType.UnaryAssignment:
            case Common.StatementType.Copy:
                if (Regex.IsMatch(right, variable.ID, RegexOptions.None) && !Regex.IsMatch(left, variable.ID, RegexOptions.None))
                {
                    var_states.Add(Variable.State.Free);
                }
                else if (Regex.IsMatch(left, variable.ID, RegexOptions.None))
                {
                    var_states.Add(Variable.State.Filled);
                }
                break;

            case Common.StatementType.ConditionalJump:
                var_states.Add(Variable.State.Free);
                break;

            case Common.StatementType.PointerAssignment:
                if (left.Contains("&"))
                {
                    throw new ObjectException("Instruction type '&a=p' is not supported. Please use 'p=&a' instead.");
                }
                else if (right.Contains("&"))
                {
                    // Nothing changed
                    if (Regex.IsMatch(right, variable.ID, RegexOptions.None) && !variable.pointer)
                    {
                        break;
                    }
                    // Pointer is filled
                    else if (Regex.IsMatch(left, variable.ID, RegexOptions.None) && variable.pointer)
                    {
                        var_states.Add(Variable.State.Filled);
                    }
                    else
                    {
                        throw new ObjectException("GetChangedStates could not parse 'p=&a' instruction type. Possible errors: 'a' is a poiner; 'p' is not a pointer; incorrect TAC text.");
                    }
                }
                else if (left.Contains("*"))
                {
                    // Variable state is free
                    if (Regex.IsMatch(right, variable.ID, RegexOptions.None) && !variable.pointer)
                    {
                        var_states.Add(Variable.State.Free);
                    }
                    // Pointer is free, variable is filled
                    else if (Regex.IsMatch(left, variable.ID, RegexOptions.None) && variable.pointer)
                    {
                        var_states.Add(Variable.State.Free);
                        var_states.Add(Variable.State.Filled);
                    }
                    else
                    {
                        throw new ObjectException("GetChangedStates could not parse '*p=a' instruction type. Possible error: 'a' is a poiner or 'p' is not a pointer; incorrect TAC text.");
                    }
                }
                else if (right.Contains("*"))
                {
                    // Pointer is free, variable is free
                    if (Regex.IsMatch(right, variable.ID, RegexOptions.None) && variable.pointer)
                    {
                        var_states.Add(Variable.State.Free);
                        var_states.Add(Variable.State.Free);
                    }
                    // Variable is filled
                    else if (Regex.IsMatch(left, variable.ID, RegexOptions.None) && !variable.pointer)
                    {
                        var_states.Add(Variable.State.Filled);
                    }
                    else
                    {
                        throw new ObjectException("GetChangedStates could not parse 'a=*p' instruction type. Possible error: 'a' is a poiner or 'p' is not a pointer; incorrect TAC text.");
                    }
                }
                else
                {
                    throw new ObjectException("GetChangedStates: problem in parsing TAC text of PointerAssignment instruction type. Instruction: " + ID);
                }
                break;

            case Common.StatementType.IndexedAssignment:
                throw new ObjectException("This statement type is not supported.");

            case Common.StatementType.Procedural:
                if (variable.pointer)
                {
                    throw new ObjectException("GetChangedStates: pointers are not supported in Procedural instruction type.");
                }
                else if ((Regex.IsMatch(TACtext, "param", RegexOptions.None) || Regex.IsMatch(TACtext, "return", RegexOptions.None)) && Regex.IsMatch(TACtext, RefVariables[0].ID, RegexOptions.None))
                {
                    var_states.Add(Variable.State.Free);
                }
                else if (Regex.IsMatch(TACtext, "retrieve", RegexOptions.None) && Regex.IsMatch(TACtext, RefVariables[0].ID, RegexOptions.None))
                {
                    var_states.Add(Variable.State.Filled);
                }
                break;

            case Common.StatementType.UnconditionalJump:
            case Common.StatementType.NoOperation:
            default:
                throw new ObjectException("This statement type cannot change states of 'dead' variables.");
            }
            return(var_states);
        }