ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/mdtools/generic_stamps/MoleculeStamp.cpp
(Generate patch)

Comparing trunk/mdtools/generic_stamps/MoleculeStamp.cpp (file contents):
Revision 160 by mmeineke, Wed Oct 30 22:38:22 2002 UTC vs.
Revision 173 by mmeineke, Mon Nov 11 17:25:15 2002 UTC

# Line 4 | Line 4
4   #include <iostream>
5  
6   #include "MoleculeStamp.hpp"
7 – #include "simError.h"
7  
8   MoleculeStamp::MoleculeStamp(){
9    
# Line 50 | Line 49 | MoleculeStamp::~MoleculeStamp(){
49    
50   }
51  
52 < void MoleculeStamp::assignString( char* lhs, char* rhs ){
52 > char* MoleculeStamp::assignString( char* lhs, char* rhs ){
53    
54    if( !strcmp( lhs, "name" ) ){
55      strcpy( name, rhs );
# Line 61 | Line 60 | void MoleculeStamp::assignString( char* lhs, char* rhs
60      else unhandled->add( lhs, rhs );
61      have_extras = 1;
62    }
63 +  return NULL;
64   }
65  
66 < void MoleculeStamp::assignDouble( char* lhs, double rhs ){
66 > char* MoleculeStamp::assignDouble( char* lhs, double rhs ){
67    int i;
68  
69    if( !strcmp( lhs, "nAtoms" ) ){
70      n_atoms = (int)rhs;
71      
72      if( have_atoms ){
73 <      sprintf( painCave.errMsg,
73 >      sprintf( errMsg,
74                 "MoleculeStamp error, n_atoms already declared"
75                 "for molecule: %s\n",
76                 name);
77 <      painCave.isFatal = 1;
78 <      simError();
77 >      return strdup( errMsg );
78      }
79      have_atoms = 1;
80      atoms = new AtomStamp*[n_atoms];
# Line 86 | Line 85 | void MoleculeStamp::assignDouble( char* lhs, double rh
85      n_bonds = (int)rhs;
86  
87      if( have_bonds ){
88 <      sprintf( painCave.errMsg,  
88 >      sprintf( errMsg,  
89                 "MoleculeStamp error, n_bonds already declared for"
90                 " molecule: %s\n",
91                 name);
92 <      painCave.isFatal = 1;
94 <      simError();
92 >      return strdup( errMsg );
93      }
94      have_bonds = 1;
95      bonds = new BondStamp*[n_bonds];
# Line 102 | Line 100 | void MoleculeStamp::assignDouble( char* lhs, double rh
100      n_bends = (int)rhs;
101  
102      if( have_bends ){
103 <      sprintf( painCave.errMsg,
103 >      sprintf( errMsg,
104                 "MoleculeStamp error, n_bends already declared for"
105                 " molecule: %s\n",
106                 name);
107 <      painCave.isFatal = 1;
110 <      simError();
107 >      return strdup( errMsg );
108      }
109      have_bends = 1;
110      bends = new BendStamp*[n_bends];
# Line 118 | Line 115 | void MoleculeStamp::assignDouble( char* lhs, double rh
115      n_torsions = (int)rhs;
116  
117      if( have_torsions ){
118 <      sprintf( painCave.errMsg,
118 >      sprintf( errMsg,
119                 "MoleculeStamp error, n_torsions already declared for"
120                 " molecule: %s\n",
121                 name );
122 <      painCave.isFatal = 1;
126 <      simError();
122 >      return strdup( errMsg );
123      }
124      have_torsions = 1;
125      torsions = new TorsionStamp*[n_torsions];
# Line 134 | Line 130 | void MoleculeStamp::assignDouble( char* lhs, double rh
130      else unhandled->add( lhs, rhs );
131      have_extras = 1;
132    }
133 +  return NULL;
134   }
135  
136 < void MoleculeStamp::assignInt( char* lhs, int rhs ){
136 > char*  MoleculeStamp::assignInt( char* lhs, int rhs ){
137    int i;
138    
139    if( !strcmp( lhs, "nAtoms" ) ){
140      n_atoms = rhs;
141      
142      if( have_atoms ){
143 <      sprintf( painCave.errMsg,
143 >      sprintf( errMsg,
144                 "MoleculeStamp error, n_atoms already declared for"
145                 " molecule: %s\n",
146                 name);
147 <      painCave.isFatal = 1;
151 <      simError();
147 >      return strdup( errMsg );
148      }
149      have_atoms = 1;
150      atoms = new AtomStamp*[n_atoms];
# Line 159 | Line 155 | void MoleculeStamp::assignInt( char* lhs, int rhs ){
155      n_bonds = rhs;
156  
157      if( have_bonds ){
158 <      sprintf( painCave.errMsg,
158 >      sprintf( errMsg,
159                 "MoleculeStamp error, n_bonds already declared for"
160                 " molecule: %s\n",
161                 name);
162 <      painCave.isFatal = 1;
167 <      simError();
162 >      return strdup( errMsg );
163      }
164      have_bonds = 1;
165      bonds = new BondStamp*[n_bonds];
# Line 175 | Line 170 | void MoleculeStamp::assignInt( char* lhs, int rhs ){
170      n_bends = rhs;
171  
172      if( have_bends ){
173 <      sprintf( painCave.errMsg,
173 >      sprintf( errMsg,
174                 "MoleculeStamp error, n_bends already declared for"
175                 " molecule: %s\n",
176                 name );
177 <      painCave.isFatal = 1;
183 <      simError();
177 >      return strdup( errMsg );
178      }
179      have_bends = 1;
180      bends = new BendStamp*[n_bends];
# Line 191 | Line 185 | void MoleculeStamp::assignInt( char* lhs, int rhs ){
185      n_torsions = rhs;
186  
187      if( have_torsions ){
188 <      sprintf( painCave.errMsg,
188 >      sprintf( errMsg,
189                 "MoleculeStamp error, n_torsions already declared for"
190                 " molecule: %s\n",
191                 name);
192 <      painCave.isFatal = 1;
199 <      simError();
192 >      return strdup( errMsg );
193      }
194      have_torsions = 1;
195      torsions = new TorsionStamp*[n_torsions];
# Line 207 | Line 200 | void MoleculeStamp::assignInt( char* lhs, int rhs ){
200      else unhandled->add( lhs, rhs );
201      have_extras = 1;
202    }
203 +  return NULL;
204   }
205  
206   char* MoleculeStamp::addAtom( AtomStamp* the_atom, int atomIndex ){
207    
214 –  char err[200];
215 –  
208    if( have_atoms && atomIndex < n_atoms ) atoms[atomIndex] = the_atom;
209    else{
210      if( have_atoms ){
211 <      sprintf( err, "MoleculeStamp error, %d out of nAtoms range",
211 >      sprintf( errMsg, "MoleculeStamp error, %d out of nAtoms range",
212                 atomIndex );
213 <      return strdup( err );
213 >      return strdup( errMsg );
214      }
215      else return strdup("MoleculeStamp error, nAtoms not given before"
216                         "first atom declaration." );
# Line 229 | Line 221 | char* MoleculeStamp::addBond( BondStamp* the_bond, int
221  
222   char* MoleculeStamp::addBond( BondStamp* the_bond, int bondIndex ){
223    
232 –  char err[200];
224    
225    if( have_bonds && bondIndex < n_bonds ) bonds[bondIndex] = the_bond;
226    else{
227      if( have_bonds ){
228 <      sprintf( err, "MoleculeStamp error, %d out of nBonds range",
228 >      sprintf( errMsg, "MoleculeStamp error, %d out of nBonds range",
229                 bondIndex );
230 <      return strdup( err );
230 >      return strdup( errMsg );
231      }
232      else return strdup("MoleculeStamp error, nBonds not given before"
233                         "first bond declaration." );
# Line 247 | Line 238 | char* MoleculeStamp::addBend( BendStamp* the_bend, int
238  
239   char* MoleculeStamp::addBend( BendStamp* the_bend, int bendIndex ){
240    
250 –  char err[200];
241    
242    if( have_bends && bendIndex < n_bends ) bends[bendIndex] = the_bend;
243    else{
244      if( have_bends ){
245 <      sprintf( err, "MoleculeStamp error, %d out of nBends range",
245 >      sprintf( errMsg, "MoleculeStamp error, %d out of nBends range",
246                 bendIndex );
247 <      return strdup( err );
247 >      return strdup( errMsg );
248      }
249      else return strdup("MoleculeStamp error, nBends not given before"
250                         "first bend declaration." );
# Line 265 | Line 255 | char* MoleculeStamp::addTorsion( TorsionStamp* the_tor
255  
256   char* MoleculeStamp::addTorsion( TorsionStamp* the_torsion, int torsionIndex ){
257    
268 –  char err[200];
258    
259    if( have_torsions && torsionIndex < n_torsions )
260      torsions[torsionIndex] = the_torsion;
261    else{
262      if( have_torsions ){
263 <      sprintf( err, "MoleculeStamp error, %d out of nTorsions range",
263 >      sprintf( errMsg, "MoleculeStamp error, %d out of nTorsions range",
264                 torsionIndex );
265 <      return strdup( err );
265 >      return strdup( errMsg );
266      }
267      else return strdup("MoleculeStamp error, nTorsions not given before"
268                         "first torsion declaration." );
# Line 286 | Line 275 | char* MoleculeStamp::checkMe( void ){
275    
276    int i;
277    short int no_atom;
289 –  char err[120];
278    
279    if( !have_name || !have_atoms ){
280      if( !have_name ) return strdup( "MoleculeStamp error. Molecule's name"
# Line 300 | Line 288 | char* MoleculeStamp::checkMe( void ){
288    }
289  
290    if( no_atom ){
291 <    sprintf( err,
291 >    sprintf( errMsg,
292               "MoleculeStamp error. Not all of the atoms were"
293               " declared in molecule \"%s\".\n", name );
294 <    return strdup( err );
294 >    return strdup( errMsg );
295    }
296  
297    return NULL;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines