/* -*- Mode: C++; c-default-style: "k&r"; indent-tabs-mode: nil; tab-width: 2; c-basic-offset: 2 -*- */

/* libmwaw

* Version: MPL 2.0 / LGPLv2+

*

* The contents of this file are subject to the Mozilla Public License Version

* 2.0 (the "License"); you may not use this file except in compliance with

* the License or as specified alternatively below. You may obtain a copy of

* the License at http://www.mozilla.org/MPL/

*

* Software distributed under the License is distributed on an "AS IS" basis,

* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

* for the specific language governing rights and limitations under the

* License.

*

* Major Contributor(s):

* Copyright (C) 2002 William Lachance (wrlach@gmail.com)

* Copyright (C) 2002,2004 Marc Maurer (uwog@uwog.net)

* Copyright (C) 2004-2006 Fridrich Strba (fridrich.strba@bluewin.ch)

* Copyright (C) 2006, 2007 Andrew Ziem

* Copyright (C) 2011, 2012 Alonso Laurent (alonso@loria.fr)

*

*

* All Rights Reserved.

*

* For minor contributions see the git repository.

*

* Alternatively, the contents of this file may be used under the terms of

* the GNU Lesser General Public License Version 2 or later (the "LGPLv2+"),

* in which case the provisions of the LGPLv2+ are applicable

* instead of those above.

*/

#include <cmath>

#include <cstring>

#include <iomanip>

#include <iostream>

#include <limits>

#include <map>

#include <set>

#include <sstream>

#include <librevenge/librevenge.h>

#include "MWAWCell.hxx"

#include "MWAWFont.hxx"

#include "MWAWFontConverter.hxx"

#include "MWAWHeader.hxx"

#include "MWAWParagraph.hxx"

#include "MWAWPosition.hxx"

#include "MWAWSpreadsheetListener.hxx"

#include "MWAWSubDocument.hxx"

#include "MultiplanParser.hxx"

/** Internal: the structures of a MultiplanParser */

namespace MultiplanParserInternal

{

////////////////////////////////////////

//! Internal: the state of a MultiplanParser

struct State {

  //! constructor

  State()

    : m_font()

    , m_maximumCell()

    , m_columnPositions()

    , m_cellPositions()

    , m_cellPositionsSet()

    , m_posToLinkMap()

    , m_posToNameMap()

    , m_posToSharedDataSeen()

  {

  }

  //! returns the column width in point

  std::vector<float> getColumnsWidth() const;

  //! the default font

  MWAWFont m_font;

  //! the maximumCell

  MWAWVec2i m_maximumCell;

  //! the columns begin position in point

  std::vector<int> m_columnPositions;

  //! the header/footer/printer message entries

  MWAWEntry m_hfpEntries[3];

  //! the positions of each cell: a vector for each row

  std::vector<std::vector<int> > m_cellPositions;

  //! the list of all position (use for checking)

  std::set<int> m_cellPositionsSet;

  //! the different main spreadsheet zones

  MWAWEntry m_entries[9];

  //! the list of link instruction

  std::map<int, MWAWCellContent::FormulaInstruction> m_posToLinkMap;

  //! the map name's pos to name's cell instruction

  std::map<int, MWAWCellContent::FormulaInstruction> m_posToNameMap;

  //! a set a shared data already seen

