SML_API SmlStatusPtr_t smlAllocStatus() {
SmlStatusPtr_t p = (SmlStatusPtr_t)smlLibMalloc(sizeof(SmlStatus_t));
if (p == 0) return NULL;
smlLibMemset(p, 0, sizeof(SmlStatus_t));
p->elementType = SML_PE_STATUS;
p->cmdID = smlAllocPcdata();
if (p->cmdID == NULL) {
smlFreeStatus(p);
return NULL;
}
p->msgRef = smlAllocPcdata();
if (p->msgRef == NULL) {
smlFreeStatus(p);
return NULL;
}
p->cmdRef = smlAllocPcdata();
if (p->cmdRef == NULL) {
smlFreeStatus(p);
return NULL;
}
p->cmd = smlAllocPcdata();
if (p->cmd == NULL) {
smlFreeStatus(p);
return NULL;
}
p->data = smlAllocPcdata();
if (p->data == NULL) {
smlFreeStatus(p);
return NULL;
}
return p;
}
SML_API SmlSearchPtr_t smlAllocSearch() {
SmlSearchPtr_t p = (SmlSearchPtr_t)smlLibMalloc(sizeof(SmlSearch_t));
if (p == 0) return NULL;
smlLibMemset(p, 0, sizeof(SmlSearch_t));
p->elementType = SML_PE_SEARCH;
p->cmdID = smlAllocPcdata();
if (p->cmdID == NULL) {
smlFreeSearch(p);
return NULL;
}
p->meta = smlAllocPcdata();
if (p->meta == NULL) {
smlFreeSearch(p);
return NULL;
}
p->data = smlAllocPcdata();
if (p->data == NULL) {
smlFreeSearch(p);
return NULL;
}
p->sourceList = smlAllocSourceList();
if (p->sourceList == NULL) {
smlFreeSearch(p);
return NULL;
}
return p;
}
SML_API SmlMapPtr_t smlAllocMap() {
SmlMapPtr_t p = (SmlMapPtr_t)smlLibMalloc(sizeof(SmlMap_t));
if (p == 0) return NULL;
smlLibMemset(p, 0, sizeof(SmlMap_t));
p->elementType = SML_PE_MAP;
p->cmdID = smlAllocPcdata();
if (p->cmdID == NULL) {
smlFreeMap(p);
return NULL;
}
p->target = smlAllocTarget();
if (p->target == NULL) {
smlFreeMap(p);
return NULL;
}
p->source = smlAllocSource();
if (p->source == NULL) {
smlFreeMap(p);
return NULL;
}
p->mapItemList = smlAllocMapItemList();
if (p->mapItemList == NULL) {
smlFreeMap(p);
return NULL;
}
return p;
}
/* decoder callbacks */
Ret_t buildDmTndCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem)
{
XltDecScannerPtr_t pScanner;
SmlDmTndPtr_t pDmTnd;
Ret_t rc;
pScanner = pDecoder->scanner;
if (*ppElem != NULL)
return SML_ERR_XLT_INVAL_SYNCML_DOC;
if ((pDmTnd = (SmlDmTndPtr_t)smlLibMalloc(sizeof(SmlDmTnd_t))) == NULL)
return SML_ERR_NOT_ENOUGH_SPACE;
smlLibMemset(pDmTnd, 0, sizeof(SmlDmTnd_t));
if (IS_EMPTY(pScanner->curtok)) {
*ppElem = pDmTnd;
return SML_ERR_OK;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlFreeDmTnd(pDmTnd);
return rc;
}
while (pScanner->curtok->type != TOK_TAG_END) {
switch (pScanner->curtok->tagid) {
case TN_DMTND_MgmtTree:
break;
case TN_DMTND_VerDTD:
rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTnd->verdtd);
break;
case TN_DMTND_Man:
rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTnd->man);
break;
case TN_DMTND_Mod:
rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTnd->mod);
break;
case TN_DMTND_Node:
rc = buildDmTndNodeList(pDecoder, (VoidPtr_t)&pDmTnd->nodelist);
break;
default:
KCDBG(">>>>> buildDmTndDFPropsCmd: Unkown token: %d <<<<<\n", pScanner->curtok->tagid);
rc = SML_ERR_XLT_INVAL_SYNCML_DOC;
}
if (rc != SML_ERR_OK) {
smlFreeDmTnd(pDmTnd);
return rc;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlFreeDmTnd(pDmTnd);
return rc;
}
}
*ppElem = pDmTnd;
return SML_ERR_OK;
}
/* decoder callbacks */
Ret_t buildDmTndTypeCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem)
{
XltDecScannerPtr_t pScanner;
SmlDmTndTypePtr_t pDmTndType;
Ret_t rc;
pScanner = pDecoder->scanner;
if (*ppElem != NULL)
return SML_ERR_XLT_INVAL_SYNCML_DOC;
if ((pDmTndType = (SmlDmTndTypePtr_t)smlLibMalloc(sizeof(SmlDmTndType_t))) == NULL)
return SML_ERR_NOT_ENOUGH_SPACE;
smlLibMemset(pDmTndType, 0, sizeof(SmlDmTndType_t));
if (IS_EMPTY(pScanner->curtok)) {
*ppElem = pDmTndType;
return SML_ERR_OK;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlFreeDmTndType(pDmTndType);
return rc;
}
while (pScanner->curtok->type != TOK_TAG_END) {
switch (pScanner->curtok->tagid) {
case TN_DMTND_MIME:
rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndType->mime);
break;
case TN_DMTND_DDFName:
rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndType->ddfname);
break;
default:
KCDBG(">>>>> Unkown token: %d <<<<<\n", pScanner->curtok->tagid);
rc = SML_ERR_XLT_INVAL_SYNCML_DOC;
}
if (rc != SML_ERR_OK) {
smlFreeDmTndType(pDmTndType);
return rc;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlFreeDmTndType(pDmTndType);
return rc;
}
if (pScanner->curtok->type != TOK_TAG_END) {
smlFreeDmTndType(pDmTndType);
return SML_ERR_XLT_INVAL_SYNCML_DOC;
}
}
*ppElem = pDmTndType;
return SML_ERR_OK;
}
Ret_t buildMetInfMemCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) {
XltDecScannerPtr_t pScanner;
SmlMetInfMemPtr_t pMem;
Ret_t rc;
pScanner = pDecoder->scanner;
if (*ppElem != NULL)
return SML_ERR_XLT_INVAL_SYNCML_DOC;
if ((pMem = (SmlMetInfMemPtr_t)smlLibMalloc(sizeof(SmlMetInfMem_t))) == NULL)
return SML_ERR_NOT_ENOUGH_SPACE;
smlLibMemset(pMem, 0, sizeof(SmlMetInfMem_t));
if (IS_EMPTY(pScanner->curtok)) {
*ppElem = pMem;
return SML_ERR_OK;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlFreeMetinfMem(pMem);
//smlLibFree(pMem);
return rc;
}
while (pScanner->curtok->type != TOK_TAG_END) {
switch (pScanner->curtok->tagid) {
/* PCDATA elements */
case TN_METINF_SHAREDMEM:
rc = buildPCData(pDecoder, (VoidPtr_t)&pMem->shared);
break;
case TN_METINF_FREEMEM:
rc = buildPCData(pDecoder, (VoidPtr_t)&pMem->free);
break;
case TN_METINF_FREEID:
rc = buildPCData(pDecoder, (VoidPtr_t)&pMem->freeid);
break;
default:
rc = SML_ERR_XLT_INVAL_SYNCML_DOC;
}
if (rc != SML_ERR_OK) {
smlFreeMetinfMem(pMem);
//smlLibFree(pMem);
return rc;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlFreeMetinfMem(pMem);
//smlLibFree(pMem);
return rc;
}
}
*ppElem = pMem;
return SML_ERR_OK;
}
Ret_t buildDevInfDSMemCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) {
XltDecScannerPtr_t pScanner;
SmlDevInfDSMemPtr_t pElem;
Ret_t rc;
pScanner = pDecoder->scanner;
if (*ppElem != NULL)
return SML_ERR_XLT_INVAL_SYNCML_DOC;
if ((pElem = (SmlDevInfDSMemPtr_t)smlLibMalloc(sizeof(SmlDevInfDSMem_t))) == NULL)
return SML_ERR_NOT_ENOUGH_SPACE;
smlLibMemset(pElem, 0, sizeof(SmlDevInfDSMem_t));
if (IS_EMPTY(pScanner->curtok)) {
*ppElem = pElem;
return SML_ERR_OK;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlLibFree(pElem);
return rc;
}
while (pScanner->curtok->type != TOK_TAG_END) {
switch (pScanner->curtok->tagid) {
/* PCDATA elements */
case TN_DEVINF_SHAREDMEM:
// %%% luz:2003-04-28: made work as a flag
pElem->flags |= SmlDevInfSharedMem_f;
// rc = buildPCData(pDecoder, (VoidPtr_t)&pElem->shared);
break;
case TN_DEVINF_MAXMEM:
rc = buildPCData(pDecoder, (VoidPtr_t)&pElem->maxmem);
break;
case TN_DEVINF_MAXID:
rc = buildPCData(pDecoder, (VoidPtr_t)&pElem->maxid);
break;
default:
rc = SML_ERR_XLT_INVAL_SYNCML_DOC;
}
if (rc != SML_ERR_OK) {
smlLibFree(pElem);
return rc;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlLibFree(pElem);
return rc;
}
}
*ppElem = pElem;
return SML_ERR_OK;
}
SML_API SmlDevInfExtPtr_t smlAllocDevInfExt() {
SmlDevInfExtPtr_t p = (SmlDevInfExtPtr_t)smlLibMalloc(sizeof(SmlDevInfExt_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlDevInfExt_t));
p->xnam = smlAllocPcdata();
if (p->xnam == NULL) {
smlFreeDevInfExt(p);
return NULL;
}
return p;
}
SML_API SmlDevInfCTDataPropPtr_t smlAllocDevInfCTDataProp() {
SmlDevInfCTDataPropPtr_t p = (SmlDevInfCTDataPropPtr_t)smlLibMalloc(sizeof(SmlDevInfCTDataProp_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlDevInfCTDataProp_t));
p->prop = smlAllocDevInfCTData();
if (p->prop == NULL) {
smlFreeDevInfCTDataProp(p);
return NULL;
}
return p;
}
SML_API SmlCredPtr_t smlAllocCred() {
SmlCredPtr_t p = (SmlCredPtr_t)smlLibMalloc(sizeof(SmlCred_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlCred_t));
p->data = smlAllocPcdata();
if (p->data == NULL) {
smlFreeCredPtr(p);
return NULL;
}
return p;
}
SML_API SmlSourcePtr_t smlAllocSource() {
SmlSourcePtr_t p = (SmlSourcePtr_t)smlLibMalloc(sizeof(SmlSource_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlSource_t));
p->locURI = smlAllocPcdata();
if (p->locURI == NULL) {
smlFreeSourceTargetPtr(p);
return NULL;
}
return p;
}
SML_API SmlDevInfSyncCapPtr_t smlAllocDevInfSyncCap() {
SmlDevInfSyncCapPtr_t p = (SmlDevInfSyncCapPtr_t)smlLibMalloc(sizeof(SmlDevInfSyncCap_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlDevInfSyncCap_t));
p->synctype = smlAllocPcdataList();
if (p->synctype == NULL) {
smlFreeDevInfSynccap(p);
return NULL;
}
return p;
}
SML_API SmlMetInfAnchorPtr_t smlAllocMetInfAnchor() {
SmlMetInfAnchorPtr_t p = (SmlMetInfAnchorPtr_t)smlLibMalloc(sizeof(SmlMetInfAnchor_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlMetInfAnchor_t));
p->next = smlAllocPcdata();
if (p->next == NULL) {
smlFreeMetinfAnchor(p);
return NULL;
}
return p;
}
SML_API SmlSourceListPtr_t smlAllocSourceList() {
SmlSourceListPtr_t p = (SmlSourceListPtr_t)smlLibMalloc(sizeof(SmlSourceList_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlSourceList_t));
p->source = smlAllocSource();
if (p->source == NULL) {
smlFreeSourceList(p);
return NULL;
}
return p;
}
SML_API SmlItemListPtr_t smlAllocItemList() {
SmlItemListPtr_t p = (SmlItemListPtr_t)smlLibMalloc(sizeof(SmlItemList_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlItemList_t));
p->item = smlAllocItem();
if (p->item == NULL) {
smlFreeItemList(p);
return NULL;
}
return p;
}
SML_API SmlTargetRefListPtr_t smlAllocTargetRefList() {
SmlTargetRefListPtr_t p = (SmlTargetRefListPtr_t)smlLibMalloc(sizeof(SmlTargetRefList_t));
if (p == 0) return NULL;
smlLibMemset(p, 0, sizeof(SmlTargetRefList_t));
p->targetRef = smlAllocPcdata();
if (p->targetRef == NULL) {
smlFreeTargetRefList(p);
return NULL;
}
return p;
}
SML_API SmlPcdataListPtr_t smlAllocPcdataList() {
SmlPcdataListPtr_t p = (SmlPcdataListPtr_t)smlLibMalloc(sizeof(SmlPcdataList_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlPcdataList_t));
p->data = smlAllocPcdata();
if (p->data == NULL) {
smlFreePcdataList(p);
return NULL;
}
return p;
}
SML_API SmlDevInfDatastoreListPtr_t smlAllocDevInfDatastoreList() {
SmlDevInfDatastoreListPtr_t p = (SmlDevInfDatastoreListPtr_t)smlLibMalloc(sizeof(SmlDevInfDatastoreList_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlDevInfDatastoreList_t));
p->data = smlAllocDevInfDatastore();
if (p->data == NULL) {
smlFreeDevInfDatastoreList(p);
return NULL;
}
return p;
}
SML_API SmlSyncPtr_t smlAllocSync() {
SmlSyncPtr_t p = (SmlSyncPtr_t)smlLibMalloc(sizeof(SmlSync_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlSync_t));
p->elementType = SML_PE_SYNC_START;
p->cmdID = smlAllocPcdata();
if (p->cmdID == NULL) {
smlFreeSync(p);
return NULL;
}
return p;
}
/* decoder callbacks */
Ret_t buildMetInfAnchorCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) {
XltDecScannerPtr_t pScanner;
SmlMetInfAnchorPtr_t pAnchor;
Ret_t rc;
pScanner = pDecoder->scanner;
if (*ppElem != NULL)
return SML_ERR_XLT_INVAL_SYNCML_DOC;
if ((pAnchor = (SmlMetInfAnchorPtr_t)smlLibMalloc(sizeof(SmlMetInfAnchor_t))) == NULL)
return SML_ERR_NOT_ENOUGH_SPACE;
smlLibMemset(pAnchor, 0, sizeof(SmlMetInfAnchor_t));
if (IS_EMPTY(pScanner->curtok)) {
*ppElem = pAnchor;
return SML_ERR_OK;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlFreeMetinfAnchor(pAnchor);
//smlLibFree(pAnchor);
return rc;
}
while (pScanner->curtok->type != TOK_TAG_END) {
switch (pScanner->curtok->tagid) {
/* PCDATA elements */
case TN_METINF_LAST:
rc = buildPCData(pDecoder, (VoidPtr_t)&pAnchor->last);
break;
case TN_METINF_NEXT:
rc = buildPCData(pDecoder, (VoidPtr_t)&pAnchor->next);
break;
default:
rc = SML_ERR_XLT_INVAL_SYNCML_DOC;
}
if (rc != SML_ERR_OK) {
smlFreeMetinfAnchor(pAnchor);
//smlLibFree(pAnchor);
return rc;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlFreeMetinfAnchor(pAnchor);
//smlLibFree(pAnchor);
return rc;
}
}
*ppElem = pAnchor;
return SML_ERR_OK;
}
Ret_t buildDevInfXmitCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) {
XltDecScannerPtr_t pScanner;
SmlDevInfXmitPtr_t pXmit;
Ret_t rc;
pScanner = pDecoder->scanner;
if (*ppElem != NULL)
return SML_ERR_XLT_INVAL_SYNCML_DOC;
if ((pXmit = (SmlDevInfXmitPtr_t)smlLibMalloc(sizeof(SmlDevInfXmit_t))) == NULL)
return SML_ERR_NOT_ENOUGH_SPACE;
smlLibMemset(pXmit, 0, sizeof(SmlDevInfXmit_t));
if (IS_EMPTY(pScanner->curtok)) {
*ppElem = pXmit;
return SML_ERR_OK;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlLibFree(pXmit);
return rc;
}
while (pScanner->curtok->type != TOK_TAG_END) {
switch (pScanner->curtok->tagid) {
/* PCDATA elements */
case TN_DEVINF_CTTYPE:
rc = buildPCData(pDecoder, (VoidPtr_t)&pXmit->cttype);
break;
case TN_DEVINF_VERCT:
rc = buildPCData(pDecoder, (VoidPtr_t)&pXmit->verct);
break;
default:
rc = SML_ERR_XLT_INVAL_SYNCML_DOC;
}
if (rc != SML_ERR_OK) {
smlLibFree(pXmit);
return rc;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlLibFree(pXmit);
return rc;
}
}
*ppElem = pXmit;
return SML_ERR_OK;
}
Ret_t buildDevInfExtCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) {
XltDecScannerPtr_t pScanner;
SmlDevInfExtPtr_t pElem;
Ret_t rc;
pScanner = pDecoder->scanner;
if (*ppElem != NULL)
return SML_ERR_XLT_INVAL_SYNCML_DOC;
if ((pElem = (SmlDevInfExtPtr_t)smlLibMalloc(sizeof(SmlDevInfExt_t))) == NULL)
return SML_ERR_NOT_ENOUGH_SPACE;
smlLibMemset(pElem, 0, sizeof(SmlDevInfExt_t));
if (IS_EMPTY(pScanner->curtok)) {
*ppElem = pElem;
return SML_ERR_OK;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlLibFree(pElem);
return rc;
}
while (pScanner->curtok->type != TOK_TAG_END) {
switch (pScanner->curtok->tagid) {
case TN_DEVINF_XNAM:
rc = buildPCData(pDecoder, (VoidPtr_t)&pElem->xnam);
break;
case TN_DEVINF_XVAL:
rc = buildPCDataList(pDecoder, (VoidPtr_t)&pElem->xval);
break;
default:
rc = SML_ERR_XLT_INVAL_SYNCML_DOC;
}
if (rc != SML_ERR_OK) {
smlLibFree(pElem);
return rc;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlLibFree(pElem);
return rc;
}
}
*ppElem = pElem;
return SML_ERR_OK;
}
SML_API SmlMapItemPtr_t smlAllocMapItem() {
SmlMapItemPtr_t p = (SmlMapItemPtr_t)smlLibMalloc(sizeof(SmlMapItem_t));
if (p == 0) return NULL;
smlLibMemset(p, 0, sizeof(SmlMapItem_t));
p->target = smlAllocTarget();
if (p->target == NULL) {
smlFreeMapItemPtr(p);
return NULL;
}
p->source = smlAllocSource();
if (p->source == NULL) {
smlFreeMapItemPtr(p);
return NULL;
}
return p;
}
SML_API SmlMetInfMemPtr_t smlAllocMetInfMem() {
SmlMetInfMemPtr_t p = (SmlMetInfMemPtr_t)smlLibMalloc(sizeof(SmlMetInfMem_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlMetInfMem_t));
p->free = smlAllocPcdata();
if (p->free == NULL) {
smlFreeMetinfMem(p);
return NULL;
}
p->freeid = smlAllocPcdata();
if (p->freeid == NULL) {
smlFreeMetinfMem(p);
return NULL;
}
return p;
}
SML_API SmlDevInfXmitPtr_t smlAllocDevInfXmit() {
SmlDevInfXmitPtr_t p = (SmlDevInfXmitPtr_t)smlLibMalloc(sizeof(SmlDevInfXmit_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlDevInfXmit_t));
p->cttype = smlAllocPcdata();
if (p->cttype == NULL) {
smlFreeDevInfXmit(p);
return NULL;
}
p->verct = smlAllocPcdata();
if (p->verct == NULL) {
smlFreeDevInfXmit(p);
return NULL;
}
return p;
}
SML_API SmlGenericCmdPtr_t smlAllocGeneric() {
SmlGenericCmdPtr_t p = (SmlGenericCmdPtr_t)smlLibMalloc(sizeof(SmlGenericCmd_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlGenericCmd_t));
p->elementType = SML_PE_GENERIC;
p->cmdID = smlAllocPcdata();
if (p->cmdID == NULL) {
smlFreeGeneric(p);
return NULL;
}
p->itemList = smlAllocItemList();
if (p->itemList == NULL) {
smlFreeGeneric(p);
return NULL;
}
return p;
}
SML_API SmlAlertPtr_t smlAllocAlert() {
SmlAlertPtr_t p = (SmlAlertPtr_t)smlLibMalloc(sizeof(SmlAlert_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlAlert_t));
p->elementType = SML_PE_ALERT;
p->cmdID = smlAllocPcdata();
if (p->cmdID == NULL) {
smlFreeAlert(p);
return NULL;
}
p->itemList = smlAllocItemList();
if (p->itemList == NULL) {
smlFreeAlert(p);
return NULL;
}
return p;
}
SML_API SmlExecPtr_t smlAllocExec() {
SmlExecPtr_t p = (SmlExecPtr_t)smlLibMalloc(sizeof(SmlExec_t));
if (p == NULL) return NULL;
smlLibMemset(p, 0, sizeof(SmlExec_t));
p->elementType = SML_PE_EXEC;
p->cmdID = smlAllocPcdata();
if (p->cmdID == NULL) {
smlFreeExec(p);
return NULL;
}
p->item = smlAllocItem();
if (p->item == NULL) {
smlFreeExec(p);
return NULL;
}
return p;
}
Ret_t buildDevInfExtList(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) {
SmlDevInfExtListPtr_t pElem = NULL, pPrev = NULL;
pElem = (SmlDevInfExtListPtr_t) *ppElem;
/* advance to the end of the list, and create ther an empty list element */
while (pElem != NULL) {
pPrev = pElem;
pElem = pPrev->next;
}
if ((pElem = (SmlDevInfExtListPtr_t)smlLibMalloc(sizeof(SmlDevInfExtList_t))) == NULL)
return SML_ERR_NOT_ENOUGH_SPACE;
smlLibMemset(pElem, 0, sizeof(SmlDevInfExtList_t));
if (pPrev != NULL) /* we already had some entries in the list */
pPrev->next = pElem;
else /* nope we created a new list */
*ppElem = pElem;
pElem->data = NULL;
/* at this point pElem should point to an valid list element */
return buildDevInfExtCmd(pDecoder, (VoidPtr_t)&pElem->data);
}
/**
* FUNCTION: smlString2Pcdata
*
* copy a string into a Pcdata structure
*
* IN: String_t
* Input String
*
* RETURN: SmlPcdataPtr_t
* A Pointer to a PcData structure
*
*/
SML_API SmlPcdataPtr_t smlString2Pcdata(String_t str)
{
/* Definitions */
SmlPcdataPtr_t pcdata;
/* Invalid Input */
if (! str)
return NULL;
/* Allocate the PcData Structure */
pcdata = (SmlPcdataPtr_t)smlLibMalloc((MemSize_t)sizeof(SmlPcdata_t));
if (! pcdata)
return NULL;
smlLibMemset (pcdata, 0, (MemSize_t)sizeof(SmlPcdata_t));
/* Set the PcData Structure */
pcdata->contentType = SML_PCDATA_STRING;
pcdata->length = smlLibStrlen( str );
pcdata->content = (VoidPtr_t)smlLibStrdup(str);
return pcdata;
}
