parsepkg.cpp

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

	GetNextToken();
	
	//check for optional items (password)
	if (m_token==',')
		{
		GetNextToken();
		if (m_token==KEY_TOKEN)
			{
			GetNextToken();
			ExpectToken('=');
			GetNextToken();
			ExpectToken(QUOTED_STRING_TOKEN);
			wcscpy(pSig->pszPassword,m_tokenValue.pszString);
			GetNextToken();		
			}
		}

	m_pSISWriter->AddSignatureNode(pSig);
#ifndef DIGITAL_SIGNATURES
	m_pObserver->DoErrMsg(_T("digital signatures not supported in this version of makesis"));
#endif
}

void CParsePkg::ParseCapabilityL()
// Parses a capability line
	{
	Verbage(_T("processing capability"));
	
	if(!m_pSISWriter->AreLangStringInit())
		throw ErrHeaderNotDefined;
	
	ExpectToken('(');
	do
		{
		GetNextToken();

		CAPABILITYNODE *pNode = new CAPABILITYNODE;
		if (!pNode) throw ErrNotEnoughMemory;
		memset((void *)pNode, '\0', sizeof(CAPABILITYNODE));
	
		ExpectToken(NUMERIC_TOKEN);
		pNode->iKey=m_tokenValue.dwNumber;
		GetNextToken();
		ExpectToken('=');
		GetNextToken();
		ExpectToken(NUMERIC_TOKEN);
		pNode->iValue=m_tokenValue.dwNumber;
		m_pSISWriter->AddCapabilityNode(pNode);

		GetNextToken();
		} while (m_token==',');
	ExpectToken(')');
	GetNextToken();
	}

void CParsePkg::ParseOptionsBlockL()
// To parse an options block
	{
	WORD wNumLangs;
	LANGSTRINGNODE *pLSNode;

	Verbage(_T("processing options block"));
	
	ExpectToken('(');
	GetNextToken();

	PKGLINENODE *pNode = new PKGLINENODE;
	if (!pNode) throw ErrNotEnoughMemory;
	memset((void *)pNode, '\0', sizeof(PKGLINENODE));
	pNode->iPackageLineType=EInstPkgLineOption;
	pNode->option = new PKGLINEOPTIONS;
	if (!pNode->option) throw ErrNotEnoughMemory;
	memset((void *)pNode->option, '\0', sizeof(PKGLINEOPTIONS));
	for (;;)
		{
		ExpectToken('{');
		GetNextToken();

		wNumLangs = 0;
		while (wNumLangs < m_pSISWriter->GetNoLanguages())
			{
			ExpectToken(QUOTED_STRING_TOKEN);
			pLSNode = new LANGSTRINGNODE;
			if (!pLSNode) throw ErrNotEnoughMemory;
			memset((void *)pLSNode, '\0', sizeof(LANGSTRINGNODE));
			wcscpy(pLSNode->pszString,m_tokenValue.pszString);
			pLSNode->pNext=pNode->option->pLangStringBase;
			pNode->option->pLangStringBase = pLSNode;
			GetNextToken();
			if (wNumLangs < m_pSISWriter->GetNoLanguages()-1)
				{
				ExpectToken(',');
				GetNextToken();
				}
			wNumLangs++;
			}

		ExpectToken('}');
		pNode->option->dwNumOptions++;
		GetNextToken();
		if (m_token!=',') break;
		GetNextToken();
		}

	ExpectToken(')');
	GetNextToken();

	m_pSISWriter->AddPkgLineNode(pNode);
	}

