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);}