parsepkg.cpp

Symbian操作系统手机上可执行程序的安装打包程序的源码

// PARSEPKG.cpp
// Copyright (c) 1997-1999 Symbian Ltd. All rights reserved.
//
// handles parsing of PKG file
//

// ===========================================================================
// INCLUDES
// ===========================================================================

#include <wctype.h>
#include <wchar.h>
#include "utils.h"
#include <assert.h>
#include <wchar.h>
#include <tchar.h>
#include <errno.h>
#include <instform.h>
#ifdef __SYMBIAN32__
#include <hal_data.h>
#endif
#include <iostream>
#include <stdio.h>
#include "parsepkg.h"
#include "parsecmd.h"
#include "crtsis.h"
#include "wcstub.h"


// ===========================================================================
// CONSTANTS
// ===========================================================================

// Set up the cout stream so that we can use it with either narrow or wide
// chars at build time
#undef OUT			   // coz it's an IDL thing...

#ifdef _UNICODE
#define OUT wcout
#else
#define OUT cout
#endif

// Parse options lookups
const SParseOpt KHeaderOptions[] =
	{
//		{L"I8", 0},
		{L"IU", EInstIsUnicode},
//		{L"ID", EInstIsDistributable},
		{L"SH", EInstShutdownApps},
		{L"NC", EInstNoCompress},
//		{L"I8BITCHARS",		0},
		{L"IUNICODE",		EInstIsUnicode},
//		{L"ISDISTRIBUTABLE",EInstIsDistributable},
		{L"SHUTDOWNAPPS",	EInstShutdownApps},
		{L"NOCOMPRESS",		EInstNoCompress},
	};
#define NUMHEADEROPTIONS (sizeof(KHeaderOptions)/sizeof(SParseOpt))

const SParseOpt KSISTypes[] =
	{
		{L"SA", EInstSISApp},
		{L"SY", EInstSISSystem},
		{L"SO", EInstSISOption},
		{L"SC", EInstSISConfig},
		{L"SP", EInstSISPatch},
		{L"SU", EInstSISUpgrade},
		{L"SISAPP",		EInstSISApp},
		{L"SISSYSTEM",  EInstSISSystem},
		{L"SISOPTION",	EInstSISOption},
		{L"SISCONFIG",	EInstSISConfig},
		{L"SISPATCH",	EInstSISPatch},
		{L"SISUPGRADE", EInstSISUpgrade},
	};
#define NUMSISTYPEOPTIONS (sizeof(KSISTypes)/sizeof(SParseOpt))

const SParseOpt KTypeOptions[] =
	{
		{L"FF", EInstFileTypeSimple},
		{L"FT", EInstFileTypeText},
		{L"FR", EInstFileTypeRun},
		{L"FN", EInstFileTypeNull},
		{L"FM", EInstFileTypeMime},
		{L"FILE",		EInstFileTypeSimple},
		{L"FILETEXT",	EInstFileTypeText},
		{L"FILERUN",	EInstFileTypeRun},
		{L"FILENULL",	EInstFileTypeNull},
		{L"FILEMIME",	EInstFileTypeMime},
	};
#define NUMTYPEOPTIONS (sizeof(KTypeOptions)/sizeof(SParseOpt))

const SParseOpt KTextOptions[] =
	{
		{L"TC", EInstFileTextOptionContinue},
		{L"TS", EInstFileTextOptionSkipOneIfNo},
		{L"TA", EInstFileTextOptionAbortIfNo},
		{L"TE", EInstFileTextOptionExitIfNo},
		{L"TEXTCONTINUE",	EInstFileTextOptionContinue},
		{L"TEXTSKIP",		EInstFileTextOptionSkipOneIfNo},
		{L"TEXTABORT",		EInstFileTextOptionAbortIfNo},
		{L"TEXTEXIT",		EInstFileTextOptionExitIfNo},
	};
