CodeGenerator.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- // 
// File: CodeGenerator.cs                                                     //
// Authors: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                   //
//          Francisco Ortin - francisco.ortin@gmail.com                       //
//          Daniel Zapico - daniel.zapico.rodriguez@gmail.com                 //
// Description:                                                               //
//    This class encapsulates the IL instruction used to generate the code.   
//   TODO: Maybe the comment above is wrong, the idea of this class is to add //
//functionality to the generated code not specifically IL code. In fact 
// children of this class are code generators of MSIL, CLR, rRotor and C#
//    Implements Factory method  [Abstract Product].       
// -------------------------------------------------------------------------- //
// Create date: 28-05-2007                                                    //
// Modification date: in progress                                              //

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using AST;
using CodeGeneration.ExceptionManagement;
using TypeSystem;

namespace CodeGeneration {
   abstract public class CodeGenerator {
        

       #region Fields

        protected TextWriter output;

        protected StringBuilder currentLocalVars;

        protected int currentLabel;

        protected Dictionary<string, DynamicExceptionManager> exceptions;

        #endregion

        #region Properties

        public abstract string NewLabel {
            get;
        }

        #endregion

        #region Constructors

        public CodeGenerator(TextWriter writer) {
            this.output = writer;
            this.currentLocalVars = new StringBuilder();
            this.currentLabel = 0;
            this.exceptions = new Dictionary<string, DynamicExceptionManager>();
        }

        #endregion

        public abstract void InitialComment();
            
        #region WriteComment()

        public abstract void Comment(string msg);
       public abstract void Comment(int indent, string msg);


        #endregion

        #region WriteLabel()

        public abstract void WriteLabel(int indent, string label);

        #endregion

        internal abstract void WriteConstructorHeader(int indent);
        
        internal abstract void WriteStaticConstructorHeader(int indent);
            

 /*       #region WriteLine()

        public abstract void WriteLine();

        #endregion

        #region WriteIndentation()

        protected abstract void WriteIndentation(int lenght);

        #endregion

        #region Write ()
        //Helper writes the formatted mesage in the file. Using format and obj
        // to build the resulting string.
        public virtual void Write(string format, params Object[] obj) {
            this.output.Write(format, obj);
        }
        #endregion
        */
        #region WriteType()

        public abstract void WriteType(TypeExpression type);
        #endregion

        #region WriteHeader()

        public abstract void WriteHeader(string fileName);

        #endregion

        #region WriteNamespaceHeader()
        public abstract void WriteNamespaceHeader(int indent, string name);

        #endregion

        #region WriteLNClassHeader()

        public abstract void WriteLNClassHeader(int indent, string name, ClassType type);
        #endregion

        #region WriteEndOfClass()

        public abstract void WriteEndOfClass(int indent, string name);

        #endregion

        #region WriteLNInterfaceHeader()
                
        public abstract void WriteInterfaceHeader(int indent, string name, InterfaceType type);

        #endregion

        #region WriteLNEndOfInterface()

        public abstract void WriteEndOfInterface(int indent, string name);
        #endregion

        #region WriteLNMethodHeader()
        public abstract void WriteLNMethodHeader(int indent, string name, MethodType type);
        #endregion

        #region WriteEndOfMethod()

        public abstract void WriteEndOfMethod(int indent, string name);

        #endregion

        #region WriteParams()
        public abstract void WriteParams(MethodType memberType, AST.CompoundExpression arguments);
        #endregion

        #region WriteField()

        public abstract void WriteField(int indent, string name, FieldType type, bool constantField);

        public abstract void WriteLNFieldInitialization(TypeExpression type);

        public virtual void WriteLNFieldInitialization(string init) {
            this.output.WriteLine(init);
        }

        #endregion

        #region WriteEndOfField()

        public abstract void WriteEndOfField();
        #endregion

        #region WriteStartBlock()

        public abstract void WriteStartBlock(int indent);

        #endregion

        #region WriteLNEndOfBlock()

        public abstract void WriteEndOfBlock(int indent);

        #endregion

        #region AddLocalVariable();
        public abstract void AddLocalVariable(string name, TypeExpression type);

        #endregion

        #region WriteLocalVariable()

        public abstract void WriteLocalVariable(int indent);

        #endregion

        #region WriteAuxiliarLocalVariable()

        public abstract void WriteAuxiliarLocalVariable(int indent, string id, string type);

        #endregion

        #region WriteCodeOfExceptions()

