2001-08-06 Miguel de Icaza <miguel@ximian.com>

[mono.git] / mcs / mcs / expression.cs

//
// expression.cs: Expression representation for the IL tree.
//
// Author:
//   Miguel de Icaza (miguel@ximian.com)
//
// (C) 2001 Ximian, Inc.
//
namespace CIR {
        using System.Collections;
        using System.Diagnostics;
        using System;
        
        public abstract class Expression {
                string type;
                bool is_lvalue;

                public string Type {
                        get {
                                return type;
                        }
                }

                public bool IsLValue {
                        get {
                                return is_lvalue;
                        }

                        set {
                                is_lvalue = value;
                        }
                }

                public virtual bool IsLiteral {
                        get {
                                return false;
                        }
                }
                
                // <summary>
                //   Protected constructor.  Only derivate types should
                //   be able to be created
                // </summary>
                // protected Type (

                protected Expression ()
                {
                        type = null;
                }
                
                static bool EvaluateType (Expression expr, out string setType)
                {
                        setType = null;
                        return true;
                }
        }

        public class Unary : Expression {
                public enum Operator {
                        Plus, Minus, Negate, BitComplement,
                        Indirection, AddressOf, PreIncrement,
                        PreDecrement, PostIncrement, PostDecrement
                }

                Operator   oper;
                Expression expr;
                
                public Unary (Operator op, Expression expr)
                {
                        this.oper = op;
                        this.expr = expr;
                }

                public Expression Expr {
                        get {
                                return expr;
                        }

                        set {
                                expr = value;
                        }
                }

                public Operator Oper {
                        get {
                                return oper;
                        }

                        set {
                                oper = value;
                        }
                }
        }

        public class Probe : Expression {
                string type;
                Expression expr;
                Operator oper;

                public enum Operator {
                        Is, As
                }
                
                public Probe (Operator oper, Expression expr, string type)
                {
                        this.oper = oper;
                        this.type = type;
                        this.expr = expr;
                }

                public Operator Oper {
                        get {
                                return oper;
                        }
                }

                public Expression Expr {
                        get {
                                return expr;
                        }
                }

                public string ProbeType {
                        get {
                                return type;
                        }
                }
                               
        }
        
        public class Cast : Expression {
                string type;
                Expression expr;
                
                public Cast (string type, Expression expr)
                {
                        this.type = type;
                        this.expr = expr;
                }

                public string TargetType {
                        get {
                                return type;
                        }
                }

                public Expression Expr {
                        get {
                                return expr;
                        }
                        set {
                                expr = value;
                        }
                }
        }

        public class Binary : Expression {
                public enum Operator {
                        Multiply, Divide, Modulo,
                        Add, Substract,
                        ShiftLeft, ShiftRight,
                        LessThan, GreatherThan, LessOrEqual, GreatherOrEqual, 
                        Equal, NotEqual,
                        BitwiseAnd,
                        ExclusiveOr,
                        BitwiseOr,
                        LogicalAnd,
                        LogicalOr
                }

                Operator oper;
                Expression left, right;
                
                public Binary (Operator oper, Expression left, Expression right)
                {
                        this.oper = oper;
                        this.left = left;
                        this.right = right;
                }

                public Operator Oper {
                        get {
                                return oper;
                        }
                        set {
                                oper = value;
                        }
                }
                
                public Expression Left {
                        get {
                                return left;
                        }
                        set {
                                left = value;
                        }
                }

                public Expression Right {
                        get {
                                return right;
                        }
                        set {
                                right = value;
                        }
                }
        }

        public class Conditional : Expression {
                Expression expr, trueExpr, falseExpr;
                
                public Conditional (Expression expr, Expression trueExpr, Expression falseExpr)
                {
                        this.expr = expr;
                        this.trueExpr = trueExpr;
                        this.falseExpr = falseExpr;
                }

                public Expression Expr {
                        get {
                                return expr;
                        }
                }

                public Expression TrueExpr {
                        get {
                                return trueExpr;
                        }
                }

                public Expression FalseExpr {
                        get {
                                return falseExpr;
                        }
                }
        }

