public void CheckConditionalStatement(ParserRuleContext context, out ErrorInformation error)
        {
            error = null;
            var  relationalExpressionContext = ((Equality_expressionContext)context).relational_expression();
            bool isBoolConditional           = (context.GetText().Contains("true") || context.GetText().Contains("false"));

            if (isBoolConditional && relationalExpressionContext.Length == 2)
            {
                List <ReplaceCodeInfomation> replaceCodes = new List <ReplaceCodeInfomation>()
                {
                    new ReplaceCodeInfomation()
                    {
                        Start       = context.Start.StartIndex,
                        Length      = context.Stop.StopIndex - context.Start.StartIndex + 1,
                        ReplaceCode = ReplaceCode(context.GetText())
                    }
                };

                error = new ErrorInformation()
                {
                    ErrorCode    = "IF0001",
                    ReplaceCode  = replaceCodes,
                    DisplayText  = "Simply statement",
                    ErrorMessage = "UIT: Bool return type in conditional statement could be simplied",
                    StartIndex   = context.Start.StartIndex,
                    Length       = context.Stop.StopIndex - context.Start.StartIndex + 1
                };
            }
        }
Exemplo n.º 2
0
 public virtual void EnterEmoji([NotNull] ParserRuleContext context)
 {
     if (emojiMap.ContainsKey(context.GetText()))
     {
         Replacements.Push(new Replacement(
                               context.start.StartIndex,
                               context.stop.StopIndex,
                               emojiMap[context.GetText()].ToString()
                               ));
     }
 }
Exemplo n.º 3
0
        private List <Diagnostic> CheckExpression(ParserRuleContext expressionContext, string prefix = "")
        {
            var exp    = expressionContext.GetText();
            var result = new List <Diagnostic>();

            if (!exp.EndsWith("}"))
            {
                result.Add(BuildLGDiagnostic(TemplateErrors.NoCloseBracket, context: expressionContext));
            }
            else
            {
                exp = exp.TrimExpression();

                try
                {
                    ExpressionParser.Parse(exp);
                }
                catch (Exception e)
                {
                    var suffixErrorMsg = Evaluator.ConcatErrorMsg(TemplateErrors.ExpressionParseError(exp), e.Message);
                    var errorMsg       = Evaluator.ConcatErrorMsg(prefix, suffixErrorMsg);

                    result.Add(BuildLGDiagnostic(errorMsg, context: expressionContext));
                    return(result);
                }
            }

            return(result);
        }
Exemplo n.º 4
0
 private static void CheckAdd(ParserRuleContext context, string cssClass, List <DiagramItem> items)
 {
     if (context != null)
     {
         items.Add(TerminalWithClass(context.GetText(), cssClass));
     }
 }
Exemplo n.º 5
0
        string GetRenameTypes(ParserRuleContext context)
        {
            var text  = context.GetText();
            var split = text.Split(' ', '\t');

            return(split[split.Length - 1]);
        }
Exemplo n.º 6
0
 private void SematicError(ParserRuleContext ctx, String msg)
 {
     m_outStream.WriteLine("Error on line " + ctx.start.Line + ": \n" + msg);
     m_outStream.WriteLine("Offending Code: ");
     m_outStream.WriteLine("\b\"" + ctx.GetText() + "\"");
     throw new SemanticException("Sematic Error");
 }
Exemplo n.º 7
0
        private List <Diagnostic> CheckExpression(ParserRuleContext expressionContext, string prefix = "")
        {
            var exp    = expressionContext.GetText();
            var result = new List <Diagnostic>();

            if (!exp.EndsWith("}", StringComparison.Ordinal))
            {
                result.Add(BuildLGDiagnostic(TemplateErrors.NoCloseBracket, context: expressionContext));
            }
            else
            {
                exp = exp.TrimExpression();

                try
                {
                    ExpressionParser.Parse(exp);
                }
#pragma warning disable CA1031 // Do not catch general exception types (catch any exception and return it in the result)
                catch (Exception e)
#pragma warning restore CA1031 // Do not catch general exception types
                {
                    var suffixErrorMsg = Evaluator.ConcatErrorMsg(TemplateErrors.ExpressionParseError(exp), e.Message);
                    var errorMsg       = Evaluator.ConcatErrorMsg(prefix, suffixErrorMsg);

                    result.Add(BuildLGDiagnostic(errorMsg, context: expressionContext));
                    return(result);
                }
            }

            return(result);
        }
