l3lib/l3lib_vc6/llfile.h

//
// G A M E.O.N.E - LOW LEVEL LIB V1.0
// Copyright (C) 2001 LEVEL ONE ENTERTAINMENT, 
// Licensed under the terms of LGPL.
//:---------------------------------------------------------------------------
//:Description
//
// LOW LEVEL FILELOAD DRIVER INCLUDE FILE
//
//:---------------------------------------------------------------------------

#ifndef _LLFILE_H
#define _LLFILE_H

//#include "lib_base.h"
#include "llstream.h"

#define LLFILE_MAXPATH	(260)

// +------------------------+
// |  llfile_CreateProcess  |
// +------------------------+
/*
 *	Startet neuen Vordergrundprozess
 *	Im Vollbildmodus verursacht der Aufruf ein Wechsel zum Desktop.
 *	RETURN:
 *	OK oder ungleich 0 bei Fehler
 */
int llfile_CreateProcess(const char * commandline );


// +-------------------+
// |  llfile_LoadToMem |
// +-------------------+
/*
 * Allociert Speicher und ladet das gesamte File ein.
 * Pointer auf "size" erhält die allokierte Filelänge.
 * RETURN:
 * Bei Erfolg: Pointer auf den allocierten Speicher mit dem Fileinhalt
 * 0 bei Fehler: kein freier Speicher mehr oder File nicht gefunden.
 * HINWEIS:
 * Speicher mit llmem_free() wieder freigeben.
 */
void * llfile_LoadToMem( const char * filename, int *size=0);



// +-----------------------+
// |  llfile_SplitSequence |
// +-----------------------+
/*
 *	Entnimmt aus einem Filenamen eine Sequenznummer.
 *	Zeiger auf seqnum enthält die erkannte Sequenznummer,
 *	Zeiger auf seqlen enthält die Länge der gefundenen Nummer
 *	Optionaler Zeiger auf filename enthält den filenamen ohne Nummer und Extension
 *	Optionaler Zeiger auf extension enthält die gefundene Extension
 *	Liefert true bei Erfolg.
 *	Beispiel:
 *				char filename[256];
 *				char extension[256];
 *				int seqlen;
 *				int seqnum;
 *
 *              if(!llfile_SplitSequence("anim-a-002.tga",
 *									  &seqnum,
 *									  &seqlen,
 *									  filename,
 *									  extension);
 *			    //extension=".tga"
 *				//filename="anim-a-"
 *				//seqlen=3
 *				//seqnum=2
 *				
 *				//Rekonstruktion der Sequenz 
 *				  seqnum ++;	// nächstes file
 *				  sprintf(buf,"%s%0*d%s",filename,seqlen,seqnum,extension);
*/
bool llfile_SplitSequence(const char *path,int *seqnum, int *seqlen, char *filename=0, char *extension=0);


// +-------------------------+
// |  llfile_GetSequencePath |
// +-------------------------+
/*
*	Erzeugt einen Pfad mit einer neuen Sequenznummer.
*  Argument path bestimmt den Basispfad 
*  Argument num bestimmt die nummer relativ zum Basispfad
*	RETURN:
*	0 bei fehler,
*	sonst zeiger auf einen statischen null-terminierten string.
*	Der String ist static und ist LLFILE_MAXPATH definiert.
*	Man kann den String verändert (strcat,etc.) muss aber innerhalb von LLFILE_MAXPATH bleiben.
*	LLFILE_MAXPATH ist mindestens 260, egal welche Zielplatform.
*  
*  bsp: path="gfx-001.tga" num = 3, return= "gfx-004.tga"
*/
char * llfile_GetSequencePath(const char *path, int num);



// +------------------------+
// |  llfile_IsFileExisting |
// +------------------------+
/*
*	Liefert true wenn der übergebene Pfad existiert
*/
bool llfile_IsFileExisting(const char *path);

char * llfile_GetFullPath(const char * filename);

// +-----------------+
// |  llfile_GetPath |
// +-----------------+
/*
 *	Liefert Pfad zu ...
 *
 *	LLFILE_APP_PATH = absoluter Pfad des Exefiles inkl. Namen
 *	LLFILE_APP_DIR  = absoluter Pfad des Verzeichnisses des Exefiles
 *	LLFILE_APP_NAME = Name des Executables
 *	LLFILE_APP_EXT  = Extension des Executables
 *	LLFILE_TEMP_DIR	  = absoluter Pfad zum Temporären Verzeichnis
 *	LLFILE_TEMP_NAME  = wie TEMP_DIR + temporärer Name
 *
 *	RETURN:
 *  Null terminierter string der den gewünschten Pfad enthält oder NULL bei Fehler.
 *	Der String ist static und ist LLFILE_MAXPATH definiert.
 *	Man kann den String verändert (strcat,etc.) muss aber innerhalb von LLFILE_MAXPATH bleiben.
 *	LLFILE_MAXPATH ist mindestens 260, egal welche Zielplatform.
*/

