bool Foam::entry::New(dictionary& parentDict, Istream& is) { is.fatalCheck("entry::New(const dictionary& parentDict, Istream&)"); keyType keyword; // Get the next keyword and if invalid return false if (!getKeyword(keyword, is)) { return false; } else // Keyword starts entry ... { if ( !disableFunctionEntries && keyword[0] == '#' ) // ... Function entry { word functionName = keyword(1, keyword.size()-1); return functionEntry::execute(functionName, parentDict, is); } else if ( !disableFunctionEntries && keyword[0] == '$' ) // ... Substitution entry { token nextToken(is); is.putBack(nextToken); if (keyword.size() > 2 && keyword[1] == token::BEGIN_BLOCK) { // Recursive substitution mode. Replace between {} with // expansion and then let standard variable expansion deal // with rest. string s(keyword(2, keyword.size()-3)); // Substitute dictionary and environment variables. Do not allow // empty substitutions. stringOps::inplaceExpand(s, parentDict, true, false); keyword.std::string::replace(1, keyword.size()-1, s); } if (nextToken == token::BEGIN_BLOCK) { word varName = keyword(1, keyword.size()-1); // lookup the variable name in the given dictionary const entry* ePtr = parentDict.lookupScopedEntryPtr ( varName, true, true ); if (ePtr) { // Read as primitiveEntry const keyType newKeyword(ePtr->stream()); return parentDict.add ( new dictionaryEntry(newKeyword, parentDict, is), false ); } else { FatalIOErrorInFunction(is) << "Attempt to use undefined variable " << varName << " as keyword" << exit(FatalIOError); return false; } } else { parentDict.substituteScopedKeyword(keyword); } return true; } else if ( !disableFunctionEntries && keyword == "include" ) // ... For backward compatibility { return functionEntries::includeEntry::execute(parentDict, is); } else // ... Data entries { token nextToken(is); is.putBack(nextToken); // Deal with duplicate entries bool mergeEntry = false; // See (using exact match) if entry already present entry* existingPtr = parentDict.lookupEntryPtr ( keyword, false, false ); if (existingPtr) { if (functionEntries::inputModeEntry::merge()) { mergeEntry = true; } else if (functionEntries::inputModeEntry::overwrite()) { // clear dictionary so merge acts like overwrite if (existingPtr->isDict()) { existingPtr->dict().clear(); } mergeEntry = true; } else if (functionEntries::inputModeEntry::protect()) { // read and discard the entry if (nextToken == token::BEGIN_BLOCK) { dictionaryEntry dummy(keyword, parentDict, is); } else { primitiveEntry dummy(keyword, parentDict, is); } return true; } else if (functionEntries::inputModeEntry::error()) { FatalIOErrorInFunction(is) << "ERROR! duplicate entry: " << keyword << exit(FatalIOError); return false; } } if (nextToken == token::BEGIN_BLOCK) { return parentDict.add ( new dictionaryEntry(keyword, parentDict, is), mergeEntry ); } else { return parentDict.add ( new primitiveEntry(keyword, parentDict, is), mergeEntry ); } } } }