Patched Calling Convention for EFI (is actually WINAPI calling convention)

git-svn-id: https://svn.inf.ethz.ch/svn/lecturers/a2/trunk@6607 8c9fc860-2736-0410-a75d-ab315db34111

source/EFI.Mod

@@ -152,32 +152,32 @@ TYPE DevicePath* = RECORD
 	SubType-: Int8;
 	Length-: ARRAY 2 OF Int8;
 END;
-TYPE BSDummyType* = PROCEDURE{C};
+TYPE BSDummyType* = PROCEDURE{WINAPI};
 (* task priority functions *)
-TYPE BSTPLRaise* = PROCEDURE{C}(NewTpl : TPL) : TPL;
-TYPE BSTPLRestore* = PROCEDURE{C}(oldTpl : TPL);
+TYPE BSTPLRaise* = PROCEDURE{WINAPI}(NewTpl : TPL) : TPL;
+TYPE BSTPLRestore* = PROCEDURE{WINAPI}(oldTpl : TPL);
 (* Memory functions *)
-TYPE BSAllocatePages* = PROCEDURE{C}(Type : Int; MemoryType : Int; Pages : Int; VAR Memory : PhysicalAddress) : Status;
-TYPE BSFreePages* = PROCEDURE{C}(Memory : PhysicalAddress; Pages : Int) : Status;
-TYPE BSGetMemoryMap* = PROCEDURE{C}(VAR MemoryMapSize : Int; VAR MemoryMap : ARRAY OF MemoryDescriptor; VAR MapKey, DescriptorSize : Int; VAR DescriptorVersion : Int32) : Status;
+TYPE BSAllocatePages* = PROCEDURE{WINAPI}(Type : Int; MemoryType : Int; Pages : Int; VAR Memory : PhysicalAddress) : Status;
+TYPE BSFreePages* = PROCEDURE{WINAPI}(Memory : PhysicalAddress; Pages : Int) : Status;
+TYPE BSGetMemoryMap* = PROCEDURE{WINAPI}(VAR MemoryMapSize : Int; VAR MemoryMap : ARRAY OF MemoryDescriptor; VAR MapKey, DescriptorSize : Int; VAR DescriptorVersion : Int32) : Status;
 (* protocol handler functions *)
-TYPE BSProtocolInstall* = PROCEDURE{C}(VAR Handle : Handle; CONST Protocol : GUID; InterfaceType : Int; Interface : Protocol) : Status;
-TYPE BSProtocolReinstall* = PROCEDURE{C}(Handle : Handle; CONST Protocol : GUID; OldInterface, NewInterface : Protocol) : Status;
-TYPE BSProtocolUninstall* = PROCEDURE{C}(Handle : Handle; CONST Protocol : GUID; Interface : Protocol) : Status;
-TYPE BSProtocolHandle* = PROCEDURE{C}(Handle : Handle; CONST Protocol : GUID; VAR Interface : Protocol) : Status;
-TYPE BSProtocolRegisterNotify* = PROCEDURE{C}(CONST Protocol : GUID; Event : Event; VAR Registration : Pointer) : Status;
-TYPE BSLocateHandle* = PROCEDURE{C}(SearchType : Int; CONST Protocol : GUID; SearchKey : Pointer; VAR BufferSize : Int; VAR Buffer : ARRAY OF Handle): Status;
-TYPE BSLocateDevicePath* = PROCEDURE{C}(CONST Protocol : GUID; VAR DevicePath : DevicePath; VAR Device : Handle) : Status;
-TYPE BSInstallConfigurationTable* = PROCEDURE{C}(CONST Protocol : GUID; Table : Pointer) : Status;
+TYPE BSProtocolInstall* = PROCEDURE{WINAPI}(VAR Handle : Handle; CONST Protocol : GUID; InterfaceType : Int; Interface : Protocol) : Status;
+TYPE BSProtocolReinstall* = PROCEDURE{WINAPI}(Handle : Handle; CONST Protocol : GUID; OldInterface, NewInterface : Protocol) : Status;
+TYPE BSProtocolUninstall* = PROCEDURE{WINAPI}(Handle : Handle; CONST Protocol : GUID; Interface : Protocol) : Status;
+TYPE BSProtocolHandle* = PROCEDURE{WINAPI}(Handle : Handle; CONST Protocol : GUID; VAR Interface : Protocol) : Status;
+TYPE BSProtocolRegisterNotify* = PROCEDURE{WINAPI}(CONST Protocol : GUID; Event : Event; VAR Registration : Pointer) : Status;
+TYPE BSLocateHandle* = PROCEDURE{WINAPI}(SearchType : Int; CONST Protocol : GUID; SearchKey : Pointer; VAR BufferSize : Int; VAR Buffer : ARRAY OF Handle): Status;
+TYPE BSLocateDevicePath* = PROCEDURE{WINAPI}(CONST Protocol : GUID; VAR DevicePath : DevicePath; VAR Device : Handle) : Status;
+TYPE BSInstallConfigurationTable* = PROCEDURE{WINAPI}(CONST Protocol : GUID; Table : Pointer) : Status;
 (* image functions *)
