StringType.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: StringType.cs                                                        //
// Authors: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                   //
//          Francisco Ortin - francisco.ortin@gmail.com                       //
// Description:                                                               //
//    Represent a string type.                                                //
//    Inheritance: TypeExpression.                                            //
//    Implements Composite pattern [Leaf].                                    //
//    Implements Singleton pattern.                                           //
// -------------------------------------------------------------------------- //
// Create date: 22-10-2006                                                    //
// Modification date: 22-03-2007                                              //
//Visto
using System;
using System.Collections.Generic;
using System.Text;

using AST;
using ErrorManagement;
using Tools;
using TypeSystem.Operations;

namespace TypeSystem {
    public class StringType : TypeExpression {
        
        #region Fields

        private static readonly StringType instance = new StringType();

        private BCLClassType BCLType = new BCLClassType("System.String", Type.GetType("System.String"));

        #endregion

        #region Properties

        public static StringType Instance {
            get { return instance; }
        }

        #endregion

        #region Constructors

        private StringType() {
            this.typeExpression = "string";
            this.fullName = "string";
        }

        static StringType() {
        }

        #endregion

        // WriteType Inference
        #region Dispatcher
        public override object AcceptOperation(TypeSystemOperation op, object arg) { return op.Exec(this, arg); }
        #endregion

        #region Assignment() ANULADA
        //public override TypeExpression Assignment(TypeExpression operand, AssignmentOperator op, MethodType methodAnalyzed, SortOfUnification unification,
        //            TypeExpression actualImplicitObject, Location location) {
        //    if ((op == AssignmentOperator.Assign) || (op == AssignmentOperator.PlusAssign))
        //        return operand.Promotion(this, op, methodAnalyzed, location);
        //    ErrorManager.Instance.NotifyError(new OperationNotAllowedError(this.FullName, operand.FullName, location));
        //    return null;
        //}

        #endregion

        #region Arithmetic() ANULADA
        /*

        public override TypeExpression Arithmetic(TypeExpression operand, Enum op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            if (op.Equals(ArithmeticOperator.Plus)) {
                if (operand is StringType)
                    return StringType.Instance;
                // * Commutative
                return operand.Arithmetic(this, op, methodAnalyzed, showErrorMessage, loc);
            }
            if (showErrorMessage)
                ErrorManager.Instance.NotifyError(new OperationNotAllowedError(op.ToString(), this.FullName, operand.FullName, loc));
            return null;
        }
        */
        #endregion

        #region Relational()ANULADA
        /*
        public override objet AcceptOperation(RelationalOperation firstOperand) {
            if (relationalOperator== RelationalOperator.Equal || op == RelationalOperator.NotEqual) {
                if (secondOperand.PromotionLevel(this) != -1)
                    return BoolType.Instance;
                if (showErrorMessage) {
                    ErrorManager.Instance.NotifyError(new TypePromotionError(operand.FullName, this.FullName, loc));
                    return null;
                }
            }
            if (showErrorMessage)
                ErrorManager.Instance.NotifyError(new OperationNotAllowedError(op.ToString(), this.FullName, operand.FullName, loc));
            return null;
        }
        */
        #endregion

        #region Dot() ANULADA
        //public override TypeExpression Dot(string field, MethodType methodAnalyzed, IList<TypeExpression> previousDot, Location loc) {
        //    return this.BCLType.Dot(field, methodAnalyzed, previousDot, loc);
        //}
        //public override TypeExpression Dot(string memberName, IList<TypeExpression> previousDot) {
        //    return this.BCLType.Dot(memberName, previousDot);
        //}
        #endregion

        #region AsClassType()
        public override ClassType AsClassType() {
            return this.BCLType;
        }
        #endregion

        // WriteType Promotion

        #region PromotionLevel() ANULADA

        //public override int PromotionLevel(TypeExpression type) {
        //    // * String WriteType and bounded type variables
        //    if (TypeExpression.As<StringType>(type)!=null)
        //        return 0;
        //    // * WriteType variable
        //    TypeVariable typeVariable = type as TypeVariable;
        //    if (typeVariable != null && typeVariable.Substitution == null)
        //        // * A free variable is complete promotion
        //        return 0;
        //    // * Union type
        //    UnionType unionType = TypeExpression.As<UnionType>(type);
        //    if (unionType != null)
        //        return unionType.SuperType(this);
        //    // * Field type and bounded type variable
        //    FieldType fieldType = TypeExpression.As<FieldType>(type);
        //    if (fieldType != null)
        //        return this.PromotionLevel(fieldType.FieldTypeExpression);
        //    // * Use the BCL object oriented approach
        //    return this.BCLType.PromotionLevel(type);
        //}

       #endregion

        #region IsValueType()

        public override bool IsValueType()
        {
           return false;
        }

        #endregion

        // WriteType Unification

        #region Unify
        public override bool Unify(TypeExpression te, SortOfUnification unification, IList<Pair<TypeExpression, TypeExpression>> previouslyUnified) {
            StringType st = te as StringType;
            if (st != null)
                return true;
            if (te is TypeVariable && unification != SortOfUnification.Incremental)
                // * No incremental unification is commutative
                return te.Unify(this, unification, previouslyUnified);
            return false;
        }
        #endregion
    }
}