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

 *

 *

 *

 *

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

 * Authors: Dimitri van Heesch, Miguel Lobo.

 *

 * 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 "perlmodgen.h"

#include "docparser.h"

#include "message.h"

#include "doxygen.h"

#include "pagedef.h"

#include <qdir.h>

#include <qstack.h>

#include <qdict.h>

#include <qfile.h>

#include <qtextstream.h>

#define PERLOUTPUT_MAX_INDENTATION 40

class PerlModOutputStream

{

public:

  QString m_s;

  QTextStream *m_t;

  PerlModOutputStream(QTextStream *t = 0) : m_t(t) { }

  void add(char c);

  void add(const char *s);

  void add(QCString &s);

  void add(QString &s);

  void add(int n);

  void add(unsigned int n);

};

void PerlModOutputStream::add(char c)

{

  if (m_t != 0)

    (*m_t) << c;

  else

    m_s += c;

}

void PerlModOutputStream::add(const char *s)

{

  if (m_t != 0)

    (*m_t) << s;

  else

    m_s += s;

}

void PerlModOutputStream::add(QCString &s)

{

  if (m_t != 0)

    (*m_t) << s;

  else

    m_s += s;

}

void PerlModOutputStream::add(QString &s)

{

  if (m_t != 0)

    (*m_t) << s;

  else

    m_s += s;

}

void PerlModOutputStream::add(int n)

{

  if (m_t != 0)

    (*m_t) << n;

  else

    m_s += n;

}

void PerlModOutputStream::add(unsigned int n)

{

  if (m_t != 0)

    (*m_t) << n;

  else

    m_s += n;

}

class PerlModOutput

{

public:

  bool m_pretty;

  inline PerlModOutput(bool pretty)

    : m_pretty(pretty), m_stream(0), m_indentation(false), m_blockstart(true)

  {

    m_spaces[0] = 0;

  }

  virtual ~PerlModOutput() { }

  inline void setPerlModOutputStream(PerlModOutputStream *os) { m_stream = os; }

  inline PerlModOutput &openSave() { iopenSave(); return *this; }

  inline PerlModOutput &closeSave(QString &s) { icloseSave(s); return *this; }

  inline PerlModOutput &continueBlock()

  {

    if (m_blockstart)

      m_blockstart = false;

    else

      m_stream->add(',');

    indent();

    return *this;

  }

  inline PerlModOutput &add(char c) { m_stream->add(c); return *this; }

  inline PerlModOutput &add(const char *s) { m_stream->add(s); return *this; }

  inline PerlModOutput &add(QCString &s) { m_stream->add(s); return *this; }

  inline PerlModOutput &add(QString &s) { m_stream->add(s); return *this; }

  inline PerlModOutput &add(int n) { m_stream->add(n); return *this; }

  inline PerlModOutput &add(unsigned int n) { m_stream->add(n); return *this; }

  PerlModOutput &addQuoted(const char *s) { iaddQuoted(s); return *this; }

  inline PerlModOutput &indent()

  {

    if (m_pretty) {

      m_stream->add('\n');

      m_stream->add(m_spaces);

    }

    return *this;

  }

  inline PerlModOutput &open(char c, const char *s = 0) { iopen(c, s); return *this; }

  inline PerlModOutput &close(char c = 0) { iclose(c); return *this; }

  inline PerlModOutput &addField(const char *s) { iaddField(s); return *this; }

  inline PerlModOutput &addFieldQuotedChar(const char *field, char content)

  {

    iaddFieldQuotedChar(field, content); return *this;

  }

  inline PerlModOutput &addFieldQuotedString(const char *field, const char *content)

  {

    iaddFieldQuotedString(field, content); return *this;

  }

  inline PerlModOutput &addFieldBoolean(const char *field, bool content)

  {

    return addFieldQuotedString(field, content ? "yes" : "no");

  }

  inline PerlModOutput &openList(const char *s = 0) { open('[', s); return *this; }

  inline PerlModOutput &closeList() { close(']'); return *this; }

  inline PerlModOutput &openHash(const char *s = 0 ) { open('{', s); return *this; }

  inline PerlModOutput &closeHash() { close('}'); return *this; }

protected:

  void iopenSave();

  void icloseSave(QString &);

  void incIndent();

  void decIndent();

  void iaddQuoted(const char *);

  void iaddFieldQuotedChar(const char *, char);

  void iaddFieldQuotedString(const char *, const char *);

  void iaddField(const char *);

  void iopen(char, const char *);

  void iclose(char);

private:

  PerlModOutputStream *m_stream;

