Changeset 12544 for trunk/psModules/src/config/pmConfigRecipes.c

Timestamp:

Mar 22, 2007, 8:07:18 AM (19 years ago)

Author:

magnier

Message:

changed config recipes rules: master recipe file must exist

File:

• trunk/psModules/src/config/pmConfigRecipes.c (modified) (20 diffs)

trunk/psModules/src/config/pmConfigRecipes.c

@@ -15 +15 @@
 #include "pmConfigRecipes.h"
 
-static bool loadRecipeFiles(pmConfig *config, psMetadata *source, pmRecipeSource type, const char *name);
-static bool loadRecipeFromArguments(pmConfig *config);
-static bool loadRecipeSymbols(pmConfig *config);
-static bool loadRecipeOptions(pmConfig *config);
+static bool loadRecipeSite(bool *status, pmConfig *config, psMetadata *source);
+static bool loadRecipeCamera(bool *status, pmConfig *config, psMetadata *source);
+static bool loadRecipeFromArguments(bool *status, pmConfig *config);
+static bool loadRecipeSymbols(bool *status, pmConfig *config);
+static bool loadRecipeOptions(bool *status, pmConfig *config);
 
 // use this function to select the options structure for the specified recipe
@@ -24 +25 @@
 psMetadata *pmConfigRecipeOptions (pmConfig *config, char *recipeName)
 {
-
-    // if the recipe is already defined in config->arguments, supplement
+    bool success;
+
+    // select or create the OPTIONS folder
+    psMetadata *options = psMetadataLookupMetadata(&success, config->arguments, "OPTIONS");
+    if (!options) {
+        options = psMetadataAlloc ();
+        success = psMetadataAddPtr (config->arguments, PS_LIST_TAIL, "OPTIONS",  PS_DATA_METADATA, "", options);
+        assert (success); // type mismatch : OPTIONS already defined but wrong type
+        psFree (options); // drop extra reference
+    }
+
+    // look for the recipe defined in recipes
+    // if the recipe is already defined in config->arguments:OPTIONS, supplement
     // save the recipe options onto config->arguments:RECIPES
-    psMetadata *options;
-    psMetadataItem *optionsItem = psMetadataLookup(config->arguments, "OPTIONS");
-    if (optionsItem) {
-        assert(optionsItem->type == PS_DATA_METADATA);
-        options = psMemIncrRefCounter(optionsItem->data.V);
-    } else {
-        options = psMetadataAlloc ();
-        psMetadataAddPtr (config->arguments, PS_LIST_TAIL, "OPTIONS",  PS_DATA_METADATA, "", options);
-    }
-
-    // look for the recipe defined in recipes
-    psMetadata *recipe;
-    psMetadataItem *recipeItem = psMetadataLookup(options, recipeName);
-    psFree(options);                   // Drop reference
-    if (recipeItem) {
-        assert(recipeItem->type == PS_DATA_METADATA);
-        recipe = psMemIncrRefCounter(recipeItem->data.V);
-    } else {
+    psMetadata *recipe = psMetadataLookupMetadata(&success, options, recipeName);
+    if (!recipe) {
         recipe = psMetadataAlloc();
-        psMetadataAddPtr(options, PS_LIST_TAIL, recipeName,  PS_DATA_METADATA, "", recipe);
-    }
-
+        success = psMetadataAddPtr(options, PS_LIST_TAIL, recipeName,  PS_DATA_METADATA, "", recipe);
+        assert (success); // type mismatch : OPTIONS already defined but wrong type
+        psFree (recipe);  // drop extra reference
+    }
     return recipe;
 }
 
 // this function may be called several times.  it attempts to load the recipe data from one of
