/******************************************************************************

 *

 * 

 *

 *

 *

 * Permission to use, copy, modify, and distribute this software and its

 * documentation under the terms of the GNU General Public License is hereby 

 * granted. No representations are made about the suitability of this software 

 * for any purpose. It is provided "as is" without express or implied warranty.

 * See the GNU General Public License for more details.

 *

 * Documents produced by Doxygen are derivative works derived from the

 * input used in their production; they are not affected by this license.

 *

 */

#include <stdlib.h>

#include "qtbc.h"

#include "xmlgen.h"

#include "doxygen.h"

#include "message.h"

#include "config.h"

#include "classlist.h"

#include "util.h"

#include "defargs.h"

#include "outputgen.h"

#include "dot.h"

#include "pagedef.h"

#include "filename.h"

#include "version.h"

#include "xmldocvisitor.h"

#include "docparser.h"

#include "language.h"

#include "parserintf.h"

#include <qdir.h>

#include <qfile.h>

#include <qtextstream.h>

#include <qintdict.h>

// no debug info

#define XML_DB(x) do {} while(0)

// debug to stdout

//#define XML_DB(x) printf x

// debug inside output

//#define XML_DB(x) QCString __t;__t.sprintf x;m_t << __t

//------------------

static const char index_xsd[] =

#include "index_xsd.h"

;

//------------------

//

static const char compound_xsd[] =

#include "compound_xsd.h"

;

//------------------

class XmlSectionMapper : public QIntDict<char>

{

  public:

    XmlSectionMapper() : QIntDict<char>(47)

    {

      insert(MemberList::pubTypes,"public-type");

      insert(MemberList::pubMethods,"public-func");

      insert(MemberList::pubAttribs,"public-attrib");

      insert(MemberList::pubSlots,"public-slot");

      insert(MemberList::signals,"signal");

      insert(MemberList::dcopMethods,"dcop-func");

      insert(MemberList::properties,"property");

      insert(MemberList::events,"event");

      insert(MemberList::pubStaticMethods,"public-static-func");

      insert(MemberList::pubStaticAttribs,"public-static-attrib");

      insert(MemberList::proTypes,"protected-type");

      insert(MemberList::proMethods,"protected-func");

      insert(MemberList::proAttribs,"protected-attrib");

      insert(MemberList::proSlots,"protected-slot");

      insert(MemberList::proStaticMethods,"protected-static-func");

      insert(MemberList::proStaticAttribs,"protected-static-attrib");

      insert(MemberList::pacTypes,"package-type");

      insert(MemberList::pacMethods,"package-func");

      insert(MemberList::pacAttribs,"package-attrib");

      insert(MemberList::pacStaticMethods,"package-static-func");

      insert(MemberList::pacStaticAttribs,"package-static-attrib");

      insert(MemberList::priTypes,"private-type");

      insert(MemberList::priMethods,"private-func");

      insert(MemberList::priAttribs,"private-attrib");

      insert(MemberList::priSlots,"private-slot");

      insert(MemberList::priStaticMethods,"private-static-func");

      insert(MemberList::priStaticAttribs,"private-static-attrib");

      insert(MemberList::friends,"friend");

      insert(MemberList::related,"related");

      insert(MemberList::decDefineMembers,"define");

      insert(MemberList::decProtoMembers,"prototype");

      insert(MemberList::decTypedefMembers,"typedef");

      insert(MemberList::decEnumMembers,"enum");

      insert(MemberList::decFuncMembers,"func");

      insert(MemberList::decVarMembers,"var");

    }

};

static XmlSectionMapper g_xmlSectionMapper;

inline void writeXMLString(QTextStream &t,const char *s)

{

  t << convertToXML(s);

}

inline void writeXMLCodeString(QTextStream &t,const char *s, int &col)

{

  char c;

  while ((c=*s++))

  {

    switch(c)

    {

      case '\t': 

      { 

	int spacesToNextTabStop = 

          Config_getInt("TAB_SIZE") - (col%Config_getInt("TAB_SIZE")); 

	col+=spacesToNextTabStop;

	while (spacesToNextTabStop--) t << "<sp/>";

	break;

	}

      case ' ':  t << "<sp/>"; col++;  break;

      case '<':  t << "&lt;"; col++;   break;

      case '>':  t << "&gt;"; col++;   break;

      case '&':  t << "&amp;"; col++;  break;

      case '\'': t << "&apos;"; col++; break; 

      case '"':  t << "&quot;"; col++; break;

      default:   t << c; col++;        break;         

    }

  } 

}

