doxygen  1.8.18
About: Doxygen is a source code documentation generator tool for C++, C, Objective-C, C#, PHP, Java, Python, IDL (diverse flavors), Fortran, VHDL, Tcl, and to some extent D. Different output formats are supported.
  Fossies Dox: doxygen-1.8.18.src.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

vhdldocgen.cpp
Go to the documentation of this file.
1 
15 
22 // global includes
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <assert.h>
26 #include <string.h>
27 #include <qcstring.h>
28 #include <qfileinfo.h>
29 #include <qcstringlist.h>
30 #include <qmap.h>
31 
32 /* --------------------------------------------------------------- */
33 
34 // local includes
35 #include "vhdldocgen.h"
36 #include "message.h"
37 #include "config.h"
38 #include "doxygen.h"
39 #include "util.h"
40 #include "language.h"
41 #include "commentscan.h"
42 #include "index.h"
43 #include "definition.h"
44 #include "searchindex.h"
45 #include "outputlist.h"
46 #include "parserintf.h"
47 #include "layout.h"
48 #include "arguments.h"
49 #include "portable.h"
50 #include "memberlist.h"
51 #include "memberdef.h"
52 #include "groupdef.h"
53 #include "classlist.h"
54 #include "namespacedef.h"
55 #include "filename.h"
56 #include "membergroup.h"
57 #include "memberdef.h"
58 #include "plantuml.h"
59 #include "vhdljjparser.h"
60 #include "VhdlParser.h"
61 //#include "vhdlcode.h"
62 #include "plantuml.h"
63 //#define DEBUGFLOW
64 #define theTranslator_vhdlType theTranslator->trVhdlType
65 
70 
71 static void initUCF(Entry* root,const char* type,QCString & qcs,int line,QCString & fileName,QCString & brief);
72 static void writeUCFLink(const MemberDef* mdef,OutputList &ol);
73 static void addInstance(ClassDef* entity, ClassDef* arch, ClassDef *inst,
74  const std::shared_ptr<Entry> &cur);
75 
76 //---------- create svg -------------------------------------------------------------
77 static void createSVG();
78 static void startDot(FTextStream &t);
79 static void startTable(FTextStream &t,const QCString &className);
81 static void writeVhdlEntityToolTip(FTextStream& t,ClassDef *cd);
82 static void endDot(FTextStream &t);
83 static void writeTable(QList<MemberDef>* port,FTextStream & t);
84 static void endTable(FTextStream &t);
85 static void writeClassToDot(FTextStream &t,ClassDef* cd);
86 static void writeVhdlDotLink(FTextStream &t,const QCString &a,const QCString &b,const QCString &style);
87 //static void writeVhdlPortToolTip(FTextStream& t,QList<MemberDef>* port,ClassDef *cd);
88 static const MemberDef *flowMember=0;
89 
91 {
92  flowMember=mem;
93 }
94 
96 {
97  return flowMember;
98 }
99 
100 
101 
102 //--------------------------------------------------------------------------------------------------
103 static void codify(FTextStream &t,const char *str)
104 {
105  if (str)
106  {
107  const char *p=str;
108  char c;
109  while (*p)
110  {
111  c=*p++;
112  switch(c)
113  {
114  case '<': t << "&lt;";
115  break;
116  case '>': t << "&gt;";
117  break;
118  case '&': t << "&amp;";
119  break;
120  case '\'': t << "&#39;";
121  break;
122  case '"': t << "&quot;";
123  break;
124  default: t << c;
125  break;
126  }
127  }
128  }
129 }
130 
131 static void writeLink(const MemberDef* mdef,OutputList &ol)
132 {
133  ol.writeObjectLink(mdef->getReference(),
134  mdef->getOutputFileBase(),
135  mdef->anchor(),
136  mdef->name());
137 }
138 
139 static void startFonts(const QCString& q, const char *keyword,OutputList& ol)
140 {
141  ol.startFontClass(keyword);
142  ol.docify(q.data());
143  ol.endFontClass();
144 }
145 
146 static QCString splitString(QCString& str,char c)
147 {
148  QCString n=str;
149  int i=str.find(c);
150  if (i>0)
151  {
152  n=str.left(i);
153  str=str.remove(0,i+1);
154  }
155  return n;
156 }
157 
158 static int compareString(const QCString& s1,const QCString& s2)
159 {
160  return qstricmp(s1.stripWhiteSpace(),s2.stripWhiteSpace());
161 }
162 
163 static void createSVG()
164 {
165  QCString ov =Config_getString(HTML_OUTPUT);
166  QCString dir="-o \""+ov+"/vhdl_design_overview.html\"";
167  ov+="/vhdl_design.dot";
168 
169  QCString vlargs="-Tsvg \""+ov+"\" "+dir ;
170 
171  if (Portable::system(Config_getString(DOT_PATH) + "dot",vlargs)!=0)
172  {
173  err("could not create dot file");
174  }
175 }
176 
177 // Creates an svg image. All in/out/inout ports are shown with brief description and direction.
178 // Brief descriptions for entities are shown too.
180 {
182  ClassDef *cd;
183  bool found=FALSE;
184  for ( ; (cd=cli.current()) ; ++cli )
185  {
187  {
188  found=TRUE;
189  break;
190  }
191  }
192 
193  if (!found) return;
194 
195  QCString ov =Config_getString(HTML_OUTPUT);
196  QCString fileName=ov+"/vhdl_design.dot";
197  QFile f(fileName);
198  FTextStream t(&f);
199 
200  if (!f.open(IO_WriteOnly))
201  {
202  err("Warning: Cannot open file %s for writing\n",fileName.data());
203  return;
204  }
205 
206  startDot(t);
207 
208  for (cli.toFirst() ; (cd=cli.current()) ; ++cli )
209  {
211  {
212  continue;
213  }
214 
215  QList<MemberDef>* port= getPorts(cd);
216  if (port==0)
217  {
218  continue;
219  }
220  if (port->count()==0)
221  {
222  delete port;
223  port=NULL;
224  continue;
225  }
226 
227  startTable(t,cd->name());
228  writeClassToDot(t,cd);
229  writeTable(port,t);
230  endTable(t);
231 
232  // writeVhdlPortToolTip(t,port,cd);
234  delete port;
235 
236  BaseClassList *bl=cd->baseClasses();
237  if (bl)
238  {
239  BaseClassListIterator bcli(*bl);
240  BaseClassDef *bcd;
241  for ( ; (bcd=bcli.current()) ; ++bcli )
242  {
243  ClassDef *bClass=bcd->classDef;
244  QCString dotn=cd->name()+":";
245  dotn+=cd->name();
246  QCString csc=bClass->name()+":";
247  csc+=bClass->name();
248  // fprintf(stderr,"\n <%s| %s>",dotn.data(),csc.data());
249  writeVhdlDotLink(t,dotn,csc,0);
250  }
251  }// if bl
252  }// for
253 
254  endDot(t);
255  // writePortLinks(t);
256  f.close();
257  createSVG();
258 }
259 
260 //------------------------------------------------------------------------------------------------------------------------------------------------------
261 
262 static void startDot(FTextStream &t)
263 {
264  t << " digraph G { \n";
265  t << "rankdir=LR \n";
266  t << "concentrate=TRUE\n";
267  t << "stylesheet=\"doxygen.css\"\n";
268 }
269 
270 static void endDot(FTextStream &t)
271 {
272  t <<" } \n";
273 }
274 
275 static void startTable(FTextStream &t,const QCString &className)
276 {
277  t << className <<" [ shape=none , fontname=\"arial\", fontcolor=\"blue\" , \n";
278  t << "label=<<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\">\n";
279 }
280 
282  const QCString &a,const QCString &b,const QCString &style)
283 {
284  t << a << "->" << b;
285  if (!style.isEmpty())
286  {
287  t << "[style=" << style << "];\n";
288  }
289  t << "\n";
290 }
291 
292 
293 static QCString formatBriefNote(const QCString &brief,ClassDef * cd)
294 {
295  QRegExp ep("[\n]");
296  QCString vForm;
297  QCString repl("<BR ALIGN=\"LEFT\"/>");
298  QCString file=cd->getDefFileName();
299 
300  int k=cd->briefLine();
301 
302  QCStringList qsl=QCStringList::split(ep,brief);
303  for(uint j=0;j<qsl.count();j++)
304  {
305  QCString qcs=qsl[j];
306  vForm+=parseCommentAsText(cd,NULL,qcs,file,k);
307  k++;
308  vForm+='\n';
309  }
310 
311  vForm.replace(ep,repl.data());
312  return vForm;
313 }
314 
315 #if 0
316 static void writeVhdlPortToolTip(FTextStream& t,QList<MemberDef>* port,ClassDef *cd)
317 {
318 /*
319  uint len=port->count();
320  MemberDef *md;
321 
322  for (uint j=0;j<len;j++)
323  {
324  md=(MemberDef*)port->at(j);
325  QCString brief=md->briefDescriptionAsTooltip();
326  if (brief.isEmpty()) continue;
327 
328  QCString node="node";
329  node+=VhdlDocGen::getRecordNumber();
330  t << node <<"[shape=box margin=0.1, label=<\n";
331  t<<"<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\" CELLPADDING=\"2\" >\n ";
332  t<<"<TR><TD BGCOLOR=\"lightcyan\"> ";
333  t<<brief;
334  t<<" </TD></TR></TABLE>>];";
335  QCString dotn=cd->name()+":";
336  dotn+=md->name();
337  // writeVhdlDotLink(t,dotn,node,"dotted");
338  }
339 */
340 }
341 #endif
342 
344 {
345 
346  QCString brief=cd->briefDescription();
347 
348  if (brief.isEmpty()) return;
349 
350  brief=formatBriefNote(brief,cd);
351 
352  QCString node="node";
354  t << node <<"[shape=none margin=0.1, label=<\n";
355  t << "<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\" CELLPADDING=\"2\" >\n ";
356  t << "<TR><TD BGCOLOR=\"lightcyan\"> ";
357  t << brief;
358  t << " </TD></TR></TABLE>>];";
359  QCString dotn=cd->name()+":";
360  dotn+=cd->name();
361  writeVhdlDotLink(t,dotn,node,"dotted");
362 }
363 
364 static void writeColumn(FTextStream &t,MemberDef *md,bool start)
365 {
366  QCString toolTip;
367 
368  static QRegExp reg("[%]");
369  bool bidir=(md!=0 &&( qstricmp(md->typeString(),"inout")==0));
370 
371  if (md)
372  {
373  toolTip=md->briefDescriptionAsTooltip();
374  if (!toolTip.isEmpty())
375  {
376  QCString largs = md->argsString();
377  if (!largs.isEmpty())
378  largs=largs.replace(reg," ");
379  toolTip+=" [";
380  toolTip+=largs;
381  toolTip+="]";
382  }
383  }
384  if (start)
385  {
386  t <<"<TR>\n";
387  }
388 
389  t << "<TD ALIGN=\"LEFT\" ";
390  if (md)
391  {
392  t << "href=\"";
394  t << "#" << md->anchor();
395  t<<"\" ";
396 
397  t<<" TOOLTIP=\"";
398  if (!toolTip.isEmpty())
399  {
400  codify(t,toolTip.data());
401  }
402  else
403  {
404  QCString largs = md->argsString();
405  if (!largs.isEmpty())
406  {
407  largs=largs.replace(reg," ");
408  codify(t,largs.data());
409  }
410  }
411  t << "\" ";
412 
413  t << " PORT=\"";
414  t << md->name();
415  t << "\" ";
416  }
417  if (!toolTip.isEmpty())
418  {
419  // if (!toolTip.isEmpty())
420 
421  if (bidir)
422  t << "BGCOLOR=\"orange\">";
423  else
424  t << "BGCOLOR=\"azure\">";
425  }
426  else if (bidir)
427  {
428  t << "BGCOLOR=\"pink\">";
429  }
430  else
431  {
432  t << "BGCOLOR=\"lightgrey\">";
433  }
434  if (md)
435  {
436  t << md->name();
437  }
438  else
439  {
440  t << " \n";
441  }
442  t << "</TD>\n";
443 
444  if (!start)
445  {
446  t << "</TR>\n";
447  }
448 }
449 
450 static void endTable(FTextStream &t)
451 {
452  t << "</TABLE>>\n";
453  t << "] \n";
454 }
455 
457 {
458  t << "<TR><TD COLSPAN=\"2\" BGCOLOR=\"yellow\" ";
459  t << "PORT=\"";
460  t << cd->name();
461  t << "\" ";
462  t << "href=\"";
464  t << "\" ";
465  t << ">";
466  t << cd->name();
467  t << " </TD></TR>\n";
468 }
469 
471 {
472  MemberDef* md;
473  QList<MemberDef> *portList=new QList<MemberDef>;
475 
476  if (ml==0)
477  {
478  delete portList;
479  return 0;
480  }
481 
482  MemberListIterator fmni(*ml);
483 
484  for (fmni.toFirst();(md=fmni.current());++fmni)
485  {
487  {
488  portList->append(md);
489  }
490  }
491 
492  return portList;
493 }
494 
495 //writeColumn(FTextStream &t,QCString name,bool start)
496 
498 {
499  MemberDef *md;
500  uint len=port->count();
501 
502  QList<MemberDef> inPorts;
503  QList<MemberDef> outPorts;
504 
505  uint j;
506  for (j=0;j<len;j++)
507  {
508  md=(MemberDef*)port->at(j);
509  QCString qc=md->typeString();
510  if(qc=="in")
511  {
512  inPorts.append(md);
513  }
514  else
515  {
516  outPorts.append(md);
517  }
518  }
519 
520  int inp = inPorts.count();
521  int outp = outPorts.count();
522  int maxLen;
523 
524  if (inp>=outp)
525  {
526  maxLen=inp;
527  }
528  else
529  {
530  maxLen=outp;
531  }
532 
533  int i;
534  for(i=0;i<maxLen;i++)
535  {
536  //write inports
537  if (i<inp)
538  {
539  md=(MemberDef*)inPorts.at(i);
540  writeColumn(t,md,TRUE);
541  }
542  else
543  {
544  writeColumn(t,NULL,TRUE);
545  }
546 
547  if (i<outp)
548  {
549  md=(MemberDef*)outPorts.at(i);
550  writeColumn(t,md,FALSE);
551  }
552  else
553  {
554  writeColumn(t,NULL,FALSE);
555  }
556  }
557 }
558 
559 //--------------------------------------------------------------------------------------------------
560 
561 
563 {
564 }
565 
567 {
568 }
569 
571 {
572 
573  // vhdl keywords included VHDL 2008
574 const char* g_vhdlKeyWordMap0[] =
575 {
576  "abs","access","after","alias","all","and","architecture","array","assert","assume","assume_guarantee","attribute",
577  "begin","block","body","buffer","bus",
578  "case","component","configuration","constant","context","cover",
579  "default","disconnect","downto",
580  "else","elsif","end","entity","exit",
581  "fairness","file","for","force","function",
582  "generate","generic","group","guarded",
583  "if","impure","in","inertial","inout","is",
584  "label","library","linkage","literal","loop",
585  "map","mod",
586  "nand","new","next","nor","not","null",
587  "of","on","open","or","others","out",
588  "package","parameter","port","postponed","procedure","process","property","protected","pure",
589  "range","record","register","reject","release","restrict","restrict_guarantee","rem","report","rol","ror","return",
590  "select","sequence","severity","signal","shared","sla","sll","sra","srl","strong","subtype",
591  "then","to","transport","type",
592  "unaffected","units","until","use",
593  "variable","vmode","vprop","vunit",
594  "wait","when","while","with",
595  "xor","xnor",
596  0
597 };
598 
599 
600 // type
601 const char* g_vhdlKeyWordMap1[] =
602 {
603  "natural","unsigned","signed","string","boolean", "bit","bit_vector","character",
604  "std_ulogic","std_ulogic_vector","std_logic","std_logic_vector","integer",
605  "real","float","ufixed","sfixed","time","positive",0
606 };
607 
608 // logic
609 const char* g_vhdlKeyWordMap2[] =
610 {
611  "abs","and","or","not","mod", "xor","rem","xnor","ror","rol","sla",
612  "sll",0
613 };
614 
615 // predefined attributes
616 const char* g_vhdlKeyWordMap3[] =
617 {
618 "base","left","right","high","low","ascending",
619 "image","value","pos","val","succ","pred","leftof","rightof","left","right","high","low",
620 "range","reverse_range","length","ascending","delayed","stable","quiet","transaction","event",
621 "active","last_event","last_active","last_value","driving","driving_value","simple_name","instance_name","path_name",0
622 };
623 
624  int j=0;
625  g_vhdlKeyDict0.setAutoDelete(TRUE);
626  g_vhdlKeyDict1.setAutoDelete(TRUE);
627  g_vhdlKeyDict2.setAutoDelete(TRUE);
628  g_vhdlKeyDict3.setAutoDelete(TRUE);
629 
630  while (g_vhdlKeyWordMap0[j])
631  {
632  g_vhdlKeyDict0.insert(g_vhdlKeyWordMap0[j],
633  new QCString(g_vhdlKeyWordMap0[j]));
634  j++;
635  }
636 
637  j=0;
638  while (g_vhdlKeyWordMap1[j])
639  {
640  g_vhdlKeyDict1.insert(g_vhdlKeyWordMap1[j],
641  new QCString(g_vhdlKeyWordMap1[j]));
642  j++;
643  }
644 
645  j=0;
646  while (g_vhdlKeyWordMap2[j])
647  {
648  g_vhdlKeyDict2.insert(g_vhdlKeyWordMap2[j],
649  new QCString(g_vhdlKeyWordMap2[j]));
650  j++;
651  }
652 
653  j=0;
654  while (g_vhdlKeyWordMap3[j])
655  {
656  g_vhdlKeyDict3.insert(g_vhdlKeyWordMap3[j],
657  new QCString(g_vhdlKeyWordMap3[j]));
658  j++;
659  }
660 
661 }// buildKeyMap
662 
668 {
669  static QCString vhdlkeyword("vhdlkeyword");
670  static QCString vhdltype("keywordtype");
671  static QCString vhdllogic("vhdllogic");
672  static QCString preprocessor("keywordflow");
673 
674  QCString word=tmp.lower();
675 
676  if (word.isEmpty() || word.at(0)=='\0') return 0;
677 
678  if (g_vhdlKeyDict0.find(word))
679  return &preprocessor;
680 
681  if (g_vhdlKeyDict1.find(word))
682  return &vhdltype;
683 
684  if (g_vhdlKeyDict2.find(word))
685  return &vhdllogic;
686 
687  if (g_vhdlKeyDict3.find(word))
688  return &vhdlkeyword;
689 
690  return 0;
691 }
692 
693 ClassDef *VhdlDocGen::getClass(const char *name)
694 {
695  if (name==0 || name[0]=='\0') return 0;
696 
697  ClassDef *cd=0;
698  QCString temp(name);
699  //temp=temp.lower();
700  temp=temp.stripWhiteSpace();
701  cd= Doxygen::classSDict->find(temp.data());
702  return cd;
703 }
704 
706 {
707  ClassDef* cd=0;
708  cd=getClass(name);
709 
710  return cd;
711 }
712 
716 
717 MemberDef* VhdlDocGen::findMember(const QCString& className, const QCString& memName)
718 {
719  ClassDef* cd,*ecd=0;
720  MemberDef *mdef=0;
721 
722  cd=getClass(className);
723  //printf("VhdlDocGen::findMember(%s,%s)=%p\n",className.data(),memName.data(),cd);
724  if (cd==0) return 0;
725 
727  if (mdef) return mdef;
729  if (mdef) return mdef;
730 
731  // nothing found so far
732  // if we are an architecture or package body search in entity
733 
736  {
737  Definition *d = cd->getOuterScope();
738  // searching upper/lower case names
739 
740  QCString tt=d->name();
741  ecd =getClass(tt);
742  if (!ecd)
743  {
744  tt=tt.upper();
745  ecd =getClass(tt);
746  }
747  if (!ecd)
748  {
749  tt=tt.lower();
750  ecd =getClass(tt);
751  }
752 
753  if (ecd) //d && d->definitionType()==Definition::TypeClass)
754  {
755  //ClassDef *ecd = (ClassDef*)d;
757  if (mdef) return mdef;
759  if (mdef) return mdef;
760  }
761  }
762 
763 
766  {
767  Definition *d = cd->getOuterScope();
768 
769  QCString tt=d->name();
770  ClassDef *acd =getClass(tt);
771  if (!acd)
772  {
773  tt=tt.upper();
774  acd =getClass(tt);
775  }
776  if (!acd)
777  {
778  tt=tt.lower();
779  acd =getClass(tt);
780  }
781  if (acd) //d && d->definitionType()==Definition::TypeClass)
782  {
783  if(!packages.contains(acd))
784  {
786  }
787  }
788  }
789  else
790  {
791  ecd=cd;
792  if (!packages.contains(ecd)) VhdlDocGen::findAllPackages(ecd);
793  }
794 
795  if (ecd)
796  {
797  QMap<ClassDef*,QList<ClassDef> >::Iterator cList=packages.find(ecd);
798  if (cList!=packages.end())
799  {
800  QList<ClassDef> mlist=cList.data();
801  for (uint j=0;j<mlist.count();j++)
802  {
804  if (mdef) return mdef;
806  if (mdef) return mdef;
807  }
808  }
809  }
810  return 0;
811 
812 }//findMember
813 
819 {
820  MemberDef *md=0;
821  MemberList *ml=0;
822  QCString keyType=cd->symbolName()+"@"+key;
823  //printf("\n %s | %s | %s",cd->symbolName().data(),key.data(,),keyType.data());
824 
826  if (it.key())
827  {
828  md=it.data();
829  if (md)
830  {
831  return md;
832  }
833  }
834  if (qli.contains(cd))
835  {
836  return 0;
837  }
838  ml=cd->getMemberList(type);
839  qli.append(cd);
840  if (!ml)
841  {
842  return 0;
843  }
844  MemberListIterator fmni(*ml);
845  //int l=ml->count();
846  // fprintf(stderr,"\n loading entity %s %s: %d",cd->symbolName().data(),keyType.data(),l);
847 
848  for (fmni.toFirst();(md=fmni.current());++fmni)
849  {
850  QCString tkey=cd->symbolName()+"@"+md->name();
851  if (varMap.contains(tkey))
852  {
853  continue;
854  }
855  varMap.insert(tkey.data(),md);
856  }
857  it=varMap.find(keyType.data());
858  if (it.key())
859  {
860  md=it.data();
861  if (md)
862  {
863  return md;
864  }
865  }
866  return 0;
867 }//findMemberDef
868 
874 {
875  QList<ClassDef> cList;
876  if (packages.contains(cdef)) return;
878  MemberDef *md;
879 
880  if (!mem) return;
881 
882  MemberListIterator fmni(*mem);
883  for (fmni.toFirst();(md=fmni.current());++fmni)
884  {
885  if (VhdlDocGen::isPackage(md))
886  {
888  if (cd)
889  {
890  cList.append(cd);
892  packages.insert(cdef,cList);
893  }
894  }
895  }//for
896 
897 }// findAllPackages
898 
904 MemberDef* VhdlDocGen::findFunction(const QCString& funcname, const QCString& package)
905 {
906  MemberDef* mdef=0;
907  ClassDef *cdef=getClass(package.data());
908  if (cdef==0) return 0;
909 
911 
912  if (mem)
913  {
914  MemberListIterator fmni(*mem);
915  for (fmni.toFirst();(mdef=fmni.current());++fmni)
916  {
917  QCString mname=mdef->name();
918  if ((VhdlDocGen::isProcedure(mdef) || VhdlDocGen::isVhdlFunction(mdef)) && (compareString(funcname,mname)==0))
919  {
920  return mdef;
921  }//if
922  }//for
923  }//if
924  return 0;
925 } //findFunction
926 
927 
928 
929 
935 {
936  QCString pageTitle;
937  if (cd==0) return "";
938  pageTitle=VhdlDocGen::getClassName(cd);
939  int ii=cd->protection();
940  pageTitle+=" ";
941  pageTitle+=theTranslator_vhdlType(ii+2,TRUE);
942  return pageTitle;
943 } // getClassTitle
944 
945 /* returns the class name without their prefixes */
946 
948 {
949  QCString temp;
950  if (cd==0) return "";
951 
953  {
954  temp=cd->name();
955  temp.stripPrefix("_");
956  return temp;
957  }
958 
959  return substitute(cd->className(),"::",".");
960 }
961 
967 {
968  QList<QCString> ql;
969  ql.setAutoDelete(TRUE);
970  QCString nn=cd->className();
971  int ii=(int)cd->protection()+2;
972 
973  QCString type;
974  if (ii==VhdlDocGen::ENTITY)
976  else if (ii==VhdlDocGen::ARCHITECTURE)
978  else if (ii==VhdlDocGen::PACKAGE_BODY)
980  else if (ii==VhdlDocGen::PACKAGE)
982  else
983  type+="";
984 
985  //type=type.lower();
986  type+=" >> ";
989 
990  if (ii==VhdlDocGen::PACKAGE_BODY)
991  {
992  nn.stripPrefix("_");
993  cd=getClass(nn.data());
994  }
995  else if (ii==VhdlDocGen::PACKAGE)
996  {
997  nn.prepend("_");
998  cd=getClass(nn.data());
999  }
1000  else if (ii==VhdlDocGen::ARCHITECTURE)
1001  {
1002  QCStringList qlist=QCStringList::split("-",nn);
1003  nn=qlist[1];
1004  cd=VhdlDocGen::getClass(nn.data());
1005  }
1006 
1007  QCString opp;
1008  if (ii==VhdlDocGen::ENTITY)
1009  {
1011  int j=ql.count();
1012  for (int i=0;i<j;i++)
1013  {
1014  QCString *temp=ql.at(i);
1015  QCStringList qlist=QCStringList::split("-",*temp);
1016  QCString s1=qlist[0];
1017  QCString s2=qlist[1];
1018  s1.stripPrefix("_");
1019  if (j==1) s1.resize(0);
1020  ClassDef*cc = getClass(temp->data());
1021  if (cc)
1022  {
1023  VhdlDocGen::writeVhdlLink(cc,ol,type,s2,s1);
1024  }
1025  }
1026  }
1027  else
1028  {
1029  VhdlDocGen::writeVhdlLink(cd,ol,type,nn,opp);
1030  }
1031 
1034 
1035 }// write
1036 
1037 /*
1038  * finds all architectures which belongs to an entity
1039  */
1041 {
1042  ClassDef *citer;
1044  for ( ; (citer=cli.current()) ; ++cli )
1045  {
1046  QCString jj=citer->className();
1047  if (cd != citer && jj.contains('-')!=-1)
1048  {
1049  QCStringList ql=QCStringList::split("-",jj);
1050  QCString temp=ql[1];
1051  if (qstricmp(cd->className(),temp)==0)
1052  {
1053  QCString *cl=new QCString(jj);
1054  qll.insert(0,cl);
1055  }
1056  }
1057  }// for
1058 }//findAllArchitectures
1059 
1061 {
1062  ClassDef *citer;
1063  QCString nn=cd->name();
1065 
1066  for ( ; (citer=cli.current()) ; ++cli )
1067  {
1068  QCString jj=citer->name();
1069  QCStringList ql=QCStringList::split(":",jj);
1070  if (ql.count()>1)
1071  {
1072  if (ql[0]==nn )
1073  {
1074  return citer;
1075  }
1076  }
1077  }
1078  return 0;
1079 }
1080 /*
1081  * writes the link entity >> .... or architecture >> ...
1082  */
1083 
1085 {
1086  if (ccd==0) return;
1087  ol.startBold();
1088  ol.docify(type.data());
1089  ol.endBold();
1090  nn.stripPrefix("_");
1091  ol.writeObjectLink(ccd->getReference(),ccd->getOutputFileBase(),0,nn.data());
1092 
1093  if (!behav.isEmpty())
1094  {
1095  behav.prepend(" ");
1096  ol.startBold();
1097  ol.docify(behav.data());
1098  ol.endBold();
1099  }
1100 
1101  ol.lineBreak();
1102 }
1103 
1104 
1109 {
1110  const char* s="--!";
1111  int index=0;
1112 
1113  while (TRUE)
1114  {
1115  index=qcs.find(s,0,TRUE);
1116  if (index<0) break;
1117  qcs=qcs.remove(index,qstrlen(s));
1118  }
1119  qcs=qcs.stripWhiteSpace();
1120 }
1121 
1122 
1130 void VhdlDocGen::parseFuncProto(const char* text,QCString& name,QCString& ret,bool doc)
1131 {
1132  int index,end;
1133  QCString s1(text);
1134  QCString temp;
1135 
1136  index=s1.find("(");
1137  end=s1.findRev(")");
1138 
1139  if ((end-index)>0)
1140  {
1141  temp=s1.mid(index+1,(end-index-1));
1142  //getFuncParams(qlist,temp);
1143  }
1144  if (doc)
1145  {
1146  name=s1.left(index);
1147  name=name.stripWhiteSpace();
1148  if ((end-index)>0)
1149  {
1150  ret="function";
1151  }
1152  return;
1153  }
1154  else
1155  {
1156  s1=s1.stripWhiteSpace();
1157  int i=s1.find("(",0,FALSE);
1158  int s=s1.find(QRegExp("[ \\t]"));
1159  if (i==-1 || i<s)
1160  s1=VhdlDocGen::getIndexWord(s1.data(),1);
1161  else // s<i, s=start of name, i=end of name
1162  s1=s1.mid(s,(i-s));
1163 
1164  name=s1.stripWhiteSpace();
1165  }
1166  index=s1.findRev("return",-1,FALSE);
1167  if (index !=-1)
1168  {
1169  ret=s1.mid(index+6,s1.length());
1170  ret=ret.stripWhiteSpace();
1171  VhdlDocGen::deleteCharRev(ret,';');
1172  }
1173 }
1174 
1175 /*
1176  * returns the n'th word of a string
1177  */
1178 
1179 QCString VhdlDocGen::getIndexWord(const char* c,int index)
1180 {
1181  QCStringList ql;
1182  QCString temp(c);
1183  QRegExp reg("[\\s:|]");
1184 
1185  ql=QCStringList::split(reg,temp);
1186 
1187  if (ql.count() > (unsigned int)index)
1188  {
1189  return ql[index];
1190  }
1191 
1192  return "";
1193 }
1194 
1195 
1197 {
1198  if (prot==VhdlDocGen::ENTITYCLASS)
1199  return "entity";
1200  else if (prot==VhdlDocGen::ARCHITECTURECLASS)
1201  return "architecture";
1202  else if (prot==VhdlDocGen::PACKAGECLASS)
1203  return "package";
1204  else if (prot==VhdlDocGen::PACKBODYCLASS)
1205  return "package body";
1206 
1207  return "";
1208 }
1209 
1215 {
1216  int index=s.findRev(c,-1,FALSE);
1217  if (index > -1)
1218  {
1219  QCString qcs=s.remove(index,1);
1220  s=qcs;
1221  return TRUE;
1222  }
1223  return FALSE;
1224 }
1225 
1227 {
1228  int index=s.findRev(c,-1,FALSE);
1229  while (index > -1)
1230  {
1231  QCString qcs=s.remove(index,1);
1232  s=qcs;
1233  index=s.findRev(c,-1,FALSE);
1234  }
1235 }
1236 
1237 
1238 static int recordCounter=0;
1239 
1245 {
1246  char buf[12];
1247  sprintf(buf,"%d",recordCounter++);
1248  QCString qcs(&buf[0]);
1249  return qcs;
1250 }
1251 
1257 {
1258  static int stringCounter;
1259  char buf[8];
1260  QCString qcs("PROCESS_");
1261  sprintf(buf,"%d",stringCounter++);
1262  qcs.append(&buf[0]);
1263  return qcs;
1264 }
1265 
1271 {
1272  QRegExp reg("[\\[\\]\\.\\/\\:\\<\\>\\:\\s\\,\\;\\'\\+\\-\\*\\|\\&\\=\\(\\)\"]");
1273  QCString qcs = s;
1274  qcs+=QCString(" ");// parsing the last sign
1275  QCString *ss;
1276  QCString find=qcs;
1277  QCString temp=qcs;
1278  char buf[2];
1279  buf[1]='\0';
1280 
1281  int j;
1282  int len;
1283  j = reg.match(temp.data(),0,&len);
1284 
1285  ol.startBold();
1286  if (j>=0)
1287  {
1288  while (j>=0)
1289  {
1290  find=find.left(j);
1291  buf[0]=temp[j];
1292  ss=VhdlDocGen::findKeyWord(find);
1293  bool k=isNumber(find); // is this a number
1294  if (k)
1295  {
1296  ol.docify(" ");
1297  startFonts(find,"vhdldigit",ol);
1298  ol.docify(" ");
1299  }
1300  else if (j != 0 && ss)
1301  {
1302  startFonts(find,ss->data(),ol);
1303  }
1304  else
1305  {
1306  if (j>0)
1307  {
1308  VhdlDocGen::writeStringLink(mdef,find,ol);
1309  }
1310  }
1311  startFonts(&buf[0],"vhdlchar",ol);
1312 
1313  QCString st=temp.remove(0,j+1);
1314  find=st;
1315  if (!find.isEmpty() && find.at(0)=='"')
1316  {
1317  int ii=find.find('"',2);
1318  if (ii>1)
1319  {
1320  QCString com=find.left(ii+1);
1321  startFonts(com,"keyword",ol);
1322  temp=find.remove(0,ii+1);
1323  }
1324  }
1325  else
1326  {
1327  temp=st;
1328  }
1329  j = reg.match(temp.data(),0,&len);
1330  }//while
1331  }//if
1332  else
1333  {
1334  startFonts(find,"vhdlchar",ol);
1335  }
1336  ol.endBold();
1337 }// writeFormatString
1338 
1343 {
1344  static QRegExp regg("[0-9][0-9eEfFbBcCdDaA_.#-+?xXzZ]*");
1345 
1346  if (s.isEmpty()) return FALSE;
1347  int j,len;
1348  j = regg.match(s.data(),0,&len);
1349  if ((j==0) && (len==(int)s.length())) return TRUE;
1350  return FALSE;
1351 
1352 }// isNumber
1353 
1354 
1361 {
1362  QCString qcs = s;
1363  QCString temp;
1364  qcs.stripPrefix(":");
1365  qcs.stripPrefix("is");
1366  qcs.stripPrefix("IS");
1367  qcs.stripPrefix("of");
1368  qcs.stripPrefix("OF");
1369 
1370  // VhdlDocGen::deleteCharRev(qcs,';');
1371  //char white='\t';
1372  int len = qcs.length();
1373  unsigned int index=1;//temp.length();
1374 
1375  for (int j=0;j<len;j++)
1376  {
1377  char c=qcs[j];
1378  char b=c;
1379  if (j>0) b=qcs[j-1];
1380  if (c=='"' || c==',' || c=='\''|| c=='(' || c==')' || c==':' || c=='[' || c==']' ) // || (c==':' && b!='=')) // || (c=='=' && b!='>'))
1381  {
1382  if (temp.length()>=index && temp.at(index-1) != ' ')
1383  {
1384  temp+=" ";
1385  }
1386  temp+=c;
1387  temp+=" ";
1388  }
1389  else if (c=='=')
1390  {
1391  if (b==':') // := operator
1392  {
1393  temp.replace(index-1,1,"=");
1394  temp+=" ";
1395  }
1396  else // = operator
1397  {
1398  temp+=" ";
1399  temp+=c;
1400  temp+=" ";
1401  }
1402  }
1403  else
1404  {
1405  temp+=c;
1406  }
1407 
1408  index=temp.length();
1409  }// for
1410  temp=temp.stripWhiteSpace();
1411  // printf("\n [%s]",qcs.data());
1412  VhdlDocGen::writeFormatString(temp,ol,mdef);
1413 }
1414 
1420 {
1421  bool sem=FALSE;
1422  size_t len=al.size();
1423  ol.docify("( ");
1424  if (len > 2)
1425  {
1426  ol.lineBreak();
1427  }
1428  for (const Argument &arg : al)
1429  {
1430  ol.startBold();
1431  if (sem && len <3)
1432  ol.writeChar(',');
1433 
1434  QCString nn=arg.name;
1435  nn+=": ";
1436 
1437  QCString defval = arg.defval;
1438  QCString *str=VhdlDocGen::findKeyWord(defval);
1439  defval+=" ";
1440  if (str)
1441  {
1442  startFonts(defval,str->data(),ol);
1443  }
1444  else
1445  {
1446  startFonts(defval,"vhdlchar",ol); // write type (variable,constant etc.)
1447  }
1448 
1449  startFonts(nn,"vhdlchar",ol); // write name
1450  if (qstricmp(arg.attrib,arg.type) != 0)
1451  {
1452  startFonts(arg.attrib.lower(),"stringliteral",ol); // write in|out
1453  }
1454  ol.docify(" ");
1455  VhdlDocGen::formatString(arg.type,ol,mdef);
1456  sem=TRUE;
1457  ol.endBold();
1458  if (len > 2)
1459  {
1460  ol.lineBreak();
1461  ol.docify(" ");
1462  }
1463  }//for
1464 
1465  ol.docify(" )");
1466 
1467 
1468 }
1469 
1475 {
1476  if (!al.hasParameters()) return;
1477  bool sem=FALSE;
1478  size_t len=al.size();
1479  ol.startBold();
1480  ol.docify(" ( ");
1481  ol.endBold();
1482  if (len>2)
1483  {
1484  ol.lineBreak();
1485  }
1486  for (const Argument &arg : al)
1487  {
1488  ol.startBold();
1489  QCString att=arg.defval;
1490  bool bGen=att.stripPrefix("gen!");
1491 
1492  if (sem && len < 3)
1493  {
1494  ol.docify(" , ");
1495  }
1496 
1497  if (bGen)
1498  {
1499  VhdlDocGen::formatString(QCString("generic "),ol,mdef);
1500  }
1501  if (!att.isEmpty())
1502  {
1504  att+=" ";
1505  if (str)
1506  VhdlDocGen::formatString(att,ol,mdef);
1507  else
1508  startFonts(att,"vhdlchar",ol);
1509  }
1510 
1511  QCString nn=arg.name;
1512  nn+=": ";
1513  QCString ss=arg.type.stripWhiteSpace(); //.lower();
1514  QCString w=ss.stripWhiteSpace();//.upper();
1515  startFonts(nn,"vhdlchar",ol);
1516  startFonts("in ","stringliteral",ol);
1518  if (str)
1519  VhdlDocGen::formatString(w,ol,mdef);
1520  else
1521  startFonts(w,"vhdlchar",ol);
1522 
1523  if (arg.attrib)
1524  startFonts(arg.attrib,"vhdlchar",ol);
1525 
1526  sem=TRUE;
1527  ol.endBold();
1528  if (len > 2)
1529  {
1530  ol.lineBreak();
1531  }
1532  }
1533  ol.startBold();
1534  ol.docify(" )");
1535  const char *exp=mdef->excpString();
1536  if (exp)
1537  {
1538  ol.insertMemberAlign();
1539  ol.startBold();
1540  ol.docify("[ ");
1541  ol.docify(exp);
1542  ol.docify(" ]");
1543  ol.endBold();
1544  }
1545  ol.endBold();
1546 }
1547 
1553 {
1554  if (!al.hasParameters()) return;
1555  bool sem=FALSE;
1556  ol.startBold();
1557  ol.docify(" ( ");
1558  for (const Argument &arg : al)
1559  {
1560  if (sem)
1561  {
1562  ol.docify(" , ");
1563  }
1564  QCString nn=arg.name;
1565  // startFonts(nn,"vhdlchar",ol);
1566  VhdlDocGen::writeFormatString(nn,ol,mdef);
1567  sem=TRUE;
1568  }
1569  ol.docify(" )");
1570  ol.endBold();
1571 }
1572 
1573 
1579  const MemberDef *md,
1580  OutputList& ol,
1581  const ArgumentList &al,
1582  bool /*type*/)
1583 {
1584  //bool sem=FALSE;
1585  ol.enableAll();
1586 
1587  size_t index=al.size();
1588  if (index==0)
1589  {
1590  ol.docify(" ( ) ");
1591  return FALSE;
1592  }
1593  ol.endMemberDocName();
1595  //ol.startParameterName(FALSE);
1596  bool first=TRUE;
1597  for (const Argument &arg : al)
1598  {
1599  ol.startParameterType(first,"");
1600  // if (first) ol.writeChar('(');
1601  QCString attl=arg.defval;
1602  bool bGen=attl.stripPrefix("gen!");
1603  if (bGen)
1604  VhdlDocGen::writeFormatString(QCString("generic "),ol,md);
1605 
1606 
1607  if (VhdlDocGen::isProcedure(md))
1608  {
1609  startFonts(arg.defval,"keywordtype",ol);
1610  ol.docify(" ");
1611  }
1612  ol.endParameterType();
1613 
1615  VhdlDocGen::writeFormatString(arg.name,ol,md);
1616 
1617  if (VhdlDocGen::isProcedure(md))
1618  {
1619  startFonts(arg.attrib,"stringliteral",ol);
1620  }
1621  else if (VhdlDocGen::isVhdlFunction(md))
1622  {
1623  startFonts(QCString("in"),"stringliteral",ol);
1624  }
1625 
1626  ol.docify(" ");
1628  ol.startEmphasis();
1630  if (!VhdlDocGen::isProcess(md))
1631  {
1632  // startFonts(arg.type,"vhdlkeyword",ol);
1633  VhdlDocGen::writeFormatString(arg.type,ol,md);
1634  }
1636  ol.endEmphasis();
1638 
1639  if (--index)
1640  {
1641  ol.docify(" , ");
1642  }
1643  else
1644  {
1645  // ol.docify(" ) ");
1647  break;
1648  }
1650 
1651  //sem=TRUE;
1652  first=FALSE;
1653  }
1654  //ol.endParameterList();
1655  return TRUE;
1656 
1657 } // writeDocFunProc
1658 
1659 
1660 
1661 
1663 {
1664  QCString argString;
1665  bool sem=FALSE;
1666 
1667  for (const Argument &arg : al)
1668  {
1669  if (sem) argString.append(", ");
1670  if (func)
1671  {
1672  argString+=arg.name;
1673  argString+=":";
1674  argString+=arg.type;
1675  }
1676  else
1677  {
1678  argString+=arg.defval+" ";
1679  argString+=arg.name+" :";
1680  argString+=arg.attrib+" ";
1681  argString+=arg.type;
1682  }
1683  sem=TRUE;
1684  }
1685  return argString;
1686 }
1687 
1688 
1690  OutputList& ol,const GroupDef* gd,const ClassDef* cd,const FileDef *fd,const NamespaceDef* nd)
1691 {
1713 
1714  // configurations must be added to global file definitions.
1717 
1718 }
1719 
1721 {
1722  if (qstrcmp(md->argsString(),"package")==0)
1723  {
1725  }
1726  else if (qstrcmp(md->argsString(),"configuration")==0)
1727  {
1729  }
1730  else if (qstrcmp(md->typeString(),"library")==0)
1731  {
1733  }
1734  else if (qstrcmp(md->typeString(),"use")==0)
1735  {
1737  }
1738  else if (qstricmp(md->typeString(),"misc")==0)
1739  {
1741  }
1742  else if (qstricmp(md->typeString(),"ucf_const")==0)
1743  {
1745  }
1746 
1748  {
1749  int mm=md->name().findRev('_');
1750  if (mm>0)
1751  {
1752  md->setName(md->name().left(mm));
1753  }
1754  }
1755  else if (md->getMemberSpecifiers()==VhdlDocGen::TYPE)
1756  {
1757  QCString largs=md->argsString();
1758  bool bRec=largs.stripPrefix("record") ;
1759  bool bUnit=largs.stripPrefix("units") ;
1760  if (bRec || bUnit)
1761  {
1762  md->setType("");
1763  }
1764  }
1765 }
1766 
1767 /* writes a vhdl type documentation */
1769 {
1770  const ClassDef *cd=dynamic_cast<const ClassDef*>(d);
1771  bool hasParams = FALSE;
1772 
1773  if (cd==0) return hasParams;
1774 
1775  QCString ttype=mdef->typeString();
1776  QCString largs=mdef->argsString();
1777 
1779  {
1780  QCString nn=mdef->typeString();
1781  nn=nn.stripWhiteSpace();
1782  QCString na=cd->name();
1783  MemberDef* memdef=VhdlDocGen::findMember(na,nn);
1784  if (memdef && memdef->isLinkable())
1785  {
1786  ol.docify(" ");
1787 
1788  ol.startBold();
1789  writeLink(memdef,ol);
1790  ol.endBold();
1791  ol.docify(" ");
1792  }
1793  else
1794  {
1795  ol.docify(" ");
1796  VhdlDocGen::formatString(ttype,ol,mdef);
1797  ol.docify(" ");
1798  }
1799  ol.docify(mdef->name());
1800  hasParams = VhdlDocGen::writeFuncProcDocu(mdef,ol, mdef->argumentList());
1801  }
1802 
1803 
1804  if (mdef->isVariable())
1805  {
1806  if (VhdlDocGen::isConstraint(mdef))
1807  {
1808  writeLink(mdef,ol);
1809  ol.docify(" ");
1810 
1811  largs=largs.replace(QRegExp("#")," ");
1812  VhdlDocGen::formatString(largs,ol,mdef);
1813  return hasParams;
1814  }
1815  else
1816  {
1817  writeLink(mdef,ol);
1818  if (VhdlDocGen::isLibrary(mdef) || VhdlDocGen::isPackage(mdef))
1819  {
1820  return hasParams;
1821  }
1822  ol.docify(" ");
1823  }
1824 
1825  // QCString largs=mdef->argsString();
1826 
1827  bool c=largs=="context";
1828  bool brec=largs.stripPrefix("record") ;
1829 
1830  if (!brec && !c)
1831  VhdlDocGen::formatString(ttype,ol,mdef);
1832 
1833  if (c || brec || largs.stripPrefix("units"))
1834  {
1835  if (c)
1836  largs=ttype;
1837  VhdlDocGen::writeRecUnitDocu(mdef,ol,largs);
1838  return hasParams;
1839  }
1840 
1841  ol.docify(" ");
1842  if (VhdlDocGen::isPort(mdef) || VhdlDocGen::isGeneric(mdef))
1843  {
1844  // QCString largs=mdef->argsString();
1845  VhdlDocGen::formatString(largs,ol,mdef);
1846  ol.docify(" ");
1847  }
1848  }
1849  return hasParams;
1850 }
1851 
1853 {
1854  tagFile << " <member kind=\"";
1855  if (VhdlDocGen::isGeneric(mdef)) tagFile << "generic";
1856  if (VhdlDocGen::isPort(mdef)) tagFile << "port";
1857  if (VhdlDocGen::isEntity(mdef)) tagFile << "entity";
1858  if (VhdlDocGen::isComponent(mdef)) tagFile << "component";
1859  if (VhdlDocGen::isVType(mdef)) tagFile << "type";
1860  if (VhdlDocGen::isConstant(mdef)) tagFile << "constant";
1861  if (VhdlDocGen::isSubType(mdef)) tagFile << "subtype";
1862  if (VhdlDocGen::isVhdlFunction(mdef)) tagFile << "function";
1863  if (VhdlDocGen::isProcedure(mdef)) tagFile << "procedure";
1864  if (VhdlDocGen::isProcess(mdef)) tagFile << "process";
1865  if (VhdlDocGen::isSignals(mdef)) tagFile << "signal";
1866  if (VhdlDocGen::isAttribute(mdef)) tagFile << "attribute";
1867  if (VhdlDocGen::isRecord(mdef)) tagFile << "record";
1868  if (VhdlDocGen::isLibrary(mdef)) tagFile << "library";
1869  if (VhdlDocGen::isPackage(mdef)) tagFile << "package";
1870  if (VhdlDocGen::isVariable(mdef)) tagFile << "shared variable";
1871  if (VhdlDocGen::isFile(mdef)) tagFile << "file";
1872  if (VhdlDocGen::isGroup(mdef)) tagFile << "group";
1873  if (VhdlDocGen::isCompInst(mdef)) tagFile << "instantiation";
1874  if (VhdlDocGen::isAlias(mdef)) tagFile << "alias";
1875  if (VhdlDocGen::isCompInst(mdef)) tagFile << "configuration";
1876 
1877  tagFile << "\">" << endl;
1878  tagFile << " <type>" << convertToXML(mdef->typeString()) << "</type>" << endl;
1879  tagFile << " <name>" << convertToXML(mdef->name()) << "</name>" << endl;
1880  tagFile << " <anchorfile>" << convertToXML(mdef->getOutputFileBase()) << Doxygen::htmlFileExtension << "</anchorfile>" << endl;
1881  tagFile << " <anchor>" << convertToXML(mdef->anchor()) << "</anchor>" << endl;
1882 
1883  if (VhdlDocGen::isVhdlFunction(mdef))
1884  tagFile << " <arglist>" << convertToXML(VhdlDocGen::convertArgumentListToString(mdef->argumentList(),TRUE)) << "</arglist>" << endl;
1885  else if (VhdlDocGen::isProcedure(mdef))
1886  tagFile << " <arglist>" << convertToXML(VhdlDocGen::convertArgumentListToString(mdef->argumentList(),FALSE)) << "</arglist>" << endl;
1887  else
1888  tagFile << " <arglist>" << convertToXML(mdef->argsString()) << "</arglist>" << endl;
1889 
1890  mdef->writeDocAnchorsToTagFile(tagFile);
1891  tagFile << " </member>" << endl;
1892 }
1893 
1894 /* writes a vhdl type declaration */
1895 
1897  const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,
1898  bool /*inGroup*/)
1899 {
1900  const Definition *d=0;
1901 
1902  ASSERT(cd!=0 || nd!=0 || fd!=0 || gd!=0 ||
1905  ); // member should belong to something
1906  if (cd) d=cd;
1907  else if (nd) d=nd;
1908  else if (fd) d=fd;
1909  else if (gd) d=gd;
1910  else d=(Definition*)mdef;
1911 
1912  // write search index info
1914  {
1918  }
1919 
1920  QCString cname = d->name();
1921  QCString cfname = d->getOutputFileBase();
1922 
1923  //HtmlHelp *htmlHelp=0;
1924  // bool hasHtmlHelp = Config_getBool(GENERATE_HTML) && Config_getBool(GENERATE_HTMLHELP);
1925  // if (hasHtmlHelp) htmlHelp = HtmlHelp::getInstance();
1926 
1927  // search for the last anonymous scope in the member type
1928  ClassDef *annoClassDef=mdef->getClassDefOfAnonymousType();
1929 
1930  // start a new member declaration
1931  uint isAnonymous = (bool)(annoClassDef); // || m_impl->annMemb || m_impl->annEnumType;
1933  int mm=mdef->getMemberSpecifiers();
1934  if (mm==VhdlDocGen::MISCELLANEOUS)
1935  isAnonymous=3;
1936 
1937  ol.startMemberItem( mdef->anchor(), isAnonymous ); //? 1 : m_impl->tArgList ? 3 : 0);
1938 
1939  // If there is no detailed description we need to write the anchor here.
1940  bool detailsVisible = mdef->isDetailedSectionLinkable();
1941  if (!detailsVisible) // && !m_impl->annMemb)
1942  {
1943  QCString doxyName=mdef->name().copy();
1944  if (!cname.isEmpty()) doxyName.prepend(cname+"::");
1945  QCString doxyArgs=mdef->argsString();
1946  ol.startDoxyAnchor(cfname,cname,mdef->anchor(),doxyName,doxyArgs);
1947 
1948  ol.pushGeneratorState();
1951  ol.docify("\n");
1952  ol.popGeneratorState();
1953 
1954  }
1955  // *** write type
1956  /*VHDL CHANGE */
1957 
1958  QCString ltype(mdef->typeString());
1959  QCString largs(mdef->argsString());
1960 
1961  ClassDef *kl=0;
1962  const ArgumentList &al = mdef->argumentList();
1963  QCString nn;
1964  //VhdlDocGen::adjustRecordMember(mdef);
1965  if (gd) gd=0;
1966  switch (mm)
1967  {
1969  VhdlDocGen::writeSource(mdef,ol,nn);
1970  break;
1971  case VhdlDocGen::PROCEDURE:
1972  case VhdlDocGen::FUNCTION:
1973  ol.startBold();
1974  VhdlDocGen::formatString(ltype,ol,mdef);
1975  ol.endBold();
1976  ol.insertMemberAlign();
1977  ol.docify(" ");
1978 
1979  writeLink(mdef,ol);
1980  if (al.hasParameters() && mm==VhdlDocGen::FUNCTION)
1981  VhdlDocGen::writeFunctionProto(ol,al,mdef);
1982 
1983  if (al.hasParameters() && mm==VhdlDocGen::PROCEDURE)
1984  VhdlDocGen::writeProcedureProto(ol,al,mdef);
1985 
1986  break;
1987  case VhdlDocGen::USE:
1988  kl=VhdlDocGen::getClass(mdef->name());
1989  if (kl && ((VhdlDocGen::VhdlClasses)kl->protection()==VhdlDocGen::ENTITYCLASS)) break;
1990  writeLink(mdef,ol);
1991  ol.insertMemberAlign();
1992  ol.docify(" ");
1993 
1994  if (kl)
1995  {
1996  nn=kl->getOutputFileBase();
1997  ol.pushGeneratorState();
1999  ol.docify(" ");
2001  ol.startBold();
2002  ol.docify(name.data());
2003  name.resize(0);
2004  ol.endBold();
2005  name+=" <"+mdef->name()+">";
2006  ol.startEmphasis();
2007  ol.writeObjectLink(kl->getReference(),kl->getOutputFileBase(),0,name.data());
2008  ol.popGeneratorState();
2009  }
2010  break;
2011  case VhdlDocGen::LIBRARY:
2012  writeLink(mdef,ol);
2013  ol.insertMemberAlign();
2014  if (largs=="context")
2015  {
2016  VhdlDocGen::writeRecordUnit(ltype,largs,ol,mdef);
2017  }
2018 
2019  break;
2020 
2021  case VhdlDocGen::GENERIC:
2022  case VhdlDocGen::PORT:
2023  case VhdlDocGen::ALIAS:
2024 
2025  writeLink(mdef,ol);
2026  ol.docify(" ");
2027  if (mm==VhdlDocGen::GENERIC)
2028  {
2029  ol.insertMemberAlign();
2030  ol.startBold();
2031  VhdlDocGen::formatString(largs,ol,mdef);
2032  ol.endBold();
2033  }
2034  else
2035  {
2036  ol.insertMemberAlignLeft(isAnonymous, false);
2037  ol.docify(" ");
2038  ol.startBold();
2039  VhdlDocGen::formatString(ltype,ol,mdef);
2040  ol.endBold();
2041  ol.insertMemberAlign();
2042  ol.docify(" ");
2043  VhdlDocGen::formatString(largs,ol,mdef);
2044  }
2045  break;
2046  case VhdlDocGen::PROCESS:
2047  writeLink(mdef,ol);
2048  ol.insertMemberAlign();
2049  VhdlDocGen::writeProcessProto(ol,al,mdef);
2050  break;
2051  case VhdlDocGen::PACKAGE:
2052  case VhdlDocGen::ENTITY:
2053  case VhdlDocGen::COMPONENT:
2055  case VhdlDocGen::CONFIG:
2056  if (VhdlDocGen::isCompInst(mdef) )
2057  {
2058  nn=largs;
2059  if(nn.stripPrefix("function") || nn.stripPrefix("package"))
2060  {
2061  VhdlDocGen::formatString(largs,ol,mdef);
2062  ol.insertMemberAlign();
2063  writeLink(mdef,ol);
2064  ol.docify(" ");
2065  VhdlDocGen::formatString(ltype,ol,mdef);
2066  break;
2067  }
2068 
2069  largs.prepend("::");
2070  largs.prepend(mdef->name().data());
2071  ol.writeObjectLink(mdef->getReference(),
2072  cfname,
2073  mdef->anchor(),
2074  mdef->name());
2075  }
2076  else
2077  writeLink(mdef,ol);
2078 
2079  ol.insertMemberAlign();
2080  ol.docify(" ");
2081  ol.startBold();
2082  ol.docify(ltype);
2083  ol.endBold();
2084  ol.docify(" ");
2085  if (VhdlDocGen::isComponent(mdef) ||
2086  VhdlDocGen::isConfig(mdef) ||
2087  VhdlDocGen::isCompInst(mdef))
2088  {
2089  if (VhdlDocGen::isConfig(mdef) || VhdlDocGen::isCompInst(mdef))
2090  {
2091  nn=ltype;
2092  }
2093  else
2094  {
2095  nn=mdef->name();
2096  }
2097  kl=getClass(nn.data());
2098  if (kl)
2099  {
2100  nn=kl->getOutputFileBase();
2101  ol.pushGeneratorState();
2103  ol.startEmphasis();
2104  QCString name("<Entity ");
2105  if (VhdlDocGen::isConfig(mdef) || VhdlDocGen::isCompInst(mdef))
2106  {
2107  name+=ltype+">";
2108  }
2109  else
2110  {
2111  name+=mdef->name()+"> ";
2112  }
2113  ol.writeObjectLink(kl->getReference(),kl->getOutputFileBase(),0,name.data());
2114  ol.endEmphasis();
2115  ol.popGeneratorState();
2116  }
2117  }
2118  break;
2119  case VhdlDocGen::UCF_CONST:
2120  writeUCFLink(mdef,ol);
2121  break;
2122  case VhdlDocGen::SIGNAL:
2123  case VhdlDocGen::ATTRIBUTE:
2124  case VhdlDocGen::SUBTYPE:
2125  case VhdlDocGen::CONSTANT:
2127  case VhdlDocGen::VFILE:
2128  case VhdlDocGen::GROUP:
2129  case VhdlDocGen::TYPE:
2130  writeLink(mdef,ol);
2131  ol.docify(" ");
2132  ol.insertMemberAlign();
2133  VhdlDocGen::formatString(ltype,ol,mdef);
2134  break;
2135  case VhdlDocGen::RECORD:
2136  case VhdlDocGen::UNITS:
2137  writeRecordUnit(largs,ltype,ol,mdef);
2138  break;
2139 
2140  default: break;
2141  }
2142 
2143  bool htmlOn = ol.isEnabled(OutputGenerator::Html);
2144  if (htmlOn && /*Config_getBool(HTML_ALIGN_MEMBERS) &&*/ !ltype.isEmpty())
2145  {
2147  }
2148  if (!ltype.isEmpty()) ol.docify(" ");
2149 
2150  if (htmlOn)
2151  {
2153  }
2154 
2155  if (!detailsVisible)// && !m_impl->annMemb)
2156  {
2157  ol.endDoxyAnchor(cfname,mdef->anchor());
2158  }
2159 
2160  // name().data(),annoClassDef,annEnumType);
2161  // if(mm!=VhdlDocGen::MISCELLANEOUS)
2162  ol.endMemberItem();
2163  if (!mdef->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC) /* && !annMemb */)
2164  {
2165  QCString s=mdef->briefDescription();
2166  ol.startMemberDescription(mdef->anchor(), NULL, mm == VhdlDocGen::PORT);
2167  ol.generateDoc(mdef->briefFile(),mdef->briefLine(),
2168  mdef->getOuterScope()?mdef->getOuterScope():d,
2169  mdef,s.data(),TRUE,FALSE,0,TRUE,FALSE);
2170  if (detailsVisible)
2171  {
2172  ol.pushGeneratorState();
2174  //ol.endEmphasis();
2175  ol.docify(" ");
2176  if (mdef->getGroupDef()!=0 && gd==0) // forward link to the group
2177  {
2178  ol.startTextLink(mdef->getOutputFileBase(),mdef->anchor());
2179  }
2180  else // local link
2181  {
2182  ol.startTextLink(0,mdef->anchor());
2183  }
2184  ol.endTextLink();
2185  //ol.startEmphasis();
2186  ol.popGeneratorState();
2187  }
2188  //ol.newParagraph();
2189  ol.endMemberDescription();
2190  }
2191  mdef->warnIfUndocumented();
2192 
2193 }// end writeVhdlDeclaration
2194 
2195 
2197  const MemberList* mlist,OutputList &ol,
2198  const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,int specifier)
2199 {
2200 
2201  SDict<QCString> pack(1009);
2202  pack.setAutoDelete(TRUE);
2203 
2204  bool first=TRUE;
2205  MemberDef *md;
2206  MemberListIterator mli(*mlist);
2207  for ( ; (md=mli.current()); ++mli )
2208  {
2209  int mems=md->getMemberSpecifiers();
2210  if (md->isBriefSectionVisible() && (mems==specifier) && (mems!=VhdlDocGen::LIBRARY) )
2211  {
2212  if (first) { ol.startMemberList();first=FALSE; }
2213  VhdlDocGen::writeVHDLDeclaration(md,ol,cd,nd,fd,gd,FALSE);
2214  } //if
2215  else if (md->isBriefSectionVisible() && (mems==specifier))
2216  {
2217  if (!pack.find(md->name().data()))
2218  {
2219  if (first) ol.startMemberList(),first=FALSE;
2220  VhdlDocGen::writeVHDLDeclaration(md,ol,cd,nd,fd,gd,FALSE);
2221  pack.append(md->name().data(),new QCString(md->name().data()));
2222  }
2223  } //if
2224  } //for
2225  if (!first) ol.endMemberList();
2226  pack.clear();
2227 }//plainDeclaration
2228 
2229 static bool membersHaveSpecificType(const MemberList *ml,uint64 type)
2230 {
2231  if (ml==0) return FALSE;
2232  MemberDef *mdd=0;
2233  MemberListIterator mmli(*ml);
2234  for ( ; (mdd=mmli.current()); ++mmli )
2235  {
2236  if (mdd->getMemberSpecifiers()==type) //is type in class
2237  {
2238  return TRUE;
2239  }
2240  }
2241  if (ml->getMemberGroupList())
2242  {
2244  MemberGroup *mg;
2245  while ((mg=mgli.current()))
2246  {
2247  if (mg->members())
2248  {
2249  if (membersHaveSpecificType(mg->members(),type)) return TRUE;
2250  }
2251  ++mgli;
2252  }
2253  }
2254  return FALSE;
2255 }
2256 
2258  const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,
2259  const char *title,const char *subtitle,bool /*showEnumValues*/,int type)
2260 {
2261  if (!membersHaveSpecificType(ml,type)) return;
2262 
2263  if (title)
2264  {
2265  ol.startMemberHeader(convertToId(title),type == VhdlDocGen::PORT ? 3 : 2);
2266  ol.parseText(title);
2267  ol.endMemberHeader();
2268  ol.docify(" ");
2269  }
2270  if (subtitle && subtitle[0]!=0)
2271  {
2272  ol.startMemberSubtitle();
2273  ol.generateDoc("[generated]",-1,0,0,subtitle,FALSE,FALSE,0,TRUE,FALSE);
2274  ol.endMemberSubtitle();
2275  } //printf("memberGroupList=%p\n",memberGroupList);
2276 
2277  VhdlDocGen::writePlainVHDLDeclarations(ml,ol,cd,nd,fd,gd,type);
2278 
2279  if (ml->getMemberGroupList())
2280  {
2282  MemberGroup *mg;
2283  while ((mg=mgli.current()))
2284  {
2285  if (membersHaveSpecificType(mg->members(),type))
2286  {
2287  //printf("mg->header=%s\n",mg->header().data());
2288  bool hasHeader=mg->header()!="[NOHEADER]";
2289  ol.startMemberGroupHeader(hasHeader);
2290  if (hasHeader)
2291  {
2292  ol.parseText(mg->header());
2293  }
2294  ol.endMemberGroupHeader();
2295  if (!mg->documentation().isEmpty())
2296  {
2297  //printf("Member group has docs!\n");
2298  ol.startMemberGroupDocs();
2299  ol.generateDoc("[generated]",-1,0,0,mg->documentation()+"\n",FALSE,FALSE);
2300  ol.endMemberGroupDocs();
2301  }
2302  ol.startMemberGroup();
2303  //printf("--- mg->writePlainDeclarations ---\n");
2304  VhdlDocGen::writePlainVHDLDeclarations(mg->members(),ol,cd,nd,fd,gd,type);
2305  ol.endMemberGroup(hasHeader);
2306  }
2307  ++mgli;
2308  }
2309  }
2310 }// writeVHDLDeclarations
2311 
2312 
2314  OutputList &ol ,QCString & cname)
2315 {
2316  int id=cd->protection();
2317  QCString qcs = theTranslator->trVhdlType(id+2,TRUE);
2318  cname=VhdlDocGen::getClassName(cd);
2319  ol.startBold();
2320  ol.writeString(qcs.data());
2321  ol.writeString(" ");
2322  ol.endBold();
2323  //ol.insertMemberAlign();
2324  return FALSE;
2325 }// writeClassLink
2326 
2327 
2331 {
2332  if (mdef)
2333  {
2334  const ClassDef *cd=mdef->getClassDef();
2335  if (cd)
2336  {
2337  QCString n=cd->name();
2338  MemberDef* memdef=VhdlDocGen::findMember(n,mem);
2339  if (memdef && memdef->isLinkable())
2340  {
2341  ol.startBold();
2342  writeLink(memdef,ol);
2343  ol.endBold();
2344  ol.docify(" ");
2345  return;
2346  }
2347  }
2348  }
2349  startFonts(mem,"vhdlchar",ol);
2350 }// found component
2351 
2352 
2353 
2354 void VhdlDocGen::writeSource(const MemberDef *mdef,OutputList& ol,const QCString & cname)
2355 {
2357  // pIntf->resetCodeParserState();
2358 
2359  QCString codeFragment=mdef->documentation();
2360 
2361  if (cname.isEmpty())
2362  {
2363  writeLink(mdef,ol);
2364  int fi=0;
2365  int j=0;
2366  do
2367  {
2368  fi=codeFragment.find("\n",++fi);
2369  } while(fi>=0 && j++ <3);
2370 
2371  // show only the first four lines
2372  if (j==4)
2373  {
2374  codeFragment=codeFragment.left(fi);
2375  codeFragment.append("\n .... ");
2376  }
2377  }
2378 
2379  codeFragment.prepend("\n");
2380  ol.pushGeneratorState();
2381  ol.startCodeFragment();
2382  intf.parseCode( ol, // codeOutIntf
2383  0, // scope
2384  codeFragment, // input
2385  SrcLangExt_VHDL, // lang
2386  FALSE, // isExample
2387  0, // exampleName
2388  const_cast<FileDef*>(mdef->getFileDef()), // fileDef
2389  mdef->getStartBodyLine(), // startLine
2390  mdef->getEndBodyLine(), // endLine
2391  TRUE, // inlineFragment
2392  mdef, // memberDef
2393  TRUE // show line numbers
2394  );
2395 
2396  ol.endCodeFragment();
2397  ol.popGeneratorState();
2398 
2399  if (cname.isEmpty()) return;
2400 
2401  mdef->writeSourceDef(ol,cname);
2402  if (mdef->hasReferencesRelation()) mdef->writeSourceRefs(ol,cname);
2403  if (mdef->hasReferencedByRelation()) mdef->writeSourceReffedBy(ol,cname);
2404 }
2405 
2406 
2407 
2409 {
2410 
2411  QCString n=name;
2412  n=n.remove(0,6);
2413 
2414  int i=0;
2415 
2416  while((i=n.find("__"))>0)
2417  {
2418  n=n.remove(i,1);
2419  }
2420 
2421  while((i=n.find("_1"))>0)
2422  {
2423  n=n.replace(i,2,":");
2424  }
2425 
2426  return n;
2427 }
2428 
2429 void VhdlDocGen::parseUCF(const char* input, Entry* entity,QCString fileName,bool altera)
2430 {
2431  QCString ucFile(input);
2432  int lineNo=0;
2433  QCString comment("#!");
2434  QCString brief;
2435 
2436  while (!ucFile.isEmpty())
2437  {
2438  int i=ucFile.find("\n");
2439  if (i<0) break;
2440  lineNo++;
2441  QCString temp=ucFile.left(i);
2442  temp=temp.stripWhiteSpace();
2443  bool bb=temp.stripPrefix("//");
2444 
2445  if (!temp.isEmpty())
2446  {
2447  if (temp.stripPrefix(comment) )
2448  {
2449  brief+=temp;
2450  brief.append("\\n");
2451  }
2452  else if (!temp.stripPrefix("#") && !bb)
2453  {
2454  if (altera)
2455  {
2456  int in=temp.find("-name");
2457  if (in>0)
2458  {
2459  temp=temp.remove(0,in+5);
2460  }
2461 
2462  temp.stripPrefix("set_location_assignment");
2463 
2464  initUCF(entity,0,temp,lineNo,fileName,brief);
2465  }
2466  else
2467  {
2468  QRegExp ee("[\\s=]");
2469  int in=temp.find(ee);
2470  QCString ff=temp.left(in);
2471  temp.stripPrefix(ff.data());
2472  ff.append("#");
2473  if (!temp.isEmpty())
2474  {
2475  initUCF(entity,ff.data(),temp,lineNo,fileName,brief);
2476  }
2477  }
2478  }
2479  }//temp
2480 
2481  ucFile=ucFile.remove(0,i+1);
2482  }// while
2483 }
2484 
2485 static void initUCF(Entry* root,const char* type,QCString & qcs,int line,QCString & fileName,QCString & brief)
2486 {
2487  if (qcs.isEmpty())return;
2488  QRegExp reg("[\\s=]");
2489  QCString n;
2490  // bool bo=(qstricmp(type,qcs.data())==0);
2491 
2492  VhdlDocGen::deleteAllChars(qcs,';');
2493  qcs=qcs.stripWhiteSpace();
2494 
2495  int i= qcs.find(reg);
2496  if (i<0) return;
2497  if (i==0)
2498  {
2499  n=type;
2501  type="";
2502  }
2503  else
2504  {
2505  n=qcs.left(i);
2506  }
2507  qcs=qcs.remove(0,i+1);
2508  // qcs.prepend("|");
2509 
2510  qcs.stripPrefix("=");
2511 
2512  std::shared_ptr<Entry> current = std::make_shared<Entry>();
2513  current->spec=VhdlDocGen::UCF_CONST;
2514  current->section=Entry::VARIABLE_SEC;
2515  current->bodyLine=line;
2516  current->fileName=fileName;
2517  current->type="ucf_const";
2518  current->args+=qcs;
2519  current->lang= SrcLangExt_VHDL ;
2520 
2521  // adding dummy name for constraints like VOLTAGE=5,TEMPERATURE=20 C
2522  if (n.isEmpty())
2523  {
2524  n="dummy";
2526  }
2527 
2528  current->name= n+"_";
2530 
2531  if (!brief.isEmpty())
2532  {
2533  current->brief=brief;
2534  current->briefLine=line;
2535  current->briefFile=fileName;
2536  brief.resize(0);
2537  }
2538 
2539  root->moveToSubEntryAndKeep(current);
2540 }
2541 
2542 
2543 static void writeUCFLink(const MemberDef* mdef,OutputList &ol)
2544 {
2545 
2546  QCString largs(mdef->argsString());
2547  QCString n= splitString(largs, '#');
2548  // VhdlDocGen::adjustRecordMember(mdef);
2549  bool equ=(n.length()==largs.length());
2550 
2551  if (!equ)
2552  {
2553  ol.writeString(n.data());
2554  ol.docify(" ");
2555  ol.insertMemberAlign();
2556  }
2557 
2558  if (mdef->name().contains("dummy")==0)
2559  {
2560  writeLink(mdef,ol);
2561  }
2562  if (equ)
2563  {
2564  ol.insertMemberAlign();
2565  }
2566  ol.docify(" ");
2567  VhdlDocGen::formatString(largs,ol,mdef);
2568 }
2569 
2570 // for cell_inst : [entity] work.proto [ (label|expr) ]
2572 {
2573  int index;
2574  QCString label;
2575  if (!entity.contains(":")) return "";
2576 
2577  QRegExp exp("[:()\\s]");
2578  QCStringList ql=QCStringList::split(exp,entity);
2579  //int ii=ql.findIndex(ent);
2580  assert(ql.count()>=2);
2581  label = ql[0];
2582  entity = ql[1];
2583  if ((index=entity.findRev("."))>=0)
2584  {
2585  entity.remove(0,index+1);
2586  }
2587 
2588  if (ql.count()==3)
2589  {
2590  arch= ql[2];
2591  ql=QCStringList::split(exp,arch);
2592  if (ql.count()>1) // expression
2593  {
2594  arch="";
2595  }
2596  }
2597  return label; // label
2598 }
2599 
2600 // use (configuration|entity|open) work.test [(cellfor)];
2601 
2603 {
2604  int index;
2605  QRegExp exp("[()\\s]");
2606 
2607  QCString label="";
2608  QCStringList ql=QCStringList::split(exp,entity);
2609 
2610  if (ql.contains("open"))
2611  {
2612  return "open";
2613  }
2614 
2615  label=ql[0];
2616 
2617  entity = ql[1];
2618  if ((index=entity.findRev("."))>=0)
2619  {
2620  entity.remove(0,index+1);
2621  }
2622 
2623  if (ql.count()==3)
2624  {
2625  arch=ql[2];
2626  }
2627  return label;
2628 }
2629 
2630 
2631 
2632  // find class with upper/lower letters
2633  ClassDef* VhdlDocGen::findVhdlClass(const char *className )
2634  {
2635 
2637  ClassDef *cd;
2638  for (;(cd=cli.current());++cli)
2639  {
2640  if (qstricmp(className,cd->name().data())==0)
2641  {
2642  return cd;
2643  }
2644  }
2645  return 0;
2646  }
2647 
2648 
2649 /*
2650 
2651 // file foo.vhd
2652 // entity foo
2653 // .....
2654 // end entity
2655 
2656 // file foo_arch.vhd
2657 // architecture xxx of foo is
2658 // ........
2659 // end architecture
2660 
2661 */
2663 {
2664 
2665  QCString entity,arch,inst;
2666 
2667  for (const auto &cur : getVhdlInstList())
2668  {
2669  if (cur->stat ) // was bind
2670  {
2671  continue;
2672  }
2673 
2674  if (cur->includeName=="entity" || cur->includeName=="component" )
2675  {
2676  entity=cur->includeName+" "+cur->type;
2677  QCString rr=VhdlDocGen::parseForBinding(entity,arch);
2678  }
2679  else if (cur->includeName.isEmpty())
2680  {
2681  entity=cur->type;
2682  }
2683 
2684  ClassDef *classEntity= VhdlDocGen::findVhdlClass(entity.data());//Doxygen::classSDict->find(entity);
2685  inst=VhdlDocGen::getIndexWord(cur->args.data(),0);
2686  ClassDef *cd=Doxygen::classSDict->find(inst);
2687  ClassDef *ar=Doxygen::classSDict->find(cur->args);
2688 
2689  if (cd==0)
2690  {
2691  continue;
2692  }
2693 
2694  // if (classEntity==0)
2695  // err("%s:%d:Entity:%s%s",cur->fileName.data(),cur->startLine,entity.data()," could not be found");
2696 
2697  addInstance(classEntity,ar,cd,cur);
2698  }
2699 
2700 }
2701 
2702 static void addInstance(ClassDef* classEntity, ClassDef* ar,
2703  ClassDef *cd , const std::shared_ptr<Entry> &cur)
2704 {
2705 
2706  QCString bName,n1;
2707  if (ar==0) return;
2708 
2709  if (classEntity==0)
2710  {
2711  //add component inst
2712  n1=cur->type;
2713  goto ferr;
2714  }
2715 
2716  if (classEntity==cd) return;
2717 
2718  bName=classEntity->name();
2719  // fprintf(stderr,"\naddInstance %s to %s %s %s\n", classEntity->name().data(),cd->name().data(),ar->name().data(),cur->name);
2720  n1=classEntity->name().data();
2721 
2722  if (!cd->isBaseClass(classEntity, true, 0))
2723  {
2724  cd->insertBaseClass(classEntity,n1,Public,Normal,0);
2725  }
2726  else
2727  {
2728  VhdlDocGen::addBaseClass(cd,classEntity);
2729  }
2730 
2731  if (!VhdlDocGen::isSubClass(classEntity,cd,true,0))
2732  {
2733  classEntity->insertSubClass(cd,Public,Normal,0);
2734  classEntity->setLanguage(SrcLangExt_VHDL);
2735  }
2736 
2737 ferr:
2738  QCString uu=cur->name;
2740  ar->getDefFileName(), cur->startLine,cur->startColumn,
2741  n1,uu,uu, 0,
2742  Public, Normal, cur->stat,Member,
2744  ArgumentList(),
2745  ArgumentList(),
2746  "");
2747 
2748  if (ar->getOutputFileBase())
2749  {
2750  TagInfo tg;
2751  tg.anchor = 0;
2752  tg.fileName = ar->getOutputFileBase();
2753  tg.tagName = 0;
2754  md->setTagInfo(&tg);
2755  }
2756 
2757  //fprintf(stderr,"\n%s%s%s\n",md->name().data(),cur->brief.data(),cur->doc.data());
2758 
2761  md->setBriefDescription(cur->brief,cur->briefFile,cur->briefLine);
2762  md->setBodySegment(cur->startLine,cur->startLine,-1) ;
2763  md->setDocumentation(cur->doc.data(),cur->docFile.data(),cur->docLine);
2764  FileDef *fd=ar->getFileDef();
2765  md->setBodyDef(fd);
2766  //QCString info="Info: Elaborating entity "+n1;
2767  //fd=ar->getFileDef();
2768  //info+=" for hierarchy ";
2769  //QRegExp epr("[|]");
2770  //QCString label=cur->type+":"+cur->write+":"+cur->name;
2771  //label.replace(epr,":");
2772  //info+=label;
2773  //fprintf(stderr,"\n[%s:%d:%s]\n",fd->fileName().data(),cur->startLine,info.data());
2774  ar->insertMember(md);
2775 
2776 }
2777 
2778 
2779 void VhdlDocGen::writeRecordUnit(QCString & largs,QCString & ltype,OutputList& ol ,const MemberDef *mdef)
2780 {
2781  int i=mdef->name().find('~');
2782  if(i>0){
2783  //sets the real record member name
2784  const_cast<MemberDef*>(mdef)->setName(mdef->name().left(i).data());
2785  }
2786 
2787  writeLink(mdef,ol);
2788  ol.startBold();
2789  ol.insertMemberAlign();
2790  if (!ltype.isEmpty()){
2791  VhdlDocGen::formatString(ltype,ol,mdef);
2792  }
2793  ol.endBold();
2794 
2795 }
2796 
2797 
2799  const MemberDef *md,
2800  OutputList& ol,
2801  QCString largs)
2802 {
2803 
2804  QCStringList ql=QCStringList::split("#",largs);
2805  uint len=ql.count();
2807  bool first=TRUE;
2808 
2809  for(uint i=0;i<len;i++)
2810  {
2811  QCString n=ql[i];
2812  ol.startParameterType(first,"");
2813  ol.endParameterType();
2815  VhdlDocGen::formatString(n,ol,md);
2816  if ((len-i)>1)
2817  {
2819  }
2820  else
2821  {
2823  }
2824 
2825  first=FALSE;
2826  }
2827 
2828 }//#
2829 
2830 
2831 
2832 bool VhdlDocGen::isSubClass(ClassDef* cd,ClassDef *scd, bool followInstances,int level)
2833 {
2834  bool found=FALSE;
2835  //printf("isBaseClass(cd=%s) looking for %s\n",name().data(),bcd->name().data());
2836  if (level>255)
2837  {
2838  err("Possible recursive class relation while inside %s and looking for %s\n",qPrint(cd->name()),qPrint(scd->name()));
2839  abort();
2840  return FALSE;
2841  }
2842 
2843  if (cd->subClasses())
2844  {
2845  BaseClassListIterator bcli(*cd->subClasses());
2846  for ( ; bcli.current() && !found ; ++bcli)
2847  {
2848  const ClassDef *ccd=bcli.current()->classDef;
2849  if (!followInstances && ccd->templateMaster()) ccd=ccd->templateMaster();
2850  //printf("isSubClass() subclass %s\n",ccd->name().data());
2851  if (ccd==scd)
2852  {
2853  found=TRUE;
2854  }
2855  else
2856  {
2857  if (level <256)
2858  {
2859  found=ccd->isBaseClass(scd,followInstances,level+1);
2860  }
2861  }
2862  }
2863  }
2864  return found;
2865 }
2866 
2868 {
2869  if (cd->baseClasses())
2870  {
2871  BaseClassListIterator bcli(*cd->baseClasses());
2872  for ( ; bcli.current() ; ++bcli)
2873  {
2874  ClassDef *ccd=bcli.current()->classDef;
2875  if (ccd==ent)
2876  {
2877  QCString n = bcli.current()->usedName;
2878  int i = n.find('(');
2879  if(i<0)
2880  {
2881  bcli.current()->usedName.append("(2)");
2882  return;
2883  }
2884  static QRegExp reg("[0-9]+");
2885  QCString s=n.left(i);
2886  QCString r=n.right(n.length()-i);
2887  QCString t=r;
2890  r.setNum(r.toInt()+1);
2891  t.replace(reg,r.data());
2892  s.append(t.data());
2893  bcli.current()->usedName=s;
2894  bcli.current()->templSpecifiers=t;
2895  }
2896  }
2897  }
2898 }
2899 
2900 
2902 
2903 static MemberDef* findMemFlow(const MemberDef* mdef)
2904 {
2905  for(uint j=0;j<mdList.count();j++)
2906  {
2907  MemberDef* md=(MemberDef*)mdList.at(j);
2908  if (md->name()==mdef->name() && md->getStartBodyLine()==mdef->getStartBodyLine())
2909  return md;
2910  }
2911  return 0;
2912 }
2913 
2915 {
2916  if (mdef==0) return;
2917 
2918  QCString codeFragment;
2919  MemberDef* mm=0;
2920  if((mm=findMemFlow(mdef))!=0)
2921  {
2922  // don't create the same flowchart twice
2924  return;
2925  }
2926  else
2927  {
2928  mdList.append(mdef);
2929  }
2930 
2931  //fprintf(stderr,"\n create flow mem %s %p\n",mdef->name().data(),mdef);
2932 
2933  int actualStart= mdef->getStartBodyLine();
2934  int actualEnd=mdef->getEndBodyLine();
2935  const FileDef* fd=mdef->getFileDef();
2936  bool b=readCodeFragment( fd->absFilePath().data(), actualStart,actualEnd,codeFragment);
2937  if (!b) return;
2938 
2941  std::shared_ptr<Entry> root = std::make_shared<Entry>();
2942  QStrList filesInSameTu;
2943  intf.startTranslationUnit("");
2944  intf.parseInput("",codeFragment.data(),root,FALSE,filesInSameTu);
2945  intf.finishTranslationUnit();
2946 }
2947 
2949 {
2950  varMap.clear();
2951  qli.clear();
2952  packages.clear();
2953 }
2954 
2956 { return mdef->getMemberSpecifiers()==VhdlDocGen::UCF_CONST; }
2958 { return mdef->getMemberSpecifiers()==VhdlDocGen::CONFIG; }
2960 { return mdef->getMemberSpecifiers()==VhdlDocGen::ALIAS; }
2962 { return mdef->getMemberSpecifiers()==VhdlDocGen::LIBRARY; }
2964 { return mdef->getMemberSpecifiers()==VhdlDocGen::GENERIC; }
2966 { return mdef->getMemberSpecifiers()==VhdlDocGen::PORT; }
2968 { return mdef->getMemberSpecifiers()==VhdlDocGen::COMPONENT; }
2970 { return mdef->getMemberSpecifiers()==VhdlDocGen::USE; }
2972 { return mdef->getMemberSpecifiers()==VhdlDocGen::ENTITY; }
2974 { return mdef->getMemberSpecifiers()==VhdlDocGen::CONSTANT; }
2976 { return mdef->getMemberSpecifiers()==VhdlDocGen::TYPE; }
2978 { return mdef->getMemberSpecifiers()==VhdlDocGen::SUBTYPE; }
2980 { return mdef->getMemberSpecifiers()==VhdlDocGen::FUNCTION; }
2982 { return mdef->getMemberSpecifiers()==VhdlDocGen::PROCESS; }
2984 { return mdef->getMemberSpecifiers()==VhdlDocGen::SIGNAL; }
2986 { return mdef->getMemberSpecifiers()==VhdlDocGen::ATTRIBUTE; }
2988 { return mdef->getMemberSpecifiers()==VhdlDocGen::SIGNAL; }
2990 { return mdef->getMemberSpecifiers()==VhdlDocGen::PROCEDURE; }
2992 { return mdef->getMemberSpecifiers()==VhdlDocGen::RECORD; }
2994 { return mdef->getMemberSpecifiers()==VhdlDocGen::ARCHITECTURE; }
2996 { return mdef->getMemberSpecifiers()==VhdlDocGen::UNITS; }
2998 { return mdef->getMemberSpecifiers()==VhdlDocGen::PACKAGE_BODY; }
3002 { return mdef->getMemberSpecifiers()==VhdlDocGen::VFILE; }
3004 { return mdef->getMemberSpecifiers()==VhdlDocGen::GROUP; }
3009 
3010 
3011 
3012 //############################## Flowcharts #################################################
3013 
3014 #define STARTL (FlowChart::WHILE_NO | FlowChart::IF_NO | \
3015  FlowChart::FOR_NO | FlowChart::CASE_NO | \
3016  FlowChart::LOOP_NO | WHEN_NO)
3017 #define DECLN (FlowChart::WHEN_NO | \
3018  FlowChart::ELSIF_NO | FlowChart::IF_NO | \
3019  FlowChart::FOR_NO | FlowChart::WHILE_NO | \
3020  FlowChart::CASE_NO | FlowChart::LOOP_NO )
3021 #define STARTFIN (FlowChart::START_NO | FlowChart::END_NO)
3022 #define LOOP (FlowChart::FOR_NO | FlowChart::WHILE_NO | \
3023  FlowChart::LOOP_NO )
3024 #define ENDCL (FlowChart::END_CASE | FlowChart::END_LOOP)
3025 #define EEND (FlowChart::ENDIF_NO | FlowChart::ELSE_NO )
3026 #define IFF (FlowChart::ELSIF_NO | FlowChart::IF_NO)
3027 #define EXITNEXT (FlowChart::EXIT_NO | FlowChart::NEXT_NO )
3028 #define EMPTY (EEND | FlowChart::ELSIF_NO)
3029 #define EE (FlowChart::ELSE_NO | FlowChart::ELSIF_NO)
3030 #define EMPTNODE (ENDCL | EEND | FlowChart::ELSIF_NO)
3031 #define FLOWLEN (flowList.count()-1)
3033 static int ifcounter=0;
3034 static int nodeCounter=0;
3035 
3036 static struct
3037 {
3038  // link colors
3039  const char *textNodeLink;
3040  const char *yesNodeLink;
3041  const char *noNodeLink;
3042 
3043  // node colors
3044  const char* comment;
3045  const char* decisionNode;
3046  const char* varNode;
3047  const char *startEndNode;
3048  const char* textNode;
3049 } flowCol =
3050 { "green", // textNodeLink
3051  "red", // yesNodeLink
3052  "black", // noNodeLink
3053  "khaki", // comment
3054  "0.7 0.3 1.0", // decisionNode
3055  "lightyellow", // varNode
3056  "white", // startEndNode
3057  "lightcyan" // textNode
3058 };
3059 
3061 
3062 #ifdef DEBUGFLOW
3063 static QMap<QCString,int> keyMap;
3064 #endif
3065 
3067 {
3068  if (q.length()<=80) return;
3069 
3070  if (q.length()>200)
3071  {
3072  q.resize(200);
3073  }
3074 
3075  q.append(" ...");
3076 
3077  QRegExp reg("[\\s|]");
3078  QCString str(q.data());
3079  QCString temp;
3080 
3081  while (str.length()>80)
3082  {
3083  int j=str.findRev(reg,80);
3084  if (j<=0)
3085  {
3086  temp+=str;
3087  q=temp;
3088  return;
3089  }
3090  else
3091  {
3092  QCString qcs=str.left(j);
3093  temp+=qcs+"\\";
3094  temp+="n";
3095  str.remove(0,j);
3096  }
3097  }//while
3098 
3099  q=temp+str;
3100 // #endif
3101 }
3102 
3104 {
3105  if (flo==0) return;
3106  QCString ui="-";
3107  QCString q,t;
3108  QRegExp ep("[\t\n\r]");
3109 
3110  ui.fill('-',255);
3111 
3112  if (flo->type & STARTL)
3113  {
3114  if (flo->stamp>0)
3115  {
3116  q=ui.left(2*flo->stamp);
3117  }
3118  else
3119  {
3120  q=" ";
3121  }
3122  QCString nn=flo->exp.stripWhiteSpace();
3123  printf("\nYES: %s%s[%d,%d]",q.data(),nn.data(),flo->stamp,flo->id);
3124  }
3125  else
3126  {
3127  if (flo->type & COMMENT_NO)
3128  {
3129  t=flo->label;
3130  }
3131  else
3132  {
3133  t=flo->text;
3134  }
3135  t=t.replace(ep,"");
3136  if (t.isEmpty())
3137  {
3138  t=" ";
3139  }
3140  if (flo->stamp>0)
3141  {
3142  q=ui.left(2*flo->stamp);
3143  }
3144  else
3145  {
3146  q=" ";
3147  }
3148  if (flo->type & EMPTNODE)
3149  {
3150  printf("\n NO: %s%s[%d,%d]",q.data(),FlowChart::getNodeType(flo->type),flo->stamp,flo->id);
3151  }
3152  else if (flo->type & COMMENT_NO)
3153  {
3154  printf("\n NO: %s%s[%d,%d]",t.data(),FlowChart::getNodeType(flo->type),flo->stamp,flo->id);
3155  }
3156  else
3157  {
3158  printf("\n NO: %s[%d,%d]",t.data(),flo->stamp,flo->id);
3159  }
3160  }
3161 }
3162 
3164 {
3165  uint size=flowList.count();
3166  for (uint j=0;j<size;j++)
3167  {
3168  printNode(flowList.at(j));
3169  }
3170 }
3171 
3173 {
3174  QCString text;
3175  FlowChart *flno;
3176  bool found=FALSE;
3177  for (uint j=0;j<flowList.count();j++)
3178  {
3179  FlowChart *flo=flowList.at(j);
3180  if (flo->type&TEXT_NO)
3181  {
3182  text+=flo->text+'\n';
3183  if (!found)
3184  {
3185  flno=flo;
3186  }
3187  if (found)
3188  {
3189  flno->text+=flo->text;
3190  flowList.remove(flo);
3191  if (j>0) j=j-1;
3192  }
3193  found=TRUE;
3194  }
3195  else
3196  found=FALSE;
3197  }
3198 
3199  // find if..endif without text
3200  // if..elseif without text
3201  for (uint j=0;j<flowList.count()-1;j++)
3202  {
3203  FlowChart *flo=flowList.at(j);
3204  int kind=flo->type;
3205  if ( (kind & IFF) || (flo->type & ELSE_NO))
3206  {
3207  FlowChart *ftemp=flowList.at(j+1);
3208  if (ftemp->type & EMPTY)
3209  {
3210  FlowChart *fNew = new FlowChart(TEXT_NO,"empty ",0);
3211  fNew->stamp=flo->stamp;
3212  flowList.insert(j+1,fNew);
3213  }
3214  }
3215  }
3216 
3217 }// colTextNode
3218 
3220 {
3221  QCString node;
3222  node.setNum(n);
3223  return node.prepend("node");
3224 }
3225 
3227 {
3228  ifcounter=0;
3229  nodeCounter=0;
3230  uint size=flowList.count();
3231 
3232  for (uint j=0;j <size ;j++)
3233  {
3234  FlowChart *fll=flowList.at(j);
3235  delete fll;
3236  }
3237  flowList.clear();
3238 }
3239 
3241 {
3242  uint max=0;
3243  QCString s;
3244  QCStringList ql=QCStringList::split("\n",com);
3245  for (uint j=0;j<ql.count();j++)
3246  {
3247  s=(QCString)ql[j];
3248  if (max<s.length()) max=s.length();
3249  }
3250 
3251  s=ql.last();
3252  int diff=max-s.length();
3253 
3254  QCString n(1);
3255  if (diff>0)
3256  {
3257  n.fill(' ',2*diff);
3258  n.append(".");
3259  s+=n;
3260  ql.remove(ql.last());
3261  ql.append(s);
3262  }
3263 
3264  for (uint j=0;j<ql.count();j++)
3265  {
3266  s=ql[j];
3267  if (j<ql.count()-1)
3268  {
3269  s+="\n";
3270  }
3271  FlowChart::codify(t,s.data());
3272  }
3273 }
3274 
3275 
3277 {
3278  uint size=flowList.count();
3279  bool begin=false;
3280 
3281  for (uint j=0;j < size-1 ;j++)
3282  {
3283  FlowChart *fll=flowList.at(j);
3284  if (fll->type & COMMENT_NO)
3285  {
3286  FlowChart* to=flowList.at(j+1);
3287  if (to->type & COMMENT_NO)
3288  {
3289  fll->label+="\n";
3290  QCString temp=fll->label+to->label;
3291  to->label=temp;
3292  flowList.remove(j);
3293  size--;
3294  if (j>0) j--;
3295  }
3296  }
3297  }// for
3298 
3299  for (uint j=0;j <flowList.count() ;j++)
3300  {
3301  FlowChart *fll=flowList.at(j);
3302 
3303  if (fll->type & BEGIN_NO)
3304  {
3305  begin = true;
3306  continue;
3307  }
3308 
3309  if (fll->type & COMMENT_NO)
3310  {
3311  FlowChart* to;
3312  if (!begin)
3313  {
3314  // comment between function/process .. begin is linked to start node
3315  to=flowList.at(0);
3316  }
3317  else
3318  {
3319  if (j>0 && flowList.at(j-1)->line==fll->line)
3320  to=flowList.at(j-1);
3321  else
3322  to=flowList.at(j+1);
3323  }
3324  t << getNodeName(fll->id);
3325  t << "[shape=none, label=<\n";
3326  t << "<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\" CELLPADDING=\"2\" >\n ";
3327  t << "<TR><TD BGCOLOR=\"";
3328  t << flowCol.comment;
3329  t << "\" > ";
3330 
3332  t << " </TD></TR></TABLE>>];";
3333  writeEdge(t,fll->id,to->id,2);
3334  }
3335  }// for
3336 
3337  // delete comment nodes;
3338  size=flowList.count();
3339  for (uint j=0;j < size;j++)
3340  {
3341  FlowChart *fll=flowList.at(j);
3342  if (fll->type & (COMMENT_NO | BEGIN_NO))
3343  {
3344  int diff=FLOWLEN-(j+1);
3345  flowList.remove(j);
3346 
3347  if ((fll->type & COMMENT_NO) && diff > 1)
3348  flowList.at(j+1)->label=fll->label;
3349 
3350  delete fll;
3351  fll=0;
3352  size--;
3353  if (j>0) j--;
3354  }
3355  }// for;
3356 }
3357 
3358 void FlowChart::codify(FTextStream &t,const char *str)
3359 {
3360  if (str)
3361  {
3362  const char *p=str;
3363  char c;
3364  while (*p)
3365  {
3366  c=*p++;
3367  switch(c)
3368  {
3369  case '<': t << "&lt;"; break;
3370  case '>': t << "&gt;"; break;
3371  case '&': t << "&amp;"; break;
3372  case '\'': t << "&#39;"; break;
3373  case '"': t << "&quot;"; break;
3374  case '\n': t <<"<BR ALIGN=\"LEFT\"/>"; break;
3375  default: t << c; break;
3376  }
3377  }
3378  }
3379 }//codify
3380 
3382 {
3383 }
3384 
3385 FlowChart::FlowChart(int typ,const char * t,const char* ex,const char* lab)
3386 {
3387  stamp=ifcounter;
3388 
3389  if (typ & STARTL)
3390  {
3391  ifcounter++;
3392  }
3393 
3394  text=t;
3395  exp=ex;
3396  type=typ;
3397  label=lab;
3398 
3399  if (typ & (ELSE_NO | ELSIF_NO))
3400  {
3401  stamp--;
3402  }
3403 
3404  if (typ & (START_NO | END_NO | VARIABLE_NO))
3405  {
3406  stamp=0;
3407  }
3408 
3409  id=nodeCounter++;
3410 }
3411 
3412 void FlowChart::addFlowChart(int type,const char* text,const char* exp, const char *label)
3413 {
3414  static QRegExp reg("[;]");
3415  static QRegExp reg1("[\"]");
3416 
3417  if (!VhdlDocGen::getFlowMember()) return;
3418 
3419  QCString typeString(text);
3420  QCString expression(exp);
3421 
3422 
3423  if (text)
3424  {
3425  typeString=typeString.replace(reg,"\n");
3426  }
3427 
3428  if (exp)
3429  {
3430  expression=expression.replace(reg1,"\\\"");
3431  }
3432 
3433  FlowChart *fl=new FlowChart(type,typeString.data(),expression.data(),label);
3434 
3435  fl->line=1; // TODO: use getLine(); of the parser
3436 
3437  if (type & (START_NO | VARIABLE_NO))
3438  {
3439  flowList.prepend(fl);
3440  }
3441  else
3442  {
3443  flowList.append(fl);
3444  }
3445 }
3446 
3448 {
3449  if (!VhdlDocGen::getFlowMember()) return;
3450  ifcounter--;
3451 }
3452 
3453 QCString FlowChart::printPlantUmlNode(const FlowChart *flo,bool ca,bool endL)
3454 {
3455  QCString t;
3458  switch (flo->type)
3459  {
3460  case START_NO: t=":"+text+"|"; break;
3461  case IF_NO : t="\nif ("+exp+") then (yes)"; break;
3462  case ELSIF_NO: t="\nelseif ("+exp+") then (yes)"; break;
3463  case ELSE_NO: t="\nelse"; break;
3464  case CASE_NO: t="\n:"+exp+";"; break;
3465  case WHEN_NO: t="\n";
3466  if (!ca) t+="else";
3467  t+="if ("+exp+") then (yes)";
3468  break;
3469  case EXIT_NO: break;
3470  case END_NO: if (text.contains(" function")==0) t="\n:"+text+";";
3471  break;
3472  case TEXT_NO: t="\n:"+text+"]"; break;
3473  case ENDIF_NO: t="\nendif"; break;
3474  case FOR_NO: t="\nwhile ("+exp+") is (yes)"; break;
3475  case WHILE_NO: t="\nwhile ("+exp+") is (yes)"; break;
3476  case END_LOOP: t="\nendwhile"; break;
3477  case END_CASE: t="\nendif\n:end case;"; break;
3478  case VARIABLE_NO:t="\n:"+text+";"; break;
3479  case RETURN_NO: t="\n:"+text+";";
3480  if (!endL) t+="\nstop";
3481  break;
3482  case LOOP_NO: t="\nwhile (infinite loop)"; break;
3483  case NEXT_NO: break;
3484  case EMPTY_NO: break;
3485  case COMMENT_NO: t="\n note left \n "+flo->label+"\nend note \n"; break;
3486  case BEGIN_NO: t="\n:begin;"; break;
3487  default: assert(false); break;
3488  }
3489  return t;
3490 }
3491 
3493 {
3494  int caseCounter = 0;
3495  int whenCounter = 0;
3496 
3497  QCString qcs;
3498  uint size=flowList.count();
3499  bool endList;
3500  for (uint j=0;j<size;j++)
3501  {
3502  endList=j==FLOWLEN;
3503  FlowChart *flo=flowList.at(j);
3504  if (flo->type==CASE_NO)
3505  {
3506  caseCounter++;
3507  whenCounter=0;
3508  }
3509 
3510  if (flo->type==END_CASE)
3511  {
3512  caseCounter--;
3513  }
3514 
3515  bool ca = (caseCounter>0 && whenCounter==0);
3516 
3517  qcs+=printPlantUmlNode(flo,ca,endList);
3518 
3519  if (flo->type==WHEN_NO)
3520  {
3521  whenCounter++;
3522  }
3523 
3524  }
3525  qcs+="\n";
3526 
3527  QCString & htmlOutDir = Config_getString(HTML_OUTPUT);
3528 
3530  QCString tmp=htmlOutDir;
3533 }
3534 
3536 {
3537  static QRegExp exp ("[^][a-z_A-Z0-9]");
3538  QCString temp,qcs;
3540 
3541  // temp.sprintf("%p",md);
3542  qcs=md->name();
3543 
3544  #if 0
3545  if (qcs.find(exp,0)>=0)
3546  {
3547  qcs.prepend("Z");
3548  qcs=qcs.replace(exp,"_");
3549  }
3550  #endif
3551 
3552  //QCString tt= qcs;VhdlDocGen::getRecordNumber();
3553  return qcs;
3554 }
3555 
3556 const char* FlowChart::getNodeType(int c)
3557 {
3558  switch(c)
3559  {
3560  case IF_NO: return "if ";
3561  case ELSIF_NO: return "elsif ";
3562  case ELSE_NO: return "else ";
3563  case CASE_NO: return "case ";
3564  case WHEN_NO: return "when ";
3565  case EXIT_NO: return "exit ";
3566  case END_NO: return "end ";
3567  case TEXT_NO: return "text ";
3568  case START_NO: return "start ";
3569  case ENDIF_NO: return "endif ";
3570  case FOR_NO: return "for ";
3571  case WHILE_NO: return "while ";
3572  case END_LOOP: return "end_loop ";
3573  case END_CASE: return "end_case ";
3574  case VARIABLE_NO: return "variable_decl ";
3575  case RETURN_NO: return "return ";
3576  case LOOP_NO: return "infinite loop ";
3577  case NEXT_NO: return "next ";
3578  case COMMENT_NO: return "comment ";
3579  case EMPTY_NO: return "empty ";
3580  case BEGIN_NO: return "<begin> ";
3581  default: return "--failure--";
3582  }
3583 }
3584 
3586 {
3587  QCString qcs("/");
3588  QCString ov = Config_getString(HTML_OUTPUT);
3589 
3590  qcs+=FlowChart::convertNameToFileName()+".svg";
3591 
3592  //const MemberDef *m=VhdlDocGen::getFlowMember();
3593  //if (m)
3594  // fprintf(stderr,"\n creating flowchart : %s %s in file %s \n",theTranslator->trVhdlType(m->getMemberSpecifiers(),TRUE),m->name().data(),m->getFileDef()->name().data());
3595 
3596  QCString dir=" -o \""+ov+qcs+"\"";
3597  ov+="/flow_design.dot";
3598 
3599  QCString vlargs="-Tsvg \""+ov+"\" "+dir ;
3600 
3601  if (Portable::system(Config_getString(DOT_PATH) + "dot",vlargs)!=0)
3602  {
3603  err("could not create dot file");
3604  }
3605 }
3606 
3608 {
3609  t << " digraph G { \n";
3610  t << "rankdir=TB \n";
3611  t << "concentrate=true\n";
3612  t << "stylesheet=\"doxygen.css\"\n";
3613 }
3614 
3616 {
3617  t << " } \n";
3618 }
3619 
3621 {
3622  // assert(VhdlDocGen::flowMember);
3623 
3624  QCString ov = Config_getString(HTML_OUTPUT);
3625  QCString fileName = ov+"/flow_design.dot";
3626  QFile f(fileName);
3627  FTextStream t(&f);
3628 
3629  if (!f.open(IO_WriteOnly))
3630  {
3631  err("Cannot open file %s for writing\n",fileName.data());
3632  return;
3633  }
3634 
3635  colTextNodes();
3636  // buildCommentNodes(t);
3637 
3638 #ifdef DEBUGFLOW
3639  printFlowTree();
3640 #endif
3642 
3643  if (p->isStatic())
3644  {
3645  printUmlTree();
3646  delFlowList();
3647  f.close();
3648  return;
3649  }
3650 
3651  startDot(t);
3652  buildCommentNodes(t);
3653  uint size=flowList.count();
3654 
3655  for (uint j=0;j <size ;j++)
3656  {
3657  FlowChart *fll=flowList.at(j);
3658  writeShape(t,fll);
3659  }
3660  writeFlowLinks(t);
3661 
3662  FlowChart::endDot(t);
3663  delFlowList();
3664  f.close();
3666 }// writeFlowChart
3667 
3669 {
3670  if (fl->type & EEND) return;
3671  QCString var;
3672  if (fl->type & LOOP)
3673  {
3674  var=" loop";
3675  }
3676  else if (fl->type & IFF)
3677  {
3678  var=" then";
3679  }
3680  else
3681  {
3682  var="";
3683  }
3684 
3685  t<<getNodeName(fl->id).data();
3686 
3687 #ifdef DEBUGFLOW
3688  QCString qq(getNodeName(fl->id).data());
3689  keyMap.insert(qq,fl->id);
3690 #endif
3691 
3692  bool dec=(fl->type & DECLN);
3693  bool exit=(fl->type & EXITNEXT);
3694  if (exit && !fl->exp.isEmpty())
3695  {
3696  dec=TRUE;
3697  }
3698  if (dec)
3699  {
3700  QCString exp=fl->exp;
3701  alignText(exp);
3702 
3703  t << " [shape=diamond,style=filled,color=\"";
3704  t << flowCol.decisionNode;
3705  t << "\",label=\" ";
3706  QCString kl;
3707  if (exit) kl=fl->text+" ";
3708 
3709  if (fl->label)
3710  {
3711  kl+=fl->label+":"+exp+var;
3712  }
3713  else
3714  {
3715  kl+=exp+var;
3716  }
3717 
3719  t << "\"]\n";
3720  }
3721  else if (fl->type & ENDCL)
3722  {
3723  QCString val=fl->text;
3724  t << " [shape=ellipse ,label=\""+val+"\"]\n";
3725  }
3726  else if (fl->type & STARTFIN)
3727  {
3728  QCString val=fl->text;
3729  t << "[shape=box , style=rounded label=<\n";
3730  t << "<TABLE BORDER=\"0\" CELLBORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"0\" >\n ";
3731  t << "<TR><TD BGCOLOR=\"";
3732  t<< flowCol.startEndNode;
3733  t<< "\"> ";
3735  t << " </TD></TR></TABLE>>];";
3736  }
3737  else
3738  {
3739  if (fl->text.isEmpty()) return;
3740  bool isVar=(fl->type & FlowChart::VARIABLE_NO);
3741  QCString q=fl->text;
3742 
3743  if (exit)
3744  {
3745  q+=" "+fl->label;
3746  }
3747 
3748  int z=q.findRev("\n");
3749 
3750  if (z==(int)q.length()-1)
3751  {
3752  q=q.remove(z,2);
3753  }
3754  t << "[shape=none margin=0.1, label=<\n";
3755  t << "<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\" CELLPADDING=\"2\" >\n ";
3756  if (isVar)
3757  {
3758  t << "<TR><TD BGCOLOR=\"" << flowCol.varNode << "\" > ";
3759  }
3760  else
3761  {
3762  t << "<TR><TD BGCOLOR=\"" << flowCol.textNode << "\" > ";
3763  }
3765  t << " </TD></TR></TABLE>>];";
3766  }
3767 }
3768 
3769 
3770 void FlowChart::writeEdge(FTextStream &t,const FlowChart* fl_from,const FlowChart* fl_to,int i)
3771 {
3772  bool b=fl_from->type & STARTL;
3773  bool c=fl_to->type & STARTL;
3774 
3775 #ifdef DEBUGFLOW
3776  QCString s1(getNodeName(fl_from->id).data());
3777  QCString s2(getNodeName(fl_to->id).data());
3778  QMap<QCString, int>::Iterator it = keyMap.find(s1);
3779  QMap<QCString, int>::Iterator it1 = keyMap.find(s2);
3780  // checks if the link is connected to a valid node
3781  assert(it.key());
3782  assert(it1.key());
3783 #endif
3784 
3785  writeEdge(t,fl_from->id,fl_to->id,i,b,c);
3786 }
3787 
3788 void FlowChart::writeEdge(FTextStream &t,int fl_from,int fl_to,int i,bool bFrom,bool bTo)
3789 {
3790  QCString label,col;
3791 
3792  if (i==0)
3793  {
3794  col=flowCol.yesNodeLink;
3795  label="yes";
3796  }
3797  else if (i==1)
3798  {
3799  col=flowCol.noNodeLink;
3800  label="no";
3801  }
3802  else
3803  {
3804  col=flowCol.textNodeLink;
3805  label="";
3806  }
3807 
3808  t << "edge [color=\""+col+"\",label=\""+label+"\"]\n";
3809  t << getNodeName(fl_from).data();
3810  if (bFrom) t << ":s";
3811  t << "->";
3812  t << getNodeName(fl_to).data();
3813  if (bTo) t << ":n";
3814  t << "\n";
3815 }
3816 
3817 void FlowChart::alignFuncProc( QCString & q,const ArgumentList &al,bool isFunc)
3818 {
3819  size_t index=al.size();
3820  if (index==0) return;
3821 
3822  int len=q.length()+VhdlDocGen::getFlowMember()->name().length();
3823  QCString prev,temp;
3824  prev.fill(' ',len+1);
3825 
3826  q+="\n";
3827  for (const Argument &arg : al)
3828  {
3829  QCString attl=arg.defval+" ";
3830  attl+=arg.name+" ";
3831 
3832  if (!isFunc)
3833  {
3834  attl+=arg.attrib+" ";
3835  }
3836  else
3837  {
3838  attl+=" in ";
3839  }
3840  attl+=arg.type;
3841  if (--index) attl+=",\n"; else attl+="\n";
3842 
3843  attl.prepend(prev.data());
3844  temp+=attl;
3845  }
3846 
3847  q+=temp;
3848 }
3849 
3850 int FlowChart::findNextLoop(int index,int stamp)
3851 {
3852  for (uint j=index+1;j<flowList.count();j++)
3853  {
3854  FlowChart *flo=flowList.at(j);
3855  if (flo->stamp==stamp)
3856  {
3857  continue;
3858  }
3859  if (flo->type&END_LOOP)
3860  {
3861  return j;
3862  }
3863  }
3864  return flowList.count()-1;
3865 }
3866 
3867 int FlowChart::findPrevLoop(int index,int stamp,bool endif)
3868 {
3869  for (uint j=index;j>0;j--)
3870  {
3871  FlowChart *flo=flowList.at(j);
3872  if (flo->type & LOOP)
3873  {
3874  if (flo->stamp==stamp && endif)
3875  {
3876  return j;
3877  }
3878  else
3879  {
3880  if (flo->stamp<stamp)
3881  {
3882  return j;
3883  }
3884  }
3885  }
3886  }
3887  return flowList.count()-1;
3888 }
3889 
3890 int FlowChart::findLabel(int index,QCString &label)
3891 {
3892  for (uint j=index;j>0;j--)
3893  {
3894  FlowChart *flo=flowList.at(j);
3895  if ((flo->type & LOOP) && !flo->label.isEmpty() && qstricmp(flo->label,label)==0)
3896  {
3897  return j;
3898  }
3899  }
3900  err("could not find label: %s",label.data());
3901  return 0;
3902 }
3903 
3904 int FlowChart::findNode(int index,int stamp,int type)
3905 {
3906  for (uint j=index+1;j<flowList.count();j++)
3907  {
3908  FlowChart *flo=flowList.at(j);
3909  if (flo->type==type && flo->stamp==stamp)
3910  {
3911  return j;
3912  }
3913  }
3914  return 0;
3915 }// findNode
3916 
3917 int FlowChart::getNextNode(int index,int stamp)
3918 {
3919  for (uint j=index+1;j<flowList.count();j++)
3920  {
3921  FlowChart *flo=flowList.at(j);
3922  int kind=flo->type;
3923  int s=flo->stamp;
3924  if (s>stamp)
3925  {
3926  continue;
3927  }
3928  if (kind & ENDIF_NO)
3929  {
3930  if (s<stamp && stamp>0)
3931  {
3932  stamp--;
3933  continue;
3934  }
3935  }
3936  if (kind & (ELSE_NO | ELSIF_NO))
3937  {
3938  if (s<stamp && stamp>0)
3939  {
3940  stamp--;
3941  }
3942  j=findNode(j,stamp,ENDIF_NO);
3943  continue;
3944  }
3945  if (kind & WHEN_NO)
3946  {
3947  if (s<stamp && stamp>0)
3948  {
3949  stamp--;
3950  }
3951  return findNode(j,stamp-1,END_CASE);
3952  }
3953  return j;
3954  }
3955  return FLOWLEN;
3956 }
3957 
3959 {
3960  int stamp=fl->stamp;
3961  uint start = index+1;
3962  int endifNode = findNode(start,stamp,ENDIF_NO);
3963  int elseifNode = findNode(start,stamp,ELSIF_NO);
3964  int elseNode = findNode(start,stamp,ELSE_NO);
3965 
3966  assert(endifNode>-1);
3967 
3968  if (elseifNode>0 && elseifNode<endifNode)
3969  {
3970  return elseifNode;
3971  }
3972 
3973  if (elseNode>0 && elseNode<endifNode)
3974  {
3975  return elseNode+1;
3976  }
3977 
3978  stamp=flowList.at(endifNode)->stamp;
3979  return getNextNode(endifNode,stamp);
3980 }
3981 
3983 {
3984  uint size=flowList.count();
3985  if (size<2) return;
3986 
3987  // write start link
3988  writeEdge(t,flowList.at(0),flowList.at(1),2);
3989 
3990  for (uint j=0;j<size;j++)
3991  {
3992  FlowChart *fll=flowList.at(j);
3993  int kind=fll->type;
3994  int stamp=fll->stamp;
3995  if (kind & EEND)
3996  {
3997  continue;
3998  }
3999 
4000  if (kind & IFF)
4001  {
4002  writeEdge(t,fll,flowList.at(j+1),0);
4003  int z=getNextIfLink(fll,j);
4004  // assert(z>-1);
4005  writeEdge(t,fll,flowList.at(z),1);
4006  }
4007  else if (kind & LOOP_NO)
4008  {
4009  writeEdge(t,fll,flowList.at(j+1),2);
4010  continue;
4011  }
4012  else if (kind & (CASE_NO | FOR_NO | WHILE_NO))
4013  {
4014  if (kind & CASE_NO)
4015  {
4016  writeEdge(t,fll,flowList.at(j+1),2);
4017  continue;
4018  }
4019  else
4020  {
4021  writeEdge(t,fll,flowList.at(j+1),0);
4022  }
4023 
4024  kind=END_LOOP;
4025  int z=findNode(j+1,fll->stamp,kind);
4026  z=getNextNode(z,flowList.at(z)->stamp);
4027 
4028  // assert(z>-1);
4029  writeEdge(t,fll,flowList.at(z),1);
4030  continue;
4031  }
4032  else if (kind & (TEXT_NO | VARIABLE_NO))
4033  {
4034  int z=getNextNode(j,stamp);
4035  writeEdge(t,fll,flowList.at(z),2);
4036  }
4037  else if (kind & WHEN_NO)
4038  {
4039  // default value
4040  if (qstricmp(fll->text.simplifyWhiteSpace().data(),"others")==0)
4041  {
4042  writeEdge(t,fll,flowList.at(j+1),2);
4043  continue;
4044  }
4045 
4046 
4047  writeEdge(t,fll,flowList.at(j+1),0);
4048  int u=findNode(j,stamp,WHEN_NO);
4049  int v=findNode(j,stamp-1,END_CASE);
4050 
4051  if (u>0 && u<v)
4052  {
4053  writeEdge(t,fll,flowList.at(u),1);
4054  }
4055  else
4056  {
4057  writeEdge(t,fll,flowList.at(v),1);
4058  }
4059  }
4060  else if (kind & END_CASE)
4061  {
4062  int z=FlowChart::getNextNode(j,fll->stamp);
4063  writeEdge(t,fll,flowList.at(z),2);
4064  }
4065  else if (kind & END_LOOP)
4066  {
4067  int z=findPrevLoop(j,fll->stamp,true);
4068  writeEdge(t,fll,flowList.at(z),2);
4069  }
4070  else if (kind & RETURN_NO)
4071  {
4072  writeEdge(t,fll,FlowChart::flowList.at(size-1),2);
4073  }
4074  else if (kind & (EXIT_NO | NEXT_NO))
4075  {
4076  int z;
4077  bool b = kind==NEXT_NO;
4078  if (fll->exp)
4079  {
4080  writeEdge(t,fll,flowList.at(j+1),1);
4081  }
4082  if (!fll->label.isEmpty())
4083  {
4084  z=findLabel(j,fll->label);
4085  if (b)
4086  {
4087  writeEdge(t,fll,flowList.at(z),0);
4088  }
4089  else
4090  {
4091  z=findNode(z,flowList.at(z)->stamp,END_LOOP);
4092  z=getNextNode(z,flowList.at(z)->stamp);
4093  writeEdge(t,fll,flowList.at(z),0);
4094  }
4095  continue;
4096  }
4097  else
4098  {
4099  if (b)
4100  {
4101  z=findPrevLoop(j,fll->stamp);
4102  writeEdge(t,fll,flowList.at(z),0);
4103  continue;
4104  }
4105  else
4106  {
4107  z =findNextLoop(j,fll->stamp-1);
4108  }
4109  z=getNextNode(z,flowList.at(z)->stamp);
4110  }
4111  writeEdge(t,fll,flowList.at(z),0);
4112  }
4113  } //for
4114 } //writeFlowLinks
FlowChart::getNextIfLink
static int getNextIfLink(const FlowChart *, uint)
Definition: vhdldocgen.cpp:3958
BaseClassDef::usedName
QCString usedName
name used in the inheritance list (may be a typedef name instead of the class name)
Definition: classdef.h:498
QList::at
type * at(uint i) const
Definition: qlist.h:94
QMapIterator::data
T & data()
Definition: qmap.h:115
QCString::replace
QCString & replace(uint index, uint len, const char *s)
Definition: qcstring.cpp:439
Entry::type
QCString type
member type
Definition: entry.h:237
OutputGenerator::Man
@ Man
Definition: outputgen.h:325
OutputList::endMemberGroup
void endMemberGroup(bool last)
Definition: outputlist.h:214
MemberDef::getReference
virtual QCString getReference() const =0
outputlist.h
MemberDef::argumentList
virtual const ArgumentList & argumentList() const =0
packages
static QMap< ClassDef *, QList< ClassDef > > packages
Definition: vhdldocgen.cpp:715
QRegExp
Definition of QRegExp class.
Definition: qregexp.h:47
MemberDef::setDocumentation
virtual void setDocumentation(const char *d, const char *docFile, int docLine, bool stripWhiteSpace=TRUE)=0
BaseClassDef
Class that contains information about an inheritance relation.
Definition: classdef.h:487
VHDLOutlineParser
VHDL parser using state-based lexical scanning.
Definition: vhdljjparser.h:31
ArgumentList
This class represents an function or template argument list.
Definition: arguments.h:60
Doxygen::classSDict
static ClassSDict * classSDict
Definition: doxygen.h:94
FlowChart::printNode
static void printNode(const FlowChart *n)
Definition: vhdldocgen.cpp:3103
OutputList::endBold
void endBold()
Definition: outputlist.h:287
Entry::briefFile
QCString briefFile
file in which the brief desc. was found
Definition: entry.h:270
VhdlDocGen::getPackageName
static ClassDef * getPackageName(const QCString &name)
Definition: vhdldocgen.cpp:705
QCString::isEmpty
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition: qcstring.h:191
Entry::bodyLine
int bodyLine
line number of the body in the source
Definition: entry.h:281
findMemFlow
static MemberDef * findMemFlow(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2903
BaseClassList
List of base classes.
Definition: classdef.h:519
QList::remove
bool remove(uint i)
Definition: qlist.h:76
bool
int bool
Definition: qglobal.h:345
VhdlDocGen::isPackageBody
static bool isPackageBody(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2997
VhdlDocGen::isConfig
static bool isConfig(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2957
MemberType_Variable
@ MemberType_Variable
Definition: types.h:200
OutputList::enableAll
void enableAll()
Definition: outputlist.cpp:56
OutputList::startParameterName
void startParameterName(bool one)
Definition: outputlist.h:410
EMPTY
#define EMPTY
Definition: vhdldocgen.cpp:3028
createSVG
static void createSVG()
Definition: vhdldocgen.cpp:163
MemberListIterator
An iterator for MemberDef objects in a MemberList.
Definition: memberlist.h:124
QCString::setNum
QCString & setNum(short n)
Definition: qcstring.cpp:648
BaseClassDef::classDef
ClassDef * classDef
Class definition that this relation inherits from.
Definition: classdef.h:493
g_vhdlKeyDict0
static QDict< QCString > g_vhdlKeyDict0(17, FALSE)
VhdlDocGen::addBaseClass
static void addBaseClass(ClassDef *cd, ClassDef *ent)
Definition: vhdldocgen.cpp:2867
VhdlDocGen::findVhdlClass
static ClassDef * findVhdlClass(const char *className)
Definition: vhdldocgen.cpp:2633
Entry::docLine
int docLine
line number at which the documentation was found
Definition: entry.h:266
QList::setAutoDelete
void setAutoDelete(bool enable)
Definition: qlist.h:99
VhdlDocGen::COMPONENT
@ COMPONENT
Definition: vhdldocgen.h:91
BaseClassListIterator
Iterator for a list of base classes.
Definition: classdef.h:536
Definition::getOutputFileBase
virtual QCString getOutputFileBase() const =0
ParserManager::getOutlineParser
OutlineParserInterface & getOutlineParser(const char *extension)
Gets the interface to the parser associated with given extension.
Definition: parserintf.h:218
Normal
@ Normal
Definition: types.h:30
VHDLOutlineParser::finishTranslationUnit
void finishTranslationUnit()
Called after all files in a translation unit have been processed.
Definition: vhdljjparser.h:36
Translator::trVhdlType
virtual QCString trVhdlType(uint64 type, bool single)=0
QCString::remove
QCString & remove(uint index, uint len)
Definition: qcstring.cpp:419
membergroup.h
SDict::clear
void clear()
Definition: sortdict.h:272
OutputList::startFontClass
void startFontClass(const char *c)
Definition: outputlist.h:462
OutputList::endCodeFragment
void endCodeFragment()
Definition: outputlist.h:226
QCString::append
QCString & append(const char *s)
Definition: qcstring.cpp:411
ClassDef::insertSubClass
virtual void insertSubClass(ClassDef *, Protection p, Specifier s, const char *t=0)=0
Entry::name
QCString name
member name
Definition: entry.h:238
Doxygen::parserManager
static ParserManager * parserManager
Definition: doxygen.h:130
MemberListType
MemberListType
Definition: types.h:101
OutputList::endParameterName
void endParameterName(bool last, bool one, bool bracket)
Definition: outputlist.h:412
FlowChart::printUmlTree
static void printUmlTree()
Definition: vhdldocgen.cpp:3492
uint
unsigned uint
Definition: qglobal.h:351
QMap::insert
Iterator insert(const Key &key, const T &value)
Definition: qmap.h:545
ClassDef
A abstract class representing of a compound symbol.
Definition: classdef.h:61
FlowChart::COMMENT_NO
@ COMMENT_NO
Definition: vhdldocgen.h:288
writeTable
static void writeTable(QList< MemberDef > *port, FTextStream &t)
Definition: vhdldocgen.cpp:497
VhdlDocGen::formatString
static void formatString(const QCString &, OutputList &ol, const MemberDef *)
Definition: vhdldocgen.cpp:1360
FlowChart::type
int type
Definition: vhdldocgen.h:338
OutputList::startMemberGroup
void startMemberGroup()
Definition: outputlist.h:212
VHDLOutlineParser::parseInput
void parseInput(const char *fileName, const char *fileBuf, const std::shared_ptr< Entry > &root, bool sameTranslationUnit, QStrList &filesInSameTranslationUnit)
Parses a single input file with the goal to build an Entry tree.
Definition: vhdljjparser.cpp:126
Entry::stat
bool stat
static ?
Definition: entry.h:248
FlowChart::addFlowChart
static void addFlowChart(int type, const char *text, const char *exp, const char *label=0)
Definition: vhdldocgen.cpp:3412
FlowChart::ENDIF_NO
@ ENDIF_NO
Definition: vhdldocgen.h:278
VhdlDocGen::isSubClass
static bool isSubClass(ClassDef *cd, ClassDef *scd, bool followInstances, int level)
Definition: vhdldocgen.cpp:2832
VhdlDocGen::isGroup
static bool isGroup(const MemberDef *mdef)
Definition: vhdldocgen.cpp:3003
Doxygen::searchIndex
static SearchIndexIntf * searchIndex
Definition: doxygen.h:122
VhdlDocGen::PORT
@ PORT
Definition: vhdldocgen.h:100
VhdlDocGen::isConstraint
static bool isConstraint(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2955
VhdlDocGen::init
static void init()
Definition: vhdldocgen.cpp:570
FlowChart::EMPTY_NO
@ EMPTY_NO
Definition: vhdldocgen.h:287
OutputList::insertMemberAlign
void insertMemberAlign(bool templ=FALSE)
Definition: outputlist.h:216
FlowChart::delFlowList
static void delFlowList()
Definition: vhdldocgen.cpp:3226
ClassDef::insertBaseClass
virtual void insertBaseClass(ClassDef *, const char *name, Protection p, Specifier s, const char *t=0)=0
VhdlDocGen::isNumber
static bool isNumber(const QCString &s)
Definition: vhdldocgen.cpp:1342
startTable
static void startTable(FTextStream &t, const QCString &className)
Definition: vhdldocgen.cpp:275
memberdef.h
VhdlDocGen::ENTITY
@ ENTITY
Definition: vhdldocgen.h:85
VhdlDocGen::PACKAGE
@ PACKAGE
Definition: vhdldocgen.h:88
QCString::findRev
int findRev(char c, int index=-1, bool cs=TRUE) const
Definition: qcstring.cpp:97
Entry::moveToSubEntryAndKeep
void moveToSubEntryAndKeep(Entry *e)
Definition: entry.cpp:147
OutputList::writeObjectLink
void writeObjectLink(const char *ref, const char *file, const char *anchor, const char *name)
Definition: outputlist.h:129
FlowChart::RETURN_NO
@ RETURN_NO
Definition: vhdldocgen.h:284
FTextStream
Simplified and optimized version of QTextStream.
Definition: ftextstream.h:12
FlowChart::EXIT_NO
@ EXIT_NO
Definition: vhdldocgen.h:274
PlantumlManager::generatePlantUMLOutput
void generatePlantUMLOutput(const char *baseName, const char *outDir, OutputFormat format)
Convert a PlantUML file to an image.
Definition: plantuml.cpp:85
FlowChart::CASE_NO
@ CASE_NO
Definition: vhdldocgen.h:272
VhdlDocGen::writeVHDLTypeDocumentation
static bool writeVHDLTypeDocumentation(const MemberDef *mdef, const Definition *d, OutputList &ol)
Definition: vhdldocgen.cpp:1768
OutputList::endMemberDescription
void endMemberDescription()
Definition: outputlist.h:291
index.h
readCodeFragment
bool readCodeFragment(const char *fileName, int &startLine, int &endLine, QCString &result)
Reads a fragment from file fileName starting with line startLine and ending with line endLine.
Definition: definition.cpp:839
flowCol
static struct @12 flowCol
QMapIterator
Definition: qmap.h:87
MemberGroup::documentation
const QCString & documentation() const
Definition: membergroup.h:68
QList::append
void append(const type *d)
Definition: qlist.h:73
namespacedef.h
codify
static void codify(FTextStream &t, const char *str)
Definition: vhdldocgen.cpp:103
OutputList::pushGeneratorState
void pushGeneratorState()
Definition: outputlist.cpp:98
FlowChart::writeEdge
static void writeEdge(FTextStream &t, int fl_from, int fl_to, int i, bool bFrom=FALSE, bool bTo=FALSE)
Definition: vhdldocgen.cpp:3788
Definition::writeSourceDef
virtual void writeSourceDef(OutputList &ol, const char *scopeName) const =0
commentscan.h
Interface for the comment block scanner.
QCString::resize
bool resize(uint newlen)
Resizes the string to hold newlen characters (this value should include the 0-terminator).
Definition: qcstring.h:227
OutputList::parseText
void parseText(const QCString &textStr)
Definition: outputlist.cpp:151
QCString::simplifyWhiteSpace
QCString simplifyWhiteSpace() const
Definition: qcstring.cpp:351
Definition::symbolName
virtual QCString symbolName() const =0
VhdlDocGen::isComponent
static bool isComponent(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2967
VhdlDocGen::writeSource
static void writeSource(const MemberDef *mdef, OutputList &ol, const QCString &cname)
Definition: vhdldocgen.cpp:2354
QList::insert
bool insert(uint i, const type *d)
Definition: qlist.h:70
FlowChart::BEGIN_NO
@ BEGIN_NO
Definition: vhdldocgen.h:289
FlowChart::WHEN_NO
@ WHEN_NO
Definition: vhdldocgen.h:273
MemberDef::getClassDefOfAnonymousType
virtual ClassDef * getClassDefOfAnonymousType() const =0
TagInfo::anchor
QCString anchor
Definition: entry.h:53
VhdlDocGen::writeRecUnitDocu
static void writeRecUnitDocu(const MemberDef *md, OutputList &ol, QCString largs)
Definition: vhdldocgen.cpp:2798
startFonts
static void startFonts(const QCString &q, const char *keyword, OutputList &ol)
Definition: vhdldocgen.cpp:139
Entry::spec
uint64 spec
class/member specifiers
Definition: entry.h:246
VhdlDocGen::ENTITYCLASS
@ ENTITYCLASS
Definition: vhdldocgen.h:76
QCString::lower
QCString lower() const
Definition: qcstring.cpp:291
formatBriefNote
static QCString formatBriefNote(const QCString &brief, ClassDef *cd)
Definition: vhdldocgen.cpp:293
VhdlDocGen::ARCHITECTURECLASS
@ ARCHITECTURECLASS
Definition: vhdldocgen.h:78
VhdlDocGen::findAllArchitectures
static void findAllArchitectures(QList< QCString > &ql, const ClassDef *cd)
Definition: vhdldocgen.cpp:1040
VhdlDocGen::ALIAS
@ ALIAS
Definition: vhdldocgen.h:108
MemberDef::isStatic
virtual bool isStatic() const =0
FlowChart::FlowChart
FlowChart(int typ, const char *t, const char *ex, const char *label=0)
Definition: vhdldocgen.cpp:3385
Entry::briefLine
int briefLine
line number at which the brief desc. was found
Definition: entry.h:269
FlowChart::END_LOOP
@ END_LOOP
Definition: vhdldocgen.h:281
data
const char *const void * data
Definition: iconv.h:120
OutputList::generateDoc
void generateDoc(const char *fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &docStr, bool indexWords, bool isExample, const char *exampleName=0, bool singleLine=FALSE, bool linkFromIndex=FALSE)
Definition: outputlist.cpp:114
Public
@ Public
Definition: types.h:27
QCString::length
uint length() const
Returns the length of the string, excluding the 0-terminator.
Definition: qcstring.h:197
FlowChart::IF_NO
@ IF_NO
Definition: vhdldocgen.h:269
Portable::system
int system(const char *command, const char *args, bool commandHasConsole=true)
Definition: portable.cpp:40
FlowChart::END_CASE
@ END_CASE
Definition: vhdldocgen.h:282
ifcounter
static int ifcounter
Definition: vhdldocgen.cpp:3033
Definition::writeDocAnchorsToTagFile
virtual void writeDocAnchorsToTagFile(FTextStream &) const =0
writeUCFLink
static void writeUCFLink(const MemberDef *mdef, OutputList &ol)
Definition: vhdldocgen.cpp:2543
QValueList::contains
uint contains(const T &x) const
Definition: qvaluelist.h:388
VhdlDocGen::getRecordNumber
static QCString getRecordNumber()
Definition: vhdldocgen.cpp:1244
VhdlDocGen::writeVhdlDeclarations
static void writeVhdlDeclarations(const MemberList *, OutputList &, const GroupDef *, const ClassDef *, const FileDef *, const NamespaceDef *)
Definition: vhdldocgen.cpp:1689
IO_WriteOnly
#define IO_WriteOnly
Definition: qiodevice.h:62
FlowChart::alignCommentNode
static void alignCommentNode(FTextStream &t, QCString com)
Definition: vhdldocgen.cpp:3240
VhdlDocGen::CONSTANT
@ CONSTANT
Definition: vhdldocgen.h:92
err
void err(const char *fmt,...)
Definition: message.cpp:238
FlowChart::flowList
static QList< FlowChart > flowList
Definition: vhdldocgen.h:330
mdList
static QList< MemberDef > mdList
Definition: vhdldocgen.cpp:2901
MemberDef::typeString
virtual const char * typeString() const =0
TagInfo
This struct is used to capture the tag file information for an Entry.
Definition: entry.h:50
FLOWLEN
#define FLOWLEN
Definition: vhdldocgen.cpp:3031
MemberDef::setTagInfo
virtual void setTagInfo(const TagInfo *i)=0
OutputList::endMemberGroupHeader
void endMemberGroupHeader()
Definition: outputlist.h:206
Definition::briefDescription
virtual QCString briefDescription(bool abbreviate=FALSE) const =0
QList< MemberDef >
VhdlDocGen::USE
@ USE
Definition: vhdldocgen.h:98
VhdlDocGen::writeVHDLDeclarations
static void writeVHDLDeclarations(const MemberList *ml, OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const char *title, const char *subtitle, bool showEnumValues, int type)
Definition: vhdldocgen.cpp:2257
MemberGroupListIterator
An iterator for MemberGroup objects in a MemberGroupList.
Definition: membergroup.h:113
ClassDef::isBaseClass
virtual bool isBaseClass(const ClassDef *bcd, bool followInstances, int level=0) const =0
Returns TRUE iff bcd is a direct or indirect base class of this class.
VhdlDocGen::correctMemberProperties
static void correctMemberProperties(MemberDef *md)
Definition: vhdldocgen.cpp:1720
VhdlDocGen::getClassName
static QCString getClassName(const ClassDef *)
Definition: vhdldocgen.cpp:947
MemberDef::setBriefDescription
virtual void setBriefDescription(const char *b, const char *briefFile, int briefLine)=0
Entry::brief
QCString brief
brief description (doc block)
Definition: entry.h:268
MemberListType_pubMethods
@ MemberListType_pubMethods
Definition: types.h:107
qcstring.h
FlowChart::getNodeName
static QCString getNodeName(int n)
Definition: vhdldocgen.cpp:3219
OutputList::disable
void disable(OutputGenerator::OutputType o)
Definition: outputlist.cpp:72
filename.h
LOOP
#define LOOP
Definition: vhdldocgen.cpp:3022
VhdlDocGen::SHAREDVARIABLE
@ SHAREDVARIABLE
Definition: vhdldocgen.h:106
MemberDef::anchor
virtual QCString anchor() const =0
FlowChart::writeShape
static void writeShape(FTextStream &t, const FlowChart *fl)
Definition: vhdldocgen.cpp:3668
QMap::find
Iterator find(const Key &k)
Definition: qmap.h:527
Definition::getEndBodyLine
virtual int getEndBodyLine() const =0
VhdlDocGen::getClassTitle
static QCString getClassTitle(const ClassDef *)
Definition: vhdldocgen.cpp:934
MemberDef::getOutputFileBase
virtual QCString getOutputFileBase() const =0
config.h
Definition::writeSourceReffedBy
virtual void writeSourceReffedBy(OutputList &ol, const char *scopeName) const =0
OutputList::endMemberItem
void endMemberItem()
Definition: outputlist.h:198
VhdlDocGen::isLibrary
static bool isLibrary(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2961
QList::contains
uint contains(const type *d) const
Definition: qlist.h:90
QCString
This is an alternative implementation of QCString.
Definition: qcstring.h:134
VhdlDocGen::parseForBinding
static QCString parseForBinding(QCString &entity, QCString &arch)
Definition: vhdldocgen.cpp:2602
VhdlDocGen::isPort
static bool isPort(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2965
Definition::setName
virtual void setName(const char *name)=0
VhdlDocGen::isFile
static bool isFile(const MemberDef *mdef)
Definition: vhdldocgen.cpp:3001
OutputList::startBold
void startBold()
Definition: outputlist.h:285
GroupDef
A model of a group of symbols.
Definition: groupdef.h:48
VhdlDocGen::isArchitecture
static bool isArchitecture(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2993
FlowChart
Definition: vhdldocgen.h:266
Definition::setLanguage
virtual void setLanguage(SrcLangExt lang)=0
textNode
const char * textNode
Definition: vhdldocgen.cpp:3048
OutputList::startMemberDescription
void startMemberDescription(const char *anchor, const char *inheritId=0, bool typ=false)
Definition: outputlist.h:289
Definition::localName
virtual QCString localName() const =0
SDict::append
void append(const char *key, const T *d)
Definition: sortdict.h:135
VhdlDocGen::SIGNAL
@ SIGNAL
Definition: vhdldocgen.h:90
FileDef
A model of a file symbol.
Definition: filedef.h:65
ParserManager::getCodeParser
CodeParserInterface & getCodeParser(const char *extension)
Gets the interface to the parser associated with given extension.
Definition: parserintf.h:227
FlowChart::ELSE_NO
@ ELSE_NO
Definition: vhdldocgen.h:271
MemberGroup
A class representing a group of members.
Definition: membergroup.h:42
Config_getString
#define Config_getString(val)
Definition: config.h:34
VhdlDocGen::getFlowMember
static const MemberDef * getFlowMember()
Definition: vhdldocgen.cpp:95
VhdlDocGen::isMisc
static bool isMisc(const MemberDef *mdef)
Definition: vhdldocgen.cpp:3007
FlowChart::findNextLoop
static int findNextLoop(int j, int stamp)
Definition: vhdldocgen.cpp:3850
MemberDef::documentation
virtual QCString documentation() const =0
QMap
Definition: qmap.h:502
FlowChart::printFlowTree
static void printFlowTree()
Definition: vhdldocgen.cpp:3163
qfileinfo.h
ClassDef::protection
virtual Protection protection() const =0
Return the protection level (Public,Protected,Private) in which this compound was found.
FlowChart::printPlantUmlNode
static QCString printPlantUmlNode(const FlowChart *flo, bool, bool)
Definition: vhdldocgen.cpp:3453
MemberDef::hasReferencedByRelation
virtual bool hasReferencedByRelation() const =0
VhdlDocGen::RECORD
@ RECORD
Definition: vhdldocgen.h:96
MemberDef
A model of a class/file/namespace member symbol.
Definition: memberdef.h:45
VhdlDocGen::VhdlClasses
VhdlClasses
Definition: vhdldocgen.h:75
QCString::find
int find(char c, int index=0, bool cs=TRUE) const
Definition: qcstring.cpp:42
VhdlDocGen::findMemberDef
static MemberDef * findMemberDef(ClassDef *cd, const QCString &key, MemberListType type)
This function returns the entity|package in which the key (type) is found.
Definition: vhdldocgen.cpp:818
Member
@ Member
Definition: types.h:39
TRUE
@ TRUE
Definition: mscgen_bool.h:29
FlowChart::WHILE_NO
@ WHILE_NO
Definition: vhdldocgen.h:280
flowMember
static const MemberDef * flowMember
Definition: vhdldocgen.cpp:88
OutputList::endDoxyAnchor
void endDoxyAnchor(const char *fn, const char *anchor)
Definition: outputlist.h:251
FALSE
@ FALSE
Definition: mscgen_bool.h:28
QList::clear
void clear()
Definition: qlist.h:82
VhdlDocGen::getClass
static ClassDef * getClass(const char *name)
Definition: vhdldocgen.cpp:693
MemberDef::hasReferencesRelation
virtual bool hasReferencesRelation() const =0
Entry::startColumn
int startColumn
start column of entry in the source
Definition: entry.h:290
initUCF
static void initUCF(Entry *root, const char *type, QCString &qcs, int line, QCString &fileName, QCString &brief)
Definition: vhdldocgen.cpp:2485
textNodeLink
const char * textNodeLink
Definition: vhdldocgen.cpp:3039
getVhdlInstList
const EntryList & getVhdlInstList()
Definition: vhdljjparser.cpp:724
MemberList::getMemberGroupList
MemberGroupList * getMemberGroupList() const
Definition: memberlist.h:93
yesNodeLink
const char * yesNodeLink
Definition: vhdldocgen.cpp:3040
convertToXML
QCString convertToXML(const char *s, bool keepEntities)
Definition: util.cpp:5386
alignText
void alignText(QCString &q)
Definition: vhdldocgen.cpp:3066
QCString::contains
int contains(char c, bool cs=TRUE) const
Definition: qcstring.cpp:163
classlist.h
writeColumn
static void writeColumn(FTextStream &t, MemberDef *md, bool start)
Definition: vhdldocgen.cpp:364
QCString::mid
QCString mid(uint index, uint len=(uint) -1) const
Definition: qcstring.cpp:274
QCString::toInt
int toInt(bool *ok=0, int base=10) const
Definition: qcstring.cpp:497
Definition::getOuterScope
virtual Definition * getOuterScope() const =0
writeClassToDot
static void writeClassToDot(FTextStream &t, ClassDef *cd)
Definition: vhdldocgen.cpp:456
Definition::briefFile
virtual QCString briefFile() const =0
VhdlDocGen::isVariable
static bool isVariable(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2999
OutputGenerator::RTF
@ RTF
Definition: outputgen.h:325
FlowChart::FOR_NO
@ FOR_NO
Definition: vhdldocgen.h:279
Doxygen::htmlFileExtension
static QCString htmlFileExtension
Definition: doxygen.h:119
message.h
VhdlDocGen::getProtectionName
static QCString getProtectionName(int prot)
Definition: vhdldocgen.cpp:1196
OutputList::disableAllBut
void disableAllBut(OutputGenerator::OutputType o)
Definition: outputlist.cpp:48
VhdlDocGen::isEntity
static bool isEntity(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2971
FlowChart::findLabel
static int findLabel(int j, QCString &)
Definition: vhdldocgen.cpp:3890
VhdlDocGen::isProcedure
static bool isProcedure(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2989
compareString
static int compareString(const QCString &s1, const QCString &s2)
Definition: vhdldocgen.cpp:158
FlowChart::VARIABLE_NO
@ VARIABLE_NO
Definition: vhdldocgen.h:283
recordCounter
static int recordCounter
Definition: vhdldocgen.cpp:1238
VhdlDocGen::resetCodeVhdlParserState
static void resetCodeVhdlParserState()
Definition: vhdldocgen.cpp:2948
QCString::at
char & at(uint i) const
Returns a reference to the character at index i.
Definition: qcstring.h:329
Argument
Copyright (C) 1997-2015 by Dimitri van Heesch.
Definition: arguments.h:27
VhdlDocGen::isSubType
static bool isSubType(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2977
VhdlDocGen::convertFileNameToClassName
static QCString convertFileNameToClassName(QCString name)
Definition: vhdldocgen.cpp:2408
writeLink
static void writeLink(const MemberDef *mdef, OutputList &ol)
Definition: vhdldocgen.cpp:131
endTable
static void endTable(FTextStream &t)
Definition: vhdldocgen.cpp:450
VhdlDocGen::writeRecordUnit
static void writeRecordUnit(QCString &largs, QCString &ltype, OutputList &ol, const MemberDef *mdef)
Definition: vhdldocgen.cpp:2779
FlowChart::getNodeType
static const char * getNodeType(int c)
Definition: vhdldocgen.cpp:3556
VhdlDocGen::GROUP
@ GROUP
Definition: vhdldocgen.h:104
VhdlDocGen::setFlowMember
static void setFlowMember(const MemberDef *flowMember)
Definition: vhdldocgen.cpp:90
ClassDef::baseClasses
virtual BaseClassList * baseClasses() const =0
Returns the list of base classes from which this class directly inherits.
arguments.h
writeVhdlEntityToolTip
static void writeVhdlEntityToolTip(FTextStream &t, ClassDef *cd)
Definition: vhdldocgen.cpp:343
theTranslator_vhdlType
#define theTranslator_vhdlType
Copyright (C) 1997-2015 by Dimitri van Heesch.
Definition: vhdldocgen.cpp:64
qmap.h
NamespaceDef
An abstract interface of a namespace symbol.
Definition: namespacedef.h:38
qstricmp
int qstricmp(const char *str1, const char *str2)
Definition: qcstring.cpp:746
theTranslator
Translator * theTranslator
Copyright (C) 1997-2015 by Dimitri van Heesch.
Definition: language.cpp:157
OutputList::endFontClass
void endFontClass()
Definition: outputlist.h:464
VhdlDocGen::parseForConfig
static QCString parseForConfig(QCString &entity, QCString &arch)
Definition: vhdldocgen.cpp:2571
MemberDef::qualifiedName
virtual QCString qualifiedName() const =0
CodeParserInterface::parseCode
virtual void parseCode(CodeOutputInterface &codeOutIntf, const char *scopeName, const QCString &input, SrcLangExt lang, bool isExampleBlock, const char *exampleName=0, FileDef *fileDef=0, int startLine=-1, int endLine=-1, bool inlineFragment=FALSE, const MemberDef *memberDef=0, bool showLineNumbers=TRUE, const Definition *searchCtx=0, bool collectXRefs=TRUE)=0
Parses a source file or fragment with the goal to produce highlighted and cross-referenced output.
doxygen.h
VhdlDocGen::PACKBODYCLASS
@ PACKBODYCLASS
Definition: vhdldocgen.h:77
parserintf.h
FlowChart::line
int line
Definition: vhdldocgen.h:340
SDict::setAutoDelete
void setAutoDelete(bool val)
Definition: sortdict.h:222
OutputList::endMemberDocName
void endMemberDocName()
Definition: outputlist.h:404
VhdlDocGen::writeStringLink
static void writeStringLink(const MemberDef *mdef, QCString mem, OutputList &ol)
Definition: vhdldocgen.cpp:2330
parseCommentAsText
QCString parseCommentAsText(const Definition *scope, const MemberDef *md, const QCString &doc, const QCString &fileName, int lineNr)
Definition: util.cpp:7062
PlantumlManager::PUML_SVG
@ PUML_SVG
Definition: plantuml.h:44
ArgumentList::hasParameters
bool hasParameters() const
Definition: arguments.h:65
language.h
QCStringList
Definition: qcstringlist.h:25
MemberDef::briefDescription
virtual QCString briefDescription(bool abbr=FALSE) const =0
convertToId
QCString convertToId(const char *s)
Definition: util.cpp:5354
OutputList::docify
void docify(const char *s)
Definition: outputlist.h:125
QFile::open
bool open(int)
Definition: qfile_unix.cpp:134
VhdlDocGen::writeFuncProcDocu
static bool writeFuncProcDocu(const MemberDef *mdef, OutputList &ol, const ArgumentList &al, bool type=false)
Definition: vhdldocgen.cpp:1578
QList::count
uint count() const
Definition: qlist.h:66
FlowChart::writeFlowLinks
static void writeFlowLinks(FTextStream &t)
Definition: vhdldocgen.cpp:3982
varNode
const char * varNode
Definition: vhdldocgen.cpp:3046
QValueList::remove
Iterator remove(Iterator it)
Definition: qvaluelist.h:371
Entry::VARIABLE_SEC
@ VARIABLE_SEC
Definition: entry.h:95
QCString::right
QCString right(uint len) const
Definition: qcstring.cpp:259
QListIterator::current
type * current() const
Definition: qlist.h:147
VhdlDocGen::isVhdlFunction
static bool isVhdlFunction(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2979
VhdlDocGen::writePlainVHDLDeclarations
static void writePlainVHDLDeclarations(const MemberList *ml, OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, int specifier)
Definition: vhdldocgen.cpp:2196
MemberDef::getClassDef
virtual const ClassDef * getClassDef() const =0
FlowChart::NEXT_NO
@ NEXT_NO
Definition: vhdldocgen.h:286
FlowChart::createSVG
static void createSVG()
Definition: vhdldocgen.cpp:3585
g_vhdlKeyDict2
static QDict< QCString > g_vhdlKeyDict2(17, FALSE)
QStrList
The QStrList class provides a doubly linked list of char*.
Definition: qstrlist.h:58
VhdlDocGen::PROCESS
@ PROCESS
Definition: vhdldocgen.h:99
QCString::stripWhiteSpace
QCString stripWhiteSpace() const
Definition: qcstring.cpp:323
Definition
The common base class of all entity definitions found in the sources.
Definition: definition.h:100
VhdlDocGen::isRecord
static bool isRecord(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2991
FlowChart::stamp
int stamp
Definition: vhdldocgen.h:337
VhdlDocGen::isAttribute
static bool isAttribute(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2985
createMemberDef
MemberDef * createMemberDef(const char *defFileName, int defLine, int defColumn, const char *type, const char *name, const char *args, const char *excp, Protection prot, Specifier virt, bool stat, Relationship related, MemberType t, const ArgumentList &tal, const ArgumentList &al, const char *metaData)
Factory method to create a new instance of a MemberDef.
Definition: memberdef.cpp:366
FlowChart::ELSIF_NO
@ ELSIF_NO
Definition: vhdldocgen.h:270
Entry::startLine
int startLine
start line of entry in the source
Definition: entry.h:289
varMap
static QMap< QCString, MemberDef * > varMap
Definition: vhdldocgen.cpp:713
MemberListType_variableMembers
@ MemberListType_variableMembers
Definition: types.h:142
VHDLOutlineParser::startTranslationUnit
void startTranslationUnit(const char *)
Starts processing a translation unit (source files + headers).
Definition: vhdljjparser.h:35
VhdlDocGen::isSignal
static bool isSignal(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2983
VhdlDocGen::PACKAGECLASS
@ PACKAGECLASS
Definition: vhdldocgen.h:79
STARTFIN
#define STARTFIN
Definition: vhdldocgen.cpp:3021
VhdlDocGen::findArchitecture
static ClassDef * findArchitecture(const ClassDef *cd)
Definition: vhdldocgen.cpp:1060
MemberGroup::header
QCString header() const
Definition: membergroup.h:48
QCString::left
QCString left(uint len) const
Definition: qcstring.cpp:241
MemberDef::isVariable
virtual bool isVariable() const =0
VhdlDocGen::ARCHITECTURE
@ ARCHITECTURE
Definition: vhdldocgen.h:87
Definition::setBodyDef
virtual void setBodyDef(FileDef *fd)=0
VhdlDocGen::LIBRARY
@ LIBRARY
Definition: vhdldocgen.h:84
VhdlDocGen::PACKAGE_BODY
@ PACKAGE_BODY
Definition: vhdldocgen.h:86
OutputList::startEmphasis
void startEmphasis()
Definition: outputlist.h:235
VhdlDocGen::isPackage
static bool isPackage(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2969
OutputList::endMemberSubtitle
void endMemberSubtitle()
Definition: outputlist.h:178
ClassDef::getReference
virtual QCString getReference() const =0
If this class originated from a tagfile, this will return the tag file reference.
noNodeLink
const char * noNodeLink
Definition: vhdldocgen.cpp:3041
ClassDef::subClasses
virtual BaseClassList * subClasses() const =0
Returns the list of sub classes that directly derive from this class.
VhdlDocGen::PROCEDURE
@ PROCEDURE
Definition: vhdldocgen.h:97
qcstringlist.h
VhdlDocGen::deleteCharRev
static bool deleteCharRev(QCString &s, char c)
Definition: vhdldocgen.cpp:1214
OutputList::startMemberItem
void startMemberItem(const char *anchor, int i1, const char *id=0)
Definition: outputlist.h:196
VhdlDocGen::writeFunctionProto
static void writeFunctionProto(OutputList &ol, const ArgumentList &al, const MemberDef *)
Definition: vhdldocgen.cpp:1474
Definition::getDefFileName
virtual QCString getDefFileName() const =0
IFF
#define IFF
Definition: vhdldocgen.cpp:3026
VhdlDocGen::convertArgumentListToString
static QCString convertArgumentListToString(const ArgumentList &al, bool f)
Definition: vhdldocgen.cpp:1662
FlowChart::exp
QCString exp
Definition: vhdldocgen.h:344
TagInfo::tagName
QCString tagName
Definition: entry.h:51
OutputList::popGeneratorState
void popGeneratorState()
Definition: outputlist.cpp:106
OutputGenerator::Html
@ Html
Definition: outputgen.h:325
memberlist.h
VhdlDocGen::TYPE
@ TYPE
Definition: vhdldocgen.h:93
VhdlDocGen::writeVhdlLink
static void writeVhdlLink(const ClassDef *cdd, OutputList &ol, QCString &type, QCString &name, QCString &beh)
Definition: vhdldocgen.cpp:1084
OutputGenerator::Latex
@ Latex
Definition: outputgen.h:325
FlowChart::text
QCString text
Definition: vhdldocgen.h:343
Entry
Represents an unstructured piece of information, about an entity found in the sources.
Definition: entry.h:63
MemberDef::getGroupDef
virtual const GroupDef * getGroupDef() const =0
g_vhdlKeyDict1
static QDict< QCString > g_vhdlKeyDict1(17, FALSE)
FlowChart::LOOP_NO
@ LOOP_NO
Definition: vhdldocgen.h:285
OutputList::endMemberGroupDocs
void endMemberGroupDocs()
Definition: outputlist.h:210
VhdlDocGen::MISCELLANEOUS
@ MISCELLANEOUS
Definition: vhdldocgen.h:109
FlowChart::TEXT_NO
@ TEXT_NO
Definition: vhdldocgen.h:276
OutputList::startParameterType
void startParameterType(bool first, const char *key)
Definition: outputlist.h:406
QCString::upper
QCString upper() const
Definition: qcstring.cpp:307
VhdlDocGen::GENERIC
@ GENERIC
Definition: vhdldocgen.h:102
FlowChart::writeFlowChart
static void writeFlowChart()
Definition: vhdldocgen.cpp:3620
QListIterator::toFirst
type * toFirst()
Definition: qlist.h:136
OutputList::startTextLink
void startTextLink(const char *file, const char *anchor)
Definition: outputlist.h:139
VhdlDocGen::writeClassType
static bool writeClassType(const ClassDef *, OutputList &ol, QCString &cname)
Definition: vhdldocgen.cpp:2313
OutputList::endTextLink
void endTextLink()
Definition: outputlist.h:141
dec
QTextStream & dec(QTextStream &s)
Definition: qtextstream.cpp:2018
MemberDef::isLinkable
virtual bool isLinkable() const =0
MemberDef::excpString
virtual const char * excpString() const =0
MemberDef::isDetailedSectionLinkable
virtual bool isDetailedSectionLinkable() const =0
VhdlDocGen::CONFIG
@ CONFIG
Definition: vhdldocgen.h:107
FlowChart::alignFuncProc
static void alignFuncProc(QCString &q, const ArgumentList &al, bool isFunc)
Definition: vhdldocgen.cpp:3817
FlowChart::START_NO
@ START_NO
Definition: vhdldocgen.h:277
SDict< ClassDef >::Iterator
friend class Iterator
Definition: sortdict.h:285
splitString
static QCString splitString(QCString &str, char c)
Definition: vhdldocgen.cpp:146
VhdlDocGen::VFILE
@ VFILE
Definition: vhdldocgen.h:105
PlantumlManager::instance
static PlantumlManager * instance()
Definition: plantuml.cpp:119
FlowChart::id
int id
Definition: vhdldocgen.h:336
Entry::args
QCString args
member argument string
Definition: entry.h:257
VhdlDocGen::~VhdlDocGen
virtual ~VhdlDocGen()
Definition: vhdldocgen.cpp:566
OutputList::startMemberGroupHeader
void startMemberGroupHeader(bool b)
Definition: outputlist.h:204
addInstance
static void addInstance(ClassDef *entity, ClassDef *arch, ClassDef *inst, const std::shared_ptr< Entry > &cur)
Definition: vhdldocgen.cpp:2702
uint64
unsigned long long uint64
Definition: qglobal.h:363
SDict< QCString >
OutputList::endMemberList
void endMemberList()
Definition: outputlist.h:186
VhdlDocGen::writeProcedureProto
static void writeProcedureProto(OutputList &ol, const ArgumentList &al, const MemberDef *)
Definition: vhdldocgen.cpp:1419
membersHaveSpecificType
static bool membersHaveSpecificType(const MemberList *ml, uint64 type)
Definition: vhdldocgen.cpp:2229
ENDCL
#define ENDCL
Definition: vhdldocgen.cpp:3024
VhdlDocGen::SUBTYPE
@ SUBTYPE
Definition: vhdldocgen.h:94
MemberDef::isBriefSectionVisible
virtual bool isBriefSectionVisible() const =0
VhdlDocGen::ATTRIBUTE
@ ATTRIBUTE
Definition: vhdldocgen.h:89
QCString::stripPrefix
bool stripPrefix(const char *prefix)
Definition: qcstring.cpp:229
QCString::data
const char * data() const
Returns a pointer to the contents of the string in the form of a 0-terminated C string.
Definition: qcstring.h:209
QCStringList::split
static QCStringList split(const QCString &sep, const QCString &str, bool allowEmptyEntries=FALSE)
Definition: qcstringlist.cpp:55
VhdlDocGen::writeOverview
static void writeOverview()
Definition: vhdldocgen.cpp:179
Entry::doc
QCString doc
documentation block (partly parsed)
Definition: entry.h:265
Entry::fileName
QCString fileName
file this entry was extracted from
Definition: entry.h:288
OutputList::endMemberHeader
void endMemberHeader()
Definition: outputlist.h:174
QCString::prepend
QCString & prepend(const char *s)
Definition: qcstring.cpp:415
FlowChart::buildCommentNodes
static void buildCommentNodes(FTextStream &t)
Definition: vhdldocgen.cpp:3276
FlowChart::~FlowChart
~FlowChart()
Definition: vhdldocgen.cpp:3381
FlowChart::findNode
static int findNode(int index, int stamp, int type)
Definition: vhdldocgen.cpp:3904
comment
const char * comment
Definition: vhdldocgen.cpp:3044
layout.h
decisionNode
const char * decisionNode
Definition: vhdldocgen.cpp:3045
FlowChart::codify
static void codify(FTextStream &t, const char *str)
Definition: vhdldocgen.cpp:3358
MemberDef::setType
virtual void setType(const char *t)=0
definition.h
g_vhdlKeyDict3
static QDict< QCString > g_vhdlKeyDict3(17, FALSE)
VhdlDocGen::isGeneric
static bool isGeneric(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2963
FlowChart::convertNameToFileName
static QCString convertNameToFileName()
Definition: vhdldocgen.cpp:3535
VhdlDocGen::createFlowChart
static void createFlowChart(const MemberDef *)
Definition: vhdldocgen.cpp:2914
CodeParserInterface
Abstract interface for code parsers.
Definition: parserintf.h:101
MemberDef::getMemberSpecifiers
virtual uint64 getMemberSpecifiers() const =0
Entry::docFile
QCString docFile
file in which the documentation was found
Definition: entry.h:267
VhdlDocGen::FUNCTION
@ FUNCTION
Definition: vhdldocgen.h:95
startDot
static void startDot(FTextStream &t)
Definition: vhdldocgen.cpp:262
MemberDef::getFileDef
virtual const FileDef * getFileDef() const =0
VhdlDocGen::writeInlineClassLink
static void writeInlineClassLink(const ClassDef *, OutputList &ol)
Definition: vhdldocgen.cpp:966
VhdlDocGen::isAlias
static bool isAlias(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2959
QMapIterator::key
const K & key() const
Definition: qmap.h:114
QCString::copy
QCString copy() const
Returns a deep copy of the string.
Definition: qcstring.h:252
qPrint
const char * qPrint(const char *s)
Definition: qcstring.h:800
VhdlParser.h
MemberGroup::members
MemberList * members() const
Definition: membergroup.h:85
FlowChart::moveToPrevLevel
static void moveToPrevLevel()
Definition: vhdldocgen.cpp:3447
OutputList::endParameterType
void endParameterType()
Definition: outputlist.h:408
nodeCounter
static int nodeCounter
Definition: vhdldocgen.cpp:3034
FlowChart::endDot
static void endDot(FTextStream &t)
Definition: vhdldocgen.cpp:3615
VhdlDocGen::VhdlDocGen
VhdlDocGen()
Definition: vhdldocgen.cpp:562
startEndNode
const char * startEndNode
Definition: vhdldocgen.cpp:3047
Config_getBool
#define Config_getBool(val)
Definition: config.h:35
OutputList::startParameterList
void startParameterList(bool openBracket)
Definition: outputlist.h:414
OutputList
Class representing a list of output generators that are written to in parallel.
Definition: outputlist.h:38
VhdlDocGen::isProcess
static bool isProcess(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2981
VhdlDocGen::INSTANTIATION
@ INSTANTIATION
Definition: vhdldocgen.h:103
QList::prepend
void prepend(const type *d)
Definition: qlist.h:72
ClassDef::insertMember
virtual void insertMember(MemberDef *)=0
OutputList::startMemberGroupDocs
void startMemberGroupDocs()
Definition: outputlist.h:208
VhdlDocGen::findKeyWord
static QCString * findKeyWord(const QCString &word)
Definition: vhdldocgen.cpp:667
VhdlDocGen::isUnit
static bool isUnit(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2995
FlowChart::colTextNodes
static void colTextNodes()
Definition: vhdldocgen.cpp:3172
Entry::section
int section
entry type (see Sections);
Definition: entry.h:236
groupdef.h
VhdlDocGen::prepareComment
static void prepareComment(QCString &)
Definition: vhdldocgen.cpp:1108
VhdlDocGen::isConstant
static bool isConstant(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2973
OutputList::enable
void enable(OutputGenerator::OutputType o)
Definition: outputlist.cpp:80
VhdlDocGen::deleteAllChars
static void deleteAllChars(QCString &s, char c)
Definition: vhdldocgen.cpp:1226
qstrcmp
int qstrcmp(const char *str1, const char *str2)
Definition: qcstring.h:97
VhdlDocGen::computeVhdlComponentRelations
static void computeVhdlComponentRelations()
Definition: vhdldocgen.cpp:2662
VhdlDocGen::findFunction
static MemberDef * findFunction(const QCString &name, const QCString &package)
Definition: vhdldocgen.cpp:904
OutputList::insertMemberAlignLeft
void insertMemberAlignLeft(int typ=0, bool templ=FALSE)
Definition: outputlist.h:218
MemberDef::warnIfUndocumented
virtual void warnIfUndocumented() const =0
QValueList::append
Iterator append(const T &x)
Definition: qvaluelist.h:368
BaseClassDef::templSpecifiers
QCString templSpecifiers
Template arguments used for the base class.
Definition: classdef.h:511
VhdlDocGen::findMember
static MemberDef * findMember(const QCString &className, const QCString &memName)
Definition: vhdldocgen.cpp:717
plantuml.h
SrcLangExt_VHDL
@ SrcLangExt_VHDL
Definition: types.h:55
ASSERT
#define ASSERT(x)
Definition: qglobal.h:591
VhdlDocGen::UCF_CONST
@ UCF_CONST
Definition: vhdldocgen.h:110
VhdlDocGen::getProcessNumber
static QCString getProcessNumber()
Definition: vhdldocgen.cpp:1256
OutputList::endEmphasis
void endEmphasis()
Definition: outputlist.h:237
VhdlDocGen::getIndexWord
static QCString getIndexWord(const char *, int index)
Definition: vhdldocgen.cpp:1179
EXITNEXT
#define EXITNEXT
Definition: vhdldocgen.cpp:3027
DECLN
#define DECLN
Definition: vhdldocgen.cpp:3017
VhdlDocGen::writeTagFile
static void writeTagFile(MemberDef *mdef, FTextStream &tagFile)
Definition: vhdldocgen.cpp:1852
Definition::name
virtual QCString name() const =0
OutputList::startMemberSubtitle
void startMemberSubtitle()
Definition: outputlist.h:176
VhdlDocGen::writeVHDLDeclaration
static void writeVHDLDeclaration(const MemberDef *mdef, OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, bool inGroup)
Definition: vhdldocgen.cpp:1896
FlowChart::getNextNode
static int getNextNode(int, int)
Definition: vhdldocgen.cpp:3917
ClassDef::getFileDef
virtual FileDef * getFileDef() const =0
Returns the file in which this compound's definition can be found.
OutputList::writeChar
void writeChar(char c)
Definition: outputlist.h:239
OutputList::writeString
void writeString(const char *text)
Definition: outputlist.h:99
substitute
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition: util.cpp:4606
Definition::briefDescriptionAsTooltip
virtual QCString briefDescriptionAsTooltip() const =0
QValueList::last
T & last()
Definition: qvaluelist.h:376
languages.tmp
string tmp
Definition: languages.py:63
portable.h
Portable versions of functions that are platform dependent.
endl
QTextStream & endl(QTextStream &s)
Definition: qtextstream.cpp:2030
VhdlDocGen::parseFuncProto
static void parseFuncProto(const char *text, QCString &name, QCString &ret, bool doc=false)
Definition: vhdldocgen.cpp:1130
VhdlDocGen::isSignals
static bool isSignals(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2987
QDict< QCString >
searchindex.h
ClassDef::className
virtual QCString className() const =0
Returns the name of the class including outer classes, but not including namespaces.
Definition::getStartBodyLine
virtual int getStartBodyLine() const =0
VhdlDocGen::isCompInst
static bool isCompInst(const MemberDef *mdef)
Definition: vhdldocgen.cpp:3005
OutputList::lineBreak
void lineBreak(const char *style=0)
Definition: outputlist.h:283
VhdlDocGen::writeFormatString
static void writeFormatString(const QCString &, OutputList &ol, const MemberDef *)
Definition: vhdldocgen.cpp:1270
OutputList::startCodeFragment
void startCodeFragment()
Definition: outputlist.h:224
OutputList::isEnabled
bool isEnabled(OutputGenerator::OutputType o)
Definition: outputlist.cpp:88
VhdlDocGen::UNITS
@ UNITS
Definition: vhdldocgen.h:101
PlantumlManager::writePlantUMLSource
QCString writePlantUMLSource(const QCString &outDir, const QCString &fileName, const QCString &content, OutputFormat format)
Write a PlantUML compatible file.
Definition: plantuml.cpp:30
ClassDef::templateMaster
virtual const ClassDef * templateMaster() const =0
Returns the template master of which this class is an instance.
writeVhdlDotLink
static void writeVhdlDotLink(FTextStream &t, const QCString &a, const QCString &b, const QCString &style)
Definition: vhdldocgen.cpp:281
OutputList::startDoxyAnchor
void startDoxyAnchor(const char *fName, const char *manName, const char *anchor, const char *name, const char *args)
Definition: outputlist.h:247
TagInfo::fileName
QCString fileName
Definition: entry.h:52
Definition::writeSourceRefs
virtual void writeSourceRefs(OutputList &ol, const char *scopeName) const =0
endDot
static void endDot(FTextStream &t)
Definition: vhdldocgen.cpp:270
STARTL
#define STARTL
Definition: vhdldocgen.cpp:3014
util.h
Copyright (C) 1997-2015 by Dimitri van Heesch.
OutputList::startMemberHeader
void startMemberHeader(const char *anchor, int typ=2)
Definition: outputlist.h:172
EEND
#define EEND
Definition: vhdldocgen.cpp:3025
Definition::briefLine
virtual int briefLine() const =0
QValueList::count
uint count() const
Definition: qvaluelist.h:390
FlowChart::END_NO
@ END_NO
Definition: vhdldocgen.h:275
FlowChart::startDot
static void startDot(FTextStream &t)
Definition: vhdldocgen.cpp:3607
Entry::lang
SrcLangExt lang
programming language in which this entry was found
Definition: entry.h:292
SDict::find
T * find(const char *key)
Definition: sortdict.h:232
QFile::close
void close()
Definition: qfile_unix.cpp:614
VhdlDocGen::parseUCF
static void parseUCF(const char *input, Entry *entity, QCString f, bool vendor)
Definition: vhdldocgen.cpp:2429
SearchIndexIntf::setCurrentDoc
virtual void setCurrentDoc(const Definition *ctx, const char *anchor, bool isSourceFile)=0
VhdlDocGen::findAllPackages
static void findAllPackages(ClassDef *)
Definition: vhdldocgen.cpp:873
VhdlDocGen::isVType
static bool isVType(const MemberDef *mdef)
Definition: vhdldocgen.cpp:2975
FlowChart::label
QCString label
Definition: vhdldocgen.h:342
ClassDef::getOutputFileBase
virtual QCString getOutputFileBase() const =0
Returns the unique base name (without extension) of the class's file on disk.
Definition::setBodySegment
virtual void setBodySegment(int defLine, int bls, int ble)=0
QCString::fill
bool fill(char c, int len=-1)
Fills a string with a predefined character.
Definition: qcstring.h:245
qstrlen
uint qstrlen(const char *str)
Definition: qcstring.h:83
qli
static QList< ClassDef > qli
Definition: vhdldocgen.cpp:714
OutputList::startMemberList
void startMemberList()
Definition: outputlist.h:184
getPorts
static QList< MemberDef > * getPorts(ClassDef *cd)
Definition: vhdldocgen.cpp:470
MemberList
A list of MemberDef objects.
Definition: memberlist.h:32
SearchIndexIntf::addWord
virtual void addWord(const char *word, bool hiPriority)=0
vhdljjparser.h
vhdldocgen.h
QFile
The QFile class is an I/O device that operates on files.
Definition: qfile.h:51
MemberDef::setMemberSpecifiers
virtual void setMemberSpecifiers(uint64 s)=0
FlowChart::findPrevLoop
static int findPrevLoop(int j, int stamp, bool endif=FALSE)
Definition: vhdldocgen.cpp:3867
MemberDef::argsString
virtual const char * argsString() const =0
VhdlDocGen::writeProcessProto
static void writeProcessProto(OutputList &ol, const ArgumentList &al, const MemberDef *)
Definition: vhdldocgen.cpp:1552
FileDef::absFilePath
virtual QCString absFilePath() const =0
EMPTNODE
#define EMPTNODE
Definition: vhdldocgen.cpp:3030
QRegExp::match
int match(const QCString &str, int index=0, int *len=0, bool indexIsStart=TRUE) const
Definition: qregexp.cpp:649
ClassDef::getMemberList
virtual MemberList * getMemberList(MemberListType lt) const =0
Returns the members in the list identified by lt.