IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 9916


Ignore:
Timestamp:
Nov 8, 2006, 3:58:52 PM (20 years ago)
Author:
jhoblitt
Message:

split parseGeneric(), parseType(), & parseMetadataEnd() out of parseLine()
fix line counting error in psMetadataConfigParse()

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r9912 r9916  
    1010*  @author Eric Van Alst, MHPCC
    1111*
    12 *  @version $Revision: 1.112 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2006-11-09 00:03:44 $
     12*  @version $Revision: 1.113 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2006-11-09 01:58:52 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    6868static psString formatMetadataItem(psMetadataItem *item);
    6969static psArray *p_psMetadataKeyArray(psMetadata *md);
     70static bool parseGeneric(char* keyName,
     71                         psS32* level,
     72                         psArray* levelArray,
     73                         char* linePtr,
     74                         psS32 lineCount,
     75                         psMetadataFlags flags);
     76static bool parseType(char* keyName,
     77                      psS32* level,
     78                      psArray* levelArray,
     79                      char* linePtr,
     80                      psS32 lineCount,
     81                      psMetadataFlags flags);
     82static bool parseMetadataEnd(char* keyName,
     83                             psS32* level,
     84                             psArray* levelArray,
     85                             char* linePtr,
     86                             psS32 lineCount,
     87                             psMetadataFlags flags);
    7088
    7189
    … …  
    11021120{
    11031121    psMetadataFlags     flags  = PS_META_DEFAULT;
    1104     psS32               status = 0;
    11051122
    11061123    // Set flags if overwrite specified
    … …  
    11161133
    11171134    // Check for more than one '@' in a line
     1135    // XXX this logic is wrong -- there's no reason a @ can't appear in a
     1136    // comment
    11181137    if (repeatedChars(linePtr, '@') > 1) {
    11191138        psError(PS_ERR_IO, true,
    … …  
    11231142
    11241143    // Get metadata item name
     1144    psS32               status = 0;
    11251145    char *keyName = getToken(&linePtr, " ", &status, true);
    11261146    if (status) {
    … …  
    11321152
    11331153    // Check for special keyName values "TYPE", "END"
    1134     if (strcmp(keyName,"TYPE") == 0 ) {
    1135         // Get the type name
    1136         char *strType = getToken(&linePtr, " ", &status, true);
    1137         if(!strType) {
    1138             psError(PS_ERR_IO,true,
    1139                     _("Failed to read item type on line %u."), lineCount);
    1140             psFree(keyName);
    1141             return false;
    1142         }
    1143         if (status) {
    1144             psError(PS_ERR_IO, true,
    1145                     _("Failed to read item type on line %u."), lineCount);
    1146             psFree(strType);
    1147             psFree(keyName);
    1148             return false;
    1149         }
    1150 
    1151         // attempt to parse the TYPE line into a template metadata
    1152         psMetadata *tempTemplate = getMetadataType(linePtr);
    1153         if (!tempTemplate) {
    1154             psError(PS_ERR_IO,true,
    1155                     _("Metadata type '%s', found on line %u, is invalid."),
    1156                     strType,lineCount);
    1157             psFree(keyName);
    1158             psFree(strType);
    1159             return false;
    1160         }
    1161 
    1162         // Access type array
    1163         psArray *typeArray = ((p_psParseLevelInfo*)(levelArray->data[*level]))->typeArray;
    1164 
    1165         // Check if type already exists in array
    1166         for (psS32 k = 0; k < psArrayLength(typeArray); k++) {
    1167             // Compare type name with the list of current types
    1168             if (strcmp(strType,(char*)typeArray->data[k]) == 0) {
    1169                 psError(PS_ERR_IO,true,
    1170                         _("Specified type, %s, on line %u is already defined."),
    1171                         strType, lineCount);
    1172                 psFree(tempTemplate);
    1173                 psFree(keyName);
    1174                 psFree(strType);
    1175                 return false;
    1176             }
    1177         }
    1178 
    1179         // Add key name to array of type
    1180         typeArray = psArrayAdd(typeArray, 1, strType);
    1181         psFree(strType);
    1182 
    1183         // Add template to array of templates
    1184         psArray *templateArray = ((p_psParseLevelInfo*)(levelArray->data[*level]))->templateArray;
    1185         psArrayAdd(templateArray, 1, tempTemplate);
    1186         psFree(tempTemplate);
    1187 
    1188         return true;
    1189     }
    1190 
    11911154    if (strcmp(keyName, "END") == 0) {
    1192         if ((*level) < 1) {
    1193             psFree(keyName);
    1194             return false;
    1195         }
    1196 
    1197         # if 1
    1198         p_psParseLevelInfo *upperLevelInfo = ((p_psParseLevelInfo*)(levelArray->data[*level-1]));
    1199         p_psParseLevelInfo *lowerLevelInfo = ((p_psParseLevelInfo*)(levelArray->data[*level]));
    1200         // Check name in nonunique list
    1201         for (psS32 k = 0; k < psArrayLength(upperLevelInfo->nonUniqueKeyArray); k++) {
    1202             if (strcmp(upperLevelInfo->nonUniqueKeyArray->data[k], lowerLevelInfo->name) == 0) {
    1203                 flags = PS_META_DUPLICATE_OK;
    1204                 break;
    1205             }
    1206         }
    1207         #endif
    1208 
    1209         char *strValue = NULL;
    1210         strValue = getToken(&linePtr, "#", &status, true);
    1211         char *strComment = NULL;
    1212         // XXX why is there a ~ here?
    1213         strComment = getToken(&linePtr, "~", &status, true);
    1214 
    1215         // Add metadata to upper level metadata
    1216         if (!psMetadataAdd(upperLevelInfo->metadata,
    1217                            PS_LIST_TAIL, lowerLevelInfo->name,
    1218                            PS_DATA_METADATA | flags,
    1219                            strComment, //"",
    1220                            lowerLevelInfo->metadata)) {
    1221             // This is pretty much a non-recoverable error - perhaps there
    1222             // should be a way of signalling non-recoverable parse errors
    1223             psError(PS_ERR_UNKNOWN, false, "failed to add metadata item");
    1224             psFree(strValue);
    1225             psFree(strComment);
    1226             psFree(keyName);
    1227             return false;
    1228         }
    1229 
    1230         // Remove lower info level
    1231         if(!psArrayRemoveIndex(levelArray, *level)) {
    1232             psError(PS_ERR_UNKNOWN, false, "failed to remove array item");
    1233             psFree(strValue);
    1234             psFree(strComment);
    1235             psFree(keyName);
    1236         }
    1237 
    1238         // the END just moved us up one nesting level
    1239         (*level)--;
    1240 
    1241         psFree(strValue);
    1242         psFree(strComment);
    1243         psFree(keyName);
    1244 
    1245         return true;
    1246     }
     1155        if (!parseMetadataEnd(keyName, level, levelArray, linePtr, lineCount, flags)) {
     1156            goto FAIL;
     1157        }
     1158    } else if (strcmp(keyName,"TYPE") == 0 ) {
     1159        if (!parseType(keyName, level, levelArray, linePtr, lineCount, flags)) {
     1160            goto FAIL;
     1161        }
     1162    } else {
     1163        if (!parseGeneric(keyName, level, levelArray, linePtr, lineCount, flags)) {
     1164            goto FAIL;
     1165        }
     1166    }
     1167
     1168    psFree(keyName);
     1169
     1170    return true;
     1171
     1172FAIL:
     1173    psError(PS_ERR_UNKNOWN, false,
     1174            _("Failed to parse line %u: %s."), lineCount, linePtr);
     1175    psFree(keyName);
     1176    return false;
     1177}
     1178
     1179static bool parseGeneric(char* keyName,
     1180                         psS32* level,
     1181                         psArray* levelArray,
     1182                         char* linePtr,
     1183                         psS32 lineCount,
     1184                         psMetadataFlags flags)
     1185{
     1186    PS_ASSERT_PTR_NON_NULL(keyName, false);
     1187    PS_ASSERT_PTR_NON_NULL(level, false);
     1188    PS_ASSERT_PTR_NON_NULL(levelArray, false);
     1189    PS_ASSERT_PTR_NON_NULL(linePtr, false);
    12471190
    12481191    // Check if key name present in array of non-unique key names
    … …  
    12581201    // Parse metadataItem
    12591202    if (!parseMetadataItem(keyName, level, levelArray, linePtr, lineCount, flags)) {
    1260         psFree(keyName);
    12611203        return false;
    12621204    }
    1263     psFree(keyName);
     1205
     1206    return true;
     1207}
     1208
     1209static bool parseType(char* keyName,
     1210                      psS32* level,
     1211                      psArray* levelArray,
     1212                      char* linePtr,
     1213                      psS32 lineCount,
     1214                      psMetadataFlags flags)
     1215{
     1216    PS_ASSERT_PTR_NON_NULL(keyName, false);
     1217    PS_ASSERT_PTR_NON_NULL(level, false);
     1218    PS_ASSERT_PTR_NON_NULL(levelArray, false);
     1219    PS_ASSERT_PTR_NON_NULL(linePtr, false);
     1220
     1221    // Get the type name
     1222    psS32 status = 0;
     1223    char *strType = getToken(&linePtr, " ", &status, true);
     1224    if(!strType) {
     1225        psError(PS_ERR_IO,true,
     1226                _("Failed to read item type on line %u."), lineCount);
     1227        return false;
     1228    }
     1229    if (status) {
     1230        psError(PS_ERR_IO, true,
     1231                _("Failed to read item type on line %u."), lineCount);
     1232        psFree(strType);
     1233        return false;
     1234    }
     1235
     1236    // attempt to parse the TYPE line into a template metadata
     1237    psMetadata *tempTemplate = getMetadataType(linePtr);
     1238    if (!tempTemplate) {
     1239        psError(PS_ERR_IO,true,
     1240                _("Metadata type '%s', found on line %u, is invalid."),
     1241                strType,lineCount);
     1242        psFree(strType);
     1243        return false;
     1244    }
     1245
     1246    // Access type array
     1247    psArray *typeArray = ((p_psParseLevelInfo*)(levelArray->data[*level]))->typeArray;
     1248
     1249    // Check if type already exists in array
     1250    for (psS32 k = 0; k < psArrayLength(typeArray); k++) {
     1251        // Compare type name with the list of current types
     1252        if (strcmp(strType, (char*)typeArray->data[k]) == 0) {
     1253            psError(PS_ERR_IO,true,
     1254                    _("Specified type, %s, on line %u is already defined."),
     1255                    strType, lineCount);
     1256            psFree(tempTemplate);
     1257            psFree(strType);
     1258            return false;
     1259        }
     1260    }
     1261
     1262    // Add key name to array of type
     1263    typeArray = psArrayAdd(typeArray, 0, strType);
     1264    psFree(strType);
     1265
     1266    // Add template to array of templates
     1267    psArray *templateArray = ((p_psParseLevelInfo*)(levelArray->data[*level]))->templateArray;
     1268    psArrayAdd(templateArray, 0, tempTemplate);
     1269    psFree(tempTemplate);
     1270
     1271    return true;
     1272}
     1273
     1274static bool parseMetadataEnd(char* keyName,
     1275                             psS32* level,
     1276                             psArray* levelArray,
     1277                             char* linePtr,
     1278                             psS32 lineCount,
     1279                             psMetadataFlags flags)
     1280{
     1281    PS_ASSERT_PTR_NON_NULL(keyName, false);
     1282    PS_ASSERT_PTR_NON_NULL(level, false);
     1283    PS_ASSERT_PTR_NON_NULL(levelArray, false);
     1284    PS_ASSERT_PTR_NON_NULL(linePtr, false);
     1285
     1286    if ((*level) < 1) {
     1287        psError(PS_ERR_UNKNOWN, false, "can not END the top level metadata");
     1288        return false;
     1289    }
     1290
     1291    p_psParseLevelInfo *upperLevelInfo = ((p_psParseLevelInfo*)(levelArray->data[*level-1]));
     1292    p_psParseLevelInfo *lowerLevelInfo = ((p_psParseLevelInfo*)(levelArray->data[*level]));
     1293    // Check name in nonunique list
     1294    for (psS32 k = 0; k < psArrayLength(upperLevelInfo->nonUniqueKeyArray); k++) {
     1295        if (strcmp(upperLevelInfo->nonUniqueKeyArray->data[k], lowerLevelInfo->name) == 0) {
     1296            flags = PS_META_DUPLICATE_OK;
     1297            break;
     1298        }
     1299    }
     1300
     1301    char *strValue = NULL;
     1302    psS32 status = 0;
     1303    strValue = getToken(&linePtr, "#", &status, true);
     1304    char *strComment = NULL;
     1305    // XXX why is there a ~ here?
     1306    strComment = getToken(&linePtr, "~", &status, true);
     1307
     1308    // Add metadata to upper level metadata
     1309    if (!psMetadataAdd(upperLevelInfo->metadata,
     1310                       PS_LIST_TAIL, lowerLevelInfo->name,
     1311                       PS_DATA_METADATA | flags,
     1312                       strComment, //"",
     1313                       lowerLevelInfo->metadata)) {
     1314        // This is pretty much a non-recoverable error - perhaps there
     1315        // should be a way of signalling non-recoverable parse errors
     1316        psError(PS_ERR_UNKNOWN, false, "failed to add metadata item");
     1317        psFree(strValue);
     1318        psFree(strComment);
     1319        return false;
     1320    }
     1321
     1322    // Remove lower info level
     1323    if(!psArrayRemoveIndex(levelArray, *level)) {
     1324        psError(PS_ERR_UNKNOWN, false, "failed to remove array item");
     1325        psFree(strValue);
     1326        psFree(strComment);
     1327    }
     1328
     1329    // the END just moved us up one nesting level
     1330    (*level)--;
     1331
     1332    psFree(strValue);
     1333    psFree(strComment);
    12641334
    12651335    return true;
    … …  
    13651435    psFree(topLevelInfo);
    13661436
    1367     psList *doc = psStringSplit(str, "\n", false);
     1437    psList *doc = psStringSplit(str, "\n", true);
    13681438    if (!doc) {
    13691439        psError(PS_ERR_UNKNOWN, false, "failed to split string: %s", str);
Note: See TracChangeset for help on using the changeset viewer.