        public virtual void WriteCodeOfExceptions() {
            foreach (string key in this.exceptions.Keys)
                WriteCodeOfExceptionsTemplateMethod(this.exceptions[key]);
        }
        protected abstract void WriteCodeOfExceptionsTemplateMethod(DynamicExceptionManager d);

        #endregion

        #region WriteEntryPoint()

        public abstract void WriteEntryPoint(int indent);


        #endregion


        #region WriteEntryPoint()

        public virtual void WriteEntryPoint() {
            this.WriteEntryPoint();
        }
        #endregion


        #region TryDirective ()

        public abstract void WriteTryDirective(int indent);

        public abstract void WriteOpenBraceTry(int indent);

        public abstract void WriteCloseBraceTry(int indent);

        #endregion

        #region Catch()

        public abstract void WriteCatch(int indent, String type, String var);

        public abstract void WriteOpenBraceCatch(int indent);

        public abstract void WriteCloseBraceCatch(int indent);

        #endregion

        #region Finally()

        public abstract void WriteFinally(int indent);

        public abstract void WriteOpenBraceFinally(int indent);

        public abstract void WriteCloseBraceFinally(int indent);
        #endregion
        //#region RuntimeFreshTypeExpressionPromotion()

        //public  abstract void RuntimeFreshTypeExpressionPromotion(int indent, TypeExpression typeExpression);
        //#endregion

        #region RuntimeIsInstruction()


        #endregion

        #region WriteThrowException

        public abstract void WriteThrowException(int indent, DynamicExceptionManager dynException);

        public abstract void WriteThrowException(int indent, string ex, string[] msg);

        #endregion

        #region Box and Unbox

        #region Box
       
        public abstract void Box(int indent, TypeExpression type);
        public abstract void BoxIfNeeded(int indent, TypeExpression type);
        #endregion

        #region UnboxAny

        // Unbox <token>
        // Revert a boxed value type instance from the object form to its value type form. <token> specifies the value type being converted and must be a valid TypeDef or TypeRef token. 
        // This instruction takes an object reference from the stack and puts a managed pointer to the value type instance on the stack.

        public abstract void UnboxAny(int indent, TypeExpression type);

        #endregion

        #region Unbox

        // Unbox <token>
        // Revert a boxed value type instance from the object form to its value type form. <token> specifies the value type being converted and must be a valid TypeDef or TypeRef token. 
        // This instruction takes an object reference from the stack and puts a managed pointer to the value type instance on the stack.

        public abstract void Unbox(int indent, TypeExpression type);
        #endregion

        #endregion

        #region CallVirt <token>
        // CallVirt <token>
        // Call the virtual method specified by <token>. 

        public abstract void CallVirt(int indent, MethodType memberType, TypeExpression klass, string member, AST.CompoundExpression arguments);

        public abstract void CallVirt(int indent, PropertyType memberType, TypeExpression obj, string member, bool setProperty);

        public abstract void CallVirt(int indent, string methodType, string result, string klass, string memberName, string[] args);

        #endregion

        #region call <token>
         // call <token>
        // Call a nonvirtual method.

        public abstract void Call(int indent, MethodType memberType, TypeExpression obj, string member);
        
        
       public abstract void Call(int indent, PropertyType memberType, TypeExpression obj, string member, bool setProperty);

        public abstract void Call(int indent, string methodType, string result, string klass, string memberName, string[] args);
        
       #endregion
        
       #region Close()

        public void Close() {
            this.output.Close();
        }

        #endregion
        #region MakeCall()

        public virtual TypeExpression MakeCall(int indent, InvocationExpression node, Object o, MethodType actualMethodCalled, FieldAccessExpression fieldAccessExpression, object arg) {
            // shortcut evaluation. Null pointed error suprimed
            if (o is SynthesizedAttributes && ((SynthesizedAttributes)o).IdentifierExpressionMode == IdentifierMode.Instance)
                // * 1.1.1 The implicit parameter is an object (not a class)
                this.CallVirt(indent, actualMethodCalled, actualMethodCalled.MemberInfo.Class, fieldAccessExpression.FieldName.Identifier, node.Arguments);
            else if (actualMethodCalled.MemberInfo.Modifiers.Contains(Modifier.Abstract))
                this.CallVirt(indent, actualMethodCalled, actualMethodCalled.MemberInfo.Class, fieldAccessExpression.FieldName.Identifier, node.Arguments);
            else
                // * 1.1.2 The implicit parameter is a class (not an object)
                this.Call(indent, actualMethodCalled, actualMethodCalled.MemberInfo.Class, actualMethodCalled.MemberInfo.MemberIdentifier);

            return actualMethodCalled.Return;
        }

        #endregion

    }
}