IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 8774


Ignore:
Timestamp:
Sep 7, 2006, 4:13:20 PM (20 years ago)
Author:
jhoblitt
Message:

change parseLine() & parseMetadataItem() to not accept a filename parameter
change parseTime() to use psTimeStrptime() instead of psTimeFromISO()
rename psMetadataConfigParse() -> psMetadataConfigRead()
reimpliement psMetadataConfigParse() to operate on strings instead of files
add psMetadataConfigParse() time format tests

Location:
trunk/psLib
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/types/psMetadataConfig.c

    r8771 r8774  
    1010*  @author Eric Van Alst, MHPCC
    1111*
    12 *  @version $Revision: 1.79 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2006-09-07 22:02:47 $
     12*  @version $Revision: 1.80 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2006-09-08 02:13:20 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2222#include <inttypes.h>
    2323#include <strings.h>
     24#include <sys/mman.h>
     25#include <sys/types.h>
     26#include <sys/stat.h>
     27#include <fcntl.h>
     28#include <unistd.h>
    2429
    2530#include "psAbort.h"
    … …  
    6974;
    7075static void parseLevelInfoFree(p_psParseLevelInfo* info);
    71 static psBool parseLine(psS32* level,   psArray* levelArray, char*  linePtr, psS32 lineCount,
    72                         char* fileName, psBool overwrite);
    73 static psBool parseMetadataItem(char* keyName, psS32* level, psArray* levelArray, char* linePtr,
    74                                 psS32 lineCount, char* fileName, psMetadataFlags flags);
     76static psBool parseLine(psS32* level,   psArray* levelArray, char*  linePtr, psS32 lineCount, psBool overwrite);
     77static psBool parseMetadataItem(char* keyName, psS32* level, psArray* levelArray, char* linePtr, psS32 lineCount, psMetadataFlags flags);
    7578static psString formatMetadataItem(psMetadataItem *item);
    7679static psArray *p_psMetadataKeyArray(psMetadata *md);
    … …  
    301304    }
    302305
    303     psTime *out = psTimeFromISO(inString, tt);
    304 
     306    // like psTimeFromISO() but the ending Z is required
     307    psTime *out = psTimeStrptime(inString, "%Y-%m-%dT%H:%M:%SZ");
    305308    if (!out) {
    306         *status = 0;
     309        *status = 1;
    307310        return NULL;
    308311    }
    309312
    310     *status = 1;
     313    // psTimeStrptime() leaves the type at the default
     314    out->type = tt;
     315
     316    *status = 0;
    311317
    312318    return out;
    … …  
    662668                         char* linePtr,
    663669                         psS32 lineCount,
    664                          char* fileName,
    665670                         psMetadataFlags flags)
    666671{
    … …  
    694699    // Check for no type
    695700    if(strType==NULL) {
    696         psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "type",lineCount,
    697                 fileName);
     701        psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u."), "type",lineCount);
    698702        returnValue = false;
    699703    } else {
    … …  
    726730                vectorType = PS_TYPE_F64;
    727731            } else {
    728                 psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), "", keyName,
    729                         strType, lineCount, fileName);
     732                psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u."), "", keyName,
     733                        strType, lineCount);
    730734                psFree(strType);
    731735                return false;
    … …  
    755759        } else if(!strncmp(strType, "METADATA", 8)) {
    756760            mdType = PS_DATA_METADATA;
    757         } else if( !strncmp(strType, "PS_TIME_UTC", 12) || !strncmp(strType, "PS_TIME_TAI", 12)
    758                    || !strncmp(strType, "PS_TIME_UT1", 12) || !strncmp(strType, "PS_TIME_TT", 12)) {
     761        } else if( !strncmp(strType, "UTC", 3) || !strncmp(strType, "TAI", 3)
     762                   || !strncmp(strType, "UT1", 3) || !strncmp(strType, "TT", 3)) {
    759763            mdType = PS_DATA_TIME;
    760764        } else {
    … …  
    771775                        // Check for add failure
    772776                        if (! addStatus) {
    773                             psError(PS_ERR_IO, true, _("Duplicate Metadata item, %s, found on line %u of %s.  Overwrite not allowed."),
    774                                     keyName, lineCount, fileName);
     777                            psError(PS_ERR_IO, true, _("Duplicate Metadata item, %s, found on line %u.  Overwrite not allowed."),
     778                                    keyName, lineCount);
    775779                            psFree(strType);
    776780                            psFree(tempMeta);
    … …  
    780784                    } else {
    781785                        // Metadata type read error
    782                         psError(PS_ERR_IO,true,_("Failed to read a metadata %s on line %u of %s."),
    783                                 keyName,lineCount,fileName);
     786                        psError(PS_ERR_IO,true,_("Failed to read a metadata %s on line %u."),
     787                                keyName, lineCount);
    784788                        psFree(strType);
    785789                        return false;
    … …  
    790794            }
    791795            if(!typeFound) {
    792                 psError(PS_ERR_IO, true, _("Metadata type '%s', found on line %u of %s, is invalid."),
    793                         strType, lineCount,fileName);
     796                psError(PS_ERR_IO, true, _("Metadata type '%s', found on line %u, is invalid."),
     797                        strType, lineCount);
    794798                psFree(strType);
    795799                return false;
    … …  
    807811        strValue = getToken(&linePtr, "#", &status,true);
    808812        if(status) {
    809             psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "value", lineCount,
    810                     fileName);
     813            psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u."), "value", lineCount);
    811814            psFree(strType);
    812815            psFree(strValue);
    … …  
    814817        }
    815818        if(strValue==NULL) {
    816             psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "value", lineCount,
    817                     fileName);
     819            psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u."), "value", lineCount);
    818820            psFree(strType);
    819821            psFree(strValue);
    … …  
    824826        strComment = getToken(&linePtr,"~", &status,true);
    825827        if(status) {
    826             psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "comment", lineCount,
    827                     fileName);
     828            psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u."), "comment", lineCount);
    828829            psFree(strType);
    829830            psFree(strValue);
    … …  
    849850                                      strComment, tempBool);
    850851        } else {
    851             psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    852                     strType, lineCount, fileName);
     852            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u."), strValue, keyName,
     853                    strType, lineCount);
    853854            returnValue = false;
    854855        }
    … …  
    863864        } else {
    864865            psError(PS_ERR_IO, true,
    865                     _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName, strType, lineCount,
    866                     fileName);
     866                    _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u."), strValue, keyName, strType, lineCount);
    867867            returnValue = false;
    868868        }
    … …  
    873873            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempInt);
    874874        } else {
    875             psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    876                     strType, lineCount, fileName);
     875            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u."), strValue, keyName,
     876                    strType, lineCount);
    877877            returnValue = false;
    878878        }
    … …  
    883883            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempInt);
    884884        } else {
    885             psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    886                     strType, lineCount, fileName);
     885            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u."), strValue, keyName,
     886                    strType, lineCount);
    887887            returnValue = false;
    888888        }
    … …  
    893893            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempInt);
    894894        } else {
    895             psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    896                     strType, lineCount, fileName);
     895            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u."), strValue, keyName,
     896                    strType, lineCount);
    897897            returnValue = false;
    898898        }
    … …  
    903903            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempUint);
    904904        } else {
    905             psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    906                     strType, lineCount, fileName);
     905            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u."), strValue, keyName,
     906                    strType, lineCount);
    907907            returnValue = false;
    908908        }
    … …  
    913913            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempUint);
    914914        } else {
    915             psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    916                     strType, lineCount, fileName);
     915            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u."), strValue, keyName,
     916                    strType, lineCount);
    917917            returnValue = false;
    918918        }
    … …  
    923923            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempUint);
    924924        } else {
    925             psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    926                     strType, lineCount, fileName);
     925            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u."), strValue, keyName,
     926                    strType, lineCount);
    927927            returnValue = false;
    928928        }
    929929        break;
    930930    case PS_DATA_TIME:
    931         if( !strncmp(strType, "PS_TIME_UTC", 12) )
     931        if(!strncmp(strType, "UTC", 3)) {
    932932            timeType = PS_TIME_UTC;
    933         else if( !strncmp(strType, "PS_TIME_TAI", 12) )
     933        } else if(!strncmp(strType, "TAI", 3)) {
    934934            timeType = PS_TIME_TAI;
    935         else if( !strncmp(strType, "PS_TIME_UT1", 12) )
     935        } else if(!strncmp(strType, "UT1", 3)) {
    936936            timeType = PS_TIME_UT1;
    937         else if( !strncmp(strType, "PS_TIME_TT", 12) )
     937        } else if(!strncmp(strType, "TT", 3)) {
    938938            timeType = PS_TIME_TT;
     939        }
     940
    939941        mTime = parseTime(strValue, timeType, &status);
    940942        if(!status) {
    … …  
    943945                                      strComment, mTime);
    944946        } else {
    945             psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    946                     strType, lineCount, fileName);
     947            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u."), strValue, keyName,
     948                    strType, lineCount);
    947949            returnValue = false;
    948950        }
    … …  
    956958                                      strComment, tempVec);
    957959        } else {
    958             psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    959                     strType, lineCount, fileName);
     960            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u."), strValue, keyName,
     961                    strType, lineCount);
    960962            returnValue = false;
    961963        }
    … …  
    968970        for(psS32 k=0; k < nonUniqueKeys->n; k++) {
    969971            if(strcmp(keyName,(char*)nonUniqueKeys->data[k]) == 0) {
    970                 psError(PS_ERR_IO,true,_("Duplicate MULTI specifier on line %u of %s."),
    971                         lineCount,fileName);
     972                psError(PS_ERR_IO,true,_("Duplicate MULTI specifier on line %u."),
     973                        lineCount);
    972974                psFree(strType);
    973975                return false;
    … …  
    994996        break;
    995997    default:
    996         psError(PS_ERR_IO,true,_("Metadata of unknown type found on line %u of %s."),
    997                 lineCount,fileName);
     998        psError(PS_ERR_IO,true,_("Metadata of unknown type found on line %u."),
     999                lineCount);
    9981000        break;
    9991001    }
    … …  
    10151017                 char* linePtr,
    10161018                 psS32 lineCount,
    1017                  char* fileName,
    10181019                 psBool overwrite)
    10191020{
    … …  
    10421043        if(repeatedChars(linePtr, '@') > 1) {
    10431044            psError(PS_ERR_IO, true,
    1044                     _("More than one '%c' character not allowed.  Found on line %u of %s."), '@', lineCount, fileName);
     1045                    _("More than one '%c' character not allowed.  Found on line %u."), '@', lineCount);
    10451046            return false;
    10461047        }
    … …  
    10501051        if(status) {
    10511052            psError(PS_ERR_IO, true,
    1052                     _("Failed to read a metadata %s on line %u of %s."), "keyName", lineCount, fileName);
     1053                    _("Failed to read a metadata %s on line %u."), "keyName", lineCount);
    10531054            psFree(keyName);
    10541055            return false;
    … …  
    10601061            strType = getToken(&linePtr," ",&status,true);
    10611062            if(strType == NULL) {
    1062                 psError(PS_ERR_IO,true,_("Failed to read a metadata %s on line %u of %s."),"type",lineCount,
    1063                         fileName);
     1063                psError(PS_ERR_IO,true,_("Failed to read a metadata %s on line %u."),"type",lineCount);
    10641064                psFree(keyName);
    10651065                return false;
    … …  
    10741074                    // Compare type name with the list of current types
    10751075                    if(strcmp(strType,(char*)typeArray->data[k]) == 0) {
    1076                         psError(PS_ERR_IO,true,_("Specified type, %s, on line %u of %s is already defined."),
    1077                                 strType,lineCount,fileName);
     1076                        psError(PS_ERR_IO,true,_("Specified type, %s, on line %u is already defined."),
     1077                                strType,lineCount);
    10781078                        psFree(tempTemplate);
    10791079                        psFree(keyName);
    … …  
    10891089                psFree(tempTemplate);
    10901090            } else {
    1091                 psError(PS_ERR_IO,true,_("Metadata type '%s', found on line %u of %s, is invalid."),
    1092                         strType,lineCount,fileName);
     1091                psError(PS_ERR_IO,true,_("Metadata type '%s', found on line %u, is invalid."),
     1092                        strType,lineCount);
    10931093                psFree(keyName);
    10941094                psFree(strType);
    … …  
    11391139            }
    11401140            // Parse metadataItem
    1141             if(!parseMetadataItem(keyName,level, levelArray, linePtr, lineCount, fileName, flags)) {
     1141            if(!parseMetadataItem(keyName,level, levelArray, linePtr, lineCount, flags)) {
    11421142                psFree(keyName);
    11431143                return false;
    … …  
    11491149}
    11501150
     1151psMetadata* psMetadataConfigRead(psMetadata* md,
     1152                                 unsigned int *nFail,
     1153                                 const char *filename,
     1154                                 bool overwrite)
     1155{
     1156    // Check for NULL file name
     1157    PS_ASSERT_PTR_NON_NULL(filename,NULL);
     1158
     1159    struct stat buf;
     1160
     1161    // Attempt to open specified file
     1162    int fd = 0;
     1163    if (!(fd = open(filename, O_RDONLY))) {
     1164        // XXX really should return strerror() here
     1165        psError(PS_ERR_IO, true, _("Failed to open file '%s'. Check if it exists and it has the proper permissions."), filename);
     1166        return NULL;
     1167    }
     1168
     1169    // psMetadataConfigParse() is going to read the entire file into memory so
     1170    // we're trying to be nice by allowing the VM to flush the file out of
     1171    // memory if need be.
     1172    // XXX yes, mmap is evil
     1173    void *file = mmap(0, (size_t)buf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
     1174
     1175    md = psMetadataConfigParse(md, nFail, (char *)file, overwrite);
     1176
     1177    munmap(file, (size_t)buf.st_size);
     1178
     1179    if (close(fd) != 0) {
     1180        // XXX really should return strerror() here
     1181        psError(PS_ERR_IO, true, _("Failed to close file '%s'."), filename);
     1182        return NULL;
     1183    }
     1184
     1185    return md;
     1186}
     1187
    11511188psMetadata* psMetadataConfigParse(psMetadata* md,
    11521189                                  unsigned int *nFail,
    1153                                   const char *filename,
     1190                                  const char *str,
    11541191                                  bool overwrite)
    11551192{
    1156     FILE*               fp                   = NULL;
    1157     char*               line                 = NULL;
    1158     char*               linePtr              = NULL;
    11591193    psArray*            parseLevelInfoArray  = NULL;
    1160     psS32               lineCount            = 0;
    11611194    psS32               nestingLevel         = 0;
    11621195    p_psParseLevelInfo* topLevelInfo         = NULL;
    1163 
    1164     // Check for NULL file name
    1165     PS_ASSERT_PTR_NON_NULL(filename,NULL);
    11661196
    11671197    // Initialise nFail, if provided
    … …  
    11701200    }
    11711201
    1172     // Attempt to open specified file
    1173     if((fp=fopen(filename, "r")) == NULL) {
    1174         psError(PS_ERR_IO, true, _("Failed to open file '%s'. Check if it exists and it has the proper permissions."), filename);
    1175         return NULL;
    1176     }
    1177 
    11781202    // Allocate metadata if necessary
    11791203    if (md == NULL) {
    … …  
    11871211    topLevelInfo = p_psParseLevelInfoAlloc();
    11881212    topLevelInfo->metadata = psMemIncrRefCounter(md);
    1189     parseLevelInfoArray = psArrayAdd(parseLevelInfoArray,1,topLevelInfo);
     1213    parseLevelInfoArray = psArrayAdd(parseLevelInfoArray, 1, topLevelInfo);
    11901214    psFree(topLevelInfo);
    1191 
    1192     // Create reusable line for continuous read
    1193     line = (char*)psAlloc(MAX_STRING_LENGTH*sizeof(char));
    11941215
    11951216    // While loop to parse the file
    11961217    psErrorClear();   // so we can call psError(..., false, ...)
    1197     while(fgets(line, MAX_STRING_LENGTH, fp) != NULL) {
    1198 
    1199         // Initialize variables for new line
    1200         linePtr = line;
    1201         lineCount++;
    1202 
    1203         if(!parseLine(&nestingLevel,parseLevelInfoArray,linePtr,lineCount,(char*)filename,overwrite)) {
     1218
     1219    psList *doc = psStringSplit(str, "\n", false);
     1220    if (!doc) {
     1221        psFree(parseLevelInfoArray);
     1222        psFree(md);
     1223        return NULL;
     1224    }
     1225
     1226    long lineCount = 0;
     1227    char *line = NULL;
     1228    psListIterator *iter = psListIteratorAlloc(doc, 0, false);
     1229    while((line = psListGetAndIncrement(iter))) {
     1230        lineCount++; // indexed from 1
     1231
     1232        if(!parseLine(&nestingLevel, parseLevelInfoArray, line, lineCount,
     1233                      overwrite)) {
    12041234            if (nFail != NULL) {
    12051235                (*nFail)++;
    12061236            } else {
    1207                 psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Error parsing line: %s", linePtr);
    1208             }
    1209         }
    1210     }
    1211     fclose(fp);
     1237                psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Error parsing line: %s", line);
     1238            }
     1239        }
     1240    }
     1241
     1242    psFree(iter);
     1243    psFree(doc);
    12121244
    12131245    // Free parse array and line buffer
    12141246    psFree(parseLevelInfoArray);
    1215     psFree(line);
    12161247
    12171248    return md;
    12181249}
    1219 
    12201250
    12211251psString psMetadataConfigFormat(psMetadata *md)
    … …  
    13581388        psTime *time = item->data.V;
    13591389        if ( time->type == PS_TIME_UTC )
    1360             psStringAppend(&content, "PS_TIME_UTC  ");
     1390            psStringAppend(&content, "UTC  ");
    13611391        else if ( time->type == PS_TIME_TAI )
    1362             psStringAppend(&content, "PS_TIME_TAI  ");
     1392            psStringAppend(&content, "TAI  ");
    13631393        else if ( time->type == PS_TIME_UT1 )
    1364             psStringAppend(&content, "PS_TIME_UT1  ");
     1394            psStringAppend(&content, "UT1  ");
    13651395        else if ( time->type == PS_TIME_TT )
    1366             psStringAppend(&content, "PS_TIME_TT  ");
     1396            psStringAppend(&content, "TT  ");
    13671397        else {
    13681398            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified psDataType, %d, is not supported."), time->type);

  • trunk/psLib/src/types/psMetadataConfig.h

    r8312 r8774  
    1010 *  @author Robert DeSonia, MHPCC
    1111 *
    12  *  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2006-08-14 20:05:05 $
     12 *  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-09-08 02:13:20 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    6565 *  @return psMetadata* : Resulting metadata from read.
    6666 */
     67psMetadata* psMetadataConfigRead(
     68    psMetadata* md,                    ///< Resulting metadata from read.
     69    unsigned int *nFail,               ///< Number of failed lines.
     70    const char *filename,              ///< Name of file to read.
     71    bool overwrite                     ///< Allow overwrite of duplicate specifications.
     72);
     73
     74/** Parse metadata configuration string.
     75 *
     76 *  Loads pre-defined settings by parsing a string into a psMetadata structure.
     77 *
     78 *  @return psMetadata* : Resulting metadata from parse.
     79 */
    6780psMetadata* psMetadataConfigParse(
    6881    psMetadata* md,                    ///< Resulting metadata from read.
    6982    unsigned int *nFail,               ///< Number of failed lines.
    70     const char *filename,              ///< Name of file to read.
     83    const char *str,                   ///< String to process.
    7184    bool overwrite                     ///< Allow overwrite of duplicate specifications.
    7285);

  • trunk/psLib/test/types/Makefile.am

    r8747 r8774  
    1616        tap_psListIterator \
    1717        tap_psMetadataConfigParse \
     18        tap_psMetadataConfigParse_time \
    1819        tap_psMetadataItemCompare \
    1920        tap_psMetadataItemParse \

  • trunk/psLib/test/types/tap_psMetadataConfigParse.c

    r8731 r8774  
    148148    plan_tests(52);
    149149
    150     diag("psMetadataParseConfig tests");
     150    diag("psMetadataConfigRead tests");
    151151
    152152    generateMDConfig();
    153153
    154154    unsigned int numBadLines = 0;            // Number of bad lines
    155     psMetadata *md = psMetadataConfigParse(NULL, &numBadLines, FILENAME, false);
     155    psMetadata *md = psMetadataConfigRead(NULL, &numBadLines, FILENAME, false);
    156156    ok(md, "md = %x", md);
    157157    ok(numBadLines == 1, "number of bad lines = %d", numBadLines); // One bad line from boolean
    158158    skip_start(!md || numBadLines != 1, 0,
    159                "Skipping 0 tests because psMetadataConfigParse failed.");
     159               "Skipping 0 tests because psMetadataConfigRead failed.");
    160160    ok(psListLength(md->list) == 6, "size = %d", psListLength(md->list));
    161161
Note: See TracChangeset for help on using the changeset viewer.