wmlif.c

是一个手机功能的模拟程序

			/* Check if text */
			if ((pElement!=NULL)&&(!isTypeWMLText(pElement->iType)))
			{
				fText=FALSE;		
			}
		}
	}

	return pElement;
}

/*========================================================================
	WML_GetCard
==========================================================================*/
pELEMENTTYPE WML_GetCard (pUA pUser, WCHAR *pchName) 
{
	pELEMENTTYPE pCont=NULL;
	pWMLELEMENT pWML=NULL;
	pELEMENTTYPE pFirstCard=NULL;
	WCHAR *pchTempName=NULL;

	if (pUser!=NULL) 
	{
		/* Get the deck */
		pCont=pUser->pDeck;

		if (pCont!=NULL) 
		{
			/* Get the first element in the deck */
			pWML=(WMLELEMENT*)(pCont);
			pCont=pWML->pContent;

			while (pCont!=NULL) 
			{
				if (pCont->iType==Type_CARD) 
				{
					if (pFirstCard==NULL)
					{
						/* First card found */
						pFirstCard=pCont;
						pUser->pCurrentCard=pCont;
					}

					pchTempName=((CARDELEMENT*)(pCont))->pchId;

					if ((pchName!=NULL) && (pchTempName!=NULL))
					{
						if (COMPARESTRING(pchName,pchTempName)==0)
						{
							return pCont;
						}
					}
				}
				pCont=pCont->pNextElement;
			}
		}
	}
	return pFirstCard;
}


/*========================================================================
	WML_GetNextCard
==========================================================================*/
pELEMENTTYPE WML_GetNextCard (pUA pUser)
{
	pELEMENTTYPE pTemp=NULL;

	if (pUser!=NULL) 
	{
		pTemp=pUser->pCurrentCard;

		if (pTemp!=NULL)
		{
			pTemp=pTemp->pNextElement;

			/* Find next CARD */
			while (pTemp!=NULL) 
			{
				/* Check if CARD */
				if (pTemp->iType==Type_CARD)
				{
					/* Next CARD found */
					pUser->pCurrentCard=pTemp;
					return pTemp;
				}

				pTemp=pTemp->pNextElement;
			}
		}
	}
	return NULL;
}


/*========================================================================
	WML_GetCardTitle
==========================================================================*/
WCHAR* WML_GetCardTitle (pUA pUser, pELEMENTTYPE pCARD)
{
	pCARDELEMENT pCardElement;

	if (pUser!=NULL)
	{
		if (pCARD!=NULL)
		{
			if (pCARD->iType==Type_CARD)
			{
				pCardElement=(CARDELEMENT*)(pCARD);
				return WML_GetString(pUser,pCardElement->pTitle);
			}
		}
	}
	return NULL;
}


/*========================================================================
	WML_GetTemplateDO
==========================================================================*/
pTEMPLATEDOTYPE WML_GetTemplateDO (pELEMENTTYPE pCARD)
{
	if (pCARD!=NULL)
	{
		if (pCARD->iType==Type_CARD)
		{
			return (((CARDELEMENT*)(pCARD))->pTemplateDO);
		}
	}
	return NULL;
}


/*========================================================================
	WML_GetNextTemplateDO
==========================================================================*/
pTEMPLATEDOTYPE WML_GetNextTemplateDO (pTEMPLATEDOTYPE pTemplateDO)
{
	if (pTemplateDO!=NULL)
	{
		return (pTemplateDO->pNext);
	}
	return NULL;
}


/*========================================================================
	WML_GetDOFromTemplate
==========================================================================*/
pELEMENTTYPE WML_GetDOFromTemplate (pTEMPLATEDOTYPE pTemplateDO)
{
	if (pTemplateDO!=NULL)
	{
		return pTemplateDO->pDO;
	}
	return NULL;
}



