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 DString &name, const DString &header=DString())
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 DString &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 1440 of file perlmodgen.cpp.

Constructor & Destructor Documentation

◆ PerlModGenerator()

PerlModGenerator::PerlModGenerator ( bool pretty )

inline

Definition at line 1459 of file perlmodgen.cpp.

1459: m_output(pretty) { }

PerlModGenerator::m_output

PerlModOutput m_output

Definition perlmodgen.cpp:1444

References m_output.

Member Function Documentation

◆ addIncludeInfo()

void PerlModGenerator::addIncludeInfo ( const IncludeInfo * ii )

Definition at line 1718 of file perlmodgen.cpp.

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

References PerlModOutput::addFieldBoolean(), PerlModOutput::addFieldQuotedString(), PerlModOutput::closeHash(), FileDef::docName(), DString::empty(), IncludeInfo::fileDef, ImportLocal, IncludeLocal, IncludeInfo::includeName, IncludeInfo::kind, m_output, and PerlModOutput::openHash().

Referenced by generatePerlModForClass(), and generatePerlModForConcept().

◆ addListOfAllMembers()

void PerlModGenerator::addListOfAllMembers ( const ClassDef * cd )

Definition at line 1665 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().empty())
        m_output.addFieldQuotedString("ambiguity_scope", mi->ambiguityResolutionScope());
 
      m_output.addFieldQuotedString("scope", mcd->name())
        .closeHash();
    }
  }
  m_output.closeList();
}

References PerlModOutput::addFieldQuotedString(), PerlModOutput::closeHash(), PerlModOutput::closeList(), MemberDef::getClassDef(), getProtectionName(), getVirtualnessName(), m_output, ClassDef::memberNameInfoLinkedMap(), Definition::name(), PerlModOutput::openHash(), PerlModOutput::openList(), and MemberDef::virtualness().

Referenced by generatePerlModForClass().

◆ createOutputDir()

bool PerlModGenerator::createOutputDir ( Dir & perlModDir )

Definition at line 2247 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 DString &	s )

Definition at line 2236 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 2906 of file perlmodgen.cpp.

{
  // + classes
  // + namespaces
  // + files
  // - packages
  // + groups
  // + related pages
  // - examples
 
  Dir perlModDir;
  if (!createOutputDir(perlModDir))
    return;
 
  bool perlmodLatex = Config_getBool(PERLMOD_LATEX);
 
  DString 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 2719 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 2597 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 2564 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 2881 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 2442 of file perlmodgen.cpp.

{
  std::ofstream doxyRulesStream;
  if (!createOutputFile(doxyRulesStream, pathDoxyRules))
    return false;
 
  bool perlmodLatex = Config_getBool(PERLMOD_LATEX);
  DString 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 2259 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 2538 of file perlmodgen.cpp.

{
  std::ofstream makefileStream;
  if (!createOutputFile(makefileStream, pathMakefile))
    return false;
 
  bool perlmodLatex = Config_getBool(PERLMOD_LATEX);
  DString 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 1734 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->briefFile(),cd->briefLine(),cd,nullptr,cd->briefDescription());
  addPerlModDocBlock(m_output,"detailed",cd->docFile(),cd->docLine(),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 PerlModOutput::addFieldQuotedString(), addIncludeInfo(), addListOfAllMembers(), addPerlModDocBlock(), addTemplateList(), ClassDef::baseClasses(), Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), PerlModOutput::closeHash(), PerlModOutput::closeList(), ClassDef::compoundTypeString(), Definition::docFile(), Definition::docLine(), 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(), PerlModOutput::openHash(), PerlModOutput::openList(), and ClassDef::subClasses().

Referenced by generatePerlModOutput().

◆ generatePerlModForConcept()

void PerlModGenerator::generatePerlModForConcept ( const ConceptDef * cd )

Definition at line 1860 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->briefFile(),cd->briefLine(),nullptr,nullptr,cd->briefDescription());
  addPerlModDocBlock(m_output,"detailed",cd->docFile(),cd->docLine(),nullptr,nullptr,cd->documentation());
 
  m_output.closeHash();
}