typedef enum {
	LLFILE_CUR_DIR,
	LLFILE_APP_DIR,
	LLFILE_APP_NAME
} llfile_ePATH;

char * llfile_GetPath(llfile_ePATH type);



// +-------------------+
// |  llfile_SetCurDir |
// +-------------------+
/*
*	Aktuelles Verzeichnis setzen
*	RETURN:
*	OK, ungleich 0 bei Fehler
*/
int llfile_SetCurDir( const char *dirpath );
const char * llfile_GetCurDir();

// +--------------------+
// |  llfile_OpenStream |
// +--------------------+
/*
 *	Stream Öffnen
 */
typedef enum {
	LLFILE_STREAM_STDIO=0,		// regular files = default
		LLFILE_STREAM_ZIP=10000,	// zip files	
		LLFILE_STREAM_FTP,
		LLFILE_STREAM_HTTP,
		LLFILE_STREAM_RES,			// packed resources with exe
		LLFILE_UNKNOWN,				// nur zip und resource supported
		LLFILE_STREAM_TCP,
		LLFILE_STREAM_UDP,
		LLFILE_STREAM_MEM,
		LLFILE_STREAM_USER,		// erster User stream handle 
} llfile_eSTREAM;

llfile_eSTREAM llfile_OpenStream( llfile_eSTREAM type, const char * url );
int	llfile_PushModule( llfile_eSTREAM type, CStreamModule * module, int option );
int	llfile_PopModule( llfile_eSTREAM type, CStreamModule * module, bool del=true);

extern llfile_eSTREAM llfile_current_stream;

// +---------------------+
// |  llfile_CloseStream |
// +---------------------+
/*
 *	Schliesst den Stream. Streammodule, Buffer werden glöscht.
 */
int llfile_CloseStream( llfile_eSTREAM type );

// +---------------------+
// |  llfile_IoCtlStream |
// +---------------------+
/*
 *	Sendet ein Commando den Stream "hinunter".
 */
int	llfile_IoCtlStream( llfile_eSTREAM type, const char * cmd, void * argument );

// +--------------------+
// |  llfile_ReadStream |
// +--------------------+
/*
 *	Liest vom Stream
 *	RETURN:
 *	Anzahl der gelesenen Bytes, bzw -1 bei Fehler
 */
int llfile_ReadStream( llfile_eSTREAM type, void * ioBuf, int numbytes );

// +---------------------------+
// |  llfile_CreateEmptyStream |
// +---------------------------+
/*
 *	Erzeugt neuen, leeren Stream
 */
llfile_eSTREAM llfile_CreateEmptyStream();

// +---------------------+
// |  llfile_OpenMapFile |
// +---------------------+
/*
 *	Memory Mapped Sequential Read Only File
 *	Mapped ein File in den Speicher.
 *	Zugriff erfolgt über die zurückgelieferte llfile_sMAPFILE structur.
 *	Diese wird wie bei den StdIo Funktionen verwendet.
 *	llfile_fgetc, llfile_ftell, etc. unterscheiden sich nur vom Namen
 *	zur stdio., funktion ist die selbe.
 */
typedef struct {
	unsigned char *	BasePtr;	// Start des Memory Mapped Files im Speicher
	unsigned char *	EndPtr;		// End Adresse + 1
	unsigned char *	ReadPtr;	// Aktueller Readpointer
} llfile_sMAPFILE;

llfile_sMAPFILE * llfile_OpenMapFile( const char * filename, int * filesize );


// +----------------------+
// |  llfile_CloseMapFile |
// +----------------------+
void llfile_CloseMapFile( llfile_sMAPFILE * mapfileptr );

// +----------------------+
// |  llfile_CloseMapFile |
// +----------------------+
/*
 *	FILE IO replacement. Funktionen die llfile_sMAPFILE unterstützen
 *	Parameter und Returnwerte wie bei den entsprechenden stdio Funktionen.
 */
int llfile_fgetc( llfile_sMAPFILE * mapfile );
long llfile_ftell( llfile_sMAPFILE * mapfile );
int	llfile_fseek( llfile_sMAPFILE * mapfile, long offset, int pos );
long llfile_fread( void * buf, long cnt, long size, llfile_sMAPFILE * mapfile );
long llfile_fwrite( void * buf, long cnt, long size, llfile_sMAPFILE * mapfile );
long llfile_filesize(llfile_sMAPFILE * mapfile );



#endif // _LLFILE_H