static void writeXMLHeader(QTextStream &t)

{

  t << "<?xml version='1.0' encoding='UTF-8' standalone='no'?>" << endl;;

  t << "<doxygen xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" ";

  t << "xsi:noNamespaceSchemaLocation=\"compound.xsd\" ";

  t << "version=\"" << versionString << "\">" << endl;

}

static void writeCombineScript()

{

  QCString outputDirectory = Config_getString("XML_OUTPUT");

  QCString fileName=outputDirectory+"/combine.xslt";

  QFile f(fileName);

  if (!f.open(IO_WriteOnly))

  {

    err("Cannot open file %s for writing!\n",fileName.data());

    return;

  }

  QTextStream t(&f);

  t.setEncoding(QTextStream::UnicodeUTF8);

  t <<

  "<!-- XSLT script to combine the generated output into a single file. \n"

  "     If you have xsltproc you could use:\n"

  "     xsltproc combine.xslt index.xml >all.xml\n"

  "-->\n"

  "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"

  "  <xsl:output method=\"xml\" version=\"1.0\" indent=\"yes\" standalone=\"yes\" />\n"

  "  <xsl:template match=\"/\">\n"

  "    <doxygen version=\"{doxygenindex/@version}\">\n"

  "      <!-- Load all doxgen generated xml files -->\n"

  "      <xsl:for-each select=\"doxygenindex/compound\">\n"

  "        <xsl:copy-of select=\"document( concat( @refid, '.xml' ) )/doxygen/*\" />\n"

  "      </xsl:for-each>\n"

  "    </doxygen>\n"

  "  </xsl:template>\n"

  "</xsl:stylesheet>\n";

}

void writeXMLLink(QTextStream &t,const char *extRef,const char *compoundId,

                  const char *anchorId,const char *text,const char *tooltip)

{

  t << "<ref refid=\"" << compoundId;

  if (anchorId) t << "_1" << anchorId;

  t << "\" kindref=\"";

  if (anchorId) t << "member"; else t << "compound"; 

  t << "\"";

  if (extRef) t << " external=\"" << extRef << "\"";

  if (tooltip) t << " tooltip=\"" << convertToXML(tooltip) << "\"";

  t << ">";

  writeXMLString(t,text);

  t << "</ref>";

}

class TextGeneratorXMLImpl : public TextGeneratorIntf

{

  public:

    TextGeneratorXMLImpl(QTextStream &t): m_t(t) {}

    void writeString(const char *s,bool /*keepSpaces*/) const

    {

      writeXMLString(m_t,s); 

    }

    void writeBreak() const {}

    void writeLink(const char *extRef,const char *file,

                   const char *anchor,const char *text

                  ) const

    {

      writeXMLLink(m_t,extRef,file,anchor,text,0);

    }

  private:

    QTextStream &m_t;

};

template<class T> class ValStack

{

  public:

    ValStack() : m_values(10), m_sp(0), m_size(10) {}

    virtual ~ValStack() {}

    ValStack(const ValStack<T> &s)

    {

      m_values=s.m_values.copy();

      m_sp=s.m_sp;

      m_size=s.m_size;

    }

    ValStack &operator=(const ValStack<T> &s)

    {

      m_values=s.m_values.copy();

      m_sp=s.m_sp;

      m_size=s.m_size;

      return *this;

    }

    void push(T v)

    {

      m_sp++;

      if (m_sp>=m_size)

      {

        m_size+=10;

        m_values.resize(m_size);

      }

      m_values[m_sp]=v;

    }

    T pop()

    {

      ASSERT(m_sp!=0);

      return m_values[m_sp--];

    }

    T& top()

    {

      ASSERT(m_sp!=0);

      return m_values[m_sp];

    }

    bool isEmpty()

    {

      return m_sp==0;

    }

    uint count() const

    {

      return m_sp;

    }

  private:

    QArray<T> m_values;

    int m_sp;

    int m_size;

};

class XMLCodeGenerator : public CodeOutputInterface

{

  public:

    XMLCodeGenerator(QTextStream &t) : m_t(t), m_lineNumber(-1),