#define NUMTEXTOPTIONS (sizeof(KTextOptions)/sizeof(SParseOpt))

const SParseOpt KRunOptions[] =
	{
		{L"RI", EInstFileRunOptionInstallOnly},
		{L"RR", EInstFileRunOptionRemoveOnly},
		{L"RB", EInstFileRunOptionInstallAndRemove},
		{L"RUNINSTALL",	EInstFileRunOptionInstallOnly},
		{L"RUNREMOVE",	EInstFileRunOptionRemoveOnly},
		{L"RUNBOTH",	EInstFileRunOptionInstallAndRemove}
	};
#define NUMRUNOPTIONS (sizeof(KRunOptions)/sizeof(SParseOpt))

const SParseOpt KCtrlOptions[] =
	{
		{L"RS", EInstRunSendEnd},
		{L"RW", EInstRunWaitEnd},
		{L"RUNSENDEND", EInstRunSendEnd},
		{L"RUNWAITEND", EInstRunWaitEnd},
	};
#define NUMCTRLOPTIONS (sizeof(KCtrlOptions)/sizeof(SParseOpt))

// Parse options lookups
#define MAXTOKENLEN	30
struct SParseToken
	{
	WCHAR pszOpt[MAXTOKENLEN];
	DWORD dwOpt;
	};

const SParseToken KTokens[] =
	{
		{L"if",		IF_TOKEN},
		{L"elseif",	ELSEIF_TOKEN},
		{L"else",	ELSE_TOKEN},
		{L"endif",	ENDIF_TOKEN},
		{L"exists",	EXISTS_TOKEN},
		{L"devcap",	DEVCAP_TOKEN},
		{L"appcap",	APPCAP_TOKEN},
		{L"not",	NOT_TOKEN},
		{L"and",	AND_TOKEN},
		{L"or",		OR_TOKEN},
		{L"type",	TYPE_TOKEN},
		{L"key",	KEY_TOKEN},
	};
#define NUMPARSETOKENS (sizeof(KTokens)/sizeof(SParseToken))