Exemplo n.º 8
0
        private bool EvalExpressionInCondition(ParserRuleContext expressionContext, string contentLine, string errorPrefix = "")
        {
            var exp = expressionContext.GetText().TrimExpression();

            var(result, error) = EvalByAdaptiveExpression(exp, CurrentTarget().Scope);

            if (_lgOptions.StrictMode == true && (error != null || result == null))
            {
                var templateName = CurrentTarget().TemplateName;
                if (_evaluationTargetStack.Count > 0)
                {
                    _evaluationTargetStack.Pop();
                }

                CheckExpressionResult(exp, error, result, templateName, contentLine, errorPrefix);
            }
            else if (error != null ||
                     result == null ||
                     (result is bool r1 && r1 == false) ||
                     (result is int r2 && r2 == 0))
            {
                return(false);
            }

            return(true);
        }
Exemplo n.º 9
0
 private void Visit(ParserRuleContext parserRuleContext)
 {
     if (IsUnaryResultContext(parserRuleContext))
     {
         VisitUnaryResultContext(parserRuleContext);
     }
     else if (parserRuleContext is VBAParser.LExprContext lExpr)
     {
         Visit(lExpr);
     }
     else if (parserRuleContext is VBAParser.LiteralExprContext litExpr)
     {
         Visit(litExpr);
     }
     else if (parserRuleContext is VBAParser.CaseClauseContext ||
              parserRuleContext is VBAParser.RangeClauseContext)
     {
         VisitImpl(parserRuleContext);
         StoreVisitResult(parserRuleContext, _inspValueFactory.Create(parserRuleContext.GetText()));
     }
     else if (IsBinaryMathContext(parserRuleContext) || IsBinaryLogicalContext(parserRuleContext))
     {
         VisitBinaryOpEvaluationContext(parserRuleContext);
     }
     else if (IsUnaryLogicalContext(parserRuleContext) || IsUnaryMathContext(parserRuleContext))
     {
         VisitUnaryOpEvaluationContext(parserRuleContext);
     }
 }
Exemplo n.º 10
0
        public static void ErrorCode(int n, ParserRuleContext prc)
        {
            var t = prc.GetText();
            var l = prc.Start.Line;
            var c = prc.Start.Column;

            /*Console.Write(String.Format("ErrorCode({0}): ", n));
             *          switch (n)
             *          {
             *                  case 1:
             *                          Console.WriteLine("Something Error");
             *                          break;
             *                  case 2:
             *                          Console.WriteLine("Undefine Variable");
             *                          break;
             *                  case 3:
             *                          Console.WriteLine("Divide By Zero");
             *                          break;
             *                  case 4:
             *                          Console.WriteLine("Type Error");
             *                          break;
             *                  case 5:
             *                          Console.WriteLine("Function Parament Count Not Match");
             *                          break;
             *                  default:
             *                          break;
             *          }
             *          Console.WriteLine(String.Format("#\"{0}\" @line {1}:{2}", t, l, c));*/
            Console.WriteLine("error");
            Environment.Exit(1);
        }
Exemplo n.º 11
0
        public static Range GetRange(ParserRuleContext context)
        {
            if (context.stop == null)
            {
                Pos pos = new Pos(context.start.Line, context.start.Column);
                return(new Range(pos, pos));
            }

            if (context.start.Line == context.stop.Line &&
                context.start.Column == context.stop.Column)
            {
                return(new Range
                       (
                           new Pos(context.start.Line - 1, context.start.Column),
                           new Pos(context.stop.Line - 1, context.stop.Column + context.GetText().Length)
                       ));
            }
            else
            {
                return(new Range
                       (
                           new Pos(context.start.Line - 1, context.start.Column),
                           new Pos(context.stop.Line - 1, context.stop.Column + 1)
                       ));
            }
        }
