**
**	$Id: OpenIFF.S,v 21.1 92/05/15 03:21:49 chris Exp $
**	$Revision: 21.1 $
**
**	$Filename: OpenIFF.S $
**	$Author: chris $
**	$Release: 19.1 $
**	$Date: 92/05/15 03:21:49 $
**
**	iff.library/IFFL_OpenIFF
**
**	COPYRIGHT (C) 1987-1992 BY CHRISTIAN A. WEBER, BRUGGERWEG 2,
**	CH-8037 ZUERICH, SWITZERLAND.  ALL RIGHTS RESERVED.  NO PART
**	OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,  OR  TRANSMITTED
**	IN ANY FORM OR BY ANY MEANS,  WITHOUT THE PRIOR WRITTEN PER-
**	MISSION OF THE AUTHOR. USE AT YOUR OWN RISK.
**


		IDNT	IFFL_OpenIFF
		SECTION	text,CODE

		INCLUDE	"IFFLib.i"

		XREF	SetError,ClearError
		XDEF	OpenIFFFunc,OldOpenIFFFunc,OldNewOpenIFFFunc


******* iff.library/IFFL_OpenIFF ********************************************
*
*   NAME
*	IFFL_OpenIFF -- Open an IFF file for reading or writing
*
*   SYNOPSIS
*	iff = IFFL_OpenIFF( filename, mode )
*	D0                  A0        D0
*
*	IFFL_HANDLE IFFL_OpenIFF( char *, ULONG )
*
*   FUNCTION
*	If mode == IFFL_MODE_READ:
*	  This function opens a file on a disk and looks whether it's an IFF
*	  file or not. If it is an IFF file, memory is allocated and the file
*	  is read into memory.
*	  If an error occurs, NULL is returned, and you can call
*	  dos.library/IoErr() to get the IFFERR_... error number.
*
*	If mode == IFFL_MODE_WRITE:
*	  Initializes an IFF file handle for writing. You may create chunks
*	  with IFFL_PushChunk() and IFFL_PopChunk(), and you can write data
*	  using the IFFL_WriteChunkBytes() routine.
*
*   INPUTS
*	filename - Pointer to a null-terminated string
*	mode     - IFFL_MODE_READ:  Open file for reading
*	           IFFL_MODE_WRITE: Open file for writing
*
*   RESULT
*	iff - IFF handle. Making assumptions about the internal structure
*	      of this handle is unwise, and may break in the future.
*	      If this function fails, NULL will be returned, and you may
*	      call IFFL_IFFError() to know the reason of the failure.
*
*   SEE ALSO
*	IFFL_CloseIFF(), IFFL_PushChunk(), IFFL_PopChunk(),
*	IFFL_WriteChunkBytes(), IFFL_IFFError()
*
*   BUGS
*	None known
*
*****************************************************************************

OpenIFFFunc:	movem.l	d2-d6/a2/a5-a6,-(SP)
		moveq.l	#MEMF_ANY,d6		; MemType: egal

		tst.l	d0			; IFFL_MODE_READ ?
		beq	ReadMode

*****************************************************************************
* Schreib-Modus

		movea.l	a6,a5			; A5 :  IFFBase
		move.l	a0,d5			; D5 :  Filename

	*** IFF-Handle allozieren

		moveq.l	#ifffh_SIZEOF,d0
		moveq.l	#1,d1
		swap	d1			; MEMF_CLEAR
		movea.l	iffb_SysBase(a5),a6
		JSRLIB	AllocMem
		tst.l	d0
		bne.b	1$
		moveq.l	#IFFL_ERROR_NOMEM,d0
		bra.b	.Error			; Error --->
1$:
		movea.l	d0,a2			; A2 :  IFF-Handle

		move.l	#IFFFH_MAGIC,ifffh_Magic(a2)

	*** File zum Schreiben öffnen

		move.l	d5,d1			; Name
		move.l	#MODE_NEWFILE,d2
		movea.l	iffb_DOSBase(a5),a6
		JSRLIB	Open
		move.l	d0,ifffh_File(a2)
		bne.b	2$
		moveq.l	#IFFL_ERROR_OPEN,d0
.Error:		bsr	SetError
		bra.b	.End			; ---> Fertig
2$:
	*** Header ('FORM\0\0\0\0') schreiben

		move.l	d0,d1			; File
		lea	IFFHeader(PC),a0
		move.l	a0,d2
		moveq.l	#8,d3
		JSRLIB	Write
		cmp.l	d3,d0
		beq.b	3$
		moveq.l	#IFFL_ERROR_WRITE,d0
		bra.b	.Error
3$:
	*** Alles OK, IFF-Handle zurückgeben

		bsr	ClearError
		move.l	a2,d0			; IFF-Handle
.End:		bra	OpenEnd			; ---> Fertig


******* iff.library/NewOpenIFF **********************************************
*
*   NAME
*	NewOpenIFF -- allocate memory for an IFF-file and read it
*
*   SYNOPSIS
*	>>> THIS FUNCTION IS OBSOLETE. USE IFFL_OpenIFF() INSTEAD <<<
*
*	ifffile = NewOpenIFF( filename, memattr )
*	D0                    A0        D0
*
*	IFFFILE OpenIFF( char * )
*
*   FUNCTION
*	This function opens a file on a disk and looks whether it's an IFF
*	file or not. If it is an IFF file, memory is allocated and the file
*	is read into memory. The 'memattr' argument is taken to define the
*	memory type. Normally memattr is set to MEMF_ANY or MEMF_PUBLIC.
*	If an error occurs, NULL is returned, and you can call
*	IFFError() to get the error number.
*
*   INPUTS
*	filename - Pointer to a null-terminated string
*	memattr  - Memory requirements as used for Exec's AllocMem(),
*	           such as MEMF_CHIP, MEMF_PUBLIC ...
*	           (MEMF_CLEAR is not necessary)
*
*   RESULT
*	ifffile - 'FileHandle', points to the beginning of the IFF file
*	("FORM...."), Zero if unsuccessful. Call IFFError() to get
*	the reason of the failure.
*
*   SEE ALSO
*	OpenIFF(), CloseIFF(), IFFError()
*
*   BUGS
*	None known
*
*****************************************************************************

