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

 *

 * Copyright (C) 1997-2015 by Dimitri van Heesch.

 *

 * 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 <qdir.h>

#include <qfile.h>

#include <qtextstream.h>

#include <qintdict.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 "arguments.h"

#include "memberlist.h"

#include "groupdef.h"

#include "memberdef.h"

#include "namespacedef.h"

#include "membername.h"

#include "membergroup.h"

#include "dirdef.h"

#include "section.h"

#include "htmlentity.h"

#include "resourcemgr.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

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

/** Helper class mapping MemberList::ListType to a string representing */

class XmlSectionMapper : public QIntDict<char>

{

  public:

    XmlSectionMapper() : QIntDict<char>(47)

    {

      insert(MemberListType_pubTypes,"public-type");

      insert(MemberListType_pubMethods,"public-func");

      insert(MemberListType_pubAttribs,"public-attrib");

      insert(MemberListType_pubSlots,"public-slot");

      insert(MemberListType_signals,"signal");

      insert(MemberListType_dcopMethods,"dcop-func");

      insert(MemberListType_properties,"property");

      insert(MemberListType_events,"event");

      insert(MemberListType_interfaces,"interfaces");

      insert(MemberListType_services,"services");

      insert(MemberListType_pubStaticMethods,"public-static-func");

      insert(MemberListType_pubStaticAttribs,"public-static-attrib");

      insert(MemberListType_proTypes,"protected-type");

      insert(MemberListType_proMethods,"protected-func");

      insert(MemberListType_proAttribs,"protected-attrib");

      insert(MemberListType_proSlots,"protected-slot");

      insert(MemberListType_proStaticMethods,"protected-static-func");

      insert(MemberListType_proStaticAttribs,"protected-static-attrib");

      insert(MemberListType_pacTypes,"package-type");

      insert(MemberListType_pacMethods,"package-func");

      insert(MemberListType_pacAttribs,"package-attrib");

      insert(MemberListType_pacStaticMethods,"package-static-func");

      insert(MemberListType_pacStaticAttribs,"package-static-attrib");

      insert(MemberListType_priTypes,"private-type");

      insert(MemberListType_priMethods,"private-func");

      insert(MemberListType_priAttribs,"private-attrib");

      insert(MemberListType_priSlots,"private-slot");

      insert(MemberListType_priStaticMethods,"private-static-func");

      insert(MemberListType_priStaticAttribs,"private-static-attrib");

      insert(MemberListType_friends,"friend");

      insert(MemberListType_related,"related");

      insert(MemberListType_decDefineMembers,"define");

      insert(MemberListType_decProtoMembers,"prototype");

      insert(MemberListType_decTypedefMembers,"typedef");

      insert(MemberListType_decEnumMembers,"enum");

      insert(MemberListType_decFuncMembers,"func");

      insert(MemberListType_decVarMembers,"var");

    }

};

static XmlSectionMapper g_xmlSectionMapper;

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

{

  t << convertToXML(s);

}

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

{

  char c;

  while ((c=*s++))

  {

    switch(c)

    {

      case '\t':

      {

        static int tabSize = Config_getInt(TAB_SIZE);

	int spacesToNextTabStop = tabSize - (col%tabSize);

	col+=spacesToNextTabStop;

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

	break;

	}

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

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

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

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

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

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

      case  1: case  2: case  3: case  4: case  5: case  6: case  7: case  8:

      case 11: case 12: case 13: case 14: case 15: case 16: case 17: case 18:

      case 19: case 20: case 21: case 22: case 23: case 24: case 25: case 26:

      case 27: case 28: case 29: case 30: case 31:

        // encode invalid XML characters (see http://www.w3.org/TR/2000/REC-xml-20001006#NT-Char)

        t << "<sp value=\"" << int(c) << "\"/>";

        break;

      default:   s=writeUtf8Char(t,s-1); col++; break;

    }

  }

}

static void writeXMLHeader(FTextStream &t)

{

  t << "" << endl;;

  t << "

  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;

  }

  FTextStream t(&f);

  //t.setEncoding(FTextStream::UnicodeUTF8);

  t <<

  "

  "     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=\"no\" standalone=\"yes\" />\n"

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

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

  "      \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(FTextStream &t,const char *extRef,const char *compoundId,

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

{

  t << "

  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>";

}

/** Implements TextGeneratorIntf for an XML stream. */

class TextGeneratorXMLImpl : public TextGeneratorIntf

{

  public:

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

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

    {

      writeXMLString(m_t,s); 

    }

    void writeBreak(int) 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:

    FTextStream &m_;;

};

/** Generator for producing XML formatted source code. */

class XMLCodeGenerator : public CodeOutputInterface

{

  public:

