// 
// Copyright (c) Microsoft Corporation.   All rights reserved.
//

using System;
using System.Text;

///////////////////////////////////////////////////////////////////////
//
// The Bartok.msil.Signature* classes represent the signatures read
// from the Blob heap of the input file(s).
// 
// Since the signatures have references to MetaData* objects, the
// signatures are initially just an array of bytes.  When all the
// MetaData objects have been created, the array of bytes is processed
// and the references resolved.
//
//////////////////////////////////////////////////////////////////////  

namespace Bartok.MSIL
{

  public abstract class Signature {

      // Constructor Methods

      internal virtual Signature resolve(MetaDataLoader mdLoader) {
          return this;
      }

      internal virtual Signature resolveTypeSpec(MetaDataLoader mdLoader) {
          return this;
      }

      // Internal Classes

      public enum CallingConventions: byte {
          Default                = 0x00,
              Unmanaged_cdecl    = 0x01,
              Unmanaged_sdtcall  = 0x02,
              Unmanaged_thiscall = 0x03,
              Unmanaged_fastcall = 0x04,
              VarArg             = 0x05,
              Field              = 0x06,
              LocalVar           = 0x07,
              Property           = 0x08,
              Unmanaged          = 0x09,
              Mask               = 0x0f,
              Generic            = 0x10,
              HasThis            = 0x20,
              ExplicitThis       = 0x40
      }

      // REVIEW: Consider memoizing these types.

      public class Type {

          // Constructor Methods

          // elementType \in
          // { VOID, BOOLEAN, CHAR, I1, U1, I2, U2, I4, U4, I8, U8, R4, R8,
          //   U, I, OBJECT, STRING, TYPEDBYREF }
          internal Type(ElementTypes elementType) {
              this.elementType = elementType;
          }

          // elementType \in {VALUETYPE, CLASS}
          internal Type(ElementTypes elementType,
                        MetaDataObject classObject) {
              this.elementType = elementType;
              this.classObject = classObject;
          }

          // elementType \in {SZARRAY, CMOD_OPT, CMOD_REQD, PINNED, PTR, BYREF}
          internal Type(ElementTypes elementType,
                        Type typeObject,
                        Modifier modifierList) {
              this.elementType = elementType;
              this.typeObject = typeObject;
              this.modifierList = modifierList;
          }
          
          // elementType is ARRAY
          internal Type(ElementTypes elementType,
                        Type typeObject,
                        uint[] lowerBounds,
                        uint[] upperBounds) {
              this.elementType = elementType;
              this.typeObject = typeObject;
              this.lowerBounds = lowerBounds;
              this.upperBounds = upperBounds;
          }

          // elementType is FNPTR
          internal Type(ElementTypes elementType,
                        SignatureMethod methodSignature) {
              this.elementType = elementType;
              this.methodSignature = methodSignature;
          }

          // elementType \in {VAR, MVAR}
          internal Type(ElementTypes elementType,
                        uint number) {
              this.elementType = elementType;
              this.number = number;
          }

          // elementType is GENERICINST
          internal Type(ElementTypes elementType,
                        Type typeObject,
                        Type[] typeList) {
              this.elementType = elementType;
              this.typeObject = typeObject;
              this.typeList = typeList;
          }

          // Accessors

          public ElementTypes ElementType {
              get { return elementType; }
          }

          public MetaDataObject ClassObject {
              // REVIEW: throw on inconsistent elementtype?
              get { return classObject; }
          }

          public Type TypeObject {
              // REVIEW: throw on inconsistent elementtype?
              get { return typeObject; }
          }

          public Type[] TypeList {
              // REVIEW: throw on inconsistent elementtype?
              get { return typeList; }
          }

          public Modifier ModifierList {
              // REVIEW: throw on inconsistent elementtype?
              get { return modifierList; }
          }

          public uint[] UpperBounds {
              // REVIEW: throw on inconsistent elementtype?
              get { return upperBounds; }
          }

          public uint[] LowerBounds {
              // REVIEW: throw on inconsistent elementtype?
              get { return lowerBounds; }
          }
          
          public int Rank {
              get { return upperBounds.Length; }
          }

          public SignatureMethod MethodSignature {
              // REVIEW: throw on inconsistent elementtype?
              get { return methodSignature; }
          }

          public uint Number {
              // REVIEW: throw on inconsistent elementtype?
              get { return number; }
          }

#region SyncBlockHack
          // Equality methods

          public override bool Equals(Object o) {
              return this == o;
          }

