// from Istream blockDescriptor::blockDescriptor ( const pointField& blockMeshPoints, const curvedEdgeList& edges, Istream& is ) : blockMeshPoints_(blockMeshPoints), blockShape_(is), curvedEdges_(edges), edgePoints_(12), edgeWeights_(12), n_(), expand_(12), zoneName_() { // Look at first token token t(is); is.putBack(t); // Optional zone name if (t.isWord()) { zoneName_ = t.wordToken(); // Consume zoneName token is >> t; // New look-ahead is >> t; is.putBack(t); }
void Foam::dimensioned<Type>::initialize(Istream& is) { token nextToken(is); is.putBack(nextToken); // Check if the original format is used in which the name is provided // and reset the name to that read if (nextToken.isWord()) { is >> name_; is >> nextToken; is.putBack(nextToken); }
Foam::autoPtr<Foam::entry> Foam::entry::New(Istream& is) { is.fatalCheck("entry::New(Istream&)"); keyType keyword; // Get the next keyword and if invalid return false if (!getKeyword(keyword, is)) { return autoPtr<entry>(NULL); } else // Keyword starts entry ... { token nextToken(is); is.putBack(nextToken); if (nextToken == token::BEGIN_BLOCK) { return autoPtr<entry> ( new dictionaryEntry(keyword, dictionary::null, is) ); } else { return autoPtr<entry> ( new primitiveEntry(keyword, is) ); } } }
Foam::autoPtr<Foam::blockVertex> Foam::blockVertex::New ( const dictionary& dict, const label index, const searchableSurfaces& geometry, Istream& is ) { if (debug) { InfoInFunction << "Constructing blockVertex" << endl; } token firstToken(is); if (firstToken.isPunctuation() && firstToken.pToken() == token::BEGIN_LIST) { // Putback the opening bracket is.putBack(firstToken); return autoPtr<blockVertex> ( new blockVertices::pointVertex(dict, index, geometry, is) ); } else if (firstToken.isWord()) { const word faceType(firstToken.wordToken()); IstreamConstructorTable::iterator cstrIter = IstreamConstructorTablePtr_->find(faceType); if (cstrIter == IstreamConstructorTablePtr_->end()) { FatalErrorInFunction << "Unknown blockVertex type " << faceType << nl << nl << "Valid blockVertex types are" << endl << IstreamConstructorTablePtr_->sortedToc() << abort(FatalError); } return autoPtr<blockVertex>(cstrIter()(dict, index, geometry, is)); } else { FatalIOErrorInFunction(is) << "incorrect first token, expected <word> or '(', found " << firstToken.info() << exit(FatalIOError); return autoPtr<blockVertex>(nullptr); } }
bool Foam::functionEntries::ifeqEntry::evaluate ( const bool doIf, DynamicList<filePos>& stack, dictionary& parentDict, Istream& is ) { while (!is.eof()) { token t; readToken(t, is); if (t.isWord() && t.wordToken() == "#ifeq") { // Recurse to evaluate execute(stack, parentDict, is); } else if (t.isWord() && t.wordToken() == "#if") { // Recurse to evaluate ifEntry::execute(stack, parentDict, is); } else if ( doIf && t.isWord() && (t.wordToken() == "#else" || t.wordToken() == "#elif") ) { // Now skip until #endif skipUntil(stack, parentDict, "#endif", is); stack.remove(); break; } else if (t.isWord() && t.wordToken() == "#endif") { stack.remove(); break; } else { is.putBack(t); bool ok = entry::New(parentDict, is); if (!ok) { return false; } } } return true; }
Foam::splineEdge::splineEdge(const pointField& points, Istream& is) : curvedEdge(points, is), CatmullRomSpline(appendEndPoints(points, start_, end_, pointField(is))) { token t(is); is.putBack(t); // compatibility - might also have start/end tangents - discard them if (t == token::BEGIN_LIST) { vector tangent0Ignored(is); vector tangent1Ignored(is); } }
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 ); } } } }
void Foam::LPtrList<LListBase, T>::read(Istream& is, const INew& iNew) { is.fatalCheck ( "LPtrList<LListBase, T>::read(Istream&, const INew&)" ); token firstToken(is); is.fatalCheck ( "LPtrList<LListBase, T>::read(Istream&, const INew&) : " "reading first token" ); if (firstToken.isLabel()) { label s = firstToken.labelToken(); // Read beginning of contents char delimiter = is.readBeginList("LPtrList<LListBase, T>"); if (s) { if (delimiter == token::BEGIN_LIST) { for (label i=0; i<s; ++i) { this->append(iNew(is).ptr()); is.fatalCheck ( "LPtrList<LListBase, T>::read(Istream&, const INew&) : " "reading entry" ); } } else { T* tPtr = iNew(is).ptr(); this->append(tPtr); is.fatalCheck ( "LPtrList<LListBase, T>::read(Istream&, const INew&) : " "reading entry" ); for (label i=1; i<s; ++i) { this->append(tPtr->clone().ptr()); } } } // Read end of contents is.readEndList("LPtrList<LListBase, T>"); } else if (firstToken.isPunctuation()) { if (firstToken.pToken() != token::BEGIN_LIST) { FatalIOErrorIn ( "LPtrList<LListBase, T>::read(Istream&, const INew&)", is ) << "incorrect first token, '(', found " << firstToken.info() << exit(FatalIOError); } token lastToken(is); is.fatalCheck("LPtrList<LListBase, T>::read(Istream&, const INew&)"); while ( !( lastToken.isPunctuation() && lastToken.pToken() == token::END_LIST ) ) { is.putBack(lastToken); this->append(iNew(is).ptr()); is >> lastToken; is.fatalCheck ( "LPtrList<LListBase, T>::read(Istream&, const INew&)" ); } } else {
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 (keyword[0] == '#') // ... Function entry { word functionName = keyword(1, keyword.size()-1); return functionEntry::execute(functionName, parentDict, is); } else if (keyword[0] == '$') // ... Substitution entry { parentDict.substituteKeyword(keyword); return true; } else if (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()) { FatalIOErrorIn ( "entry::New(const dictionary& parentDict, Istream&)", 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 ); } } } }