<WarningLevelCondition=" '$(WarningLevel)' == ''">3</WarningLevel>

</PropertyGroup>

<PropertyGroup>

<DefineConstantsCondition="'$(VisualStudioVersion)'=='12.0' AND '$(ProjectLanguage)' == 'VisualBasic'">$(DefineConstants),VS_VERSION_DEV12=True</DefineConstants>

<DefineConstantsCondition="'$(VisualStudioVersion)'=='12.0' AND '$(ProjectLanguage)' != 'VisualBasic'">$(DefineConstants);VS_VERSION_DEV12</DefineConstants>

<DefineConstantsCondition="'$(VisualStudioVersion)'=='14.0' AND '$(ProjectLanguage)' == 'VisualBasic'">$(DefineConstants),VS_VERSION_DEV14=True</DefineConstants>

<DefineConstantsCondition="'$(VisualStudioVersion)'=='14.0' AND '$(ProjectLanguage)' != 'VisualBasic'">$(DefineConstants);VS_VERSION_DEV14</DefineConstants>

<DefineConstantsCondition="'$(VisualStudioVersion)'=='15.0' AND '$(ProjectLanguage)' == 'VisualBasic'">$(DefineConstants),VS_VERSION_DEV15=True</DefineConstants>

<DefineConstantsCondition="'$(VisualStudioVersion)'=='15.0' AND '$(ProjectLanguage)' != 'VisualBasic'">$(DefineConstants);VS_VERSION_DEV15</DefineConstants>

<DefineConstantsCondition="'$(VisualStudioVersion)'=='' AND '$(ProjectLanguage)' == 'VisualBasic'">$(DefineConstants),VS_VERSION_DEV14=True</DefineConstants>

<DefineConstantsCondition="'$(VisualStudioVersion)'=='' AND '$(ProjectLanguage)' != 'VisualBasic'">$(DefineConstants);VS_VERSION_DEV14</DefineConstants>

</PropertyGroup>

<PropertyGroup>

<BuildRevision>$([System.DateTime]::Now.ToString(`yyMMdd`))</BuildRevision>

if idx<0then failwith"splitNameAt: idx < 0";

if idx<0then failwith"splitNameAt: idx < 0"

letlast= nm.Length-1

if idx> lastthen failwith"splitNameAt: idx > last";

if idx> lastthen failwith"splitNameAt: idx > last"

(nm.Substring(0, idx)),

(if idx< lastthen nm.Substring(idx+1, last- idx)else"")

{ stream:byte[];

mutable pos:int;

mutable eof:bool;}

{ stream:byte[]

mutable pos:int

mutable eof:bool}

letrotLeft32 x n=(x<<< n)|||(x>>>&(32-n))

letb=new System.Text.StringBuilder(100)

letadd(s:string)=(b.Append(s)|> ignore)

letaddC(s:char)=(b.Append(s)|> ignore)

add(aref.Name);

add(aref.Name)

match aref.Versionwith

| None->()

| Some(a, b, c, d)->

add", Version=";

add", Version="

add(string(int a))

add".";

add"."

add(string(int b))

add".";

add"."

add(string(int c))

add".";

add"."

add(string(int d))

add", Culture="

match aref.Localewith

{ name:string;

hasMetadata:bool;

hash:byte[] option;}

{ name:string

hasMetadata:bool

hash:byte[] option}