-TYPE BSImageLoad* = PROCEDURE{C}(BootPolicy : Boolean; ParentImageHandle : Handle; CONST FilePath : DevicePath; SourceSize : Int; SourceBuffer : Pointer; VAR ImageHandle : Handle) : Status;
-TYPE BSImageStart* = PROCEDURE{C}(ImageHandle : Handle; VAR ExitDataSize : Int; VAR ExitData : ARRAY OF Char16) : Status;
-TYPE BSImageExit* = PROCEDURE{C}(ImageHandle : Handle; ExitStatus : Status; ExitDataSize : Int; VAR ExitData : ARRAY OF Char16) : Status;
-TYPE BSImageUnload* = PROCEDURE{C}(ImageHandle : Handle) : Status;
-TYPE BSExitBootServices* = PROCEDURE{C}(ImageHandle : Handle; MapKey : Int) : Status;
+TYPE BSImageLoad* = PROCEDURE{WINAPI}(BootPolicy : Boolean; ParentImageHandle : Handle; CONST FilePath : DevicePath; SourceSize : Int; SourceBuffer : Pointer; VAR ImageHandle : Handle) : Status;
+TYPE BSImageStart* = PROCEDURE{WINAPI}(ImageHandle : Handle; VAR ExitDataSize : Int; VAR ExitData : ARRAY OF Char16) : Status;
+TYPE BSImageExit* = PROCEDURE{WINAPI}(ImageHandle : Handle; ExitStatus : Status; ExitDataSize : Int; VAR ExitData : ARRAY OF Char16) : Status;
+TYPE BSImageUnload* = PROCEDURE{WINAPI}(ImageHandle : Handle) : Status;
+TYPE BSExitBootServices* = PROCEDURE{WINAPI}(ImageHandle : Handle; MapKey : Int) : Status;
 (* misc. functions *)
-TYPE BSGetNextMonotonicCount* = PROCEDURE{C}(VAR Count : Int64);
-TYPE BSStall* = PROCEDURE{C}(Microseconds : Int);
+TYPE BSGetNextMonotonicCount* = PROCEDURE{WINAPI}(VAR Count : Int64);
+TYPE BSStall* = PROCEDURE{WINAPI}(Microseconds : Int);
 
 TYPE BootServices* = RECORD
 	Hdr- : TableHeader;
@@ -219,7 +219,7 @@ TYPE BootServices* = RECORD
 END;
 
 (* RuntimeService function type declarations *)
-TYPE RSDummyType* = PROCEDURE{C};
+TYPE RSDummyType* = PROCEDURE{WINAPI};
 
 TYPE RuntimeServices* = RECORD
 	Hdr- : TableHeader;
@@ -252,8 +252,8 @@ TYPE InputKey* = RECORD
 	ScanCode-: Int16;
 	UnicodeChar-: Char16;
 END;
