Collaboration diagram for PerlModGenerator:

Public Member Functions
	PerlModGenerator (bool pretty)
void	generatePerlModForMember (const MemberDef md, const Definition )
void	generatePerlUserDefinedSection (const Definition *d, const MemberGroupList &mgl)
void	generatePerlModSection (const Definition d, MemberList ml, const QCString &name, const QCString &header=QCString())
void	addListOfAllMembers (const ClassDef *cd)
void	addIncludeInfo (const IncludeInfo *ii)
void	generatePerlModForClass (const ClassDef *cd)
void	generatePerlModForConcept (const ConceptDef *cd)
void	generatePerlModForModule (const ModuleDef *mod)
void	generatePerlModForNamespace (const NamespaceDef *nd)
void	generatePerlModForFile (const FileDef *fd)
void	generatePerlModForGroup (const GroupDef *gd)
void	generatePerlModForPage (PageDef *pi)
bool	createOutputFile (std::ofstream &f, const QCString &s)
bool	createOutputDir (Dir &perlModDir)
bool	generateDoxyLatexTex ()
bool	generateDoxyFormatTex ()
bool	generateDoxyStructurePM ()
bool	generateDoxyLatexPL ()
bool	generateDoxyLatexStructurePL ()
bool	generateDoxyRules ()
bool	generateMakefile ()
bool	generatePerlModOutput ()
void	generate ()

Detailed Description

Definition at line 1420 of file perlmodgen.cpp.

Constructor & Destructor Documentation

◆ PerlModGenerator()

PerlModGenerator::PerlModGenerator ( bool pretty )

inline

Definition at line 1439 of file perlmodgen.cpp.

1439: m_output(pretty) { }

PerlModGenerator::m_output

PerlModOutput m_output

Definition perlmodgen.cpp:1424

References m_output.

Member Function Documentation

◆ addIncludeInfo()

void PerlModGenerator::addIncludeInfo ( const IncludeInfo * ii )

Definition at line 1717 of file perlmodgen.cpp.

{
  if (ii)
  {
    QCString nm = ii->includeName;
    if (nm.isEmpty() && ii->fileDef) nm = ii->fileDef->docName();
    if (!nm.isEmpty())
    {
      m_output.openHash("includes");
      m_output.addFieldBoolean("local", ii->kind==IncludeKind::IncludeLocal || ii->kind==IncludeKind::ImportLocal)
        .addFieldQuotedString("name", nm)
        .closeHash();
    }
  }
}

References FileDef::docName(), IncludeInfo::fileDef, ImportLocal, IncludeLocal, IncludeInfo::includeName, QCString::isEmpty(), IncludeInfo::kind, and m_output.

Referenced by generatePerlModForClass(), and generatePerlModForConcept().

◆ addListOfAllMembers()

void PerlModGenerator::addListOfAllMembers ( const ClassDef * cd )

Definition at line 1664 of file perlmodgen.cpp.

{
  m_output.openList("all_members");
  for (auto &mni : cd->memberNameInfoLinkedMap())
  {
    for (auto &mi : *mni)
    {
      const MemberDef *md=mi->memberDef();
      const ClassDef  *mcd=md->getClassDef();
 
      m_output.openHash()
        .addFieldQuotedString("name", md->name())
        .addFieldQuotedString("virtualness", getVirtualnessName(md->virtualness()))
        .addFieldQuotedString("protection", getProtectionName(mi->prot()));
 
      if (!mi->ambiguityResolutionScope().isEmpty())
        m_output.addFieldQuotedString("ambiguity_scope", mi->ambiguityResolutionScope());
 
      m_output.addFieldQuotedString("scope", mcd->name())
        .closeHash();
    }
  }
  m_output.closeList();
}

References MemberDef::getClassDef(), getProtectionName(), getVirtualnessName(), m_output, ClassDef::memberNameInfoLinkedMap(), Definition::name(), and MemberDef::virtualness().

Referenced by generatePerlModForClass().

◆ createOutputDir()

bool PerlModGenerator::createOutputDir ( Dir & perlModDir )

Definition at line 2246 of file perlmodgen.cpp.

{
  std::string outputDirectory = Config_getString(OUTPUT_DIRECTORY).str();
  perlModDir.setPath(outputDirectory+"/perlmod");
  if (!perlModDir.exists() && !perlModDir.mkdir(outputDirectory+"/perlmod"))
  {
    err("Could not create perlmod directory in {}\n",outputDirectory);
    return false;
  }
  return true;
}

References Config_getString, err, Dir::exists(), Dir::mkdir(), and Dir::setPath().

Referenced by generate().

◆ createOutputFile()

bool PerlModGenerator::createOutputFile	(	std::ofstream &	f,
		const QCString &	s )

Definition at line 2235 of file perlmodgen.cpp.

{
  f = Portable::openOutputStream(s);
  if (!f.is_open())
  {
    err("Cannot open file {} for writing!\n", s);
    return false;
  }
  return true;
}

References err, and Portable::openOutputStream().

Referenced by generateDoxyFormatTex(), generateDoxyLatexPL(), generateDoxyLatexStructurePL(), generateDoxyLatexTex(), generateDoxyRules(), generateDoxyStructurePM(), generateMakefile(), and generatePerlModOutput().

◆ generate()

void PerlModGenerator::generate ( )

Definition at line 2905 of file perlmodgen.cpp.

{
  // + classes
  // + namespaces
  // + files
  // - packages
  // + groups
  // + related pages
  // - examples
 
  Dir perlModDir;
  if (!createOutputDir(perlModDir))
    return;
 
  bool perlmodLatex = Config_getBool(PERLMOD_LATEX);
 
  QCString perlModAbsPath = perlModDir.absPath();
  pathDoxyDocsPM = perlModAbsPath + "/DoxyDocs.pm";
  pathDoxyStructurePM = perlModAbsPath + "/DoxyStructure.pm";
  pathMakefile = perlModAbsPath + "/Makefile";
  pathDoxyRules = perlModAbsPath + "/doxyrules.make";
 
  if (perlmodLatex) {
    pathDoxyStructureTex = perlModAbsPath + "/doxystructure.tex";
    pathDoxyFormatTex = perlModAbsPath + "/doxyformat.tex";
    pathDoxyLatexTex = perlModAbsPath + "/doxylatex.tex";
    pathDoxyLatexDVI = perlModAbsPath + "/doxylatex.dvi";
    pathDoxyLatexPDF = perlModAbsPath + "/doxylatex.pdf";
    pathDoxyDocsTex = perlModAbsPath + "/doxydocs.tex";
    pathDoxyLatexPL = perlModAbsPath + "/doxylatex.pl";
    pathDoxyLatexStructurePL = perlModAbsPath + "/doxylatex-structure.pl";
  }
 
  if (!(generatePerlModOutput()
        && generateDoxyStructurePM()
        && generateMakefile()
        && generateDoxyRules()))
    return;
 
  if (perlmodLatex) {
    if (!(generateDoxyLatexStructurePL()
          && generateDoxyLatexPL()
          && generateDoxyLatexTex()
          && generateDoxyFormatTex()))
      return;
  }
}

References Dir::absPath(), Config_getBool, createOutputDir(), generateDoxyFormatTex(), generateDoxyLatexPL(), generateDoxyLatexStructurePL(), generateDoxyLatexTex(), generateDoxyRules(), generateDoxyStructurePM(), generateMakefile(), generatePerlModOutput(), pathDoxyDocsPM, pathDoxyDocsTex, pathDoxyFormatTex, pathDoxyLatexDVI, pathDoxyLatexPDF, pathDoxyLatexPL, pathDoxyLatexStructurePL, pathDoxyLatexTex, pathDoxyRules, pathDoxyStructurePM, pathDoxyStructureTex, and pathMakefile.

Referenced by generatePerlMod().

◆ generateDoxyFormatTex()

bool PerlModGenerator::generateDoxyFormatTex ( )

Definition at line 2718 of file perlmodgen.cpp.

