public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
            {
                if (node.Kind != SyntaxKind.StringLiteralExpression)
                    return node;

                var variables = InterpolationUtils.EnumerateVariables(node.GetText().ToString()).Distinct().ToArray();
                var arguments = string.Join(", ", variables);
                var formatString = node.GetText().ToString();

                for (int i = 0; i < variables.Length; i++) {
                    formatString = formatString.Replace("$" + variables[0], "{" + i + "}");
                }

                return Syntax.ParseExpression(string.Format("string.Format({0}, {1})", formatString, arguments));
            }
 public override IStmt VisitLiteralExpression(LiteralExpressionSyntax node)
 {
     return(new LiteralExpr
     {
         Value = node.GetText().ToString()
     });
 }
Exemple #3
0
        public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
        {
            switch (node.Kind())
            {
            case SyntaxKind.FalseLiteralExpression:
                _output.Write(node, "false");
                break;

            case SyntaxKind.TrueLiteralExpression:
                _output.Write(node, "true");
                break;

            case SyntaxKind.NullLiteralExpression:
                _output.Write(node, "null");
                break;

            case SyntaxKind.NumericLiteralExpression:
                string num = node.GetText().ToString().Trim(); //Note:Keep everything, e.g. prefix 0, in C#, it has no meaning, but it means octet in js
                if (!char.IsNumber(num[num.Length - 1]))       //Note:Remove postfix, since C# has l,m etc as postfix.
                {
                    num = num.Substring(0, num.Length - 1);
                }
                _output.Write(node, num);
                break;

            case SyntaxKind.StringLiteralExpression:
                string str = node.Token.ValueText.Bracketing(StringPair.DoubleQuote);
                if (str[0] == '@')
                {
                    str = str.Substring(1);

                    this.AppendCompileIssue(node, IssueType.Warning, IssueId.StringPrefixIgnore);
                }
                _output.Write(node, str);
                break;

            case SyntaxKind.CharacterLiteralExpression:
                _output.Write(node, node.Token.ValueText.Bracketing(StringPair.SingleQuote));
                break;

            default:
                this.AppendCompileIssue(node, IssueType.Error, IssueId.UnknownExpressionType, node.Kind());
                break;
            }

            return(node);
        }
        private string EmitLiteralExpression(LiteralExpressionSyntax node)
        {
            /*
             * switch (node.Kind)
             * {
             *  case SyntaxKind.NumericLiteralExpression:
             *      _writer.Write(node.GetText());
             *      break;
             *
             *  case SyntaxKind.StringLiteralExpression:
             *      _writer.Write("\"{0}\"", node.GetText());
             *      break;
             * }
             */

            return(node.GetText().ToString());
        }
Exemple #5
0
        private string EmitLiteralExpression(LiteralExpressionSyntax node)
        {
            /*
            switch (node.Kind)
            {
                case SyntaxKind.NumericLiteralExpression:
                    _writer.Write(node.GetText());
                    break;

                case SyntaxKind.StringLiteralExpression:
                    _writer.Write("\"{0}\"", node.GetText());
                    break;
            }
            */

            return node.GetText();
        }
Exemple #6
0
        public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
        {
            switch (node.Kind())
            {
                case SyntaxKind.FalseLiteralExpression:
                    _output.Write(node, "false");
                    break;

                case SyntaxKind.TrueLiteralExpression:
                    _output.Write(node, "true");
                    break;

                case SyntaxKind.NullLiteralExpression:
                    _output.Write(node, "null");
                    break;

                case SyntaxKind.NumericLiteralExpression:
                    string num = node.GetText().ToString().Trim();//Note:Keep everything, e.g. prefix 0, in C#, it has no meaning, but it means octet in js
                    if (!char.IsNumber(num[num.Length - 1]))//Note:Remove postfix, since C# has l,m etc as postfix.
                    {
                        num = num.Substring(0, num.Length - 1);
                    }
                    _output.Write(node, num);
                    break;

                case SyntaxKind.StringLiteralExpression:
                    string str = node.Token.ValueText.Bracketing(StringPair.DoubleQuote);
                    if (str[0] == '@')
                    {
                        str = str.Substring(1);

                        this.AppendCompileIssue(node, IssueType.Warning, IssueId.StringPrefixIgnore);
                    }
                    _output.Write(node, str);
                    break;

                case SyntaxKind.CharacterLiteralExpression:
                    _output.Write(node, node.Token.ValueText.Bracketing(StringPair.SingleQuote));
                    break;

                default:
                    this.AppendCompileIssue(node, IssueType.Error, IssueId.UnknownExpressionType, node.Kind());
                    break;
            }

            return node;
        }