-TYPE InputReset* = PROCEDURE {C} (This: POINTER TO SimpleInputInterface; ExtendedVerification: Boolean): Status;
-TYPE InputReadKey* = PROCEDURE {C} (This: POINTER TO SimpleInputInterface; VAR key: InputKey): Status;
+TYPE InputReset* = PROCEDURE {WINAPI} (This: POINTER TO SimpleInputInterface; ExtendedVerification: Boolean): Status;
+TYPE InputReadKey* = PROCEDURE {WINAPI} (This: POINTER TO SimpleInputInterface; VAR key: InputKey): Status;
 
 TYPE SimpleInputInterface* = RECORD(ProtocolDescription)
 	Reset-: InputReset;
@@ -273,15 +273,15 @@ TYPE SimpleTextOutputInterfaceMode* = RECORD
 	CursorVisible-: Boolean;
 END;
 
-TYPE TextReset* = PROCEDURE {C} (This: POINTER TO SimpleTextOutputInterface; ExtendedVerification: Boolean): Status;
-TYPE TextString* = PROCEDURE {C} (This: POINTER TO SimpleTextOutputInterface;  CONST String: ARRAY OF Char16): Status;
-TYPE TextTestString* = PROCEDURE {C} (This: POINTER TO SimpleTextOutputInterface; CONST String: ARRAY OF Char16): Status;
-TYPE TextQueryMode* = PROCEDURE {C} (This: POINTER TO SimpleTextOutputInterface; ModeNumber: Int; VAR Columns, Rows: Int): Status;
-TYPE TextSetMode* = PROCEDURE {C} (This: POINTER TO SimpleTextOutputInterface; ModeNumber: Int): Status;
-TYPE TextSetAttribute* = PROCEDURE {C} (This: POINTER TO SimpleTextOutputInterface; Attribute: Int): Status;
-TYPE TextClearScreen* = PROCEDURE {C} (This: POINTER TO SimpleTextOutputInterface): Status;
-TYPE TextSetCursorPos* = PROCEDURE {C} (This: POINTER TO SimpleTextOutputInterface; Column, Row : Int): Status;
-TYPE TextEnableCursor* = PROCEDURE {C} (This : POINTER TO SimpleTextOutputInterface; Visible : Boolean): Status;
+TYPE TextReset* = PROCEDURE {WINAPI} (This: POINTER TO SimpleTextOutputInterface; ExtendedVerification: Boolean): Status;
+TYPE TextString* = PROCEDURE {WINAPI} (This: POINTER TO SimpleTextOutputInterface;  CONST String: ARRAY OF Char16): Status;
+TYPE TextTestString* = PROCEDURE {WINAPI} (This: POINTER TO SimpleTextOutputInterface; CONST String: ARRAY OF Char16): Status;
+TYPE TextQueryMode* = PROCEDURE {WINAPI} (This: POINTER TO SimpleTextOutputInterface; ModeNumber: Int; VAR Columns, Rows: Int): Status;
+TYPE TextSetMode* = PROCEDURE {WINAPI} (This: POINTER TO SimpleTextOutputInterface; ModeNumber: Int): Status;
+TYPE TextSetAttribute* = PROCEDURE {WINAPI} (This: POINTER TO SimpleTextOutputInterface; Attribute: Int): Status;
+TYPE TextClearScreen* = PROCEDURE {WINAPI} (This: POINTER TO SimpleTextOutputInterface): Status;
+TYPE TextSetCursorPos* = PROCEDURE {WINAPI} (This: POINTER TO SimpleTextOutputInterface; Column, Row : Int): Status;
+TYPE TextEnableCursor* = PROCEDURE {WINAPI} (This : POINTER TO SimpleTextOutputInterface; Visible : Boolean): Status;
 
 TYPE SimpleTextOutputInterface* = RECORD(ProtocolDescription)
 	Reset-: TextReset;

source/EFIBlockIO.Mod