void CParsePkg::ParseLanguageBlockL()
// To parse the start of a language block											 
	{
	Verbage(_T("processing language block"));
	
	if(!m_pSISWriter->AreLangStringInit())
		throw ErrHeaderNotDefined;
	
	BOOL packages=(m_token=='@');
	
	for (DWORD m_wCurrLang = 0; m_wCurrLang<m_pSISWriter->GetNoLanguages(); m_wCurrLang++)
		{
		PKGLINENODE *pNode = new PKGLINENODE;
		if (!pNode) throw ErrNotEnoughMemory;
		memset((void *)pNode, '\0', sizeof(PKGLINENODE));
		pNode->iPackageLineType=EInstPkgLineLanguageFile;
		pNode->file = new PKGLINEFILE;
		if (!pNode->file) throw ErrNotEnoughMemory;
		memset((void *)pNode->file, '\0', sizeof(PKGLINEFILE));
		if (packages)
			{
			ExpectToken('@');
			GetNextToken();
			pNode->file->type = EInstFileTypeComponent;
			}
		else
			{
			pNode->file->type = EInstFileTypeSimple;
			}
		ExpectToken(QUOTED_STRING_TOKEN);
		wcscpy(pNode->file->pszSource,m_tokenValue.pszString);			
		// Test that the file exists
		if(!DoesExist(pNode->file->pszSource, &pNode->file->dwSize))
			throw ErrFileNotFound;
		m_pSISWriter->AddPkgLineNode(pNode);
		GetNextToken();	
		}
	
	ExpectToken('}');
	GetNextToken();	
	
	// Test if it was a file or package block
	if(!packages)
		{
		ExpectToken('-');
		GetNextToken();	
		
		// Get the destination & options
		ExpectToken(QUOTED_STRING_TOKEN);
		WCHAR pszDest[MAX_PATH] = L"";
		wcscpy(pszDest,m_tokenValue.pszString);
		GetNextToken();
		
		DWORD dwType=0;
		DWORD dwOptions=0;
		WCHAR pszMimeType[MAX_MIME_TYPE] = L"";
		// Test for options
		if (m_token==',')
			{
			GetNextToken();
			ParseOption(KTypeOptions,NUMTYPEOPTIONS, &dwType);
			if ((TInstFileType)dwType==EInstFileTypeNull) throw ErrBadOption;
			if ((TInstFileType)dwType==EInstFileTypeMime)
				{
				ExpectToken(',');
				GetNextToken();
				ExpectToken(QUOTED_STRING_TOKEN);
				wcscpy(pszMimeType, m_tokenValue.pszString);
				GetNextToken();
				}
			if (m_token==',')
				{
				switch ((TInstFileType)dwType)
					{
					case EInstFileTypeText:
						GetNextToken();
						ParseOption(KTextOptions,NUMTEXTOPTIONS, &dwOptions);
						break;
					case EInstFileTypeRun:
						GetNextToken();
						ParseOption(KRunOptions,NUMRUNOPTIONS, &dwOptions);
						if (m_token==',')
							{
							GetNextToken();
							ParseOption(KCtrlOptions,NUMCTRLOPTIONS, &dwOptions);
							}
						// if running when uninstall then must use wait end option
						if (dwOptions&(EInstFileRunOptionRemoveOnly|EInstFileRunOptionInstallAndRemove) &&
							!(dwOptions&EInstRunWaitEnd))
							throw ErrUninstallNeedsWaitEnd;
						break;
					case EInstFileTypeMime:
						if (m_token==',')
							{
							GetNextToken();
							ParseOption(KCtrlOptions,NUMCTRLOPTIONS, &dwOptions);
							}
						break;
					default:
						throw ErrBadOption;
						break;
					}
				}
			}
		
		m_pSISWriter->SetLangDependFileDestinations(pszDest, pszMimeType, dwType, dwOptions);
		}
	else
		{
		ExpectToken(',');
		GetNextToken();	
		ExpectToken('(');
		GetNextToken();	
		
		ExpectToken(NUMERIC_TOKEN);
		m_pSISWriter->SetLangDependCompDestinations(m_tokenValue.dwNumber);
		GetNextToken();	
		
		ExpectToken(')');
		GetNextToken();	
		
		}
	}

void CParsePkg::ParseIfBlockL()
	{
	Verbage(_T("processing IF block"));
	
	ParseConditionL(EInstPkgLineCondIf);
	ParseEmbeddedBlockL();
	
	while (m_token==ELSEIF_TOKEN)
		{
		GetNextToken();
		ParseConditionL(EInstPkgLineCondElseIf);
		ParseEmbeddedBlockL();
		}
	
	if (m_token==ELSE_TOKEN)
		{
		GetNextToken();
		ParseConditionL(EInstPkgLineCondElse);
		ParseEmbeddedBlockL();
		}
	
	ExpectToken(ENDIF_TOKEN);
	ParseConditionL(EInstPkgLineCondEndIf);
	GetNextToken();
	}

void CParsePkg::ParseCommentL()
// Purpose  : Parses a comment line (Does nothing, just throws the line away)
// Inputs   : m_pkgPtr - The string to parse
// Returns  : Success or failure
	{
	Verbage(_T("processing comment"));
	
	// parse to end of line
	while (m_pkgChar && m_pkgChar!='\n')
		GetNextChar();
	GetNextToken();
	}

void CParsePkg::ParseConditionL(TInstPackageLineType type)
// Purpose  : Parses a condition line                         
// Inputs   : m_pkgPtr - The string to parse
// returns  : Success or failure (actually, always TRUE - failure causes an exception to be thrown)
	{
	PKGLINENODE *pNode = new PKGLINENODE;
	if (!pNode) throw ErrNotEnoughMemory;
	memset((void *)pNode, '\0', sizeof(PKGLINENODE));
	pNode->iPackageLineType=type;

	if (type==EInstPkgLineCondElse || type==EInstPkgLineCondEndIf)
		{
		pNode->cond=NULL;
		}
	else
		{
		pNode->cond=ParseExpr();
		}
	
	m_pSISWriter->AddPkgLineNode(pNode);
	}

PKGLINECONDITION* CParsePkg::ParseExpr()
	{
    return ParseLogicalOp();
	}

