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 ); |
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 |
< |
std::cerr << "MoleculeStamp error, n_atoms already declared for" |
74 |
< |
<< " molecule: " << name << "\n"; |
75 |
< |
exit(1); |
73 |
> |
sprintf( errMsg, |
74 |
> |
"MoleculeStamp error, n_atoms already declared" |
75 |
> |
"for molecule: %s\n", |
76 |
> |
name); |
77 |
> |
return strdup( errMsg ); |
78 |
|
} |
79 |
|
have_atoms = 1; |
80 |
|
atoms = new AtomStamp*[n_atoms]; |
85 |
|
n_bonds = (int)rhs; |
86 |
|
|
87 |
|
if( have_bonds ){ |
88 |
< |
std::cerr << "MoleculeStamp error, n_bonds already declared for" |
89 |
< |
<< " molecule: " << name << "\n"; |
90 |
< |
exit(1); |
88 |
> |
sprintf( errMsg, |
89 |
> |
"MoleculeStamp error, n_bonds already declared for" |
90 |
> |
" molecule: %s\n", |
91 |
> |
name); |
92 |
> |
return strdup( errMsg ); |
93 |
|
} |
94 |
|
have_bonds = 1; |
95 |
|
bonds = new BondStamp*[n_bonds]; |
100 |
|
n_bends = (int)rhs; |
101 |
|
|
102 |
|
if( have_bends ){ |
103 |
< |
std::cerr << "MoleculeStamp error, n_bends already declared for" |
104 |
< |
<< " molecule: " << name << "\n"; |
105 |
< |
exit(1); |
103 |
> |
sprintf( errMsg, |
104 |
> |
"MoleculeStamp error, n_bends already declared for" |
105 |
> |
" molecule: %s\n", |
106 |
> |
name); |
107 |
> |
return strdup( errMsg ); |
108 |
|
} |
109 |
|
have_bends = 1; |
110 |
|
bends = new BendStamp*[n_bends]; |
115 |
|
n_torsions = (int)rhs; |
116 |
|
|
117 |
|
if( have_torsions ){ |
118 |
< |
std::cerr << "MoleculeStamp error, n_torsions already declared for" |
119 |
< |
<< " molecule: " << name << "\n"; |
120 |
< |
exit(1); |
118 |
> |
sprintf( errMsg, |
119 |
> |
"MoleculeStamp error, n_torsions already declared for" |
120 |
> |
" molecule: %s\n", |
121 |
> |
name ); |
122 |
> |
return strdup( errMsg ); |
123 |
|
} |
124 |
|
have_torsions = 1; |
125 |
|
torsions = new TorsionStamp*[n_torsions]; |
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 |
< |
std::cerr << "MoleculeStamp error, n_atoms already declared for" |
144 |
< |
<< " molecule: " << name << "\n"; |
145 |
< |
exit(1); |
143 |
> |
sprintf( errMsg, |
144 |
> |
"MoleculeStamp error, n_atoms already declared for" |
145 |
> |
" molecule: %s\n", |
146 |
> |
name); |
147 |
> |
return strdup( errMsg ); |
148 |
|
} |
149 |
|
have_atoms = 1; |
150 |
|
atoms = new AtomStamp*[n_atoms]; |
155 |
|
n_bonds = rhs; |
156 |
|
|
157 |
|
if( have_bonds ){ |
158 |
< |
std::cerr << "MoleculeStamp error, n_bonds already declared for" |
159 |
< |
<< " molecule: " << name << "\n"; |
160 |
< |
exit(1); |
158 |
> |
sprintf( errMsg, |
159 |
> |
"MoleculeStamp error, n_bonds already declared for" |
160 |
> |
" molecule: %s\n", |
161 |
> |
name); |
162 |
> |
return strdup( errMsg ); |
163 |
|
} |
164 |
|
have_bonds = 1; |
165 |
|
bonds = new BondStamp*[n_bonds]; |
170 |
|
n_bends = rhs; |
171 |
|
|
172 |
|
if( have_bends ){ |
173 |
< |
std::cerr << "MoleculeStamp error, n_bends already declared for" |
174 |
< |
<< " molecule: " << name << "\n"; |
175 |
< |
exit(1); |
173 |
> |
sprintf( errMsg, |
174 |
> |
"MoleculeStamp error, n_bends already declared for" |
175 |
> |
" molecule: %s\n", |
176 |
> |
name ); |
177 |
> |
return strdup( errMsg ); |
178 |
|
} |
179 |
|
have_bends = 1; |
180 |
|
bends = new BendStamp*[n_bends]; |
185 |
|
n_torsions = rhs; |
186 |
|
|
187 |
|
if( have_torsions ){ |
188 |
< |
std::cerr << "MoleculeStamp error, n_torsions already declared for" |
189 |
< |
<< " molecule: " << name << "\n"; |
190 |
< |
exit(1); |
188 |
> |
sprintf( errMsg, |
189 |
> |
"MoleculeStamp error, n_torsions already declared for" |
190 |
> |
" molecule: %s\n", |
191 |
> |
name); |
192 |
> |
return strdup( errMsg ); |
193 |
|
} |
194 |
|
have_torsions = 1; |
195 |
|
torsions = new TorsionStamp*[n_torsions]; |
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 |
|
|
189 |
– |
char err[200]; |
190 |
– |
|
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." ); |
221 |
|
|
222 |
|
char* MoleculeStamp::addBond( BondStamp* the_bond, int bondIndex ){ |
223 |
|
|
207 |
– |
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." ); |
238 |
|
|
239 |
|
char* MoleculeStamp::addBend( BendStamp* the_bend, int bendIndex ){ |
240 |
|
|
225 |
– |
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." ); |
255 |
|
|
256 |
|
char* MoleculeStamp::addTorsion( TorsionStamp* the_torsion, int torsionIndex ){ |
257 |
|
|
243 |
– |
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." ); |
275 |
|
|
276 |
|
int i; |
277 |
|
short int no_atom; |
264 |
– |
char err[120]; |
278 |
|
|
279 |
|
if( !have_name || !have_atoms ){ |
280 |
|
if( !have_name ) return strdup( "MoleculeStamp error. Molecule's name" |
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; |