  std::set<int> m_posToSharedDataSeen;

};

std::vector<float> State::getColumnsWidth() const

{

  std::vector<float> res;

  bool first=true;

  int lastPos=0;

  float const defWidth=64.f;

  for (auto p : m_columnPositions) {

    if (first) {

      first=false;

      continue;

    }

    if (p

      res.push_back(defWidth);

    else

      res.push_back(float(p-lastPos));

    lastPos=p;

  }

  if (res.size()<64) res.resize(64, defWidth);

  return res;

}

////////////////////////////////////////

//! Internal: the subdocument of a MultiplanParserInternal

class SubDocument final : public MWAWSubDocument

{

public:

  SubDocument(MultiplanParser &parser, MWAWInputStreamPtr const &input, MWAWEntry const &entry)

    : MWAWSubDocument(&parser, input, entry)

    , m_parser(parser)

  {

  }

  //! destructor

  ~SubDocument() final {}

  //! operator!=

  bool operator!=(MWAWSubDocument const &doc) const final;

  //! the parser function

  void parse(MWAWListenerPtr &listener, libmwaw::SubDocumentType type) final;

protected:

  /** the main parser */

  MultiplanParser &m_parser;

};

void SubDocument::parse(MWAWListenerPtr &listener, libmwaw::SubDocumentType /*type*/)

{

  if (!listener.get()) {

    MWAW_DEBUG_MSG(("MultiplanParser::SubDocument::parse: no listener\n"));

    return;

  }

  long pos = m_input->tell();

  m_parser.sendText(m_zone);

  m_input->seek(pos, librevenge::RVNG_SEEK_SET);

}

bool SubDocument::operator!=(MWAWSubDocument const &doc) const

{

  if (MWAWSubDocument::operator!=(doc)) return true;

  auto const *sDoc = dynamic_cast<SubDocument const *>(&doc;;

  if (!sDoc) return true;

  if (&m_parser != &sDoc->m_parser) return true;

  return false;

}

}

////////////////////////////////////////////////////////////

// constructor/destructor, ...

////////////////////////////////////////////////////////////

MultiplanParser::MultiplanParser(MWAWInputStreamPtr const &input, MWAWRSRCParserPtr const &rsrcParser, MWAWHeader *header)

  : MWAWSpreadsheetParser(input, rsrcParser, header)

  , m_state(new MultiplanParserInternal::State)

{

  setAsciiName("main-1");

  // reduce the margin (in case, the page is not defined)

  getPageSpan().setMargins(0.1);

}

MultiplanParser::~MultiplanParser()

{

}

////////////////////////////////////////////////////////////

// the parser

////////////////////////////////////////////////////////////

void MultiplanParser::parse(librevenge::RVNGSpreadsheetInterface *docInterface)

{

  if (!getInput().get() || !checkHeader(nullptr))  throw(libmwaw::ParseException());

  bool ok = true;

  try {

    // create the asciiFile

    ascii().setStream(getInput());

    ascii().open(asciiName());

    checkHeader(nullptr);

    ok = createZones();

    if (ok) {

      createDocument(docInterface);

      sendSpreadsheet();

    }

  }

  catch (...) {

    MWAW_DEBUG_MSG(("MultiplanParser::parse: exception catched when parsing\n"));

    ok = false;

  }

  ascii().reset();

  resetSpreadsheetListener();

  if (!ok) throw(libmwaw::ParseException());

}

////////////////////////////////////////////////////////////

// create the document

////////////////////////////////////////////////////////////

void MultiplanParser::createDocument(librevenge::RVNGSpreadsheetInterface *documentInterface)

{

  if (!documentInterface) return;

  if (getSpreadsheetListener()) {

    MWAW_DEBUG_MSG(("MultiplanParser::createDocument: listener already exist\n"));

    return;

  }

  // create the page list

  MWAWPageSpan ps(getPageSpan());

  ps.setPageSpan(1);

  for (int i=0; i<2; ++i) {

    if (!m_state->m_hfpEntries[i].valid()) continue;

    MWAWHeaderFooter header(i==0 ? MWAWHeaderFooter::HEADER :  MWAWHeaderFooter::FOOTER, MWAWHeaderFooter::ALL);

    header.m_subDocument.reset

    (new MultiplanParserInternal::SubDocument

     (*this, getInput(), m_state->m_hfpEntries[i]));

    ps.setHeaderFooter(header);

  }

  std::vector<MWAWPageSpan> pageList(1,ps);

  //

  MWAWSpreadsheetListenerPtr listen(new MWAWSpreadsheetListener(*getParserState(), pageList, documentInterface));

  setSpreadsheetListener(listen);

  listen->startDocument();

}

////////////////////////////////////////////////////////////

//

// Intermediate level

//

////////////////////////////////////////////////////////////

bool MultiplanParser::createZones()

{

  if (!readPrinterMessage() || !readZoneB()) return false;

  if (!readColumnsPos() || !readPrinterInfo()) return false;

  if (!readHeaderFooter() || !readZoneC()) return false;

  if (!readZonesList()) return false;

  MWAWInputStreamPtr input = getInput();

  if (!input->isEnd()) {

    MWAW_DEBUG_MSG(("MultiplanParser::createZones: find extra data\n"));

    ascii().addPos(input->tell());

    ascii().addNote("Entries(Unknown):###extra");

  }

  return true;

}

////////////////////////////////////////////////////////////

//

// Low level

//

////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////

// spreadsheet

////////////////////////////////////////////////////////////

bool MultiplanParser::readHeaderFooter()

{

  MWAWInputStreamPtr input = getInput();

  long pos = input->tell();

  if (!input->checkPosition(pos+2*256)) {

    MWAW_DEBUG_MSG(("MultiplanParser::readHeaderFooter: the zone seems too short\n"));

    return false;

  }

  libmwaw::DebugStream f;

  for (int i=0; i<2; ++i) {

    pos = input->tell();

    f.str("");

    f << "Entries(HF)[" << (i==0 ? "header" : "footer") << "]:";

    int sSz=int(input->readULong(1));

    m_state->m_hfpEntries[i].setBegin(pos+1);

    m_state->m_hfpEntries[i].setLength(sSz);

    std::string name;

    for (int c=0; c<sSz; ++c) name+=char(input->readULong(1));

    f << name;

    ascii().addPos(pos);

    ascii().addNote(f.str().c_str());

    input->seek(pos+256, librevenge::RVNG_SEEK_SET);

  }

  return true;

}

bool MultiplanParser::readPrinterInfo()

{

  MWAWInputStreamPtr input = getInput();

  long pos = input->tell();

  if (!input->checkPosition(pos+0xbc)) {

    MWAW_DEBUG_MSG(("MultiplanParser::readPrinterInfo: the zone seems too short\n"));

    return false;

  }

  libmwaw::DebugStream f;

  f << "Entries(PrinterInfo):";

  int val=int(input->readULong(2));

  if (val!=0x7fff) f << "f0=" << val << ",";

  val=int(input->readULong(2));

  if (val) f << "f1=" << val << ",";

  f << "left[margin]=" << input->readULong(1) << ",";

  f << "width=" << input->readULong(1) << ",";

  f << "right[margin]=" << input->readULong(1) << ",";

  f << "length=" << input->readULong(1) << ",";

  // then 0 and a string?

  ascii().addDelimiter(input->tell(),'|');

  ascii().addPos(pos);

  ascii().addNote(f.str().c_str());

  input->seek(pos+130, librevenge::RVNG_SEEK_SET);

  pos=input->tell();

  f.str("");

  f << "PrinterInfo[II]:";

  f << "row[pbBreak]=[";

  for (int i=0; i<32; ++i) {

    val=int(input->readULong(1));

    if (!val) continue;

    for (int d=0, depl=1; d<8; ++d, depl<<=1) {

      if (val&depl) f << i*8+d << ",";

    }

  }

  f << "],";

  f << "col[pbBreak]=[";

  for (int i=0; i<8; ++i) {

    val=int(input->readULong(1));

    if (!val) continue;

    for (int d=0, depl=1; d<8; ++d, depl<<=1) {

      if (val&depl) f << i*8+d << ",";

    }

  }

  f << "],";

  for (int i=0; i<7; ++i) {

    val=int(input->readULong(2));

    int const expected[]= {0x48,0x48,0x36,0x36,1,1,0};

    if (val==expected[i]) continue;

    if (i==4) {

      if (val==0)

        f << "print[col,row,number]=no,";

      else

        f << "##print[col,row,number]=" << val << ",";

    }

    else

      f << "g" << i << "=" << val << ",";

  }

  m_state->m_font.setId(int(input->readULong(2)));

  m_state->m_font.setSize(float(input->readULong(2)));

  f << "font=[" << m_state->m_font.getDebugString(getFontConverter()) << "],";

  ascii().addPos(pos);

  ascii().addNote(f.str().c_str());

  input->seek(pos+58, librevenge::RVNG_SEEK_SET);

  return true;

}

bool MultiplanParser::readPrinterMessage()

{

  MWAWInputStreamPtr input = getInput();

  long pos = input->tell();

  if (!input->checkPosition(pos+256)) {

    MWAW_DEBUG_MSG(("MultiplanParser::readPrinterMessage: the zone seems too short\n"));

    return false;

  }

  libmwaw::DebugStream f;

  f << "Entries(HF)[printerMessage]:";

  int sSz=int(input->readULong(1));

  m_state->m_hfpEntries[2].setBegin(pos+1);

  m_state->m_hfpEntries[2].setLength(sSz);

  std::string name;

  for (int c=0; c<sSz; ++c) name+=char(input->readULong(1));

  f << name;

  ascii().addPos(pos);

  ascii().addNote(f.str().c_str());

  input->seek(pos+256, librevenge::RVNG_SEEK_SET);

  return true;

}

bool MultiplanParser::readColumnsPos()

{

  MWAWInputStreamPtr input = getInput();

  long pos = input->tell();

  if (!input->checkPosition(pos+256)) {

    MWAW_DEBUG_MSG(("MultiplanParser::readColumnsPos: the zone seems too short\n"));

    return false;

  }

  libmwaw::DebugStream f;

  f << "Entries(ColPos):pos=[";

  for (int i=0; i<64; ++i) {

    m_state->m_columnPositions.push_back(int(input->readULong(2)));

    f << m_state->m_columnPositions.back() << ",";

  }

  f << "],";

  ascii().addPos(pos);

  ascii().addNote(f.str().c_str());

  return true;

}

bool MultiplanParser::readZonesList()

{

  MWAWInputStreamPtr input = getInput();

  long pos = input->tell();

  if (!input->checkPosition(pos+20)) {

    MWAW_DEBUG_MSG(("MultiplanParser::readZonesList: the zone seems too short\n"));

    return false;

  }

  libmwaw::DebugStream f;

  f << "Entries(ZonesList):";

  int lastPos=0;

  f << "zones=[";

  for (int i=0, w=0; i<10; ++i) {

    int newPos=int(input->readULong(2));

    if (i==6) newPos+=lastPos; // length

    if (i==7) {

      lastPos=newPos;

      continue;

    }

    if (newPos>lastPos) {

      if (!input->checkPosition(pos+20+newPos)) {

        MWAW_DEBUG_MSG(("MultiplanParser::readZonesList: find a bad position"));

        f << "###";

      }

      else {

        m_state->m_entries[w].setBegin(pos+20+lastPos);

        m_state->m_entries[w].setEnd(pos+20+newPos);

      }

      f << std::hex << lastPos << "<->" << newPos << std::dec << ",";

      lastPos=newPos;

    }

    else

      f << "_,";

    ++w;

  }

  f << "],";

  ascii().addPos(pos);

  ascii().addNote(f.str().c_str());

  for (int i=0; i<9; ++i) {

    if (!m_state->m_entries[i].valid()) continue;

    bool ok=false;

    std::string name;

    switch (i) {

    case 1:

      ok=readZone1(m_state->m_entries[i]);

      break;

    case 3:

      ok=readCellDataPosition(m_state->m_entries[i]);

      break;

    case 4:

      name="Link";

      break;

    case 5:

      name="Link";

      break;

    case 6:

      name="DataCell";

      break;

    case 7: // the data are normally read in zone 6

      name="SharedData";

      break;

    case 8:

      name="Names";

      break;

    default:

      ok=false;

      break;

    }

    if (ok)

      continue;

    f.str("");

    if (!name.empty())

      f << "Entries(" << name << "):";

    else

      f << "Entries(Zone" << i << "):";

    ascii().addPos(m_state->m_entries[i].begin());

    ascii().addNote(f.str().c_str());

    ascii().addPos(m_state->m_entries[i].end());

    ascii().addNote("_");

    input->seek(m_state->m_entries[i].end(), librevenge::RVNG_SEEK_SET);

  }

  return true;

}

bool MultiplanParser::readZone1(MWAWEntry const &entry)

{

  if (entry.length()%30) {

    MWAW_DEBUG_MSG(("MultiplanParser::readZone1: the zone size seems bad\n"));

    return false;

  }

  MWAWInputStreamPtr input = getInput();

  input->seek(entry.begin(), librevenge::RVNG_SEEK_SET);

  libmwaw::DebugStream f;

  f << "Entries(Zone1):";

  ascii().addPos(entry.begin());

  ascii().addNote(f.str().c_str());

  int N=int(entry.length()/30);

  for (int i=0; i

    /* find something like that

       0000000000fb01d80012001c00fb01d800000000000d0007ffe4ffeec000

       00000000005500550012001c005500550000000000040001ffe4ffeec000

    */

    long pos=input->tell();

    f.str("");

    f << "Zone1-" << i << ":";

    ascii().addPos(pos);

    ascii().addNote(f.str().c_str());

    input->seek(pos+30, librevenge::RVNG_SEEK_SET);

  }

  return true;

}

bool MultiplanParser::readCellDataPosition(MWAWEntry const &entry)

{

  if (m_state->m_maximumCell[0]<=0 || m_state->m_maximumCell[1]<=0 || entry.length()/m_state->m_maximumCell[0]/2<m_state->m_maximumCell[1]) {

    MWAW_DEBUG_MSG(("MultiplanParser::readCellDataPosition: the zone seems bad\n"));

    return false;

  }

  MWAWInputStreamPtr input = getInput();

  input->seek(entry.begin(), librevenge::RVNG_SEEK_SET);

  libmwaw::DebugStream f;

  f << "Entries(DataPos):";

  m_state->m_cellPositions.resize(size_t(m_state->m_maximumCell[0]));

  auto &posSet=m_state->m_cellPositionsSet;

  for (int i=0; i<m_state->m_maximumCell[0]; ++i) {

    f << "[" << std::hex;

    auto &cellPos=m_state->m_cellPositions[size_t(i)];

    for (int j=0; j<m_state->m_maximumCell[1]; ++j) {

      cellPos.push_back(int(input->readLong(2)));

      posSet.insert(cellPos.back());

      if (cellPos.back())

        f << cellPos.back() << ",";

      else

        f << "_,";

    }

    f << std::dec << "],";

  }

  if (input->tell()!=entry.end()) {

    MWAW_DEBUG_MSG(("MultiplanParser::readCellDataPosition: find extra data\n"));

    f << "###extra";

    ascii().addDelimiter(input->tell(),'|');

  }

  ascii().addPos(entry.begin());

  ascii().addNote(f.str().c_str());

  return true;

}

bool MultiplanParser::readLink(int pos, MWAWCellContent::FormulaInstruction &instr)

{

  auto it=m_state->m_posToLinkMap.find(pos);

  if (it!=m_state->m_posToLinkMap.end()) {

    instr=it->second;

    return true;

  }

  auto const &entry=m_state->m_entries[4];

  if (!entry.valid() || pos<0 || pos+12>entry.length()) {

    MWAW_DEBUG_MSG(("MultiplanParser::readLink: the pos %d seems bad\n", pos));

    return false;

  }

  auto input = getInput();

  long actPos=input->tell();

  long begPos=entry.begin()+pos;

  input->seek(begPos, librevenge::RVNG_SEEK_SET);

  libmwaw::DebugStream f;

  f << "Link-" << std::hex << pos << std::dec << "[pos]:";

  int dSz=int(input->readULong(1));

  if (dSz<0 || pos+12+dSz > entry.end()) {

    MWAW_DEBUG_MSG(("MultiplanParser::readLink: the pos %d seems bad\n", pos));

    input->seek(actPos, librevenge::RVNG_SEEK_SET);

    return false;

  }

  int type=int(input->readULong(1));

  f << "type=" << type << ",";

  int lPos=int(input->readULong(2));

  if (!readLinkFilename(lPos, instr))

    f << "###";

  f << "pos=" << std::hex << lPos << std::dec << ",";

  int val;

  for (int j=0; j<2; ++j) {

    val=int(input->readULong(1));

    int const expected[]= {0x1a,0x1a};

    if (val!=expected[j]) f << "f" << j+2 << "=" << val << ",";

  }

  for (int j=0; j<3; ++j) {  // f4=1|821

    val=int(input->readULong(2));

    if (val)

      f << "f" << j+4 << "=" << std::hex << val << std::dec << ",";

  }

  bool ok=false;

  switch (type) {

  case 0: {

    ok=true;

    auto fontConverter=getFontConverter();

    auto const fId=m_state->m_font.id();

    librevenge::RVNGString name=instr.m_fileName.c_str();

    name.append(':');

    for (int i=0; i

      auto ch=static_cast<unsigned char>(input->readULong(1));

      int unicode = fontConverter->unicode(fId, static_cast<unsigned char>(ch));

      if (unicode!=-1)

        libmwaw::appendUnicode(uint32_t(unicode), name);

      else if (ch==0x9 || ch > 0x1f)

        libmwaw::appendUnicode(static_cast<uint32_t>(ch), name);

      else {

        f << "##";

        MWAW_DEBUG_MSG(("MultiplanParser::readLink: name seems bad\n"));

      }

    }

    instr.m_type=instr.F_Text;

    instr.m_content=name.cstr();

    break;

  }

  case 1: {

    if (dSz<4)

      break;

    ok=true;

    int rows[2], cols[2];

    for (auto &r : rows) r=int(input->readULong(1));

    for (auto &c : cols) c=int(input->readULong(1));

    for (int j=0; j<2; ++j) {

      instr.m_position[j]=MWAWVec2i(cols[j],rows[j]);

      instr.m_positionRelative[j]=MWAWVec2b(false,false);

    }

    instr.m_type=instr.m_position[0]==instr.m_position[1] ? instr.F_Cell : instr.F_CellList;

    f << instr << ",";

    break;

  }

  default:

    MWAW_DEBUG_MSG(("MultiplanParser::readLink: find unknown type %d\n", type));

    break;

  }

  if (!ok) {

    MWAW_DEBUG_MSG(("MultiplanParser::readLink: can not read link at pos %d\n", pos));

    f << "###";

  }

  else

    m_state->m_posToLinkMap[pos]=instr;

  ascii().addPos(begPos);

  ascii().addNote(f.str().c_str());

  input->seek(actPos, librevenge::RVNG_SEEK_SET);

  return ok;

}

bool MultiplanParser::readLinkFilename(int pos, MWAWCellContent::FormulaInstruction &instr)

{

  auto const &entry=m_state->m_entries[5];

  if (!entry.valid() || pos<0 || pos+10>entry.length()) {

    MWAW_DEBUG_MSG(("MultiplanParser::readLinkFilename: the pos %d seems bad\n", pos));

    return false;

  }

  MWAWInputStreamPtr input = getInput();

  long actPos=input->tell();

  long begPos=entry.begin()+pos;

  input->seek(begPos, librevenge::RVNG_SEEK_SET);

  libmwaw::DebugStream f;

  f << "Link-" << std::hex << pos << std::dec << ":";

  for (int i=0; i<2; ++i) {

    int val=int(input->readLong(2));

    if (val!=1-i) f << "f" << i << "=" << val << ",";

  }

  f << "unkn=" << std::hex << input->readULong(4) << std::dec << ","; // d66aa996 | d66aab1e maybe dirId, fileId

  int dSz=int(input->readULong(1));

  if (begPos+9+dSz>entry.end()) {

    MWAW_DEBUG_MSG(("MultiplanParser::readLinkFilename: the pos %d seems bad\n", pos));

    input->seek(actPos, librevenge::RVNG_SEEK_SET);

    return false;

  }

  librevenge::RVNGString filename;

  auto fontConverter=getFontConverter();

  auto const fId=m_state->m_font.id();

  for (int i=0; i

    auto ch=static_cast<unsigned char>(input->readULong(1));

    int unicode = fontConverter->unicode(fId, static_cast<unsigned char>(ch));

    if (unicode!=-1)

      libmwaw::appendUnicode(uint32_t(unicode), filename);

    else if (ch==0x9 || ch > 0x1f)

      libmwaw::appendUnicode(static_cast<uint32_t>(ch), filename);

    else {

      f << "##";

      MWAW_DEBUG_MSG(("MultiplanParser::readLinkFilename: dir seems bad\n"));

    }

  }

  instr.m_fileName=filename.cstr();

  f << instr.m_fileName << ",";

  instr.m_sheet="Sheet0";

  ascii().addPos(begPos);

  ascii().addNote(f.str().c_str());

  input->seek(actPos, librevenge::RVNG_SEEK_SET);

  return true;

}

bool MultiplanParser::readSharedData(int pos, int cellType, MWAWVec2i const &cellPos, MWAWCellContent &content)

{

  auto const &entry=m_state->m_entries[7];

  if (!entry.valid() || pos<0 || pos+3>entry.length()) {

    MWAW_DEBUG_MSG(("MultiplanParser::readSharedData: the pos %d seems bad\n", pos));

    return false;

  }

  MWAWInputStreamPtr input = getInput();

  long actPos=input->tell();

  long begPos=entry.begin()+pos;

  input->seek(begPos, librevenge::RVNG_SEEK_SET);

  libmwaw::DebugStream f;

  f << "SharedData-" << std::hex << pos << std::dec << ":";

  int type=int(input->readULong(2));

  f << "type=" << (type&3) << ",";

  int N=(type/4);

  if (N!=2) f << "used=" << N << ",";

  int dSz=int(input->readULong(1));

  long endPos=begPos+3+dSz;

  if (endPos>entry.end()) {

    MWAW_DEBUG_MSG(("MultiplanParser::readSharedData: the pos %d seems bad\n", pos));

    input->seek(actPos, librevenge::RVNG_SEEK_SET);

    return false;

  }

  bool ok=true;

  switch (type&3) {

  case 0:

    switch (cellType&3) {

    case 0: {

      double value;

      if (dSz!=8 || !readDouble(value))

        ok=false;

      else {

        content.m_contentType=content.C_NUMBER;

        content.setValue(value);

        f << value << ",";

      }

      break;

    }

    case 1: {

      content.m_contentType=content.C_TEXT;

      content.m_textEntry.setBegin(input->tell());

      content.m_textEntry.setLength(dSz);

      std::string name;

      for (int c=0; c<dSz; ++c) name+=char(input->readULong(1));

      f << name << ",";

      break;

    }

    case 2:

      if (dSz!=8)

        ok=false;

      else {

        f << "Nan" << input->readULong(1) << ",";

        input->seek(7, librevenge::RVNG_SEEK_CUR);

        content.m_contentType=content.C_NUMBER;

        content.setValue(std::nan(""));

      }

      break;

    case 3:

    default:

      if (dSz!=8)

        ok=false;

      else {

        int val=int(input->readULong(1));

        content.m_contentType=content.C_NUMBER;

        content.setValue(val);

        if (val==0)

          f << "false,";

        else if (val==1)

          f << "true,";

        else

          f << "##bool=" << val << ",";

        input->seek(7, librevenge::RVNG_SEEK_CUR);

      }

      break;

    }

    break;

  case 1: {

    std::string err;

    if (!readFormula(cellPos, content.m_formula, endPos, err))

      f << "###";

    else

      content.m_contentType=content.C_FORMULA;

    for (auto const &fo : content.m_formula) f << fo;

    f << ",";

    f << err;

    break;

  }

  default:

    ok=false;

    break;

  }

  if (!ok) {

    MWAW_DEBUG_MSG(("MultiplanParser::readSharedData: can not read data for the pos %d\n", pos));

    f << "###";

  }

  if (m_state->m_posToSharedDataSeen.find(pos)==m_state->m_posToSharedDataSeen.end()) {

    m_state->m_posToSharedDataSeen.insert(pos);

    if (input->tell()!=endPos)

      ascii().addDelimiter(input->tell(),'|');

    ascii().addPos(begPos);

    ascii().addNote(f.str().c_str());

  }

  input->seek(actPos, librevenge::RVNG_SEEK_SET);

  return true;

}

bool MultiplanParser::readName(int pos, MWAWCellContent::FormulaInstruction &instruction)

{

  auto it=m_state->m_posToNameMap.find(pos);

  if (it!=m_state->m_posToNameMap.end()) {

    instruction=it->second;

    return true;

  }

  auto const &entry=m_state->m_entries[8]; // the named entry

  if (!entry.valid() || pos<0 || pos+10>=entry.length()) {

    MWAW_DEBUG_MSG(("MultiplanParser::readName: the pos %d seeems bad\n", pos));

    return false;

  }

  MWAWInputStreamPtr input = getInput();

  long actPos=input->tell();

  long begPos=entry.begin()+pos;

  input->seek(begPos, librevenge::RVNG_SEEK_SET);

  libmwaw::DebugStream f;

  f << "Names-" << std::hex << pos << std::dec << ":";

  int val=int(input->readULong(1));

  int dSz=(val>>3);

  if (dSz<=0 || begPos+10+dSz>entry.end()) {

    input->seek(actPos, librevenge::RVNG_SEEK_SET);

    MWAW_DEBUG_MSG(("MultiplanParser::readName: the pos %d seeems bad\n", pos));

    return false;

  }

  if (val&3) f << "f0=" << val << ",";

  val=int(input->readULong(1)); // 40|60

  if (val) f << "f1=" << std::hex << val << std::dec << ",";

  int rows[2];

  for (auto &r : rows) r=int(input->readULong(1));

  val=int(input->readULong(2));

  int cols[2]= {(val>>10),(val>>4)&0x3f};

  for (int i=0; i<2; ++i) {

    instruction.m_position[i]=MWAWVec2i(cols[i], rows[i]);

    instruction.m_positionRelative[i]=MWAWVec2b(false,false);

  }

  instruction.m_type=instruction.m_position[0]==instruction.m_position[1] ? instruction.F_Cell : instruction.F_CellList;

  f << instruction << ",";

  m_state->m_posToNameMap[pos]=instruction;

  if (val&0xf) f << "f2=" << (val&0xf) << ","; // 0|2

  for (int i=0; i<2; ++i) { // 0

    val=int(input->readLong(2));

    if (val) f << "f" << i+2 << "=" << val << ",";

  }

  std::string name;

  for (int c=0; c<dSz; ++c) name+=char(input->readULong(1));

  f << name << ",";

  ascii().addPos(begPos);

  ascii().addNote(f.str().c_str());

  input->seek(actPos, librevenge::RVNG_SEEK_SET);

  return true;

}

bool MultiplanParser::readZoneB()

{

  MWAWInputStreamPtr input = getInput();

  long pos = input->tell();

  if (!input->checkPosition(pos+82)) {

    MWAW_DEBUG_MSG(("MultiplanParser::readZoneB: the zone seems too short\n"));

    return false;

  }

  libmwaw::DebugStream f;

  f << "Entries(ZoneB):";

  int dim[2];

  for (auto &d : dim) d=int(input->readULong(2));

  m_state->m_maximumCell=MWAWVec2i(dim[0],dim[1]);

  f << "cell[max]=" << m_state->m_maximumCell << ",";

  int val;

  for (int i=0; i<7; ++i) {

    val=int(input->readLong(2));

    int const expected[]= {0,0,0x7fff,0x47,0xc,0x1e7,0x10a};

    if (val!=expected[i])

      f << "f" << i << "=" << val << ",";

  }

  for (int i=0; i<15; ++i) {

    val=int(input->readLong(2));

    if (!val) continue;

    f << "g" << i << "=" << val << ",";