Branch data Line data Source code
1 : : /*
2 : : * module.cpp - module class implementation
3 : : *
4 : : * Copyright (C) 2008, 2009, 2010 Stefan Jahn <stefan@lkcc.org>
5 : : * New models added Mike Brinson 2013 mbrin72043@yahoo.co.uk
6 : : *
7 : : * This is free software; you can redistribute it and/or modify
8 : : * it under the terms of the GNU General Public License as published by
9 : : * the Free Software Foundation; either version 2, or (at your option)
10 : : * any later version.
11 : : *
12 : : * This software is distributed in the hope that it will be useful,
13 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : : * GNU General Public License for more details.
16 : : *
17 : : * You should have received a copy of the GNU General Public License
18 : : * along with this package; see the file COPYING. If not, write to
19 : : * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
20 : : * Boston, MA 02110-1301, USA.
21 : : *
22 : : * $Id: module.cpp 1872 2013-03-06 14:13:37Z fransschreuder $
23 : : *
24 : : */
25 : :
26 : : #if HAVE_CONFIG_H
27 : : # include <config.h>
28 : : #endif
29 : :
30 : : #include <iostream>
31 : : #include <stdio.h>
32 : : #include <stdlib.h>
33 : : #include <map>
34 : : #include <list>
35 : :
36 : : #include "netdefs.h"
37 : : #include "components.h"
38 : : #include "analyses.h"
39 : : #include "netdefs.h"
40 : : #include "module.h"
41 : :
42 : : #ifdef __MINGW32__
43 : : #include <windows.h>
44 : : #else
45 : : #include <dlfcn.h>
46 : : #endif
47 : :
48 : : #include <cstdlib> //for exit
49 : :
50 : : // Global module hash.
51 : 107 : qucs::hash<module> module::modules;
52 : :
53 : : // Our global factories for making loaded circuit objects
54 : : // The factories are populated as dynamic modules are loaded
55 : : // factorycreate hold the loaded modules constructor function
56 : 107 : std::map< std::string, creator_t *, std::less<std::string> > factorycreate;
57 : : // factorydef hold the loaded modules definitions
58 : 107 : std::map< std::string, defs_t *, std::less<std::string> > factorydef;
59 : :
60 : : #if __MINGW32__
61 : : std::list<HINSTANCE> dl_list; // list to hold handles for dynamic libs
62 : : std::list<HINSTANCE>::iterator itr;
63 : : #else
64 : 107 : std::list<void *> dl_list; // list to hold handles for dynamic libs
65 : 107 : std::list<void *>::iterator itr;
66 : : #endif
67 : :
68 : : // Constructor creates an instance of the module class.
69 : 16328 : module::module () {
70 : 16328 : definition = NULL;
71 : 16328 : circreate = NULL;
72 : 16328 : anacreate = NULL;
73 : 16328 : }
74 : :
75 : : // Destructor deletes an instance of the module class.
76 : 16171 : module::~module () {
77 : 16171 : }
78 : :
79 : : // Definitions which do not fit elsewhere.
80 : : static struct property_t props1[] = {
81 : : PROP_NO_PROP };
82 : : static struct property_t props2[] = {
83 : : { "Type", PROP_STR, { PROP_NO_VAL, "DEF1" }, PROP_NO_RANGE },
84 : : PROP_NO_PROP };
85 : :
86 : : struct define_t miscdef1 =
87 : : { "Def", PROP_NODES, PROP_ACTION, PROP_NO_SUBSTRATE, PROP_LINEAR,
88 : : props1, props1 };
89 : :
90 : : struct define_t miscdef2 =
91 : : { "Sub", PROP_NODES, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_LINEAR,
92 : : props1, props2 };
93 : :
94 : : // Registers an analysis object to the list of available modules.
95 : 728 : void module::registerModule (analysis_definer_t define,
96 : : analysis_creator_t create) {
97 : 728 : module * m = new module ();
98 : 728 : m->definition = define ();
99 : 728 : m->anacreate = create;
100 : 728 : modules.put ((char *) define()->type, m);
101 : 728 : }
102 : :
103 : : // Registers a circuit object to the list of available modules.
104 : 15184 : void module::registerModule (circuit_definer_t define,
105 : : circuit_creator_t create) {
106 : 15184 : module * m = new module ();
107 : 15184 : m->definition = define ();
108 : 15184 : m->circreate = create;
109 : 15184 : registerModule (define()->type, m);
110 : 15184 : }
111 : :
112 : : // Registers a miscellaneous object to the list of available modules.
113 : 208 : void module::registerModule (misc_definer_t define) {
114 : 208 : module * m = new module ();
115 : 208 : m->definition = define ();
116 : 208 : registerModule (define()->type, m);
117 : 208 : }
118 : :
119 : : /* Registers a miscellaneous structure just defined by a somple
120 : : define_t structure to the list of available modules. */
121 : 208 : void module::registerModule (struct define_t * define) {
122 : 208 : module * m = new module ();
123 : 208 : m->definition = define;
124 : 208 : registerModule (define->type, m);
125 : 208 : }
126 : :
127 : : // Puts a module into the available module hash.
128 : 15600 : void module::registerModule (const char * type, module * m) {
129 [ - + ]: 15600 : if (modules.get ((char *) type) != NULL) {
130 : 0 : logprint (LOG_ERROR, "module already registered: %s\n", type);
131 : : }
132 : : else {
133 : 15600 : modules.put ((char *) type, m);
134 : : }
135 : 15600 : }
136 : :
137 : : /* Returns the definition of a module specified by its type name if
138 : : such is existing and otherwise NULL. */
139 : 1098 : struct define_t * module::getModule (char * type) {
140 : 1098 : module * m = modules.get (type);
141 [ + - ]: 1098 : if (m != NULL) {
142 : 1098 : return m->definition;
143 : : }
144 : 1098 : return NULL;
145 : : }
146 : :
147 : : // Helper macros.
148 : : #define REGISTER_CIRCUIT(val) \
149 : : registerModule (&val::definition, &val::create)
150 : : #define REGISTER_ANALYSIS(val) \
151 : : registerModule (&val::definition, &val::create)
152 : : #define REGISTER_MISC(val) \
153 : : registerModule (&val::definition)
154 : :
155 : : // Global static module registration.
156 : 104 : void module::registerModules (void) {
157 : :
158 : : // miscellaneous
159 : 104 : registerModule (&miscdef1);
160 : 104 : registerModule (&miscdef2);
161 : 104 : REGISTER_MISC (nodeset);
162 : 104 : REGISTER_MISC (substrate);
163 : :
164 : : // circuit components
165 : 104 : REGISTER_CIRCUIT (resistor);
166 : 104 : REGISTER_CIRCUIT (capacitor);
167 : 104 : REGISTER_CIRCUIT (pac);
168 : 104 : REGISTER_CIRCUIT (inductor);
169 : 104 : REGISTER_CIRCUIT (vccs);
170 : 104 : REGISTER_CIRCUIT (cccs);
171 : 104 : REGISTER_CIRCUIT (vcvs);
172 : 104 : REGISTER_CIRCUIT (ccvs);
173 : 104 : REGISTER_CIRCUIT (biastee);
174 : 104 : REGISTER_CIRCUIT (dcfeed);
175 : 104 : REGISTER_CIRCUIT (dcblock);
176 : 104 : REGISTER_CIRCUIT (circulator);
177 : 104 : REGISTER_CIRCUIT (attenuator);
178 : 104 : REGISTER_CIRCUIT (isolator);
179 : 104 : REGISTER_CIRCUIT (trafo);
180 : 104 : REGISTER_CIRCUIT (strafo);
181 : 104 : REGISTER_CIRCUIT (vdc);
182 : 104 : REGISTER_CIRCUIT (idc);
183 : 104 : REGISTER_CIRCUIT (vac);
184 : 104 : REGISTER_CIRCUIT (iac);
185 : 104 : REGISTER_CIRCUIT (iexp);
186 : 104 : REGISTER_CIRCUIT (vexp);
187 : 104 : REGISTER_CIRCUIT (ifile);
188 : 104 : REGISTER_CIRCUIT (vfile);
189 : 104 : REGISTER_CIRCUIT (vam);
190 : 104 : REGISTER_CIRCUIT (vpm);
191 : 104 : REGISTER_CIRCUIT (vpulse);
192 : 104 : REGISTER_CIRCUIT (ipulse);
193 : 104 : REGISTER_CIRCUIT (vrect);
194 : 104 : REGISTER_CIRCUIT (irect);
195 : 104 : REGISTER_CIRCUIT (gyrator);
196 : 104 : REGISTER_CIRCUIT (phaseshifter);
197 : 104 : REGISTER_CIRCUIT (tswitch);
198 : 104 : REGISTER_CIRCUIT (relais);
199 : 104 : REGISTER_CIRCUIT (tline);
200 : 104 : REGISTER_CIRCUIT (tline4p);
201 : 104 : REGISTER_CIRCUIT (ctline);
202 : 104 : REGISTER_CIRCUIT (coaxline);
203 : 104 : REGISTER_CIRCUIT (rectline);
204 : 104 : REGISTER_CIRCUIT (twistedpair);
205 : 104 : REGISTER_CIRCUIT (rlcg);
206 : 104 : REGISTER_CIRCUIT (coupler);
207 : 104 : REGISTER_CIRCUIT (hybrid);
208 : 104 : REGISTER_CIRCUIT (diode);
209 : 104 : REGISTER_CIRCUIT (eqndefined);
210 : 104 : REGISTER_CIRCUIT (rfedd);
211 : 104 : REGISTER_CIRCUIT (diac);
212 : 104 : REGISTER_CIRCUIT (thyristor);
213 : 104 : REGISTER_CIRCUIT (triac);
214 : 104 : REGISTER_CIRCUIT (tunneldiode);
215 : 104 : REGISTER_CIRCUIT (msline);
216 : 104 : REGISTER_CIRCUIT (mscorner);
217 : 104 : REGISTER_CIRCUIT (msstep);
218 : 104 : REGISTER_CIRCUIT (msopen);
219 : 104 : REGISTER_CIRCUIT (msgap);
220 : 104 : REGISTER_CIRCUIT (msmbend);
221 : 104 : REGISTER_CIRCUIT (mscoupled);
222 : 104 : REGISTER_CIRCUIT (mslange);
223 : 104 : REGISTER_CIRCUIT (mstee);
224 : 104 : REGISTER_CIRCUIT (mscross);
225 : 104 : REGISTER_CIRCUIT (msvia);
226 : 104 : REGISTER_CIRCUIT (msrstub);
227 : 104 : REGISTER_CIRCUIT (bondwire);
228 : 104 : REGISTER_CIRCUIT (cpwline);
229 : 104 : REGISTER_CIRCUIT (cpwopen);
230 : 104 : REGISTER_CIRCUIT (cpwshort);
231 : 104 : REGISTER_CIRCUIT (cpwgap);
232 : 104 : REGISTER_CIRCUIT (cpwstep);
233 : 104 : REGISTER_CIRCUIT (iprobe);
234 : 104 : REGISTER_CIRCUIT (vprobe);
235 : 104 : REGISTER_CIRCUIT (jfet);
236 : 104 : REGISTER_CIRCUIT (bjt);
237 : 104 : REGISTER_CIRCUIT (spfile);
238 : 104 : REGISTER_CIRCUIT (vnoise);
239 : 104 : REGISTER_CIRCUIT (inoise);
240 : 104 : REGISTER_CIRCUIT (mosfet);
241 : 104 : REGISTER_CIRCUIT (amplifier);
242 : 104 : REGISTER_CIRCUIT (opamp);
243 : 104 : REGISTER_CIRCUIT (iinoise);
244 : 104 : REGISTER_CIRCUIT (mutual);
245 : 104 : REGISTER_CIRCUIT (mutual2);
246 : 104 : REGISTER_CIRCUIT (mutualx);
247 : 104 : REGISTER_CIRCUIT (ivnoise);
248 : 104 : REGISTER_CIRCUIT (vvnoise);
249 : 104 : REGISTER_CIRCUIT (inverter);
250 : 104 : REGISTER_CIRCUIT (logicnor);
251 : 104 : REGISTER_CIRCUIT (logicor);
252 : 104 : REGISTER_CIRCUIT (logicnand);
253 : 104 : REGISTER_CIRCUIT (logicand);
254 : 104 : REGISTER_CIRCUIT (logicxnor);
255 : 104 : REGISTER_CIRCUIT (logicxor);
256 : 104 : REGISTER_CIRCUIT (digisource);
257 : 104 : REGISTER_CIRCUIT (buffer);
258 : 104 : REGISTER_CIRCUIT (hicumL2V2p1);
259 : 104 : REGISTER_CIRCUIT (HBT_X);
260 : 104 : REGISTER_CIRCUIT (mod_amp);
261 : 104 : REGISTER_CIRCUIT (hic2_full);
262 : 104 : REGISTER_CIRCUIT (log_amp);
263 : 104 : REGISTER_CIRCUIT (hic0_full);
264 : 104 : REGISTER_CIRCUIT (potentiometer);
265 : 104 : REGISTER_CIRCUIT (MESFET);
266 : 104 : REGISTER_CIRCUIT (EKV26MOS);
267 : 104 : REGISTER_CIRCUIT (bsim3v34nMOS);
268 : 104 : REGISTER_CIRCUIT (bsim3v34pMOS);
269 : 104 : REGISTER_CIRCUIT (bsim4v30nMOS);
270 : 104 : REGISTER_CIRCUIT (bsim4v30pMOS);
271 : 104 : REGISTER_CIRCUIT (hicumL0V1p2);
272 : 104 : REGISTER_CIRCUIT (hicumL0V1p2g);
273 : 104 : REGISTER_CIRCUIT (hicumL0V1p3);
274 : 104 : REGISTER_CIRCUIT (hicumL2V2p23);
275 : 104 : REGISTER_CIRCUIT (hicumL2V2p24);
276 : 104 : REGISTER_CIRCUIT (hicumL2V2p31n);
277 : 104 : REGISTER_CIRCUIT (photodiode);
278 : 104 : REGISTER_CIRCUIT (phototransistor);
279 : 104 : REGISTER_CIRCUIT (nigbt);
280 : 104 : REGISTER_CIRCUIT (dff_SR);
281 : 104 : REGISTER_CIRCUIT (tff_SR);
282 : 104 : REGISTER_CIRCUIT (jkff_SR);
283 : 104 : REGISTER_CIRCUIT (gatedDlatch);
284 : 104 : REGISTER_CIRCUIT (logic_1);
285 : 104 : REGISTER_CIRCUIT (logic_0);
286 : 104 : REGISTER_CIRCUIT (mux2to1);
287 : 104 : REGISTER_CIRCUIT (mux4to1);
288 : 104 : REGISTER_CIRCUIT (mux8to1);
289 : 104 : REGISTER_CIRCUIT (DLS_nto1);
290 : 104 : REGISTER_CIRCUIT (DLS_1ton);
291 : 104 : REGISTER_CIRCUIT (andor4x2);
292 : 104 : REGISTER_CIRCUIT (andor4x3);
293 : 104 : REGISTER_CIRCUIT (andor4x4);
294 : 104 : REGISTER_CIRCUIT (dmux2to4);
295 : 104 : REGISTER_CIRCUIT (dmux3to8);
296 : 104 : REGISTER_CIRCUIT (dmux4to16);
297 : 104 : REGISTER_CIRCUIT (ha1b);
298 : 104 : REGISTER_CIRCUIT (fa1b);
299 : 104 : REGISTER_CIRCUIT (fa2b);
300 : 104 : REGISTER_CIRCUIT (pad2bit);
301 : 104 : REGISTER_CIRCUIT (pad3bit);
302 : 104 : REGISTER_CIRCUIT (pad4bit);
303 : 104 : REGISTER_CIRCUIT (binarytogrey4bit);
304 : 104 : REGISTER_CIRCUIT (greytobinary4bit);
305 : 104 : REGISTER_CIRCUIT (comp_1bit);
306 : 104 : REGISTER_CIRCUIT (comp_2bit);
307 : 104 : REGISTER_CIRCUIT (comp_4bit);
308 : 104 : REGISTER_CIRCUIT (hpribin4bit);
309 : 104 : REGISTER_CIRCUIT (vcresistor);
310 : 104 : REGISTER_CIRCUIT (ecvs);
311 : :
312 : : // analyses
313 : 104 : REGISTER_ANALYSIS (dcsolver);
314 : 104 : REGISTER_ANALYSIS (acsolver);
315 : 104 : REGISTER_ANALYSIS (spsolver);
316 : 104 : REGISTER_ANALYSIS (trsolver);
317 : 104 : REGISTER_ANALYSIS (hbsolver);
318 : 104 : REGISTER_ANALYSIS (parasweep);
319 : 104 : REGISTER_ANALYSIS (e_trsolver);
320 : 104 : }
321 : :
322 : : // Global module unregistration.
323 : 103 : void module::unregisterModules (void) {
324 : 103 : qucs::hashiterator<module> it;
325 [ + - ][ + - ]: 16274 : for (it = qucs::hashiterator<module> (modules); *it; ++it) {
[ + + ]
326 [ + - ]: 16171 : delete it.currentVal ();
327 : : }
328 [ + - ]: 103 : modules.clear ();
329 : 103 : }
330 : :
331 : : #if DEBUG
332 : : // header prefix
333 : : static const char * def_prefix =
334 : : "/*\n"
335 : : " * qucsdefs.h - netlist definitions for the Qucs netlists\n"
336 : : " *\n"
337 : : " * This is free software; you can redistribute it and/or modify\n"
338 : : " * it under the terms of the GNU General Public License as published by\n"
339 : : " * the Free Software Foundation; either version 2, or (at your option)\n"
340 : : " * any later version.\n"
341 : : " * \n"
342 : : " */\n"
343 : : "\n"
344 : : "#ifndef __QUCSDEFS_H__\n"
345 : : "#define __QUCSDEFS_H__\n";
346 : :
347 : : // header suffix
348 : : static const char * def_suffix =
349 : : "\n"
350 : : "#endif /* __QUCSDEFS_H__ */\n";
351 : :
352 : : // start of list of definitions
353 : : static const char * def_start =
354 : : "\n"
355 : : "// List of available components.\n"
356 : : "struct define_t qucs_definition_available[] =\n";
357 : :
358 : : // end of list entry
359 : : static const char * def_stop =
360 : : "\n"
361 : : "static struct define_t def_End = {\n"
362 : : " ((char *) 0), -1, 1, 0, 0, req_Def, opt_Def };\n";
363 : :
364 : : // Returns a compilable C-code string made from the given string.
365 : 11528 : static char * printstr (const char * str) {
366 : : static char txt[256];
367 : 11528 : int nostr = (str == PROP_NO_STR);
368 : : sprintf (txt, "%s%s%s",
369 : : (str && !nostr) ? "\"" : "",
370 : : str ? nostr ? "((char *) -1)" : str : "((char *) 0)",
371 [ + + ][ + + ]: 11528 : (str && !nostr) ? "\"" : "");
[ + + ][ + + ]
[ + + ][ + + ]
372 : 11528 : return txt;
373 : : }
374 : :
375 : : // Prints a property list as compilable C-code.
376 : 314 : static void printprop (const char * type, const char * prefix,
377 : : struct property_t * prop) {
378 : : const char * key;
379 : : const char ** str;
380 : : const char * txt;
381 : 314 : fprintf (stdout, "static struct property_t %s_%s[] = {\n", prefix, type);
382 [ + + ]: 3726 : do {
383 : 3726 : key = prop->key;
384 : 3726 : fprintf (stdout, " { %s, %d, ", printstr (key), prop->type);
385 : : fprintf (stdout, "{ %g, %s }, ", prop->defaultval.d,
386 : 3726 : printstr (prop->defaultval.s));
387 : : fprintf (stdout, "{ '%c', %g, %g, '%c',\n",
388 : 3726 : prop->range.il, prop->range.l, prop->range.h, prop->range.ih);
389 : 3726 : fprintf (stdout, " {");
390 : 3726 : str = prop->range.str;
391 [ + + ]: 3919 : do {
392 : 3919 : txt = *str;
393 : 3919 : fprintf (stdout, " %s", printstr (txt));
394 [ + + ]: 3919 : if (txt) fprintf (stdout, ",");
395 : 3919 : str++;
396 : : }
397 : : while (txt != NULL);
398 : 3726 : fprintf (stdout, " } } }");
399 [ + + ]: 3726 : if (key) fprintf (stdout, ",");
400 : 3726 : fprintf (stdout, "\n");
401 : 3726 : prop++;
402 : : }
403 : : while (key != NULL);
404 : 314 : fprintf (stdout, "};\n");
405 : 314 : }
406 : :
407 : : /* The function emits a complete list of the registered component
408 : : definitions as compilable C-code. */
409 : 1 : void module::print (void) {
410 [ + - ]: 1 : fprintf (stdout, "%s", def_prefix);
411 : 1 : qucs::hashiterator<module> it;
412 [ + - ][ + - ]: 158 : for (it = qucs::hashiterator<module> (modules); *it; ++it) {
[ + + ]
413 : 157 : module * m = it.currentVal ();
414 : 157 : struct define_t * def = m->definition;
415 [ + - ]: 157 : fprintf (stdout, "\n");
416 [ + - ]: 157 : printprop (def->type, "req", def->required);
417 [ + - ]: 157 : fprintf (stdout, "\n");
418 [ + - ]: 157 : printprop (def->type, "opt", def->optional);
419 [ + - ]: 157 : fprintf (stdout, "\n");
420 [ + - ]: 157 : fprintf (stdout, "static struct define_t def_%s = {\n", def->type);
421 : : fprintf (stdout, " %s, %d, %d, %d, %d, req_%s, opt_%s };\n",
422 : : printstr (def->type), def->nodes, def->action, def->substrate,
423 [ + - ]: 157 : def->nonlinear, def->type, def->type);
424 : : }
425 [ + - ]: 1 : fprintf (stdout, "%s", def_stop);
426 [ + - ]: 1 : fprintf (stdout, "%s", def_start);
427 [ + - ]: 1 : fprintf (stdout, "{\n");
428 [ + - ][ + - ]: 158 : for (it = qucs::hashiterator<module> (modules); *it; ++it) {
[ + + ]
429 : 157 : module * m = it.currentVal ();
430 : 157 : struct define_t * def = m->definition;
431 [ + - ]: 157 : fprintf (stdout, " def_%s,\n", def->type);
432 : : }
433 [ + - ]: 1 : fprintf (stdout, " def_End\n");
434 [ + - ]: 1 : fprintf (stdout, "};\n");
435 [ + - ]: 1 : fprintf (stdout, "%s", def_suffix);
436 : 1 : }
437 : : #endif /* DEBUG */
438 : :
439 : :
440 : : // look for dynamic libs, load and register them
441 : 103 : void module::registerDynamicModules (char *proj, std::list<std::string> modlist)
442 : : {
443 : : /* How it is (WAS) supposed to work:
444 : : * 1) It will list the working directory contents looking for libraries
445 : : * 2) It will try to open each library and put its handle into a list
446 : : * - Just by opening the lib it will already populate the factorycreate and factorydef
447 : : * 3) The factory is iterated to create new modules and add them to the global hash
448 : : *
449 : : * TODO:
450 : : * - Add destructor for loaded objects
451 : : * - Add other methods to find the libraries
452 : : *
453 : : * Update
454 : : * * project path is passed as paramter
455 : : * * module names are passed as parameter
456 : : */
457 : :
458 [ + - ]: 103 : fprintf(stdout,"project location: %s\n", proj);
459 [ + - ]: 103 : fprintf(stdout,"modules to load: %lu\n", modlist.size());
460 : :
461 : 103 : std::list<std::string>::iterator it;
462 [ - + ]: 103 : for (it=modlist.begin(); it!=modlist.end(); ++it) {
463 : :
464 [ # # ]: 0 : std::string absPathLib = proj;
465 : :
466 : : #ifdef __APPLE__
467 [ # # ][ # # ]: 0 : absPathLib = absPathLib + "/" + *it + ".dylib";
[ # # ][ # # ]
468 : : #endif
469 : : #ifdef __linux__
470 : : absPathLib = absPathLib + "/" + *it + ".so";
471 : : #endif
472 : : #ifdef __MINGW32__
473 : : absPathLib = absPathLib + "\\" + *it + ".dll";
474 : : #endif
475 : :
476 : : // which lib is going to be loaded
477 [ # # ]: 0 : fprintf( stdout, "try loading %s\n", absPathLib.c_str() );
478 : :
479 : : #if __MINGW32__
480 : : // Load the DLL
481 : : HINSTANCE dlib = ::LoadLibrary(TEXT(absPathLib.c_str()));
482 : : if (!dlib) {
483 : : std::cerr << "Unable to load DLL!\n";
484 : : exit(-1);
485 : : }
486 : : #else //Linux and OSX
487 : : // for some reason the RTLD_NOW alones makes dlopen
488 : : // stick with the name (content) of the first loaded library
489 [ # # ]: 0 : void* dlib = dlopen(absPathLib.c_str(), RTLD_NOW|RTLD_LOCAL);
490 [ # # ]: 0 : if(dlib == NULL){
491 [ # # ][ # # ]: 0 : std::cerr << dlerror() << std::endl;
[ # # ]
492 : 0 : exit(-1);
493 : : }
494 : : #endif
495 : :
496 : : // add the handle to our list
497 [ # # ]: 0 : dl_list.insert(dl_list.end(), dlib);
498 : :
499 : 0 : }
500 : :
501 : : // report on factorycreate
502 [ + - ][ + - ]: 103 : std::cout << "factorycreate.size() is " << factorycreate.size() << '\n';
[ + - ]
503 [ + - ]: 103 : std::cout << "factorycreate has registered:";
504 : :
505 : : // print map key names/registered objects into factory
506 : 103 : std::map<std::string, creator_t *, std::less<std::string> >::iterator fitr;
507 [ - + ]: 103 : for (fitr=factorycreate.begin(); fitr!=factorycreate.end(); ++fitr)
508 [ # # ][ # # ]: 0 : std::cout << ' ' << fitr->first;
509 [ + - ]: 103 : std::cout << '\n';
510 : :
511 : : // loop again over registered keys in factory and register into hash
512 [ - + ]: 103 : for (fitr=factorycreate.begin(); fitr!=factorycreate.end(); ++fitr) {
513 : :
514 : : // fetch creator and definition by key name from factories
515 [ # # ]: 0 : circuit_creator_t mycreate = factorycreate[fitr->first];
516 [ # # ][ # # ]: 0 : define_t *mydefine = factorydef[fitr->first]();
517 : :
518 : : /*
519 : : printf("\n type: %s\n",mydefine->type );
520 : : printf(" nodes: %i\n",mydefine->nodes );
521 : : printf(" action: %i\n",mydefine->action );
522 : : printf(" required->key: %s\n",mydefine->required->key);
523 : : */
524 : :
525 : : // modified registerModule to register dynamic loaded modules
526 [ # # ]: 0 : module * m = new module ();
527 : 0 : m->circreate = mycreate;
528 : 0 : m->definition = mydefine;
529 : :
530 [ # # ][ # # ]: 0 : if (modules.get ((char *) mydefine->type) != NULL) {
531 [ # # ]: 0 : logprint (LOG_ERROR, "load module already registered: %s\n", mydefine->type);
532 : : }
533 : : else {
534 [ # # ]: 0 : modules.put ((char *) mydefine->type, m);
535 : : }
536 : : }
537 : :
538 : : // print registered components
539 : : /*
540 : : qucs::hashiterator<module> it;
541 : : for (it = qucs::hashiterator<module> (module::modules); *it; ++it) {
542 : : module * m = it.currentVal ();
543 : : struct define_t * def = m->definition;
544 : : printf("\n" );
545 : : printf("type: %s\n",def->type );
546 : : printf("\n" );
547 : : }
548 : : */
549 : :
550 : 103 : }
551 : :
552 : : // Close all the dynamic libs if any opened
553 : 103 : void module::closeDynamicLibs()
554 : : {
555 [ - + ]: 103 : for(itr=dl_list.begin(); itr!=dl_list.end(); itr++){
556 : : #if __MINGW32__
557 : : FreeLibrary(*itr);
558 : : #else
559 : 0 : dlclose(*itr);
560 : : #endif
561 : : }
562 [ + - ][ + - ]: 424 : }
|