Exemplo n.º 12
0
        string GetContentFromCharType(ParserRuleContext context)
        {
            var text  = context.GetText();
            var split = text.Split(' ', '\t', ':');

            return(split[split.Length - 1]);
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="TreeExpressionEvaluator"/> class.
 /// </summary>
 /// <param name="requiredPattern">The requiredPattern<see cref="ParserRuleContext"/>.</param>
 /// <param name="matcher">The <see cref="Matcher"/>.</param>
 /// <param name="verbose">True to enable verbose logging.</param>
 public TreeExpressionEvaluator(ParserRuleContext requiredPattern, Matcher matcher, bool verbose)
 {
     this.requiredPatternText    = requiredPattern.GetText();
     this.matcher                = matcher;
     this.verbose                = verbose;
     this.FixedValue             = this.CalculateFixedValue(requiredPattern);
     this.WalkListForUnitTesting = new WalkList(requiredPattern, matcher.Lookups, matcher.LookupSets, verbose);
 }
Exemplo n.º 14
0
 public static string GetFunctionName(ParserRuleContext context)
 {
     if (context == null)
     {
         return("<Empty>");
     }
     return("Unnamed" + HashUtil.Base64SHA256(context.GetText()));
 }
Exemplo n.º 15
0
 private Identifier GetIdentifier(ParserRuleContext context)
 {
     if (context == null)
     {
         return(null);
     }
     return(new Identifier(context.GetText(), this.DBMSType));
 }
Exemplo n.º 16
0
        public void AddAttr(string type, string input, ParserRuleContext ctx)
        {
            var text = ctx.GetText(input);
            int start, end;

            ctx.GetBounds(out start, out end);
            AddAttrNode(type, text, start, end);
        }
Exemplo n.º 17
0
        private RosTypeInfo VisitBuiltInType(ParserRuleContext context)
        {
            var rosType  = context.GetText();
            var typeInfo = RosTypeInfo.CreateBuiltIn(rosType);

            _listener.OnVisitBuiltInType(typeInfo);
            return(typeInfo);
        }
Exemplo n.º 18
0
        public static QsiLiteralExpressionNode VisitLiteral(ParserRuleContext context)
        {
            QsiDataType literalType;
            object      value;

            switch (context)
            {
            case NullLiteralContext _:
                literalType = QsiDataType.Null;
                value       = null;
                break;

            case StringLiteralContext stringLiteral:
            {
                value = string.Join("",
                                    stringLiteral.STRING_LITERAL()
                                    .Select(l => IdentifierUtility.Unescape(l.GetText())));

                literalType = QsiDataType.String;
                break;
            }

            case DecimalLiteralContext _:
                literalType = QsiDataType.Decimal;
                value       = decimal.Parse(context.GetText());
                break;

            case BooleanLiteralContext _:
                literalType = QsiDataType.Boolean;
                value       = bool.Parse(context.GetText());
                break;

            default:
                throw TreeHelper.NotSupportedTree(context);
            }

            var node = new QsiLiteralExpressionNode
            {
                Value = value,
                Type  = literalType
            };

            PrimarSqlTree.PutContextSpan(node, context);

            return(node);
        }
 public static string GetFullText(this ParserRuleContext context)
 {
     if (context.Start == null || context.Stop == null || context.Start.StartIndex < 0 || context.Stop.StopIndex < 0)
     {
         return(context.GetText()); // Fallback
     }
     return(context.Start.InputStream.GetText(Interval.Of(context.Start.StartIndex, context.Stop.StopIndex)));
 }
Exemplo n.º 20
0
        private BinaryExpressionNode CreateBinaryExpressionNode(NodeLocation location, ParserRuleContext operatorContext, DaedalusParser.ExpressionContext[] expressionContexts)
        {
            string         oper             = operatorContext.GetText();
            NodeLocation   operatorLocation = GetLocation(operatorContext);
            ExpressionNode leftSide         = (ExpressionNode)Visit(expressionContexts[0]);
            ExpressionNode rightSide        = (ExpressionNode)Visit(expressionContexts[1]);

            return(new BinaryExpressionNode(location, GetBinaryOperator(oper), operatorLocation, leftSide, rightSide));
        }
        private void ResolveDefault(
            ParserRuleContext expression,
            StatementResolutionContext statementContext = StatementResolutionContext.Undefined,
            bool isAssignmentTarget      = false,
            bool hasExplicitLetStatement = false,
            bool isSetAssignment         = false)
        {
            var withExpression  = GetInnerMostWithExpression();
            var boundExpression = _bindingService.ResolveDefault(
                _moduleDeclaration,
                _currentParent,
                expression,
                withExpression,
                statementContext);

            if (boundExpression.Classification == ExpressionClassification.ResolutionFailed)
            {
                var lexpression = expression as VBAParser.LExpressionContext
                                  ?? expression.GetChild <VBAParser.LExpressionContext>(0)
                                  ?? (expression as VBAParser.LExprContext
                                      ?? expression.GetChild <VBAParser.LExprContext>(0))?.lExpression();

                if (lexpression != null)
                {
                    _declarationFinder.AddUnboundContext(_currentParent, lexpression, withExpression);
                }
                else
                {
                    Logger.Warn(
                        $"Default Context: Failed to resolve {expression.GetText()}. Binding as much as we can.");
                }
            }

            IParameterizedDeclaration defaultMember = null;

            if (boundExpression.ReferencedDeclaration != null &&
                boundExpression.ReferencedDeclaration.DeclarationType != DeclarationType.Project &&
                boundExpression.ReferencedDeclaration.AsTypeDeclaration != null)
            {
                var module  = boundExpression.ReferencedDeclaration.AsTypeDeclaration;
                var members = _declarationFinder.Members(module);
                defaultMember = (IParameterizedDeclaration)members.FirstOrDefault(member =>
                                                                                  member is IParameterizedDeclaration && member.Attributes.HasDefaultMemberAttribute() &&
                                                                                  (isAssignmentTarget
                            ? member.DeclarationType.HasFlag(DeclarationType.Procedure)
                            : member.DeclarationType.HasFlag(DeclarationType.Function)));
            }

            _boundExpressionVisitor.AddIdentifierReferences(
                boundExpression,
                _qualifiedModuleName,
                _currentScope,
                _currentParent,
                isAssignmentTarget && (defaultMember == null || isSetAssignment || defaultMember.Parameters.All(param => param.IsOptional)),
                hasExplicitLetStatement,
                isSetAssignment);
        }
Exemplo n.º 22
0
        public void EnterNumber([NotNull] ParserRuleContext context)
        {
            var literal = context.GetText().ToLowerInvariant();

            if (literal.StartsWith("0b"))
            {
                var tokens      = literal.Substring(2).Split(new char[] { '.' }, StringSplitOptions.None);
                var integerStr  = tokens[0];
                var fractionStr = tokens.Length > 1 ? tokens[1] : "";

                while (integerStr.Length % 4 != 0)
                {
                    integerStr = "0" + integerStr;
                }
                while (fractionStr.Length % 4 != 0)
                {
                    fractionStr += "0";
                }

                var str = new StringBuilder("0x");

                for (int i = 0; i < integerStr.Length; i += 4)
                {
                    var num =
                        (integerStr[i + 3] == '1' ? 1 : 0) |
                        (integerStr[i + 2] == '1' ? 2 : 0) |
                        (integerStr[i + 1] == '1' ? 4 : 0) |
                        (integerStr[i + 0] == '1' ? 8 : 0)
                    ;
                    str.Append(num.ToString("x1", CultureInfo.InvariantCulture));
                }

                if (fractionStr.Length > 0)
                {
                    str.Append(".");

                    for (int i = 0; i < fractionStr.Length; i += 4)
                    {
                        var num =
                            (fractionStr[i + 3] == '1' ? 1 : 0) |
                            (fractionStr[i + 2] == '1' ? 2 : 0) |
                            (fractionStr[i + 1] == '1' ? 4 : 0) |
                            (fractionStr[i + 0] == '1' ? 8 : 0)
                        ;
                        str.Append(num.ToString("x1", CultureInfo.InvariantCulture));
                    }
                }

                Replacements.Push(
                    new Replacement(
                        context.start.StartIndex,
                        context.stop.StopIndex,
                        str.ToString()
                        )
                    );
            }
        }
Exemplo n.º 23
0
        public override void ExitEveryRule([NotNull] ParserRuleContext context)
        {
            if (this.writer != default)
            {
                writer($"{System.Reflection.MethodBase.GetCurrentMethod().Name} | {context.GetText()} | {context.ToStringTree(parser)}");
            }

            base.ExitEveryRule(context);
        }
Exemplo n.º 24
0
 public override void EnterEveryRule([NotNull] ParserRuleContext context)
 {
     if (context.ChildCount > 1)
     {
         if (_isOtherListener == 1)
         {
             Rules.Add(new BaseRule(context.SourceInterval, context, context.GetText()));
         }
     }
 }
        private void ResolveType(ParserRuleContext expression)
        {
            var boundExpression = _bindingService.ResolveType(_moduleDeclaration, _currentParent, expression);

            if (boundExpression.Classification == ExpressionClassification.ResolutionFailed)
            {
                Logger.Warn($"Type Context: Failed to resolve {expression.GetText()}. Binding as much as we can.");
            }
            _boundExpressionVisitor.AddIdentifierReferences(boundExpression, _qualifiedModuleName, _currentScope, _currentParent);
        }
Exemplo n.º 26
0
 // Checks if the current context is an identifier, and pushes it to the expression stack.
 private void PushIfIdentifier(ParserRuleContext context)
 {
     if (context.ChildCount == 1)
     {
         var child = context.GetChild(0) as TerminalNodeImpl;
         if (child != null && child.Payload.Type == SBP.IDENTIFIER)
         {
             m_expressionData.Push(SBExpressionData.CreateIdentifier(context.GetText(), token: child.Payload as CommonToken));
         }
     }
 }
        private IdentifierReference CreateReference(ParserRuleContext callSiteContext, Declaration callee, bool isAssignmentTarget = false, bool hasExplicitLetStatement = false)
        {
            if (callSiteContext == null)
            {
                return(null);
            }
            var name      = callSiteContext.GetText();
            var selection = callSiteContext.GetSelection();

            return(new IdentifierReference(_qualifiedModuleName, name, selection, callSiteContext, callee, isAssignmentTarget, hasExplicitLetStatement));
        }
Exemplo n.º 28
0
        /// <summary>
        /// Create a node when a rule is visited
        /// </summary>
        /// <param name="context"></param>
        public override void EnterEveryRule([NotNull] ParserRuleContext context)
        {
            base.EnterEveryRule(context);
            //create metadata to save some information of context
            TreeViewerNodeMeta node = new TreeViewerNodeMeta();

            node.StartIndex = context.Start.StartIndex;
            node.StopIndex  = context.Stop.StopIndex;

            //current node is parent of context, add context to child list of current node
            if (_currentNode.Text == context.Parent?.GetType().Name)
            {
                _currentNode.Nodes.Add(context.GetType().Name);
                _currentNode     = _currentNode.Nodes[_currentNode.Nodes.Count - 1];
                _currentNode.Tag = node;
            }
            else
            {
                //current node is root node
                if (_currentNode.Parent == null)
                {
                    _currentNode.Nodes.Add(context.GetType().Name);
                    _currentNode     = _currentNode.Nodes[_currentNode.Nodes.Count - 1];
                    _currentNode.Tag = node;
                }
                else
                {
                    //current node and context node is same lever
                    _currentNode.Parent.Nodes.Add(context.GetType().Name);
                    _currentNode     = _currentNode.Parent.Nodes[_currentNode.Parent.Nodes.Count - 1];
                    _currentNode.Tag = node;
                }
            }
            //context is leaf node
            if (context.ChildCount == 1 && context.GetChild(0).ChildCount <= 0)
            {
                node.Token = context.GetText();
                _currentNode.Nodes.Add(context.GetText());
                _currentNode.Nodes[0].Tag = node;
            }
        }
Exemplo n.º 29
0
 public static void Context(ParserRuleContext ctx, LogEventLevel level = LogEventLevel.Debug)
 {
     Log.Write(
         level,
         "[{Depth}:{ContextType}] [{SourceInterval}] | children: {ChildrenCount} | {Code}",
         ctx.Depth(),
         ctx.GetType().Name,
         ctx.SourceInterval,
         ctx.ChildCount,
         ctx.GetText()
         );
 }
Exemplo n.º 30
0
 private void UpdateCondition(ParserRuleContext condition, IModuleRewriter rewriter)
 {
     if (condition.GetText().Contains(' '))
     {
         rewriter.InsertBefore(condition.Start.TokenIndex, "Not (");
         rewriter.InsertAfter(condition.Stop.TokenIndex, ")");
     }
     else
     {
         rewriter.InsertBefore(condition.Start.TokenIndex, "Not ");
     }
 }
Exemplo n.º 31
0
 public void EnterEveryRule(ParserRuleContext ctx)
 {
     if (VerboseUpdate != null)
     {
         VerboseUpdate(ctx.GetText());
     }
 }
Exemplo n.º 32
0
 private static ExpressionSyntax Constant(ParserRuleContext node)
 {
     return CSharp.ParseExpression(node.GetText());
 }
Exemplo n.º 33
0
 private static ExpressionSyntax Identifer(ParserRuleContext arg)
 {
     return CSharp.IdentifierName(arg.GetText());
 }
Exemplo n.º 34
0
 private static ExpressionSyntax StringLiteral(ParserRuleContext arg)
 {
     return CSharp.ParseExpression(arg.GetText());
 }
Exemplo n.º 35
0
 private CodeSnippetTypeMember CreateSnippetMember(ParserRuleContext context)
 {
     // The original source code
     String sourceCode = context.GetText();
     //
     CodeSnippetTypeMember snippet = new CodeSnippetTypeMember(sourceCode);
     FillCodeDomDesignerData(snippet, context.Start.Line, context.Start.Column);
     return snippet;
 }
 public UntypedFunctionUsageQuickFix(ParserRuleContext context, QualifiedSelection selection) 
     : base(context, selection, string.Format(InspectionsUI.QuickFixUseTypedFunction_, context.GetText()))
 {
 }
Exemplo n.º 37
0
		public void AddAttr(string type, string input, ParserRuleContext ctx)
		{
			var text = ctx.GetText(input);
			int start, end;
			ctx.GetBounds(out start, out end);
			AddAttrNode(type, text, start, end);
		}