IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Dec 3, 2004, 1:19:07 PM (22 years ago)
Author:
harman
Message:

Updates for version 10 of SDRS

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/xml/psXML.c

    r2525 r2607  
    99*  @author Ross Harman, MHPCC
    1010*
    11 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2004-11-30 01:09:14 $
     11*  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     12*  @date $Date: 2004-12-03 23:14:40 $
    1313*
    1414*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    6060/** Free and null temporary variables used by config file parser */
    6161#define CLEAR_TEMPS()                                                                                        \
    62 if(strName) {                                                                                            \
    63     psFree(strName);                                                                                     \
    64     strName = NULL;                                                                                      \
    65 }                                                                                                        \
    66 if(strType) {                                                                                            \
    67     psFree(strType);                                                                                     \
    68     strType = NULL;                                                                                      \
    69 }                                                                                                        \
    70 if(strValue) {                                                                                           \
    71     psFree(strValue);                                                                                    \
    72     strValue = NULL;                                                                                     \
    73 }                                                                                                        \
    74 if(strComment) {                                                                                         \
    75     psFree(strComment);                                                                                  \
    76     strComment = NULL;                                                                                   \
    77 }                                                                                                        \
    78 if(tempVec) {                                                                                            \
    79     psFree(tempVec);                                                                                     \
    80     tempVec = NULL;                                                                                      \
     62if(strName) {                                                                                                \
     63    psFree(strName);                                                                                         \
     64    strName = NULL;                                                                                          \
     65}                                                                                                            \
     66if(strType) {                                                                                                \
     67    psFree(strType);                                                                                         \
     68    strType = NULL;                                                                                          \
     69}                                                                                                            \
     70if(strValue) {                                                                                               \
     71    psFree(strValue);                                                                                        \
     72    strValue = NULL;                                                                                         \
     73}                                                                                                            \
     74if(strComment) {                                                                                             \
     75    psFree(strComment);                                                                                      \
     76    strComment = NULL;                                                                                       \
    8177}
    8278
    … …  
    316312{
    317313    psMetadataType type;
     314    psElemType pType;
    318315
    319316    PS_PTR_CHECK_NULL(fd,);
    … …  
    322319
    323320    type = metadataItem->type;
     321    pType = metadataItem->pType;
    324322
    325323    switch(type) {
    326     case PS_META_BOOL:
    327         fprintf(fd, format, metadataItem->data.B);
    328         break;
    329     case PS_META_S32:
    330         fprintf(fd,format, metadataItem->data.S32);
    331         break;
    332     case PS_META_F32:
    333         fprintf(fd, format, metadataItem->data.F32);
    334         break;
    335     case PS_META_F64:
    336         fprintf(fd, format, metadataItem->data.F64);
     324    case PS_META_PRIMITIVE:
     325        switch(pType) {
     326        case PS_TYPE_BOOL:
     327            fprintf(fd, format, metadataItem->data.B);
     328            break;
     329        case PS_TYPE_S32:
     330            fprintf(fd,format, metadataItem->data.S32);
     331            break;
     332        case PS_TYPE_F32:
     333            fprintf(fd, format, metadataItem->data.F32);
     334            break;
     335        case PS_TYPE_F64:
     336            fprintf(fd, format, metadataItem->data.F64);
     337            break;
     338        default:
     339            psError(PS_ERR_BAD_PARAMETER_TYPE,true, PS_ERRORTEXT_psMetadata_METATYPE_INVALID, (int)pType);
     340        }
    337341        break;
    338342    case PS_META_STR:
    339         fprintf(fd, format, metadataItem->data.V);
     343        fprintf(fd,format, metadataItem->data.V);
    340344        break;
    341345    default:
    … …  
    359363    psS32 numKeys = 0;
    360364    psS32 keyNum = 0;
    361     psMetadataType metadataItemType;
    362365    fitsfile *fd = NULL;
    363366
    … …  
    416419        switch (keyType) {
    417420        case 'I':
    418             metadataItemType = PS_META_S32;
    419             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, atoi(keyValue));
     421            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_S32, PS_META_PRIMITIVE,
     422                                    keyComment, atoi(keyValue));
    420423            break;
    421424        case 'F':
    422             metadataItemType = PS_META_F64;
    423             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, atof(keyValue));
     425            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_F64, PS_META_PRIMITIVE,
     426                                    keyComment, atof(keyValue));
    424427            break;
    425428        case 'C':
    426             metadataItemType = PS_META_STR;
    427             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, keyValue);
     429            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_PTR, PS_META_STR, keyComment,
     430                                    keyValue);
    428431            break;
    429432        case 'L':
    430             metadataItemType = PS_META_BOOL;
    431433            tempBool = (keyValue[0] == 'T') ? 1 : 0;
    432             success = psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, tempBool);
     434            success = psMetadataAdd(output, PS_LIST_TAIL, keyName, PS_TYPE_BOOL, PS_META_PRIMITIVE, keyComment,
     435                                    tempBool);
    433436            break;
    434437        case 'U':
    435438        case 'X':
    436439        default:
    437             psError(PS_ERR_IO, true,
    438                     PS_ERRORTEXT_psMetadataIO_FITS_METATYPE_INVALID,
    439                     keyType);
     440            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FITS_METATYPE_INVALID, keyType);
    440441            return output;
    441442        }
    442443
    443444        if (!success) {
    444             psError(PS_ERR_UNKNOWN, false,
    445                     PS_ERRORTEXT_psMetadataIO_ADD_FAILED,
    446                     keyName);
     445            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadataIO_ADD_FAILED, keyName);
    447446            return output;
    448447        }
    … …  
    452451}
    453452
    454 
    455 psS32 psMetadataParseConfig(psMetadata** md, const char *fileName, psBool overwrite)
     453psMetadata* psMetadataParseConfig(psMetadata* md, psU32 *nFail, const char *fileName, psBool overwrite)
    456454{
    457455    psBool tempBool;
    … …  
    463461    char *linePtr = NULL;
    464462    psS32 status = 0;
    465     psS32 lineCount = 0;
    466     psS32 failedLines = 0;
     463    psU32 lineCount = 0;
    467464    psF64 tempDbl = 0.0;
    468465    psS32 tempInt = 0.0;
    … …  
    470467    psVector *tempVec = NULL;
    471468    FILE *fp = NULL;
    472     psElemType elemType;
     469    psElemType pType;
    473470    psMetadataType mdType;
    474471
    475472
    476473    // Check for nulls
    477     PS_PTR_CHECK_NULL(fileName,-1);
     474    PS_PTR_CHECK_NULL(fileName,NULL);
    478475    if((fp=fopen(fileName, "r")) == NULL) {
    479         psError(PS_ERR_IO, true,
    480                 PS_ERRORTEXT_psMetadataIO_FILE_OPEN_FAILED,
    481                 fileName);
    482         return -1;
     476        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_OPEN_FAILED, fileName);
     477        return NULL;
    483478    }
    484479
    485480    // Allocate metadata if necessary
    486     if (*md == NULL) {
    487         *md = psMetadataAlloc();
     481    if (md == NULL) {
     482        md = psMetadataAlloc();
    488483    }
    489484
    … …  
    504499            // Check for more than one '*' or '@' in a line
    505500            if(repeatedChars(linePtr, '@') > 1) {
    506                 failedLines++;
     501                (*nFail)++;
    507502                psError(PS_ERR_IO, true,
    508                         PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR,
    509                         '@', lineCount, fileName);
     503                        PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR, '@', lineCount, fileName);
    510504                continue;
    511505            } else if(repeatedChars(linePtr, '*') > 1) {
    512                 failedLines++;
     506                (*nFail)++;
    513507                psError(PS_ERR_IO, true,
    514                         PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR,
    515                         '*', lineCount, fileName);
     508                        PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR, '*', lineCount, fileName);
    516509                continue;
    517510            } else if(repeatedChars(linePtr, '~') > 0) {
    518                 failedLines++;
     511                (*nFail)++;
    519512                psError(PS_ERR_IO, true,
    520                         PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR,
    521                         '~', lineCount, fileName);
     513                        PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR, '~', lineCount, fileName);
    522514                continue;
    523515            }
    … …  
    526518            strName = getToken(&linePtr, " ", &status);
    527519            if(strName==NULL || status) {
    528                 failedLines++;
     520                (*nFail)++;
    529521                status = 0;
    530522                psError(PS_ERR_IO, true,
    531                         PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,
    532                         "name",lineCount, fileName);
     523                        PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "name", lineCount, fileName);
    533524                continue;
    534525            }
    … …  
    537528            strType = getToken(&linePtr, " ", &status);
    538529            if(strType==NULL) {
    539                 failedLines++;
     530                (*nFail)++;
    540531                status = 0;
    541                 psError(PS_ERR_IO, true,
    542                         PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,
    543                         "type",lineCount, fileName);
     532                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "type",lineCount,
     533                        fileName);
    544534                continue;
    545535            } else if(!strncmp(strType, "*", 1)) {
    546                 mdType = PS_META_ITEM_SET;
     536                mdType = PS_META_LIST;
     537                pType = PS_TYPE_PTR;
    547538            } else if(!strncmp(strType, "STR", 3)) {
    548539                mdType = PS_META_STR;
    549                 elemType = PS_TYPE_PTR;
     540                pType = PS_TYPE_PTR;
    550541            } else if(!strncmp(strType, "BOOL", 3)) {
    551                 mdType = PS_META_BOOL;
    552                 elemType = PS_TYPE_U8;
     542                mdType = PS_META_PRIMITIVE;
     543                pType = PS_TYPE_BOOL;
    553544            } else if(!strncmp(strType, "S32", 3)) {
    554                 mdType = PS_META_S32;
    555                 elemType = PS_TYPE_S32;
     545                mdType = PS_META_PRIMITIVE;
     546                pType = PS_TYPE_S32;
    556547            } else if(!strncmp(strType, "F32", 3)) {
    557                 mdType = PS_META_F32;
    558                 elemType = PS_TYPE_F32;
     548                mdType = PS_META_PRIMITIVE;
     549                pType = PS_TYPE_F32;
    559550            } else if(!strncmp(strType, "F64", 3)) {
    560                 mdType = PS_META_F64;
    561                 elemType = PS_TYPE_F64;
     551                mdType = PS_META_PRIMITIVE;
     552                pType = PS_TYPE_F64;
    562553            } else {
    563                 failedLines++;
    564                 psError(PS_ERR_IO, true,
    565                         PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID,
    566                         strType, lineCount, fileName);
     554                (*nFail)++;
     555                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID, strType, lineCount,
     556                        fileName);
    567557                continue;
    568558            }
    … …  
    573563
    574564            // Get the metadata item value if there is one. Lines with * don't have values.
    575             if(mdType != PS_META_ITEM_SET) {
     565            if(mdType != PS_META_LIST) {
    576566                strValue = getToken(&linePtr, "#", &status);
    577567                if(strValue==NULL) {
    578                     failedLines++;
     568                    (*nFail)++;
    579569                    status = 0;
    580                     psError(PS_ERR_IO, true,
    581                             PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,
    582                             "value",lineCount, fileName);
     570                    psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "value", lineCount,
     571                            fileName);
    583572                    continue;
    584573                }
    … …  
    588577            strComment = getToken(&linePtr,"~", &status);
    589578            if(status) {
    590                 failedLines++;
     579                (*nFail)++;
    591580                status = 0;
    592                 psError(PS_ERR_IO, true,
    593                         PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,
    594                         "comment",lineCount, fileName);
     581                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "comment", lineCount,
     582                        fileName);
    595583                continue;
    596584            }
    … …  
    599587            and allow switch/case below to add new item. If overwrite is false, then report error. If found
    600588            item is folder node, then psMetadataAdd will automatically add a new child. */
    601             metadataItem = psMetadataLookup(*md, strName);
     589            metadataItem = psMetadataLookup(md, strName);
    602590            if(metadataItem != NULL) {
    603                 if(metadataItem->type!=PS_META_ITEM_SET) {
     591                if(metadataItem->type!=PS_META_LIST) {
    604592                    if(overwrite) {
    605                         psMetadataRemove(*md, PS_LIST_UNKNOWN, strName);
     593                        psMetadataRemove(md, PS_LIST_UNKNOWN, strName);
    606594                    } else {
    607                         failedLines++;
    608                         psError(PS_ERR_IO, true,
    609                                 PS_ERRORTEXT_psMetadataIO_OVERWRITE_ITEM,
    610                                 strName, lineCount, fileName);
     595                        (*nFail)++;
     596                        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_OVERWRITE_ITEM, strName, lineCount,
     597                                fileName);
    611598                        continue;
    612599                    }
    … …  
    616603            // Create and add metadata item to metadata and parse values
    617604            switch (mdType) {
    618             case PS_META_ITEM_SET:
    619                 psMetadataAdd(*md, PS_LIST_TAIL, strName, mdType, NULL, NULL);
     605            case PS_META_LIST:
     606                psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, NULL);
    620607                break;
    621             case PS_META_BOOL:
    622                 tempBool = parseBool(strValue, &status);
     608            case PS_META_STR:
     609                psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, strComment, strValue);
     610                break;
     611            case PS_META_VEC:
     612                tempVec = parseVector(strValue, pType, &status);
    623613                if(!status) {
    624                     psMetadataAdd(*md, PS_LIST_TAIL, strName, mdType, strComment, tempBool);
     614                    psMetadataAdd(md, PS_LIST_TAIL, strName+1, pType, mdType, strComment, tempVec);
    625615                } else {
    626616                    status = 0;
    627                     failedLines++;
    628                     psError(PS_ERR_IO, true,
    629                             PS_ERRORTEXT_psMetadataIO_PARSE_FAILED,
    630                             strValue, strName, strType, lineCount, fileName);
     617                    (*nFail)++;
     618                    psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName,
     619                            strType, lineCount, fileName);
    631620                    continue;
    632621                }
    633622                break;
    634             case PS_META_S32:
    635                 tempInt = (psS32)parseValue(strValue, &status);
    636                 if(!status) {
    637                     psMetadataAdd(*md, PS_LIST_TAIL, strName, mdType, strComment, tempInt);
    638                 } else {
    639                     status = 0;
    640                     failedLines++;
    641                     psError(PS_ERR_IO, true,
    642                             PS_ERRORTEXT_psMetadataIO_PARSE_FAILED,
    643                             strValue, strName, strType, lineCount, fileName);
     623            case PS_META_PRIMITIVE:
     624                switch (pType) {
     625                case PS_TYPE_BOOL:
     626                    tempBool = parseBool(strValue, &status);
     627                    if(!status) {
     628                        psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, strComment, tempBool);
     629                    } else {
     630                        status = 0;
     631                        (*nFail)++;
     632                        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName,
     633                                strType, lineCount, fileName);
     634                        continue;
     635                    }
     636                    break;
     637                case PS_TYPE_S32:
     638                    tempInt = (psS32)parseValue(strValue, &status);
     639                    if(!status) {
     640                        psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, strComment, tempInt);
     641                    } else {
     642                        status = 0;
     643                        (*nFail)++;
     644                        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName,
     645                                strType, lineCount, fileName);
     646                        continue;
     647                    }
     648                    break;
     649                case PS_TYPE_F32:
     650                case PS_TYPE_F64:
     651                    tempDbl = parseValue(strValue, &status);
     652                    if(!status) {
     653                        psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, strComment, tempDbl);
     654                    } else {
     655                        status = 0;
     656                        (*nFail)++;
     657                        psError(PS_ERR_IO, true,
     658                                PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType, lineCount,
     659                                fileName);
     660                        continue;
     661                    }
     662                    break;
     663                default:
     664                    (*nFail)++;
     665                    psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID, mdType, lineCount,
     666                            fileName);
    644667                    continue;
    645                 }
    646                 break;
    647             case PS_META_F32:
    648             case PS_META_F64:
    649                 tempDbl = parseValue(strValue, &status);
    650                 if(!status) {
    651                     psMetadataAdd(*md, PS_LIST_TAIL, strName, mdType, strComment, tempDbl);
    652                 } else {
    653                     status = 0;
    654                     failedLines++;
    655                     psError(PS_ERR_IO, true,
    656                             PS_ERRORTEXT_psMetadataIO_PARSE_FAILED,
    657                             strValue, strName, strType, lineCount, fileName);
    658                     continue;
    659                 }
    660                 break;
    661             case PS_META_STR:
    662                 psMetadataAdd(*md, PS_LIST_TAIL, strName, mdType, strComment, strValue);
    663                 break;
    664             case PS_META_VEC:
    665                 tempVec = parseVector(strValue, elemType, &status);
    666                 if(!status) {
    667                     psMetadataAdd(*md, PS_LIST_TAIL, strName+1, mdType, strComment, tempVec);
    668                 } else {
    669                     status = 0;
    670                     failedLines++;
    671                     psError(PS_ERR_IO, true,
    672                             PS_ERRORTEXT_psMetadataIO_PARSE_FAILED,
    673                             strValue, strName, strType, lineCount, fileName);
    674                     continue;
    675                 }
     668                } // switch
    676669                break;
    677670            default:
    678                 failedLines++;
    679                 psError(PS_ERR_IO, true,
    680                         PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID,
    681                         mdType, lineCount, fileName);
     671                (*nFail)++;
     672                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID, mdType, lineCount,
     673                        fileName);
    682674                continue;
    683675            } // switch
    … …  
    687679    psFree(line);
    688680
    689     return failedLines;
     681    return md;
    690682}
    691683
    … …  
    753745
    754746    // Add attributes to metadata
    755     psMetadataAdd(md, PS_LIST_TAIL, "htAtts", PS_META_HASH, NULL, htAtts);
     747    psMetadataAdd(md, PS_LIST_TAIL, "htAtts", PS_TYPE_PTR, PS_META_HASH, NULL, htAtts);
    756748
    757749    psFree(psTagName);
    … …  
    765757    psBool tempBool = false;
    766758    psS32 status = 0;
    767     psU64 lineNumber = 0;
     759    psU32 lineNumber = 0;
    768760    psF64 tempDbl = 0.0;
    769761    psS32 tempInt = 0.0;
    770     psElemType elemType;
     762    psElemType pType;
    771763    psMetadataType mdType;
    772764    char *fileName = NULL;
    … …  
    790782    metadataItem = psMetadataLookup(md, "htAtts");
    791783    PS_PTR_CHECK_NULL_GENERAL(metadataItem, return);
    792     PS_PTR_CHECK_NULL_GENERAL(metadataItem->items, return);
    793     psListSetIterator(metadataItem->items, PS_LIST_TAIL);
    794     metadataItem = (psMetadataItem*)psListGetCurrent(metadataItem->items);
    795     htAtts = (psHash*)metadataItem->data.V;
     784    PS_PTR_CHECK_NULL_GENERAL(metadataItem->data.list, return);
     785    psListSetIterator(metadataItem->data.list, PS_LIST_TAIL);
     786    metadataItem = (psMetadataItem*)psListGetCurrent(metadataItem->data.list);
     787    htAtts = (psHash*)metadataItem->data.list;
    796788    PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
    797789    fileName = (char*)input->filename;
    … …  
    811803        if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psString")) {
    812804            mdType = PS_META_STR;
    813             elemType = PS_TYPE_PTR;
     805            pType = PS_TYPE_PTR;
    814806        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psBool")) {
    815             mdType = PS_META_BOOL;
    816             elemType = PS_TYPE_U8;
     807            mdType = PS_META_PRIMITIVE;
     808            pType = PS_TYPE_U8;
    817809        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psS32")) {
    818             mdType = PS_META_S32;
    819             elemType = PS_TYPE_S32;
     810            mdType = PS_META_PRIMITIVE;
     811            pType = PS_TYPE_S32;
    820812        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF32")) {
    821             mdType = PS_META_F32;
    822             elemType = PS_TYPE_F32;
     813            mdType = PS_META_PRIMITIVE;
     814            pType = PS_TYPE_F32;
    823815        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF64")) {
    824             mdType = PS_META_F64;
    825             elemType = PS_TYPE_F64;
     816            mdType = PS_META_PRIMITIVE;
     817            pType = PS_TYPE_F64;
    826818        } else {
    827819            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_TYPE_INVALID_LINE_FILE, strType, lineNumber,
    … …  
    847839        metadataItem = psMetadataLookup(md, strName);
    848840        if(metadataItem != NULL) {
    849             if(metadataItem->type != PS_META_ITEM_SET) {
     841            if(metadataItem->type != PS_META_LIST) {
    850842                if(overwrite) {
    851843                    psMetadataRemove(md, PS_LIST_UNKNOWN, strName);
    … …  
    861853    // Create metadata item and add to metadata
    862854    switch(mdType) {
    863     case PS_META_ITEM_SET:
    864         psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, NULL);
    865         break;
    866     case PS_META_BOOL:
    867         tempBool = parseBool((char*)strValue, &status);
    868         if(!status) {
    869             psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, tempBool);
    870         } else {
    871             status = 0;
    872             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    873                     lineNumber, fileName);
    874         }
    875         break;
    876     case PS_META_S32:
    877         tempInt = (psS32)parseValue((char*)strValue, &status);
    878         if(!status) {
    879             psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, tempInt);
    880         } else {
    881             status = 0;
    882             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    883                     lineNumber, fileName);
    884         }
    885         break;
    886     case PS_META_F32:
    887     case PS_META_F64:
    888         tempDbl = parseValue((char*)strValue, &status);
    889         if(!status) {
    890             psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, tempDbl);
    891         } else {
    892             status = 0;
    893             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    894                     lineNumber, fileName);
    895         }
     855    case PS_META_LIST:
     856        psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, NULL);
    896857        break;
    897858    case PS_META_STR:
    898         psMetadataAdd(md, PS_LIST_TAIL, strName, mdType, NULL, strValue);
     859        psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, strValue);
     860        break;
     861    case PS_META_PRIMITIVE:
     862        switch(pType) {
     863        case PS_TYPE_BOOL:
     864            tempBool = parseBool((char*)strValue, &status);
     865            if(!status) {
     866                psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, tempBool);
     867            } else {
     868                status = 0;
     869                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
     870                        lineNumber, fileName);
     871            }
     872            break;
     873        case PS_TYPE_S32:
     874            tempInt = (psS32)parseValue((char*)strValue, &status);
     875            if(!status) {
     876                psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, tempInt);
     877            } else {
     878                status = 0;
     879                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
     880                        lineNumber, fileName);
     881            }
     882            break;
     883        case PS_TYPE_F32:
     884        case PS_TYPE_F64:
     885            tempDbl = parseValue((char*)strValue, &status);
     886            if(!status) {
     887                psMetadataAdd(md, PS_LIST_TAIL, strName, pType, mdType, NULL, tempDbl);
     888            } else {
     889                status = 0;
     890                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
     891                        lineNumber, fileName);
     892            }
     893            break;
     894        default:
     895            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID, strType, lineNumber, fileName);
     896        } // End switch
    899897        break;
    900898    default:
    … …  
    902900    } // End switch
    903901
     902
    904903    return;
    905904}
    … …  
    910909    bool overwrite = false;
    911910    psS32 status = 0;
    912     psU64 lineNumber = 0;
    913     psElemType elemType;
     911    psU32 lineNumber = 0;
     912    psElemType pType;
    914913    psMetadataType mdType;
    915914    char *strName = NULL;
    … …  
    936935    tables = psMetadataLookup(md, "htAtts");
    937936    PS_PTR_CHECK_NULL_GENERAL(tables, return);
    938     PS_PTR_CHECK_NULL_GENERAL(tables->items, return);
    939     psListSetIterator(tables->items, PS_LIST_TAIL);
    940     table = (psMetadataItem*)psListGetCurrent(tables->items);
    941     htAtts = (psHash*)table->data.V;
     937    PS_PTR_CHECK_NULL_GENERAL(tables->data.list, return);
     938    psListSetIterator(tables->data.list, PS_LIST_TAIL);
     939    table = (psMetadataItem*)psListGetCurrent(tables->data.list);
     940    htAtts = (psHash*)table->data.list;
    942941    PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
    943942    fileName = (char*)input->filename;
    … …  
    957956        if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psString")) {
    958957            mdType = PS_META_STR;
    959             elemType = PS_TYPE_PTR;
     958            pType = PS_TYPE_PTR;
    960959        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psBool")) {
    961             mdType = PS_META_BOOL;
    962             elemType = PS_TYPE_U8;
     960            mdType = PS_META_PRIMITIVE;
     961            pType = PS_TYPE_U8;
    963962        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psS32")) {
    964             mdType = PS_META_S32;
    965             elemType = PS_TYPE_S32;
     963            mdType = PS_META_PRIMITIVE;
     964            pType = PS_TYPE_S32;
    966965        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF32")) {
    967             mdType = PS_META_F32;
    968             elemType = PS_TYPE_F32;
     966            mdType = PS_META_PRIMITIVE;
     967            pType = PS_TYPE_F32;
    969968        } else if(xmlStrEqual(BAD_CAST strType, BAD_CAST "psF64")) {
    970             mdType = PS_META_F64;
    971             elemType = PS_TYPE_F64;
     969            mdType = PS_META_PRIMITIVE;
     970            pType = PS_TYPE_F64;
    972971        } else {
    973972            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_TYPE_INVALID_LINE_FILE, strName, lineNumber,
    … …  
    994993        metadataItem = psMetadataLookup(md, strName);
    995994        if(metadataItem != NULL) {
    996             if(metadataItem->type != PS_META_ITEM_SET) {
     995            if(metadataItem->type != PS_META_LIST) {
    997996                if(overwrite) {
    998997                    psMetadataRemove(md, PS_LIST_UNKNOWN, strName);
    … …  
    10071006
    10081007    // Get value
    1009     vec = parseVector((char*)strValue, elemType, &status);
     1008    vec = parseVector((char*)strValue, pType, &status);
    10101009    if(!status) {
    1011         psMetadataAdd(md, PS_LIST_TAIL, strName+1, mdType, NULL, vec);
     1010        psMetadataAdd(md, PS_LIST_TAIL, strName+1, pType, mdType, NULL, vec);
    10121011    } else {
    10131012        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, strName, strType,
    … …  
    10381037    tables = psMetadataLookup(md, "htAtts");
    10391038    PS_PTR_CHECK_NULL_GENERAL(tables, return);
    1040     PS_PTR_CHECK_NULL_GENERAL(tables->items, return);
    1041     psListSetIterator(tables->items, PS_LIST_TAIL);
    1042     table = (psMetadataItem*)psListGetCurrent(tables->items);
    1043     htAtts = (psHash*)table->data.V;
     1039    PS_PTR_CHECK_NULL_GENERAL(tables->data.list, return);
     1040    psListSetIterator(tables->data.list, PS_LIST_TAIL);
     1041    table = (psMetadataItem*)psListGetCurrent(tables->data.list);
     1042    htAtts = (psHash*)table->data.list;
    10441043    PS_PTR_CHECK_NULL_GENERAL(htAtts, return);
    10451044
    … …  
    10641063
    10651064    // Free temporary metadata item and its hash table
    1066     psListRemove(tables->items, PS_LIST_TAIL, table);
     1065    psListRemove(tables->data.list, PS_LIST_TAIL, table);
    10671066
    10681067    psFree(psEndTagName);
    … …  
    10711070}
    10721071
    1073 psS32 psMetadataParseConfigXml(psMetadata** md, const char *fileName)
     1072psMetadata*  psMetadataParseConfigXml(psMetadata* md, psU32 *nFail, const char *fileName, psBool overwrite)
    10741073{
    10751074    xmlSAXHandler saxHandler;
    … …  
    10771076
    10781077    // Error checks
    1079     PS_PTR_CHECK_NULL(fileName,-1);
     1078    PS_PTR_CHECK_NULL(fileName, NULL);
    10801079
    10811080    // Allocate metadata if necessary
    1082     if (*md == NULL) {
    1083         *md = psMetadataAlloc();
     1081    if (md == NULL) {
     1082        md = psMetadataAlloc();
    10841083    }
    10851084
    … …  
    11131112    saxHandler.externalSubset           = NULL;
    11141113    saxHandler.initialized              = 1;
    1115     saxHandler._private                 = *md;
     1114    saxHandler._private                 = md;
    11161115    saxHandler.startElementNs           = NULL;
    11171116    saxHandler.endElementNs             = NULL;
    … …  
    11211120    if (xmlSAXUserParseFile(&saxHandler, NULL, fileName)) {
    11221121        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_OPEN_FAILED, fileName);
    1123         return -1;
     1122        return NULL;
    11241123    }
    11251124
Note: See TracChangeset for help on using the changeset viewer.