void parseProgram(istream &inf, vector<Statement *> & program) { program.push_back(NULL); string line; while( ! inf.eof() ) { getline(inf, line); program.push_back( parseLine( line ) ); } }
//加载输入流 bool LanguageParsers::LoadInput(istream& ins) { if(ins.fail()) { return false; } this->input_symbols.clear(); char c=ins.get(); if(!ins.eof()) { do { this->input_symbols.push_back(Symbols(c)); c=ins.get(); }while(!ins.eof()); } return true; }
// Consume whitespace characters from stream. Leaves the stream // pointing at the next non-whitespace char (or possibly eof()); void skipWhiteSpace(istream &istr) { char next; istr >> next; // take advantage of the fact that >> uses whitespace as a field // separator if (!istr.eof()) { // If eof() is set, it means we didn't find any tokens after the whitespace. // In this case // there's nother to put back, and doing so would unset the eof bit. istr.putback(next); } }
void readExpression(istream& is, bitset* minterms, bitset* donotcare, uint8_t* varsCount) { char temp = '0'; long long number; bitset* currentSet = minterms; is >> number; *varsCount = number; cout << *varsCount << endl; if (is.fail() || int(*varsCount) > int(16)) throw logic_error("Variables count could not be read or invalid"); is >> temp; if (is.fail() || is.eof() || temp != ';') throw logic_error("Syntax error: expected ';'"); _t_minterm maxValue = (pow(2, *varsCount) - 1); minterms->resize(maxValue + 1); donotcare->resize(maxValue + 1); is >> number; if (!is.eof()) { while (true) { if (is.fail()) throw logic_error("Syntax error"); if (number > maxValue) throw out_of_range("Invalid min-term value: given value is greater than maximum"); currentSet->set(number); temp = '0'; is >> temp; if (is.fail() || is.eof() || (temp != ';' && temp != ',')) throw logic_error("Syntax error: expected ';'"); if (temp == ',') { is >> number; } else if (temp == ';') { if (currentSet == donotcare) break; else { currentSet = donotcare; is >> number; if (is.eof()) break; } } else { throw logic_error("Unhandled weird exception");
void HumdrumFileBasic::read(istream& inStream) { char* templine; templine = new char[4096]; int linecount = 0; while (!inStream.eof()) { inStream.getline(templine, 4096); #ifdef USING_URI if ((linecount++ == 0) && (strstr(templine, "://") != NULL)) { if (strncmp(templine, "http://", strlen("http://")) == 0) { readFromHttpURI(templine); delete [] templine; return; } if (strncmp(templine, "humdrum://", strlen("humdrum://")) == 0) { readFromHumdrumURI(templine); delete [] templine; return; } if (strncmp(templine, "hum://", strlen("hum://")) == 0) { readFromHumdrumURI(templine); delete [] templine; return; } if (strncmp(templine, "h://", strlen("h://")) == 0) { readFromHumdrumURI(templine); delete [] templine; return; } } #endif if (inStream.eof() && (strcmp(templine, "") == 0)) { break; } else { appendLine(templine); } } analyzeSpines(); analyzeDots(); delete [] templine; }
vector<string> splitString(char* rawSplit, istream& source, char delimiter, unsigned int estimatedSplitCount) { vector<string> splits; splits.reserve(estimatedSplitCount); while (!source.eof()) { source.getline(rawSplit, MAX_SPLIT_LENGTH, delimiter); splits.push_back(rawSplit); } return splits; }
bool SkipOnError(istream& istr){ if (istr.fail()){ if (istr.eof()){ exit(EXIT_FAILURE); } // skip one character char ch; istr.clear(); istr >> ch; return true; } else { return false;
void createProcesses(istream& ifs, vector<Process*>& processes) { while(!ifs.eof()) { unsigned id; unsigned arrivalTime; unsigned totalCPU; unsigned averageBurst; ifs >> id >> arrivalTime >> totalCPU >> averageBurst; Process* p = new Process(id, arrivalTime, totalCPU, averageBurst); processes.push_back(p); } }
bool getLine( istream &fileP, vector< string > &item ) { if (fileP.eof()) return false; string line; if (!getline(fileP, line)) return false; item = splitLine(line.c_str()); return true; }
// DO NOT CHANGE THIS PART... // DO NOT CHANGE THIS PART... // // This part will be used by TA to test your program. // // TA will use "make -DTA_KB_SETTING" to test your program // ParseChar CmdParser::getChar(istream& istr) const { char ch = mygetc(istr); if (istr.eof()) return returnCh(INPUT_END_KEY); switch (ch) { // Simple keys: one code for one key press // -- The following should be platform-independent case LINE_BEGIN_KEY: // Ctrl-a case LINE_END_KEY: // Ctrl-e case INPUT_END_KEY: // Ctrl-d case TAB_KEY: // tab('\t') or Ctrl-i case NEWLINE_KEY: // enter('\n') or ctrl-m return returnCh(ch); // -- The following simple/combo keys are platform-dependent // You should test to check the returned codes of these key presses // -- You should either modify the "enum ParseChar" definitions in // "charDef.h", or revise the control flow of the "case ESC" below case BACK_SPACE_KEY: return returnCh(ch); // Combo keys: multiple codes for one key press // -- Usually starts with ESC key, so we check the "case ESC" case ESC_KEY: { char combo = mygetc(istr); // Note: ARROW_KEY_INT == MOD_KEY_INT, so we only check MOD_KEY_INT if (combo == char(MOD_KEY_INT)) { char key = mygetc(istr); if ((key >= char(MOD_KEY_BEGIN)) && (key <= char(MOD_KEY_END))) { if (mygetc(istr) == MOD_KEY_DUMMY) return returnCh(int(key) + MOD_KEY_FLAG); else return returnCh(UNDEFINED_KEY); } else if ((key >= char(ARROW_KEY_BEGIN)) && (key <= char(ARROW_KEY_END))) return returnCh(int(key) + ARROW_KEY_FLAG); else return returnCh(UNDEFINED_KEY); } else { mybeep(); return getChar(istr); } } // For the remaining printable and undefined keys default: if (isprint(ch)) return returnCh(ch); else return returnCh(UNDEFINED_KEY); } return returnCh(UNDEFINED_KEY); }
void ScorePageBase::readPmx(istream& infile, int verboseQ) { clear(); ScoreItem* sip = NULL; while (!infile.eof()) { sip = readPmxScoreLine(infile, verboseQ); if (sip != NULL) { // setPageOwner will store the pointer for the ScoreItem // on the given page. The page will delete it when it // is deconstructed. sip->setPageOwner(this); } } }
// EOFまたは終了インジゲータが検出されるまでistからvに整数を読み取る void fill_vector(istream& ist, vector<int>& v, char terminator){ int i = 0; while(ist >> i) v.push_back(i); if(ist.eof()) return; // OK: EOFが検出された if(ist.fail()){ // できるだけ後始末をし、問題を報告する ist.clear(); // ストリームの状態をクリアし、終了インジゲータを調査できるようにする char c; ist >> c; // 文字を読み取る(終了インジゲータでありますように) if(c != terminator){ // 予想外の文字 ist.unget(); ist.clear(ios_base::failbit); // 状態をfailに設定する } }
string Utils::readStreamAsString(istream &inStream) { ostringstream result; while (true) { char got = static_cast<char>(inStream.get()); if (!inStream.eof()) { result << got; } else { break; } } return result.str(); }
obj ReplacementSelection<obj>::fill(istream& infile){ obj newelement; int i; int newIndex; infile>>newelement; for(i=0; i<size && !infile.eof(); i++){ heap[i]=newelement; leftEnd=i; heapify(true); infile>>newelement; } return newelement; }
void createPrimary(istream& read, ostream& primary){ int number,byte = 0; map<int,int> mymap; PrimaryIndex p; ClientData client; read.clear(); read.seekg(0); primary.seekp(0); if(read.eof())return; read >> client; while(!read.eof()){ if(number = client.getAccountNumber()){ mymap[number] = byte; byte = read.tellg(); } read >> client; } for(map<int,int>::iterator it = mymap.begin(); it != mymap.end(); it++){ p.AccountNumber = it->first; p.Byte = it->second; primary.write(reinterpret_cast<char*>(&p), sizeof(PrimaryIndex)); } }
void RecordProcess::AnalyseRecordStream(istream &RecordStream) { while(!RecordStream.eof()) { AnalyseARecord(RecordStream); } }
string GroceryItem::readName(istream &in) { long int eoln; char inval[255]; char *ptr; do { in.getline(inval,255); ptr = strchr(inval,'\0'); eoln = ptr -inval; } while (!eoln && !in.eof()); return string(inval); }
bool EGS_RandomGenerator::setState(istream &data) { if( !egsGetI64(data,count) ) return false; int np1; data >> np1 >> ip; if( !data.good() || data.fail() || data.eof() ) return false; if( np1 < 1 ) return false; if( np1 != np && np > 0 ) { delete [] rarray; rarray = new EGS_Float [np1]; } np = np1; for(int j=0; j<np; j++) data >> rarray[j]; if( !data.good() ) return false; return setPrivateState(data); }
string read_line(istream &in) { char c; string str; in.get(c); while(!in.eof() && c != '\n') { if(c != '\r') { str = str + c; } in.get(c); } return str; }
// read documents in a file, using the document buffer given as argument // (can be BoWDocument* or BoWDocumentST*) void readDocuments(istream& fileIn, ostream& out) { while (! fileIn.eof()) { // enum type with small number of values coded on one byte; BoWBlocType blocType; fileIn >> blocType; if (blocType==DOCUMENT_PROPERTIES_BLOC) { Lima::Common::Misc::DocumentProperties props; props.read(fileIn); props.write(out); fileIn >> blocType; } BoWText text; while (blocType==BOW_TEXT_BLOC) { text.read(fileIn); if (fileIn.eof()) break; fileIn >> blocType; } text.write(out); }
const char* LgScriptReader::read(State&, size_t *sz) { if (extraline) { extraline = false; *sz = 1; return "\n"; } if (infile->eof()) return NULL; infile->read(buff, sizeof(buff)); *sz = infile->gcount(); return buff; }
bool Lagenhet::laes( istream &is ) { // För varje lägenhet finns // följande information i filen: // koeksyta badrumsyta antalrum yta // för varje rum. // Exempel: // 20 12 3 20 10 10 // 12 12 2 15 10 // Rum har ingen egen inläsningsmetod. // Använd temporär variabel vid // inläsning. Om det gick bra: // använd konstruktor i Rum-klassen. int temp; // temporär variabel is >> temp; if ( is.eof() ) return false; koek = Rum(temp); is >> temp; if ( is.eof() ) return false; badrum = Rum(temp); is >> temp; if ( is.eof() ) return false; antalrum = temp; for ( int i = 0; i < antalrum; i++ ) { is >> temp; if ( is.eof() ) return false; rum[i] = Rum(temp); } return true; }
// Initialize a JSON array from a stream // This is similar to initFromStream() above and may also be called // recursively by way of initValueFromStream() // The expectation is that the first character will be a '[' and it // will run until if finds a matching ']' char. Along the way it // may create nested objects and/or arrays. // Note: It will consume the closing bracket from the stream void initArrayFromStream(JSONArray &arr, istream &istr) { char nextChar; istr >> nextChar; checkChar(nextChar, '['); // sanity check skipWhiteSpace(istr); // Check for empty array (and make sure we consume the ]) nextChar = static_cast<char>(istr.peek()); if (nextChar == ']') { istr.ignore(); } while (nextChar != ']') // process the stream { // Quick sanity check if (istr.eof()) { throw JSONParseException("Unexpected end of data stream"); } // We expect to start the loop with the stream pointing to the // first character of the value // Add the value to our array arr.push_back(initValueFromStream(istr)); istr >> nextChar; // nextChar is guaranteed to be either a comma, close brace or close // bracket. //(If it was anything else, initValueFromStream() would have thrown an // exception.) // A brace is an error, a bracket means the array is done (and will be // checked at // the start of the while loop) and a comma needs to be thrown out (along // with any // following whitespace) to position us for the next value if (nextChar == '}') throw JSONParseException( "Invalid closing brace while initializing array"); else if (nextChar == ',') { skipWhiteSpace(istr); // Check to see if another key/value pair really follows the comma // (because if one doesn't, the parser will get screwed up and may not // actually detect the problem). if (istr.peek() == ']') { throw JSONParseException( "Invalid comma (array ended with no further values)"); } } } }
int getFunctionInput(istream &fin, FunctionFormat &function) { function.prepUp(); fin.ignore(numeric_limits<streamsize>::max(), ':'); if(fin.eof()) return 1; //Could not find a function fin>>function.newname; if(!fin) return 1; //There was nothing after colon while(fin) { int temp; fin>>temp; if(fin) function.addReturn(temp); } fin.clear(); while(fin.peek()!=':' && !fin.eof()) { char temp_string[1000]; fin.getline(temp_string, 1000); stringstream case_string_stream(temp_string); Case temp_case; case_string_stream>>temp_case.oldname; while(case_string_stream) { int temp_int; case_string_stream>>temp_int; if(case_string_stream) temp_case.addArg(temp_int); } function.addCase(temp_case); } return 0; }
void GenBank::appendFromStream(istream & input, VectorSequenceContainer & vsc) const throw (Exception) { if (!input) { throw IOException ("GenBank::read: fail to open file"); } string temp, name, sequence = ""; // Initialization // Main loop : for all file lines while (!input.eof()) { getline(input, temp, '\n'); // Copy current line in temporary string if(temp.size() >= 9 && temp.substr(0,9) == "ACCESSION") { name = TextTools::removeSurroundingWhiteSpaces(temp.substr(10)); StringTokenizer st(name, " "); name = st.nextToken(); //cout << name << endl; } if(temp.size() >=6 && temp.substr(0,6) == "ORIGIN") { sequence = ""; getline(input, temp, '\n'); // Copy current line in temporary string while(!input.eof() && temp.size() > 2 && temp.substr(0,2) != "//") { sequence += TextTools::removeWhiteSpaces(temp.substr(10)); getline(input, temp, '\n'); // Copy current line in temporary string } if(name == "") throw Exception("GenBank::read(). Sequence with no ACCESSION number!"); Sequence * seq = new Sequence(name, sequence, vsc.getAlphabet()); vsc.addSequence(* seq); name = ""; } } }
void ConfigFile::read(istream& in) { _map.clear(); int lineNumber = 0; while (! in.eof()) { string line; getline(in, line); trim(line); ++lineNumber; if (line == "" || line[0] == '#') continue; handleLine(line, lineNumber); } }
bool CanberraCnfDataSet::check(istream &f, string*) { int acq_offset = 0; f.ignore(112); int pos = 112; char buf[48]; while (!f.eof()) { f.read(buf, 48); if (f.gcount() != 48) return false; if ((buf[1] != 0x20 || buf[2] != 0x01) && buf[1] != 0 && buf[2] != 0) return false; pos += 48; if (buf[0] == 0) { acq_offset = from_le<uint32_t>(buf+10); break; } } if (acq_offset <= pos) return false; f.ignore(acq_offset - pos); f.read(buf, 48); return (!f.eof() && f.gcount() == 48 && buf[0] == 0 && buf[1] == 0x20); }
//------------------------------------------------------------------------------------------------------------------------------------------ /// bool SyncRecordManager::istreamMatrix( istream &is, const char *header, double m[16], const bool verbose ) { if( !istreamSkipPastEOL( is, 1 ) ){ cerr << "SyncRecordManager::istreamMatrix(): cannot skip header line '" << header << "'" << endl; return false; } // later we can scan in the header and actually verify it int err = 0; for( int i = 0 ; i < 4 ; ++i ) for( int j = 0 ; j < 4 ; ++j ) if( !is.eof() && is.good() ) err += !( is >> m[4*i+j] ); if( err ){ cerr << "SyncRecordManager::istreamMatrix(): could not read " << header << " matrix" << endl; return false; } if( verbose ){ cout << "SyncRecordManager::istreamMatrix(): read following matrix:" << endl; ostreamMatrix( cout, header, m ); } if( !istreamSkipPastEOL( is, 1 ) ){ cerr << "SyncRecordManager::istreamMatrix(): cannot skip to end of matrix" << endl; return false; } return true; }
void translateStream(istream& in, ostream& out){ char s[60]; char t[60]; in>>s; if(!in.eof()){ translateWord(s,t); out<<t<<" "; out<<"00000"; translateStream(in,out); } return; }
void printStreamState(const istream& istr) { if (istr.good()) { cout << "stream state is good" << endl; } if (istr.bad()) { cout << "stream state is bad" << endl; } if (istr.fail()) { cout << "stream state is fail" << endl; } if (istr.eof()) { cout << "stream state is eof" << endl; } }