{
  std::ofstream doxyFormatTexStream;
  if (!createOutputFile(doxyFormatTexStream, pathDoxyFormatTex))
    return false;
 
  doxyFormatTexStream <<
    "\\def\\Defcs#1{\\long\\expandafter\\def\\csname#1\\endcsname}\n"
    "\\Defcs{Empty}{}\n"
    "\\def\\IfEmpty#1{\\expandafter\\ifx\\csname#1\\endcsname\\Empty}\n"
    "\n"
    "\\def\\StringNode#1{\\Defcs{#1}##1{##1}}\n"
    "\\def\\DocNode#1{\\Defcs{#1}##1{##1}}\n"
    "\\def\\ListNode#1{\\Defcs{#1}##1{##1}\\Defcs{#1Sep}{}}\n"
    "\\def\\HashNode#1{\\Defcs{#1}{}}\n"
    "\n"
    "\\input{" << pathDoxyStructureTex << "}\n"
    "\n"
    "\\newbox\\BoxA\n"
    "\\dimendef\\DimenA=151\\relax\n"
    "\\dimendef\\DimenB=152\\relax\n"
    "\\countdef\\ZoneDepth=151\\relax\n"
    "\n"
    "\\def\\Cs#1{\\csname#1\\endcsname}\n"
    "\\def\\Letcs#1{\\expandafter\\let\\csname#1\\endcsname}\n"
    "\\def\\Heading#1{\\vskip 4mm\\relax\\textbf{#1}}\n"
    "\\def\\See#1{\\begin{flushleft}\\Heading{See also: }#1\\end{flushleft}}\n"
    "\n"
    "\\def\\Frame#1{\\vskip 3mm\\relax\\fbox{ \\vbox{\\hsize0.95\\hsize\\vskip 1mm\\relax\n"
    "\\raggedright#1\\vskip 0.5mm\\relax} }}\n"
    "\n"
    "\\def\\Zone#1#2#3{%\n"
    "\\Defcs{Test#1}{#2}%\n"
    "\\Defcs{Emit#1}{#3}%\n"
    "\\Defcs{#1}{%\n"
    "\\advance\\ZoneDepth1\\relax\n"
    "\\Letcs{Mode\\number\\ZoneDepth}0\\relax\n"
    "\\Letcs{Present\\number\\ZoneDepth}0\\relax\n"
    "\\Cs{Test#1}\n"
    "\\expandafter\\if\\Cs{Present\\number\\ZoneDepth}1%\n"
    "\\advance\\ZoneDepth-1\\relax\n"
    "\\Letcs{Present\\number\\ZoneDepth}1\\relax\n"
    "\\expandafter\\if\\Cs{Mode\\number\\ZoneDepth}1%\n"
    "\\advance\\ZoneDepth1\\relax\n"
    "\\Letcs{Mode\\number\\ZoneDepth}1\\relax\n"
    "\\Cs{Emit#1}\n"
    "\\advance\\ZoneDepth-1\\relax\\fi\n"
    "\\advance\\ZoneDepth1\\relax\\fi\n"
    "\\advance\\ZoneDepth-1\\relax}}\n"
    "\n"
    "\\def\\Member#1#2{%\n"
    "\\Defcs{Test#1}{\\Cs{field#1Detailed}\n"
    "\\IfEmpty{field#1DetailedDoc}\\else\\Letcs{Present#1}1\\fi}\n"
    "\\Defcs{#1}{\\Letcs{Present#1}0\\relax\n"
    "\\Cs{Test#1}\\if1\\Cs{Present#1}\\Letcs{Present\\number\\ZoneDepth}1\\relax\n"
    "\\if1\\Cs{Mode\\number\\ZoneDepth}#2\\fi\\fi}}\n"
    "\n"
    "\\def\\TypedefMemberList#1#2{%\n"
    "\\Defcs{#1DetailedDoc}##1{\\vskip 5.5mm\\relax##1}%\n"
    "\\Defcs{#1Name}##1{\\textbf{##1}}%\n"
    "\\Defcs{#1See}##1{\\See{##1}}%\n"
    "%\n"
    "\\Zone{#1s}{\\Cs{field#1List}}{\\subsubsection{#2}\\Cs{field#1List}}%\n"
    "\\Member{#1}{\\Frame{typedef \\Cs{field#1Type} \\Cs{field#1Name}}%\n"
    "\\Cs{field#1DetailedDoc}\\Cs{field#1See}\\vskip 5mm\\relax}}%\n"
    "\n"
    "\\def\\VariableMemberList#1#2{%\n"
    "\\Defcs{#1DetailedDoc}##1{\\vskip 5.5mm\\relax##1}%\n"
    "\\Defcs{#1Name}##1{\\textbf{##1}}%\n"
    "\\Defcs{#1See}##1{\\See{##1}}%\n"
    "%\n"
    "\\Zone{#1s}{\\Cs{field#1List}}{\\subsubsection{#2}\\Cs{field#1List}}%\n"
    "\\Member{#1}{\\Frame{\\Cs{field#1Type}{} \\Cs{field#1Name}}%\n"
    "\\Cs{field#1DetailedDoc}\\Cs{field#1See}\\vskip 5mm\\relax}}%\n"
    "\n"
    "\\def\\FunctionMemberList#1#2{%\n"
    "\\Defcs{#1PDParamName}##1{\\textit{##1}}%\n"
    "\\Defcs{#1PDParam}{\\Cs{field#1PDParamName}}%\n"
    "\\Defcs{#1PDParamsSep}{, }%\n"
    "\\Defcs{#1PDBlocksSep}{\\vskip 2mm\\relax}%\n"
    "%\n"
    "\\Defcs{#1PDBlocks}##1{%\n"
    "\\Heading{Parameters:}\\vskip 1.5mm\\relax\n"
    "\\DimenA0pt\\relax\n"
    "\\Defcs{#1PDBlock}{\\setbox\\BoxA\\hbox{\\Cs{field#1PDParams}}%\n"
    "\\ifdim\\DimenA<\\wd\\BoxA\\DimenA\\wd\\BoxA\\fi}%\n"
    "##1%\n"
    "\\advance\\DimenA3mm\\relax\n"
    "\\DimenB\\hsize\\advance\\DimenB-\\DimenA\\relax\n"
    "\\Defcs{#1PDBlock}{\\hbox to\\hsize{\\vtop{\\hsize\\DimenA\\relax\n"
    "\\Cs{field#1PDParams}}\\hfill\n"
    "\\vtop{\\hsize\\DimenB\\relax\\Cs{field#1PDDoc}}}}%\n"
    "##1}\n"
    "\n"
    "\\Defcs{#1ParamName}##1{\\textit{##1}}\n"
    "\\Defcs{#1Param}{\\Cs{field#1ParamType}{} \\Cs{field#1ParamName}}\n"
    "\\Defcs{#1ParamsSep}{, }\n"
    "\n"
    "\\Defcs{#1Name}##1{\\textbf{##1}}\n"
    "\\Defcs{#1See}##1{\\See{##1}}\n"
    "\\Defcs{#1Return}##1{\\Heading{Returns: }##1}\n"
    "\\Defcs{field#1Title}{\\Frame{\\Cs{field#1Type}{} \\Cs{field#1Name}(\\Cs{field#1Params})}}%\n"
    "%\n"
    "\\Zone{#1s}{\\Cs{field#1List}}{\\subsubsection{#2}\\Cs{field#1List}}%\n"
    "\\Member{#1}{%\n"
    "\\Cs{field#1Title}\\vskip 6mm\\relax\\Cs{field#1DetailedDoc}\n"
    "\\Cs{field#1Return}\\Cs{field#1PDBlocks}\\Cs{field#1See}\\vskip 5mm\\relax}}\n"
    "\n"
    "\\def\\FileDetailed{\\fieldFileDetailedDoc\\par}\n"
    "\\def\\ClassDetailed{\\fieldClassDetailedDoc\\par}\n"
    "\n"
    "\\def\\FileSubzones{\\fieldFileTypedefs\\fieldFileVariables\\fieldFileFunctions}\n"
    "\n"
    "\\def\\ClassSubzones{%\n"
    "\\fieldClassPublicTypedefs\\fieldClassPublicMembers\\fieldClassPublicMethods\n"
    "\\fieldClassProtectedTypedefs\\fieldClassProtectedMembers\\fieldClassProtectedMethods\n"
    "\\fieldClassPrivateTypedefs\\fieldClassPrivateMembers\\fieldClassPrivateMethods}\n"
    "\n"
    "\\Member{Page}{\\subsection{\\fieldPageName}\\fieldPageDetailedDoc}\n"
    "\n"
    "\\TypedefMemberList{FileTypedef}{Typedefs}\n"
    "\\VariableMemberList{FileVariable}{Variables}\n"
    "\\FunctionMemberList{FileFunction}{Functions}\n"
    "\\Zone{File}{\\FileSubzones}{\\subsection{\\fieldFileName}\\fieldFileDetailed\\FileSubzones}\n"
    "\n"
    "\\TypedefMemberList{ClassPublicTypedef}{Public Typedefs}\n"
    "\\TypedefMemberList{ClassProtectedTypedef}{Protected Typedefs}\n"
    "\\TypedefMemberList{ClassPrivateTypedef}{Private Typedefs}\n"
    "\\VariableMemberList{ClassPublicMember}{Public Members}\n"
    "\\VariableMemberList{ClassProtectedMember}{Protected Members}\n"
    "\\VariableMemberList{ClassPrivateMember}{Private Members}\n"
    "\\FunctionMemberList{ClassPublicMethod}{Public Methods}\n"
    "\\FunctionMemberList{ClassProtectedMethod}{Protected Methods}\n"
    "\\FunctionMemberList{ClassPrivateMethod}{Private Methods}\n"
    "\\Zone{Class}{\\ClassSubzones}{\\subsection{\\fieldClassName}\\fieldClassDetailed\\ClassSubzones}\n"
    "\n"
    "\\Zone{AllPages}{\\fieldPages}{\\section{Pages}\\fieldPages}\n"
    "\\Zone{AllFiles}{\\fieldFiles}{\\section{Files}\\fieldFiles}\n"
    "\\Zone{AllClasses}{\\fieldClasses}{\\section{Classes}\\fieldClasses}\n"
    "\n"
    "\\newlength{\\oldparskip}\n"
    "\\newlength{\\oldparindent}\n"
    "\\newlength{\\oldfboxrule}\n"
    "\n"
    "\\ZoneDepth0\\relax\n"
    "\\Letcs{Mode0}1\\relax\n"
    "\n"
    "\\def\\EmitDoxyDocs{%\n"
    "\\setlength{\\oldparskip}{\\parskip}\n"
    "\\setlength{\\oldparindent}{\\parindent}\n"
    "\\setlength{\\oldfboxrule}{\\fboxrule}\n"
    "\\setlength{\\parskip}{0cm}\n"
    "\\setlength{\\parindent}{0cm}\n"
    "\\setlength{\\fboxrule}{1pt}\n"
    "\\AllPages\\AllFiles\\AllClasses\n"
    "\\setlength{\\parskip}{\\oldparskip}\n"
    "\\setlength{\\parindent}{\\oldparindent}\n"
    "\\setlength{\\fboxrule}{\\oldfboxrule}}\n";
 
  return true;
}

References createOutputFile(), pathDoxyFormatTex, and pathDoxyStructureTex.

Referenced by generate().

◆ generateDoxyLatexPL()

bool PerlModGenerator::generateDoxyLatexPL ( )

Definition at line 2596 of file perlmodgen.cpp.