      m_insideCodeLine(FALSE), m_normalHLNeedStartTag(TRUE), 

      m_insideSpecialHL(FALSE) {}

    virtual ~XMLCodeGenerator() { }

    void codify(const char *text) 

    {

      XML_DB(("(codify \"%s\")\n",text));

      if (m_insideCodeLine && !m_insideSpecialHL && m_normalHLNeedStartTag)

      {

        m_t << "<highlight class=\"normal\">";

        m_normalHLNeedStartTag=FALSE;

      }

      writeXMLCodeString(m_t,text,col);

    }

    void writeCodeLink(const char *ref,const char *file,

                       const char *anchor,const char *name,

                       const char *tooltip) 

    {

      XML_DB(("(writeCodeLink)\n"));

      if (m_insideCodeLine && !m_insideSpecialHL && m_normalHLNeedStartTag)

      {

        m_t << "<highlight class=\"normal\">";

        m_normalHLNeedStartTag=FALSE;

      }

      writeXMLLink(m_t,ref,file,anchor,name,tooltip);

      col+=strlen(name);

    }

    void startCodeLine() 

    {

      XML_DB(("(startCodeLine)\n"));

      m_t << "<codeline";

      if (m_lineNumber!=-1)

      {

        m_t << " lineno=\"" << m_lineNumber << "\"";

        if (!m_refId.isEmpty())

        {

          m_t << " refid=\"" << m_refId << "\"";

          if (m_isMemberRef)

          {

            m_t << " refkind=\"member\"";

          }

          else

          {

            m_t << " refkind=\"compound\"";

          }

        }

        if (!m_external.isEmpty())

        {

          m_t << " external=\"" << m_external << "\"";

        }

      }

      m_t << ">"; 

      m_insideCodeLine=TRUE;

      col=0;

    }

    void endCodeLine() 

    {

      XML_DB(("(endCodeLine)\n"));

      if (!m_insideSpecialHL && !m_normalHLNeedStartTag)

      {

        m_t << "</highlight>";

        m_normalHLNeedStartTag=TRUE;

      }

      m_t << "</codeline>" << endl; // non DocBook

      m_lineNumber = -1;

      m_refId.resize(0);

      m_external.resize(0);

      m_insideCodeLine=FALSE;

    }

    void startCodeAnchor(const char *id) 

    {

      XML_DB(("(startCodeAnchor)\n"));

      if (m_insideCodeLine && !m_insideSpecialHL && m_normalHLNeedStartTag)

      {

        m_t << "<highlight class=\"normal\">";

        m_normalHLNeedStartTag=FALSE;

      }

      m_t << "<anchor id=\"" << id << "\">";

    }

    void endCodeAnchor() 

    {

      XML_DB(("(endCodeAnchor)\n"));

      m_t << "</anchor>";

    }

    void startFontClass(const char *colorClass) 

    {

      XML_DB(("(startFontClass)\n"));

      if (m_insideCodeLine && !m_insideSpecialHL && !m_normalHLNeedStartTag)

      {

        m_t << "</highlight>";

        m_normalHLNeedStartTag=TRUE;

      }

      m_t << "<highlight class=\"" << colorClass << "\">"; // non DocBook

      m_insideSpecialHL=TRUE;

    }

    void endFontClass()

    {

      XML_DB(("(endFontClass)\n"));

      m_t << "</highlight>"; // non DocBook

      m_insideSpecialHL=FALSE;

    }

    void writeCodeAnchor(const char *)

    {

      XML_DB(("(writeCodeAnchor)\n"));

    }

    void writeLineNumber(const char *extRef,const char *compId,

                         const char *anchorId,int l)

    {

      XML_DB(("(writeLineNumber)\n"));

      // we remember the information provided here to use it 

      // at the <codeline> start tag.

      m_lineNumber = l;

      if (compId)

      {

        m_refId=compId;

        if (anchorId) m_refId+=(QCString)"_1"+anchorId;

        m_isMemberRef = anchorId!=0;

        if (extRef) m_external=extRef;

      }

    }

    void linkableSymbol(int, const char *,Definition *,Definition *) 

    {

    }

    void finish()

    {

      if (m_insideCodeLine) endCodeLine();

    }

  private:

    QTextStream &m_t;  

