Index: /trunk/psLib/src/types/psMetadataConfig.c
===================================================================
--- /trunk/psLib/src/types/psMetadataConfig.c	(revision 9911)
+++ /trunk/psLib/src/types/psMetadataConfig.c	(revision 9912)
@@ -10,6 +10,6 @@
 *  @author Eric Van Alst, MHPCC
 *
-*  @version $Revision: 1.111 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-11-07 05:09:32 $
+*  @version $Revision: 1.112 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-11-09 00:03:44 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -1101,146 +1101,167 @@
                  psBool overwrite)
 {
-    psBool              returnValue    = true;
-    psMetadataFlags     flags          = PS_META_DEFAULT;
-    char*               keyName        = NULL;
-    psS32               status         = 0;
-    psS32               limit          = 0;
-    psMetadata*         tempTemplate   = NULL;
-    char*               strType        = NULL;
-    psArray*            typeArray      = NULL;
-    psArray*            templateArray  = NULL;
-    p_psParseLevelInfo* upperLevelInfo = NULL;
-    p_psParseLevelInfo* lowerLevelInfo = NULL;
-    psBool              addStatus      = 0;
+    psMetadataFlags     flags  = PS_META_DEFAULT;
+    psS32               status = 0;
 
     // Set flags if overwrite specified
-    if(overwrite) {
+    if (overwrite) {
         flags = PS_META_REPLACE;
     }
 
-    // If line is not a comment or blank, then extract data
-    if(!ignoreLine(linePtr)) {
-
-        // Check for more than one '@' in a line
-        if(repeatedChars(linePtr, '@') > 1) {
+    // If line is a comment or blank, then extract data
+    if (ignoreLine(linePtr)) {
+        // do nothing and return
+        return true;
+    }
+
+    // Check for more than one '@' in a line
+    if (repeatedChars(linePtr, '@') > 1) {
+        psError(PS_ERR_IO, true,
+                _("More than one '@' character not allowed.  Found on line %u."), lineCount);
+        return false;
+    }
+
+    // Get metadata item name
+    char *keyName = getToken(&linePtr, " ", &status, true);
+    if (status) {
+        psError(PS_ERR_IO, true,
+                _("Failed to read item key name on line %u."), lineCount);
+        psFree(keyName);
+        return false;
+    }
+
+    // Check for special keyName values "TYPE", "END"
+    if (strcmp(keyName,"TYPE") == 0 ) {
+        // Get the type name
+        char *strType = getToken(&linePtr, " ", &status, true);
+        if(!strType) {
+            psError(PS_ERR_IO,true,
+                    _("Failed to read item type on line %u."), lineCount);
+            psFree(keyName);
+            return false;
+        }
+        if (status) {
             psError(PS_ERR_IO, true,
-                    _("More than one '%c' character not allowed.  Found on line %u."),
-                    '@', lineCount);
+                    _("Failed to read item type on line %u."), lineCount);
+            psFree(strType);
+            psFree(keyName);
             return false;
         }
 
-        // Get metadata item name
-        keyName = getToken(&linePtr, " ", &status,true);
-        /*        if(status) {
-                    psError(PS_ERR_IO, true,
-                            _("Failed to read a metadata %s on line %u."), "keyName", lineCount);
-                    psFree(keyName);
-                    return false;
-                }
-        */
-        // Check for special keyName values "TYPE", "END"
-        if(strcmp(keyName,"TYPE") == 0 ) {
-            // Get the type name
-            strType = getToken(&linePtr," ",&status,true);
-            if(strType == NULL) {
+        // attempt to parse the TYPE line into a template metadata
+        psMetadata *tempTemplate = getMetadataType(linePtr);
+        if (!tempTemplate) {
+            psError(PS_ERR_IO,true,
+                    _("Metadata type '%s', found on line %u, is invalid."),
+                    strType,lineCount);
+            psFree(keyName);
+            psFree(strType);
+            return false;
+        }
+
+        // Access type array
+        psArray *typeArray = ((p_psParseLevelInfo*)(levelArray->data[*level]))->typeArray;
+
+        // Check if type already exists in array
+        for (psS32 k = 0; k < psArrayLength(typeArray); k++) {
+            // Compare type name with the list of current types
+            if (strcmp(strType,(char*)typeArray->data[k]) == 0) {
                 psError(PS_ERR_IO,true,
-                        _("Failed to read a metadata %s on line %u."), "type", lineCount);
-                psFree(keyName);
-                return false;
-            }
-            tempTemplate = getMetadataType(linePtr);
-            // Check if type was parsed succesfully
-            if(tempTemplate != NULL) {
-                // Access type array
-                typeArray = ((p_psParseLevelInfo*)(levelArray->data[*level]))->typeArray;
-                // Check if type already exists in array
-                for(psS32 k=0; k < typeArray->n; k++) {
-                    // Compare type name with the list of current types
-                    if(strcmp(strType,(char*)typeArray->data[k]) == 0) {
-                        psError(PS_ERR_IO,true,
-                                _("Specified type, %s, on line %u is already defined."),
-                                strType,lineCount);
-                        psFree(tempTemplate);
-                        psFree(keyName);
-                        psFree(strType);
-                        return false;
-                    }
-                }
-                // Add key name to array of type
-                typeArray = psArrayAdd(typeArray,1,strType);
-                // Add template to array of templates
-                templateArray = ((p_psParseLevelInfo*)(levelArray->data[*level]))->templateArray;
-                templateArray = psArrayAdd(templateArray,1,tempTemplate);
+                        _("Specified type, %s, on line %u is already defined."),
+                        strType, lineCount);
                 psFree(tempTemplate);
-            } else {
-                psError(PS_ERR_IO,true,
-                        _("Metadata type '%s', found on line %u, is invalid."),
-                        strType,lineCount);
                 psFree(keyName);
                 psFree(strType);
                 return false;
             }
-            psFree(strType);
-        } else if (strcmp(keyName,"END") == 0 ) {
-            if(*level > 0) {
-                upperLevelInfo = ((p_psParseLevelInfo*)(levelArray->data[*level-1]));
-                lowerLevelInfo = ((p_psParseLevelInfo*)(levelArray->data[*level]));
-                // Check name in nonunique list
-                for(psS32 k=0; k < upperLevelInfo->nonUniqueKeyArray->n; k++) {
-                    if(strcmp(upperLevelInfo->nonUniqueKeyArray->data[k],lowerLevelInfo->name) == 0) {
-                        flags = PS_META_DUPLICATE_OK;
-                        break;
-                    }
-                }
-
-                char *strValue = NULL;
-                strValue = getToken(&linePtr, "#", &status,true);
-                char *strComment = NULL;
-                strComment = getToken(&linePtr,"~", &status,true);
-
-                // Add metadata to upper level metadata
-                addStatus = psMetadataAdd(upperLevelInfo->metadata,
-                                          PS_LIST_TAIL,lowerLevelInfo->name,
-                                          PS_DATA_METADATA | flags,
-                                          strComment, //"",
-                                          lowerLevelInfo->metadata);
-                psFree(strValue);
-                psFree(strComment);
-                if(!addStatus) {
-                    psFree(keyName);
-                    return false;
-                } else {
-                    // Remove lower info level
-                    /*                    if(!psArrayRemoveIndex(levelArray, *level)) {
-                                            psFree(keyName);
-                                            return false;
-                                        }
-                                        */
-                    psArrayRemoveIndex(levelArray, *level);
-                    (*level)--;
-                }
-            } else {
-                psFree(keyName);
-                return false;
-            }
-        } else {
-            // Check if key name present in array of non-unique key names
-            limit = ((p_psParseLevelInfo*)(levelArray->data[*level]))->nonUniqueKeyArray->n;
-            for(psS32 k=0; k < limit; k++) {
-                char* name = (char*)((p_psParseLevelInfo*)
-                                     (levelArray->data[*level]))->nonUniqueKeyArray->data[k];
-                if(strcmp(name,keyName) == 0) {
-                    flags = PS_META_DUPLICATE_OK;
-                }
-            }
-            // Parse metadataItem
-            if(!parseMetadataItem(keyName,level, levelArray, linePtr, lineCount, flags)) {
-                psFree(keyName);
-                return false;
-            }
-        }
+        }
+
+        // Add key name to array of type
+        typeArray = psArrayAdd(typeArray, 1, strType);
+        psFree(strType);
+
+        // Add template to array of templates
+        psArray *templateArray = ((p_psParseLevelInfo*)(levelArray->data[*level]))->templateArray;
+        psArrayAdd(templateArray, 1, tempTemplate);
+        psFree(tempTemplate);
+
+        return true;
+    }
+
+    if (strcmp(keyName, "END") == 0) {
+        if ((*level) < 1) {
+            psFree(keyName);
+            return false;
+        }
+
+        # if 1
+        p_psParseLevelInfo *upperLevelInfo = ((p_psParseLevelInfo*)(levelArray->data[*level-1]));
+        p_psParseLevelInfo *lowerLevelInfo = ((p_psParseLevelInfo*)(levelArray->data[*level]));
+        // Check name in nonunique list
+        for (psS32 k = 0; k < psArrayLength(upperLevelInfo->nonUniqueKeyArray); k++) {
+            if (strcmp(upperLevelInfo->nonUniqueKeyArray->data[k], lowerLevelInfo->name) == 0) {
+                flags = PS_META_DUPLICATE_OK;
+                break;
+            }
+        }
+        #endif
+
+        char *strValue = NULL;
+        strValue = getToken(&linePtr, "#", &status, true);
+        char *strComment = NULL;
+        // XXX why is there a ~ here?
+        strComment = getToken(&linePtr, "~", &status, true);
+
+        // Add metadata to upper level metadata
+        if (!psMetadataAdd(upperLevelInfo->metadata,
+                           PS_LIST_TAIL, lowerLevelInfo->name,
+                           PS_DATA_METADATA | flags,
+                           strComment, //"",
+                           lowerLevelInfo->metadata)) {
+            // This is pretty much a non-recoverable error - perhaps there
+            // should be a way of signalling non-recoverable parse errors
+            psError(PS_ERR_UNKNOWN, false, "failed to add metadata item");
+            psFree(strValue);
+            psFree(strComment);
+            psFree(keyName);
+            return false;
+        }
+
+        // Remove lower info level
+        if(!psArrayRemoveIndex(levelArray, *level)) {
+            psError(PS_ERR_UNKNOWN, false, "failed to remove array item");
+            psFree(strValue);
+            psFree(strComment);
+            psFree(keyName);
+        }
+
+        // the END just moved us up one nesting level
+        (*level)--;
+
+        psFree(strValue);
+        psFree(strComment);
         psFree(keyName);
-    }
-    return returnValue;
+
+        return true;
+    }
+
+    // Check if key name present in array of non-unique key names
+    psS32 limit = ((p_psParseLevelInfo*)(levelArray->data[*level]))->nonUniqueKeyArray->n;
+    for (psS32 k = 0; k < limit; k++) {
+        char *name = (char*)((p_psParseLevelInfo*)
+                             (levelArray->data[*level]))->nonUniqueKeyArray->data[k];
+        if (strcmp(name, keyName) == 0) {
+            flags = PS_META_DUPLICATE_OK;
+        }
+    }
+
+    // Parse metadataItem
+    if (!parseMetadataItem(keyName, level, levelArray, linePtr, lineCount, flags)) {
+        psFree(keyName);
+        return false;
+    }
+    psFree(keyName);
+
+    return true;
 }