mgrutil.c

SyncML ToolKits,学习syncml的参考工具包.非常好用.

    if (p->cmdID == NULL) {
        smlFreeAtomic(p);
        return NULL;
    }
    return p;
}

SML_API SmlSequencePtr_t smlAllocSequence() {
    SmlSequencePtr_t p = smlAllocAtomic();
    if (p == NULL) return NULL;
    p->elementType = SML_PE_SEQUENCE_START;
    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;
}

#if defined(EXEC_SEND) || defined(EXEC_RECEIVE)
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;
}
#endif

SML_API SmlGetPtr_t smlAllocGet() {
    SmlGetPtr_t p = (SmlGetPtr_t)smlLibMalloc(sizeof(SmlGet_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlGet_t));
    p->elementType = SML_PE_GET;
    p->cmdID = smlAllocPcdata();
    if (p->cmdID == NULL) {
        smlFreeGetPut(p);
        return NULL;
    }
    p->itemList = smlAllocItemList();
    if (p->itemList == NULL) {
        smlFreeGetPut(p);
        return NULL;
    }
    return p;
}

SML_API SmlPutPtr_t smlAllocPut() {
    SmlPutPtr_t p = smlAllocGet();
    if (p == NULL) return NULL;
    p->elementType = SML_PE_PUT;
    return p;
}

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 SmlMapItemListPtr_t smlAllocMapItemList() {
    SmlMapItemListPtr_t p = (SmlMapItemListPtr_t)smlLibMalloc(sizeof(SmlMapItemList_t));
    if (p == 0) return NULL;
    smlLibMemset(p, 0, sizeof(SmlMapItemList_t));
    p->mapItem = smlAllocMapItem();
    if (p->mapItem == NULL) {
        smlFreeMapItemList(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;
}

SML_API SmlResultsPtr_t smlAllocResults() {
    SmlResultsPtr_t p = (SmlResultsPtr_t)smlLibMalloc(sizeof(SmlResults_t));
    if (p == 0) return NULL;
    smlLibMemset(p, 0, sizeof(SmlResults_t));
    p->elementType = SML_PE_RESULTS;
    p->cmdID = smlAllocPcdata();
    if (p->cmdID == NULL) {
        smlFreeResults(p);
        return NULL;
    }
    p->cmdRef = smlAllocPcdata();
    if (p->cmdRef == NULL) {
        smlFreeResults(p);
        return NULL;
    }
    p->itemList = smlAllocItemList();
    if (p->itemList == NULL) {
        smlFreeResults(p);
        return NULL;
    }
    return p;
}

#if (defined SEARCH_SEND || defined SEARCH_RECEIVE)

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;
}
#endif

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 SmlSourceRefListPtr_t smlAllocSourceRefList() {
    SmlSourceRefListPtr_t p = (SmlSourceRefListPtr_t)smlLibMalloc(sizeof(SmlSourceRefList_t));
    if (p == 0) return NULL;
    smlLibMemset(p, 0, sizeof(SmlSourceRefList_t));
    p->sourceRef = smlAllocPcdata();
    if (p->sourceRef == NULL) {
        smlFreeSourceRefList(p);
        return NULL;
    }
    return p;
}

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 SmlUnknownProtoElementPtr_t smlAllocUnknownProtoElement() {
    SmlUnknownProtoElementPtr_t p = (SmlUnknownProtoElementPtr_t)smlLibMalloc(sizeof(SmlUnknownProtoElement_t));
    if (p == 0) return NULL;
    smlLibMemset(p, 0, sizeof(SmlUnknownProtoElement_t));
    p->elementType = SML_PE_UNDEF;
    return p;
}

#ifdef __USE_METINF__
SML_API SmlMetInfMetInfPtr_t smlAllocMetInfMetInf() {
    SmlMetInfMetInfPtr_t p = (SmlMetInfMetInfPtr_t)smlLibMalloc(sizeof(SmlMetInfMetInf_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlMetInfMetInf_t));
    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 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;
}
#endif

#ifdef __USE_DEVINF__
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 SmlDevInfExtListPtr_t smlAllocDevInfExtList() {
    SmlDevInfExtListPtr_t p = (SmlDevInfExtListPtr_t)smlLibMalloc(sizeof(SmlDevInfExtList_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlDevInfExtList_t));
    p->data = smlAllocDevInfExt();
    if (p->data == NULL) {
        smlFreeDevInfExtList(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 SmlDevInfCTDataPtr_t smlAllocDevInfCTData() {
    SmlDevInfCTDataPtr_t p = (SmlDevInfCTDataPtr_t)smlLibMalloc(sizeof(SmlDevInfCTData_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlDevInfCTData_t));
    p->name = smlAllocPcdata();
    if (p->name == NULL) {
        smlFreeDevInfCTData(p);
        return NULL;
    }
    return p;
}

SML_API SmlDevInfCTDataListPtr_t smlAllocDevInfCTDataList() {
    SmlDevInfCTDataListPtr_t p = (SmlDevInfCTDataListPtr_t)smlLibMalloc(sizeof(SmlDevInfCTDataList_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlDevInfCTDataList_t));
    p->data = smlAllocDevInfCTData();
    if (p->data == NULL) {
        smlFreeDevInfCTDataList(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 SmlDevInfCTDataPropListPtr_t smlAllocDevInfCTDataPropList() {
    SmlDevInfCTDataPropListPtr_t p = (SmlDevInfCTDataPropListPtr_t)smlLibMalloc(sizeof(SmlDevInfCTDataPropList_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlDevInfCTDataPropList_t));
    p->data = smlAllocDevInfCTDataProp();
    if (p->data == NULL) {
        smlFreeDevInfCTDataPropList(p);
        return NULL;
    }
    return p;
}

SML_API SmlDevInfCTCapPtr_t smlAllocDevInfCTCap() {
    SmlDevInfCTCapPtr_t p = (SmlDevInfCTCapPtr_t)smlLibMalloc(sizeof(SmlDevInfCTCap_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlDevInfCTCap_t));
    p->cttype = smlAllocPcdata();
    if (p->cttype == NULL) {
        smlFreeDevInfCTCap(p);
        return NULL;
    }
    p->prop = smlAllocDevInfCTDataPropList();
    if (p->prop == NULL) {
        smlFreeDevInfCTCap(p);
        return NULL;
    }
    return p;
}

SML_API SmlDevInfCtcapListPtr_t smlAllocDevInfCtcapList() {
    SmlDevInfCtcapListPtr_t p = (SmlDevInfCtcapListPtr_t)smlLibMalloc(sizeof(SmlDevInfCtcapList_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlDevInfCtcapList_t));
    p->data = smlAllocDevInfCTCap();
    if (p->data == NULL) {
        smlFreeDevInfCtcapList(p);
        return NULL;
    }
    return p;
}

SML_API SmlDevInfDSMemPtr_t smlAllocDevInfDSMem() {
    SmlDevInfDSMemPtr_t p = (SmlDevInfDSMemPtr_t)smlLibMalloc(sizeof(SmlDevInfDSMem_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlDevInfDSMem_t));
    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 SmlDevInfXmitListPtr_t smlAllocDevInfXmitList() {
    SmlDevInfXmitListPtr_t p = (SmlDevInfXmitListPtr_t)smlLibMalloc(sizeof(SmlDevInfXmitList_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlDevInfXmitList_t));
    p->data = smlAllocDevInfXmit();
    if (p->data == NULL) {
        smlFreeDevInfXmitList(p);
        return NULL;
    }
    return p;
}

SML_API SmlDevInfDatastorePtr_t smlAllocDevInfDatastore() {
    SmlDevInfDatastorePtr_t p = (SmlDevInfDatastorePtr_t)smlLibMalloc(sizeof(SmlDevInfDatastore_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlDevInfDatastore_t));
    p->sourceref = smlAllocPcdata();
    if (p->sourceref == NULL) {
        smlFreeDevInfDatastore(p);
        return NULL;
    }
    p->rxpref = smlAllocDevInfXmit();
    if (p->rxpref == NULL) {
        smlFreeDevInfDatastore(p);
        return NULL;
    }
    p->txpref = smlAllocDevInfXmit();
    if (p->txpref == NULL) {
        smlFreeDevInfDatastore(p);
        return NULL;
    }
    p->synccap = smlAllocDevInfSyncCap();
    if (p->synccap == NULL) {
        smlFreeDevInfDatastore(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 SmlDevInfDevInfPtr_t smlAllocDevInfDevInf() {
    SmlDevInfDevInfPtr_t p = (SmlDevInfDevInfPtr_t)smlLibMalloc(sizeof(SmlDevInfDevInf_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlDevInfDevInf_t));
    p->verdtd = smlAllocPcdata();
    if (p->verdtd == NULL) {
        smlFreeDevInfDevInf(p);
        return NULL;
    }
    p->devid = smlAllocPcdata();
    if (p->devid == NULL) {
        smlFreeDevInfDevInf(p);
        return NULL;
    }
    p->devtyp = smlAllocPcdata();
    if (p->devtyp == NULL) {
        smlFreeDevInfDevInf(p);
        return NULL;
    }
    p->datastore = smlAllocDevInfDatastoreList();
    if (p->verdtd == NULL) {
        smlFreeDevInfDevInf(p);
        return NULL;
    }
    p->ctcap = smlAllocDevInfCtcapList();
    if (p->ctcap == NULL) {
        smlFreeDevInfDevInf(p);
        return NULL;
    }
    p->ext = smlAllocDevInfExtList();
    if (p->ext == NULL) {
        smlFreeDevInfDevInf(p);
        return NULL;
    }

    return p;
}

#endif // DevInf
#endif // AllocFuncs