csmacred.c

www工具包

PRIVATE TargetObject_t Enum_targetObject = {"Enum", &Enum_open, &Enum_close, &Enum_destroy, Enum_stateTokens, raysize(Enum_stateTokens), CSMRTC_ENUM};

/* CSParse_doc end */
/* S T A T E   A S S O C I A T I O N - associate a CSMachRead with the label list data 
   The label list data is kept around until all states referencing it are destroyed */
typedef struct {
    CSMachRead_t * pCSMachRead;
    CSMachReadData_t * pCSMachReadData;
    } CSMachReadAssoc_t;

PRIVATE HTList * CSMachReadAssocs = 0;

PRIVATE void CSMachReadAssoc_add(CSMachRead_t * pCSMachRead, CSMachReadData_t * pCSMachReadData)
{
    CSMachReadAssoc_t * pElement;
    if ((pElement = (CSMachReadAssoc_t *) HT_CALLOC(1, sizeof(CSMachReadAssoc_t))) == NULL)
        HT_OUTOFMEM("CSMachReadAssoc_t");
    pElement->pCSMachRead = pCSMachRead;
    pElement->pCSMachReadData = pCSMachReadData;
    if (!CSMachReadAssocs)
        CSMachReadAssocs = HTList_new();
    HTList_appendObject(CSMachReadAssocs, (void *)pElement);
}

PRIVATE CSMachReadAssoc_t * CSMachReadAssoc_findByData(CSMachReadData_t * pCSMachReadData)
{
    HTList * assocs = CSMachReadAssocs;
    CSMachReadAssoc_t * pElement;
    while ((pElement = (CSMachReadAssoc_t *) HTList_nextObject(assocs)))
        if (pElement->pCSMachReadData == pCSMachReadData)
            return pElement;
    return 0;
}

PRIVATE CSMachReadAssoc_t * CSMachReadAssoc_findByState(CSMachRead_t * pCSMachRead)
{
    HTList * assocs = CSMachReadAssocs;
    CSMachReadAssoc_t * pElement;
    while ((pElement = (CSMachReadAssoc_t *) HTList_nextObject(assocs)))
        if (pElement->pCSMachRead == pCSMachRead)
            return pElement;
    return 0;
}

PRIVATE void CSMachReadAssoc_removeByState(CSMachRead_t * pCSMachRead)
{
    CSMachReadAssoc_t * pElement = CSMachReadAssoc_findByState(pCSMachRead);
    if (!pElement)
        return;
    HTList_removeObject(CSMachReadAssocs, (void *)pElement);
    HT_FREE(pElement);
}

/* C O N S T R U C T O R S / D E S T R U C T O R S */
PRIVATE MachRead_enum_t * MachRead_enum_new(void)
{
	MachRead_enum_t * me;
	if ((me = (MachRead_enum_t *) HT_CALLOC(1, sizeof(MachRead_enum_t))) == NULL)
	    HT_OUTOFMEM("MachRead_enum_t");
    return me;
}

PUBLIC void MachRead_enum_free(MachRead_enum_t * me)
{
    SVal_clear(&me->name);
    SVal_clear(&me->description);
    FVal_clear(&me->value);
    SVal_clear(&me->icon);
}

PRIVATE MachRead_category_t * MachRead_category_new(void)
{
    MachRead_category_t * me;
    if ((me = (MachRead_category_t *) HT_CALLOC(1, sizeof(MachRead_category_t))) == NULL)
        HT_OUTOFMEM("MachRead_category_t");
    return me;
}

PUBLIC void MachRead_category_free(MachRead_category_t * me)
{
    MachRead_enum_t * pMachRead_enum;
    MachRead_category_t * pMachRead_category;
    while ((pMachRead_enum = (MachRead_enum_t *) HTList_removeLastObject(me->machRead_enums)))
        MachRead_enum_free(pMachRead_enum);
    while ((pMachRead_category = (MachRead_category_t *) HTList_removeLastObject(me->machRead_categories)))
        MachRead_category_free(pMachRead_category);
    HTList_delete(me->machRead_enums);
    HTList_delete(me->machRead_categories);
    SVal_clear(&me->transmit);
    SVal_clear(&me->icon);
    SVal_clear(&me->name);
    SVal_clear(&me->description);
    FVal_clear(&me->min);
    FVal_clear(&me->max);
    BVal_clear(&me->multi);
    BVal_clear(&me->unord);
    BVal_clear(&me->integer);
    BVal_clear(&me->labeled);
}

