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

 *

 * Copyright (C) 1997-2008 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 "qtbc.h"

#include <qfileinfo.h>

#include <qfile.h>

#include <qdir.h>

#include <qdict.h>

#include <qregexp.h>

#include <qstrlist.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/stat.h>

#include <qtextcodec.h>

#include <unistd.h>

#include <errno.h>

#include "version.h"

#include "doxygen.h"

#include "scanner.h"

#include "entry.h"

#include "index.h"

#include "logos.h"

#include "instdox.h"

#include "message.h"

#include "config.h"

#include "util.h"

#include "pre.h"

#include "tagreader.h"

#include "dot.h"

#include "docparser.h"

#include "dirdef.h"

#include "outputlist.h"

#include "declinfo.h"

#include "htmlgen.h"

#include "latexgen.h"

#include "mangen.h"

#include "language.h"

#include "debug.h"

#include "htmlhelp.h"

#include "qhp.h"

#include "indexlog.h"

#include "ftvhelp.h"

#include "defargs.h"

#include "rtfgen.h"

#include "xmlgen.h"

#include "xmlditagen.h"

#include "defgen.h"

#include "perlmodgen.h"

#include "reflist.h"

#include "pagedef.h"

#include "bufstr.h"

#include "commentcnv.h"

#include "cmdmapper.h"

#include "searchindex.h"

#include "parserintf.h"

#include "htags.h"

#include "pyscanner.h"

#include "fortranscanner.h"

#include "dbusxmlscanner.h"

#include "code.h"

#include "objcache.h"

#include "store.h"

#include "marshal.h"

#include "portable.h"

#include "vhdlscanner.h"

#include "vhdldocgen.h"

#include "eclipsehelp.h"

#include "layout.h"

#define RECURSE_ENTRYTREE(func,var) \

  do { if (var->children()) { \

    EntryNavListIterator eli(*var->children()); \

    for (;eli.current();++eli) func(eli.current()); \

  } } while(0) 

#if !defined(_WIN32) || defined(__CYGWIN__)

#include <signal.h>

#define HAS_SIGNALS

#endif

// globally accessible variables

ClassSDict      *Doxygen::classSDict = 0;

ClassSDict      *Doxygen::hiddenClasses = 0;

NamespaceSDict  *Doxygen::namespaceSDict = 0;

MemberNameSDict *Doxygen::memberNameSDict = 0;

MemberNameSDict *Doxygen::functionNameSDict = 0;   

FileNameList    *Doxygen::inputNameList = 0;       // all input files

FileNameDict    *Doxygen::inputNameDict = 0;          

GroupSDict      *Doxygen::groupSDict = 0;

FormulaList      Doxygen::formulaList;             // all formulas

FormulaDict      Doxygen::formulaDict(1009);       // all formulas

FormulaDict      Doxygen::formulaNameDict(1009);   // the label name of all formulas

PageSDict       *Doxygen::pageSDict = 0;

PageSDict       *Doxygen::exampleSDict = 0;

SectionDict      Doxygen::sectionDict(257);        // all page sections

StringDict       Doxygen::aliasDict(257);          // aliases

FileNameDict    *Doxygen::includeNameDict = 0;     // include names

FileNameDict    *Doxygen::exampleNameDict = 0;     // examples

FileNameDict    *Doxygen::imageNameDict = 0;       // images

FileNameDict    *Doxygen::dotFileNameDict = 0;     // dot files

StringDict       Doxygen::namespaceAliasDict(257); // all namespace aliases

StringDict       Doxygen::tagDestinationDict(257); // all tag locations

QDict<void>      Doxygen::expandAsDefinedDict(257); // all macros that should be expanded

QIntDict<MemberGroupInfo> Doxygen::memGrpInfoDict(1009); // dictionary of the member groups heading

PageDef         *Doxygen::mainPage = 0;

bool             Doxygen::insideMainPage = FALSE; // are we generating docs for the main page?

QTextStream      Doxygen::tagFile;

NamespaceDef    *Doxygen::globalScope = 0;

QDict<RefList>  *Doxygen::xrefLists = new QDict<RefList>; // dictionary of cross-referenced item lists

bool             Doxygen::parseSourcesNeeded = FALSE;

QTime            Doxygen::runningTime;

SearchIndex *    Doxygen::searchIndex=0;

QDict<DefinitionIntf> *Doxygen::symbolMap;

bool             Doxygen::outputToWizard=FALSE;