    XMLCodeGenerator(FTextStream &t) : m_t(t), m_lineNumber(-1), m_isMemberRef(FALSE), m_col(0),

      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,m_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);

      m_col+=qstrlen(name);

    }

    void writeTooltip(const char *, const DocLinkInfo &, const char *,

                      const char *, const SourceLinkInfo &, const SourceLinkInfo &

                     )

    {

      XML_DB(("(writeToolTip)\n"));

    }

    void startCodeLine(bool)

    {

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

      m_t << "

      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;

      m_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 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 setCurrentDoc(Definition *,const char *,bool)

    {

    }

    void addWord(const char *,bool)

    {

    }

    void finish()

    {

      if (m_insideCodeLine) endCodeLine();

    }

  private:

    FTextStream &m_;;

    QCString m_refId;

    QCString m_external;

    int m_lineNumber;

    bool m_isMemberRef;

    int m_col;

    bool m_insideCodeLine;

    bool m_normalHLNeedStartTag;

    bool m_insideSpecialHL;

};

static void writeTemplateArgumentList(ArgumentList *al,

                                      FTextStream &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;

      }

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

      {

        t << indentStr << "    <typeconstraint>";

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

        t << "</typeconstraint>" << endl;

      }

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

    }

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

  }

}

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

{

  ArgumentList *templMd = md->templateArguments();

  if (templMd) // function template prefix

  {

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

  }

}

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

{

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

}

static void writeXMLDocBlock(FTextStream &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,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(FTextStream &t,FileDef *fd)

{

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

  SrcLangExt langExt = getLanguageFromFileName(fd->getDefFileExtension());

  pIntf->resetCodeParserState();

  XMLCodeGenerator *xmlGen = new XMLCodeGenerator(t);

  pIntf->parseCode(*xmlGen,  // codeOutIntf

                0,           // scopeName

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

                langExt,     // lang

                FALSE,       // isExampleBlock

                0,           // exampleName

                fd,          // fileDef

                -1,          // startLine

                -1,          // endLine

                FALSE,       // inlineFragement

                0,           // memberDef

                TRUE         // showLineNumbers

                );

  xmlGen->finish();

  delete xmlGen;

}

static void writeMemberReference(FTextStream &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+getLanguageSpecificSeparator(rmd->getLanguage()));

  }

  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() << "\"";

    }

  }

  t << ">" << convertToXML(name) << "</" << tagName << ">" << endl;

}

static void stripQualifiers(QCString &typeStr)

{

  bool done=FALSE;

  while (!done)

  {

    if (typeStr.stripPrefix("static "));

    else if (typeStr.stripPrefix("virtual "));

    else if (typeStr.stripPrefix("volatile "));

    else if (typeStr=="virtual") typeStr="";

    else done=TRUE;

  }

}

static QCString classOutputFileBase(ClassDef *cd)

{

  //static bool inlineGroupedClasses = Config_getBool(INLINE_GROUPED_CLASSES);

  //if (inlineGroupedClasses && cd->partOfGroups()!=0) 

  return cd->getOutputFileBase();

  //else 

  //  return cd->getOutputFileBase();

}

static QCString memberOutputFileBase(MemberDef *md)

{

  //static bool inlineGroupedClasses = Config_getBool(INLINE_GROUPED_CLASSES);

  //if (inlineGroupedClasses && md->getClassDef() && md->getClassDef()->partOfGroups()!=0) 

  //  return md->getClassDef()->getXmlOutputFileBase();

  //else 

  //  return md->getOutputFileBase();

  return md->getOutputFileBase();

}

static void generateXMLForMember(MemberDef *md,FTextStream &ti,FTextStream &t,Definition *def)

