latexgen.cpp

doxygen(一个自动从源代码生成文档的工具)的源代码

void LatexGenerator::docify(const char *str)
{
  static bool isCzech     = theTranslator->idLanguage()=="czech";
  static bool isJapanese  = theTranslator->idLanguage()=="japanese";
  static bool isKorean    = theTranslator->idLanguage()=="korean";
  static bool isRussian   = theTranslator->idLanguage()=="russian";
  static bool isUkrainian = theTranslator->idLanguage()=="ukrainian";
  static bool isChinese   = theTranslator->idLanguage()=="chinese";
  static bool isLatin2    = theTranslator->idLanguageCharset()=="iso-8859-2";
  if (str)
  {
    const unsigned char *p=(const unsigned char *)str;
    unsigned char c;
    unsigned char pc='\0';
    while (*p)
    {
      c=*p++;
      if (insidePre)
      {
        switch(c)
        {
          case '\\': t << "\\(\\backslash\\)"; break;
          case '{':  t << "\\{"; break;
          case '}':  t << "\\}"; break;
          default: t << (char)c; break;
        }
      }
      else
      {
        switch(c)
        {
          case '#':  t << "\\#";           break;
          case '$':  t << "\\$";           break;
          case '%':  t << "\\%";           break;
          case '^':  t << "$^\\wedge$";    break;
          case '&':  t << "\\&";           break;
          case '*':  t << "$\\ast$";       break;
          case '_':  t << "\\_"; 
                     if (!insideTabbing) t << "\\-";  
                     break;
          case '{':  t << "\\{";           break;
          case '}':  t << "\\}";           break;
          case '<':  t << "$<$";           break;
          case '>':  t << "$>$";           break;
          case '|':  t << "$|$";           break;
          case '~':  t << "$\\sim$";       break;
          case '[':  if (Config_getBool("PDF_HYPERLINKS")) 
                       t << "\\mbox{[}"; 
                     else 
                       t << "[";
                     break;
          case ']':  if (pc=='[') t << "$\\,$";
                       if (Config_getBool("PDF_HYPERLINKS"))
                         t << "\\mbox{]}";
                       else
                         t << "]";             
                     break;
          case '-':  if (*p=='>') 
                       { t << " $\\rightarrow$ "; p++; }
                     else
                     { t << (char)c; }
                     break;
          case '\\': if (*p=='<') 
                       { t << "$<$"; p++; }
                     else if (*p=='>')
                     { t << "$>$"; p++; } 
                     else  
                     { t << "$\\backslash$"; }
                     break;           
          case '"':  { t << "\\char`\\\"{}"; }
                     break;

          default:   
             // Some languages uses wide characters
             if (isJapanese || isKorean || isChinese)
             { 
               if (c>=128) 
               {
                 t << (char)c;
                 if (*p)  
                 {
                   c = *p++;
                   t << (char)c;
                 }
               }
               else // ascii char => see if we can insert a hypenation hint
               {
                 if (isupper(c) && islower(pc) && !insideTabbing) t << "\\-";
                 t << (char)c;    
               } 
             }
             else if (isCzech || isRussian || isUkrainian)
             {
               if (c>=128)
               {
                 t << (char)c;
               }
               else // ascii char => see if we can insert a hypenation hint
               {
                 if (isupper(c) && islower(pc) && !insideTabbing) t << "\\-";
                 t << (char)c;
               }
             }
	     else if (isLatin2)
	     {
               if (c>=128)
               {
                 latin2ToLatex(c);
               }
               else
               { 
                 // see if we can insert an hyphenation hint
                 if (isupper(c) && islower(pc) && !insideTabbing) t << "\\-";
                 t << (char)c;
               }
	     }
             else // language is other than Czech, Russian or Japanese
             {
               switch(c)
               {
                 // the Latin-1 characters
                 case 161: t << "!`";            break;
                 case 181: t << "$\\mu$";        break;
                 case 191: t << "?`";            break;
                 case 192: t << "\\`{A}";        break;
                 case 193: t << "\\'{A}";        break;
                 case 194: t << "\\^{A}";        break;
                 case 195: t << "\\~{A}";        break;
                 case 196: t << "\\\"{A}";       break;
                 case 197: t << "\\AA{}";         break;
                 case 198: t << "\\AE{}";         break;
                 case 199: t << "\\c{C}";        break;
                 case 200: t << "\\`{E}";        break;
                 case 201: t << "\\'{E}";        break;
                 case 202: t << "\\^{E}";        break;
                 case 203: t << "\\\"{E}";       break;
                 case 204: t << "\\`{I}";        break;
                 case 205: t << "\\'{I}";        break;
                 case 206: t << "\\^{I}";        break;
                 case 207: t << "\\\"{I}";       break;
                 case 208: t << "D ";            break; // anyone know the real code?
                 case 209: t << "\\~{N}";        break;
                 case 210: t << "\\`{O}";        break;
                 case 211: t << "\\'{O}";        break;
                 case 212: t << "\\^{O}";        break;
                 case 213: t << "\\~{O}";        break;
                 case 214: t << "\\\"{O}";       break;
                 case 215: t << "$\\times$";     break;
                 case 216: t << "\\O";           break;
                 case 217: t << "\\`{U}";        break;
                 case 218: t << "\\'{U}";        break;
                 case 219: t << "\\^{U}";        break;
                 case 220: t << "\\\"{U}";       break;
                 case 221: t << "\\'{Y}";        break;
                 case 223: t << "\\ss{}";         break; 
                 case 224: t << "\\`{a}";        break;
                 case 225: t << "\\'{a}";        break;
                 case 226: t << "\\^{a}";        break;
                 case 227: t << "\\~{a}";        break;
                 case 228: t << "\\\"{a}";       break;
                 case 229: t << "\\aa{}";         break;
                 case 230: t << "\\ae{}";         break;
                 case 231: t << "\\c{c}";        break;
                 case 232: t << "\\`{e}";        break;
                 case 233: t << "\\'{e}";        break;
                 case 234: t << "\\^{e}";        break;
                 case 235: t << "\\\"{e}";       break;
                 case 236: t << "\\`{\\i}";      break;
                 case 237: t << "\\'{\\i}";      break;
                 case 238: t << "\\^{\\i}";      break;
                 case 239: t << "\\\"{\\i}";     break;
                 case 241: t << "\\~{n}";        break;
                 case 242: t << "\\`{o}";        break;
                 case 243: t << "\\'{o}";        break;
                 case 244: t << "\\^{o}";        break;
                 case 245: t << "\\~{o}";        break;
                 case 246: t << "\\\"{o}";       break;
                 case 248: t << "\\o{}";          break;
                 case 249: t << "\\`{u}";        break;
                 case 250: t << "\\'{u}";        break;
                 case 251: t << "\\^{u}";        break;
                 case 252: t << "\\\"{u}";       break;
                 case 253: t << "\\'{y}";        break;
                 case 255: t << "\\\"{y}";       break;           
                 default: // normal ascii char 
                           { 
                             // see if we can insert an hyphenation hint
                             if (isupper(c) && islower(pc) && !insideTabbing) t << "\\-";
                             t << (char)c;    
                           }
               }
             }
        }
      }
      pc = c;
    }
  }
}