References PerlModOutput::addFieldQuotedString(), addIncludeInfo(), addPerlModDocBlock(), addTemplateList(), Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), PerlModOutput::closeHash(), Definition::docFile(), Definition::docLine(), Definition::documentation(), ConceptDef::includeInfo(), ConceptDef::initializer(), Definition::isReference(), m_output, Definition::name(), and PerlModOutput::openHash().

Referenced by generatePerlModOutput().

◆ generatePerlModForFile()

void PerlModGenerator::generatePerlModForFile ( const FileDef * fd )

Definition at line 1987 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->briefFile(),fd->briefLine(),nullptr,nullptr,fd->briefDescription());
  addPerlModDocBlock(m_output,"detailed",fd->docFile(),fd->docLine(),nullptr,nullptr,fd->documentation());
 
  m_output.closeHash();
}

References PerlModOutput::addFieldQuotedString(), addPerlModDocBlock(), Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), PerlModOutput::closeHash(), PerlModOutput::closeList(), Definition::docFile(), Definition::docLine(), Definition::documentation(), generatePerlModSection(), generatePerlUserDefinedSection(), FileDef::getMemberGroups(), FileDef::getMemberList(), FileDef::includedByFileList(), FileDef::includeFileList(), Definition::isReference(), m_output, Definition::name(), PerlModOutput::openHash(), and PerlModOutput::openList().

Referenced by generatePerlModOutput().

◆ generatePerlModForGroup()

void PerlModGenerator::generatePerlModForGroup ( const GroupDef * gd )

Definition at line 2049 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->briefFile(),gd->briefLine(),nullptr,nullptr,gd->briefDescription());
  addPerlModDocBlock(m_output,"detailed",gd->docFile(),gd->docLine(),nullptr,nullptr,gd->documentation());
 
  m_output.closeHash();
}

References PerlModOutput::addFieldQuotedString(), addPerlModDocBlock(), Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), PerlModOutput::closeHash(), PerlModOutput::closeList(), Definition::docFile(), Definition::docLine(), Definition::documentation(), LinkedRefMap< T, Hash, KeyEqual, Map >::empty(), generatePerlModSection(), generatePerlUserDefinedSection(), GroupDef::getClasses(), GroupDef::getConcepts(), GroupDef::getFiles(), GroupDef::getMemberGroups(), GroupDef::getMemberList(), GroupDef::getModules(), GroupDef::getNamespaces(), GroupDef::getPages(), GroupDef::getSubGroups(), GroupDef::groupTitle(), Definition::isReference(), m_output, Definition::name(), PerlModOutput::openHash(), and PerlModOutput::openList().

Referenced by generatePerlModOutput().

◆ generatePerlModForMember()

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

Definition at line 1489 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())
 
  DString memType = to_string_lower(md->memberType());
  DString name;
  bool isFunc=to_isFunction(md->memberType());
 
  bool isFortran = md->getLanguage()==SrcLangExt::Fortran;
  name = md->name();
  if (md->isAnonymous()) name = "__unnamed" + name.mid(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->briefFile(),md->briefLine(),md->getOuterScope(),md,md->briefDescription());
  addPerlModDocBlock(m_output,"detailed",md->docFile(),md->docLine(),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.empty())
          m_output.addFieldQuotedString("declaration_name", a.name);
 
        if (defArg && !defArg->name.empty() && defArg->name!=a.name)
          m_output.addFieldQuotedString("definition_name", defArg->name);
 
        if (isFortran && defArg && !defArg->type.empty())
          m_output.addFieldQuotedString("type", defArg->type);
        else if (!a.type.empty())
          m_output.addFieldQuotedString("type", a.type);
 
        if (!a.array.empty())
          m_output.addFieldQuotedString("array", a.array);
 
        if (!a.defval.empty())
          m_output.addFieldQuotedString("default_value", a.defval);
 
        if (!a.attrib.empty())
          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().empty())
    m_output.addFieldQuotedString("initializer", md->initializer());
 
  if (!md->excpString().empty())
    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().empty())
          m_output.addFieldQuotedString("initializer", emd->initializer());
 
        addPerlModDocBlock(m_output,"brief",emd->briefFile(),emd->briefLine(),emd->getOuterScope(),emd,emd->briefDescription());
 
        addPerlModDocBlock(m_output,"detailed",emd->docFile(),emd->docLine(),emd->getOuterScope(),emd,emd->documentation());
 
        m_output.closeHash();
      }
      m_output.closeList();
    }
  }
 
  if (md->memberType() == MemberType::Variable && !md->bitfieldString().empty())
  {
    DString 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 PerlModOutput::addFieldBoolean(), PerlModOutput::addFieldQuotedString(), addPerlModDocBlock(), MemberDef::argsString(), MemberDef::argumentList(), DString::at(), ArgumentList::begin(), MemberDef::bitfieldString(), Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), PerlModOutput::closeHash(), PerlModOutput::closeList(), ArgumentList::constSpecifier(), MemberDef::declArgumentList(), Definition::docFile(), Definition::docLine(), Definition::documentation(), ArgumentList::empty(), DString::empty(), MemberVector::empty(), ArgumentList::end(), MemberDef::enumBaseType(), MemberDef::enumFieldList(), MemberDef::excpString(), Definition::getLanguage(), Definition::getOuterScope(), getProtectionName(), getVirtualnessName(), MemberDef::initializer(), Definition::isAnonymous(), MemberDef::isStatic(), m_output, MemberDef::memberType(), DString::mid(), Argument::name, Definition::name(), PerlModOutput::openHash(), PerlModOutput::openList(), MemberDef::protection(), MemberDef::reimplementedBy(), MemberDef::reimplements(), Argument::type, MemberDef::typeString(), MemberDef::virtualness(), and ArgumentList::volatileSpecifier().