{
  std::ofstream doxyLatexPLStream;
  if (!createOutputFile(doxyLatexPLStream, pathDoxyLatexPL))
    return false;
 
  doxyLatexPLStream <<
    "use DoxyStructure;\n"
    "use DoxyDocs;\n"
    "\n"
    "sub latex_quote($) {\n"
    "\tmy $text = $_[0];\n"
    "\t$text =~ s/\\\\/\\\\textbackslash /g;\n"
    "\t$text =~ s/\\|/\\\\textbar /g;\n"
    "\t$text =~ s/</\\\\textless /g;\n"
    "\t$text =~ s/>/\\\\textgreater /g;\n"
    "\t$text =~ s/~/\\\\textasciitilde /g;\n"
    "\t$text =~ s/\\^/\\\\textasciicircum /g;\n"
    "\t$text =~ s/[\\$&%#_{}]/\\\\$&/g;\n"
    "\tprint $text;\n"
    "}\n"
    "\n"
    "sub generate_doc($) {\n"
    "\tmy $doc = $_[0];\n"
    "\tfor my $item (@$doc) {\n"
    "\t\tmy $type = $$item{type};\n"
    "\t\tif ($type eq \"text\") {\n"
    "\t\t\tlatex_quote($$item{content});\n"
    "\t\t} elsif ($type eq \"parbreak\") {\n"
    "\t\t\tprint \"\\n\\n\";\n"
    "\t\t} elsif ($type eq \"style\") {\n"
    "\t\t\tmy $style = $$item{style};\n"
    "\t\t\tif ($$item{enable} eq \"yes\") {\n"
    "\t\t\t\tif ($style eq \"bold\") { print '\\bfseries'; }\n"
    "\t\t\t\tif ($style eq \"italic\") { print '\\itshape'; }\n"
    "\t\t\t\tif ($style eq \"code\") { print '\\ttfamily'; }\n"
    "\t\t\t} else {\n"
    "\t\t\t\tif ($style eq \"bold\") { print '\\mdseries'; }\n"
    "\t\t\t\tif ($style eq \"italic\") { print '\\upshape'; }\n"
    "\t\t\t\tif ($style eq \"code\") { print '\\rmfamily'; }\n"
    "\t\t\t}\n"
    "\t\t\tprint '{}';\n"
    "\t\t} elsif ($type eq \"symbol\") {\n"
    "\t\t\tmy $symbol = $$item{symbol};\n"
    "\t\t\tif ($symbol eq \"copyright\") { print '\\copyright'; }\n"
    "\t\t\telsif ($symbol eq \"szlig\") { print '\\ss'; }\n"
    "\t\t\tprint '{}';\n"
    "\t\t} elsif ($type eq \"accent\") {\n"
    "\t\t\tmy ($accent) = $$item{accent};\n"
    "\t\t\tif ($accent eq \"umlaut\") { print '\\\"'; }\n"
    "\t\t\telsif ($accent eq \"acute\") { print '\\\\\\''; }\n"
    "\t\t\telsif ($accent eq \"grave\") { print '\\`'; }\n"
    "\t\t\telsif ($accent eq \"circ\") { print '\\^'; }\n"
    "\t\t\telsif ($accent eq \"tilde\") { print '\\~'; }\n"
    "\t\t\telsif ($accent eq \"cedilla\") { print '\\c'; }\n"
    "\t\t\telsif ($accent eq \"ring\") { print '\\r'; }\n"
    "\t\t\tprint \"{\" . $$item{letter} . \"}\"; \n"
    "\t\t} elsif ($type eq \"list\") {\n"
    "\t\t\tmy $env = ($$item{style} eq \"ordered\") ? \"enumerate\" : \"itemize\";\n"
    "\t\t\tprint \"\\n\\\\begin{\" . $env .\"}\";\n"
    "\t\t  \tfor my $subitem (@{$$item{content}}) {\n"
    "\t\t\t\tprint \"\\n\\\\item \";\n"
    "\t\t\t\tgenerate_doc($subitem);\n"
    "\t\t  \t}\n"
    "\t\t\tprint \"\\n\\\\end{\" . $env .\"}\";\n"
    "\t\t} elsif ($type eq \"url\") {\n"
    "\t\t\tlatex_quote($$item{content});\n"
    "\t\t}\n"
    "\t}\n"
    "}\n"
    "\n"
    "sub generate($$) {\n"
    "\tmy ($item, $node) = @_;\n"
    "\tmy ($type, $name) = @$node[0, 1];\n"
    "\tif ($type eq \"string\") {\n"
    "\t\tprint \"\\\\\" . $name . \"{\";\n"
    "\t\tlatex_quote($item);\n"
    "\t\tprint \"}\";\n"
    "\t} elsif ($type eq \"doc\") {\n"
    "\t\tif (@$item) {\n"
    "\t\t\tprint \"\\\\\" . $name . \"{\";\n"
    "\t\t\tgenerate_doc($item);\n"
    "\t\t\tprint \"}%\\n\";\n"
    "\t\t} else {\n"
    "#\t\t\tprint \"\\\\\" . $name . \"Empty%\\n\";\n"
    "\t\t}\n"
    "\t} elsif ($type eq \"hash\") {\n"
    "\t\tmy ($key, $value);\n"
    "\t\twhile (($key, $subnode) = each %{$$node[2]}) {\n"
    "\t\t\tmy $subname = $$subnode[1];\n"
    "\t\t\tprint \"\\\\Defcs{field\" . $subname . \"}{\";\n"
    "\t\t\tif ($$item{$key}) {\n"
    "\t\t\t\tgenerate($$item{$key}, $subnode);\n"
    "\t\t\t} else {\n"
    "#\t\t\t\t\tprint \"\\\\\" . $subname . \"Empty%\\n\";\n"
    "\t\t\t}\n"
    "\t\t\tprint \"}%\\n\";\n"
    "\t\t}\n"
    "\t\tprint \"\\\\\" . $name . \"%\\n\";\n"
    "\t} elsif ($type eq \"list\") {\n"
    "\t\tmy $index = 0;\n"
    "\t\tif (@$item) {\n"
    "\t\t\tprint \"\\\\\" . $name . \"{%\\n\";\n"
    "\t\t\tfor my $subitem (@$item) {\n"
    "\t\t\t\tif ($index) {\n"
    "\t\t\t\t\tprint \"\\\\\" . $name . \"Sep%\\n\";\n"
    "\t\t\t\t}\n"
    "\t\t\t\tgenerate($subitem, $$node[2]);\n"
    "\t\t\t\t$index++;\n"
    "\t\t\t}\n"
    "\t\t\tprint \"}%\\n\";\n"
    "\t\t} else {\n"
    "#\t\t\tprint \"\\\\\" . $name . \"Empty%\\n\";\n"
    "\t\t}\n"
    "\t}\n"
    "}\n"
    "\n"
    "generate($doxydocs, $doxystructure);\n";
 
  return true;
}

References createOutputFile(), and pathDoxyLatexPL.

Referenced by generate().

◆ generateDoxyLatexStructurePL()

bool PerlModGenerator::generateDoxyLatexStructurePL ( )

Definition at line 2563 of file perlmodgen.cpp.

{
  std::ofstream doxyLatexStructurePLStream;
  if (!createOutputFile(doxyLatexStructurePLStream, pathDoxyLatexStructurePL))
    return false;
 
  doxyLatexStructurePLStream <<
    "use DoxyStructure;\n"
    "\n"
    "sub process($) {\n"
    "\tmy $node = $_[0];\n"
    "\tmy ($type, $name) = @$node[0, 1];\n"
    "\tmy $command;\n"
    "\tif ($type eq \"string\") { $command = \"String\" }\n"
    "\telsif ($type eq \"doc\") { $command = \"Doc\" }\n"
    "\telsif ($type eq \"hash\") {\n"
    "\t\t$command = \"Hash\";\n"
    "\t\tfor my $subnode (values %{$$node[2]}) {\n"
    "\t\t\tprocess($subnode);\n"
    "\t\t}\n"
    "\t}\n"
    "\telsif ($type eq \"list\") {\n"
    "\t\t$command = \"List\";\n"
    "\t\tprocess($$node[2]);\n"
    "\t}\n"
    "\tprint \"\\\\\" . $command . \"Node{\" . $name . \"}%\\n\";\n"
    "}\n"
    "\n"
    "process($doxystructure);\n";
 
  return true;
}

References createOutputFile(), and pathDoxyLatexStructurePL.

Referenced by generate().

◆ generateDoxyLatexTex()

bool PerlModGenerator::generateDoxyLatexTex ( )

Definition at line 2880 of file perlmodgen.cpp.

{
  std::ofstream doxyLatexTexStream;
  if (!createOutputFile(doxyLatexTexStream, pathDoxyLatexTex))
    return false;
 
  doxyLatexTexStream <<
    "\\documentclass[a4paper,12pt]{article}\n"
    "\\usepackage[latin1]{inputenc}\n"
    "\\usepackage[none]{hyphenat}\n"
    "\\usepackage[T1]{fontenc}\n"
    "\\usepackage{hyperref}\n"
    "\\usepackage{times}\n"
    "\n"
    "\\input{doxyformat}\n"
    "\n"
    "\\begin{document}\n"
    "\\input{" << pathDoxyDocsTex << "}\n"
    "\\sloppy\n"
    "\\EmitDoxyDocs\n"
    "\\end{document}\n";
 
  return true;
}

References createOutputFile(), pathDoxyDocsTex, and pathDoxyLatexTex.

Referenced by generate().

◆ generateDoxyRules()

bool PerlModGenerator::generateDoxyRules ( )

Definition at line 2441 of file perlmodgen.cpp.