-// three locations: config->site, config->camera, and config->argv we cannot read the recipes
+// three locations: config->site, config->camera, and config->argv.  We cannot read the recipes
 // from config->camera until a camera has been read BUT, the argv recipes must override the
 // camera and site recipes.
 bool pmConfigReadRecipes(pmConfig *config, pmRecipeSource source)
 {
+    bool status;
     PS_ASSERT_PTR_NON_NULL(config, false);
 
@@ -65 +63 @@
 
     // Read the recipe file names from the site configuration and camera configuration
-    // XXX EAM : I think it should be an error for config->site:recipes not to exist
-    // for now, keep this as a warning
+    // It is an error for config->site:recipes not to exist.  all programs install their
+    // master recipe files in the site:recipe location when they are built.
     if (config->site && (source & PM_RECIPE_SOURCE_SITE)) {
-        if (!loadRecipeFiles(config, config->site, PM_RECIPE_SOURCE_SITE, "site configuration")) {
-            psLogMsg ("psModules.config", PS_LOG_WARN, "Failed to read recipes from site config");
-        } else {
-            psTrace ("psModules.config", 3, "read recipes from site config");
-        }
+        if (!loadRecipeSite(&status, config, config->site)) {
+            psError(PS_ERR_IO, false, "Failed to read recipes from site config");
+            return false;
+        } 
+        psTrace ("psModules.config", 3, "read recipes from site config");
     }
 
@@ -80 +78 @@
     // set should not override the first set
     if (config->camera && (source & PM_RECIPE_SOURCE_CAMERA) && !(config->recipesRead & PM_RECIPE_SOURCE_CAMERA)) {
-        if (!loadRecipeFiles(config, config->camera, PM_RECIPE_SOURCE_CAMERA, "camera configuration")) {
-            psLogMsg ("psModules.config", PS_LOG_DETAIL, "no recipe supplied by camera config");
-        } else {
-            psTrace ("psModules.config", 3, "read recipes from camera config");
-        }
+        if (!loadRecipeCamera(&status, config, config->camera)) {
+            psError(PS_ERR_IO, false, "Failed to read recipes from camera config");
+            return false;
+        } 
+        if (status) {
+            psTrace ("psModules.config", 3, "read recipes from camera config");
+        } else {
+            psLogMsg ("psModules.config", PS_LOG_DETAIL, "no recipe supplied by camera config");
+        }
     }
 
     // apply recipes loaded into config->arguments based on command-line arguments
     if (config->arguments && (source & PM_RECIPE_SOURCE_CL)) {
-        if (!loadRecipeFromArguments(config)) {
+        if (!loadRecipeFromArguments(&status, config)) {
+            psError(PS_ERR_IO, false, "Failed to read recipes from command-line arguments");
+            return false;
+        } 
+        if (status) {
+            psTrace ("psModules.config", 3, "read recipes from command-line arguments");
+        } else {
+            psLogMsg ("psModules.config", PS_LOG_DETAIL, "no recipe supplied on command-line arguments");
+        }
+        if (!loadRecipeSymbols(&status, config)) {
+            psError(PS_ERR_IO, false, "Failed to read recipes from symbolic references");
+            return false;
+        } 
+        if (status) {
+            psTrace ("psModules.config", 3, "read recipes from symbolic references");
+        } else {
+            psLogMsg ("psModules.config", PS_LOG_DETAIL, "no recipe supplied by symbolic reference");
+        }
+        if (!loadRecipeOptions(&status, config)) {
+            psError(PS_ERR_IO, false, "Failed to read recipes from symbolic references");
+            return false;
+        } 
+        if (status) {
+            psTrace ("psModules.config", 3, "read recipes from command-line arguments");
+        } else {
             psLogMsg ("psModules.config", PS_LOG_DETAIL, "no recipe supplied on command-line arguments");
-        } else {
-            psTrace ("psModules.config", 3, "read recipes from command-line arguments");
-        }
-        if (!loadRecipeSymbols(config)) {
-            psLogMsg ("psModules.config", PS_LOG_DETAIL, "no recipe supplied on command-line arguments");
-        } else {
-            psTrace ("psModules.config", 3, "read recipes from command-line arguments");
-        }
-        if (!loadRecipeOptions(config)) {
-            psLogMsg ("psModules.config", PS_LOG_DETAIL, "no recipe supplied on command-line arguments");
-        } else {
-            psTrace ("psModules.config", 3, "read recipes from command-line arguments");
-        }
-    }
-    /*
-     * We may have seen real errors, but we also get false status returned by valid conditions (e.g. asking a
-     * file for a recipe when none was provided).  For now we'll never signal an error, but this should
-     * be reconsidered ASAP.
-     */
-    psErrorClear();
+        }
+    }
     return true;
 }
