csmacred.c

www工具包

PRIVATE StateRet_t Version_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
	if (!FVal_readVal(&pCSMachRead->pCSMachReadData->version, token))
		return StateRet_WARN_NO_MATCH;
	return StateRet_OK;
}

PRIVATE StateRet_t System_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
	if (!SVal_readVal(&pCSMachRead->pCSMachReadData->system, token))
		return StateRet_WARN_NO_MATCH;
	return StateRet_OK;
}

PRIVATE StateRet_t Service_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
	if (!SVal_readVal(&pCSMachRead->pCSMachReadData->service, token))
		return StateRet_WARN_NO_MATCH;
	return StateRet_OK;
}

PRIVATE StateRet_t Icon_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
	SVal_t * pSVal;
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_enum)
		pSVal = &pCSMachRead->pCurrentMachRead_enum->icon;
    else if (pCSMachRead->pCurrentMachRead_category)
		pSVal = &pCSMachRead->pCurrentMachRead_category->icon;
	else
		pSVal = &pCSMachRead->pCSMachReadData->icon;
	if (!SVal_readVal(pSVal, token))
		return StateRet_WARN_NO_MATCH;
	return StateRet_OK;
}

PRIVATE StateRet_t Name_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
	SVal_t * pSVal;
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_enum)
		pSVal = &pCSMachRead->pCurrentMachRead_enum->name;
    else if (pCSMachRead->pCurrentMachRead_category)
		pSVal = &pCSMachRead->pCurrentMachRead_category->name;
	else
		pSVal = &pCSMachRead->pCSMachReadData->name;
	if (!SVal_readVal(pSVal, token))
		return StateRet_WARN_NO_MATCH;
	return StateRet_OK;
}

PRIVATE StateRet_t Description_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
	SVal_t * pSVal;
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_enum)
		pSVal = &pCSMachRead->pCurrentMachRead_enum->description;
    else if (pCSMachRead->pCurrentMachRead_category)
		pSVal = &pCSMachRead->pCurrentMachRead_category->description;
	else
		pSVal = &pCSMachRead->pCSMachReadData->description;
	if (!SVal_readVal(pSVal, token))
		return StateRet_WARN_NO_MATCH;
	return StateRet_OK;
}

PRIVATE StateRet_t Min_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
	FVal_t * pFVal;
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_category)
		pFVal = &pCSMachRead->pCurrentMachRead_category->min;
	else
		pFVal = &pCSMachRead->pCSMachReadData->min;
	if (!FVal_readVal(pFVal, token))
		return StateRet_WARN_NO_MATCH;
	return StateRet_OK;
}

PRIVATE StateRet_t Max_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
	FVal_t * pFVal;
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_category)
		pFVal = &pCSMachRead->pCurrentMachRead_category->max;
	else
		pFVal = &pCSMachRead->pCSMachReadData->max;
	if (!FVal_readVal(pFVal, token))
		return StateRet_WARN_NO_MATCH;
	return StateRet_OK;
}

PRIVATE StateRet_t Multi_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
	BVal_t * pBVal;
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_category)
		pBVal = &pCSMachRead->pCurrentMachRead_category->multi;
	else
		pBVal = &pCSMachRead->pCSMachReadData->multi;
	if (!BVal_readVal(pBVal, token))
		return StateRet_WARN_NO_MATCH;
	return StateRet_OK;
}

PRIVATE StateRet_t Unord_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
	BVal_t * pBVal;
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_category)
		pBVal = &pCSMachRead->pCurrentMachRead_category->unord;
	else
		pBVal = &pCSMachRead->pCSMachReadData->unord;
	if (!BVal_readVal(pBVal, token))
		return StateRet_WARN_NO_MATCH;
	return StateRet_OK;
}

PRIVATE StateRet_t Integer_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
	BVal_t * pBVal;
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_category)
		pBVal = &pCSMachRead->pCurrentMachRead_category->integer;
	else
		pBVal = &pCSMachRead->pCSMachReadData->integer;
	if (!BVal_readVal(pBVal, token))
		return StateRet_WARN_NO_MATCH;
	return StateRet_OK;
}


PRIVATE StateRet_t Labeled_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    BVal_t * pBVal;
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_category)
        pBVal = &pCSMachRead->pCurrentMachRead_category->labeled;
    else
        pBVal = &pCSMachRead->pCSMachReadData->labeled;
    if (!BVal_readVal(pBVal, token))
        return StateRet_WARN_NO_MATCH;
    return StateRet_OK;
}

PRIVATE StateRet_t Transmit_as_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (!SVal_readVal(&pCSMachRead->pCurrentMachRead_category->transmit, token))
        return StateRet_WARN_NO_MATCH;
    return StateRet_OK;
}

PRIVATE StateRet_t Value_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (!FVal_readVal(&pCSMachRead->pCurrentMachRead_enum->value, token))
        return StateRet_WARN_NO_MATCH;
    return StateRet_OK;
}

PRIVATE StateRet_t MachRead_open(CSParse_t * pCSParse, char * token, char demark)
{
    return StateRet_OK;
}