Referenced by generatePerlModSection(), and generatePerlUserDefinedSection().

◆ generatePerlModForModule()

void PerlModGenerator::generatePerlModForModule ( const ModuleDef * mod )

Definition at line 1876 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->briefFile(),mod->briefLine(),nullptr,nullptr,mod->briefDescription());
  addPerlModDocBlock(m_output,"detailed",mod->docFile(),mod->docLine(),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 PerlModOutput::addFieldQuotedString(), addPerlModDocBlock(), Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), PerlModOutput::closeHash(), PerlModOutput::closeList(), Definition::docFile(), Definition::docLine(), Definition::documentation(), LinkedRefMap< T, Hash, KeyEqual, Map >::empty(), generatePerlModSection(), generatePerlUserDefinedSection(), ModuleDef::getClasses(), ModuleDef::getConcepts(), ModuleDef::getMemberGroups(), ModuleDef::getMemberList(), ModuleDef::getUsedFiles(), Definition::isReference(), m_output, Definition::name(), PerlModOutput::openHash(), and PerlModOutput::openList().

Referenced by generatePerlModOutput().

◆ generatePerlModForNamespace()

void PerlModGenerator::generatePerlModForNamespace ( const NamespaceDef * nd )

Definition at line 1936 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->briefFile(),nd->briefLine(),nullptr,nullptr,nd->briefDescription());
  addPerlModDocBlock(m_output,"detailed",nd->docFile(),nd->docLine(),nullptr,nullptr,nd->documentation());
 
  m_output.closeHash();
}

References PerlModOutput::addFieldQuotedString(), addPerlModDocBlock(), Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), PerlModOutput::closeHash(), PerlModOutput::closeList(), Definition::docFile(), Definition::docLine(), Definition::documentation(), LinkedRefMap< T, Hash, KeyEqual, Map >::empty(), generatePerlModSection(), generatePerlUserDefinedSection(), NamespaceDef::getClasses(), NamespaceDef::getMemberGroups(), NamespaceDef::getMemberList(), NamespaceDef::getNamespaces(), Definition::isReference(), m_output, Definition::name(), PerlModOutput::openHash(), and PerlModOutput::openList().

Referenced by generatePerlModOutput().

◆ generatePerlModForPage()

void PerlModGenerator::generatePerlModForPage ( PageDef * pi )

Definition at line 2154 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 PerlModOutput::addFieldQuotedString(), addPerlModDocBlock(), PerlModOutput::closeHash(), Definition::docFile(), Definition::docLine(), Definition::documentation(), filterTitle(), LinkedMap< T, Hash, KeyEqual, Map >::find(), SectionManager::instance(), Definition::isReference(), m_output, Definition::name(), PerlModOutput::openHash(), and SectionInfo::title().

Referenced by generatePerlModOutput().

◆ generatePerlModOutput()

bool PerlModGenerator::generatePerlModOutput ( )