{ name=name;

hasMetadata= hasMetadata;

{ name=name

hasMetadata= hasMetadata

hash=hash}

memberx.Name=x.name

match xwith

| ILType.TypeVar_->true|_->false

overridex.ToString()= x.QualifiedName

{ CallingConv:ILCallingConv;

ArgTypes:ILTypes;

{ CallingConv:ILCallingConv

ArgTypes:ILTypes

ReturnType:ILType}

andILGenericArgs= list<ILType>

{ Method:ILMethodSpec

Data:byte[]

Elements:ILAttribElem list}

Elements:ILAttribElem list}

overridex.ToString()= x.Method.ToString()+"(...)"

{ Type:ILType;

IsPinned:bool;

{ Type:ILType

IsPinned:bool

DebugInfo:(string* int* int) option}

typeILLocals= list<ILLocal>

{ IsZeroInit:bool;

MaxStack:int32;

NoInlining:bool;

AggressiveInlining:bool;

Locals:ILLocals;

Code:ILCode;

{ IsZeroInit:bool

MaxStack:int32

NoInlining:bool

AggressiveInlining:bool

Locals:ILLocals

Code:ILCode

SourceMarker:ILSourceMarker option}

mkILCallSig(csig.CallingConv, rescopeILTypes scoref csig.ArgTypes, rescopeILType scoref csig.ReturnType)

{ mrefParent= rescopeILTypeRef scoref x.DeclaringTypeRef;

mrefCallconv= x.mrefCallconv;

mrefGenericArity=x.mrefGenericArity;

mrefName=x.mrefName;

mrefArgs= rescopeILTypes scoref x.mrefArgs;

{ mrefParent= rescopeILTypeRef scoref x.DeclaringTypeRef

mrefCallconv= x.mrefCallconv

mrefGenericArity=x.mrefGenericArity

mrefName=x.mrefName

mrefArgs= rescopeILTypes scoref x.mrefArgs

mrefReturn= rescopeILType scoref x.mrefReturn}

{ DeclaringTypeRef= rescopeILTypeRef scoref x.DeclaringTypeRef;

Name= x.Name;

{ DeclaringTypeRef= rescopeILTypeRef scoref x.DeclaringTypeRef

Name= x.Name

Type= rescopeILType scoref x.Type}

MetadataIndex= NoMetadataIdx}

{ IsPinned=false;

Type=ty;

{ IsPinned=false

Type=ty

DebugInfo=dbgInfo}

[ mkLdarg0;]@

[ mkLdarg0]@

List.mapi(fun i _-> mkLdarg(uint16(i+1))) args@

[ mkNormalCall(mkILCtorMethSpecForTy(typ,[]))]

letnewLocals= ResizeArray<ILLocal>()

letlocn= uint16(numPrealloc+ newLocals.Count)

newLocals.Add loc;

newLocals.Add loc

locn

membertmps.Close()= ResizeArray.toList newLocals

(match tagwith Some x->[I_seqpoint x]| None->[])@

preblock@

List.concat(List.mapi(fun n(_pnm,nm,ty)->

[ mkLdarg0;

mkLdarg(uint16(n+1));

mkNormalStfld(mkILFieldSpecInTy(typ, nm, ty));

[ mkLdarg0

mkLdarg(uint16(n+1))

mkNormalStfld(mkILFieldSpecInTy(typ, nm, ty))

]) flds)

end, tag))

match base_tspecwith

None->[]

| Some tspec->

([ mkLdarg0;

([ mkLdarg0

mkNormalCall(mkILCtorMethSpecForTy(mkILBoxedType tspec,[]))])

mkILStorageCtorWithParamNames(tag, preblock, typ, extraParams, flds, access)

mdef.WithAbstract(false).WithHideBySig(true).WithRuntime(true)

letctor= mkILCtor(access,[ mkILParamNamed("object", ilg.typ_Object); mkILParamNamed("method", ilg.typ_IntPtr)], MethodBody.Abstract)

letctor= ctor.WithRuntime(true).WithHideBySig(true)

[ ctor;

one"Invoke" parms rty;

one"BeginInvoke"(parms@[mkILParamNamed("callback", iltyp_AsyncCallback); mkILParamNamed("objects", ilg.typ_Object)]) iltyp_IAsyncResult;

one"EndInvoke"[mkILParamNamed("result", iltyp_IAsyncResult)] rty;]

[ ctor

one"Invoke" parms rty

one"BeginInvoke"(parms@[mkILParamNamed("callback", iltyp_AsyncCallback); mkILParamNamed("objects", ilg.typ_Object)]) iltyp_IAsyncResult

one"EndInvoke"[mkILParamNamed("result", iltyp_IAsyncResult)] rty]

letscoref= typ.TypeRef.Scope

mkILInstanceMethSpecInTy(typ,".ctor",[rescopeILType scoref ilg.typ_Object; rescopeILType scoref(if useUIntPtrthen ilg.typ_UIntPtrelse ilg.typ_IntPtr)], ILType.Void, emptyILGenericArgsList)

{ enumValues:(string* ILFieldInit) list;

{ enumValues:(string* ILFieldInit) list

enumType:ILType}

letgetTyOfILEnumInfo info= info.enumType

match(List.partition(fun(fd:ILFieldDef)-> fd.IsStatic) mdFields.AsList)with

| staticFields,[vfd]->

{ enumType= vfd.FieldType;

{ enumType= vfd.FieldType

enumValues= staticFields|> List.map(fun fd->(fd.Name,match fd.LiteralValuewith Some i-> i| None-> failwith("info_of_enum_tdef: badly formed enum"+mdName+": static field does not have an default value")))}

|_,[]-> failwith("info_of_enum_tdef: badly formed enum"+mdName+": no non-static field found")

|_,_-> failwith("info_of_enum_tdef: badly formed enum"+mdName+": more than one non-static field found")

if n>=0&& n<=0x7Fthen[| byte n|]

elif n>=0x80&& n<=0x3FFFthen[| byte(0x80|||(n>>>&8)); byte(n&&&0xFF)|]

else[| byte(0xc0|||(n>>>&24));

byte((n>>>&16)&&&0xFF);

byte((n>>>&8)&&&0xFF);

else[| byte(0xc0|||(n>>>&24))

byte((n>>>&16)&&&0xFF)

byte((n>>>&8)&&&0xFF)

byte(n&&&0xFF)|]

letstring_as_utf8_bytes(s:string)= System.Text.Encoding.UTF8.GetBytes s

[|yield(if propthen0x54uyelse0x53uy)

yield! encodeCustomAttrElemType ty;

yield! encodeCustomAttrString nm;

yield! encodeCustomAttrElemType ty

yield! encodeCustomAttrString nm

yield! encodeCustomAttrValue ilg ty elem|]

yield! u16AsBytes(uint16 namedArgs.Length)

for namedArgin namedArgsdo

yield! encodeCustomAttrNamedArg ilg namedArg|]

{ Method= mspec;

Data= args;

{ Method= mspec

Data= args

Elements= fixedArgs@(namedArgs|> List.map(fun(_,_,_,e)-> e))}

[|yield(byte'.');

yield! z_unsigned_int attributes.Length;

[|yield(byte'.')

yield! z_unsigned_int attributes.Length

for(tref:ILTypeRef, props)in attributesdo

yield! encodeCustomAttrString tref.QualifiedName

[|yield! z_unsigned_int props.Length;

for(nm, typ, value)in propsdo

yield! encodeCustomAttrNamedArg ilg(nm, typ,true, value)|]

yield! z_unsigned_int bytes.Length;

[|yield! z_unsigned_int props.Length

for(nm, typ, value)in propsdo

yield! encodeCustomAttrNamedArg ilg(nm, typ,true, value)|]

yield! z_unsigned_int bytes.Length

yield! bytes|]

ILSecurityDecl.ILSecurityDecl(action, bytes)

letbb0,sigptr= sigptr_get_byte bytes sigptr

letbb1,sigptr= sigptr_get_byte bytes sigptr

ifnot(bb0=0x01&& bb1=0x00)then failwith"decodeILAttribData: invalid data";

ifnot(bb0=0x01&& bb1=0x00)then failwith"decodeILAttribData: invalid data"

match argtywith

{ AssemblyReferences:ILAssemblyRef list;

ModuleReferences:ILModuleRef list;}

{ AssemblyReferences:ILAssemblyRef list

ModuleReferences:ILModuleRef list}

{ refsA:HashSet<ILAssemblyRef>;

refsM:HashSet<ILModuleRef>;}

{ refsA:HashSet<ILAssemblyRef>

refsM:HashSet<ILModuleRef>}

{ AssemblyReferences=[];

ModuleReferences=[];}

{ AssemblyReferences=[]

ModuleReferences=[]}

letrefs_of_assref(s:ILReferencesAccumulator)x= s.refsA.Add x|> ignore

andrefs_of_dloc s ts= refs_of_tref s ts

refs_of_dloc s x.DeclaringTypeRef;

refs_of_typs s x.mrefArgs;

refs_of_dloc s x.DeclaringTypeRef

refs_of_typs s x.mrefArgs

refs_of_typ s x.mrefReturn

andrefs_of_fref s x= refs_of_tref s x.DeclaringTypeRef; refs_of_typ s x.Type

andrefs_of_ospec s(OverridesSpec(mref,ty))= refs_of_mref s mref; refs_of_typ s ty

refs_of_mref s x.MethodRef;

refs_of_typ s x.DeclaringType;

refs_of_mref s x.MethodRef

refs_of_typ s x.DeclaringType

refs_of_inst s x.GenericArgs

refs_of_fref s x.FieldRef;

refs_of_fref s x.FieldRef

refs_of_typ s x.DeclaringType

andrefs_of_typs s l= List.iter(refs_of_typ s) l

match xwith

| I_call(_, mr, varargs)| I_newobj(mr, varargs)| I_callvirt(_, mr, varargs)->

refs_of_mspec s mr;

refs_of_mspec s mr

refs_of_varargs s varargs

| I_callconstraint(_, tr, mr, varargs)->

refs_of_typ s tr;

refs_of_mspec s mr;

refs_of_typ s tr

refs_of_mspec s mr

refs_of_varargs s varargs

| I_calli(_, callsig, varargs)->

refs_of_callsig s callsig; refs_of_varargs s varargs

static membertastUnexpectedByRef()=(255, GetStringFunc("tastUnexpectedByRef",",,,"))

static membertastValueMustBeLocalAndMutable()=(256, GetStringFunc("tastValueMustBeLocalAndMutable",",,,"))

static membertastValueMustBeMutable()=(256, GetStringFunc("tastValueMustBeMutable",",,,"))

static membertastInvalidMutationOfConstant()=(257, GetStringFunc("tastInvalidMutationOfConstant",",,,"))

ignore(GetString("tastInvalidFormForPropertyGetter"))

ignore(GetString("tastInvalidFormForPropertySetter"))

ignore(GetString("tastUnexpectedByRef"))

ignore(GetString("tastValueMustBeLocalAndMutable"))

ignore(GetString("tastValueMustBeMutable"))

ignore(GetString("tastInvalidMutationOfConstant"))

ignore(GetString("tastValueHasBeenCopied"))

ignore(GetString("tastRecursiveValuesMayNotBeInConstructionOfTuple"))