          public override int GetHashCode() {
              if (hash == 0) {
                  if (nextHash == 0) {
                      nextHash++;
                  }
                  hash = nextHash++;
              }
              return hash;
          }
#endregion
              
          // Debug Methods

          public override string ToString() {
              StringBuilder sb = new StringBuilder("Type(0x");
              // BUGBUG: use symbolic printing when selfhost can do so
              sb.Append(((uint) elementType).ToString("x"));
              sb.Append(",");
              for (Modifier modifier = this.modifierList;
                   modifier != null;
                   modifier = modifier.next) {
                  sb.Append(modifier);
                  sb.Append(",");
              }
              if (this.typeObject != null) {
                  sb.Append(this.typeObject);
                  sb.Append(",");
              }
              if (this.typeList != null) {
                  sb.Append("typelist[");
                  sb.Append(this.typeList[0]);
                  for (int i = 1; i < this.typeList.Length; i++) {
                      sb.Append(",");
                      sb.Append(this.typeList[i]);
                  }
                  sb.Append("],");
              }
              if (this.classObject != null) {
                  sb.Append(this.classObject);
                  sb.Append(",");
              }
              if (this.lowerBounds != null) {
                  sb.Append("lowerbounds[");
                  sb.Append(this.lowerBounds[0]);
                  for (int i = 1; i < this.lowerBounds.Length; i++) {
                      sb.Append(",");
                      sb.Append(this.lowerBounds[i]);
                  }
                  sb.Append("],");
              }
              if (this.upperBounds != null) {
                  sb.Append("upperbounds[");
                  sb.Append(this.upperBounds[0]);
                  for (int i = 1; i < this.upperBounds.Length; i++) {
                      sb.Append(",");
                      sb.Append(this.upperBounds[i]);
                  }
                  sb.Append("],");
              }
              if (this.methodSignature != null) {
                  sb.Append(methodSignature);
                  sb.Append(",");
              }
              if (this.elementType == ElementTypes.VAR
                  || this.elementType == ElementTypes.MVAR) {
                  sb.Append(number);
                  sb.Append(",");
              }
              sb.Remove(sb.Length-1, 1);
              sb.Append(")");
              return sb.ToString();
          }

          // State

          private readonly ElementTypes elementType;
          private readonly MetaDataObject classObject;
          private readonly Type typeObject;
          private readonly Type[] typeList;
          private readonly Modifier modifierList;
          private readonly uint[] lowerBounds;
          private readonly uint[] upperBounds;
          private readonly SignatureMethod methodSignature;
          private readonly uint number;

#region SyncBlockHack
          private int hash;
          private static int nextHash;
#endregion
      }

      public class Param {

          // Constructor Methods

          internal Param(Modifier modifierList, ElementTypes kind, Type type) {
              this.modifierList = modifierList;
              this.kind = kind;
              this.type = type;
          }

          // Access Methods

          public Modifier ModifierList {
              get {
                  return this.modifierList;
              }
          }

          // One of ElementTypes.{END, BYREF, TYPEDBYREF},
          // ElementTypes.END means no flag present
          public ElementTypes Kind {
              get {
                  return this.kind;
              }
          }

          public Type Type {
              get {
                  return this.type;
              }
          }

          // Debug Methods

          public override string ToString() {
              StringBuilder sb = new StringBuilder("Parameter(");
              for (Modifier modifier = this.modifierList;
                   modifier != null;
                   modifier = modifier.next) {
                  sb.Append(modifier);
                  sb.Append(",");
              }
              sb.Append(((uint) kind).ToString("x"));
              sb.Append(",");
              sb.Append(type);
              sb.Append(")");
              return sb.ToString();
          }

          // State

          private readonly Modifier modifierList;
          private readonly ElementTypes kind;
          private readonly Type type;

      }

      public class Modifier {

          // Constructor Methods

          internal Modifier(ElementTypes kind,
                            MetaDataObject type,
                            Modifier next) {
              this.kind = kind;
              this.type = type;
              this.next = next;
          }

          // Accessor
          public ElementTypes Kind {
              get { return kind; }
          }

          public MetaDataObject Type {
              get { return type; }
          }

          public Modifier Next {
              get { return next; }
          }

          // Debug Methods

          public override string ToString() {
              return (((uint) kind).ToString("x")+" "+type);
          }

          // State

          private  readonly ElementTypes   kind;
          private  readonly MetaDataObject type;
          internal readonly Modifier       next;

      }

  }

  internal class SignatureBuffer: Signature {