{
  std::ofstream doxyRulesStream;
  if (!createOutputFile(doxyRulesStream, pathDoxyRules))
    return false;
 
  bool perlmodLatex = Config_getBool(PERLMOD_LATEX);
  QCString prefix = Config_getString(PERLMOD_MAKEVAR_PREFIX);
 
  doxyRulesStream <<
    prefix << "DOXY_EXEC_PATH = " << pathDoxyExec << "\n" <<
    prefix << "DOXYFILE = " << pathDoxyfile << "\n" <<
    prefix << "DOXYDOCS_PM = " << pathDoxyDocsPM << "\n" <<
    prefix << "DOXYSTRUCTURE_PM = " << pathDoxyStructurePM << "\n" <<
    prefix << "DOXYRULES = " << pathDoxyRules << "\n";
  if (perlmodLatex)
    doxyRulesStream <<
      prefix << "DOXYLATEX_PL = " << pathDoxyLatexPL << "\n" <<
      prefix << "DOXYLATEXSTRUCTURE_PL = " << pathDoxyLatexStructurePL << "\n" <<
      prefix << "DOXYSTRUCTURE_TEX = " << pathDoxyStructureTex << "\n" <<
      prefix << "DOXYDOCS_TEX = " << pathDoxyDocsTex << "\n" <<
      prefix << "DOXYFORMAT_TEX = " << pathDoxyFormatTex << "\n" <<
      prefix << "DOXYLATEX_TEX = " << pathDoxyLatexTex << "\n" <<
      prefix << "DOXYLATEX_DVI = " << pathDoxyLatexDVI << "\n" <<
      prefix << "DOXYLATEX_PDF = " << pathDoxyLatexPDF << "\n";
 
  doxyRulesStream <<
    "\n"
    ".PHONY: clean-perlmod\n"
    "clean-perlmod::\n"
    "\trm -f $(" << prefix << "DOXYSTRUCTURE_PM) \\\n"
    "\t$(" << prefix << "DOXYDOCS_PM)";
  if (perlmodLatex)
    doxyRulesStream <<
      " \\\n"
      "\t$(" << prefix << "DOXYLATEX_PL) \\\n"
      "\t$(" << prefix << "DOXYLATEXSTRUCTURE_PL) \\\n"
      "\t$(" << prefix << "DOXYDOCS_TEX) \\\n"
      "\t$(" << prefix << "DOXYSTRUCTURE_TEX) \\\n"
      "\t$(" << prefix << "DOXYFORMAT_TEX) \\\n"
      "\t$(" << prefix << "DOXYLATEX_TEX) \\\n"
      "\t$(" << prefix << "DOXYLATEX_PDF) \\\n"
      "\t$(" << prefix << "DOXYLATEX_DVI) \\\n"
      "\t$(addprefix $(" << prefix << "DOXYLATEX_TEX:tex=),out aux log)";
  doxyRulesStream << "\n\n";
 
  doxyRulesStream <<
    "$(" << prefix << "DOXYRULES) \\\n"
    "$(" << prefix << "DOXYMAKEFILE) \\\n"
    "$(" << prefix << "DOXYSTRUCTURE_PM) \\\n"
    "$(" << prefix << "DOXYDOCS_PM)";
  if (perlmodLatex) {
    doxyRulesStream <<
      " \\\n"
      "$(" << prefix << "DOXYLATEX_PL) \\\n"
      "$(" << prefix << "DOXYLATEXSTRUCTURE_PL) \\\n"
      "$(" << prefix << "DOXYFORMAT_TEX) \\\n"
      "$(" << prefix << "DOXYLATEX_TEX)";
  }
  doxyRulesStream <<
    ": \\\n"
    "\t$(" << prefix << "DOXYFILE)\n"
    "\tcd $(" << prefix << "DOXY_EXEC_PATH) ; doxygen \"$<\"\n";
 
  if (perlmodLatex) {
    doxyRulesStream <<
      "\n"
      "$(" << prefix << "DOXYDOCS_TEX): \\\n"
      "$(" << prefix << "DOXYLATEX_PL) \\\n"
      "$(" << prefix << "DOXYDOCS_PM)\n"
      "\tperl -I\"$(<D)\" \"$<\" >\"$@\"\n"
      "\n"
      "$(" << prefix << "DOXYSTRUCTURE_TEX): \\\n"
      "$(" << prefix << "DOXYLATEXSTRUCTURE_PL) \\\n"
      "$(" << prefix << "DOXYSTRUCTURE_PM)\n"
      "\tperl -I\"$(<D)\" \"$<\" >\"$@\"\n"
      "\n"
      "$(" << prefix << "DOXYLATEX_PDF) \\\n"
      "$(" << prefix << "DOXYLATEX_DVI): \\\n"
      "$(" << prefix << "DOXYLATEX_TEX) \\\n"
      "$(" << prefix << "DOXYFORMAT_TEX) \\\n"
      "$(" << prefix << "DOXYSTRUCTURE_TEX) \\\n"
      "$(" << prefix << "DOXYDOCS_TEX)\n"
      "\n"
      "$(" << prefix << "DOXYLATEX_PDF): \\\n"
      "$(" << prefix << "DOXYLATEX_TEX)\n"
      "\tpdflatex -interaction=nonstopmode \"$<\"\n"
      "\n"
      "$(" << prefix << "DOXYLATEX_DVI): \\\n"
      "$(" << prefix << "DOXYLATEX_TEX)\n"
      "\tlatex -interaction=nonstopmode \"$<\"\n";
  }
 
  return true;
}

References Config_getBool, Config_getString, createOutputFile(), pathDoxyDocsPM, pathDoxyDocsTex, pathDoxyExec, pathDoxyfile, pathDoxyFormatTex, pathDoxyLatexDVI, pathDoxyLatexPDF, pathDoxyLatexPL, pathDoxyLatexStructurePL, pathDoxyLatexTex, pathDoxyRules, pathDoxyStructurePM, pathDoxyStructureTex, and prefix.

Referenced by generate().

◆ generateDoxyStructurePM()

bool PerlModGenerator::generateDoxyStructurePM ( )

Definition at line 2258 of file perlmodgen.cpp.

{
  std::ofstream doxyModelPMStream;
  if (!createOutputFile(doxyModelPMStream, pathDoxyStructurePM))
    return false;
 
  doxyModelPMStream <<
    "sub memberlist($) {\n"
    "    my $prefix = $_[0];\n"
    "    return\n"
    "\t[ \"hash\", $prefix . \"s\",\n"
    "\t  {\n"
    "\t    members =>\n"
    "\t      [ \"list\", $prefix . \"List\",\n"
    "\t\t[ \"hash\", $prefix,\n"
    "\t\t  {\n"
    "\t\t    kind => [ \"string\", $prefix . \"Kind\" ],\n"
    "\t\t    name => [ \"string\", $prefix . \"Name\" ],\n"
    "\t\t    static => [ \"string\", $prefix . \"Static\" ],\n"
    "\t\t    virtualness => [ \"string\", $prefix . \"Virtualness\" ],\n"
    "\t\t    protection => [ \"string\", $prefix . \"Protection\" ],\n"
    "\t\t    type => [ \"string\", $prefix . \"Type\" ],\n"
    "\t\t    parameters =>\n"
    "\t\t      [ \"list\", $prefix . \"Params\",\n"
    "\t\t\t[ \"hash\", $prefix . \"Param\",\n"
    "\t\t\t  {\n"
    "\t\t\t    declaration_name => [ \"string\", $prefix . \"ParamName\" ],\n"
    "\t\t\t    type => [ \"string\", $prefix . \"ParamType\" ],\n"
    "\t\t\t  },\n"
    "\t\t\t],\n"
    "\t\t      ],\n"
    "\t\t    detailed =>\n"
    "\t\t      [ \"hash\", $prefix . \"Detailed\",\n"
    "\t\t\t{\n"
    "\t\t\t  doc => [ \"doc\", $prefix . \"DetailedDoc\" ],\n"
    "\t\t\t  return => [ \"doc\", $prefix . \"Return\" ],\n"
    "\t\t\t  see => [ \"doc\", $prefix . \"See\" ],\n"
    "\t\t\t  params =>\n"
    "\t\t\t    [ \"list\", $prefix . \"PDBlocks\",\n"
    "\t\t\t      [ \"hash\", $prefix . \"PDBlock\",\n"
    "\t\t\t\t{\n"
    "\t\t\t\t  parameters =>\n"
    "\t\t\t\t    [ \"list\", $prefix . \"PDParams\",\n"
    "\t\t\t\t      [ \"hash\", $prefix . \"PDParam\",\n"
    "\t\t\t\t\t{\n"
    "\t\t\t\t\t  name => [ \"string\", $prefix . \"PDParamName\" ],\n"
    "\t\t\t\t\t},\n"
    "\t\t\t\t      ],\n"
    "\t\t\t\t    ],\n"
    "\t\t\t\t  doc => [ \"doc\", $prefix . \"PDDoc\" ],\n"
    "\t\t\t\t},\n"
    "\t\t\t      ],\n"
    "\t\t\t    ],\n"
    "\t\t\t},\n"
    "\t\t      ],\n"
    "\t\t  },\n"
    "\t\t],\n"
    "\t      ],\n"
    "\t  },\n"
    "\t];\n"
    "}\n"
    "\n"
    "$doxystructure =\n"
    "    [ \"hash\", \"Root\",\n"
    "      {\n"
    "\tfiles =>\n"
    "\t  [ \"list\", \"Files\",\n"
    "\t    [ \"hash\", \"File\",\n"
    "\t      {\n"
    "\t\tname => [ \"string\", \"FileName\" ],\n"
    "\t\ttypedefs => memberlist(\"FileTypedef\"),\n"
    "\t\tvariables => memberlist(\"FileVariable\"),\n"
    "\t\tfunctions => memberlist(\"FileFunction\"),\n"
    "\t\tdetailed =>\n"
    "\t\t  [ \"hash\", \"FileDetailed\",\n"
    "\t\t    {\n"
    "\t\t      doc => [ \"doc\", \"FileDetailedDoc\" ],\n"
    "\t\t    },\n"
    "\t\t  ],\n"
    "\t      },\n"
    "\t    ],\n"
    "\t  ],\n"
    "\tpages =>\n"
    "\t  [ \"list\", \"Pages\",\n"
    "\t    [ \"hash\", \"Page\",\n"
    "\t      {\n"
    "\t\tname => [ \"string\", \"PageName\" ],\n"
    "\t\tdetailed =>\n"
    "\t\t  [ \"hash\", \"PageDetailed\",\n"
    "\t\t    {\n"
    "\t\t      doc => [ \"doc\", \"PageDetailedDoc\" ],\n"
    "\t\t    },\n"
    "\t\t  ],\n"
    "\t      },\n"
    "\t    ],\n"
    "\t  ],\n"
    "\tclasses =>\n"
    "\t  [ \"list\", \"Classes\",\n"
    "\t    [ \"hash\", \"Class\",\n"
    "\t      {\n"
    "\t\tname => [ \"string\", \"ClassName\" ],\n"
    "\t\tpublic_typedefs => memberlist(\"ClassPublicTypedef\"),\n"
    "\t\tpublic_methods => memberlist(\"ClassPublicMethod\"),\n"
    "\t\tpublic_members => memberlist(\"ClassPublicMember\"),\n"
    "\t\tprotected_typedefs => memberlist(\"ClassProtectedTypedef\"),\n"
    "\t\tprotected_methods => memberlist(\"ClassProtectedMethod\"),\n"
    "\t\tprotected_members => memberlist(\"ClassProtectedMember\"),\n"
    "\t\tprivate_typedefs => memberlist(\"ClassPrivateTypedef\"),\n"
    "\t\tprivate_methods => memberlist(\"ClassPrivateMethod\"),\n"
    "\t\tprivate_members => memberlist(\"ClassPrivateMember\"),\n"
    "\t\tdetailed =>\n"
    "\t\t  [ \"hash\", \"ClassDetailed\",\n"
    "\t\t    {\n"
    "\t\t      doc => [ \"doc\", \"ClassDetailedDoc\" ],\n"
    "\t\t    },\n"
    "\t\t  ],\n"
    "\t      },\n"
    "\t    ],\n"
    "\t  ],\n"
    "\tgroups =>\n"
    "\t  [ \"list\", \"Groups\",\n"
    "\t    [ \"hash\", \"Group\",\n"
    "\t      {\n"
    "\t\tname => [ \"string\", \"GroupName\" ],\n"
    "\t\ttitle => [ \"string\", \"GroupTitle\" ],\n"
    "\t\tfiles =>\n"
    "\t\t  [ \"list\", \"Files\",\n"
    "\t\t    [ \"hash\", \"File\",\n"
    "\t\t      {\n"
    "\t\t        name => [ \"string\", \"Filename\" ]\n"
    "\t\t      }\n"
    "\t\t    ],\n"
    "\t\t  ],\n"
    "\t\tclasses  =>\n"
    "\t\t  [ \"list\", \"Classes\",\n"
    "\t\t    [ \"hash\", \"Class\",\n"
    "\t\t      {\n"
    "\t\t        name => [ \"string\", \"Classname\" ]\n"
    "\t\t      }\n"
    "\t\t    ],\n"
    "\t\t  ],\n"
    "\t\tnamespaces =>\n"
    "\t\t  [ \"list\", \"Namespaces\",\n"
    "\t\t    [ \"hash\", \"Namespace\",\n"
    "\t\t      {\n"
    "\t\t        name => [ \"string\", \"NamespaceName\" ]\n"
    "\t\t      }\n"
    "\t\t    ],\n"
    "\t\t  ],\n"
    "\t\tpages =>\n"
    "\t\t  [ \"list\", \"Pages\",\n"
    "\t\t    [ \"hash\", \"Page\","
    "\t\t      {\n"
    "\t\t        title => [ \"string\", \"PageName\" ]\n"
    "\t\t      }\n"
    "\t\t    ],\n"
    "\t\t  ],\n"
    "\t\tgroups =>\n"
    "\t\t  [ \"list\", \"Groups\",\n"
    "\t\t    [ \"hash\", \"Group\",\n"
    "\t\t      {\n"
    "\t\t        title => [ \"string\", \"GroupName\" ]\n"
    "\t\t      }\n"
    "\t\t    ],\n"
    "\t\t  ],\n"
    "\t\tfunctions => memberlist(\"GroupFunction\"),\n"
    "\t\tdetailed =>\n"
    "\t\t  [ \"hash\", \"GroupDetailed\",\n"
    "\t\t    {\n"
    "\t\t      doc => [ \"doc\", \"GroupDetailedDoc\" ],\n"
    "\t\t    },\n"
    "\t\t  ],\n"
    "\t      }\n"
    "\t    ],\n"
    "\t  ],\n"
    "      },\n"
    "    ];\n"
    "\n"
    "1;\n";
 
  return true;
}