void LatexGenerator::codify(const char *str)
{
  if (str)
  { 
    const char *p=str;
    char c;
    int spacesToNextTabStop;
    int &tabSize = Config_getInt("TAB_SIZE");
    while (*p)
    {
      c=*p++;
      switch(c)
      {
        case 0x0c: break; // remove ^L
        case '\t': spacesToNextTabStop =
                         tabSize - (col%tabSize);
                   t << spaces.left(spacesToNextTabStop); 
                   col+=spacesToNextTabStop;
                   break; 
        case '\n': t << '\n'; col=0;                    break;
        default:   t << c;    col++;                    break;
      }
    }
  }
}

void LatexGenerator::writeChar(char c)
{
  char cs[2];
  cs[0]=c;
  cs[1]=0;
  docify(cs);
}

void LatexGenerator::startClassDiagram()
{
  //if (Config_getBool("COMPACT_LATEX")) t << "\\subsubsection"; else t << "\\subsection";
  //t << "{";
}

void LatexGenerator::endClassDiagram(ClassDiagram &d,
                                       const char *fileName,const char *)
{
  d.writeFigure(t,dir,fileName);
}

void LatexGenerator::writeFormula(const char *,const char *text)
{
  t << text;
}

void LatexGenerator::startMemberItem(int annType) 
{ 
  if (!insideTabbing)
  {
    t << "\\item " << endl; 
    switch(annType)
    {
      case 0: break;
      case 1:
      default: 
        t << "\\begin{tabbing}" << endl;
        t << "xx\\=xx\\=xx\\=xx\\=xx\\=xx\\=xx\\=xx\\=xx\\=\\kill" << endl;
        //printf("LatexGenerator::startMemberItem() insideTabbing=TRUE\n");
        insideTabbing=TRUE;
        break;
    }
  }
}

