Inheritance: DataDictionary.Interpreter.InterpreterTreeNode, IReference, ITextualExplain
 /// <summary>
 ///     Browse through the Term to find the value to edit
 /// </summary>
 /// <param name="term"></param>
 private void VisitTerm(Term term)
 {
     if (term.LiteralValue != null)
     {
         term.LiteralValue = EditExpression(term.LiteralValue);
     }
 }
Exemplo n.º 2
0
        /// <summary>
        ///     Visits a term
        /// </summary>
        /// <param name="term"></param>
        protected virtual void VisitTerm(Term term)
        {
            if (term != null)
            {
                if (term.Designator != null)
                {
                    VisitDesignator(term.Designator);
                }

                if (term.LiteralValue != null)
                {
                    VisitExpression(term.LiteralValue);
                }
            }
        }
 /// <summary>
 ///     Constructor
 /// </summary>
 /// <param name="root">The root for which this expression should be evaluated</param>
 /// <param name="log"></param>
 /// <param name="term"></param>
 /// <param name="parsingData">Additional information about the parsing process</param>
 public UnaryExpression(ModelElement root, ModelElement log, Term term, ParsingData parsingData)
     : base(root, log, parsingData)
 {
     Term = SetEnclosed(term);
 }
Exemplo n.º 4
0
        /// <summary>
        ///     Creates a redef expression based on the input of the parser
        /// </summary>
        /// <returns></returns>
        private Expression DerefExpression()
        {
            Expression retVal = null;

            List<Expression> derefArguments = new List<Expression>();
            SkipWhiteSpaces();
            int start = Index;
            string id = Identifier();
            while (id != null)
            {
                Designator designator = new Designator(Root, RootLog, id, start, start + id.Length);
                Term term = new Term(Root, RootLog, designator, designator.Start, designator.End);
                UnaryExpression unaryExpression = new UnaryExpression(Root, RootLog, term, term.Start, term.End);
                derefArguments.Add(unaryExpression);

                id = null;
                if (LookAhead("."))
                {
                    Match(".");
                    SkipWhiteSpaces();
                    start = Index;
                    id = Identifier();
                }
            }

            if (derefArguments.Count == 1)
            {
                retVal = derefArguments[0];
            }
            else if (derefArguments.Count > 1)
            {
                retVal = new DerefExpression(Root, RootLog, derefArguments, derefArguments[0].Start,
                    derefArguments[derefArguments.Count - 1].End);
            }

            return retVal;
        }
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="root">The root for which this expression should be evaluated</param>
 /// <param name="term"></parparam>
 public UnaryExpression(ModelElement root, Term term)
     : base(root)
 {
     Term = term;
     Term.Enclosing = this;
 }
Exemplo n.º 6
0
        /// <summary>
        ///     Provides the Term at position Index of the Buffer.
        /// </summary>
        /// <returns></returns>
        public Term Term()
        {
            Term retVal = null;

            Expression literalValue = EvaluateLiteral();
            if (literalValue != null)
            {
                retVal = new Term(Root, RootLog, literalValue, literalValue.Start, literalValue.End);
            }

            if (retVal == null)
            {
                Designator designator = Designator();
                if (designator != null)
                {
                    retVal = new Term(Root, RootLog, designator, designator.Start, designator.End);
                }
            }

            return retVal;
        }
Exemplo n.º 7
0
        /// <summary>
        /// Creates a redef expression based on the input of the parser
        /// </summary>
        /// <returns></returns>
        private Expression DerefExpression()
        {
            Expression retVal = null;

            List<Expression> derefArguments = new List<Expression>();
            string id = Identifier();
            while (id != null)
            {
                Designator designator = new Interpreter.Designator(Root, id);
                Term term = new Term(Root, designator);
                UnaryExpression unaryExpression = new UnaryExpression(Root, term);
                derefArguments.Add(unaryExpression);

                id = null;
                if (LookAhead("."))
                {
                    Match(".");
                    id = Identifier();
                }
            }

            if (derefArguments.Count == 1)
            {
                retVal = derefArguments[0];
            }
            else if (derefArguments.Count > 1)
            {
                retVal = new DerefExpression(Root, derefArguments);
            }

            return retVal;
        }
 /// <summary>
 ///     Constructor
 /// </summary>
 /// <param name="root">The root for which this expression should be evaluated</param>
 /// <param name="term"></parparam>
 ///     <param name="start">The start character for this expression in the original string</param>
 ///     <param name="end">The end character for this expression in the original string</param>
 public UnaryExpression(ModelElement root, ModelElement log, Term term, int start, int end)
     : base(root, log, start, end)
 {
     Term = term;
     Term.Enclosing = this;
 }
Exemplo n.º 9
0
        /// <summary>
        ///     Visits a term
        /// </summary>
        /// <param name="term"></param>
        protected virtual void VisitTerm(Term term)
        {
            if (term != null)
            {
                if (term.Designator != null)
                {
                    VisitInterpreterTreeNode(term.Designator);
                }

                if (term.LiteralValue != null)
                {
                    VisitInterpreterTreeNode(term.LiteralValue);
                }
            }
        }
 /// <summary>
 ///     Constructor
 /// </summary>
 /// <param name="root">The root for which this expression should be evaluated</param>
 /// <param name="log"></param>
 /// <param name="term"></param>
 /// <param name="start">The start character for this expression in the original string</param>
 /// <param name="end">The end character for this expression in the original string</param>
 public UnaryExpression(ModelElement root, ModelElement log, Term term, int start, int end)
     : base(root, log, start, end)
 {
     Term = SetEnclosed(term);
 }