setup.h

虚幻的再开发程序包源代码

/*=============================================================================
	Filer.h: Unreal Filer public definitions.
	Copyright 1997-1999 Epic Games, Inc. All Rights Reserved.

Revision history:
	* Created by Tim Sweeney.
=============================================================================*/

/*-----------------------------------------------------------------------------
	Globals.
-----------------------------------------------------------------------------*/

// Classes.
class	USetupObject;
class       USetupGroup;
class		USetupProduct;
class			USetupDefinition;
class				USetupDefinitionWindows;

// Constants.
#define PER_FILE_OVERHEAD    (65536+16384)
#define PER_INSTALL_OVERHEAD (16*1024*1024)

// Interfaces..
extern class FInstallPoll
{
public:
	virtual UBOOL Poll( const TCHAR* Label, SQWORD LocalBytes, SQWORD LocalTotal, SQWORD RunningBytes, SQWORD TotalBytes )
	{
		return 0;
	}
} GNoPoll;

// Types.
typedef void (USetupDefinition::*INSTALL_STEP)(FString,FString,UBOOL,FInstallPoll*);

// Manifest.
#define MANIFEST_FILE TEXT("Manifest")
#define MANIFEST_EXT  TEXT(".ini")
#define SFX_STUB      TEXT("RunSFX.exe")
#define MOD_EXT       TEXT(".umod")
#define SETUP_INI     MANIFEST_FILE MANIFEST_EXT
#define MOD_MAGIC     0x9fe3c5a3

// Archives.
enum {ARCHIVE_MAGIC=0x9fe3c5a3};
enum {ARCHIVE_HEADER_SIZE=5*4};
enum {ARCHIVE_VERSION=1};
enum EArchiveFlags
{
	ARCHIVEF_Bootstrap      = 0x00000001,
	ARCHIVEF_Unbootstrap    = 0x00000002,
	ARCHIVEF_Compressed     = 0x00000004,
};
struct FArchiveItem
{
	FString Filename;
	DWORD   Offset;
	DWORD   Size;
	DWORD	Flags;
	FArchiveItem()
	{}
	FArchiveItem( const TCHAR* InFilename, DWORD InOffset, DWORD InSize, DWORD InFlags )
	: Filename(InFilename), Offset(InOffset), Size(InSize), Flags(InFlags)
	{}
	friend FArchive& operator<<( FArchive& Ar, FArchiveItem& Item )
	{
		guard(FArchiveItem<<);
		return Ar << Item.Filename << Item.Offset << Item.Size << Item.Flags;
		unguard;
	}
};
struct FArchiveHeader
{
	INT Magic, TableOffset, FileSize, Ver, CRC;
	TArray<FArchiveItem> Items;
	FArchiveHeader()
	: Magic(MOD_MAGIC), TableOffset(-1), FileSize(0), Ver(ARCHIVE_VERSION), CRC(0)
	{}
	friend FArchive& operator<<( FArchive& Ar, FArchiveHeader& Head )
	{
		guard(FArchiveHeader<<);
		// Must match ARCHIVE_HEADER_SIZE.
		return Ar << Head.Magic << Head.TableOffset << Head.FileSize << Head.Ver << Head.CRC;
		unguard;
	}
};

/*-----------------------------------------------------------------------------
	Functions.
-----------------------------------------------------------------------------*/

//
// Return the name part only.
//
inline FString BaseFilename( FString Src )
{
	guard(BaseFilename);
	for( ; ; )
	{
		INT i = Src.InStr( PATH_SEPARATOR ); 
		if( i<0 )
			break;
		Src = Src.Mid(i+1);
	}
	return Src;
	unguard;
}

//
// Return the path part only.
//
inline FString BasePath( const FString& Src )
{
	guard(BasePath);
	for( INT i=Src.Len()-1; i>=0; i-- )
		if( Src.Mid(i,1)==PATH_SEPARATOR )
			return Src.Left(i);
	return TEXT("");
	unguard;
}