      // Constructor Methods

      internal SignatureBuffer(byte[] buffer) {
          this.buffer = buffer;
      }

      internal override Signature resolve(MetaDataLoader mdLoader) {
          uint unmaskedCallingConvention =
              uncompressInt(this.buffer, ref this.offset);
          CallingConventions callingConvention = (CallingConventions)
              (unmaskedCallingConvention & (uint) CallingConventions.Mask);
          switch (callingConvention) {
            case CallingConventions.Field: {
                // Section 22.2.4 of ECMA spec, partition II
                Type type = this.parseSignatureType(mdLoader);
                if (this.offset != this.buffer.Length) {
                    throw new MetaDataLoader.IllegalMetaDataFormatException("Only read "+this.offset+" bytes of "+this);
                }
                return new SignatureField(type);
            }
            case CallingConventions.LocalVar: {
                // Section 22.2.6 of ECMA spec, partition II
                uint count = uncompressInt(this.buffer, ref this.offset);
                Type[] locals = new Type[count];
                for (int i = 0; i < count; i++) {
                    locals[i] = parseSignatureLocal(mdLoader);
                }
                if (this.offset != this.buffer.Length) {
                    throw new MetaDataLoader.IllegalMetaDataFormatException("Only read "+this.offset+" bytes of "+this);
                }
                return new SignatureLocalVar(locals);
            }
            case CallingConventions.Property: {
                // Section 22.2.5 of ECMA spec, partition II
                uint paramCount = uncompressInt(this.buffer, ref this.offset);
                Type returnType = this.parseSignatureType(mdLoader);
                Param[] parameters = new Param[paramCount];
                for (int i = 0; i < paramCount; i++) {
                    parameters[i] = this.parseSignatureParam(mdLoader);
                }
                if (this.offset != this.buffer.Length) {
                    throw new MetaDataLoader.IllegalMetaDataFormatException("Only read "+this.offset+" bytes of "+this);
                }
                return new SignatureProperty(returnType, parameters);
            }
            default: {
                // Section2 22.2.1, 22.2.2, and 22.2.3 of ECMA spec, II
                uint genericParamCount = 0;
                if((unmaskedCallingConvention
                    & (uint) CallingConventions.Generic) != 0) {
                    genericParamCount = uncompressInt(this.buffer,
                                                      ref this.offset);
                }
                uint paramCount = uncompressInt(this.buffer, ref this.offset);
                Type returnType = this.parseSignatureType(mdLoader);
                int sentinelLocation = -1;
                Param[] parameters = new Param[paramCount];
                for (int i = 0; i < paramCount; i++) {
                    byte first = this.buffer[this.offset];
                    if (first == (byte) ElementTypes.SENTINEL) {
                        sentinelLocation = i;
                        this.offset++;
                    }
                    parameters[i] = this.parseSignatureParam(mdLoader);
                }
                if (this.offset != this.buffer.Length) {
                    throw new MetaDataLoader.IllegalMetaDataFormatException("Only read "+this.offset+" bytes of "+this);
                }
                // pass unmasked convention because user of signature (e.g. memberRef)
                // may need to know the static vs. instance status of the method
                // Erik, 4/13/01
                return new SignatureMethod((CallingConventions)
                                           unmaskedCallingConvention,
                                           genericParamCount,
                                           returnType, parameters,
                                           sentinelLocation);
            }
          }

      }

      internal override Signature resolveTypeSpec(MetaDataLoader mdLoader) {
          Type type = this.parseSignatureType(mdLoader);
          if (this.offset != this.buffer.Length) {
              throw new MetaDataLoader.IllegalMetaDataFormatException("Only read "+this.offset+" bytes of "+this);
          }
          return new SignatureTypeSpec(type);
      }

      internal static uint uncompressInt(byte[] buffer, ref int offset) {
          byte first = buffer[offset];
          if ((first & 0x80) == 0x00) {
              // 0??? ????: one byte encoding
              offset++;
              return first;
          }
          else if ((first & 0xC0) == 0x80) {
              // 10?? ????: two byte encoding
              byte second = buffer[offset+1];
              offset += 2;
              return (((first & 0x3fU) << 8) | second);
          }
          else {
              // 11?? ????: four byte encoding
              byte second = buffer[offset+1];
              byte third = buffer[offset+2];
              byte fourth = buffer[offset+3];
              offset += 4;
              return (((uint) ((first & 0x3fU) << 24)) |
                      ((uint) (second << 16)) |
                      ((uint) (third << 8)) |
                      ((uint) fourth));
          }
      }