Definition at line 2173 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 PerlModOutput::add(), Doxygen::classLinkedMap, PerlModOutput::closeHash(), PerlModOutput::closeList(), Doxygen::conceptLinkedMap, createOutputFile(), generatePerlModForClass(), generatePerlModForConcept(), generatePerlModForFile(), generatePerlModForGroup(), generatePerlModForModule(), generatePerlModForNamespace(), generatePerlModForPage(), Doxygen::groupLinkedMap, Doxygen::inputNameLinkedMap, ModuleManager::instance(), m_output, Doxygen::mainPage, Doxygen::namespaceLinkedMap, PerlModOutput::openHash(), PerlModOutput::openList(), Doxygen::pageLinkedMap, pathDoxyDocsPM, PerlModOutput::reset(), and PerlModOutput::setPerlModOutputStream().

Referenced by generate().

◆ generatePerlModSection()

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

Definition at line 1646 of file perlmodgen.cpp.

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

References PerlModOutput::addFieldQuotedString(), PerlModOutput::closeHash(), PerlModOutput::closeList(), DString::empty(), generatePerlModForMember(), m_output, PerlModOutput::openHash(), and PerlModOutput::openList().

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

◆ generatePerlUserDefinedSection()

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

Definition at line 1690 of file perlmodgen.cpp.

{
  if (!mgl.empty())
  {
    m_output.openList("user_defined");
    for (const auto &mg : mgl)
    {
      m_output.openHash();
      if (!mg->header().empty())
      {
        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 PerlModOutput::addFieldQuotedString(), PerlModOutput::closeHash(), PerlModOutput::closeList(), generatePerlModForMember(), m_output, PerlModOutput::openHash(), and PerlModOutput::openList().

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

Member Data Documentation

◆ m_output

PerlModOutput PerlModGenerator::m_output

Definition at line 1444 of file perlmodgen.cpp.

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

◆ pathDoxyDocsPM

DString PerlModGenerator::pathDoxyDocsPM

Definition at line 1453 of file perlmodgen.cpp.

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

◆ pathDoxyDocsTex

DString PerlModGenerator::pathDoxyDocsTex

Definition at line 1447 of file perlmodgen.cpp.

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

◆ pathDoxyFormatTex

DString PerlModGenerator::pathDoxyFormatTex

Definition at line 1448 of file perlmodgen.cpp.

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

◆ pathDoxyLatexDVI

DString PerlModGenerator::pathDoxyLatexDVI

Definition at line 1450 of file perlmodgen.cpp.

Referenced by generate(), and generateDoxyRules().

◆ pathDoxyLatexPDF

DString PerlModGenerator::pathDoxyLatexPDF

Definition at line 1451 of file perlmodgen.cpp.

Referenced by generate(), and generateDoxyRules().

◆ pathDoxyLatexPL

DString PerlModGenerator::pathDoxyLatexPL

Definition at line 1454 of file perlmodgen.cpp.

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

◆ pathDoxyLatexStructurePL

DString PerlModGenerator::pathDoxyLatexStructurePL

Definition at line 1455 of file perlmodgen.cpp.

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

◆ pathDoxyLatexTex

DString PerlModGenerator::pathDoxyLatexTex

Definition at line 1449 of file perlmodgen.cpp.

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

◆ pathDoxyRules

DString PerlModGenerator::pathDoxyRules

Definition at line 1456 of file perlmodgen.cpp.

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

◆ pathDoxyStructurePM

DString PerlModGenerator::pathDoxyStructurePM

Definition at line 1446 of file perlmodgen.cpp.

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

◆ pathDoxyStructureTex

DString PerlModGenerator::pathDoxyStructureTex

Definition at line 1452 of file perlmodgen.cpp.

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

◆ pathMakefile

DString PerlModGenerator::pathMakefile

Definition at line 1457 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
DString	pathDoxyStructurePM
DString	pathDoxyDocsTex
DString	pathDoxyFormatTex
DString	pathDoxyLatexTex
DString	pathDoxyLatexDVI
DString	pathDoxyLatexPDF
DString	pathDoxyStructureTex
DString	pathDoxyDocsPM
DString	pathDoxyLatexPL
DString	pathDoxyLatexStructurePL
DString	pathDoxyRules
DString	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