  int m_indentation;

  bool m_blockstart;

  QStack<PerlModOutputStream> m_saved;

  char m_spaces[PERLOUTPUT_MAX_INDENTATION * 2 + 2];

};

void PerlModOutput::iopenSave()

{

  m_saved.push(m_stream);

  m_stream = new PerlModOutputStream();

}

void PerlModOutput::icloseSave(QString &s)

{

  s = m_stream->m_s;

  delete m_stream;

  m_stream = m_saved.pop();

}

void PerlModOutput::incIndent()

{

  if (m_indentation < PERLOUTPUT_MAX_INDENTATION)

  {

    char *s = &m_spaces[m_indentation * 2];

    *s++ = ' '; *s++ = ' '; *s = 0;

  }

  m_indentation++;

}

void PerlModOutput::decIndent()

{

  m_indentation--;

  if (m_indentation < PERLOUTPUT_MAX_INDENTATION)

    m_spaces[m_indentation * 2] = 0;

}

void PerlModOutput::iaddQuoted(const char *s) 

{

  char c;

  while ((c = *s++) != 0) {

    if ((c == '\'') || (c == '\\'))

      m_stream->add('\\');

    m_stream->add(c);

  }

}

void PerlModOutput::iaddField(const char *s)

{

  continueBlock();

  m_stream->add(s);

  m_stream->add(m_pretty ? " => " : "=>");

}

void PerlModOutput::iaddFieldQuotedChar(const char *field, char content)

{

  iaddField(field);

  m_stream->add('\'');

  if ((content == '\'') || (content == '\\'))

    m_stream->add('\\');

  m_stream->add(content);

  m_stream->add('\'');

}

void PerlModOutput::iaddFieldQuotedString(const char *field, const char *content)

{

  if (content == 0)

    return;

  iaddField(field);

  m_stream->add('\'');

  iaddQuoted(content);

  m_stream->add('\'');

}

void PerlModOutput::iopen(char c, const char *s)

{

  if (s != 0)

    iaddField(s);

  else

    continueBlock();

  m_stream->add(c);

  incIndent();

  m_blockstart = true;

}

void PerlModOutput::iclose(char c)

{

  decIndent(); 

  indent();

  if (c != 0)

    m_stream->add(c); 

  m_blockstart = false;

}

/*! @brief Concrete visitor implementation for PerlMod output. */

class PerlModDocVisitor : public DocVisitor

{

public:

  PerlModDocVisitor(PerlModOutput &);

  virtual ~PerlModDocVisitor() { }

  void finish();

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

  // visitor functions for leaf nodes

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

  void visit(DocWord *);

  void visit(DocLinkedWord *);

  void visit(DocWhiteSpace *);

  void visit(DocSymbol *);

  void visit(DocURL *);

  void visit(DocLineBreak *);

  void visit(DocHorRuler *);

  void visit(DocStyleChange *);

  void visit(DocVerbatim *);

  void visit(DocAnchor *);

  void visit(DocInclude *);

  void visit(DocIncOperator *);

  void visit(DocFormula *);

  void visit(DocIndexEntry *);

  void visit(DocSimpleSectSep *);

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

  // visitor functions for compound nodes

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

  void visitPre(DocAutoList *);

  void visitPost(DocAutoList *);

  void visitPre(DocAutoListItem *);

  void visitPost(DocAutoListItem *);

  void visitPre(DocPara *) ;

  void visitPost(DocPara *);

  void visitPre(DocRoot *);

  void visitPost(DocRoot *);

  void visitPre(DocSimpleSect *);

  void visitPost(DocSimpleSect *);

  void visitPre(DocTitle *);

  void visitPost(DocTitle *);

  void visitPre(DocSimpleList *);

  void visitPost(DocSimpleList *);

  void visitPre(DocSimpleListItem *);

  void visitPost(DocSimpleListItem *);

  void visitPre(DocSection *);

  void visitPost(DocSection *);

  void visitPre(DocHtmlList *);

  void visitPost(DocHtmlList *) ;

  void visitPre(DocHtmlListItem *);

  void visitPost(DocHtmlListItem *);

  //void visitPre(DocHtmlPre *);

  //void visitPost(DocHtmlPre *);

  void visitPre(DocHtmlDescList *);

  void visitPost(DocHtmlDescList *);

  void visitPre(DocHtmlDescTitle *);

  void visitPost(DocHtmlDescTitle *);

  void visitPre(DocHtmlDescData *);

  void visitPost(DocHtmlDescData *);

  void visitPre(DocHtmlTable *);

  void visitPost(DocHtmlTable *);