      private MetaDataObject uncompressToken(MetaDataLoader mdLoader) {
          uint codedToken = uncompressInt(this.buffer, ref this.offset);
          MetaDataLoader.TokenType tokenType =
              ((((codedToken & 0x2) == 0) ?
                (((codedToken & 0x1) == 0) ?
                 MetaDataLoader.TokenType.TypeDef :
                 MetaDataLoader.TokenType.TypeRef) :
                (((codedToken & 0x1) == 0) ?
                 MetaDataLoader.TokenType.TypeSpec :
                 MetaDataLoader.TokenType.BaseType)));
          int token = (int) (codedToken >> 2) | (int) tokenType;
          return mdLoader.getObjectFromToken(token);
      }

      private Type parseSignatureType(MetaDataLoader mdLoader) {
          ElementTypes elementType = (ElementTypes) this.buffer[this.offset];
          this.offset++;
          switch (elementType) {
            case ElementTypes.VOID:
            case ElementTypes.BOOLEAN:
            case ElementTypes.CHAR:
            case ElementTypes.I1:
            case ElementTypes.U1:
            case ElementTypes.I2:
            case ElementTypes.U2:
            case ElementTypes.I4:
            case ElementTypes.U4:
            case ElementTypes.I8:
            case ElementTypes.U8:
            case ElementTypes.R4:
            case ElementTypes.R8:
            case ElementTypes.U:
            case ElementTypes.I:
            case ElementTypes.OBJECT:
            case ElementTypes.STRING:
            case ElementTypes.TYPEDBYREF: {
                return new Type(elementType);
            }
            case ElementTypes.VALUETYPE:
            case ElementTypes.CLASS: {
                // Followed by: TypeDefOrRefEncoded
                MetaDataObject classObject = uncompressToken(mdLoader);
                return new Type(elementType, classObject);
            }
            case ElementTypes.SZARRAY: {
                // Followed by: CustomMod* Type
                Modifier modifierList = this.parseSignatureModifiers(mdLoader);
                Type type = this.parseSignatureType(mdLoader);
                return new Type(elementType, type, modifierList);
            }
            case ElementTypes.ARRAY: {
                // Followed by: Type ArrayShape
                Type type = this.parseSignatureType(mdLoader);
                uint rank = uncompressInt(this.buffer, ref this.offset);
                if (rank == 0) {
                    throw new MetaDataLoader.IllegalMetaDataFormatException("ARRAY with rank 0");
                }
                uint[] upperBounds = new uint[rank];
                uint[] lowerBounds = new uint[rank];
                uint numUpperBounds =
                    uncompressInt(this.buffer, ref this.offset);
                if (numUpperBounds > rank) {
                    throw new MetaDataLoader.IllegalMetaDataFormatException("ARRAY with upper bounds > rank");
                }
                for (int i = 0; i < numUpperBounds; i++) {
                    upperBounds[i] =
                        uncompressInt(this.buffer, ref this.offset);
                }
                uint numLowerBounds =
                    uncompressInt(this.buffer, ref this.offset);
                if (numLowerBounds > rank) {
                    throw new MetaDataLoader.IllegalMetaDataFormatException("ARRAY with lower bounds > rank");
                }
                for (int i = 0; i < numLowerBounds; i++) {
                    lowerBounds[i] =
                        uncompressInt(this.buffer, ref this.offset);
                }
                return new Type(elementType, type, lowerBounds, upperBounds);
            }
            case ElementTypes.FNPTR: {
                // Followed by: MethodDefSig or MethodRefSig
                uint unmaskedCallingConvention =
                    uncompressInt(this.buffer, ref this.offset);
                CallingConventions callingConvention = (CallingConventions)
                    (unmaskedCallingConvention
                     & (uint) CallingConventions.Mask);
                if (callingConvention == CallingConventions.Field ||
                    callingConvention == CallingConventions.LocalVar ||
                    callingConvention == CallingConventions.Property) {
                    throw new MetaDataLoader.IllegalMetaDataFormatException("FNPTR surprised by calling convention "+callingConvention);
                }
                if ((unmaskedCallingConvention
                     & (uint) CallingConventions.Generic) != 0) {
                    throw new MetaDataLoader.IllegalMetaDataFormatException("FNPTR generic unimplemented - check to see if legal");
                }
                uint paramCount = uncompressInt(this.buffer, ref this.offset);
                Type returnType = this.parseSignatureType(mdLoader);
                int sentinelLocation = -1;
                Param[] parameters = new Param[paramCount];
                for (int i = 0; i < paramCount; i++) {
                    byte first = this.buffer[this.offset];
                    if (first == (byte) ElementTypes.SENTINEL) {
                        sentinelLocation = i;
                        this.offset++;
                    }
                    parameters[i] = this.parseSignatureParam(mdLoader);
                }
                SignatureMethod signature =
                    new SignatureMethod(callingConvention, 0, returnType,
                                        parameters, sentinelLocation);
                return new Type(elementType, signature);
            }
            case ElementTypes.VAR:
            case ElementTypes.MVAR: {
                // Generic type variables
                uint number = uncompressInt(this.buffer, ref this.offset);
                return new Type(elementType, number);
            }
            case ElementTypes.GENERICINST: {
                // Generic type instantiation
                Type type = this.parseSignatureType(mdLoader);
                uint typeCount = uncompressInt(this.buffer, ref this.offset);
                Type[] typeParams = new Type[typeCount];
                for (int i = 0; i < typeCount; i++) {
                    Type paramType = this.parseSignatureType(mdLoader);
                    typeParams[i] = paramType;
                }

                return new Type(elementType, type, typeParams);
            }
            case ElementTypes.CMOD_OPT:
            case ElementTypes.CMOD_REQD: {
                // Modifiers
                this.offset--;
                Modifier modifierList = this.parseSignatureModifiers(mdLoader);
                Type type = this.parseSignatureType(mdLoader);
                return new Type(elementType, type, modifierList);
            }
            case ElementTypes.PINNED:
            case ElementTypes.PTR:
            case ElementTypes.BYREF: {
                // Modifiers
                Type type = this.parseSignatureType(mdLoader);
                return new Type(elementType, type, (Modifier) null);
            }
            default: {
                throw new MetaDataLoader.IllegalMetaDataFormatException("Unknown signature type: 0x"+((byte) elementType).ToString("x2")+" at "+this.offset+" in "+this);
            }
          }
      }