@@ -117 +125 @@
 bool pmConfigLoadRecipeOptions (pmConfig *config, char *flag)
 {
-
+    bool success;
     int argNum;
 
     // save the recipes onto config->arguments:RECIPES
-    // increment so we can free below (is a NOP is options is NULL)
-    psMetadata *options;                // OPTIONS on the arguments
-    psMetadataItem *optionsItem = psMetadataLookup(config->arguments, "OPTIONS");
-    if (optionsItem) {
-        if (optionsItem->type != PS_DATA_METADATA) {
-            psAbort("OPTIONS is not of type METADATA.");
-        }
-        options = psMemIncrRefCounter(optionsItem->data.V);
-    } else {
+    // increment so we can free below (is a NOP if 'options' is NULL)
+    psMetadata *options = psMetadataLookupMetadata(&success, config->arguments, "OPTIONS");
+    if (!options) {
         options = psMetadataAlloc();
-        psMetadataAddPtr(config->arguments, PS_LIST_TAIL, "OPTIONS",  PS_DATA_METADATA,
-                         "Command-line options specified with -D", options);
+        success = psMetadataAddPtr(config->arguments, PS_LIST_TAIL, "OPTIONS",  PS_DATA_METADATA, "Command-line options specified with -D", options);
+        assert (success); // type mismatch : OPTIONS already defined but wrong type
+        psFree (options); // drop extra reference
     }
 
@@ -168 +171 @@
 
         // if this recipe is already defined in options, supplement
-        psMetadata *recipe;
-        psMetadataItem *recipeItem = psMetadataLookup(options, recipeName);
-        if (recipeItem) {
-            assert(recipeItem->type == PS_DATA_METADATA);
-            recipe = psMemIncrRefCounter(recipeItem->data.V);
-        } else {
+        psMetadata *recipe = psMetadataLookupMetadata(&success, options, recipeName);
+        if (!recipe) {
             recipe = psMetadataAlloc();
-            psMetadataAddPtr(options, PS_LIST_TAIL, recipeName,  PS_DATA_METADATA, "", recipe);
+            success = psMetadataAddPtr(options, PS_LIST_TAIL, recipeName,  PS_DATA_METADATA, "", recipe);
+            assert (success); // type mismatch : recipe already defined but wrong type
+            psFree (recipe); // drop extra reference
         }
 
@@ -200 +201 @@
         }
         psFree (words);
-        psFree (recipe);
         assert (valid);  // flag may be: -D, -Df, -Di, -Db
 
@@ -206 +206 @@
         psArgumentRemove (argNum, config->argc, config->argv);
     }
-    psFree (options);
     return true;
 }
@@ -216 +215 @@
 bool pmConfigLoadRecipeArguments (pmConfig *config)
 {
-    psMetadata *recipes;                // Recipes in the arguments list
-    psMetadataItem *recipesItem = psMetadataLookup(config->arguments, "RECIPES");
-    if (recipesItem) {
-        if (recipesItem->type != PS_DATA_METADATA) {
-            psAbort("RECIPES is not of type METADATA.");
-        }
-        recipes = psMemIncrRefCounter(recipesItem->data.V);
-    } else {
+    bool success; 
+
+    psMetadata *recipes = psMetadataLookupMetadata(&success, config->arguments, "RECIPES");
+    if (!recipes) {
         recipes = psMetadataAlloc();
-        psMetadataAddPtr (config->arguments, PS_LIST_TAIL, "RECIPES",  PS_DATA_METADATA, "", recipes);
-    }
-
+        success = psMetadataAddPtr (config->arguments, PS_LIST_TAIL, "RECIPES",  PS_DATA_METADATA, "", recipes);
+        assert (success);
+        psFree (recipes);
+    }
 
     // Go through the command-line arguments
@@ -238 +234 @@
         }
 
-        const char *recipeName = psStringCopy(config->argv[argNum]); // Name of the recipe
+        char *recipeName = psStringCopy(config->argv[argNum]); // Name of the recipe
         psArgumentRemove(argNum, config->argc, config->argv);
-        const char *recipeSource = psStringCopy(config->argv[argNum]); // Source of the recipe
+        char *recipeSource = psStringCopy(config->argv[argNum]); // Source of the recipe
         psArgumentRemove(argNum, config->argc, config->argv);
 
@@ -265 +261 @@
         }
         psTrace ("psModules.config", 3, "read recipe %s from %s", recipeName, recipeSource);