OldNewOpenIFFFunc:
		movem.l	d2-d6/a2/a5-a6,-(SP)
		move.l	d0,d6			; D6 :  MemType
		bra.b	ReadMode


******* iff.library/OpenIFF *************************************************
*
*    NAME
*	OpenIFF -- allocate memory for an IFF-file and read it
*
*    SYNOPSIS
*	>>> THIS FUNCTION IS OBSOLETE. USE IFFL_OpenIFF() INSTEAD <<<
*
*	ifffile = OpenIFF( filename )
*	D0                 A0
*
*	IFFFILE OpenIFF( char * )
*
*    FUNCTION
*	This function does the same as the NewOpenIFF() routine
*	above, except that you cannot specify the type of memory which is
*	allocated for the file. Normally the type is 0 which means 'any
*	memory', but if the IFF file type is '8SVX', the file is ALWAYS
*	loaded into CHIP memory. If you wish to override these defaults,
*	use NewOpenIFF() instead of OpenIFF().
*
*   INPUTS
*	filename - Pointer to a null-terminated string
*
*   RESULT
*	ifffile - 'FileHandle', points to the beginning of the IFF file
*	("FORM...."), 0 if unsuccessful. Call IFFError() to get the
*	reason of the failure.
*
*   BUGS
*	None
*
*   SEE ALSO
*	NewOpenIFF(), CloseIFF(), IFFError()
*
*****************************************************************************

OldOpenIFFFunc:	movem.l	d2-d6/a2/a5-a6,-(SP)
		moveq.l	#-1,d6			; Kein MemType angegeben
;;		bra.b	ReadMode

*****************************************************************************
* Lese-Modus

ReadMode:	movea.l	a6,a5			; A5 :  IFFBase
		lea	-12(SP),SP		; Arbeitsspeicher reservieren
		moveq.l	#0,d5			; Fehlernummer rücksetzen

	*** File öffnen

		move.l	a0,d1			; Name
		move.l	#MODE_OLDFILE,d2	; accessmode
		movea.l	iffb_DOSBase(a5),a6
		JSRLIB	Open
		move.l	d0,d4			; D4 := FileHandle
		bne.b	1$
		moveq	#IFFL_ERROR_OPEN,d5
		bra.b	.Error2			; --->
1$:
	*** Erste 12 Bytes lesen, testen ob 'FORM'

		move.l	d4,d1			; File
		move.l	SP,d2			; Adr
		moveq.l	#12,d3			; Len
		JSRLIB	Read			; erste 3 Longwords lesen
		cmpi.l	#'FORM',(SP)
		beq.b	2$
		moveq	#IFFL_ERROR_NOTIFF,d5
		bra.b	.Error1			; --->
2$:
	*** Testen ob Chip-Speicher erwünscht (bei 8SVX-Files)

		move.l	d6,d1			; Default-Requirements
		bpl.b	3$			; sind gültig --->
		moveq.l	#MEMF_PUBLIC,d1
		cmpi.l	#'8SVX',8(SP)		; 8SVX-File ?
		bne.b	3$			; nein --->
		moveq.l	#MEMF_CHIP|MEMF_PUBLIC,d1 ; sonst CHIP-Memory!
3$:
	*** Speicher für File reservieren

		moveq.l	#12,d2			; 'Remember' + FORM....
		move.l	4(SP),d3		; D3 :  FORM-Länge
		add.l	d3,d2			; D2 :  Gesamtlänge
		subq.l	#4,d3	; FUCK!!! IFF-Typ ist ja schon gelesen!
		move.l	d2,d0
		movea.l	iffb_SysBase(a5),a6
		JSRLIB	AllocMem		; requirements von D1
		movea.l	d0,a2			; A2 :  IFFFile-Adresse
		tst.l	d0
		bne.b	4$			; OK --->
		moveq	#IFFL_ERROR_NOMEM,d5
		bra.b	.Error1			; --->
4$:
	*** File einladen

		move.l	d2,(a2)+		; Länge des reserv. Bereichs
		move.l	d4,d1			; File
		move.l	a2,d2			; Adr
		addq.l	#8,d2			; FORM.... schon gelesen!
		addq.l	#4,d2			; IFF-Typ schon gelesen
		movea.l	iffb_DOSBase(a5),a6
		JSRLIB	Read			; D3 war schon Länge
		tst.l	d0
		bpl.b	5$			; OK --->
		moveq	#IFFL_ERROR_READ,d5
		bra.b	.Error1
5$:
		movem.l	(SP),d0-d2		; FORM, Länge und Type
		movem.l	d0-d2,(a2)		; IFF-Filetyp

.Error1:	move.l	d4,d1			; File
		movea.l	iffb_DOSBase(a5),a6
		JSRLIB	Close

.Error2:	move.l	d5,d0			; Error ?
		beq.b	6$			; nein --->
		bsr	SetError		; Löscht auch D0
		bra.b	Ende
6$:
		bsr	ClearError
		move.l	a2,d0			; Adresse als Return-Code
Ende:
		lea	12(SP),SP		; Lokalen Speicher freigeben

OpenEnd:	movem.l	(SP)+,d2-d6/a2/a5-a6
		rts


IFFHeader:	dc.b	"FORM",0,0,0,0

		END