void LatexGenerator::endMemberItem(bool endItem) 
{
  if (insideTabbing && endItem)
  {
    t << endl << "\\end{tabbing}";
    //printf("LatexGenerator::endMemberItem() insideTabbing=FALSE\n");
    insideTabbing=FALSE;
  }
  if (insideTabbing)
  {
    t << "\\\\";
  } 
  t << endl; 
}

void LatexGenerator::writeNonBreakableSpace(int) 
{
  if (insideTabbing)
    t << "\\>";
  else
    t << "\\ "; 
}

void LatexGenerator::startMemberList()  
{ 
  if (!insideTabbing)
    t << "\\begin{CompactItemize}" << endl; 
}

void LatexGenerator::endMemberList()    
{
  if (!insideTabbing)
    t << "\\end{CompactItemize}"   << endl; 
}

void LatexGenerator::startImage(const char *name,const char *size,bool hasCaption)
{
  if (hasCaption)
  {
    t << "\\begin{figure}[H]" << endl;
    t << "\\begin{center}" << endl;
  }
  else
  {
    t << "\\mbox{";
  }
  QCString gfxName = name;
  if (gfxName.right(4)==".eps") gfxName.left(gfxName.length()-4);
  //     "\\epsfig{file=" << name;
  t << "\\includegraphics";
  if (size) t << "[" << size << "]";
  t << "{" << gfxName << "}";
  if (hasCaption) 
  {
    t << "\\caption{";
  }
  else
  {
    t << "}" << endl;
  }
}

void LatexGenerator::endImage(bool hasCaption)
{
  if (hasCaption)
  {
    t << "}" << endl;
    t << "\\end{center}" << endl;
    t << "\\end{figure}" << endl;
  }
}

void LatexGenerator::startDotFile(const char *name,bool hasCaption)
{
  QCString baseName=name;
  int i;
  if ((i=baseName.findRev('/'))!=-1 || (i=baseName.findRev('\\'))!=-1)
  {
    baseName=baseName.right(baseName.length()-i-1); 
  }
  QCString outName = Config_getString("LATEX_OUTPUT")+
#ifdef _WIN32
    "\\"
#else
    "/"
#endif
    +baseName;
  writeDotGraphFromFile(name,outName,EPS);
  if (hasCaption)
    t << "\\begin{figure}[H]" << endl;
  else
    t << "\\mbox{";
  t << "\\includegraphics";
  t << "{" << baseName << ".eps}";
  if (hasCaption) 
    t << "\\caption{";
  else
    t << "}" << endl;
}

void LatexGenerator::endDotFile(bool hasCaption)
{
  if (hasCaption)
  {
    t << "}" << endl;
    t << "\\end{figure}" << endl;
  }
}


void LatexGenerator::startMemberGroupHeader(bool hasHeader)
{
  if (hasHeader) t << "\\begin{Indent}";
  t << "{\\bf ";
}

void LatexGenerator::endMemberGroupHeader()
{
  t << "}\\par" << endl;
}

void LatexGenerator::startMemberGroupDocs()
{
  t << "{\\em ";
}

void LatexGenerator::endMemberGroupDocs()
{
  t << "}";
}

void LatexGenerator::startMemberGroup()
{
}

void LatexGenerator::endMemberGroup(bool hasHeader)
{
  if (hasHeader)t << "\\end{Indent}"; 
  t << endl;
}

void LatexGenerator::startDotGraph() 
{
}

void LatexGenerator::endDotGraph(DotClassGraph &g) 
{
  g.writeGraph(t,EPS,Config_getString("LATEX_OUTPUT"));
}

void LatexGenerator::startInclDepGraph() 
{
}

void LatexGenerator::endInclDepGraph(DotInclDepGraph &g) 
{
  g.writeGraph(t,EPS,Config_getString("LATEX_OUTPUT"));
}

void LatexGenerator::startDescription() 
{ 
  t << "\\begin{description}" << endl; 
}

void LatexGenerator::endDescription()   
{ 
  t << "\\end{description}" << endl; 
  firstDescItem=TRUE;
}

void LatexGenerator::startDescItem()    
{ 
  firstDescItem=TRUE;
  t << "\\item["; 
}

void LatexGenerator::endDescItem()      
{ 
  if (firstDescItem) 
  {
    t << "]" << endl;
    firstDescItem=FALSE;
  } 
  else
  {
    lineBreak();
  }
}