rti2code.cpp
Go to the documentation of this file.
1 /** rti2code.cpp Utility to generate registry initialisation code from rti files */
2 
3 /* FAU Discrete Event Systems Library (libfaudes)
4 
5 Copyright (C) 2009 Ruediger Berndt
6 Copyright (C) 2010, 2023, 2025 Thomas Moor
7 
8 This library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Lesser General Public
10 License as published by the Free Software Foundation; either
11 version 2.1 of the License, or (at your option) any later version.
12 
13 This library is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17 
18 You should have received a copy of the GNU Lesser General Public
19 License along with this library; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
21 
22 
23 #include <string>
24 #include <iostream>
25 #include <fstream>
26 #include "corefaudes.h"
27 
28 
29 using namespace faudes;
30 
31 // ******************************************************************
32 // error exit
33 // ******************************************************************
34 
35 void usage(const std::string& rMessage="") {
36  // UI hints
37  if(rMessage!="") {
38  std::cerr << rMessage << std::endl;
39  std::cout << "" << std::endl;
40  }
41  std::cerr << "rti2code: " << VersionString() << std::endl;
42  std::cerr << std::endl;
43  std::cerr << "utility to generates c code from an rti-file to " << std::endl;
44  std::cerr << "1) register faudes-types and -functions with the run-time interface," << std::endl;
45  std::cerr << "2) extract c declarations for bindings interface code." << std::endl;
46  std::cerr << std::endl;
47  std::cerr << "usage:" << std::endl;
48  std::cerr << " rti2code [-swig|-loader] <rti input file> <output basename>" << std::endl;
49  std::cerr << " rti2code -merge <rti input files> <output rti-file>" << std::endl;
50  std::cerr << std::endl;
51  std::cerr << "[note: the -loader flag will produce .h/.cpp files to instantiate prototypes" << std::endl;
52  std::cerr << "[note: the -swig flag will produce a .i file for swig include" << std::endl;
53  std::cerr << "[note: the -flat flag circumvents an issue with SWIG pre 4.1.0]" << std::endl;
54  exit(1);
55 }
56 
57 
58 // ******************************************************************
59 // main programm
60 // ******************************************************************
61 
62 int main(int argc, char *argv[]) {
63 
64  // config
65  bool loader=false;
66  bool swig=false;
67  bool flat=false;
68  bool merge=false;
69 
70  // primitive command line parser
71  int pos=1;
72  for(; pos<argc; pos++) {
73  std::string option(argv[pos]);
74  // option: help
75  if((option=="-?") || (option=="--help")) {
76  usage();
77  continue;
78  }
79  // option: loader
80  if(option=="-loader") {
81  loader=true;
82  continue;
83  }
84  // option: swig
85  if(option=="-swig") {
86  swig=true;
87  continue;
88  }
89  // option: flat
90  if(option=="-flat") {
91  flat=true;
92  continue;
93  }
94  // option: merge
95  if(option=="-merge") {
96  merge=true;
97  continue;
98  }
99  // option: unknown
100  if(option.c_str()[0]=='-') {
101  usage("unknown option "+ option);
102  continue;
103  }
104  // break for args
105  break;
106  }
107 
108  // mode test
109  if(merge && (loader || swig)) {
110  usage("mismatching options: either merge or code generation");
111  }
112  if(!merge && !(loader || swig)) {
113  usage("mismatching options: either merge or code generation");
114  }
115  if(flat && !swig) {
116  usage("mismatching options: flat is only applicable to swig");
117  }
118  if(merge && (argc-pos <3)) {
119  usage("mismatching agruments: to few files to merge");
120  }
121  if(!merge && (argc-pos !=2)) {
122  usage("mismatching agruments: need one source and one destination for code generation");
123  }
124 
125  // Merge mode -- get this done first
126  if(merge) {
127  // Load from files
128  for(; pos< argc-1; pos++) {
129  TypeRegistry::G()->MergeDocumentation(std::string(argv[pos]));
130  FunctionRegistry::G()->MergeDocumentation(std::string(argv[pos]));
131  }
132  // Dump
133  if(std::string(argv[argc-1]) != "-") {
134  SaveRegistry(std::string(argv[argc-1]));
135  } else {
136  SaveRegistry();
137  }
138  return 0;
139  }
140 
141  // code-gen modes loader/swig
142  LoadRegistry(argv[pos++]);
143 
144  // Code output streams
145  std::ofstream rtiheader;
146  std::ofstream rticode;
147  std::ofstream swigheader;
148  if(loader) {
149  rtiheader.open((std::string(argv[pos])+".h").c_str(), std::ios::out);
150  rticode.open((std::string(argv[pos])+".cpp").c_str(), std::ios::out);
151  }
152  if(swig){
153  swigheader.open((std::string(argv[pos])+".i").c_str(), std::ios::out);
154  }
155 
156  // Introduce myself
157  if(loader) {
158  rtiheader << "/* rti2code: autogenerated libFAUDES rti registration: ";
159  rtiheader << VersionString() << " " << PluginsString() << " */" << std::endl << std::endl;
160  rticode << "/* rti2code: autogenerated libFAUDES rti registration: ";
161  rticode << VersionString() << " " << PluginsString() << " */" << std::endl << std::endl;
162  }
163  if(swig) {
164  swigheader << "/* rti2code: autogenerated libFAUDES swig bindings declarations: ";
165  swigheader << VersionString() << " " << PluginsString() << " */" << std::endl << std::endl;
166  }
167 
168  // C++ static objects: auto load types
169  if(loader) {
170  rticode << "namespace faudes {" << std::endl;
171  rticode << "/* Auto-register faudes types */" << std::endl;
172  }
173 
174  // Traverse type registry to figure faudes types
175  if(loader) {
177  int tcnt;
178  for(tit=TypeRegistry::G()->Begin(), tcnt=1; tit!=TypeRegistry::G()->End();tit++,tcnt++) {
179  // Get c/f type
180  std::string ctype=tit->second->CType();
181  std::string ftype=tit->second->Name();
182  // Bail out if no C type specified
183  if(ctype=="") continue;
184  // Remove name space faudes
185  size_t pos=ctype.find("faudes::");
186  if(pos!=std::string::npos)
187  ctype=ctype.substr(std::string("faudes::").length());
188  // Bail out no auto-registration specified
189  if(!tit->second->AutoRegistered()) continue;
190  // report
191  std::cout << "rti2code: generating auto-registration code for \"" << ftype << "\"" << std::endl;
192  // Produce c code
193  std::string rtiname = std::string("gRti") + ToStringInteger(tcnt) + "Register" + ftype;
194  rticode << "AutoRegisterType<" << ctype << "> " << rtiname << "(\"" << ftype <<"\");";
195  rticode << std::endl;
196  // Extra data set: element tag
197  if(tit->second->ElementTag()!="") {
198  rtiname = std::string("gRti") + ToStringInteger(tcnt) + "ElementTag" + ftype;
199  rticode << "AutoRegisterElementTag<" << ctype << "> " << rtiname << "(\"" << ftype <<
200  "\", \"" << tit->second->ElementTag() << "\");";
201  rticode << std::endl;
202  }
203  // Extra data set: element tag
204  if(tit->second->ElementType()!="") {
205  rtiname = std::string("gRti") + ToStringInteger(tcnt) + "ElementType" + ftype;
206  rticode << "AutoRegisterElementType<" << ctype << "> " << rtiname << "(\"" << ftype <<
207  "\", \"" << tit->second->ElementType() << "\");";
208  rticode << std::endl;
209  }
210  }
211  }
212 
213  // C++ static objects: auto load types end
214  if(loader) {
215  rticode << "} // namespace" << std::endl;
216  }
217 
218  // C++ function declaration: load types
219  if(loader) {
220  rtiheader << "namespace faudes {" << std::endl;
221  rtiheader << "void LoadRegisteredTypes(void);" << std::endl;
222  rtiheader << "} // namespace" << std::endl;
223  }
224 
225  // C++ function definition: load types
226  if(loader) {
227  rticode << "namespace faudes {" << std::endl;
228  rticode << "/* Register faudes types */" << std::endl;
229  rticode << "void LoadRegisteredTypes(void) {" << std::endl;
230  }
231 
232  // Traverse type registry to figure faudes types
233  if(loader) {
235  int tcnt;
236  for(tit=TypeRegistry::G()->Begin(); tit!=TypeRegistry::G()->End();tit++) {
237  // Get C type
238  std::string ctype=tit->second->CType();
239  // Bail out if no c type specified
240  if(ctype=="") continue;
241  // Remove name space faudes
242  size_t pos=ctype.find("faudes::");
243  if(pos!=std::string::npos)
244  ctype=ctype.substr(std::string("faudes::").length());
245  // Report
246  std::cout << "rti2code: generating registration code for \"" << tit->second->Name() << "\"" << std::endl;
247  // Produce c code
248  rticode << " TypeRegistry::G()->Insert<" << ctype << ">(\"" << tit->second->Name() <<"\");";
249  rticode << std::endl;
250  }
251  }
252 
253  // C++ function definition: load types end
254  if(loader) {
255  rticode << "}" << std::endl;
256  rticode << "} // namespace" << std::endl;
257  }
258 
259 
260  // C++ function declaration: load functions
261  if(loader) {
262  rtiheader << "namespace faudes {" << std::endl;
263  rtiheader << "void LoadRegisteredFunctions(void);" << std::endl;
264  rtiheader << "} // namespace" << std::endl;
265  }
266 
267  // C++ function definition: load functions
268  if(loader) {
269  rticode << "namespace faudes {" << std::endl;
270  rticode << "/* Register faudes functions */" << std::endl;
271  rticode << "void LoadRegisteredFunctions(void) {" << std::endl;
272  }
273 
274  // C++ class definition: Function derivates
275  if(loader) {
276  rtiheader << "namespace faudes {" << std::endl;
277  }
278 
279  // Traverse function registry: define rti functions
280  int fcnt=0;
282  for(fit=FunctionRegistry::G()->Begin(); fit!=FunctionRegistry::G()->End();fit++, fcnt++) {
283  // Current function definition
284  const FunctionDefinition* fdef = fit->second;
285  // Get C type and faudes function name
286  std::string ctype=fdef->CType();
287  std::string fname = fdef->Name();
288  // Bail out if no c type specified
289  if(ctype=="") continue;
290  // Remove name space faudes
291  size_t pos=ctype.find("faudes::");
292  if(pos!=std::string::npos)
293  ctype=ctype.substr(std::string("faudes::").length());
294  // Bail out if no signature
295  if(fdef->VariantsSize()==0) {
296  std::cout << "rti2cocde: function registration: " << fname << ": no signatures" << std::endl;
297  continue;
298  }
299  // Interpret signatures: set up type array
300  std::vector< std::vector<std::string> > cparams;
301  std::vector< std::vector<Parameter::ParamAttr> > cattrib;
302  std::vector< std::vector<bool> > cretval;
303  cparams.resize(fdef->VariantsSize());
304  cattrib.resize(fdef->VariantsSize());
305  cretval.resize(fdef->VariantsSize());
306  // Loop all signatures
307  for(int i=0; i<fdef->VariantsSize(); i++) {
308  const Signature& sigi=fdef->Variant(i);
309  int retcount=0;
310  for(int j=0; j<sigi.Size(); j++) {
311  // Retrieve faudes type and attrib
312  std::string ftype=sigi.At(j).Type();
313  Parameter::ParamAttr fattr=sigi.At(j).Attribute();
314  bool fcret=sigi.At(j).CReturn();
315  // Count ret values
316  if(fcret) retcount++;
317  // Bail out on unknown faudestype
318  if(!TypeRegistry::G()->Exists(ftype)) break;
319  // Get corresponding ctype
320  std::string ctype=TypeRegistry::G()->Definition(ftype).CType();
321  // Bail out on unknown ctype
322  if(ctype=="") break;
323  // bail out on non-out ret value
324  if(fcret && !(fattr==Parameter::Out)) break;
325  // Bail out on undef attribute
326  if(fattr==Parameter::UnDef) break;
327  // Bail out on more than one ret values
328  if(retcount>1) break;
329  // Remove name space faudes
330  size_t pos=ctype.find("faudes::");
331  if(pos!=std::string::npos)
332  ctype=ctype.substr(std::string("faudes::").length());
333  // Param ok
334  cparams.at(i).push_back(ctype);
335  cattrib.at(i).push_back(fattr);
336  cretval.at(i).push_back(fcret);
337  }
338  // Test for signature error
339  if((int) cparams.at(i).size()!=sigi.Size()) {
340  std::cout << "rti2code: function registration: " << fname << ": cannot interpret signature "
341  << sigi.Name() << std::endl;
342  cparams.resize(i);
343  break;
344  }
345  }
346  // Report
347  std::cout << "rti2code: generating rti wrapper for \"" << fdef->Name() << "\"" <<
348  " #" << cparams.size() << " variants" << std::endl;
349  std::string rtiname = std::string("Rti") + ToStringInteger(fcnt) + ctype;
350  // Produce c code: register all functions function
351  if(loader) {
352  rticode << " FunctionRegistry::G()->Insert<" << rtiname << ">(\"" << fname <<"\");" << std::endl;
353  }
354  // Produce c code: class declaration intro
355  if(loader) {
356  rtiheader << "/* Function class for C++ function " << ctype << "*/" << std::endl;
357  rtiheader << "class " << rtiname << " : public Function { " << std::endl;
358  rtiheader << "public:" << std::endl;
359  rtiheader << " using Function::operator=;" << std::endl;
360  rtiheader << rtiname << "(const FunctionDefinition* fdef) : Function(fdef) {};" << std::endl;
361  rtiheader << "virtual Function* New(void) const { return new " << rtiname << "(pFuncDef); };" << std::endl;
362  rtiheader << "protected:" << std::endl;
363  }
364  // Produce c code: function class: have typed param
365  if(loader) {
366  for(unsigned int i=0; i<cparams.size(); i++)
367  for(unsigned int j=0; j<cparams.at(i).size(); j++)
368  rtiheader << cparams.at(i).at(j) << "* " << "mP_" << i << "_" << j << ";" << std::endl;
369  }
370  // Produce c code: function class: do type check
371  if(loader) {
372  rtiheader << "virtual bool DoTypeCheck(int n) {" << std::endl;
373  rtiheader << " bool res=false;" << std::endl;
374  rtiheader << " switch(mVariantIndex) { "<< std::endl;
375  for(unsigned int i=0; i<cparams.size(); i++) {
376  rtiheader << " case " << i << ": { // variant " << fdef->Variant(i).Name() << std::endl;
377  rtiheader << " switch(n) { "<< std::endl;
378  for(unsigned int j=0; j<cparams.at(i).size(); j++) {
379  rtiheader << " case " << j << ": ";
380  rtiheader << " res=DoTypeCast<" << cparams.at(i).at(j) << ">(" << j << ", mP_" << i <<"_" << j << "); ";
381  rtiheader << "break; "<< std::endl;
382  }
383  rtiheader << " default: break; " << std::endl;
384  rtiheader << " } "<< std::endl;
385  rtiheader << " break; "<< std::endl;
386  rtiheader << " } "<< std::endl;
387  }
388  rtiheader << " default: break; " << std::endl;
389  rtiheader << " } "<< std::endl;
390  rtiheader << " return res;" << std::endl;
391  rtiheader << "};" << std::endl;
392  }
393  // Produce c code: function class: do execute
394  if(loader) {
395  rtiheader << "virtual void DoExecute(void) {" << std::endl;
396  }
397  // Produce c code: do execute: switch variant
398  if(loader) {
399  rtiheader << " switch(mVariantIndex) { "<< std::endl;
400  for(unsigned int i=0; i<cparams.size(); i++) {
401  rtiheader << " case " << i << ": { // variant " << fdef->Variant(i).Name() << std::endl;
402  rtiheader << " ";
403  // Figure return value (if any)
404  for(unsigned int j=0; j<cparams.at(i).size(); j++) {
405  if(!cretval.at(i).at(j)) continue;
406  // Special case: integer
407  if(cparams.at(i).at(j) == "Integer") {
408  rtiheader << "*(mP_" << i << "_" << j << "->CReference()) = ";
409  } else
410  // Special case: boolean
411  if(cparams.at(i).at(j) == "Boolean") {
412  rtiheader << "*(mP_" << i << "_" << j << "->CReference()) = ";
413  } else
414  // Special case: integer
415  if(cparams.at(i).at(j) == "String") {
416  rtiheader << "*(mP_" << i << "_" << j << "->CReference()) = ";
417  } else
418  // Std case
419  rtiheader << "*mP_" << i << "_" << j << " = ";
420  }
421  // Function name
422  rtiheader << ctype <<"(";
423  // Parameters
424  int parpos=0;
425  for(unsigned int j=0; j<cparams.at(i).size(); j++) {
426  if(cretval.at(i).at(j)) continue;
427  if((parpos++)!=0) rtiheader << " ,";
428  // Special case: integer
429  if(cparams.at(i).at(j) == "Integer") {
430  rtiheader << "*(mP_" << i << "_" << j << "->CReference())";
431  } else
432  // Special case: boolean
433  if(cparams.at(i).at(j) == "Boolean") {
434  rtiheader << "*(mP_" << i << "_" << j << "->CReference())";
435  } else
436  // Special case: integer
437  if(cparams.at(i).at(j) == "String") {
438  rtiheader << "*(mP_" << i << "_" << j << "->CReference())";
439  } else
440  // Std case
441  rtiheader << "*mP_" << i << "_" << j;
442  }
443  rtiheader << "); break; };" << std::endl;
444  }
445  // Produce c code: switch variant; done
446  rtiheader << " default: break; " << std::endl;
447  rtiheader << " }; "<< std::endl;
448  // Produce c code: do execute: done
449  rtiheader << "}; "<< std::endl;
450  // Produce c code: function class: done
451  rtiheader << "};" << std::endl;
452  }
453 
454  // Produce swig code: function definition(s)
455  if(swig) {
456  swigheader << "/* faudes-function \"" << fname << "\" */" << std::endl;
457  }
458  // Figure my plugin to insert a conditional
459  if(swig) {
460  if(!flat) {
461  std::string plugin=fdef->PlugIn();
462  swigheader << "#if " << "( SwigModule == \"Swig" << plugin << "\")";
463  //luaheader << " || ( SwigModule == \"SwigLibFaudes\")"; // requires SWIG 4.1
464  swigheader << std::endl;
465  }
466  }
467  // Use C-type function name
468  if(swig) {
469  if(ctype!=fname)
470  swigheader << "%rename(" << fname << ") " << ctype << ";" << std::endl;
471  }
472 
473  // Prepare swig code: preprocessed array
474  if(swig) {
475  std::vector< std::string > lfdefs;
476  std::vector< std::string > lrtypes;
477  std::vector< std::string > lhelp;
478  // Prepare swig code: generate per signature
479  for(unsigned int i=0; i<cparams.size(); i++) {
480  // Create ctype function declaration: return value
481  std::string lrtype="void";
482  for(unsigned int j=0; j<cparams.at(i).size(); j++) {
483  if(!cretval.at(i).at(j)) continue;
484  // Special case: integer
485  if(cparams.at(i).at(j) == "Integer") {
486  lrtype="long int";
487  } else
488  // Special case: boolean
489  if(cparams.at(i).at(j) == "Boolean") {
490  lrtype="bool";
491  } else
492  // Special case: string
493  if(cparams.at(i).at(j) == "String") {
494  lrtype="std::string";
495  } else
496  // Std case ctype as refernce
497  lrtype = cparams.at(i).at(j);
498  // No more than one return value
499  break;
500  }
501  lrtypes.push_back(lrtype);
502  // Create ctype function declaration: function body
503  std::string lfdef = ctype + "(";
504  // Create ctype function declaration: parameters
505  int parpos=0;
506  for(unsigned int j=0; j<cparams.at(i).size(); j++) {
507  if(cretval.at(i).at(j)) continue;
508  if((parpos++)!=0) lfdef += ", ";
509  // Have const for +In+
510  if(cattrib.at(i).at(j)==Parameter::In)
511  lfdef += "const ";
512  // Special case: integer
513  if(cparams.at(i).at(j) == "Integer") {
514  lfdef += "long int&";
515  } else
516  // Special case: boolean
517  if(cparams.at(i).at(j) == "Boolean") {
518  lfdef += "bool&";
519  } else
520  // Special case: string
521  if(cparams.at(i).at(j) == "String") {
522  lfdef += "std::string&";
523  } else
524  // Std case ctype as refernce
525  lfdef += cparams.at(i).at(j) + "&";
526  // Mark elementary outputs
527  if(cparams.at(i).at(j) == "Boolean" || cparams.at(i).at(j) == "String"
528  || cparams.at(i).at(j) == "Integer")
529  if(cattrib.at(i).at(j)==Parameter::Out)
530  lfdef += " OUTPUT";
531  }
532  // End of function declaration
533  lfdef += ")";
534  lfdefs.push_back(lfdef);
535  // Add help entry: build nice signature
536  std::string luasig = " " + fname + "(";
537  bool leftcomma = false;
538  bool rightcomma = false;
539  for(unsigned int j=0; j<cparams.at(i).size(); j++) {
540  // Special case: elementary output
541  if(cparams.at(i).at(j) == "Boolean" || cparams.at(i).at(j) == "String"
542  || cparams.at(i).at(j) == "Integer")
543  if(cattrib.at(i).at(j)==Parameter::Out) {
544  if(leftcomma) luasig = "," + luasig;
545  // if(leftcomma) luasig = ", " + luasig; // need tab in help system?
546  luasig=cparams.at(i).at(j) + luasig;
547  leftcomma=true;
548  continue;
549  }
550  // Std case
551  if(rightcomma) luasig += ", ";
552  const Signature& sigi=fdef->Variant(i);
553  luasig += sigi.At(j).Str();
554  rightcomma=true;
555  }
556  luasig+=")";
557  // Add help entry: add with topic
558  if(fdef->TextDoc()!=""){
559  std::string topic= fdef->PlugIn();
560  std::string key1=fdef->KeywordAt(1);
561  if(topic=="CoreFaudes") {
562  topic=fdef->KeywordAt(1);
563  key1=fdef->KeywordAt(2);
564  }
565  if(topic.length()>0) topic.at(0)=toupper(topic.at(0));
566  if(key1.length()>0) key1.at(0)=toupper(key1.at(0));
567  lhelp.push_back("SwigHelpEntry(\"" + topic + "\", \"" + key1 + "\", \"" +
568  luasig + "\")");
569  } else {
570  lhelp.push_back("");
571  }
572  }
573  // Filter pseudo doublets (only differ in lrtype)
574  for(unsigned int i=1; i<lfdefs.size();i++) {
575  unsigned int j;
576  for(j=0; j<i; j++)
577  if(lfdefs.at(i)==lfdefs.at(j)) break;
578  if(j==i) continue;
579  // Invalidate entry?
580  if(lrtypes.at(j)=="void")
581  {lfdefs[j]=""; continue;}
582  if(lrtypes.at(i)=="void")
583  {lfdefs[i]=""; continue;}
584  } // Done: prepare per signature
585 
586  // Generate swig definitions: write
587  int lcount=0;
588  for(unsigned int i=0; i<lfdefs.size(); i++) {
589  if(lfdefs.at(i)=="") continue;
590  swigheader << lrtypes.at(i) << " " << lfdefs.at(i) << ";" << std::endl;
591  lcount++;
592  if(lhelp.at(i)=="") continue;
593  swigheader << lhelp.at(i) << ";" << std::endl;
594  }
595  std::cout << "rti2code: generating swig interface for function \"" << fdef->Name() << "\"" <<
596  " #" << lcount << " variants" << std::endl;
597 
598  // End all signatures, incl conditional
599  if(!flat) {
600  swigheader << "#endif " << std::endl;
601  }
602  swigheader << std::endl;
603  } // endif swig
604 
605 
606  } // loop all functions
607 
608  // C++ class definition: function class: all such done
609  if(loader) {
610  rtiheader << "} // namespace" << std::endl;
611  }
612 
613  // C++ class definition: register function prototypes: done
614  if(loader) {
615  rticode << "}" << std::endl;
616  rticode << "} // namespace" << std::endl;
617  }
618 
619  return(0);
620 }
const std::string & Name(void) const
Definition: cfl_types.cpp:565
std::string KeywordAt(int pos) const
Definition: cfl_types.cpp:621
const std::string & PlugIn(void) const
Definition: cfl_types.cpp:566
const std::string & TextDoc(void) const
Definition: cfl_types.cpp:568
const std::string & CType(void) const
Definition: cfl_types.cpp:567
const Signature & Variant(const std::string &rName) const
Iterator End(void) const
static FunctionRegistry * G()
std::map< std::string, FunctionDefinition * >::const_iterator Iterator
Definition: cfl_registry.h:541
void MergeDocumentation(TokenReader &rTr)
Iterator Begin(void) const
std::string Str(void) const
bool CReturn(void) const
const std::string & Type(void) const
const ParamAttr & Attribute(void) const
int Size(void) const
const std::string & Name(void) const
const Parameter & At(int n) const
void MergeDocumentation(TokenReader &rTr)
const TypeDefinition & Definition(const std::string &rTypeName) const
static TypeRegistry * G()
bool Exists(const std::string &rName) const
Iterator End(void) const
std::map< std::string, TypeDefinition * >::const_iterator Iterator
Definition: cfl_registry.h:54
void SaveRegistry(const std::string &rPath)
void LoadRegistry(const std::string &rPath)
std::string VersionString()
Definition: cfl_utils.cpp:141
std::string PluginsString()
Definition: cfl_utils.cpp:146
std::string ToStringInteger(Int number)
Definition: cfl_utils.cpp:43
int main(int argc, char *argv[])
Definition: rti2code.cpp:62
void usage(const std::string &rMessage="")
Definition: rti2code.cpp:35

libFAUDES 2.33h --- 2025.06.18 --- c++ api documentaion by doxygen