PKGLINECONDITION* CParsePkg::ParseLogicalOp()
	{
    PKGLINECONDITION* left=ParseRelation();
    for (;;)
		{
		switch (m_token)
			{
			case AND_TOKEN:
			case OR_TOKEN:
				{
				PKGLINECONDITION* expr=new PKGLINECONDITION;
				if (!expr) throw ErrNotEnoughMemory;
				memset((void *)expr, '\0', sizeof(PKGLINECONDITION));
				if (m_token==AND_TOKEN)
					expr->exprType=EInstCondLogOpAnd;
				else
					expr->exprType=EInstCondLogOpOr;
				expr->b.pLhs=left;
				GetNextToken();
				expr->b.pRhs=ParseRelation();
				left=expr;
				}
				continue;
			default:
				return left;
			}
		}
	}

PKGLINECONDITION* CParsePkg::ParseRelation()
	{
    PKGLINECONDITION* left=ParseUnary();
	switch (m_token)
		{
		case '=':
		case '>':
		case '<':
		case GE_TOKEN:
		case LE_TOKEN:
		case NE_TOKEN:
			{
			PKGLINECONDITION* expr=new PKGLINECONDITION;
			if (!expr) throw ErrNotEnoughMemory;
			memset((void *)expr, '\0', sizeof(PKGLINECONDITION));
			switch (m_token)
				{
				case '=':
					expr->exprType=EInstCondBinOpEq;
					break;
				case '>':
					expr->exprType=EInstCondBinOpGt;
					break;
				case '<':
					expr->exprType=EInstCondBinOpLt;
					break;
				case GE_TOKEN:
					expr->exprType=EInstCondBinOpGe;
					break;
				case LE_TOKEN:
					expr->exprType=EInstCondBinOpLe;
					break;
				case NE_TOKEN:
					expr->exprType=EInstCondBinOpNe;
					break;
				}
			expr->b.pLhs=left;
			GetNextToken();
			expr->b.pRhs=ParseUnary();
			return expr;
			}
		}
	return left;
	}

PKGLINECONDITION* CParsePkg::ParseUnary()
	{
    switch (m_token)
		{
		case NOT_TOKEN:
			{
			PKGLINECONDITION* expr=new PKGLINECONDITION;
			if (!expr) throw ErrNotEnoughMemory;
			memset((void *)expr, '\0', sizeof(PKGLINECONDITION));
			if (m_token==EXISTS_TOKEN)
				expr->exprType=EInstCondFuncExists;
			else
				expr->exprType=EInstCondUnaryOpNot;
			GetNextToken();
			expr->pExpr=ParseUnary();
			return expr;
			}
		case APPCAP_TOKEN:
			{	// 2 arg function
			GetNextToken();
			ExpectToken('(');
			PKGLINECONDITION* expr=new PKGLINECONDITION;
			if (!expr) throw ErrNotEnoughMemory;
			memset((void *)expr, '\0', sizeof(PKGLINECONDITION));
			expr->exprType=EInstCondFuncAppCap;
			GetNextToken();
			ExpectToken(NUMERIC_TOKEN);
			expr->pArg[0]=ParseUnary();
			ExpectToken(',');
			GetNextToken();
			ExpectToken(NUMERIC_TOKEN);
			expr->pArg[1]=ParseUnary();
			ExpectToken(')');
			GetNextToken();
			return expr;
			}
		case EXISTS_TOKEN:
		case DEVCAP_TOKEN:
			{	// 1 arg function
			TOKEN token=m_token;
			GetNextToken();
			ExpectToken('(');
			PKGLINECONDITION* expr=new PKGLINECONDITION;
			if (!expr) throw ErrNotEnoughMemory;
			memset((void *)expr, '\0', sizeof(PKGLINECONDITION));
			GetNextToken();
			if (token==EXISTS_TOKEN)
				{
				expr->exprType=EInstCondFuncExists;
				ExpectToken(QUOTED_STRING_TOKEN);
				}
			else
				{
				expr->exprType=EInstCondFuncDevCap;
				ExpectToken(NUMERIC_TOKEN);
				}
			expr->pArg[0]=ParseUnary();
			ExpectToken(')');
			GetNextToken();
			return expr;
			}
		default:
			return ParseFactor();
		}
	}

PKGLINECONDITION* CParsePkg::ParseFactor()
	{
	PKGLINECONDITION* expr;
    switch (m_token) {
		case '(':
			{
			GetNextToken();
			expr=ParseExpr();
			ExpectToken(')');
			}
			break;
		case QUOTED_STRING_TOKEN:
		case ALPHA_TOKEN:
		case NUMERIC_TOKEN:
			{
			expr=new PKGLINECONDITION;
			if (!expr) throw ErrNotEnoughMemory;
			memset((void *)expr, '\0', sizeof(PKGLINECONDITION));
			expr->pPrim=new VARIANTVAL;
			if (!expr->pPrim) throw ErrNotEnoughMemory;
			switch (m_token)
				{