// Language options
const SParseOpt KLangOptions[] = 
	{
		{L"EN", ELangEnglish},
		{L"FR", ELangFrench},
		{L"GE", ELangGerman},
		{L"SP", ELangSpanish},
		{L"IT", ELangItalian},
		{L"SW", ELangSwedish},
		{L"DA", ELangDanish},
		{L"NO", ELangNorwegian},
		{L"FI", ELangFinnish},
		{L"AM", ELangAmerican},
		{L"SF", ELangSwissFrench},
		{L"SG", ELangSwissGerman},
		{L"PO", ELangPortuguese},
		{L"TU", ELangTurkish},
		{L"IC", ELangIcelandic},
		{L"RU", ELangRussian},
		{L"HU", ELangHungarian},
		{L"DU", ELangDutch},
		{L"BL", ELangBelgianFlemish},
		{L"AU", ELangAustralian},
		{L"BF", ELangBelgianFrench},
		{L"AS", ELangAustrian},
		{L"NZ", ELangNewZealand},
		{L"IF", ELangInternationalFrench},
		{L"CS", ELangCzech},
		{L"SK", ELangSlovak},
		{L"PL", ELangPolish},
		{L"SL", ELangSlovenian},
		{L"TC", ELangTaiwanChinese},
		{L"HK", ELangHongKongChinese},
		{L"ZH", ELangPrcChinese},
		{L"JA", ELangJapanese},
		{L"TH", ELangThai},

		{L"AF", ELangAfrikaans },
		{L"SQ", ELangAlbanian },
		{L"AH", ELangAmharic },
		{L"AR", ELangArabic },
		{L"HY", ELangArmenian },
		{L"TL", ELangTagalog },
		{L"BE", ELangBelarussian },
		{L"BN", ELangBengali },
		{L"BG", ELangBulgarian },
		{L"MY", ELangBurmese },
		{L"CA", ELangCatalan },
		{L"HR", ELangCroatian },
		{L"CE", ELangCanadianEnglish },
		{L"IE", ELangInternationalEnglish },
		{L"SF", ELangSouthAfricanEnglish },
		{L"ET", ELangEstonian },
		{L"FA", ELangFarsi },
		{L"CF", ELangCanadianFrench },
		{L"GD", ELangScotsGaelic },
		{L"KA", ELangGeorgian },
		{L"EL", ELangGreek },
		{L"CG", ELangCyprusGreek },
		{L"GU", ELangGujarati },
		{L"HE", ELangHebrew },
		{L"HI", ELangHindi },
		{L"IN", ELangIndonesian },
		{L"GA", ELangIrish },
		{L"SZ", ELangSwissItalian },
		{L"KN", ELangKannada },
		{L"KK", ELangKazakh },
		{L"KM", ELangKhmer },
		{L"KO", ELangKorean },
		{L"LO", ELangLao },
		{L"LV", ELangLatvian },
		{L"LT", ELangLithuanian },
		{L"MK", ELangMacedonian },
		{L"MS", ELangMalay },
		{L"ML", ELangMalayalam },
		{L"MR", ELangMarathi },
		{L"MO", ELangMoldavian },
		{L"MN", ELangMongolian },
		{L"NN", ELangNorwegianNynorsk },
		{L"BP", ELangBrazilianPortuguese },
		{L"PA", ELangPunjabi },
		{L"RO", ELangRomanian },
		{L"SR", ELangSerbian },
		{L"SI", ELangSinhalese },
		{L"SO", ELangSomali },
		{L"OS", ELangInternationalSpanish },
		{L"LS", ELangLatinAmericanSpanish },
		{L"SH", ELangSwahili },
		{L"FS", ELangFinlandSwedish },
		//{L"??", ELangReserved1 },
		{L"TA", ELangTamil },
		{L"TE", ELangTelugu },
		{L"BO", ELangTibetan },
		{L"TI", ELangTigrinya },
		{L"CT", ELangCyprusTurkish },
		{L"TK", ELangTurkmen },
		{L"UK", ELangUkrainian },
		{L"UR", ELangUrdu },
		//{L"??", ELangReserved2 },
		{L"VI", ELangVietnamese },
		{L"CY", ELangWelsh },
		{L"ZU", ELangZulu },
		//{L"??", ELangOther },
		//{L"??", ELangNone  }

	};
#define NUMLANGOPTIONS (sizeof(KLangOptions)/sizeof(SParseOpt))

/*
 * Optional dependency on Symbian SDK
 */

#ifndef __SYMBIAN32__
#undef X
#define X(a) E ## a,

enum {
#include "haltable.hm"
};
#undef X
#endif

