| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // G4tgrFileIn implementation <<
27 // 26 //
28 // Author: P.Arce, CIEMAT (November 2007) << 27 // $Id: G4tgrFileIn.cc,v 1.13 2010-12-15 11:29:54 arce Exp $
29 // ------------------------------------------- << 28 // GEANT4 tag $Name: not supported by cvs2svn $
>> 29 //
>> 30 //
>> 31 // class G4tgrFileIn
>> 32
>> 33 // History:
>> 34 // - Created. P.Arce, CIEMAT (November 2007)
>> 35 // -------------------------------------------------------------------------
30 36
31 #include "globals.hh" 37 #include "globals.hh"
32 38
33 #include <iostream> 39 #include <iostream>
34 #include <fstream> 40 #include <fstream>
35 #include <sstream> 41 #include <sstream>
36 42
37 #include "G4tgrFileIn.hh" 43 #include "G4tgrFileIn.hh"
38 #include "G4tgrMessenger.hh" 44 #include "G4tgrMessenger.hh"
39 #include "G4tgrUtils.hh" 45 #include "G4tgrUtils.hh"
40 #include "G4UIcommand.hh" 46 #include "G4UIcommand.hh"
41 47
42 G4ThreadLocal std::vector<G4tgrFileIn*>* G4tgr << 48 std::vector<G4tgrFileIn*> G4tgrFileIn::theInstances;
>> 49
43 50
44 // ------------------------------------------- << 51 //-----------------------------------------------------------------------
45 G4tgrFileIn::G4tgrFileIn() 52 G4tgrFileIn::G4tgrFileIn()
>> 53 : theCurrentFile(-1), theName("")
46 { 54 {
47 if(theInstances == nullptr) <<
48 { <<
49 theInstances = new std::vector<G4tgrFileIn <<
50 } <<
51 } 55 }
52 56
53 // ------------------------------------------- <<
54 G4tgrFileIn::~G4tgrFileIn() <<
55 { <<
56 delete theInstances; <<
57 theInstances = nullptr; <<
58 /* <<
59 for( auto vfcite = theInstances->cbegin(); <<
60 vfcite != theInstances->cend(); <<
61 { <<
62 delete *vfcite; <<
63 } <<
64 */ <<
65 } <<
66 57
67 // ------------------------------------------- << 58 //-----------------------------------------------------------------------
68 G4tgrFileIn& G4tgrFileIn::GetInstance(const G4 << 59 G4tgrFileIn::~G4tgrFileIn()
69 { 60 {
70 if(theInstances == nullptr) << 61 /*
>> 62 std::vector<G4tgrFileIn*>::const_iterator vfcite;
>> 63 for( vfcite = theInstances.begin(); vfcite != theInstances.end(); vfcite++)
71 { 64 {
72 theInstances = new std::vector<G4tgrFileIn << 65 delete *vfcite;
73 } 66 }
>> 67 */
>> 68 }
>> 69
74 70
>> 71 //-----------------------------------------------------------------------
>> 72 G4tgrFileIn& G4tgrFileIn::GetInstance( const G4String& filename )
>> 73 {
75 std::vector<G4tgrFileIn*>::const_iterator vf 74 std::vector<G4tgrFileIn*>::const_iterator vfcite;
76 for(vfcite = theInstances->cbegin(); vfcite << 75 for( vfcite = theInstances.begin(); vfcite != theInstances.end(); vfcite++)
77 { 76 {
78 if((*vfcite)->GetName() == filename) << 77 if( (*vfcite)->GetName() == filename)
79 { 78 {
80 return *(*vfcite); 79 return *(*vfcite);
81 } 80 }
82 } 81 }
83 82
84 G4tgrFileIn* instance = nullptr; << 83 G4tgrFileIn* instance = 0;
85 if(vfcite == theInstances->cend()) << 84 if( vfcite == theInstances.end() )
86 { 85 {
87 instance = new G4tgrFileIn(filename); << 86 instance = new G4tgrFileIn( filename );
88 << 87
89 instance->theCurrentFile = -1; 88 instance->theCurrentFile = -1;
90 instance->OpenNewFile(filename.c_str()); << 89 instance->OpenNewFile( filename.c_str() );
91 90
92 theInstances->push_back(instance); << 91 theInstances.push_back( instance );
93 } 92 }
94 93
95 return *instance; 94 return *instance;
96 } 95 }
97 96
98 // ------------------------------------------- << 97
99 void G4tgrFileIn::OpenNewFile(const char* file << 98 //-----------------------------------------------------------------------
100 { << 99 void G4tgrFileIn::OpenNewFile( const char* filename )
101 ++theCurrentFile; << 100 {
>> 101 theCurrentFile++;
102 std::ifstream* fin = new std::ifstream(filen 102 std::ifstream* fin = new std::ifstream(filename);
103 theFiles.push_back(fin); 103 theFiles.push_back(fin);
104 104
105 theLineNo.push_back(0); << 105 theLineNo.push_back( 0 );
106 106
107 theNames.push_back(filename); << 107 theNames.push_back( filename );
108 108
109 #ifndef OS_SUN_4_2 109 #ifndef OS_SUN_4_2
110 if(!fin->is_open()) << 110 if( !fin->is_open() )
111 { 111 {
112 G4String ErrMessage = "Input file does not 112 G4String ErrMessage = "Input file does not exist: " + G4String(filename);
113 G4Exception("G4tgrFileIn::OpenNewFile()", << 113 G4Exception("G4tgrFileIn::OpenNewFile()",
114 ErrMessage); << 114 "InvalidInput", FatalException, ErrMessage);
115 } 115 }
116 #endif 116 #endif
117 } 117 }
118 118
119 // ------------------------------------------- << 119
120 G4tgrFileIn& G4tgrFileIn::GetInstanceOpened(co << 120 //-----------------------------------------------------------------------
>> 121 G4tgrFileIn& G4tgrFileIn::GetInstanceOpened( const G4String& filename )
121 { 122 {
>> 123
122 G4tgrFileIn& filein = G4tgrFileIn::GetInstan 124 G4tgrFileIn& filein = G4tgrFileIn::GetInstance(filename);
123 if(filein.GetName() != filename) << 125 if (filein.GetName() != filename )
124 { 126 {
125 G4String ErrMessage = "File not opened yet 127 G4String ErrMessage = "File not opened yet: " + filename;
126 G4Exception("G4tgrFileIn::GetInstanceOpene << 128 G4Exception("G4tgrFileIn::GetInstanceOpened()",
127 FatalException, ErrMessage); << 129 "InvalidInput", FatalException, ErrMessage);
128 } 130 }
129 else 131 else
130 { 132 {
131 return filein; 133 return filein;
132 } 134 }
133 return filein; // to avoid compilation warn << 135 return filein; // to avoid compilation warnings
134 } 136 }
135 137
136 // ------------------------------------------- << 138
137 G4int G4tgrFileIn::GetWordsInLine(std::vector< << 139 //-----------------------------------------------------------------------
>> 140 G4int G4tgrFileIn::GetWordsInLine( std::vector<G4String>& wordlist)
138 { 141 {
139 G4int isok = 1; 142 G4int isok = 1;
140 143
141 //---------- Read a line of file: 144 //---------- Read a line of file:
142 // NOTE: cannot be read with a ist 145 // NOTE: cannot be read with a istream_iterator,
143 // because it uses G4cout, and the 146 // because it uses G4cout, and then doesn't read '\n'
144 //----- Clear wordlist 147 //----- Clear wordlist
145 G4int wsiz = (G4int)wordlist.size(); << 148 G4int wsiz = wordlist.size();
146 G4int ii; 149 G4int ii;
147 for(ii = 0; ii < wsiz; ++ii) << 150 for (ii = 0; ii < wsiz; ii++)
148 { 151 {
149 wordlist.pop_back(); 152 wordlist.pop_back();
150 } << 153 }
151 154
152 //---------- Loop lines while there is an en << 155 //---------- Loop lines while there is an ending '\' or line is blank
153 const G4int NMAXLIN = 1000; 156 const G4int NMAXLIN = 1000;
154 char ltemp[NMAXLIN]; // there won't be line << 157 char ltemp[NMAXLIN]; // there won't be lines longer than NMAXLIN characters
155 for(;;) << 158 for (;;)
156 { 159 {
157 (theLineNo[theCurrentFile])++; 160 (theLineNo[theCurrentFile])++;
158 for(ii = 0; ii < NMAXLIN; ++ii) << 161 for ( ii = 0; ii < NMAXLIN; ii++) { ltemp[ii] = ' '; }
159 { << 162 theFiles[theCurrentFile]->getline( ltemp, NMAXLIN );
160 ltemp[ii] = ' '; <<
161 } <<
162 theFiles[theCurrentFile]->getline(ltemp, N <<
163 163
164 //---------- Check for lines longer than N 164 //---------- Check for lines longer than NMAXLIN character
165 for(ii = 0; ii < NMAXLIN; ++ii) << 165 for ( ii=0; ii < NMAXLIN; ii++)
166 { 166 {
167 if(ltemp[ii] == '\0') << 167 if ( ltemp[ii] == '\0' ) { break; }
168 { <<
169 break; <<
170 } <<
171 } 168 }
172 if(ii == NMAXLIN - 1) << 169 if ( ii == NMAXLIN-1 )
173 { 170 {
174 ErrorInLine(); 171 ErrorInLine();
175 G4String ErrMessage = "Too long line. Pl << 172 G4String ErrMessage = "Too long line. Please split it "
176 G4String("putting << 173 + G4String("putting a '\\' at the end!");
177 G4Exception("G4tgrFileIn::GetWordsInLine 174 G4Exception("G4tgrFileIn::GetWordsInLine()", "InvalidInput",
178 FatalException, ErrMessage); 175 FatalException, ErrMessage);
179 } 176 }
180 << 177
181 //---------- End of file 178 //---------- End of file
182 if(EndOfFile()) << 179 if ( EndOfFile() )
183 { 180 {
184 return 0; 181 return 0;
185 } 182 }
186 << 183
187 //---------- Convert line read to istrstre << 184 //---------- Convert line read to istrstream to split it in words
188 std::istringstream istr_line(ltemp); 185 std::istringstream istr_line(ltemp);
189 << 186
190 //--------- Count how many words are there 187 //--------- Count how many words are there in ltemp
191 // this shouln't be needed, but S 188 // this shouln't be needed, but SUN compiler has problems...
192 G4int NoWords = 0; 189 G4int NoWords = 0;
193 char* tt = ltemp; << 190 char* tt = ltemp;
194 191
195 G4String stemp(ltemp); 192 G4String stemp(ltemp);
196 do 193 do
197 { 194 {
198 if(*tt != ' ' && *(tt) != '\0') << 195 if( *tt != ' ' && *(tt) != '\0' )
199 { 196 {
200 if(tt == ltemp) << 197 if( tt == ltemp)
201 { 198 {
202 ++NoWords; << 199 NoWords++;
203 #ifdef G4VERBOSE 200 #ifdef G4VERBOSE
204 if(G4tgrMessenger::GetVerboseLevel() << 201 if( G4tgrMessenger::GetVerboseLevel() >= 3 )
205 { 202 {
206 G4cout << "G4tgrFileIn::GetWordsIn << 203 G4cout << "G4tgrFileIn::GetWordsInLine() - NoWords"
207 << ltemp << G4endl; << 204 << NoWords << ltemp << G4endl;
208 } 205 }
209 #endif 206 #endif
210 } 207 }
211 else if(*(tt - 1) == ' ' || *(tt - 1) << 208 else if( *(tt-1) == ' ' || *(tt-1) == '\015' || *(tt-1) == '\t')
212 { 209 {
213 ++NoWords; << 210 NoWords++;
214 #ifdef G4VERBOSE 211 #ifdef G4VERBOSE
215 if(G4tgrMessenger::GetVerboseLevel() << 212 if( G4tgrMessenger::GetVerboseLevel() >= 3 )
216 { 213 {
217 G4cout << "G4tgrFileIn::GetWordsIn << 214 G4cout << "G4tgrFileIn::GetWordsInLine() - NoWords"
218 << ltemp << G4endl; << 215 << NoWords << ltemp << G4endl;
219 } 216 }
220 #endif 217 #endif
221 } 218 }
222 } 219 }
223 ++tt; << 220 tt++;
224 } while((*tt != '\0') && (stemp.length() ! << 221 } while((*tt != '\0') && (stemp.length()!=0));
225 222
226 if(stemp.length() == 0) << 223 G4String stempt (ltemp);
227 { << 224 if(stempt.length() == 0) { NoWords = 0; }
228 NoWords = 0; <<
229 } <<
230 225
231 //--------- Read words from istr_line and 226 //--------- Read words from istr_line and write them into wordlist
232 for(ii = 0; ii < NoWords; ++ii) << 227 for( ii=0; ii < NoWords; ii++)
233 { 228 {
234 stemp = ""; << 229 G4String stemp = "";
235 istr_line >> stemp; 230 istr_line >> stemp;
236 if(stemp.length() == 0) << 231 if ( stemp.length() == 0 ) { break; }
237 { << 232 G4int comment = stemp.find(G4String("//") );
238 break; <<
239 } <<
240 G4int comment = (G4int)stemp.find(G4Stri <<
241 #ifdef G4VERBOSE 233 #ifdef G4VERBOSE
242 if(G4tgrMessenger::GetVerboseLevel() >= << 234 if( G4tgrMessenger::GetVerboseLevel() >= 3 )
243 { 235 {
244 G4cout << "!!!COMMENT" << comment << s 236 G4cout << "!!!COMMENT" << comment << stemp.c_str() << G4endl;
245 } 237 }
246 #endif 238 #endif
247 if(comment == 0) << 239 if ( comment == 0 )
248 { 240 {
249 break; << 241 break;
250 } 242 }
251 else if(comment > 0) << 243 else if ( comment > 0 )
252 { 244 {
253 stemp = stemp.substr(0, comment); << 245 stemp = stemp.substr( 0, comment );
254 wordlist.push_back(std::move(stemp)); << 246 wordlist.push_back(stemp);
255 break; 247 break;
256 } << 248 }
257 wordlist.push_back(std::move(stemp)); << 249 wordlist.push_back(stemp);
258 } 250 }
259 << 251
260 // These two algorithms should be the more 252 // These two algorithms should be the more STL-like way, but they don't
261 // work for files whose lines end without 253 // work for files whose lines end without '\015'=TAB (STL problem: doesn't
262 // find end of string??): 254 // find end of string??):
263 // istream_iterator<G4String, ptrdiff_t> G 255 // istream_iterator<G4String, ptrdiff_t> G4String_iter(istr_line);
264 // istream_iterator<G4String, ptrdiff_t> e 256 // istream_iterator<G4String, ptrdiff_t> eosl;
265 // copy(G4String_iter, eosl, back_inserter 257 // copy(G4String_iter, eosl, back_inserter(wordlist));
266 // typedef istream_iterator<G4String, ptrd 258 // typedef istream_iterator<G4String, ptrdiff_t> G4String_iter;
267 // copy(G4String_iter(istr_line), G4String 259 // copy(G4String_iter(istr_line), G4String_iter(), back_inserter(wordlist));
268 << 260
269 if(wordlist.size() != 0) << 261 if ( wordlist.size() != 0 )
270 { 262 {
271 if((*(wordlist.end() - 1)).compare("\\") << 263 if( (*(wordlist.end()-1)).compare("\\") == 0 ) // use '\' to mark
272 { << 264 { // continuing line
273 wordlist.pop_back(); 265 wordlist.pop_back();
274 } 266 }
275 else 267 else
276 { 268 {
277 break; 269 break;
278 } 270 }
279 } 271 }
280 } 272 }
281 << 273
282 //--------- A pair of double quotes delimits 274 //--------- A pair of double quotes delimits a word, therefore, look for the
283 // case where there is more than on 275 // case where there is more than one word between two double quotes
284 std::vector<G4String> wordlist2; 276 std::vector<G4String> wordlist2;
285 G4String wordq = ""; << 277 G4String wordq = "";
286 unsigned int imerge = 0; 278 unsigned int imerge = 0;
287 for(std::size_t jj = 0; jj < wordlist.size() << 279 for( size_t ii = 0; ii < wordlist.size(); ii++)
288 { 280 {
289 if(wordlist[jj].substr(0, 1) == "\"") << 281 if( wordlist[ii].substr(0,1) == "\"" )
290 { 282 {
291 imerge = 1; 283 imerge = 1;
292 } << 284 }
293 if(wordlist[jj][G4int(wordlist[jj].size() << 285 if( wordlist[ii][ wordlist[ii].size()-1 ] == '\"' )
294 { 286 {
295 if(imerge != 1) << 287 if( imerge != 1 )
296 { 288 {
297 const G4String& err1 = " word with tra << 289 G4String err1 = " word with trailing '\"' while there is no";
298 const G4String& err2 = " previous word << 290 G4String err2 = " previous word with leading '\"' in line ";
299 const G4String& err = err1 + err2; << 291 G4String err = err1 + err2;
300 DumpException(err); 292 DumpException(err);
301 } 293 }
302 imerge = 2; 294 imerge = 2;
303 } 295 }
304 if(imerge == 0) << 296 if( imerge == 0 )
305 { 297 {
306 wordlist2.push_back(wordlist[jj]); << 298 wordlist2.push_back( wordlist[ii] );
307 } 299 }
308 else if(imerge == 1) << 300 else if( imerge == 1 )
309 { 301 {
310 if(wordq == "") << 302 if( wordq == "" )
311 { 303 {
312 wordq.append(wordlist[jj].substr(1, wo << 304 wordq.append( wordlist[ii].substr(1,wordlist[ii].size()) );
313 } 305 }
314 else 306 else
315 { 307 {
316 wordq.append(wordlist[jj].substr(0, wo << 308 wordq.append( wordlist[ii].substr(0,wordlist[ii].size()) );
317 } 309 }
318 wordq.append(" "); 310 wordq.append(" ");
319 } 311 }
320 else if(imerge == 2) << 312 else if( imerge == 2 )
321 { 313 {
322 if(wordq == "") << 314 if( wordq == "" )
323 { 315 {
324 wordq.append(wordlist[jj].substr(1, wo << 316 wordq.append( wordlist[ii].substr(1,wordlist[ii].size()-2));
325 } 317 }
326 else 318 else
327 { 319 {
328 wordq.append(wordlist[jj].substr(0, wo << 320 wordq.append( wordlist[ii].substr(0,wordlist[ii].size()-1) );
329 } << 321 }
330 wordlist2.push_back(wordq); << 322 wordlist2.push_back( wordq );
331 wordq = ""; << 323 wordq = "";
332 imerge = 0; 324 imerge = 0;
333 } 325 }
334 } 326 }
335 if(imerge == 1) << 327 if( imerge == 1 )
336 { 328 {
337 const G4String& err1 = " word with leading << 329 G4String err1 = " word with leading '\"' in line while there is no";
338 const G4String& err2 = " later word with t << 330 G4String err2 = " later word with trailing '\"' in line ";
339 const G4String& err = err1 + err2; << 331 G4String err = err1 + err2;
340 DumpException(err); 332 DumpException(err);
341 } 333 }
342 334
343 wordlist = std::move(wordlist2); << 335 wordlist = wordlist2;
344 336
345 // Or why not like this (?): 337 // Or why not like this (?):
346 // typedef std::istream_iterator<G4String, p 338 // typedef std::istream_iterator<G4String, ptrdiff_t> string_iter;
347 // std::copy(string_iter(istr_line), string_ 339 // std::copy(string_iter(istr_line), string_iter(), back_inserter(wordlist));
348 << 340
349 // check if including a new file 341 // check if including a new file
350 if(wordlist[0] == "#include") << 342 if( wordlist[0] == "#include" )
351 { 343 {
352 if(wordlist.size() != 2) << 344 if( wordlist.size() != 2 )
353 { 345 {
354 ErrorInLine(); 346 ErrorInLine();
355 G4String ErrMessage = << 347 G4String ErrMessage
356 "'#include' should have as second argu << 348 = "'#include' should have as second argument, the filename !";
357 G4Exception("G4tgrFileIn::GetWordsInLine 349 G4Exception("G4tgrFileIn::GetWordsInLine()", "InvalidInput",
358 FatalException, ErrMessage); 350 FatalException, ErrMessage);
359 } 351 }
360 352
361 #ifdef G4VERBOSE 353 #ifdef G4VERBOSE
362 if(G4tgrMessenger::GetVerboseLevel() >= 3) << 354 if( G4tgrMessenger::GetVerboseLevel() >= 3 )
363 { 355 {
364 G4cout << " G4tgrFileIn::GetWordsInLine( 356 G4cout << " G4tgrFileIn::GetWordsInLine() - Include found !" << G4endl;
365 } 357 }
366 #endif 358 #endif
367 OpenNewFile(wordlist[1].c_str()); << 359 OpenNewFile( wordlist[1].c_str() );
368 isok = GetWordsInLine(wordlist); << 360 isok = GetWordsInLine( wordlist);
369 } 361 }
370 362
371 return isok; 363 return isok;
372 } 364 }
373 365
374 // ------------------------------------------- << 366
>> 367 //-----------------------------------------------------------------------
375 void G4tgrFileIn::ErrorInLine() 368 void G4tgrFileIn::ErrorInLine()
376 { 369 {
377 G4cerr << "!! EXITING: ERROR IN LINE No " << << 370 G4cerr << "!! EXITING: ERROR IN LINE No "
378 << " file: " << theNames[theCurrentFi << 371 << theLineNo[theCurrentFile] << " file: "
>> 372 << theNames[theCurrentFile] << " : ";
379 } 373 }
380 374
381 // ------------------------------------------- << 375
>> 376 //-----------------------------------------------------------------------
382 G4bool G4tgrFileIn::EndOfFile() 377 G4bool G4tgrFileIn::EndOfFile()
383 { 378 {
384 G4bool isok = theFiles[theCurrentFile]->eof( 379 G4bool isok = theFiles[theCurrentFile]->eof();
385 if(isok) << 380 if( isok )
386 { 381 {
387 #ifdef G4VERBOSE 382 #ifdef G4VERBOSE
388 if(G4tgrMessenger::GetVerboseLevel() >= 3) << 383 if( G4tgrMessenger::GetVerboseLevel() >= 3 )
389 { 384 {
390 G4cout << " G4tgrFileIn::EndOfFile() - E << 385 G4cout << " G4tgrFileIn::EndOfFile() - EOF: "
>> 386 << theCurrentFile << G4endl;
391 } 387 }
392 #endif 388 #endif
393 --theCurrentFile; << 389 theCurrentFile--;
394 if(theCurrentFile != -1) // Last file wil << 390 if( theCurrentFile != -1 ) // Last file will be closed by the user
395 { 391 {
396 Close(); 392 Close();
397 } 393 }
398 } 394 }
399 395
400 // Only real closing if all files are closed 396 // Only real closing if all files are closed
401 #ifdef G4VERBOSE 397 #ifdef G4VERBOSE
402 if(G4tgrMessenger::GetVerboseLevel() >= 3) << 398 if( G4tgrMessenger::GetVerboseLevel() >= 3 )
403 { 399 {
404 G4cout << " G4tgrFileIn::EndOfFile() - EOF << 400 G4cout << " G4tgrFileIn::EndOfFile() - EOF: "
405 << theCurrentFile << G4endl; << 401 << isok << " " << theCurrentFile << G4endl;
406 } 402 }
407 #endif 403 #endif
408 if(theCurrentFile != -1) << 404 if( theCurrentFile != -1 )
409 { << 405 {
410 return false; << 406 return 0;
411 } 407 }
412 else 408 else
413 { 409 {
414 return isok; 410 return isok;
415 } 411 }
416 } 412 }
417 413
418 // ------------------------------------------- << 414
>> 415 //-----------------------------------------------------------------------
419 void G4tgrFileIn::Close() 416 void G4tgrFileIn::Close()
420 { 417 {
421 #ifdef G4VERBOSE 418 #ifdef G4VERBOSE
422 if(G4tgrMessenger::GetVerboseLevel() >= 3) << 419 if( G4tgrMessenger::GetVerboseLevel() >= 3 )
423 { 420 {
424 G4cout << "G4tgrFileIn::Close() - " << the << 421 G4cout << "G4tgrFileIn::Close() - "
425 << theFiles.size() << G4endl; << 422 << theCurrentFile << ", size " << theFiles.size() << G4endl;
426 } 423 }
427 #endif 424 #endif
428 425
429 theFiles[theCurrentFile + 1]->close(); << 426 theFiles[theCurrentFile+1]->close();
430 theFiles.pop_back(); 427 theFiles.pop_back();
431 } 428 }
432 429
433 // ------------------------------------------- << 430
434 void G4tgrFileIn::DumpException(const G4String << 431 //-----------------------------------------------------------------------
>> 432 void G4tgrFileIn::DumpException( const G4String& sent )
435 { 433 {
436 const G4String& Err1 = sent + " in file " + << 434 G4String Err1 = sent + " in file " + theName;
437 const G4String& Err2 = << 435 G4String Err2 = " line No: "
438 ", line No: " + G4UIcommand::ConvertToStri << 436 + G4UIcommand::ConvertToString(theLineNo[theCurrentFile]);
439 const G4String& ErrMessage = Err1 + Err2; << 437 G4String ErrMessage = Err1;
440 G4Exception("G4tgrFileIn::DumpException()", 438 G4Exception("G4tgrFileIn::DumpException()", "FileError",
441 FatalException, ErrMessage); << 439 FatalException, ErrMessage);
442 } 440 }
>> 441
443 442