References createOutputFile(), and pathDoxyStructurePM.

Referenced by generate().

◆ generateMakefile()

bool PerlModGenerator::generateMakefile ( )

Definition at line 2537 of file perlmodgen.cpp.

{
  std::ofstream makefileStream;
  if (!createOutputFile(makefileStream, pathMakefile))
    return false;
 
  bool perlmodLatex = Config_getBool(PERLMOD_LATEX);
  QCString prefix = Config_getString(PERLMOD_MAKEVAR_PREFIX);
 
  makefileStream <<
    ".PHONY: default clean" << (perlmodLatex ? " pdf" : "") << "\n"
    "default: " << (perlmodLatex ? "pdf" : "clean") << "\n"
    "\n"
    "include " << pathDoxyRules << "\n"
    "\n"
    "clean: clean-perlmod\n";
 
  if (perlmodLatex) {
    makefileStream <<
      "pdf: $(" << prefix << "DOXYLATEX_PDF)\n"
      "dvi: $(" << prefix << "DOXYLATEX_DVI)\n";
  }
 
  return true;
}

References Config_getBool, Config_getString, createOutputFile(), pathDoxyRules, pathMakefile, and prefix.

Referenced by generate().

◆ generatePerlModForClass()

void PerlModGenerator::generatePerlModForClass ( const ClassDef * cd )

Definition at line 1733 of file perlmodgen.cpp.

{
  // + brief description
  // + detailed description
  // + template argument list(s)
  // - include file
  // + member groups
  // + inheritance diagram
  // + list of direct super classes
  // + list of direct sub classes
  // + list of inner classes
  // + collaboration diagram
  // + list of all members
  // + user defined member sections
  // + standard member sections
  // + detailed member documentation
  // - examples using the class
 
  if (cd->isReference())        return; // skip external references.
  if (cd->isAnonymous())        return; // skip anonymous compounds.
  if (cd->isImplicitTemplateInstance())  return; // skip generated template instances.
 
  m_output.openHash()
    .addFieldQuotedString("name", cd->name());
  /* DGA: fix # #7547 Perlmod does not generate "kind" information to discriminate struct/union */
  m_output.addFieldQuotedString("kind", cd->compoundTypeString());
 
  if (!cd->baseClasses().empty())
  {
    m_output.openList("base");
    for (const auto &bcd : cd->baseClasses())
    {
      m_output.openHash()
        .addFieldQuotedString("name", bcd.classDef->displayName())
        .addFieldQuotedString("virtualness", getVirtualnessName(bcd.virt))
        .addFieldQuotedString("protection", getProtectionName(bcd.prot))
        .closeHash();
    }
    m_output.closeList();
  }
 
  if (!cd->subClasses().empty())
  {
    m_output.openList("derived");
    for (const auto &bcd : cd->subClasses())
    {
      m_output.openHash()
        .addFieldQuotedString("name", bcd.classDef->displayName())
        .addFieldQuotedString("virtualness", getVirtualnessName(bcd.virt))
        .addFieldQuotedString("protection", getProtectionName(bcd.prot))
        .closeHash();
    }
    m_output.closeList();
  }
 
  {
    m_output.openList("inner");
    for (const auto &icd : cd->getClasses())
      m_output.openHash()
        .addFieldQuotedString("name", icd->name())
        .closeHash();
    m_output.closeList();
  }
 
  addIncludeInfo(cd->includeInfo());
 
  addTemplateList(cd,m_output);
  addListOfAllMembers(cd);
  generatePerlUserDefinedSection(cd, cd->getMemberGroups());
 
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PubTypes()),"public_typedefs");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PubMethods()),"public_methods");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PubAttribs()),"public_members");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PubSlots()),"public_slots");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::Signals()),"signals");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::DcopMethods()),"dcop_methods");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::Properties()),"properties");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PubStaticMethods()),"public_static_methods");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PubStaticAttribs()),"public_static_members");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::ProTypes()),"protected_typedefs");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::ProMethods()),"protected_methods");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::ProAttribs()),"protected_members");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::ProSlots()),"protected_slots");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::ProStaticMethods()),"protected_static_methods");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::ProStaticAttribs()),"protected_static_members");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PriTypes()),"private_typedefs");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PriMethods()),"private_methods");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PriAttribs()),"private_members");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PriSlots()),"private_slots");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PriStaticMethods()),"private_static_methods");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::PriStaticAttribs()),"private_static_members");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::Friends()),"friend_methods");
  generatePerlModSection(cd,cd->getMemberList(MemberListType::Related()),"related_methods");
 
  addPerlModDocBlock(m_output,"brief",cd->getDefFileName(),cd->getDefLine(),cd,nullptr,cd->briefDescription());
  addPerlModDocBlock(m_output,"detailed",cd->getDefFileName(),cd->getDefLine(),cd,nullptr,cd->documentation());
 
#if 0
  DotClassGraph inheritanceGraph(cd,DotClassGraph::Inheritance);
  if (!inheritanceGraph.isTrivial())
  {
    t << "    <inheritancegraph>" << endl;
    inheritanceGraph.writePerlMod(t);
    t << "    </inheritancegraph>" << endl;
  }
  DotClassGraph collaborationGraph(cd,DotClassGraph::Implementation);
  if (!collaborationGraph.isTrivial())
  {
    t << "    <collaborationgraph>" << endl;
    collaborationGraph.writePerlMod(t);
    t << "    </collaborationgraph>" << endl;
  }
  t << "    <location file=\""
    << cd->getDefFileName() << "\" line=\""
    << cd->getDefLine() << "\"";
    if (cd->getStartBodyLine()!=-1)
    {
      t << " bodystart=\"" << cd->getStartBodyLine() << "\" bodyend=\""
        << cd->getEndBodyLine() << "\"";
    }
  t << "/>" << endl;
#endif
 
  m_output.closeHash();
}

References addIncludeInfo(), addListOfAllMembers(), addPerlModDocBlock(), addTemplateList(), ClassDef::baseClasses(), Definition::briefDescription(), ClassDef::compoundTypeString(), Definition::documentation(), generatePerlModSection(), generatePerlUserDefinedSection(), ClassDef::getClasses(), Definition::getDefFileName(), Definition::getDefLine(), Definition::getEndBodyLine(), ClassDef::getMemberGroups(), ClassDef::getMemberList(), getProtectionName(), Definition::getStartBodyLine(), getVirtualnessName(), ClassDef::includeInfo(), Definition::isAnonymous(), ClassDef::isImplicitTemplateInstance(), Definition::isReference(), DotClassGraph::isTrivial(), m_output, Definition::name(), and ClassDef::subClasses().

Referenced by generatePerlModOutput().

◆ generatePerlModForConcept()

void PerlModGenerator::generatePerlModForConcept ( const ConceptDef * cd )

Definition at line 1859 of file perlmodgen.cpp.

{
  if (cd->isReference()) return; // skip external references
 
  m_output.openHash()
    .addFieldQuotedString("name", cd->name());
 
  addIncludeInfo(cd->includeInfo());
  addTemplateList(cd,m_output);
  m_output.addFieldQuotedString("initializer", cd->initializer());
  addPerlModDocBlock(m_output,"brief",cd->getDefFileName(),cd->getDefLine(),nullptr,nullptr,cd->briefDescription());
  addPerlModDocBlock(m_output,"detailed",cd->getDefFileName(),cd->getDefLine(),nullptr,nullptr,cd->documentation());
 
  m_output.closeHash();
}