-        psFree((void *)recipeName);
-        psFree((void *)recipeSource);
+        psFree(recipeName);
+        psFree(recipeSource);
     } // Iterating through the command-line arguments
 
-    psFree(recipes);                    // Drop reference
-    return true;
-}
-
-// Load the recipe files (valid for SITE | CAMERA)
-// each time we load a specific recipe, it overrides the existing metadata for that recipe
-// for sourceType == SITE | CAMERA, RECIPES contains a list of files to be read (pmConfigFileRead)
-static bool loadRecipeFiles(pmConfig *config, // The configuration into which to read the recipes
-                            psMetadata *source, // The source configuration, from which to read the filenames
-                            pmRecipeSource sourceType, // The source type
-                            const char *sourceName // The name of the source, for error messages
-                           )
-{
+    return true;
+}
+
+// Load the recipe files for SITE : REQUIRED
+static bool loadRecipeSite(bool *status,
+                           pmConfig *config, // The configuration into which to read the recipes
+                           psMetadata *source // The source configuration, from which to read the filenames
+    )
+{
+    assert(status);
     assert(config);
-    if ((sourceType != PM_RECIPE_SOURCE_SITE) && (sourceType != PM_RECIPE_SOURCE_CAMERA)) {
-        psAbort("invalid source for loadRecipes");
-    }
+    *status = false;
+
     if (!source) {
-        psTrace("psModules.config", 4, "The %s has not been read --- cannot read recipes from this "
-                "location.\n", sourceName);
-        config->recipesRead &= ~sourceType;
+        psError(PS_ERR_IO, true, "The site configuration has not been read --- cannot read recipes from this location.\n");
+        config->recipesRead &= ~PM_RECIPE_SOURCE_SITE;
         return false;
     }
@@ -295 +286 @@
     psMetadata *recipes = psMetadataLookupMetadata(NULL, source, "RECIPES"); // The list of recipes
     if (!recipes) {
-        psLogMsg("psModules.config", PS_LOG_WARN, "RECIPES not found in the %s\n", sourceName);
-        config->recipesRead &= ~sourceType;
+        psError(PS_ERR_IO, false, "RECIPES not found in the site configuration\n");
         return false;
     }
@@ -308 +298 @@
         // type mismatch is a serious error
         if (fileItem->type != PS_DATA_STRING) {
-            psAbort("%s in %s RECIPES is not of type STR", fileItem->name, sourceName);
+            psError(PS_ERR_IO, true, "%s in site configuration RECIPES is not of type STR", fileItem->name);
+            return false;
         }
 
@@ -314 +305 @@
         psMetadata *recipe = NULL;
         if (!pmConfigFileRead(&recipe, fileItem->data.V, "recipe")) {
-            psWarning("Failed to read recipe file %s listed in %s\n", (char *)fileItem->data.V, sourceName);
-            continue;
+            psError(PS_ERR_IO, false, "Failed to read recipe file %s listed in site configuration\n", (char *)fileItem->data.V);
+            return false;
         }
 
         // if this named recipe exists, supplement it
-        psMetadata *current = NULL;     // Current, extant recipe of the same name, to be supplemented
-        psMetadataItem *currentItem = psMetadataLookup(config->recipes, fileItem->name);
-        if (currentItem) {
-            if (currentItem->type != PS_DATA_METADATA) {
-                psAbort("Item from recipes is not of type METADATA.");
-            }
-            current = psMemIncrRefCounter(currentItem->data.V);
-            psTrace("psModules.config", 3, "Supplementing %s from %s within %s.\n", currentItem->name,
-                    fileItem->name, sourceName);
-        }
-        current = psMetadataCopy(current, recipe);
+        psMetadataAdd(config->recipes, PS_LIST_TAIL, fileItem->name, PS_DATA_METADATA | PS_META_REPLACE,
+                      fileItem->comment, recipe);
         psFree(recipe);  // Drop reference
-        psMetadataAdd(config->recipes, PS_LIST_TAIL, fileItem->name, PS_DATA_METADATA | PS_META_REPLACE,
-                      fileItem->comment, current);
-        psFree(current);  // Drop reference
     }
     psFree(recipesIter);