const SParseToken KVariableLookupTable[] =
	{
#ifndef __SYMBIAN32__
#undef X
#define X(a) {L ## #a , E ## a},
#include "haltable.hm"
#undef X
#else
		{L"Manufacturer",				HALData::EManufacturer},
		{L"ManufacturerHardwareRev",	HALData::EManufacturerHardwareRev},
		{L"ManufacturerSoftwareRev",	HALData::EManufacturerSoftwareRev},
		{L"ManufacturerSoftwareBuild",	HALData::EManufacturerSoftwareBuild},
		{L"Model",						HALData::EModel},
		{L"MachineUid",					HALData::EMachineUid},
		{L"DeviceFamily",				HALData::EDeviceFamily},
		{L"DeviceFamilyRev",			HALData::EDeviceFamilyRev},
		{L"CPU",						HALData::ECPU},
		{L"CPUArch",					HALData::ECPUArch},
		{L"CPUABI",						HALData::ECPUABI},
		{L"CPUSpeed",					HALData::ECPUSpeed},
		//{L"SystemStartupReason",		HALData::ESystemStartupReason},
		//{L"SystemException",			HALData::ESystemException},
		{L"SystemTickPeriod",			HALData::ESystemTickPeriod},
		{L"MemoryRAM",					HALData::EMemoryRAM},
		{L"MemoryRAMFree",				HALData::EMemoryRAMFree},
		{L"MemoryROM",					HALData::EMemoryROM},
		{L"MemoryPageSize",				HALData::EMemoryPageSize},
		//{L"PowerGood",				HALData::EPowerGood},
		//{L"PowerBatteryGood",			HALData::EPowerBatteryGood},
		{L"PowerBackup",				HALData::EPowerBackup},
		//{L"PowerBackupGood",			HALData::EPowerBackupGood},
		//{L"PowerExternal",				HALData::EPowerExternal},
		{L"Keyboard",					HALData::EKeyboard},
		{L"KeyboardDeviceKeys",			HALData::EKeyboardDeviceKeys},
		{L"KeyboardAppKeys",			HALData::EKeyboardAppKeys},
		{L"KeyboardClick",				HALData::EKeyboardClick},
		//{L"KeyboardClickState",		HALData::EKeyboardClickState},
		//{L"KeyboardClickVolume",		HALData::EKeyboardClickVolume},
		{L"KeyboardClickVolumeMax",		HALData::EKeyboardClickVolumeMax},
		{L"DisplayXPixels",				HALData::EDisplayXPixels},
		{L"DisplayYPixels",				HALData::EDisplayYPixels},
		{L"DisplayXTwips",				HALData::EDisplayXTwips},
		{L"DisplayYTwips",				HALData::EDisplayYTwips},
		{L"DisplayColors",				HALData::EDisplayColors},
		//{L"DisplayState",				HALData::EDisplayState},
		//{L"DisplayContrast",			HALData::EDisplayContrast},
		{L"DisplayContrastMax",			HALData::EDisplayContrastMax},
		{L"Backlight",					HALData::EBacklight},
		//{L"BacklightState",			HALData::EBacklightState},
		{L"Pen",						HALData::EPen},
		{L"PenX",						HALData::EPenX},
		{L"PenY",						HALData::EPenY},
		{L"PenDisplayOn",				HALData::EPenDisplayOn},
		{L"PenClick",					HALData::EPenClick},
		//{L"PenClickState",			HALData::EPenClickState},
		//{L"PenClickVolume",			HALData::EPenClickVolume},
		{L"PenClickVolumeMax",			HALData::EPenClickVolumeMax},
		{L"Mouse",						HALData::EMouse},
		{L"MouseX",						HALData::EMouseX},
		{L"MouseY",						HALData::EMouseY},
		//{L"MouseState",				HALData::EMouseState},
		//{L"MouseSpeed",				HALData::EMouseSpeed},
		//{L"MouseAcceleration",		HALData::EMouseAcceleration},
		{L"MouseButtons",				HALData::EMouseButtons},
		//{L"MouseButtonState",			HALData::EMouseButtonState},
		//{L"CaseState",					HALData::ECaseState},
		{L"CaseSwitch",					HALData::ECaseSwitch},
		//{L"CaseSwitchDisplayOn",		HALData::ECaseSwitchDisplayOn},
		//{L"CaseSwitchDisplayOff",		HALData::ECaseSwitchDisplayOff},
		{L"LEDs",						HALData::ELEDs},
		//{L"LEDmask",					HALData::ELEDmask},
		{L"IntegratedPhone",			HALData::EIntegratedPhone},
		//{L"DisplayBrightness",			HALData::EDisplayBrightness},
		{L"DisplayBrightnessMax",		HALData::EDisplayBrightnessMax},
		{L"KeyboardBacklightState",		HALData::EKeyboardBacklightState},
		{L"AccessoryPower",				HALData::EAccessoryPower},

		{L"NumHalAttributes",			HALData::ENumHalAttributes},
#endif
		{L"Language",					EVarLanguage},
		{L"RemoteInstall",				EVarRemoteInstall},
	};