QDict<int> *     Doxygen::htmlDirMap = 0;

QCache<LookupInfo> Doxygen::lookupCache(50000,50000);

DirSDict        *Doxygen::directories;

SDict<DirRelation> Doxygen::dirRelations(257);

ParserManager   *Doxygen::parserManager = 0;

QCString Doxygen::htmlFileExtension;

bool             Doxygen::suppressDocWarnings = FALSE;

ObjCache        *Doxygen::symbolCache = 0;

Store           *Doxygen::symbolStorage;

QCString         Doxygen::objDBFileName;

QCString         Doxygen::entryDBFileName;

bool             Doxygen::gatherDefines = TRUE;

IndexList        Doxygen::indexList;

int              Doxygen::subpageNestingLevel = 0;

bool             Doxygen::userComments = FALSE;

QCString         Doxygen::spaces;

// locally accessible globals

static QDict<EntryNav>  g_classEntries(1009);

static StringList       g_inputFiles;         

static QDict<void>      g_compoundKeywordDict(7);  // keywords recognised as compounds

static OutputList      *g_outputList = 0;          // list of output generating objects

static QDict<FileDef>   g_usingDeclarations(1009); // used classes

static FileStorage     *g_storage = 0;

static bool             g_successfulRun = FALSE;

static bool             g_dumpSymbolMap = FALSE;

static bool             g_dumpConfigAsXML = FALSE;

void clearAll()

{

  g_inputFiles.clear();      

  //g_excludeNameDict.clear();  

  //delete g_outputList; g_outputList=0;

  Doxygen::classSDict->clear();       

  Doxygen::namespaceSDict->clear();   

  Doxygen::pageSDict->clear();         

  Doxygen::exampleSDict->clear();      

  Doxygen::inputNameList->clear();   

  Doxygen::formulaList.clear();     

  Doxygen::sectionDict.clear();       

  Doxygen::inputNameDict->clear();    

  Doxygen::includeNameDict->clear();  

  Doxygen::exampleNameDict->clear();  

  Doxygen::imageNameDict->clear();     

  Doxygen::dotFileNameDict->clear();     

  Doxygen::formulaDict.clear();      

  Doxygen::formulaNameDict.clear();  

  Doxygen::tagDestinationDict.clear();

  delete Doxygen::mainPage; Doxygen::mainPage=0;

}

void statistics()

{

  fprintf(stderr,"--- inputNameDict stats ----\n");

  Doxygen::inputNameDict->statistics();

  fprintf(stderr,"--- includeNameDict stats ----\n");

  Doxygen::includeNameDict->statistics();

  fprintf(stderr,"--- exampleNameDict stats ----\n");

  Doxygen::exampleNameDict->statistics();

  fprintf(stderr,"--- imageNameDict stats ----\n");

  Doxygen::imageNameDict->statistics();

  fprintf(stderr,"--- dotFileNameDict stats ----\n");

  Doxygen::dotFileNameDict->statistics();

  //fprintf(stderr,"--- g_excludeNameDict stats ----\n");

  //g_excludeNameDict.statistics();

  fprintf(stderr,"--- aliasDict stats ----\n");

  Doxygen::aliasDict.statistics();

  fprintf(stderr,"--- typedefDict stats ----\n");

  fprintf(stderr,"--- namespaceAliasDict stats ----\n");

  Doxygen::namespaceAliasDict.statistics();

  fprintf(stderr,"--- formulaDict stats ----\n");

  Doxygen::formulaDict.statistics();

  fprintf(stderr,"--- formulaNameDict stats ----\n");

  Doxygen::formulaNameDict.statistics();

  fprintf(stderr,"--- tagDestinationDict stats ----\n");

  Doxygen::tagDestinationDict.statistics();

  fprintf(stderr,"--- g_compoundKeywordDict stats ----\n");

  g_compoundKeywordDict.statistics();

  fprintf(stderr,"--- expandAsDefinedDict stats ----\n");

  Doxygen::expandAsDefinedDict.statistics();

  fprintf(stderr,"--- memGrpInfoDict stats ----\n");

  Doxygen::memGrpInfoDict.statistics();

}

static void addMemberDocs(EntryNav *rootNav,MemberDef *md, const char *funcDecl,

                   ArgumentList *al,bool over_load,NamespaceSDict *nl=0);

static void findMember(EntryNav *rootNav,

                       QCString funcDecl,

                       bool overloaded,

                       bool isFunc

                      );

struct STLInfo

{

  const char *className;