-    config->recipesRead |= sourceType;
+    config->recipesRead |= PM_RECIPE_SOURCE_SITE;
+
+    *status = true;
+    return true;
+}
+
+// Load the recipe files (valid for SITE | CAMERA)
+// each time we load a specific recipe, it overrides the existing metadata for that recipe
+// for sourceType == SITE | CAMERA, RECIPES contains a list of files to be read (pmConfigFileRead)
+static bool loadRecipeCamera(bool *status, // status variable
+                             pmConfig *config, // The configuration into which to read the recipes
+                             psMetadata *source // The source configuration, from which to read the filenames
+    )
+{
+    bool success;
+
+    assert(status);
+    assert(config);
+    *status = false;
+
+    if (!source) {
+        psError(PS_ERR_IO, true, "The camera configuration has not been read --- cannot read recipes from this location.\n");
+        config->recipesRead &= ~PM_RECIPE_SOURCE_CAMERA;
+        return false;
+    }
+
+    // it is not necessary to define any local recipes in the camera config
+    psMetadata *recipes = psMetadataLookupMetadata(&success, source, "RECIPES"); // The list of recipes
+    if (!recipes) {
+        psTrace ("psModules.config", 3, "RECIPES not found in the camera configuration\n");
+        return true;
+    }
+
+    // Copy contents of the filenames to config->recipes from the "RECIPES" metadata in the source.
+    // We could use psMetadataCopy for this, but it's better to check that everything's of the correct type.
+    // If it's not of the correct type, we can tell the user which file it's in, so they can find it easier.
+    psMetadataIterator *recipesIter = psMetadataIteratorAlloc(recipes, PS_LIST_HEAD, NULL); // Iterator
+    psMetadataItem *fileItem = NULL;    // MD item containing the filename, from recipe iteration
+    while ((fileItem = psMetadataGetAndIncrement(recipesIter))) {
+        char *recipeName = fileItem->name;
+        char *recipeFile = fileItem->data.V;
+
+        psTrace("psModules.config", 3, "Supplementing %s from %s within camera configuration.\n", recipeName, recipeFile);
+
+        // type mismatch is a serious error
+        if (fileItem->type != PS_DATA_STRING) {
+            psAbort("%s in camera configuration RECIPES is not of type STR", recipeName);
+        }
+
+        // Read the recipe file. if we fail on a file, give a warning, but continue
+        psMetadata *recipe = NULL;
+        if (!pmConfigFileRead(&recipe, recipeFile, "recipe")) {
+            psError(PS_ERR_IO, false, "Failed to read recipe file %s listed in camera configuration\n", recipeFile);
+            return false;
+        }
+
+        // the named recipe must exist; supplement it
+        psMetadata *current = psMetadataLookupMetadata(NULL, config->recipes, recipeName);
+        if (!current) {
+            psError(PS_ERR_IO, false, "Failed to find recipe for %s in master recipe list", recipeName);
+            psFree(recipe);  // Drop reference
+            return false;
+        }
+
+        if (!psMetadataUpdate(current, recipe)) {
+            psError(PS_ERR_IO, false, "Failed to update recipe for %s from camera recipe", recipeName);
+            psFree(recipe);  // Drop reference
+            return false;
+        }
+        psFree(recipe);  // Drop reference
+    }
+    psFree(recipesIter);
+    config->recipesRead |= PM_RECIPE_SOURCE_CAMERA;
+    *status = true;
     return true;
 }
@@ -343 +395 @@
 // Load the recipes: each time we load a specific recipe, it overrides the metadata
 // entries for an existing recipe metadata