References addIncludeInfo(), addPerlModDocBlock(), addTemplateList(), Definition::briefDescription(), Definition::documentation(), Definition::getDefFileName(), Definition::getDefLine(), ConceptDef::includeInfo(), ConceptDef::initializer(), Definition::isReference(), m_output, and Definition::name().

Referenced by generatePerlModOutput().

◆ generatePerlModForFile()

void PerlModGenerator::generatePerlModForFile ( const FileDef * fd )

Definition at line 1986 of file perlmodgen.cpp.

{
  // + includes files
  // + includedby files
  // - include graph
  // - included by graph
  // - contained class definitions
  // - contained namespace definitions
  // - member groups
  // + normal members
  // + brief desc
  // + detailed desc
  // - source code
  // - location
  // - number of lines
 
  if (fd->isReference()) return;
 
  m_output.openHash()
    .addFieldQuotedString("name", fd->name());
 
  m_output.openList("includes");
  for (const auto &inc: fd->includeFileList())
  {
    m_output.openHash()
      .addFieldQuotedString("name", inc.includeName);
    if (inc.fileDef && !inc.fileDef->isReference())
    {
      m_output.addFieldQuotedString("ref", inc.fileDef->getOutputFileBase());
    }
    m_output.closeHash();
  }
  m_output.closeList();
 
  m_output.openList("included_by");
  for (const auto &inc : fd->includedByFileList())
  {
    m_output.openHash()
      .addFieldQuotedString("name", inc.includeName);
    if (inc.fileDef && !inc.fileDef->isReference())
    {
      m_output.addFieldQuotedString("ref", inc.fileDef->getOutputFileBase());
    }
    m_output.closeHash();
  }
  m_output.closeList();
 
  generatePerlUserDefinedSection(fd, fd->getMemberGroups());
 
  generatePerlModSection(fd,fd->getMemberList(MemberListType::DecDefineMembers()),"defines");
  generatePerlModSection(fd,fd->getMemberList(MemberListType::DecProtoMembers()),"prototypes");
  generatePerlModSection(fd,fd->getMemberList(MemberListType::DecTypedefMembers()),"typedefs");
  generatePerlModSection(fd,fd->getMemberList(MemberListType::DecEnumMembers()),"enums");
  generatePerlModSection(fd,fd->getMemberList(MemberListType::DecFuncMembers()),"functions");
  generatePerlModSection(fd,fd->getMemberList(MemberListType::DecVarMembers()),"variables");
 
  addPerlModDocBlock(m_output,"brief",fd->getDefFileName(),fd->getDefLine(),nullptr,nullptr,fd->briefDescription());
  addPerlModDocBlock(m_output,"detailed",fd->getDefFileName(),fd->getDefLine(),nullptr,nullptr,fd->documentation());
 
  m_output.closeHash();
}

References addPerlModDocBlock(), Definition::briefDescription(), Definition::documentation(), generatePerlModSection(), generatePerlUserDefinedSection(), Definition::getDefFileName(), Definition::getDefLine(), FileDef::getMemberGroups(), FileDef::getMemberList(), FileDef::includedByFileList(), FileDef::includeFileList(), Definition::isReference(), m_output, and Definition::name().

Referenced by generatePerlModOutput().

◆ generatePerlModForGroup()

void PerlModGenerator::generatePerlModForGroup ( const GroupDef * gd )

Definition at line 2048 of file perlmodgen.cpp.

{
  // + members
  // + member groups
  // + files
  // + classes
  // + namespaces
  // - packages
  // + pages
  // + child groups
  // - examples
  // + brief description
  // + detailed description
 
  if (gd->isReference()) return; // skip external references
 
  m_output.openHash()
    .addFieldQuotedString("name", gd->name())
    .addFieldQuotedString("title", gd->groupTitle());
 
  if (!gd->getFiles().empty())
  {
    m_output.openList("files");
    for (const auto &fd : gd->getFiles())
      m_output.openHash()
        .addFieldQuotedString("name", fd->name())
        .closeHash();
    m_output.closeList();
  }
 
  if (!gd->getClasses().empty())
  {
    m_output.openList("classes");
    for (const auto &cd : gd->getClasses())
      m_output.openHash()
        .addFieldQuotedString("name", cd->name())
        .closeHash();
    m_output.closeList();
  }
 
  if (!gd->getConcepts().empty())
  {
    m_output.openList("concepts");
    for (const auto &cd : gd->getConcepts())
      m_output.openHash()
        .addFieldQuotedString("name", cd->name())
        .closeHash();
    m_output.closeList();
  }
 
  if (!gd->getModules().empty())
  {
    m_output.openList("modules");
    for (const auto &mod : gd->getModules())
      m_output.openHash()
        .addFieldQuotedString("name", mod->name())
        .closeHash();
    m_output.closeList();
  }
 
  if (!gd->getNamespaces().empty())
  {
    m_output.openList("namespaces");
    for (const auto &nd : gd->getNamespaces())
      m_output.openHash()
        .addFieldQuotedString("name", nd->name())
        .closeHash();
    m_output.closeList();
  }
 
  if (!gd->getPages().empty())
  {
    m_output.openList("pages");
    for (const auto &pd : gd->getPages())
      m_output.openHash()
        .addFieldQuotedString("title", pd->title())
        .closeHash();
    m_output.closeList();
  }
 
  if (!gd->getSubGroups().empty())
  {
    m_output.openList("groups");
    for (const auto &sgd : gd->getSubGroups())
      m_output.openHash()
        .addFieldQuotedString("title", sgd->groupTitle())
        .closeHash();
    m_output.closeList();
  }
 
  generatePerlUserDefinedSection(gd, gd->getMemberGroups());
 
  generatePerlModSection(gd,gd->getMemberList(MemberListType::DecDefineMembers()),"defines");
  generatePerlModSection(gd,gd->getMemberList(MemberListType::DecProtoMembers()),"prototypes");
  generatePerlModSection(gd,gd->getMemberList(MemberListType::DecTypedefMembers()),"typedefs");
  generatePerlModSection(gd,gd->getMemberList(MemberListType::DecEnumMembers()),"enums");
  generatePerlModSection(gd,gd->getMemberList(MemberListType::DecFuncMembers()),"functions");
  generatePerlModSection(gd,gd->getMemberList(MemberListType::DecVarMembers()),"variables");
 
  addPerlModDocBlock(m_output,"brief",gd->getDefFileName(),gd->getDefLine(),nullptr,nullptr,gd->briefDescription());
  addPerlModDocBlock(m_output,"detailed",gd->getDefFileName(),gd->getDefLine(),nullptr,nullptr,gd->documentation());
 
  m_output.closeHash();
}

References addPerlModDocBlock(), Definition::briefDescription(), Definition::documentation(), LinkedRefMap< T, Hash, KeyEqual, Map >::empty(), generatePerlModSection(), generatePerlUserDefinedSection(), GroupDef::getClasses(), GroupDef::getConcepts(), Definition::getDefFileName(), Definition::getDefLine(), GroupDef::getFiles(), GroupDef::getMemberGroups(), GroupDef::getMemberList(), GroupDef::getModules(), GroupDef::getNamespaces(), GroupDef::getPages(), GroupDef::getSubGroups(), GroupDef::groupTitle(), Definition::isReference(), m_output, and Definition::name().

Referenced by generatePerlModOutput().

◆ generatePerlModForMember()

void PerlModGenerator::generatePerlModForMember	(	const MemberDef *	md,
		const Definition *	)

Definition at line 1469 of file perlmodgen.cpp.