/*========================================================================
	WML_CheckAccessElement
==========================================================================*/
BOOL WML_CheckAccessElement (pELEMENTTYPE pAccess, BYTE *pbURL, BYTE *pbDefaultDomain)
{
	pACCESSELEMENT pAccessElm=NULL;
	BOOL fResult=FALSE;
	BOOL fOverflow=FALSE;
	BYTE *pbTempDomain=NULL;
	BYTE *pbPath=NULL;
	BYTE *pbDomain=NULL;

	if (pAccess!=NULL)
	{
		pAccessElm=(pACCESSELEMENT)pAccess;

		if (pAccessElm!=NULL)
		{
			/* Get domain */
			if (pAccessElm->pchDomain!=NULL)
			{
				/* Convert host to byte*. Dealloc pbTempDomain 
				   after comparision (not pbDomain) */

				pbTempDomain=wip_wchar2byte(pAccessElm->pchDomain,&fOverflow);
				pbDomain=pbTempDomain;

				if ((pbTempDomain==NULL)||(fOverflow))
				{
					/* Error */
					DEALLOC(&pbTempDomain);
					return FALSE;
				}
			}
			else
			{
				pbDomain=pbDefaultDomain;
			}

			/* Get path */
			if (pAccessElm->pchPath!=NULL)
			{
				/* Convert path to byte*. Dealloc pbPath
				   after comparision. */
				pbPath=wip_wchar2byte(pAccessElm->pchPath,&fOverflow);

				if ((pbPath==NULL)||(fOverflow))
				{
					/* Error */
					DEALLOC(&pbTempDomain);
					DEALLOC(&pbPath);
					return FALSE;
				}
			}

			/* Path and Domain specified - check access */
			fResult=URL_CheckAccess (pbURL, pbDomain, pbPath);

			/* DEALLOC temporary strings */
			DEALLOC(&pbTempDomain);
			DEALLOC(&pbPath);
		}
	}
	return fResult;
}

/*========================================================================
	WML_NewContext
==========================================================================*/
void WML_NewContext (pUA pUser)
{
	if (pUser!=NULL)
	{
		/* Empty variable table */
		WML_EmptyVarTable (pUser);

		/* Remove all history entries but the newest */
		WML_EmptyHistoryNewContext (pUser);
	}
}



/*========================================================================
	UApragmaFromScript
==========================================================================*/
void UApragmaFromScript(pUA userAgent, WCHAR** ppwchPropertyName, 
						WCHAR** ppwchContent, WCHAR** ppwchScheme )
{
/*  Added by GBU,990702,    to get rid of IAR warning */
    userAgent = userAgent;

	/* no UA pragma handling at this time */
	DEALLOC( ppwchPropertyName );
	DEALLOC( ppwchContent );
	DEALLOC( ppwchScheme  );
}





/*========================================================================
	WML_IsPEmpty
==========================================================================*/
BOOL WML_IsPEmpty (pUA pUser, pELEMENTTYPE pPElement)
{ 
	pELEMENTTYPE pContent=NULL;
	WCHAR *pchText=NULL;

	if ((pPElement==NULL)||(pUser==NULL))
	{
		/* NO ELEMENT - EMPTY (?) */
		return TRUE;
	}

	if (pPElement->iType!=Type_P)
	{
		/* Not p element */
		return FALSE;
	}

	/* Get p content */
	pContent=WML_GetContent(pPElement);

	while (pContent!=NULL)
	{
		if (isTypeWMLText(pContent->iType))
		{
			/* Text found, check if only white space */
			pchText=WML_GetString (pUser, pContent);

			if (pchText!=NULL)
			{
				if (!(WML_CheckIfOnlyWhiteSpace(pchText)))
				{
					/* Not empty */
					DEALLOC(&pchText);
					return FALSE;
				}
				DEALLOC(&pchText);
			}
		}
		else
		{
			/* Other element found, return FALSE  
			   (p element not empty) */
			return FALSE;
		}

		/* Get next content */
		pContent=WML_GetNextElement(pContent);
	}

	/* p element is empty */
	return TRUE;
}