-static bool loadRecipeFromArguments(pmConfig *config // The configuration into which to read the recipes
-                                   )
-{
+static bool loadRecipeFromArguments(bool *status,
+                                    pmConfig *config // The configuration into which to read the recipes
+    )
+{
+    assert(status);
     assert(config);
+    *status = false;
+
     if (!config->arguments) {
         psTrace("psModules.config", 4, "no config->arguments metadata, nothing to read here");
-        return false;
+        return true;
     }
 
@@ -355 +411 @@
     if (!recipes) {
         psTrace("psModules.config", 4, "no RECIPES in config->arguments, nothing to read here");
-        return false;
+        return true;
     }
 
@@ -371 +427 @@
 
         // if this named recipe exists, supplement it
-        psMetadata *current = NULL;
-        psMetadataItem *currentItem = psMetadataLookup(config->recipes, item->name);
-        if (currentItem) {
-            assert(currentItem->type == PS_DATA_METADATA);
-            current = psMemIncrRefCounter(currentItem->data.V);
-        }
-        current = psMetadataCopy (current, recipe);
-        psMetadataAdd(config->recipes, PS_LIST_TAIL, item->name, PS_DATA_METADATA | PS_META_REPLACE,
-                      "added from command-line recipe", current);
-        psFree(current);  // Drop reference
+        psMetadata *current = psMetadataLookupMetadata(NULL, config->recipes, item->name);
+        if (!current) {
+            psError(PS_ERR_IO, false, "Failed to find recipe for %s in master recipe list", item->name);
+            psFree(recipe);  // Drop reference
+            return false;
+        }
+        psTrace("psModules.config", 3, "Supplementing %s from arguments.\n", item->name);
+
+        if (!psMetadataUpdate (current, recipe)) {
+            psError(PS_ERR_IO, false, "Failed to update recipe for %s from camera recipe", item->name);
+            return false;
+        }
     }
     psFree(recipesIter);
+    *status = true;
     return true;
 }
@@ -388 +447 @@
 // Load the recipes: each time we load a specific recipe, it overrides the metadata
 // entries for an existing recipe metadata
