Line data Source code
1 : /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 : Copyright (c) 2011-2023 The plumed team
3 : (see the PEOPLE file at the root of the distribution for a list of names)
4 :
5 : See http://www.plumed.org for more information.
6 :
7 : This file is part of plumed, version 2.
8 :
9 : plumed is free software: you can redistribute it and/or modify
10 : it under the terms of the GNU Lesser General Public License as published by
11 : the Free Software Foundation, either version 3 of the License, or
12 : (at your option) any later version.
13 :
14 : plumed is distributed in the hope that it will be useful,
15 : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : GNU Lesser General Public License for more details.
18 :
19 : You should have received a copy of the GNU Lesser General Public License
20 : along with plumed. If not, see <http://www.gnu.org/licenses/>.
21 : +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
22 : #include "PlumedMainInitializer.h"
23 : #include "PlumedMain.h"
24 : #include "tools/Exception.h"
25 : #include "lepton/Exception.h"
26 : #include <cstdlib>
27 : #include <cstring>
28 : #include <iostream>
29 : #if defined __PLUMED_HAS_DLOPEN
30 : #include <dlfcn.h>
31 : #endif
32 : #include <exception>
33 : #include <stdexcept>
34 : #include <ios>
35 : #include <new>
36 : #include <typeinfo>
37 : #include <system_error>
38 : #include <future>
39 : #include <memory>
40 : #include <functional>
41 : #include <regex>
42 : #include <any>
43 : #include <variant>
44 : #include <optional>
45 : #include <filesystem>
46 : #include "tools/TypesafePtr.h"
47 : #include "tools/Log.h"
48 : #include "tools/Tools.h"
49 :
50 :
51 20449 : static bool getenvTypesafeDebug() noexcept {
52 20449 : static const auto* res=std::getenv("PLUMED_TYPESAFE_DEBUG");
53 20449 : return res;
54 : }
55 :
56 : // cppcheck-suppress passedByValue
57 0 : static void typesafeDebug(const char*key,plumed_safeptr_x safe) noexcept {
58 0 : std::fprintf(stderr,"+++ PLUMED_TYPESAFE_DEBUG %s %p %zu",key,safe.ptr,safe.nelem);
59 0 : const size_t* shape=safe.shape;
60 0 : if(shape) {
61 0 : std::fprintf(stderr," (");
62 0 : while(*shape!=0) {
63 0 : std::fprintf(stderr," %zu",*shape);
64 0 : shape++;
65 : }
66 0 : std::fprintf(stderr," )");
67 : }
68 0 : std::fprintf(stderr," %zx %p\n",safe.flags,safe.opt);
69 0 : }
70 :
71 : // create should never throw
72 : // in case of a problem, it logs the error and return a null pointer
73 : // when loaded by an interface >=2.5, this will result in a non valid plumed object.
74 : // earlier interfaces will just give a segfault or a failed assertion.
75 805720 : extern "C" void*plumed_plumedmain_create() {
76 : try {
77 805720 : return new PLMD::PlumedMain;
78 0 : } catch(const std::exception & e) {
79 0 : std::cerr<<"+++ an error happened while creating a plumed object\n";
80 0 : std::cerr<<e.what()<<std::endl;
81 : return nullptr;
82 0 : } catch(...) {
83 0 : std::cerr<<"+++ an unknown error happened while creating a plumed object"<<std::endl;
84 : return nullptr;
85 0 : }
86 : }
87 :
88 8000671 : extern "C" unsigned plumed_plumedmain_create_reference(void*plumed) {
89 8000671 : plumed_massert(plumed,"trying to create a reference to a plumed object which is not initialized");
90 : auto p=static_cast<PLMD::PlumedMain*>(plumed);
91 8000671 : return p->increaseReferenceCounter();
92 : }
93 :
94 8806391 : extern "C" unsigned plumed_plumedmain_delete_reference(void*plumed) {
95 8806391 : plumed_massert(plumed,"trying to delete a reference to a plumed object which is not initialized");
96 : auto p=static_cast<PLMD::PlumedMain*>(plumed);
97 8806391 : return p->decreaseReferenceCounter();
98 : }
99 :
100 42 : extern "C" unsigned plumed_plumedmain_use_count(void*plumed) {
101 42 : plumed_massert(plumed,"trying to delete a reference to a plumed object which is not initialized");
102 : auto p=static_cast<PLMD::PlumedMain*>(plumed);
103 42 : return p->useCountReferenceCounter();
104 : }
105 :
106 357 : extern "C" void plumed_plumedmain_cmd(void*plumed,const char*key,const void*val) {
107 357 : plumed_massert(plumed,"trying to use a plumed object which is not initialized");
108 : auto p=static_cast<PLMD::PlumedMain*>(plumed);
109 357 : p->cmd(key,PLMD::TypesafePtr::unchecked(val));
110 357 : }
111 :
112 : extern "C" {
113 95 : static void plumed_plumedmain_cmd_safe(void*plumed,const char*key,plumed_safeptr_x safe) {
114 95 : plumed_massert(plumed,"trying to use a plumed object which is not initialized");
115 : auto p=static_cast<PLMD::PlumedMain*>(plumed);
116 95 : if(getenvTypesafeDebug()) {
117 0 : typesafeDebug(key,safe);
118 : }
119 95 : p->cmd(key,PLMD::TypesafePtr::fromSafePtr(&safe));
120 95 : }
121 : }
122 :
123 : /// Internal tool
124 : /// Throws the currently managed exception and call the nothrow handler.
125 : /// If nested is not null, it is passed and then gets populated with a pointer that should
126 : /// be called on the nested exception
127 : /// If msg is not null, it overrides the message. Can be used to build a concatenated message.
128 178 : static void translate_current(plumed_nothrow_handler_x nothrow,void**nested=nullptr,const char*msg=nullptr) {
129 178 : const void* opt[11]= {"n",nested,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr};
130 : try {
131 : // this function needs to be called while catching an exception
132 : // cppcheck-suppress rethrowNoCurrentException
133 178 : throw;
134 178 : } catch(const PLMD::ExceptionTypeError & e) {
135 52 : if(!msg) {
136 0 : msg=e.what();
137 : }
138 52 : nothrow.handler(nothrow.ptr,20300,msg,opt);
139 105 : } catch(const PLMD::ExceptionError & e) {
140 53 : if(!msg) {
141 2 : msg=e.what();
142 : }
143 53 : nothrow.handler(nothrow.ptr,20200,msg,opt);
144 54 : } catch(const PLMD::ExceptionDebug & e) {
145 1 : if(!msg) {
146 1 : msg=e.what();
147 : }
148 1 : nothrow.handler(nothrow.ptr,20100,msg,opt);
149 24 : } catch(const PLMD::Exception & e) {
150 23 : if(!msg) {
151 16 : msg=e.what();
152 : }
153 23 : nothrow.handler(nothrow.ptr,20000,msg,opt);
154 24 : } catch(const PLMD::lepton::Exception & e) {
155 1 : if(!msg) {
156 1 : msg=e.what();
157 : }
158 1 : nothrow.handler(nothrow.ptr,19900,msg,opt);
159 : // 11000 to 12000 are "bad exceptions". message will be copied without new allocations
160 2 : } catch(const std::bad_variant_access & e) {
161 1 : if(!msg) {
162 1 : msg=e.what();
163 : }
164 1 : nothrow.handler(nothrow.ptr,11700,msg,opt);
165 2 : } catch(const std::bad_optional_access & e) {
166 1 : if(!msg) {
167 1 : msg=e.what();
168 : }
169 1 : nothrow.handler(nothrow.ptr,11600,msg,opt);
170 2 : } catch(const std::bad_exception & e) {
171 1 : if(!msg) {
172 1 : msg=e.what();
173 : }
174 1 : nothrow.handler(nothrow.ptr,11500,msg,opt);
175 2 : } catch(const std::bad_array_new_length & e) {
176 1 : if(!msg) {
177 1 : msg=e.what();
178 : }
179 1 : nothrow.handler(nothrow.ptr,11410,msg,opt);
180 4 : } catch(const std::bad_alloc & e) {
181 3 : if(!msg) {
182 3 : msg=e.what();
183 : }
184 3 : nothrow.handler(nothrow.ptr,11400,msg,opt);
185 4 : } catch(const std::bad_function_call & e) {
186 1 : if(!msg) {
187 1 : msg=e.what();
188 : }
189 1 : nothrow.handler(nothrow.ptr,11300,msg,opt);
190 2 : } catch(const std::bad_weak_ptr & e) {
191 1 : if(!msg) {
192 1 : msg=e.what();
193 : }
194 1 : nothrow.handler(nothrow.ptr,11200,msg,opt);
195 2 : } catch(const std::bad_any_cast & e) {
196 1 : if(!msg) {
197 1 : msg=e.what();
198 : }
199 1 : nothrow.handler(nothrow.ptr,11150,msg,opt);
200 2 : } catch(const std::bad_cast & e) {
201 1 : if(!msg) {
202 1 : msg=e.what();
203 : }
204 1 : nothrow.handler(nothrow.ptr,11100,msg,opt);
205 2 : } catch(const std::bad_typeid & e) {
206 1 : if(!msg) {
207 1 : msg=e.what();
208 : }
209 1 : nothrow.handler(nothrow.ptr,11000,msg,opt);
210 14 : } catch(const std::regex_error & e) {
211 13 : if(!msg) {
212 13 : msg=e.what();
213 : }
214 13 : if(e.code()==std::regex_constants::error_collate) {
215 1 : nothrow.handler(nothrow.ptr,10240,msg,opt);
216 : } else if(e.code()==std::regex_constants::error_ctype) {
217 1 : nothrow.handler(nothrow.ptr,10241,msg,opt);
218 : } else if(e.code()==std::regex_constants::error_escape) {
219 1 : nothrow.handler(nothrow.ptr,10242,msg,opt);
220 : } else if(e.code()==std::regex_constants::error_backref) {
221 1 : nothrow.handler(nothrow.ptr,10243,msg,opt);
222 : } else if(e.code()==std::regex_constants::error_brack) {
223 1 : nothrow.handler(nothrow.ptr,10244,msg,opt);
224 : } else if(e.code()==std::regex_constants::error_paren) {
225 1 : nothrow.handler(nothrow.ptr,10245,msg,opt);
226 : } else if(e.code()==std::regex_constants::error_brace) {
227 1 : nothrow.handler(nothrow.ptr,10246,msg,opt);
228 : } else if(e.code()==std::regex_constants::error_badbrace) {
229 1 : nothrow.handler(nothrow.ptr,10247,msg,opt);
230 : } else if(e.code()==std::regex_constants::error_range) {
231 1 : nothrow.handler(nothrow.ptr,10248,msg,opt);
232 : } else if(e.code()==std::regex_constants::error_space) {
233 1 : nothrow.handler(nothrow.ptr,10249,msg,opt);
234 : } else if(e.code()==std::regex_constants::error_badrepeat) {
235 1 : nothrow.handler(nothrow.ptr,10250,msg,opt);
236 : } else if(e.code()==std::regex_constants::error_complexity) {
237 1 : nothrow.handler(nothrow.ptr,10251,msg,opt);
238 : } else if(e.code()==std::regex_constants::error_stack) {
239 1 : nothrow.handler(nothrow.ptr,10252,msg,opt);
240 : }
241 : // fallback to generic runtime_error
242 : else {
243 0 : nothrow.handler(nothrow.ptr,10200,msg,opt);
244 : }
245 16 : } catch(const std::filesystem::filesystem_error & e) {
246 3 : if(!msg) {
247 3 : msg=e.what();
248 : }
249 3 : int value=e.code().value();
250 :
251 3 : opt[2]="c"; // "c" passes the error code.
252 3 : opt[3]=&value;
253 :
254 3 : opt[4]="C"; // "C" passes the error category
255 3 : int generic_category=1;
256 3 : int system_category=2;
257 3 : int iostream_category=3;
258 3 : int future_category=4;
259 3 : if(e.code().category()==std::generic_category()) {
260 3 : opt[5]=&generic_category;
261 0 : } else if(e.code().category()==std::system_category()) {
262 0 : opt[5]=&system_category;
263 0 : } else if(e.code().category()==std::iostream_category()) {
264 0 : opt[5]=&iostream_category;
265 0 : } else if(e.code().category()==std::future_category()) {
266 0 : opt[5]=&future_category;
267 : } else {
268 0 : opt[5]=nullptr;
269 : }
270 :
271 : // local class, just needed to propely pass path information
272 : // path is stored as a span of bytes.
273 : // in theory, could be wchar type (on Windows, not tested),
274 : // so we explicitly store the number of bytes
275 : struct Path {
276 : std::size_t numbytes=0;
277 : const void* ptr=nullptr;
278 : Path(const std::filesystem::path & path):
279 : numbytes(sizeof(std::filesystem::path::value_type)*path.native().length()),
280 : ptr(path.c_str())
281 : {}
282 : Path() = default;
283 : };
284 :
285 3 : opt[6]="p"; // path1
286 3 : Path path1; // declared here since it should survive till the end of this function
287 3 : if(!e.path1().empty()) {
288 2 : path1=Path(e.path1());
289 2 : opt[7]=&path1;
290 : }
291 :
292 3 : opt[8]="q"; // path2
293 3 : Path path2; // declared here since it should survive till the end of this function
294 3 : if(!e.path2().empty()) {
295 1 : path2=Path(e.path2());
296 1 : opt[9]=&path2;
297 : }
298 :
299 3 : nothrow.handler(nothrow.ptr,10229,msg,opt);
300 4 : } catch(const std::ios_base::failure & e) {
301 1 : if(!msg) {
302 1 : msg=e.what();
303 : }
304 1 : int value=e.code().value();
305 1 : opt[2]="c"; // "c" passes the error code.
306 1 : opt[3]=&value;
307 1 : if(e.code().category()==std::generic_category()) {
308 0 : nothrow.handler(nothrow.ptr,10230,msg,opt);
309 1 : } else if(e.code().category()==std::system_category()) {
310 0 : nothrow.handler(nothrow.ptr,10231,msg,opt);
311 1 : } else if(e.code().category()==std::iostream_category()) {
312 1 : nothrow.handler(nothrow.ptr,10232,msg,opt);
313 0 : } else if(e.code().category()==std::future_category()) {
314 0 : nothrow.handler(nothrow.ptr,10233,msg,opt);
315 : } else
316 : // 10239 represents std::ios_base::failure with default constructur
317 : {
318 0 : nothrow.handler(nothrow.ptr,10239,msg,opt);
319 : }
320 5 : } catch(const std::system_error & e) {
321 4 : if(!msg) {
322 4 : msg=e.what();
323 : }
324 4 : int value=e.code().value();
325 4 : opt[2]="c"; // "c" passes the error code.
326 4 : opt[3]=&value;
327 4 : if(e.code().category()==std::generic_category()) {
328 1 : nothrow.handler(nothrow.ptr,10220,msg,opt);
329 3 : } else if(e.code().category()==std::system_category()) {
330 1 : nothrow.handler(nothrow.ptr,10221,msg,opt);
331 2 : } else if(e.code().category()==std::iostream_category()) {
332 1 : nothrow.handler(nothrow.ptr,10222,msg,opt);
333 1 : } else if(e.code().category()==std::future_category()) {
334 1 : nothrow.handler(nothrow.ptr,10223,msg,opt);
335 : }
336 : // fallback to generic runtime_error
337 : else {
338 0 : nothrow.handler(nothrow.ptr,10200,msg,opt);
339 : }
340 5 : } catch(const std::underflow_error &e) {
341 1 : if(!msg) {
342 1 : msg=e.what();
343 : }
344 1 : nothrow.handler(nothrow.ptr,10215,msg,opt);
345 2 : } catch(const std::overflow_error &e) {
346 1 : if(!msg) {
347 1 : msg=e.what();
348 : }
349 1 : nothrow.handler(nothrow.ptr,10210,msg,opt);
350 2 : } catch(const std::range_error &e) {
351 1 : if(!msg) {
352 1 : msg=e.what();
353 : }
354 1 : nothrow.handler(nothrow.ptr,10205,msg,opt);
355 2 : } catch(const std::runtime_error & e) {
356 1 : if(!msg) {
357 1 : msg=e.what();
358 : }
359 1 : nothrow.handler(nothrow.ptr,10200,msg,opt);
360 5 : } catch(const std::future_error & e) {
361 4 : if(!msg) {
362 4 : msg=e.what();
363 : }
364 : if(e.code()==std::make_error_code(std::future_errc::broken_promise)) {
365 1 : nothrow.handler(nothrow.ptr,10125,msg,opt);
366 : } else if(e.code()==std::make_error_code(std::future_errc::future_already_retrieved)) {
367 1 : nothrow.handler(nothrow.ptr,10126,msg,opt);
368 : } else if(e.code()==std::make_error_code(std::future_errc::promise_already_satisfied)) {
369 1 : nothrow.handler(nothrow.ptr,10127,msg,opt);
370 : } else if(e.code()==std::make_error_code(std::future_errc::no_state)) {
371 1 : nothrow.handler(nothrow.ptr,10128,msg,opt);
372 : }
373 : // fallback to generic logic_error
374 : else {
375 0 : nothrow.handler(nothrow.ptr,10100,msg,opt);
376 : }
377 5 : } catch(const std::out_of_range & e) {
378 1 : if(!msg) {
379 1 : msg=e.what();
380 : }
381 1 : nothrow.handler(nothrow.ptr,10120,msg,opt);
382 2 : } catch(const std::length_error & e) {
383 1 : if(!msg) {
384 1 : msg=e.what();
385 : }
386 1 : nothrow.handler(nothrow.ptr,10115,msg,opt);
387 2 : } catch(const std::domain_error & e) {
388 1 : if(!msg) {
389 1 : msg=e.what();
390 : }
391 1 : nothrow.handler(nothrow.ptr,10110,msg,opt);
392 2 : } catch(const std::invalid_argument & e) {
393 1 : if(!msg) {
394 1 : msg=e.what();
395 : }
396 1 : nothrow.handler(nothrow.ptr,10105,msg,opt);
397 2 : } catch(const std::logic_error & e) {
398 1 : if(!msg) {
399 1 : msg=e.what();
400 : }
401 1 : nothrow.handler(nothrow.ptr,10100,msg,opt);
402 : // generic exception. message will be copied without new allocations
403 : // reports all non caught exceptions that are derived from std::exception
404 : // for instance, boost exceptions would end up here
405 1 : } catch(const std::exception & e) {
406 0 : if(!msg) {
407 0 : msg=e.what();
408 : }
409 0 : nothrow.handler(nothrow.ptr,10000,msg,opt);
410 1 : } catch(const char* m) {
411 1 : if(!msg) {
412 : msg=m;
413 : }
414 1 : nothrow.handler(nothrow.ptr,10000,msg,opt);
415 1 : } catch(const std::string & s) {
416 0 : if(!msg) {
417 : msg=s.c_str();
418 : }
419 0 : nothrow.handler(nothrow.ptr,10000,msg,opt);
420 1 : } catch (...) {
421 : // if exception cannot be translated, we add a bad_exception to the stack
422 1 : nothrow.handler(nothrow.ptr,11500,"plumed could not translate exception",opt);
423 1 : }
424 178 : }
425 :
426 68 : static void translate_nested(plumed_nothrow_handler_x nothrow) {
427 : try {
428 68 : throw;
429 68 : } catch (const std::nested_exception & e) {
430 : // If this exception has a nested one:
431 12 : auto nothrow_nested=nothrow;
432 12 : nothrow_nested.ptr=nullptr;
433 : // translate the current exception asking the wrapper to allocate a new exception
434 12 : translate_current(nothrow,¬hrow_nested.ptr);
435 : // if the wrapper cannot allocate the exception, this will be a nullptr
436 12 : if(nothrow_nested.ptr) {
437 : try {
438 : // transfer control to the nested exception
439 12 : e.rethrow_nested();
440 12 : } catch (...) {
441 : // recursively translate it
442 12 : translate_nested(nothrow_nested);
443 12 : }
444 : }
445 68 : } catch (...) {
446 : // otherwise, just translate the current exception
447 56 : translate_current(nothrow);
448 56 : }
449 68 : }
450 :
451 : extern "C" {
452 20354 : static void plumed_plumedmain_cmd_safe_nothrow(void*plumed,const char*key,plumed_safeptr_x safe,plumed_nothrow_handler_x nothrow) {
453 : // This is a workaround for a suboptimal choice in PLUMED <2.8
454 : // In particular, the only way to bypass the exception handling process was to call the plumed_plumedmain_cmd_safe
455 : // function directly.
456 : // With this modification, it is possible to just call the plumed_plumedmain_cmd_safe_nothrow function
457 : // passing a null error handler.
458 20354 : if(!nothrow.handler) {
459 0 : plumed_plumedmain_cmd_safe(plumed,key,safe);
460 0 : return;
461 : }
462 : auto p=static_cast<PLMD::PlumedMain*>(plumed);
463 : // At library boundaries we translate exceptions to error codes.
464 : // This allows an exception to be catched also if the MD code
465 : // was linked against a different C++ library
466 : try {
467 20354 : plumed_massert(plumed,"trying to use a plumed object which is not initialized");
468 20354 : if(getenvTypesafeDebug()) {
469 0 : typesafeDebug(key,safe);
470 : }
471 20354 : p->cmd(key,PLMD::TypesafePtr::fromSafePtr(&safe));
472 166 : } catch(...) {
473 166 : if(p->getNestedExceptions()) {
474 56 : translate_nested(nothrow);
475 : } else {
476 : // In this case, we just consider the latest thrown exception and
477 : // supplement it with a concatenated message so as not to
478 : // loose information.
479 110 : auto msg=PLMD::Tools::concatenateExceptionMessages();
480 110 : translate_current(nothrow,nullptr,msg.c_str());
481 : }
482 166 : }
483 : }
484 : }
485 :
486 : extern "C" {
487 0 : static void plumed_plumedmain_cmd_nothrow(void*plumed,const char*key,const void*val,plumed_nothrow_handler_x nothrow) {
488 : plumed_safeptr_x safe;
489 0 : plumed_assert(nothrow.handler) << "Accepting a null pointer here would make the calling code non compatible with plumed 2.5 to 2.7";
490 0 : safe.ptr=val;
491 0 : safe.nelem=0;
492 0 : safe.shape=NULL;
493 0 : safe.flags=0;
494 0 : safe.opt=NULL;
495 0 : plumed_plumedmain_cmd_safe_nothrow(plumed,key,safe,nothrow);
496 0 : }
497 : }
498 :
499 805720 : extern "C" void plumed_plumedmain_finalize(void*plumed) {
500 805720 : plumed_massert(plumed,"trying to deallocate a plumed object which is not initialized");
501 : // I think it is not possible to replace this delete with a smart pointer
502 : // since the ownership of this pointer is in a C structure. GB
503 805720 : delete static_cast<PLMD::PlumedMain*>(plumed);
504 805720 : }
505 :
506 : // values here should be consistent with those in plumed_symbol_table_init !!!!
507 : plumed_symbol_table_type_x plumed_symbol_table= {
508 : 4,
509 : {plumed_plumedmain_create,plumed_plumedmain_cmd,plumed_plumedmain_finalize},
510 : plumed_plumedmain_cmd_nothrow,
511 : plumed_plumedmain_cmd_safe,
512 : plumed_plumedmain_cmd_safe_nothrow,
513 : plumed_plumedmain_create_reference,
514 : plumed_plumedmain_delete_reference,
515 : plumed_plumedmain_use_count
516 : };
517 :
518 : // values here should be consistent with those above !!!!
519 811107 : extern "C" void plumed_symbol_table_init() {
520 811107 : plumed_symbol_table.version=4;
521 811107 : plumed_symbol_table.functions.create=plumed_plumedmain_create;
522 811107 : plumed_symbol_table.functions.cmd=plumed_plumedmain_cmd;
523 811107 : plumed_symbol_table.functions.finalize=plumed_plumedmain_finalize;
524 811107 : plumed_symbol_table.cmd_nothrow=plumed_plumedmain_cmd_nothrow;
525 811107 : plumed_symbol_table.cmd_safe=plumed_plumedmain_cmd_safe;
526 811107 : plumed_symbol_table.cmd_safe_nothrow=plumed_plumedmain_cmd_safe_nothrow;
527 811107 : plumed_symbol_table.create_reference=plumed_plumedmain_create_reference;
528 811107 : plumed_symbol_table.delete_reference=plumed_plumedmain_delete_reference;
529 811107 : plumed_symbol_table.use_count=plumed_plumedmain_use_count;
530 811107 : }
531 :
532 : namespace PLMD {
533 :
534 : #define plumed_convert_fptr(ptr,fptr) { ptr=NULL; std::memcpy(&ptr,&fptr,(sizeof(fptr)>sizeof(ptr)?sizeof(ptr):sizeof(fptr))); }
535 :
536 : /// Static object which registers Plumed.
537 : /// This is a static object which, during its construction at startup,
538 : /// registers the pointers to plumed_plumedmain_create, plumed_plumedmain_cmd and plumed_plumedmain_finalize
539 : /// to the plumed_kernel_register function.
540 : /// Registration is only required with plumed loader <=2.4, but we do it anyway in order to maintain
541 : /// backward compatibility. Notice that as of plumed 2.5 the plumed_kernel_register is found
542 : /// using dlsym, in order to allow the libplumedKernel library to be loadable also when
543 : /// the plumed_kernel_register symbol is not available.
544 : namespace {
545 : class PlumedMainInitializer {
546 : const bool debug;
547 : public:
548 5418 : PlumedMainInitializer():
549 5418 : debug(std::getenv("PLUMED_LOAD_DEBUG")) {
550 : // make sure static plumed_function_pointers is initialized here
551 5418 : plumed_symbol_table_init();
552 5418 : if(debug) {
553 0 : std::fprintf(stderr,"+++ Initializing PLUMED with plumed_symbol_table version %i at %p\n",plumed_symbol_table.version,(void*)&plumed_symbol_table);
554 : }
555 : #if defined(__PLUMED_HAS_DLOPEN)
556 5418 : if(std::getenv("PLUMED_LOAD_SKIP_REGISTRATION")) {
557 0 : if(debug) {
558 0 : std::fprintf(stderr,"+++ Skipping registration +++\n");
559 : }
560 0 : return;
561 : }
562 : typedef plumed_plumedmain_function_holder_x* (*plumed_kernel_register_type_x)(const plumed_plumedmain_function_holder_x*);
563 : plumed_kernel_register_type_x plumed_kernel_register=nullptr;
564 : void* handle=nullptr;
565 : #if defined(__PLUMED_HAS_RTLD_DEFAULT)
566 5418 : if(debug) {
567 0 : std::fprintf(stderr,"+++ Registering functions. Looking in RTLD_DEFAULT +++\n");
568 : }
569 5418 : void* dls=dlsym(RTLD_DEFAULT,"plumed_kernel_register");
570 : #else
571 : handle=dlopen(NULL,RTLD_LOCAL);
572 : if(debug) {
573 : std::fprintf(stderr,"+++ Registering functions. dlopen handle at %p +++\n",handle);
574 : }
575 : void* dls=dlsym(handle,"plumed_kernel_register");
576 : #endif
577 5418 : *(void **)(&plumed_kernel_register)=dls;
578 5418 : if(debug) {
579 0 : if(plumed_kernel_register) {
580 0 : std::fprintf(stderr,"+++ plumed_kernel_register found at %p +++\n",dls);
581 : } else {
582 0 : std::fprintf(stderr,"+++ plumed_kernel_register not found +++\n");
583 : }
584 : }
585 : void*createp;
586 : void*cmdp;
587 : void*finalizep;
588 : plumed_convert_fptr(createp,plumed_symbol_table.functions.create);
589 : plumed_convert_fptr(cmdp,plumed_symbol_table.functions.cmd);
590 : plumed_convert_fptr(finalizep,plumed_symbol_table.functions.finalize);
591 5418 : if(plumed_kernel_register && debug)
592 0 : std::fprintf(stderr,"+++ Registering functions at %p (%p,%p,%p) +++\n",
593 : (void*)&plumed_symbol_table.functions,createp,cmdp,finalizep);
594 5418 : if(plumed_kernel_register) {
595 26 : (*plumed_kernel_register)(&plumed_symbol_table.functions);
596 : }
597 : // Notice that handle could be null in the following cases:
598 : // - if we use RTLD_DEFAULT
599 : // - on Linux if we don't use RTLD_DEFAULT, since dlopen(NULL,RTLD_LOCAL) returns a null pointer.
600 : if(handle) {
601 : dlclose(handle);
602 : }
603 : #endif
604 : }
605 5418 : ~PlumedMainInitializer() {
606 5418 : if(debug) {
607 0 : std::fprintf(stderr,"+++ Finalizing PLUMED with plumed_symbol_table at %p\n",(void*)&plumed_symbol_table);
608 : }
609 5418 : }
610 : } PlumedMainInitializerRegisterMe;
611 : }
612 :
613 : }
614 :
615 :
|