{
  // + declaration/definition arg lists
  // + reimplements
  // + reimplementedBy
  // + exceptions
  // + const/volatile specifiers
  // - examples
  // - source definition
  // - source references
  // - source referenced by
  // - body code
  // - template arguments
  //     (templateArguments(), definitionTemplateParameterLists())
 
  QCString memType;
  QCString name;
  bool isFunc=FALSE;
  switch (md->memberType())
  {
    case MemberType::Define:      memType="define";     break;
    case MemberType::EnumValue:   memType="enumvalue";  break;
    case MemberType::Property:    memType="property";   break;
    case MemberType::Variable:    memType="variable";   break;
    case MemberType::Typedef:     memType="typedef";    break;
    case MemberType::Enumeration: memType="enum";       break;
    case MemberType::Function:    memType="function";   isFunc=TRUE; break;
    case MemberType::Signal:      memType="signal";     isFunc=TRUE; break;
    case MemberType::Friend:      memType="friend";     isFunc=TRUE; break;
    case MemberType::DCOP:        memType="dcop";       isFunc=TRUE; break;
    case MemberType::Slot:        memType="slot";       isFunc=TRUE; break;
    case MemberType::Event:       memType="event";      break;
    case MemberType::Interface:   memType="interface";  break;
    case MemberType::Service:     memType="service";    break;
    case MemberType::Sequence:    memType="sequence";   break;
    case MemberType::Dictionary:  memType="dictionary"; break;
  }
 
  bool isFortran = md->getLanguage()==SrcLangExt::Fortran;
  name = md->name();
  if (md->isAnonymous()) name = "__unnamed" + name.right(name.length() - 1)+"__";
 
  m_output.openHash()
    .addFieldQuotedString("kind", memType)
    .addFieldQuotedString("name", name)
    .addFieldQuotedString("virtualness", getVirtualnessName(md->virtualness()))
    .addFieldQuotedString("protection", getProtectionName(md->protection()))
    .addFieldBoolean("static", md->isStatic());
 
  addPerlModDocBlock(m_output,"brief",md->getDefFileName(),md->getDefLine(),md->getOuterScope(),md,md->briefDescription());
  addPerlModDocBlock(m_output,"detailed",md->getDefFileName(),md->getDefLine(),md->getOuterScope(),md,md->documentation());
  if (md->memberType()!=MemberType::Define &&
      md->memberType()!=MemberType::Enumeration)
    m_output.addFieldQuotedString("type", md->typeString());
 
  const ArgumentList &al = md->argumentList();
  if (isFunc) //function
  {
    m_output.addFieldBoolean("const",    al.constSpecifier())
            .addFieldBoolean("volatile", al.volatileSpecifier());
 
    m_output.openList("parameters");
    const ArgumentList &declAl = md->declArgumentList();
    if (!declAl.empty())
    {
      auto defIt = al.begin();
      for (const Argument &a : declAl)
      {
        const Argument *defArg = nullptr;
        if (defIt!=al.end())
        {
          defArg = &(*defIt);
          ++defIt;
        }
        m_output.openHash();
 
        if (!a.name.isEmpty())
          m_output.addFieldQuotedString("declaration_name", a.name);
 
        if (defArg && !defArg->name.isEmpty() && defArg->name!=a.name)
          m_output.addFieldQuotedString("definition_name", defArg->name);
 
        if (isFortran && defArg && !defArg->type.isEmpty())
          m_output.addFieldQuotedString("type", defArg->type);
        else if (!a.type.isEmpty())
          m_output.addFieldQuotedString("type", a.type);
 
        if (!a.array.isEmpty())
          m_output.addFieldQuotedString("array", a.array);
 
        if (!a.defval.isEmpty())
          m_output.addFieldQuotedString("default_value", a.defval);
 
        if (!a.attrib.isEmpty())
          m_output.addFieldQuotedString("attributes", a.attrib);
 
        m_output.closeHash();
      }
    }
    m_output.closeList();
  }
  else if (md->memberType()==MemberType::Define &&
           md->argsString()!=nullptr) // define
  {
    m_output.openList("parameters");
    for (const Argument &a : al)
    {
      m_output.openHash()
        .addFieldQuotedString("name", a.type)
        .closeHash();
    }
    m_output.closeList();
  }
  else if (md->argsString()!=nullptr)
  {
    m_output.addFieldQuotedString("arguments", md->argsString());
  }
 
  if (!md->initializer().isEmpty())
    m_output.addFieldQuotedString("initializer", md->initializer());
 
  if (!md->excpString().isEmpty())
    m_output.addFieldQuotedString("exceptions", md->excpString());
 
  if (md->memberType()==MemberType::Enumeration) // enum
  {
    const MemberVector &enumFields = md->enumFieldList();
    m_output.addFieldQuotedString("type", md->enumBaseType());
    if (!enumFields.empty())
    {
      m_output.openList("values");
      for (const auto &emd : enumFields)
      {
        m_output.openHash()
          .addFieldQuotedString("name", emd->name());
 
        if (!emd->initializer().isEmpty())
          m_output.addFieldQuotedString("initializer", emd->initializer());
 
        addPerlModDocBlock(m_output,"brief",emd->getDefFileName(),emd->getDefLine(),emd->getOuterScope(),emd,emd->briefDescription());
 
        addPerlModDocBlock(m_output,"detailed",emd->getDefFileName(),emd->getDefLine(),emd->getOuterScope(),emd,emd->documentation());
 
        m_output.closeHash();
      }
      m_output.closeList();
    }
  }
 
  if (md->memberType() == MemberType::Variable && !md->bitfieldString().isEmpty())
  {
    QCString bitfield = md->bitfieldString();
    if (bitfield.at(0) == ':') bitfield = bitfield.mid(1);
    m_output.addFieldQuotedString("bitfield", bitfield);
  }
 
  const MemberDef *rmd = md->reimplements();
  if (rmd)
    m_output.openHash("reimplements")
      .addFieldQuotedString("name", rmd->name())
      .closeHash();
 
  const MemberVector &rbml = md->reimplementedBy();
  if (!rbml.empty())
  {
    m_output.openList("reimplemented_by");
    for (const auto &rbmd : rbml)
      m_output.openHash()
        .addFieldQuotedString("name", rbmd->name())
        .closeHash();
    m_output.closeList();
  }
 
  m_output.closeHash();
}

References addPerlModDocBlock(), MemberDef::argsString(), MemberDef::argumentList(), QCString::at(), ArgumentList::begin(), MemberDef::bitfieldString(), Definition::briefDescription(), ArgumentList::constSpecifier(), DCOP, MemberDef::declArgumentList(), Define, Dictionary, Definition::documentation(), ArgumentList::empty(), MemberVector::empty(), ArgumentList::end(), MemberDef::enumBaseType(), Enumeration, MemberDef::enumFieldList(), EnumValue, Event, MemberDef::excpString(), FALSE, Friend, Function, Definition::getDefFileName(), Definition::getDefLine(), Definition::getLanguage(), Definition::getOuterScope(), getProtectionName(), getVirtualnessName(), MemberDef::initializer(), Interface, Definition::isAnonymous(), QCString::isEmpty(), MemberDef::isStatic(), QCString::length(), m_output, MemberDef::memberType(), QCString::mid(), Argument::name, Definition::name(), Property, MemberDef::protection(), MemberDef::reimplementedBy(), MemberDef::reimplements(), QCString::right(), Sequence, Service, Signal, Slot, TRUE, Argument::type, Typedef, MemberDef::typeString(), Variable, MemberDef::virtualness(), and ArgumentList::volatileSpecifier().

Referenced by generatePerlModSection(), and generatePerlUserDefinedSection().

◆ generatePerlModForModule()

void PerlModGenerator::generatePerlModForModule ( const ModuleDef * mod )

Definition at line 1875 of file perlmodgen.cpp.

{
  // + contained class definitions
  // + contained concept definitions
  // + member groups
  // + normal members
  // + brief desc
  // + detailed desc
  // + location (file_id, line, column)
  // - exports
  // + used files
 
  if (mod->isReference()) return; // skip external references
 
  m_output.openHash()
    .addFieldQuotedString("name", mod->name());
 
  generatePerlUserDefinedSection(mod, mod->getMemberGroups());
 
  if (!mod->getClasses().empty())
  {
    m_output.openList("classes");
    for (const auto &cd : mod->getClasses())
      m_output.openHash()
        .addFieldQuotedString("name", cd->name())
        .closeHash();
    m_output.closeList();
  }
 
  if (!mod->getConcepts().empty())
  {
    m_output.openList("concepts");
    for (const auto &cd : mod->getConcepts())
      m_output.openHash()
        .addFieldQuotedString("name", cd->name())
        .closeHash();
    m_output.closeList();
  }
 
  generatePerlModSection(mod,mod->getMemberList(MemberListType::DecTypedefMembers()),"typedefs");
  generatePerlModSection(mod,mod->getMemberList(MemberListType::DecEnumMembers()),"enums");
  generatePerlModSection(mod,mod->getMemberList(MemberListType::DecFuncMembers()),"functions");
  generatePerlModSection(mod,mod->getMemberList(MemberListType::DecVarMembers()),"variables");
 
  addPerlModDocBlock(m_output,"brief",mod->getDefFileName(),mod->getDefLine(),nullptr,nullptr,mod->briefDescription());
  addPerlModDocBlock(m_output,"detailed",mod->getDefFileName(),mod->getDefLine(),nullptr,nullptr,mod->documentation());
 
  if (!mod->getUsedFiles().empty())
  {
    m_output.openList("files");
    for (const auto &fd : mod->getUsedFiles())
      m_output.openHash()
        .addFieldQuotedString("name", fd->name())
        .closeHash();
    m_output.closeList();
  }
 
  m_output.closeHash();
}

References addPerlModDocBlock(), Definition::briefDescription(), Definition::documentation(), LinkedRefMap< T, Hash, KeyEqual, Map >::empty(), generatePerlModSection(), generatePerlUserDefinedSection(), ModuleDef::getClasses(), ModuleDef::getConcepts(), Definition::getDefFileName(), Definition::getDefLine(), ModuleDef::getMemberGroups(), ModuleDef::getMemberList(), ModuleDef::getUsedFiles(), Definition::isReference(), m_output, and Definition::name().

Referenced by generatePerlModOutput().

◆ generatePerlModForNamespace()

void PerlModGenerator::generatePerlModForNamespace ( const NamespaceDef * nd )

Definition at line 1935 of file perlmodgen.cpp.

{
  // + contained class definitions
  // + contained namespace definitions
  // + member groups
  // + normal members
  // + brief desc
  // + detailed desc
  // + location
  // - files containing (parts of) the namespace definition
 
  if (nd->isReference()) return; // skip external references
 
  m_output.openHash()
    .addFieldQuotedString("name", nd->name());
 
  if (!nd->getClasses().empty())
  {
    m_output.openList("classes");
    for (const auto &cd : nd->getClasses())
      m_output.openHash()
        .addFieldQuotedString("name", cd->name())
        .closeHash();
    m_output.closeList();
  }
 
  if (!nd->getNamespaces().empty())
  {
    m_output.openList("namespaces");
    for (const auto &ind : nd->getNamespaces())
      m_output.openHash()
        .addFieldQuotedString("name", ind->name())
        .closeHash();
    m_output.closeList();
  }
 
  generatePerlUserDefinedSection(nd, nd->getMemberGroups());
 
  generatePerlModSection(nd,nd->getMemberList(MemberListType::DecDefineMembers()),"defines");
  generatePerlModSection(nd,nd->getMemberList(MemberListType::DecProtoMembers()),"prototypes");
  generatePerlModSection(nd,nd->getMemberList(MemberListType::DecTypedefMembers()),"typedefs");
  generatePerlModSection(nd,nd->getMemberList(MemberListType::DecEnumMembers()),"enums");
  generatePerlModSection(nd,nd->getMemberList(MemberListType::DecFuncMembers()),"functions");
  generatePerlModSection(nd,nd->getMemberList(MemberListType::DecVarMembers()),"variables");
 
  addPerlModDocBlock(m_output,"brief",nd->getDefFileName(),nd->getDefLine(),nullptr,nullptr,nd->briefDescription());
  addPerlModDocBlock(m_output,"detailed",nd->getDefFileName(),nd->getDefLine(),nullptr,nullptr,nd->documentation());
 
  m_output.closeHash();
}

References addPerlModDocBlock(), Definition::briefDescription(), Definition::documentation(), LinkedRefMap< T, Hash, KeyEqual, Map >::empty(), generatePerlModSection(), generatePerlUserDefinedSection(), NamespaceDef::getClasses(), Definition::getDefFileName(), Definition::getDefLine(), NamespaceDef::getMemberGroups(), NamespaceDef::getMemberList(), NamespaceDef::getNamespaces(), Definition::isReference(), m_output, and Definition::name().

Referenced by generatePerlModOutput().

◆ generatePerlModForPage()

void PerlModGenerator::generatePerlModForPage ( PageDef * pi )

Definition at line 2153 of file perlmodgen.cpp.