-static bool loadRecipeSymbols(pmConfig *config // The configuration into which to read the recipes
-                             )
-{
+static bool loadRecipeSymbols(bool *status,
+                              pmConfig *config // The configuration into which to read the recipes
+    )
+{
+    bool found = false;
+
+    assert(status);
     assert(config);
+    *status = false;
 
     // check to see if any symbolic names need to be resolved
-    // each entry in recipeSymbols are of the form NAME=REF where NAME is an existing
+    // each entry in recipeSymbols are of the form TARGET=SOURCE where TARGET is an existing
     // recipe MD and REF is a MD to load over that recipe
-    psMetadataIterator *recipesIter = psMetadataIteratorAlloc(config->recipeSymbols, PS_LIST_HEAD, NULL);
+    psMetadataIterator *iter = psMetadataIteratorAlloc(config->recipeSymbols, PS_LIST_HEAD, NULL);
     psMetadataItem *item = NULL;  // Item containing source, from iteration
-    while ((item = psMetadataGetAndIncrement(recipesIter))) {
+    while ((item = psMetadataGetAndIncrement(iter))) {
         assert(item->type == PS_DATA_STRING); // It should be this type: we put it in ourselves
-        const char *symbolRef = item->data.V; // The name of the symbolic reference
-        const char *symbolName = item->name;
-
-        // search for linkName in config->recipes
-        psMetadataItem *recipeItem = psMetadataLookup(config->recipes, symbolRef);
-        if (recipeItem) {
-            // if this named recipe exists, supplement it
-            assert(recipeItem->type == PS_DATA_METADATA);
-            psMetadata *recipe = recipeItem->data.V;
-            psTrace("psModules.config", 3, "Supplementing %s from %s.\n", symbolName, symbolRef);
-
-            psMetadata *current = NULL;
-            psMetadataItem *currentItem = psMetadataLookup(config->recipes, symbolName);
-            if (currentItem) {
-                assert(currentItem->type == PS_DATA_METADATA);
-                current = psMemIncrRefCounter(currentItem->data.V);
-            }
-
-            current = psMetadataCopy(current, recipe);
-            psMetadataAdd(config->recipes, PS_LIST_TAIL, symbolName, PS_DATA_METADATA | PS_META_REPLACE,
-                          symbolRef, current);
-            psFree(current);  // Drop reference
-            continue;
-        }
-
-        // search for linkName in config->recipes:NAME
-        psMetadata *current = psMetadataLookupMetadata(NULL, config->recipes, symbolName); // The source
-        if (current) {
-            psMetadataItem *recipeItem = psMetadataLookup(current, symbolRef);
-            if (recipeItem) {
-                assert(recipeItem->type == PS_DATA_METADATA);
-                psMetadata *recipe = recipeItem->data.V;
-                psTrace("psModules.config", 3, "Supplementing %s from %s metadata within %s.\n",
-                        symbolName, symbolRef, symbolRef);
-                psMetadataCopy (current, recipe);
-                psMetadataAdd(config->recipes, PS_LIST_TAIL, symbolName, PS_DATA_METADATA | PS_META_REPLACE,
-                              symbolRef, current);
-                continue;
-            }
-        }
-        // symbol is not found: ERROR
-    }
-    psFree(recipesIter);
+        const char *sourceName = item->data.V; // The name of the symbolic reference
+        const char *targetName = item->name;
+        psTrace("psModules.config", 3, "Supplementing %s from %s.\n", targetName, sourceName);
+
+        // the target recipe must exist; select it
+        psMetadata *targetMD = psMetadataLookupMetadata(&found, config->recipes, targetName);
+        if (!targetMD) {
+            psError(PS_ERR_IO, true, "Failed to find recipe for %s in master recipe list", targetName);
+            return false;
+        }
+
+        // search for sourceName : it may be in config->recipes or target MD
+        psMetadata *sourceMD = NULL;
+        sourceMD = psMetadataLookupMetadata(&found, config->recipes, sourceName);
+        if (!sourceMD) {
+            sourceMD = psMetadataLookupMetadata(&found, targetMD, sourceName);
+            if (!sourceMD) {
+                psError(PS_ERR_IO, false, "Selected symbolic name %s does not exist in recipes", sourceName);
+                return false;
+            }
+        }
+
+        if (!psMetadataUpdate(targetMD, sourceMD)) {
+            psError(PS_ERR_IO, false, "Failed to update recipe for %s from camera recipe", targetName);
+            return false;
+        }
+    }
+    psFree(iter);
+    *status = true;
     return true;
 }
@@ -449 +499 @@
 // Load the recipes: each time we load a specific recipe, it overrides the metadata
 // entries for an existing recipe metadata
-static bool loadRecipeOptions(pmConfig *config // The configuration into which to read the recipes
-                             )
-{
+static bool loadRecipeOptions(bool *status,
+                              pmConfig *config // The configuration into which to read the recipes
+    )
+{
+    bool found;
+    assert(status);
     assert(config);
+    *status = false;
+
     if (!config->arguments) {
         psTrace("psModules.config", 4, "no config->arguments metadata, nothing to read here");
-        return false;
-    }
-
-    psMetadata *recipes = psMetadataLookupMetadata(NULL, config->arguments, "OPTIONS"); // The list of recipes
+        return true;
+    }
+
+    psMetadata *recipes = psMetadataLookupMetadata(&found, config->arguments, "OPTIONS"); // The list of recipes
     if (!recipes) {
         psTrace("psModules.config", 4, "no OPTIONS in config->arguments, nothing to read here");
-        return false;
+        return true;
     }
 
@@ -468 +523 @@
     psMetadataItem *item = NULL;    // MD item containing the filename, from recipe iteration
     while ((item = psMetadataGetAndIncrement(recipesIter))) {
+        char *recipeName = item->name;
+        psMetadata *recipe = item->data.V;
+
         // type mismatch is a serious error
         if (item->type != PS_DATA_METADATA) {
-            psAbort("%s in config arguments OPTIONS is not of type METADATA", item->name);
-        }
-        // increment the ref counter to protect the data
-        psMetadata *recipe = psMemIncrRefCounter (item->data.V);
+            psAbort("%s in config arguments OPTIONS is not of type METADATA", recipeName);
+        }
 
         // if this named recipe exists, supplement it
-        psMetadata *current = NULL;
-        psMetadataItem *currentItem = psMetadataLookup(config->recipes, item->name);
-        if (currentItem) {
-            assert(currentItem->type == PS_DATA_METADATA);
-            current = psMemIncrRefCounter(currentItem->data.V);
-        }
-        current = psMetadataCopy (current, recipe);
-        psMetadataAdd(config->recipes, PS_LIST_TAIL, item->name, PS_DATA_METADATA | PS_META_REPLACE,
-                      "supplement command-line arguments", current);
-        psFree(recipe);  // Drop reference
-        psFree(current);  // Drop reference
+        psMetadata *current = psMetadataLookupMetadata(NULL, config->recipes, recipeName);
+        if (!current) {
+            psError(PS_ERR_IO, false, "Selected recipe %s is not found in camera recipe", recipeName);
+            return false;
+        }
+        if (!psMetadataUpdate (current, recipe)) {
+            psError(PS_ERR_IO, false, "Failed to update recipe for %s from camera recipe", recipeName);
+            return false;
+        }
     }
     psFree(recipesIter);
-    return true;
-}
-
-
+    *status = true;
+    return true;
+}