//
// Recurive file find.
//
inline TArray<FString> FindFilesRecursive( FString Path, FString Spec )
{
	guard(FindFilesRecursive);
	TArray<FString> Result = GFileManager->FindFiles( *(Path * Spec), 1, 0 );
	TArray<FString> Dirs   = GFileManager->FindFiles( *(Path * TEXT("*")), 0, 1 );
	for( TArray<FString>::TIterator It(Dirs); It; ++It )
	{
		TArray<FString> SubFiles = FindFilesRecursive( *(Path*(*It)), Spec );
		for( TArray<FString>::TIterator Jt(SubFiles); Jt; ++Jt )
			new(Result)FString( (*It) * (*Jt) );
	}
	return Result;
	unguard;
}

/*-----------------------------------------------------------------------------
	File information.
-----------------------------------------------------------------------------*/

//
// Information about a file.
//
struct FFileInfo
{
	FString Dest, Src, Master, Ref, Lang;
	SQWORD  Size, RefSize;
	UBOOL   MasterRecurse;
	DWORD   Flags;
	FFileInfo( FString Init )
	: Dest(), Src(), Ref(), Lang(), Size(0), RefSize(0), MasterRecurse(0), Flags(0)
	{
		guard(FFileInfo::FFileInfo);
		if( Init.Left(1)==TEXT("(") )
			Init = Init.Mid(1);
		if( Init.Right(1)==TEXT(")") )
			Init = Init.LeftChop(1);
		Parse( *Init, TEXT("DEST="),   Dest   );
		Parse( *Init, TEXT("SRC="),    Src    );
		Parse( *Init, TEXT("MASTER="), Master );
		Parse( *Init, TEXT("REF="),    Ref    );
		Parse( *Init, TEXT("REFSIZE="),RefSize);
		Parse( *Init, TEXT("SIZE="),   Size   );
		Parse( *Init, TEXT("LANG="),   Lang   );
		Parse( *Init, TEXT("FLAGS="),  Flags  );
		ParseUBOOL( *Init, TEXT("MASTERRECURSE="), MasterRecurse );
		unguard;
	}
	FString Safe( const FString& Str )
	{
		if( Src.InStr(TEXT(" "))>=0 )
			return US+TEXT("\"") + Str + TEXT("\"");
		return Str;
	}
	void Write( FOutputDevice& Ar, UBOOL Distribution )
	{
		guard(FFileInfo::Write);
		Ar.Logf( TEXT("(Src=%s"), *Safe(Src) );
		if( Dest!=TEXT("") )
			Ar.Logf( TEXT(",Dest=%s"), *Safe(Dest) );
		if( Distribution && Master!=TEXT("") )
			Ar.Logf( TEXT(",Master=%s"), *Safe(Master) );
		if( Ref!=TEXT("") )
			Ar.Logf( TEXT(",Ref=%s"), *Safe(Ref) );
		if( RefSize )
			Ar.Logf( TEXT(",RefSize=%i"), RefSize );
		if( Lang!=TEXT("") )
			Ar.Logf( TEXT(",Lang=%s"), *Lang );
		if( Size!=0 )
			Ar.Logf( TEXT(",Size=%i"), Size );
		if( Flags!=0 )
			Ar.Logf( TEXT(",Flags=%i"), Flags );
		if( Distribution && MasterRecurse )
			Ar.Logf( TEXT(",MasterRecurse=True"), Size );
		Ar.Log( TEXT(")") );
		unguard;
	}
};

/*-----------------------------------------------------------------------------
	USetupObject.
-----------------------------------------------------------------------------*/

class USetupObject : public UObject
{
	DECLARE_ABSTRACT_CLASS(USetupObject,UObject,0)
};

/*-----------------------------------------------------------------------------
	USetupProduct.
-----------------------------------------------------------------------------*/