PUBLIC CSMachReadData_t * CSMachReadData_new(void)
{
    CSMachReadData_t * me;
    if ((me = (CSMachReadData_t *) HT_CALLOC(1, sizeof(CSMachReadData_t))) == NULL)
        HT_OUTOFMEM("CSMachReadData_t");
    me->machRead_categories = HTList_new();
    return me;
}

PUBLIC void CSMachReadData_free(CSMachReadData_t * me)
{
    MachRead_category_t * pMachRead_category;
    if (CSMachReadAssoc_findByData(me))
        return;
    while ((pMachRead_category = (MachRead_category_t *) HTList_removeLastObject(me->machRead_categories)))
        MachRead_category_free(pMachRead_category);
    FVal_clear(&me->version);
    SVal_clear(&me->system);
    SVal_clear(&me->service);
    SVal_clear(&me->icon);
    SVal_clear(&me->name);
    SVal_clear(&me->description);
    FVal_clear(&me->min);
    FVal_clear(&me->max);
    BVal_clear(&me->multi);
    BVal_clear(&me->unord);
    BVal_clear(&me->integer);
    BVal_clear(&me->labeled);
    HT_FREE(me);
}

PUBLIC CSMachRead_t * CSMachRead_new(CSMachReadData_t * pCSMachReadData, MachReadTargetCallback_t * pMachReadTargetCallback, 
								   MRErrorHandler_t * pMRErrorHandler)
{
    CSMachRead_t * me;
    if ((me = (CSMachRead_t *) HT_CALLOC(1, sizeof(CSMachRead_t))) == NULL)
        HT_OUTOFMEM("CSMachRead_t");
    me->pCSMachReadData = pCSMachReadData;
    me->pMachReadTargetCallback = pMachReadTargetCallback;
    me->pMRErrorHandler = pMRErrorHandler;
    CSMachReadAssoc_add(me, pCSMachReadData);
    return me;
}

PUBLIC CSMachRead_t * CSMachRead_copy(CSMachRead_t * old)
{
    CSMachRead_t * me;
    me = CSMachRead_new(old->pCSMachReadData, old->pMachReadTargetCallback, 
			old->pMRErrorHandler);
    memcpy(me, old, sizeof(CSMachRead_t));
    return me;
}

PUBLIC void CSMachRead_free(CSMachRead_t * me)
{
    CSMachReadData_t * pCSMachReadData = me->pCSMachReadData;
    CSMachReadAssoc_removeByState(me);
    HT_FREE(me);
    CSMachReadData_free(pCSMachReadData);
}

PUBLIC char * CSMachRead_getSystem(CSMachRead_t * me) {return SVal_value(&me->pCSMachReadData->system);}
PUBLIC char * CSMachRead_getService(CSMachRead_t * me) {return SVal_value(&me->pCSMachReadData->service);}
PUBLIC CSMachReadData_t * CSMachRead_getCSMachReadData(CSMachRead_t * me) {return me->pCSMachReadData;}
PUBLIC MachRead_category_t * CSMachRead_getMachReadCategory(CSMachRead_t * pCSMachRead) {return pCSMachRead->pCurrentMachRead_category;}
PUBLIC MachRead_enum_t * CSMachRead_getMachReadEnum(CSMachRead_t * pCSMachRead) {return pCSMachRead->pCurrentMachRead_enum;}

PUBLIC CSParse_t * CSParse_newMachRead(MachReadTargetCallback_t * pMachReadTargetCallback, 
				       MRErrorHandler_t * pMRErrorHandler)
{
    CSParse_t * me = CSParse_new();
    me->pParseContext->engineOf = &CSParse_targetParser;
    me->pParseContext->pTargetChangeCallback = &targetChangeCallback;
    me->pParseContext->pParseErrorHandler = &parseErrorHandler;
    me->target.pCSMachRead = CSMachRead_new(CSMachReadData_new(), pMachReadTargetCallback, pMRErrorHandler);
    me->pTargetObject = &MachRead_targetObject;
    me->currentSubState = SubState_N;
    return me;
}

PUBLIC CSMachRead_t * CSParse_getMachRead(CSParse_t * me)
{
    return (me->target.pCSMachRead);
}