{

  // + declaration/definition arg lists

  // + reimplements

  // + reimplementedBy

  // + exceptions

  // + const/volatile specifiers

  // - examples

  // + source definition

  // + source references

  // + source referenced by

  // - body code 

  // + template arguments 

  //     (templateArguments(), definitionTemplateParameterLists())

  // - call graph

  // enum values are written as part of the enum

  if (md->memberType()==MemberType_EnumValue) return;

  if (md->isHidden()) return;

  //if (md->name().at(0)=='@') return; // anonymous member

  // group members are only visible in their group

  //if (def->definitionType()!=Definition::TypeGroup && md->getGroupDef()) return;

  QCString memType;

  bool isFunc=FALSE;

  switch (md->memberType())

  {

    case MemberType_Define:      memType="define";    break;

    case MemberType_Function:    memType="function";  isFunc=TRUE; break;

    case MemberType_Variable:    memType="variable";  break;

    case MemberType_Typedef:     memType="typedef";   break;

    case MemberType_Enumeration: memType="enum";      break;

    case MemberType_EnumValue:   ASSERT(0);           break;

    case MemberType_Signal:      memType="signal";    isFunc=TRUE; break;

    case MemberType_Slot:        memType="slot";      isFunc=TRUE; break;

    case MemberType_Friend:      memType="friend";    isFunc=TRUE; break;

    case MemberType_DCOP:        memType="dcop";      isFunc=TRUE; break;

    case MemberType_Property:    memType="property";  break;

    case MemberType_Event:       memType="event";     break;

    case MemberType_Interface:   memType="interface"; break;

    case MemberType_Service:     memType="service";   break;

  }

  ti << "    

     << "_1" << md->anchor() << "\" kind=\"" << memType << "\"><name>" 

     << convertToXML(md->name()) << "</name></member>" << endl;

  QCString scopeName;

  if (md->getClassDef()) 

    scopeName=md->getClassDef()->name();

  else if (md->getNamespaceDef()) 

    scopeName=md->getNamespaceDef()->name();

  t << "      

  //enum { define_t,variable_t,typedef_t,enum_t,function_t } xmlType = function_t;

  t << memType << "\" id=\"";

  if (md->getGroupDef() && def->definitionType()==Definition::TypeGroup)

  {

    t << md->getGroupDef()->getOutputFileBase();

  }

  else

  {

    t << memberOutputFileBase(md);

  }

  t << "_1"      // encoded `:' character (see util.cpp:convertNameToFile)

    << md->anchor();

  t << "\" prot=\"";

  switch(md->protection())

  {

    case Public:    t << "public";     break;

    case Protected: t << "protected";  break;

    case Private:   t << "private";    break;

    case Package:   t << "package";    break;

  }

  t << "\"";

  t << " static=\"";

  if (md->isStatic()) t << "yes"; else t << "no";

  t << "\"";

  if (isFunc)

  {

    ArgumentList *al = md->argumentList();

    t << " const=\"";

    if (al!=0 && al->constSpecifier)    t << "yes"; else t << "no"; 

    t << "\"";

    t << " explicit=\"";

    if (md->isExplicit()) t << "yes"; else t << "no";

    t << "\"";

    t << " inline=\"";

    if (md->isInline()) t << "yes"; else t << "no";

    t << "\"";

    if (al!=0 && al->refQualifier!=RefQualifierNone)

    {

      t << " refqual=\"";

      if (al->refQualifier==RefQualifierLValue) t << "lvalue"; else t << "rvalue";

      t << "\"";

    }

    if (md->isFinal())

    {

      t << " final=\"yes\"";

    }

    if (md->isSealed())

    {

      t << " sealed=\"yes\"";

    }

    if (md->isNew())

    {

      t << " new=\"yes\"";

    }

    if (md->isOptional())

    {

      t << " optional=\"yes\"";

    }

    if (md->isRequired())

    {

      t << " required=\"yes\"";

    }

    if (al && al->volatileSpecifier)

    {

      t << " volatile=\"yes\"";

    }

    t << " virt=\"";

    switch (md->virtualness())

    {

      case Normal:  t << "non-virtual";  break;

      case Virtual: t << "virtual";      break;

      case Pure:    t << "pure-virtual"; break;

      default: ASSERT(0);

    }

    t << "\"";

  }

  if (md->memberType() == MemberType_Enumeration)

  {

    t << " strong=\"";

    if (md->isStrong()) t << "yes"; else t << "no";

    t << "\"";

  }

  if (md->memberType() == MemberType_Variable)

  {

    //ArgumentList *al = md->argumentList();

    //t << " volatile=\"";

    //if (al && al->volatileSpecifier) t << "yes"; else t << "no"; 

    t << " mutable=\"";

    if (md->isMutable()) t << "yes"; else t << "no";

    t << "\"";

    if (md->isInitonly())

    {

      t << " initonly=\"yes\"";

    }

    if (md->isAttribute())

    {

      t << " attribute=\"yes\"";

    }

    if (md->isUNOProperty())

    {

      t << " property=\"yes\"";

    }

    if (md->isReadonly())

    {

      t << " readonly=\"yes\"";

    }

    if (md->isBound())

    {

      t << " bound=\"yes\"";

    }

    if (md->isRemovable())

    {

      t << " removable=\"yes\"";

    }

    if (md->isConstrained())

    {

      t << " constrained=\"yes\"";

    }

    if (md->isTransient())

    {

      t << " transient=\"yes\"";

    }

    if (md->isMaybeVoid())

    {

      t << " maybevoid=\"yes\"";

    }

    if (md->isMaybeDefault())

    {

      t << " maybedefault=\"yes\"";

    }

    if (md->isMaybeAmbiguous())

    {

      t << " maybeambiguous=\"yes\"";

    }

  }

  else if (md->memberType() == MemberType_Property)

  {

    t << " readable=\"";

    if (md->isReadable()) t << "yes"; else t << "no";

    t << "\"";

    t << " writable=\"";

    if (md->isWritable()) t << "yes"; else t << "no";

    t << "\"";

    t << " gettable=\"";

    if (md->isGettable()) t << "yes"; else t << "no";

    t << "\"";

    t << " privategettable=\"";

    if (md->isPrivateGettable()) t << "yes"; else t << "no";

    t << "\"";

    t << " protectedgettable=\"";

    if (md->isProtectedGettable()) t << "yes"; else t << "no";

    t << "\"";

    t << " settable=\"";

    if (md->isSettable()) t << "yes"; else t << "no";

    t << "\"";

    t << " privatesettable=\"";

    if (md->isPrivateSettable()) t << "yes"; else t << "no";

    t << "\"";

    t << " protectedsettable=\"";

    if (md->isProtectedSettable()) t << "yes"; else t << "no";

    t << "\"";

    if (md->isAssign() || md->isCopy() || md->isRetain() || md->isStrong() || md->isWeak())

    {

      t << " accessor=\"";

      if (md->isAssign())      t << "assign";

      else if (md->isCopy())   t << "copy";

      else if (md->isRetain()) t << "retain";

      else if (md->isStrong()) t << "strong";

      else if (md->isWeak())   t << "weak";

      t << "\"";

    }

  }

  else if (md->memberType() == MemberType_Event)

  {

    t << " add=\"";

    if (md->isAddable()) t << "yes"; else t << "no";

    t << "\"";

    t << " remove=\"";

    if (md->isRemovable()) t << "yes"; else t << "no";

    t << "\"";

    t << " raise=\"";

    if (md->isRaisable()) t << "yes"; else t << "no";

    t << "\"";

  }

  t << ">" << endl;

  if (md->memberType()!=MemberType_Define &&

      md->memberType()!=MemberType_Enumeration

     )

  {

    writeMemberTemplateLists(md,t);

    QCString typeStr = md->typeString(); //replaceAnonymousScopes(md->typeString());

    stripQualifiers(typeStr);

    t << "        <type>";

    linkifyText(TextGeneratorXMLImpl(t),def,md->getBodyDef(),md,typeStr);

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

    t << "        <definition>" << convertToXML(md->definition()) << "</definition>" << endl;

    t << "        <argsstring>" << convertToXML(md->argsString()) << "</argsstring>" << endl;

  }

  if (md->memberType() == MemberType_Enumeration)

  {

    t << "        <type>";

    linkifyText(TextGeneratorXMLImpl(t),def,md->getBodyDef(),md,md->enumBaseType());

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

  }

  t << "        <name>" << convertToXML(md->name()) << "</name>" << endl;

  if (md->memberType() == MemberType_Property)

  {

    if (md->isReadable())

      t << "        <read>" << convertToXML(md->getReadAccessor()) << "</read>" << endl;

    if (md->isWritable())

      t << "        <write>" << convertToXML(md->getWriteAccessor()) << "</write>" << endl;

  }

  if (md->memberType()==MemberType_Variable && md->bitfieldString())

  {

    QCString bitfield = md->bitfieldString();

    if (bitfield.at(0)==':') bitfield=bitfield.mid(1);

    t << "        <bitfield>" << convertToXML(bitfield) << "</bitfield>" << endl;

  }

  MemberDef *rmd = md->reimplements();

  if (rmd)

  {

    t << "        

      << memberOutputFileBase(rmd) << "_1" << rmd->anchor() << "\">"

      << convertToXML(rmd->name()) << "</reimplements>" << endl;

  }

  MemberList *rbml = md->reimplementedBy();

  if (rbml)

  {

    MemberListIterator mli(*rbml);

    for (mli.toFirst();(rmd=mli.current());++mli)

    {

      t << "        

        << memberOutputFileBase(rmd) << "_1" << rmd->anchor() << "\">"

        << convertToXML(rmd->name()) << "</reimplementedby>" << endl;

    }

  }

  if (isFunc) //function

  {

    ArgumentList *declAl = md->declArgumentList();

    ArgumentList *defAl = md->argumentList();

    if (declAl && defAl && declAl->count()>0)

    {

      ArgumentListIterator declAli(*declAl);

      ArgumentListIterator defAli(*defAl);

      Argument *a;

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

      {

        Argument *defArg = defAli.current();

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

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

        {

          t << "          <attributes>";

          writeXMLString(t,a->attrib);

          t << "</attributes>" << endl;

        }

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

        {

          t << "          <type>";

          linkifyText(TextGeneratorXMLImpl(t),def,md->getBodyDef(),md,a->type);

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

        }

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

        {