{
  // + name
  // + title
  // + documentation
 
  if (pd->isReference()) return;
 
  m_output.openHash()
    .addFieldQuotedString("name", pd->name());
 
  const SectionInfo *si = SectionManager::instance().find(pd->name());
  if (si)
    m_output.addFieldQuotedString("title4", filterTitle(si->title()));
 
  addPerlModDocBlock(m_output,"detailed",pd->docFile(),pd->docLine(),nullptr,nullptr,pd->documentation());
  m_output.closeHash();
}

References addPerlModDocBlock(), Definition::docFile(), Definition::docLine(), Definition::documentation(), filterTitle(), LinkedMap< T, Hash, KeyEqual, Map >::find(), SectionManager::instance(), Definition::isReference(), m_output, Definition::name(), and SectionInfo::title().

Referenced by generatePerlModOutput().

◆ generatePerlModOutput()

bool PerlModGenerator::generatePerlModOutput ( )

Definition at line 2172 of file perlmodgen.cpp.

{
  std::ofstream outputFileStream;
  if (!createOutputFile(outputFileStream, pathDoxyDocsPM))
    return false;
 
  PerlModOutputStream outputStream(outputFileStream);
  m_output.setPerlModOutputStream(&outputStream);
  m_output.add("$doxydocs=").openHash();
 
  m_output.openList("classes");
  for (const auto &cd : *Doxygen::classLinkedMap)
    generatePerlModForClass(cd.get());
  m_output.closeList();
 
  m_output.openList("concepts");
  for (const auto &cd : *Doxygen::conceptLinkedMap)
    generatePerlModForConcept(cd.get());
  m_output.closeList();
 
  m_output.openList("modules");
  for (const auto &mod : ModuleManager::instance().modules())
    generatePerlModForModule(mod.get());
  m_output.closeList();
 
  m_output.openList("namespaces");
  for (const auto &nd : *Doxygen::namespaceLinkedMap)
    generatePerlModForNamespace(nd.get());
  m_output.closeList();
 
  m_output.openList("files");
  for (const auto &fn : *Doxygen::inputNameLinkedMap)
  {
    for (const auto &fd : *fn)
    {
      generatePerlModForFile(fd.get());
    }
  }
  m_output.closeList();
 
  m_output.openList("groups");
  for (const auto &gd : *Doxygen::groupLinkedMap)
  {
    generatePerlModForGroup(gd.get());
  }
  m_output.closeList();
 
  m_output.openList("pages");
  for (const auto &pd : *Doxygen::pageLinkedMap)
  {
    generatePerlModForPage(pd.get());
  }
  if (Doxygen::mainPage)
  {
    generatePerlModForPage(Doxygen::mainPage.get());
  }
  m_output.closeList();
 
  m_output.closeHash().add(";\n1;\n");
  m_output.reset();
  return true;
}

References Doxygen::classLinkedMap, Doxygen::conceptLinkedMap, createOutputFile(), generatePerlModForClass(), generatePerlModForConcept(), generatePerlModForFile(), generatePerlModForGroup(), generatePerlModForModule(), generatePerlModForNamespace(), generatePerlModForPage(), Doxygen::groupLinkedMap, Doxygen::inputNameLinkedMap, ModuleManager::instance(), m_output, Doxygen::mainPage, Doxygen::namespaceLinkedMap, Doxygen::pageLinkedMap, and pathDoxyDocsPM.

Referenced by generate().

◆ generatePerlModSection()

void PerlModGenerator::generatePerlModSection	(	const Definition *	d,
		MemberList *	ml,
		const QCString &	name,
		const QCString &	header = QCString() )

Definition at line 1645 of file perlmodgen.cpp.

{
  if (ml==nullptr) return; // empty list
 
  m_output.openHash(name);
 
  if (!header.isEmpty())
    m_output.addFieldQuotedString("header", header);
 
  m_output.openList("members");
  for (const auto &md : *ml)
  {
    generatePerlModForMember(md,d);
  }
  m_output.closeList()
    .closeHash();
}

References generatePerlModForMember(), QCString::isEmpty(), and m_output.

Referenced by generatePerlModForClass(), generatePerlModForFile(), generatePerlModForGroup(), generatePerlModForModule(), and generatePerlModForNamespace().

◆ generatePerlUserDefinedSection()

void PerlModGenerator::generatePerlUserDefinedSection	(	const Definition *	d,
		const MemberGroupList &	mgl )

Definition at line 1689 of file perlmodgen.cpp.

{
  if (!mgl.empty())
  {
    m_output.openList("user_defined");
    for (const auto &mg : mgl)
    {
      m_output.openHash();
      if (!mg->header().isEmpty())
      {
        m_output.addFieldQuotedString("header", mg->header());
      }
 
      if (!mg->members().empty())
      {
        m_output.openList("members");
        for (const auto &md : mg->members())
        {
          generatePerlModForMember(md, d);
        }
        m_output.closeList();
      }
      m_output.closeHash();
    }
    m_output.closeList();
  }
}

References generatePerlModForMember(), and m_output.

Referenced by generatePerlModForClass(), generatePerlModForFile(), generatePerlModForGroup(), generatePerlModForModule(), and generatePerlModForNamespace().

Member Data Documentation

◆ m_output

PerlModOutput PerlModGenerator::m_output

Definition at line 1424 of file perlmodgen.cpp.

Referenced by addIncludeInfo(), addListOfAllMembers(), generatePerlModForClass(), generatePerlModForConcept(), generatePerlModForFile(), generatePerlModForGroup(), generatePerlModForMember(), generatePerlModForModule(), generatePerlModForNamespace(), generatePerlModForPage(), generatePerlModOutput(), generatePerlModSection(), generatePerlUserDefinedSection(), and PerlModGenerator().

◆ pathDoxyDocsPM

QCString PerlModGenerator::pathDoxyDocsPM

Definition at line 1433 of file perlmodgen.cpp.

Referenced by generate(), generateDoxyRules(), and generatePerlModOutput().

◆ pathDoxyDocsTex

QCString PerlModGenerator::pathDoxyDocsTex

Definition at line 1427 of file perlmodgen.cpp.

Referenced by generate(), generateDoxyLatexTex(), and generateDoxyRules().

◆ pathDoxyFormatTex

QCString PerlModGenerator::pathDoxyFormatTex

Definition at line 1428 of file perlmodgen.cpp.

Referenced by generate(), generateDoxyFormatTex(), and generateDoxyRules().

◆ pathDoxyLatexDVI

QCString PerlModGenerator::pathDoxyLatexDVI

Definition at line 1430 of file perlmodgen.cpp.

Referenced by generate(), and generateDoxyRules().

◆ pathDoxyLatexPDF

QCString PerlModGenerator::pathDoxyLatexPDF

Definition at line 1431 of file perlmodgen.cpp.

Referenced by generate(), and generateDoxyRules().

◆ pathDoxyLatexPL

QCString PerlModGenerator::pathDoxyLatexPL

Definition at line 1434 of file perlmodgen.cpp.

Referenced by generate(), generateDoxyLatexPL(), and generateDoxyRules().

◆ pathDoxyLatexStructurePL

QCString PerlModGenerator::pathDoxyLatexStructurePL

Definition at line 1435 of file perlmodgen.cpp.

Referenced by generate(), generateDoxyLatexStructurePL(), and generateDoxyRules().

◆ pathDoxyLatexTex

QCString PerlModGenerator::pathDoxyLatexTex

Definition at line 1429 of file perlmodgen.cpp.

Referenced by generate(), generateDoxyLatexTex(), and generateDoxyRules().

◆ pathDoxyRules

QCString PerlModGenerator::pathDoxyRules

Definition at line 1436 of file perlmodgen.cpp.

Referenced by generate(), generateDoxyRules(), and generateMakefile().

◆ pathDoxyStructurePM

QCString PerlModGenerator::pathDoxyStructurePM

Definition at line 1426 of file perlmodgen.cpp.

Referenced by generate(), generateDoxyRules(), and generateDoxyStructurePM().

◆ pathDoxyStructureTex

QCString PerlModGenerator::pathDoxyStructureTex

Definition at line 1432 of file perlmodgen.cpp.

Referenced by generate(), generateDoxyFormatTex(), and generateDoxyRules().

◆ pathMakefile

QCString PerlModGenerator::pathMakefile

Definition at line 1437 of file perlmodgen.cpp.

Referenced by generate(), and generateMakefile().

The documentation for this class was generated from the following file:

src/perlmodgen.cpp

Public Attributes
PerlModOutput	m_output
QCString	pathDoxyStructurePM
QCString	pathDoxyDocsTex
QCString	pathDoxyFormatTex
QCString	pathDoxyLatexTex
QCString	pathDoxyLatexDVI
QCString	pathDoxyLatexPDF
QCString	pathDoxyStructureTex
QCString	pathDoxyDocsPM
QCString	pathDoxyLatexPL
QCString	pathDoxyLatexStructurePL
QCString	pathDoxyRules
QCString	pathMakefile

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PerlModGenerator()

Member Function Documentation

◆ addIncludeInfo()

◆ addListOfAllMembers()

◆ createOutputDir()

◆ createOutputFile()

◆ generate()

◆ generateDoxyFormatTex()

◆ generateDoxyLatexPL()

◆ generateDoxyLatexStructurePL()

◆ generateDoxyLatexTex()

◆ generateDoxyRules()

◆ generateDoxyStructurePM()

◆ generateMakefile()

◆ generatePerlModForClass()

◆ generatePerlModForConcept()

◆ generatePerlModForFile()

◆ generatePerlModForGroup()

◆ generatePerlModForMember()

◆ generatePerlModForModule()

◆ generatePerlModForNamespace()

◆ generatePerlModForPage()

◆ generatePerlModOutput()

◆ generatePerlModSection()

◆ generatePerlUserDefinedSection()

Member Data Documentation

◆ m_output

◆ pathDoxyDocsPM

◆ pathDoxyDocsTex

◆ pathDoxyFormatTex

◆ pathDoxyLatexDVI

◆ pathDoxyLatexPDF

◆ pathDoxyLatexPL

◆ pathDoxyLatexStructurePL

◆ pathDoxyLatexTex

◆ pathDoxyRules

◆ pathDoxyStructurePM

◆ pathDoxyStructureTex

◆ pathMakefile