PUBLIC BOOL CSParse_deleteMachRead(CSParse_t * pCSParse)
{
    CSMachRead_t * me = GetCSMachRead(pCSParse);
    CSMachReadData_free(CSMachRead_getCSMachReadData(me));
    CSMachRead_free(me);
    return YES;
}

/* P A R S I N G   H A N D L E R S */
PRIVATE StateRet_t targetChangeCallback(CSParse_t * pCSParse, TargetObject_t * pTargetObject, CSParseTC_t target, BOOL closed, void * pVoid)
{

    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pMachReadTargetCallback)
       	return (*pCSMachRead->pMachReadTargetCallback)(pCSMachRead, pCSParse, (CSMRTC_t)target, closed, pVoid);
    return StateRet_OK;
}

PRIVATE StateRet_t parseErrorHandler(CSParse_t * pCSParse, const char * token, char demark, StateRet_t errorCode)
{
	CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
	if (pCSMachRead->pMRErrorHandler)
		return (*pCSMachRead->pMRErrorHandler)(pCSMachRead, pCSParse, token, demark, errorCode);
  return errorCode;
}

/* CSParse_doc methods */
/* P A R S I N G   S T A T E   F U N C T I O N S */
PRIVATE StateRet_t postValueState(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);

    if (pCSMachRead->inDefault) {
        SETNEXTSTATE(&Default_targetObject, SubState_A);
	return StateRet_OK;
    }
    if (pCSMachRead->pCurrentMachRead_enum) {
	if (SVal_initialized(&pCSMachRead->pCurrentMachRead_enum->icon)) {
	    SETNEXTSTATE(&Enum_targetObject, SubState_I);
	    return StateRet_OK;
	}
	if (FVal_initialized(&pCSMachRead->pCurrentMachRead_enum->value)) {
	    SETNEXTSTATE(&Enum_targetObject, SubState_G);
	    return StateRet_OK;
	}
	if (SVal_initialized(&pCSMachRead->pCurrentMachRead_enum->description)) {
	    SETNEXTSTATE(&Enum_targetObject, SubState_E);
	    return StateRet_OK;
	}
        SETNEXTSTATE(&Enum_targetObject, SubState_C);
	return StateRet_OK;
      }
    if (pCSMachRead->pCurrentMachRead_category){
	SETNEXTSTATE(&Category_targetObject, SubState_B);
	return StateRet_OK;
    }
    SETNEXTSTATE(&MachRead_targetObject, SubState_D);
    return StateRet_OK;
}

PRIVATE StateRet_t Category_next(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_category) {
        SETNEXTSTATE(&Category_targetObject, SubState_F);
	return StateRet_OK;
    }
    SETNEXTSTATE(&Category_targetObject, SubState_H);
    return StateRet_OK;
}

PRIVATE StateRet_t Multi_setTrue(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_category) {
        BVal_set(&pCSMachRead->pCurrentMachRead_category->multi, YES);
    } else {
        BVal_set(&pCSMachRead->pCSMachReadData->multi, YES);
    }
    return postValueState(pCSParse, token, demark);
}

PRIVATE StateRet_t Unord_setTrue(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
    if (pCSMachRead->pCurrentMachRead_category) {
        BVal_set(&pCSMachRead->pCurrentMachRead_category->unord, YES);
    } else {
        BVal_set(&pCSMachRead->pCSMachReadData->unord, YES);
    }
    return postValueState(pCSParse, token, demark);
}

PRIVATE StateRet_t Integer_setTrue(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
	if (pCSMachRead->pCurrentMachRead_category) {
		BVal_set(&pCSMachRead->pCurrentMachRead_category->integer, YES);
	} else {
		BVal_set(&pCSMachRead->pCSMachReadData->integer, YES);
	}
	return postValueState(pCSParse, token, demark);
}

PRIVATE StateRet_t Labeled_setTrue(CSParse_t * pCSParse, char * token, char demark)
{
    CSMachRead_t * pCSMachRead = GetCSMachRead(pCSParse);
	if (pCSMachRead->pCurrentMachRead_category) {
		BVal_set(&pCSMachRead->pCurrentMachRead_category->labeled, YES);
	} else {
		BVal_set(&pCSMachRead->pCSMachReadData->labeled, YES);
	}
	return postValueState(pCSParse, token, demark);
}