  const char *baseClass1;

  const char *baseClass2;

  const char *templType1;

  const char *templName1;

  const char *templType2;

  const char *templName2;

  bool virtualInheritance;

  bool iterators;

};

static STLInfo g_stlinfo[] =

{

  // className              baseClass1                      baseClass2             templType1     templName1     templType2    templName2     virtInheritance  // iterators

  { "allocator",            0,                              0,                     "T",           "elements",    0,            0,             FALSE,              FALSE },

  { "auto_ptr",             0,                              0,                     "T",           "ptr",         0,            0,             FALSE,              FALSE },

  { "ios_base",             0,                              0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "basic_ios",            "ios_base",                     0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

  { "basic_istream",        "basic_ios<Char>",              0,                     "Char",        0,             0,            0,             TRUE,               FALSE },

  { "basic_ostream",        "basic_ios<Char>",              0,                     "Char",        0,             0,            0,             TRUE,               FALSE },

  { "basic_iostream",       "basic_istream<Char>",          "basic_ostream<Char>", "Char",        0,             0,            0,             FALSE,              FALSE },

  { "basic_ifstream",       "basic_istream<Char>",          0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

  { "basic_ofstream",       "basic_ostream<Char>",          0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

  { "basic_fstream",        "basic_iostream<Char>",         0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

  { "basic_istringstream",  "basic_istream<Char>",          0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

  { "basic_ostringstream",  "basic_ostream<Char>",          0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

  { "basic_stringstream",   "basic_iostream<Char>",         0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

  { "ios",                  "basic_ios<char>",              0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "wios",                 "basic_ios<wchar_t>",           0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "istream",              "basic_istream<char>",          0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "wistream",             "basic_istream<wchar_t>",       0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "ostream",              "basic_ostream<char>",          0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "wostream",             "basic_ostream<wchar_t>",       0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "ifstream",             "basic_ifstream<char>",         0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "wifstream",            "basic_ifstream<wchar_t>",      0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "ofstream",             "basic_ofstream<char>",         0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "wofstream",            "basic_ofstream<wchar_t>",      0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "fstream",              "basic_fstream<char>",          0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "wfstream",             "basic_fstream<wchar_t>",       0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "istringstream",        "basic_istringstream<char>",    0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "wistringstream",       "basic_istringstream<wchar_t>", 0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "ostringstream",        "basic_ostringstream<char>",    0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "wostringstream",       "basic_ostringstream<wchar_t>", 0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "stringstream",         "basic_stringstream<char>",     0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "wstringstream",        "basic_stringstream<wchar_t>",  0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "basic_string",         0,                              0,                     "Char",        0,             0,            0,             FALSE,              TRUE  },

  { "string",               "basic_string<char>",           0,                     0,             0,             0,            0,             FALSE,              TRUE  },

  { "wstring",              "basic_string<wchar_t>",        0,                     0,             0,             0,            0,             FALSE,              TRUE  },

  { "complex",              0,                              0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "bitset",               0,                              0,                     "Bits",        0,             0,            0,             FALSE,              FALSE },

  { "deque",                0,                              0,                     "T",           "elements",    0,            0,             FALSE,              TRUE  },

  { "list",                 0,                              0,                     "T",           "elements",    0,            0,             FALSE,              TRUE  },

  { "map",                  0,                              0,                     "K",           "keys",        "T",          "elements",    FALSE,              TRUE  },

  { "multimap",             0,                              0,                     "K",           "keys",        "T",          "elements",    FALSE,              TRUE  },

  { "set",                  0,                              0,                     "K",           "keys",        0,            0,             FALSE,              TRUE  },

  { "multiset",             0,                              0,                     "K",           "keys",        0,            0,             FALSE,              TRUE  },

  { "vector",               0,                              0,                     "T",           "elements",    0,            0,             FALSE,              TRUE  },

  { "queue",                0,                              0,                     "T",           "elements",    0,            0,             FALSE,              FALSE },

  { "priority_queue",       0,                              0,                     "T",           "elements",    0,            0,             FALSE,              FALSE },

  { "stack",                0,                              0,                     "T",           "elements",    0,            0,             FALSE,              FALSE },

  { "valarray",             0,                              0,                     "T",           "elements",    0,            0,             FALSE,              FALSE },

  { "exception",            0,                              0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "bad_alloc",            "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "bad_cast",             "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "bad_typeid",           "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "logic_error",          "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "ios_base::failure",    "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "runtime_error",        "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "bad_exception",        "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "domain_error",         "logic_error",                  0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "invalid_argument",     "logic_error",                  0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "length_error",         "logic_error",                  0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "out_of_range",         "logic_error",                  0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "range_error",          "runtime_error",                0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "overflow_error",       "runtime_error",                0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { "underflow_error",      "runtime_error",                0,                     0,             0,             0,            0,             FALSE,              FALSE },

  { 0,                      0,                              0,                     0,             0,             0,            0,             FALSE,              FALSE }

};

static void addSTLMember(EntryNav *rootNav,const char *type,const char *name)

{

  Entry *memEntry = new Entry;

  memEntry->name       = name;

  memEntry->type       = type;

  memEntry->protection = Private;

  memEntry->section    = Entry::VARIABLE_SEC;

  memEntry->brief      = "STL member";

  memEntry->hidden     = FALSE; 

  memEntry->artificial = TRUE;

  //memEntry->parent     = root;

  //root->addSubEntry(memEntry);

  EntryNav *memEntryNav = new EntryNav(rootNav,memEntry);

  memEntryNav->setEntry(memEntry);

  rootNav->addChild(memEntryNav);

}

static void addSTLIterator(EntryNav *classEntryNav,const char *name)

{

  Entry *iteratorClassEntry = new Entry;

  iteratorClassEntry->fileName  = "[STL]";

  iteratorClassEntry->startLine = 1;

  iteratorClassEntry->name      = name;

  iteratorClassEntry->section   = Entry::CLASS_SEC;

  iteratorClassEntry->brief     = "STL iterator class";

  iteratorClassEntry->hidden    = FALSE;

  iteratorClassEntry->artificial= TRUE;

  EntryNav *iteratorClassEntryNav = new EntryNav(classEntryNav,iteratorClassEntry);

  iteratorClassEntryNav->setEntry(iteratorClassEntry);

  classEntryNav->addChild(iteratorClassEntryNav);

}

static void addSTLClasses(EntryNav *rootNav)

{

  Entry *namespaceEntry = new Entry;

  namespaceEntry->fileName  = "[STL]";

  namespaceEntry->startLine = 1;

  //namespaceEntry->parent    = rootNav->entry();

  namespaceEntry->name      = "std";

  namespaceEntry->section   = Entry::NAMESPACE_SEC;

  namespaceEntry->brief     = "STL namespace";

  namespaceEntry->hidden    = FALSE;

  namespaceEntry->artificial= TRUE;

  //root->addSubEntry(namespaceEntry);

  EntryNav *namespaceEntryNav = new EntryNav(rootNav,namespaceEntry);

  namespaceEntryNav->setEntry(namespaceEntry);

  rootNav->addChild(namespaceEntryNav);

  STLInfo *info = g_stlinfo;

  while (info->className)

  {

    //printf("Adding STL class %s\n",info->className);

    QCString fullName = info->className;

    fullName.prepend("std::");

    // add fake Entry for the class

    Entry *classEntry = new Entry;

    classEntry->fileName  = "[STL]";

    classEntry->startLine = 1;

    classEntry->name      = fullName;

    //classEntry->parent    = namespaceEntry;

    classEntry->section   = Entry::CLASS_SEC;

    classEntry->brief     = "STL class";

    classEntry->hidden    = FALSE;

    classEntry->artificial= TRUE;

    //namespaceEntry->addSubEntry(classEntry);

    EntryNav *classEntryNav = new EntryNav(namespaceEntryNav,classEntry);

    classEntryNav->setEntry(classEntry);

    namespaceEntryNav->addChild(classEntryNav);

    // add template arguments to class

    if (info->templType1)

    {

      ArgumentList *al = new ArgumentList;

      Argument *a=new Argument;

      a->type="typename";

      a->name=info->templType1;

      al->append(a);

      if (info->templType2) // another template argument

      {

        a=new Argument;

        a->type="typename";

        a->name=info->templType2;

        al->append(a);

      }

      classEntry->tArgLists = new QList<ArgumentList>;

      classEntry->tArgLists->setAutoDelete(TRUE);

      classEntry->tArgLists->append(al);

    }

    // add member variables

    if (info->templName1)

    {

      addSTLMember(classEntryNav,info->templType1,info->templName1);

    }

    if (info->templName2)

    {

      addSTLMember(classEntryNav,info->templType2,info->templName2);

    }

    if (info->baseClass1)

    {

      classEntry->extends->append(new BaseInfo(info->baseClass1,Public,info->virtualInheritance?Virtual:Normal));

    }

    if (info->baseClass2)

    {

      classEntry->extends->append(new BaseInfo(info->baseClass2,Public,info->virtualInheritance?Virtual:Normal));

    }

    if (info->iterators)

    {

      // add iterator class

      addSTLIterator(classEntryNav,fullName+"::iterator");

      addSTLIterator(classEntryNav,fullName+"::const_iterator");

      addSTLIterator(classEntryNav,fullName+"::reverse_iterator");

      addSTLIterator(classEntryNav,fullName+"::const_reverse_iterator");

    }

    info++;

  }

}

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

static Definition *findScopeFromQualifiedName(Definition *startScope,const QCString &n,

                                              FileDef *fileScope=0);

static void addPageToContext(PageDef *pd,EntryNav *rootNav)

{

  if (rootNav->parent()) // add the page to it's scope

  {

    QCString scope = rootNav->parent()->name();

    if (rootNav->parent()->section()==Entry::PACKAGEDOC_SEC)

    {

      scope=substitute(scope,".","::");

    }

    scope = stripAnonymousNamespaceScope(scope);

    scope+="::"+pd->name();

    Definition *d = findScopeFromQualifiedName(Doxygen::globalScope,scope);

    if (d) 

    {

      pd->setPageScope(d);

    }

  }

}

static void addRelatedPage(EntryNav *rootNav)

{

  Entry *root = rootNav->entry();

  GroupDef *gd=0;

  QListIterator<Grouping> gli(*root->groups);

  Grouping *g;

  for (;(g=gli.current());++gli)

  {

    if (!g->groupname.isEmpty() && (gd=Doxygen::groupSDict->find(g->groupname))) break;

  }

  //printf("---> addRelatedPage() %s gd=%p\n",root->name.data(),gd);

  QCString doc;

  if (root->brief.isEmpty())

  {

    doc=root->doc+root->inbodyDocs;

  }

  else

  {

    doc=root->brief+"\n\n"+root->doc+root->inbodyDocs;

  }

  PageDef *pd = addRelatedPage(root->name,root->args,doc,root->anchors,

      root->fileName,root->startLine,

      root->sli,

      gd,rootNav->tagInfo()

     );

  if (pd)

  {

    pd->addSectionsToDefinition(root->anchors);

    addPageToContext(pd,rootNav);

  }

}

static void buildGroupListFiltered(EntryNav *rootNav,bool additional)

{

  if (rootNav->section()==Entry::GROUPDOC_SEC && !rootNav->name().isEmpty())

  {

    //printf("Found group %s title=`%s type=%d'\n",

    //    root->name.data(),root->type.data(),root->groupDocType);

    rootNav->loadEntry(g_storage);

    Entry *root = rootNav->entry();

    if ((root->groupDocType==Entry::GROUPDOC_NORMAL && !additional) ||

        (root->groupDocType!=Entry::GROUPDOC_NORMAL && additional))

    {

      GroupDef *gd;

      if ((gd=Doxygen::groupSDict->find(root->name)))

      {

        if ( !gd->hasGroupTitle() )

        {

          gd->setGroupTitle( root->type );

        }

        else if ( root->type.length() > 0 && root->name != root->type && gd->groupTitle() != root->type )

        {

          warn( root->fileName,root->startLine,

              "group %s: ignoring title \"%s\" that does not match old title \"%s\"\n",

              root->name.data(), root->type.data(), gd->groupTitle() );

        }

        gd->setBriefDescription(root->brief,root->briefFile,root->briefLine);

        gd->setDocumentation( root->doc, root->docFile, root->docLine );

        gd->setInbodyDocumentation( root->inbodyDocs, root->inbodyFile, root->inbodyLine );

        gd->addSectionsToDefinition(root->anchors);

        gd->setRefItems(root->sli);

      }

      else

      {

        if (rootNav->tagInfo())

        {

          gd = new GroupDef(root->fileName,root->startLine,root->name,root->type,rootNav->tagInfo()->fileName);

          gd->setReference(rootNav->tagInfo()->tagName);

        }

        else

        {

          gd = new GroupDef(root->fileName,root->startLine,root->name,root->type);

        }

        gd->setBriefDescription(root->brief,root->briefFile,root->briefLine);

        gd->setDocumentation(root->doc,root->docFile,root->docLine);

        gd->setInbodyDocumentation( root->inbodyDocs, root->inbodyFile, root->inbodyLine );