  void visitPre(DocHtmlRow *);

  void visitPost(DocHtmlRow *) ;

  void visitPre(DocHtmlCell *);

  void visitPost(DocHtmlCell *);

  void visitPre(DocHtmlCaption *);

  void visitPost(DocHtmlCaption *);

  void visitPre(DocInternal *);

  void visitPost(DocInternal *);

  void visitPre(DocHRef *);

  void visitPost(DocHRef *);

  void visitPre(DocHtmlHeader *);

  void visitPost(DocHtmlHeader *);

  void visitPre(DocImage *);

  void visitPost(DocImage *);

  void visitPre(DocDotFile *);

  void visitPost(DocDotFile *);

  void visitPre(DocLink *);

  void visitPost(DocLink *);

  void visitPre(DocRef *);

  void visitPost(DocRef *);

  void visitPre(DocSecRefItem *);

  void visitPost(DocSecRefItem *);

  void visitPre(DocSecRefList *);

  void visitPost(DocSecRefList *);

  //void visitPre(DocLanguage *);

  //void visitPost(DocLanguage *);

  void visitPre(DocParamSect *);

  void visitPost(DocParamSect *);

  void visitPre(DocParamList *);

  void visitPost(DocParamList *);

  void visitPre(DocXRefItem *);

  void visitPost(DocXRefItem *);

  void visitPre(DocInternalRef *);

  void visitPost(DocInternalRef *);

  void visitPre(DocCopy *);

  void visitPost(DocCopy *);

  void visitPre(DocText *);

  void visitPost(DocText *);

private:

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

  // helper functions

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

  void addLink(const QString &ref, const QString &file,

	       const QString &anchor);

  void enterText();

  void leaveText();

  void openItem(const char *);

  void closeItem();

  void singleItem(const char *);

  void openSubBlock(const char * = 0);

  void closeSubBlock();

  void openOther();

  void closeOther();

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

  // state variables

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

  PerlModOutput &m_output;

  bool m_textmode;

  bool m_textblockstart;

  QString m_other;

};

PerlModDocVisitor::PerlModDocVisitor(PerlModOutput &output)

  : DocVisitor(DocVisitor_Other), m_output(output), m_textmode(false)

{

  m_output.openList("doc");

}

void PerlModDocVisitor::finish()

{

  leaveText();

  m_output.closeList()

    .add(m_other);

}

void PerlModDocVisitor::addLink(const QString &,const QString &file,const QString &anchor)

{

  QString link = file;

  if (!anchor.isEmpty())

    (link += "_1") += anchor;

  m_output.addFieldQuotedString("link", link);

}

void PerlModDocVisitor::openItem(const char *name)

{

  leaveText();

  m_output.openHash().addFieldQuotedString("type", name);

}

void PerlModDocVisitor::closeItem()

{

  leaveText();

  m_output.closeHash();

}

void PerlModDocVisitor::enterText()

{

  if (m_textmode)

    return;

  openItem("text");

  m_output.addField("content").add('\'');

  m_textmode = true;

}

void PerlModDocVisitor::leaveText()

{

  if (!m_textmode)

    return;

  m_textmode = false;

  m_output

    .add('\'')

    .closeHash();

}

void PerlModDocVisitor::singleItem(const char *name)

{

  openItem(name);

  closeItem();

}

void PerlModDocVisitor::openSubBlock(const char *s)

{

  leaveText();

  m_output.openList(s);

  m_textblockstart = true;

}

void PerlModDocVisitor::closeSubBlock()

{

  leaveText();

  m_output.closeList();

}

void PerlModDocVisitor::openOther()

{

  // Using a secondary text stream will corrupt the perl file. Instead of

  // printing doc => [ data => [] ], it will print doc => [] data => [].

  /*

  leaveText();

  m_output.openSave();

  */

}

void PerlModDocVisitor::closeOther()

{

  // Using a secondary text stream will corrupt the perl file. Instead of

  // printing doc => [ data => [] ], it will print doc => [] data => [].

  /*

  QString other;

  leaveText();

  m_output.closeSave(other);

  m_other += other;

  */

}

void PerlModDocVisitor::visit(DocWord *w)

{

  enterText();

  m_output.addQuoted(w->word());

}

void PerlModDocVisitor::visit(DocLinkedWord *w)

{

  openItem("url");

  addLink(w->ref(), w->file(), w->anchor());

  m_output.addFieldQuotedString("content", w->word());

  closeItem();

}

void PerlModDocVisitor::visit(DocWhiteSpace *)

{

  enterText();

  m_output.add(' ');

}