      private Modifier parseSignatureModifiers(MetaDataLoader mdLoader) {
          Modifier result = null;
          ElementTypes mod = (ElementTypes) this.buffer[this.offset];
          while (mod == ElementTypes.CMOD_REQD ||
                 mod == ElementTypes.CMOD_OPT) {
              this.offset++;
              uint typeEncoded = uncompressInt(this.buffer, ref this.offset);
              // BUGBUG: type conversion on int.
              MetaDataObject type = mdLoader.getTypeDefOrRef((int) typeEncoded);
              result = new Modifier(mod, type, result);
              if (this.offset < this.buffer.Length) {
                mod = (ElementTypes) this.buffer[this.offset];
              }
              else {
                mod = ElementTypes.VOID;
              }
          }
          return result;
      }

      private Param parseSignatureParam(MetaDataLoader mdLoader) {
          Modifier modifierList = this.parseSignatureModifiers(mdLoader);
          byte first = this.buffer[this.offset];
          if (first == (byte) ElementTypes.BYREF) {
              this.offset++;
              Type type = this.parseSignatureType(mdLoader);
              return new Param(modifierList, (ElementTypes) first, type);
          }
          else if (first == (byte) ElementTypes.TYPEDBYREF) {
              this.offset++;
              return new Param(modifierList, (ElementTypes) first, null);
          }
          else {
              Type type = this.parseSignatureType(mdLoader);
              return new Param(modifierList, ElementTypes.END, type);
          }
      }

      private Type parseSignatureLocal(MetaDataLoader mdLoader) {
          ElementTypes first = (ElementTypes) this.buffer[this.offset];
          if (first == ElementTypes.PINNED) {
              this.offset++;
              Type type = this.parseSignatureType(mdLoader);
              return new Type(first, type, (Modifier) null);
          }
          else {
              return this.parseSignatureType(mdLoader);
          }
      }

      // Debug Methods

      public override string ToString() {
          StringBuilder sb = new StringBuilder("SignatureBuffer(");
          int bufferSize = this.buffer.Length;
          if (bufferSize > 0) {
              sb.Append("0x");
              sb.Append(this.buffer[0].ToString("x2"));
              for (int i = 1; i < bufferSize; i++) {
                  sb.Append(",");
                  sb.Append("0x");
                  sb.Append(this.buffer[i].ToString("x2"));
              }
          }
          sb.Append(")");
          return sb.ToString();
      }

      // State

      private readonly byte[] buffer;
      private int offset;

  }

}