        public class SimpleName : Expression {
                string name;
                
                public SimpleName (string name)
                {
                        this.name = name;
                }

                public string Name {
                        get {
                                return name;
                        }
                }
        }
        
        public class LocalVariableReference : Expression {
                string name;
                Block block;
                
                public LocalVariableReference (Block block, string name)
                {
                        this.block = block;
                        this.name = name;
                }

                public Block Block {
                        get {
                                return block;
                        }
                }

                public string Name {
                        get {
                                return name;
                        }
                }
        }

        public class ParameterReference : Expression {
                Parameters pars;
                string name;
                
                public ParameterReference (Parameters pars, string name)
                {
                        this.pars = pars;
                        this.name = name;
                }

                public string Name {
                        get {
                                return name;
                        }
                }
        }
        
        // <summary>
        //   Used for arguments to New(), Invocation()
        // </summary>
        public class Argument {
                public enum AType {
                        Expression,
                        Ref,
                        Out
                };

                AType type;
                Expression expr;

                public Argument (Expression expr, AType type)
                {
                        this.expr = expr;
                        this.type = type;
                }

                public Expression Expr {
                        get {
                                return expr;
                        }
                }

                public AType Type {
                        get {
                                return type;
                        }
                }
        }

        // <summary>
        //   Invocation of methods or delegates.
        // </summary>
        public class Invocation : Expression {
                ArrayList arguments;
                Expression expr;

                //
                // arguments is an ArrayList, but we do not want to typecast,
                // as it might be null.
                //
                // FIXME: only allow expr to be a method invocation or a
                // delegate invocation (7.5.5)
                //
                public Invocation (Expression expr, ArrayList arguments)
                {
                        this.expr = expr;
                        this.arguments = arguments;
                }

                public Expression Expr {
                        get {
                                return expr;
                        }
                }

                public ArrayList Arguments {
                        get {
                                return arguments;
                        }
                }
        }

        public class New : Expression {
                ArrayList arguments;
                string requested_type;

                public New (string requested_type, ArrayList arguments)
                {
                        this.requested_type = requested_type;
                        this.arguments = arguments;
                }
                
                public ArrayList Arguments{
                        get {
                                return arguments;
                        }
                }
                
                public string RequestedType {
                        get {
                                return requested_type;
                        }
                }
        }

        public class This : Expression {
        }

        public class TypeOf : Expression {
                string queried_type;
                
                public TypeOf (string queried_type)
                {
                        this.queried_type = queried_type;
                }

                public string QueriedType {
                        get {
                                return queried_type;
                        }
                }
        }

        public class SizeOf : Expression {
                string queried_type;
                
                public SizeOf (string queried_type)
                {
                        this.queried_type = queried_type;
                }

                public string QueriedType {
                        get {
                                return queried_type;
                        }
                }
        }

        public class MemberAccess : Expression {
                Expression expr;
                string id;
                
                public MemberAccess (Expression expr, string id)
                {
                        this.expr = expr;
                        this.id = id;
                }

                public Expression Expr {
                        get {
                                return expr;
                        }
                }

                public string Identifier {
                        get {
                                return id;
                        }
                }
        }

        public class BuiltinTypeAccess : Expression {
                string access_base;
                string method;
                
                public BuiltinTypeAccess (string type, string method)
                {
                        System.Console.WriteLine ("DUDE! This type should be fully resolved!");
                        this.access_base = access_base;
                        this.method = method;
                }

                public string AccessBase {
                        get {
                                return access_base;
                        }
                }

                public string Method {
                        get {
                                return method;
                        }
                }
        }

        public class MethodGroup : Expression {
                Hashtable signatures;
                string name;
                
                public MethodGroup (string name)
                {
                        signatures = new Hashtable ();
                        this.name = name;
                }

                public bool Add (Method method)
                {
                        string sig = method.ArgumentSignature;

                        if (signatures.Contains (sig))
                                return false;

                        signatures.Add (sig, method);
                        return true;
                }

                public string Name {
                        get {
                                return name;
                        }
                }

                public Hashtable Methods {
                        get {
                                return signatures;
                        }
                }
        }
}