/*========================================================================
	WML_TrimTextWCHAR
	WML_TrimTextBYTE
==========================================================================*/
BOOL WML_TrimTextWCHAR (WCHAR *pchText, UINT8 iMode)
{
	WCHAR *pchRead=NULL;
	WCHAR *pchWrite=NULL;
	WCHAR *pchLastChar=NULL;
	BOOL fSpaceFound=FALSE;
	BOOL fResult=FALSE;

	if (pchText==NULL)
	{
		return FALSE;
	}

	pchWrite=pchText;
	pchRead=pchText;

	/* Trim left? */
	if ((iMode)&(TRIMTEXT_LEFT))
	{
		BOOL fSpaceFound=TRUE;

		/* Find first non-white space char */
		while ((*pchRead!=0)&&(fSpaceFound))
		{
			if (isXMLWhiteSpace(*pchRead))
			{
				/* Do not step write pos */
				pchRead++;
			}
			else
			{
				/* Not white space */
				fSpaceFound=FALSE;
			}
		}
	}

	pchLastChar=pchWrite;

	/* Remove insignificant white spaces */
	while (*pchRead!=0)
	{
		if (isXMLWhiteSpace(*pchRead))
		{
			/* All white spaces -> x20 */
			*pchRead=(WCHAR)('\x20');

			if (fSpaceFound)
			{
				/* Do not step write pos */
				pchRead++;
			}
			else
			{
				fSpaceFound=TRUE;
				*pchWrite++=*pchRead++;
			}
		}
		else
		{
			pchLastChar=pchWrite;

			/* Not white space - write */
			*pchWrite++=*pchRead++;
			fSpaceFound=FALSE;
		}
	}

	/* Trim right? */
	if ((iMode)&(TRIMTEXT_RIGHT))
	{
		if (isXMLWhiteSpace(*pchLastChar))
		{
			*pchLastChar=0;
		}
		else if (!*pchLastChar++==0)
		{
			*pchLastChar=0;
		}
	}
	else
	{
		/* Check if last char is white space.
		   (For not LEFT)
		*/
		if (isXMLWhiteSpace(*pchLastChar))
		{
			if (!((iMode)&(TRIMTEXT_LEFT)))
			{
				fResult=TRUE;
			}
		}
		else
		{
			/* Find last character in string */
			if (pchLastChar<pchWrite)
			{
				pchLastChar++;
			}

			/* Check if last char is white space. */
			if (isXMLWhiteSpace(*pchLastChar))
			{
				fResult=TRUE;
			}
		}
	}

	/* Set new termination character */
	*pchWrite=0;

	return fResult;
}


/* Byte version */
BOOL WML_TrimTextBYTE (BYTE *pbText, UINT8 iMode)
{
	BYTE *pbRead=NULL;
	BYTE *pbWrite=NULL;
	BYTE *pbLastChar=NULL;
	BOOL fSpaceFound=FALSE;
	BOOL fResult=FALSE;

	if (pbText==NULL)
	{
		return FALSE;
	}

	pbWrite=pbText;
	pbRead=pbText;

	/* Trim left? */
	if ((iMode)&(TRIMTEXT_LEFT))
	{
		BOOL fSpaceFound=TRUE;

		/* Find first non-white space char */
		while ((*pbRead!=0)&&(fSpaceFound))
		{
			if (B_isXMLWhiteSpace(*pbRead))
			{
				/* Do not step write pos */
				pbRead++;
			}
			else
			{
				/* Not white space */
				fSpaceFound=FALSE;
			}
		}
	}

	pbLastChar=pbWrite;

	/* Remove insignificant white spaces */
	while (*pbRead!=0)
	{
		if (B_isXMLWhiteSpace(*pbRead))
		{
			/* All white spaces -> x20 */
			*pbRead=(BYTE)('\x20');

			if (fSpaceFound)
			{
				/* Do not step write pos */
				pbRead++;
			}
			else
			{
				fSpaceFound=TRUE;
				*pbWrite++=*pbRead++;
			}
		}
		else
		{
			pbLastChar=pbWrite;

			/* Not white space - write */
			*pbWrite++=*pbRead++;
			fSpaceFound=FALSE;
		}
	}

	/* Trim right? */
	if ((iMode)&(TRIMTEXT_RIGHT))
	{
		if (B_isXMLWhiteSpace(*pbLastChar))
		{
			*pbLastChar=0;
		}
		else if (!*pbLastChar++==0)
		{
			*pbLastChar=0;
		}
	}
	else
	{
		/* Check if last char is white space.
		   (For not LEFT)
		*/
		if (B_isXMLWhiteSpace(*pbLastChar))
		{
			if (!((iMode)&(TRIMTEXT_LEFT)))
			{
				fResult=TRUE;
			}
		}
		else
		{
			/* Find last character in string */
			if (pbLastChar<pbWrite)
			{
				pbLastChar++;
			}

			/* Check if last char is white space. */
			if (B_isXMLWhiteSpace(*pbLastChar))
			{
				fResult=TRUE;
			}
		}
	}

	/* Set new termination character */
	*pbWrite=0;

	return fResult;
}


/*========================================================================
	WML_GetTextEncodForm 
==========================================================================*/
INT16 WML_GetTextEncodForm (pUA pUser) 
{
	if (pUser!=NULL)
	{
		return (pUser->iTextEncodFormat);
	}
	return 0;
}




/*========================================================================
	WML_GetString
==========================================================================*/
WCHAR* WML_GetString (pUA pUser, pELEMENTTYPE pElement)
{
	UINT32 iLength=0;
	WCHAR* pwchString=NULL;
	WCHAR* pwchTemp=NULL;
	WCHAR* pwchExt=N