Beispiel #1
0
        public string Transpile(BinaryOperatorType binaryOperator, JassTypeSyntax left, JassTypeSyntax right, out JassTypeSyntax type)
        {
            switch (binaryOperator)
            {
            case BinaryOperatorType.GreaterThan:
            case BinaryOperatorType.LessThan:
            case BinaryOperatorType.Equals:
            case BinaryOperatorType.NotEquals:
            case BinaryOperatorType.GreaterOrEqual:
            case BinaryOperatorType.LessOrEqual:
            case BinaryOperatorType.And:
            case BinaryOperatorType.Or:
                type = JassTypeSyntax.Boolean;
                break;

            default:
                type = left.Equals(JassTypeSyntax.String) || right.Equals(JassTypeSyntax.String)
                        ? JassTypeSyntax.String
                        : left.Equals(JassTypeSyntax.Real) || right.Equals(JassTypeSyntax.Real)
                            ? JassTypeSyntax.Real
                            : left;
                break;
            }

            return(binaryOperator switch
            {
                BinaryOperatorType.Add => type.Equals(JassTypeSyntax.String) ? LuaSyntaxNode.Tokens.Concatenation : LuaSyntaxNode.Tokens.Plus,
                BinaryOperatorType.Subtract => LuaSyntaxNode.Tokens.Sub,
                BinaryOperatorType.Multiplication => LuaSyntaxNode.Tokens.Multiply,
                BinaryOperatorType.Division => type.Equals(JassTypeSyntax.Integer) ? LuaSyntaxNode.Tokens.IntegerDiv : LuaSyntaxNode.Tokens.Div,
                BinaryOperatorType.GreaterThan => ">",
                BinaryOperatorType.LessThan => "<",
                BinaryOperatorType.Equals => LuaSyntaxNode.Tokens.EqualsEquals,
                BinaryOperatorType.NotEquals => LuaSyntaxNode.Tokens.NotEquals,
                BinaryOperatorType.GreaterOrEqual => ">=",
                BinaryOperatorType.LessOrEqual => "<=",
                BinaryOperatorType.And => LuaSyntaxNode.Keyword.And,
                BinaryOperatorType.Or => LuaSyntaxNode.Keyword.Or,
            });
Beispiel #2
0
        public TypeSyntax Transpile(JassTypeSyntax type)
        {
            if (type.Equals(JassTypeSyntax.Boolean))
            {
                return(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)));
            }

            if (type.Equals(JassTypeSyntax.Code))
            {
                return(SyntaxFactory.ParseTypeName(typeof(Action).FullName !));
            }

            if (type.Equals(JassTypeSyntax.Handle))
            {
                return(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)));
            }

            if (type.Equals(JassTypeSyntax.Integer))
            {
                return(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)));
            }

            if (type.Equals(JassTypeSyntax.Nothing))
            {
                return(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)));
            }

            if (type.Equals(JassTypeSyntax.Real))
            {
                return(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.FloatKeyword)));
            }

            if (type.Equals(JassTypeSyntax.String))
            {
                return(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)));
            }

            return(SyntaxFactory.ParseTypeName(Transpile(type.TypeName).Text));
        }