@@ -23,10 +23,10 @@ END;
 
 TYPE Protocol* = POINTER TO ProtocolDescription;
 
-TYPE BlockIOReset* = PROCEDURE{C}(This : Protocol; ExtendedVerification : EFI.Boolean) : EFI.Status;
-TYPE BlockIOReadBlocks* = PROCEDURE{C}(This : Protocol; MediaId : EFI.Int32; LBA: EFI.LBA; BufferSize : EFI.Int; VAR Buffer : ARRAY OF SYSTEM.BYTE) : EFI.Status;
-TYPE BlockIOWriteBlocks* = PROCEDURE{C}(This : Protocol; MediaId : EFI.Int32; LBA: EFI.LBA; BufferSize : EFI.Int; CONST Buffer : ARRAY OF SYSTEM.BYTE) : EFI.Status;
-TYPE BlockIOFlushBlocks* = PROCEDURE{C}(This : Protocol) : EFI.Status;
+TYPE BlockIOReset* = PROCEDURE{WINAPI}(This : Protocol; ExtendedVerification : EFI.Boolean) : EFI.Status;
+TYPE BlockIOReadBlocks* = PROCEDURE{WINAPI}(This : Protocol; MediaId : EFI.Int32; LBA: EFI.LBA; BufferSize : EFI.Int; VAR Buffer : ARRAY OF SYSTEM.BYTE) : EFI.Status;
+TYPE BlockIOWriteBlocks* = PROCEDURE{WINAPI}(This : Protocol; MediaId : EFI.Int32; LBA: EFI.LBA; BufferSize : EFI.Int; CONST Buffer : ARRAY OF SYSTEM.BYTE) : EFI.Status;
+TYPE BlockIOFlushBlocks* = PROCEDURE{WINAPI}(This : Protocol) : EFI.Status;
 
 TYPE ProtocolDescription* = RECORD(EFI.ProtocolDescription)
 	Revision-: EFI.Int64;

source/EFIFileProtocol.Mod