#define NUMVAROPTIONS (sizeof(KVariableLookupTable)/sizeof(SParseOpt))

// ===========================================================================
// CParsePkg
// ===========================================================================

CParsePkg::CParsePkg()
:m_nLineNo(0),	   		// The line we are currently on
m_fInLangBlock(0),		// Are we processing a language block
m_fInLangFileBlock(0),	// Are we processing a language dependent file block
m_wCurrLang(0),   		// If we are in a lang/lang file block - which lang are we processing
m_pSISWriter(NULL)		// Stuff all our intermediate data in here
	{
	memset((void *)m_pszSearchDir, 0x0000, MAX_PATH * sizeof(WCHAR));
	}

void CParsePkg::SetSearchDirectory(LPCWSTR pszPath)
// Purpose  : Sets the search directory
// Inputs   : pszPath  - The directory path (including trailing backslash!)
	{
	wcscpy(m_pszSearchDir, pszPath);
	DWORD len=wcslen(m_pszSearchDir);
	if(len>0 && m_pszSearchDir[len-1] != '/') 	// Ensure a trailing slash
		{
		m_pszSearchDir[len] = '/';
		m_pszSearchDir[len+1] = '\0';
		}
	}

void CParsePkg::ParseL(HANDLE hFile, CSISWriter *pWriter, BOOL fIsStub, MParserObserver *pObserver /*= NULL*/)
// Purpose  : Check the contents of an input line and defers parsing to the appropriate ParseXXXL()
//			  method
// Inputs   : m_pkgPtr - The line to process
// Returns  : Success or failure (actually, always TRUE - failure causes an exception to be thrown)
	{
	assert(hFile != INVALID_HANDLE_VALUE);
	assert(pWriter);
	
	m_file = hFile;
	m_pSISWriter = pWriter;
	m_pObserver  = pObserver;
	m_stubFile = fIsStub;
	m_enoughForStub = FALSE;
	
	if (m_pObserver) m_pObserver->SetLineNumber(++m_nLineNo);
	
	// Make sure we're at the beginning of the file	
	::SetFilePointer(m_file, 0L, NULL, FILE_BEGIN);	
	
	GetNextChar();
	// skip unicode marker if present
	if (m_pkgChar==0xFEFF) GetNextChar();
	GetNextToken();
	while(m_token!=EOF_TOKEN && !(m_stubFile && m_enoughForStub))
		{
		ParseEmbeddedBlockL();
		switch (m_token)
			{
			case '&':
				GetNextToken();
				ParseLanguagesL();
				break;
			case '#':
				GetNextToken();
				ParseHeaderL();
				break;
			case '(':
				GetNextToken();
				ParseDependencyL();
				break;
			case '*':
				GetNextToken();
				ParseSignatureL();
				break;
			case EOF_TOKEN:
				break;
			default :
				{
				  printf("unknown token '%c' (%0x)\n", m_token, m_token);
				throw ErrUnknownLine;
				}
			}
		}

	// for patch/upgrade/config SIS types check is valid
	// (must declare a dependency on component with same UID)
	TSISType wType=m_pSISWriter->GetType();
	if ((wType==EInstSISConfig) || (wType==EInstSISUpgrade) || (wType==EInstSISPatch))
		{
		const DEPENDNODE* depend=m_pSISWriter->GetDependencyBase();
		DWORD dwUid=m_pSISWriter->GetUID();
		while (depend && dwUid!=depend->dwUID)
			depend=depend->pNext;
		if (!depend) throw ErrNoMainDependency;
		}

	}

void CParsePkg::ParseEmbeddedBlockL()
	{
	while(m_token!=EOF_TOKEN)
		{
		switch (m_token & 0x0000ffff)
			{
			case QUOTED_STRING_TOKEN:
				ParseFileL();
				break;