PRIVATE StateRet_t Category_open(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    MachRead_category_t * me = MachRead_category_new();
    me->pParent = pCSMachRead->pCurrentMachRead_category;
    pCSMachRead->pCurrentMachRead_category = me;
    HTList_appendObject(pCSMachRead->pCSMachReadData->machRead_categories, (void *)me);
    return StateRet_OK;
}

PRIVATE StateRet_t Default_open(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    pCSMachRead->inDefault = YES;
    return StateRet_OK;
}

PRIVATE StateRet_t Enum_open(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    MachRead_enum_t * me = MachRead_enum_new();
    pCSMachRead->pCurrentMachRead_enum = me;
    if (!pCSMachRead->pCurrentMachRead_category->machRead_enums)
        pCSMachRead->pCurrentMachRead_category->machRead_enums = HTList_new();
    HTList_appendObject(pCSMachRead->pCurrentMachRead_category->machRead_enums, (void *)me);
    return StateRet_OK;
}

PRIVATE StateRet_t MachRead_close(CSParse_t * pCSParse, char * token, char demark)
{
	return StateRet_DONE;
}

PRIVATE StateRet_t Category_close(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    pCSMachRead->pCurrentMachRead_category = pCSMachRead->pCurrentMachRead_category->pParent;
    return StateRet_OK;
}

PRIVATE StateRet_t Default_close(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    pCSMachRead->inDefault = NO;
    return StateRet_OK;
}

PRIVATE StateRet_t Enum_close(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    pCSMachRead->pCurrentMachRead_enum = 0;
    return StateRet_OK;
}

PRIVATE void MachRead_destroy(CSParse_t * pCSParse)
{
}

PRIVATE void Category_destroy(CSParse_t * pCSParse)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    HTList_removeObject(pCSMachRead->pCurrentMachRead_category->machRead_categories, (void *)pCSMachRead->pCurrentMachRead_category);
    MachRead_category_free(pCSMachRead->pCurrentMachRead_category);
    pCSMachRead->pCurrentMachRead_category = 0;
}

PRIVATE void Default_destroy(CSParse_t * pCSParse)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    pCSMachRead->inDefault = NO;
}

PRIVATE void Enum_destroy(CSParse_t * pCSParse)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    HTList_removeObject(pCSMachRead->pCurrentMachRead_category->machRead_enums, (void *)pCSMachRead->pCurrentMachRead_enum);
	if (!HTList_count(pCSMachRead->pCurrentMachRead_category->machRead_enums)) {
        HTList_delete(pCSMachRead->pCurrentMachRead_category->machRead_enums);
        pCSMachRead->pCurrentMachRead_category->machRead_enums = 0;
    }
    MachRead_enum_free(pCSMachRead->pCurrentMachRead_enum);
    pCSMachRead->pCurrentMachRead_enum = 0;
}

/* CSParse_doc end */
/* I T E R A T O R S - scan through the CSMachRead data structures for <identifier>
 */
PUBLIC CSError_t CSMachRead_iterateCategories(CSMachRead_t * pCSMachRead, CSMachRead_callback_t * pIteratorCB, State_Parms_t * pParms, const char * identifier, void * pVoid)
{
    HTList * machRead_categories;
    CSError_t ret = CSError_OK;
    int count = 0;
    if (!pIteratorCB ||
        !pCSMachRead ||
        !pCSMachRead->pCSMachReadData->machRead_categories)
        return CSError_BAD_PARAM;
    machRead_categories = pCSMachRead->pCSMachReadData->machRead_categories;
	while ((pCSMachRead->pCurrentMachRead_category = (MachRead_category_t *) HTList_nextObject(machRead_categories)) && ret == CSError_OK)
        if (!identifier || !strcasecomp(SVal_value(&pCSMachRead->pCurrentMachRead_category->transmit), identifier)) {
            ret = (*pIteratorCB)(pCSMachRead, pParms, identifier, pVoid) != CSError_OK;
            count++;
        }
    if (!count)
        return CSError_CATEGORY_MISSING;
    return ret;
}

PUBLIC CSError_t CSMachRead_iterateEnums(CSMachRead_t * pCSMachRead, CSMachRead_callback_t * pIteratorCB, State_Parms_t * pParms, const char * identifier, void * pVoid)
{
    HTList * machRead_enums;
    CSError_t ret = CSError_OK;
    int count = 0;
    if (!pIteratorCB ||
        !pCSMachRead ||
        !pCSMachRead->pCurrentMachRead_category ||
        !pCSMachRead->pCurrentMachRead_category->machRead_enums)
        return CSError_BAD_PARAM;
    machRead_enums = pCSMachRead->pCurrentMachRead_category->machRead_enums;
	while ((pCSMachRead->pCurrentMachRead_enum = (MachRead_enum_t *) HTList_nextObject(machRead_enums)) && ret == CSError_OK)
        if (!identifier || !strcasecomp(SVal_value(&pCSMachRead->pCurrentMachRead_enum->name), identifier)) {
            ret = (*pIteratorCB)(pCSMachRead, pParms, identifier, pVoid) != CSError_OK;
            count++;
        }
    if (!count)
        return CSError_ENUM_MISSING;
    return ret;
}