@@ -30,25 +30,25 @@ TYPE Protocol*= POINTER TO ProtocolDescription;
 (* Open or create a new file. 'This' is a pointer to a protocol instance that is the file handle to the source location. This would
 typically be an open handle to a directory. A handle for the new file is returned to 'NewHandle'.  The filename may include
 the path modifiers '\', '.' and '..'. If the filename starts with a '\' the relative location is the root directory. *)
-TYPE FileOpen* = PROCEDURE{C}(This : Protocol; VAR NewHandle : Protocol; CONST FileName : ARRAY OF EFI.Char16; OpenMode : EFI.Int64; Attributes : EFI.Int64) : EFI.Status;
+TYPE FileOpen* = PROCEDURE{WINAPI}(This : Protocol; VAR NewHandle : Protocol; CONST FileName : ARRAY OF EFI.Char16; OpenMode : EFI.Int64; Attributes : EFI.Int64) : EFI.Status;
 (* Close a specified handle. All dirty cached file data is flushed to the device, and the file is closed *)
-TYPE FileClose* = PROCEDURE{C}(This : Protocol) : EFI.Status;
+TYPE FileClose* = PROCEDURE{WINAPI}(This : Protocol) : EFI.Status;
 (* Close and delete a file *)
-TYPE FileDelete* = PROCEDURE{C}(This : Protocol) : EFI.Status;
+TYPE FileDelete* = PROCEDURE{WINAPI}(This : Protocol) : EFI.Status;
 (* Read 'BufferSize' bytes. On success, the number bytes read is written to 'BufferSize' and the file position is updated.
 If 'This' is a directory, read the directory entry at the current file position. If this entry does not fit into the buffer BufferTooSmall
 is returned and the file position is not updated and 'BufferSize' is set to the size needed to read the entry. *)
-TYPE FileRead* = PROCEDURE{C}(This : Protocol; VAR BufferSize : EFI.Int; Buffer : ADDRESS) : EFI.Status;
+TYPE FileRead* = PROCEDURE{WINAPI}(This : Protocol; VAR BufferSize : EFI.Int; Buffer : ADDRESS) : EFI.Status;
 (* Write specified number of bytes to the file at the current file position. Current file position is advanced the actual number of
 bytes written, which is returned in 'BufferSize'. Direct writes to open directories are not supported *)
-TYPE FileWrite* = PROCEDURE{C}(This : Protocol; VAR BufferSize : EFI.Int; CONST Buffer : ARRAY OF SYSTEM.BYTE) : EFI.Status;
+TYPE FileWrite* = PROCEDURE{WINAPI}(This : Protocol; VAR BufferSize : EFI.Int; CONST Buffer : ARRAY OF SYSTEM.BYTE) : EFI.Status;
 (* Set the current file position. Only absolute position is supported with exception of FFFFFFFFFFFFFFFFH which sets the position
 to the end of the file. Seeking past the end of file is allowed (a subsequent write would grow the file. *)
-TYPE FileGetPosition* = PROCEDURE{C}(This : Protocol; VAR Position : EFI.Int64) : EFI.Status;
-TYPE FileSetPosition* = PROCEDURE{C}(This : Protocol; Position : EFI.Int64) : EFI.Status;
-TYPE FileGetInfo* = PROCEDURE{C}(This : Protocol; CONST InformationType : EFI.GUID; VAR BufferSize : EFI.Int; VAR Buffer : ARRAY OF SYSTEM.BYTE) : EFI.Status;
-TYPE FileSetInfo* = PROCEDURE{C}(This : Protocol; CONST InformationType : EFI.GUID; BufferSize : EFI.Int; CONST Buffer : ARRAY OF SYSTEM.BYTE) : EFI.Status;
-TYPE FileFlush* = PROCEDURE{C}(This : Protocol) : EFI.Status;
+TYPE FileGetPosition* = PROCEDURE{WINAPI}(This : Protocol; VAR Position : EFI.Int64) : EFI.Status;
+TYPE FileSetPosition* = PROCEDURE{WINAPI}(This : Protocol; Position : EFI.Int64) : EFI.Status;
+TYPE FileGetInfo* = PROCEDURE{WINAPI}(This : Protocol; CONST InformationType : EFI.GUID; VAR BufferSize : EFI.Int; VAR Buffer : ARRAY OF SYSTEM.BYTE) : EFI.Status;
+TYPE FileSetInfo* = PROCEDURE{WINAPI}(This : Protocol; CONST InformationType : EFI.GUID; BufferSize : EFI.Int; CONST Buffer : ARRAY OF SYSTEM.BYTE) : EFI.Status;
+TYPE FileFlush* = PROCEDURE{WINAPI}(This : Protocol) : EFI.Status;
 
 TYPE ProtocolDescription*= RECORD(EFI.ProtocolDescription)
 	Revision-: EFI.Int64;

source/EFIGraphicsOutput.Mod

@@ -35,9 +35,9 @@ TYPE GraphicsModeInfoDescription* = RECORD
 END;
 
 TYPE Protocol* = POINTER TO ProtocolDescription;
-TYPE GOQueryMode* = PROCEDURE{C}(This : Protocol; ModeNumber : EFI.Int32; VAR SizeOfInfo : EFI.Int; VAR Info : GraphicsModeInfo) : EFI.Status;
-TYPE GOSetMode* = PROCEDURE{C}(This : Protocol; ModeNumber : EFI.Int32) : EFI.Status;
-TYPE GODummyType* = PROCEDURE{C}():EFI.Status;
+TYPE GOQueryMode* = PROCEDURE{WINAPI}(This : Protocol; ModeNumber : EFI.Int32; VAR SizeOfInfo : EFI.Int; VAR Info : GraphicsModeInfo) : EFI.Status;
+TYPE GOSetMode* = PROCEDURE{WINAPI}(This : Protocol; ModeNumber : EFI.Int32) : EFI.Status;
+TYPE GODummyType* = PROCEDURE{WINAPI}():EFI.Status;
 TYPE ProtocolDescription* = RECORD(EFI.ProtocolDescription)
 	QueryMode-: GOQueryMode;
 	SetMode-: GOSetMode;

source/EFILoadedImage.Mod

@@ -12,7 +12,7 @@ VAR
 TYPE Protocol* = POINTER TO ProtocolDescription;
 
 TYPE PtrToArrayOfByte* = POINTER TO ARRAY 2048 OF SYSTEM.BYTE;
-TYPE LIUnload* = PROCEDURE{C}(ImageHandle : EFI.Handle) : EFI.Status;
+TYPE LIUnload* = PROCEDURE{WINAPI}(ImageHandle : EFI.Handle) : EFI.Status;
 TYPE ProtocolDescription* = RECORD(EFI.ProtocolDescription)
 	Revision-: EFI.Int32;
 	ParentHandle-: EFI.Handle;

source/EFISimpleFS.Mod

@@ -11,7 +11,7 @@ VAR
 
 TYPE Protocol*= POINTER TO ProtocolDescription;
 
-TYPE SFSOpenVolume* = PROCEDURE{C}(This : Protocol; VAR Root : EFIFileProtocol.Protocol):EFI.Status;
+TYPE SFSOpenVolume* = PROCEDURE{WINAPI}(This : Protocol; VAR Root : EFIFileProtocol.Protocol):EFI.Status;
 TYPE ProtocolDescription *= RECORD(EFI.ProtocolDescription)
 	Revision-:EFI.Int64;
 	OpenVolume-: SFSOpenVolume

source/FoxIntermediateBackend.Mod

@@ -13100,9 +13100,9 @@ TYPE
 	BEGIN
 		IF parameter.kind = SyntaxTree.ValueParameter THEN RETURN FALSE
 		ELSIF parameter.kind = SyntaxTree.ConstParameter THEN
-			RETURN (parameter.type.resolved IS SyntaxTree.RecordType) OR (parameter.type.resolved IS SyntaxTree.ArrayType) & SysvABI(parameter.ownerType(SyntaxTree.ProcedureType).callingConvention)
+			RETURN (parameter.type.resolved IS SyntaxTree.RecordType) OR (parameter.type.resolved IS SyntaxTree.ArrayType) & SysvABIorWINAPI(parameter.ownerType(SyntaxTree.ProcedureType).callingConvention)
 		ELSIF parameter.kind = SyntaxTree.VarParameter THEN
-			RETURN ~(parameter.type.resolved IS SyntaxTree.ArrayType) & ~(parameter.type.resolved IS SyntaxTree.MathArrayType) OR (parameter.type.resolved IS SyntaxTree.ArrayType) & SysvABI(parameter.ownerType(SyntaxTree.ProcedureType).callingConvention)
+			RETURN ~(parameter.type.resolved IS SyntaxTree.ArrayType) & ~(parameter.type.resolved IS SyntaxTree.MathArrayType) OR (parameter.type.resolved IS SyntaxTree.ArrayType) & SysvABIorWINAPI(parameter.ownerType(SyntaxTree.ProcedureType).callingConvention)
 		END
 	END PassBySingleReference;
 
@@ -13561,6 +13561,11 @@ TYPE
 		RETURN (cc IN {SyntaxTree.CCallingConvention, SyntaxTree.DarwinCCallingConvention})
 	END SysvABI;
 
+	PROCEDURE SysvABIorWINAPI( cc: LONGINT ): BOOLEAN;
+	BEGIN
+		RETURN (cc IN {SyntaxTree.CCallingConvention, SyntaxTree.DarwinCCallingConvention, SyntaxTree.WinAPICallingConvention})
+	END SysvABIorWINAPI;
+
 	PROCEDURE Call*(position: LONGINT;op: IntermediateCode.Operand; parSize: LONGINT): IntermediateCode.Instruction;
 	VAR instruction: IntermediateCode.Instruction;
 	BEGIN