    QCString m_refId;

    QCString m_external;

    int m_lineNumber;

    bool m_isMemberRef;

    int col;

    bool m_insideCodeLine;

    bool m_normalHLNeedStartTag;

    bool m_insideSpecialHL;

};

static void writeTemplateArgumentList(ArgumentList *al,

                                      QTextStream &t,

                                      Definition *scope,

                                      FileDef *fileScope,

                                      int indent)

{

  QCString indentStr;

  indentStr.fill(' ',indent);

  if (al)

  {

    t << indentStr << "<templateparamlist>" << endl;

    ArgumentListIterator ali(*al);

    Argument *a;

    for (ali.toFirst();(a=ali.current());++ali)

    {

      t << indentStr << "  <param>" << endl;

      if (!a->type.isEmpty())

      {

        t << indentStr <<  "    <type>";

        linkifyText(TextGeneratorXMLImpl(t),scope,fileScope,0,a->type);

        t << "</type>" << endl;

      }

      if (!a->name.isEmpty())

      {

        t << indentStr <<  "    <declname>" << a->name << "</declname>" << endl;

        t << indentStr <<  "    <defname>" << a->name << "</defname>" << endl;

      }

      if (!a->defval.isEmpty())

      {

        t << indentStr << "    <defval>";

        linkifyText(TextGeneratorXMLImpl(t),scope,fileScope,0,a->defval);

        t << "</defval>" << endl;

      }

      t << indentStr << "  </param>" << endl;

    }

    t << indentStr << "</templateparamlist>" << endl;

  }

}

static void writeMemberTemplateLists(MemberDef *md,QTextStream &t)

{

  LockingPtr<ArgumentList> templMd = md->templateArguments();

  if (templMd!=0) // function template prefix

  {

    writeTemplateArgumentList(templMd.pointer(),t,md->getClassDef(),md->getFileDef(),8);

  }

}

static void writeTemplateList(ClassDef *cd,QTextStream &t)

{

  writeTemplateArgumentList(cd->templateArguments(),t,cd,0,4);

}

static void writeXMLDocBlock(QTextStream &t,

                      const QCString &fileName,

                      int lineNr,

                      Definition *scope,

                      MemberDef * md,

                      const QCString &text)

{

  QCString stext = text.stripWhiteSpace();

  if (stext.isEmpty()) return;

  // convert the documentation string into an abstract syntax tree

  DocNode *root = validatingParseDoc(fileName,lineNr,scope,md,text+"\n",FALSE,FALSE);

  // create a code generator

  XMLCodeGenerator *xmlCodeGen = new XMLCodeGenerator(t);

  // create a parse tree visitor for XML

  XmlDocVisitor *visitor = new XmlDocVisitor(t,*xmlCodeGen);

  // visit all nodes

  root->accept(visitor);

  // clean up

  delete visitor;

  delete xmlCodeGen;

  delete root;

}

void writeXMLCodeBlock(QTextStream &t,FileDef *fd)

{

  ParserInterface *pIntf=Doxygen::parserManager->getParser(fd->getDefFileExtension());

  pIntf->resetCodeParserState();

  XMLCodeGenerator *xmlGen = new XMLCodeGenerator(t);

  pIntf->parseCode(*xmlGen,

                0,

                fileToString(fd->absFilePath(),Config_getBool("FILTER_SOURCE_FILES")),

                FALSE,

                0,

                fd);

  xmlGen->finish();

  delete xmlGen;

}

static void writeMemberReference(QTextStream &t,Definition *def,MemberDef *rmd,const char *tagName)

{

  QCString scope = rmd->getScopeString();

  QCString name = rmd->name();

  if (!scope.isEmpty() && scope!=def->name())

  {

    name.prepend(scope+"::");

  }

  t << "        <" << tagName << " refid=\"";

  t << rmd->getOutputFileBase() << "_1" << rmd->anchor() << "\"";

  if (rmd->getStartBodyLine()!=-1 && rmd->getBodyDef()) 

  {

    t << " compoundref=\"" << rmd->getBodyDef()->getOutputFileBase() << "\"";

    t << " startline=\"" << rmd->getStartBodyLine() << "\"";

    if (rmd->getEndBodyLine()!=-1)

    {

      t << " endline=\"" << rmd->getEndBodyLine() << "\"";

    }