/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-  */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef _MDB_
#  include "mdb.h"
#endif

#ifndef _MORK_
#  include "mork.h"
#endif

#ifndef _MORKNODE_
#  include "morkNode.h"
#endif

#ifndef _MORKMAP_
#  include "morkMap.h"
#endif

#ifndef _MORKENV_
#  include "morkEnv.h"
#endif

#ifndef _MORKPARSER_
#  include "morkParser.h"
#endif

#ifndef _MORKSTREAM_
#  include "morkStream.h"
#endif

#ifndef _MORKBLOB_
#  include "morkBlob.h"
#endif

#ifndef _MORKSINK_
#  include "morkSink.h"
#endif

#ifndef _MORKCH_
#  include "morkCh.h"
#endif

#ifndef _MORKSTORE_
#  include "morkStore.h"
#endif

// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789

// ````` ````` ````` ````` `````
// { ===== begin morkNode interface =====

/*public virtual*/ void morkParser::CloseMorkNode(
    morkEnv* ev)  // CloseParser() only if open
{
  if (this->IsOpenNode()) {
    this->MarkClosing();
    this->CloseParser(ev);
    this->MarkShut();
  }
}

/*public virtual*/
morkParser::~morkParser()  // assert CloseParser() executed earlier
{
  MORK_ASSERT(mParser_Heap == 0);
  MORK_ASSERT(mParser_Stream == 0);
}

/*public non-poly*/
morkParser::morkParser(morkEnv* ev, const morkUsage& inUsage,
                       nsIMdbHeap* ioHeap, morkStream* ioStream,
                       mdb_count inBytesPerParseSegment, nsIMdbHeap* ioSlotHeap)
    : morkNode(ev, inUsage, ioHeap),
      mParser_Heap(0),
      mParser_Stream(0),
      mParser_MoreGranularity(inBytesPerParseSegment),
      mParser_State(morkParser_kStartState)

      ,
      mParser_GroupContentStartPos(0)

      ,
      mParser_TableMid(),
      mParser_RowMid(),
      mParser_CellMid()

      ,
      mParser_InPort(morkBool_kFalse),
      mParser_InDict(morkBool_kFalse),
      mParser_InCell(morkBool_kFalse),
      mParser_InMeta(morkBool_kFalse)

      ,
      mParser_InPortRow(morkBool_kFalse),
      mParser_InRow(morkBool_kFalse),
      mParser_InTable(morkBool_kFalse),
      mParser_InGroup(morkBool_kFalse)

      ,
      mParser_AtomChange(morkChange_kNil),
      mParser_CellChange(morkChange_kNil),
      mParser_RowChange(morkChange_kNil),
      mParser_TableChange(morkChange_kNil)

      ,
      mParser_Change(morkChange_kNil),
      mParser_IsBroken(morkBool_kFalse),
      mParser_IsDone(morkBool_kFalse),
      mParser_DoMore(morkBool_kTrue)

      ,
      mParser_Mid()

      ,
      mParser_ScopeCoil(ev, ioSlotHeap),
      mParser_ValueCoil(ev, ioSlotHeap),
      mParser_ColumnCoil(ev, ioSlotHeap),
      mParser_StringCoil(ev, ioSlotHeap)

      ,
      mParser_ScopeSpool(ev, &mParser_ScopeCoil),
      mParser_ValueSpool(ev, &mParser_ValueCoil),
      mParser_ColumnSpool(ev, &mParser_ColumnCoil),
      mParser_StringSpool(ev, &mParser_StringCoil)

      ,
      mParser_MidYarn(ev, morkUsage(morkUsage_kMember), ioSlotHeap) {
  if (inBytesPerParseSegment < morkParser_kMinGranularity)
    inBytesPerParseSegment = morkParser_kMinGranularity;
  else if (inBytesPerParseSegment > morkParser_kMaxGranularity)
    inBytesPerParseSegment = morkParser_kMaxGranularity;

  mParser_MoreGranularity = inBytesPerParseSegment;

  if (ioSlotHeap && ioStream) {
    nsIMdbHeap_SlotStrongHeap(ioSlotHeap, ev, &mParser_Heap);
    morkStream::SlotStrongStream(ioStream, ev, &mParser_Stream);

    if (ev->Good()) {
      mParser_Tag = morkParser_kTag;
      mNode_Derived = morkDerived_kParser;
    }
  } else
    ev->NilPointerError();
}

/*public non-poly*/ void morkParser::CloseParser(
    morkEnv* ev)  // called by CloseMorkNode();
{
  if (this->IsNode()) {
    if (!this->IsShutNode()) {
      mParser_ScopeCoil.CloseCoil(ev);
      mParser_ValueCoil.CloseCoil(ev);
      mParser_ColumnCoil.CloseCoil(ev);
      mParser_StringCoil.CloseCoil(ev);
      nsIMdbHeap_SlotStrongHeap((nsIMdbHeap*)0, ev, &mParser_Heap);
      morkStream::SlotStrongStream((morkStream*)0, ev, &mParser_Stream);
      this->MarkShut();
    }
  } else
    this->NonNodeError(ev);
}

// } ===== end morkNode methods =====
// ````` ````` ````` ````` `````

/*protected non-poly*/ void morkParser::NonGoodParserError(
    morkEnv* ev)  // when GoodParserTag() is false
{
  ev->NewError("non-morkNode");
}

/*protected non-poly*/ void morkParser::NonUsableParserError(morkEnv* ev)  //
{
  if (this->IsNode()) {
    if (this->IsOpenNode()) {
      if (this->GoodParserTag()) {
        // okay
      } else
        this->NonGoodParserError(ev);
    } else
      this->NonOpenNodeError(ev);
  } else
    this->NonNodeError(ev);
}

/*protected non-poly*/ void morkParser::StartParse(morkEnv* ev) {
  MORK_USED_1(ev);
  mParser_InCell = morkBool_kFalse;
  mParser_InMeta = morkBool_kFalse;
  mParser_InDict = morkBool_kFalse;
  mParser_InPortRow = morkBool_kFalse;

  mParser_RowMid.ClearMid();
  mParser_TableMid.ClearMid();
  mParser_CellMid.ClearMid();

  mParser_GroupId = 0;
  mParser_InPort = morkBool_kTrue;

  mParser_GroupSpan.ClearSpan();
  mParser_DictSpan.ClearSpan();
  mParser_AliasSpan.ClearSpan();
  mParser_MetaSpan.ClearSpan();
  mParser_TableSpan.ClearSpan();
  mParser_RowSpan.ClearSpan();
  mParser_CellSpan.ClearSpan();
  mParser_ColumnSpan.ClearSpan();
  mParser_SlotSpan.ClearSpan();

  mParser_PortSpan.ClearSpan();
}

/*protected non-poly*/ void morkParser::StopParse(morkEnv* ev) {
  if (mParser_InCell) {
    mParser_InCell = morkBool_kFalse;
    mParser_CellSpan.SetEndWithEnd(mParser_PortSpan);
    this->OnCellEnd(ev, mParser_CellSpan);
  }
  if (mParser_InMeta) {
    mParser_InMeta = morkBool_kFalse;
    mParser_MetaSpan.SetEndWithEnd(mParser_PortSpan);
    this->OnMetaEnd(ev, mParser_MetaSpan);
  }
  if (mParser_InDict) {
    mParser_InDict = morkBool_kFalse;
    mParser_DictSpan.SetEndWithEnd(mParser_PortSpan);
    this->OnDictEnd(ev, mParser_DictSpan);
  }
  if (mParser_InPortRow) {
    mParser_InPortRow = morkBool_kFalse;
    mParser_RowSpan.SetEndWithEnd(mParser_PortSpan);
    this->OnPortRowEnd(ev, mParser_RowSpan);
  }
  if (mParser_InRow) {
    mParser_InRow = morkBool_kFalse;
    mParser_RowMid.ClearMid();
    mParser_RowSpan.SetEndWithEnd(mParser_PortSpan);
    this->OnRowEnd(ev, mParser_RowSpan);
  }
  if (mParser_InTable) {
    mParser_InTable = morkBool_kFalse;
    mParser_TableMid.ClearMid();
    mParser_TableSpan.SetEndWithEnd(mParser_PortSpan);
    this->OnTableEnd(ev, mParser_TableSpan);
  }
  if (mParser_GroupId) {
    mParser_GroupId = 0;
    mParser_GroupSpan.SetEndWithEnd(mParser_PortSpan);
    this->OnGroupAbortEnd(ev, mParser_GroupSpan);
  }
  if (mParser_InPort) {
    mParser_InPort = morkBool_kFalse;
    this->OnPortEnd(ev, mParser_PortSpan);
  }
}

int morkParser::eat_comment(morkEnv* ev)  // last char was '/'
{
  morkStream* s = mParser_Stream;
  // Note morkStream::Getc() returns EOF when an error occurs, so
  // we don't need to check for both c != EOF and ev->Good() below.

  int c = s->Getc(ev);
  if (c == '/')  // C++ style comment?
  {
    while ((c = s->Getc(ev)) != EOF && c != 0xA && c != 0xD)
      ; /* empty */

    if (c == 0xA || c == 0xD) c = this->eat_line_break(ev, c);
  } else if (c == '*') /* C style comment? */
  {
    int depth = 1;  // count depth of comments until depth reaches zero

    while (depth > 0 && c != EOF)  // still looking for comment end(s)?
    {
      while ((c = s->Getc(ev)) != EOF && c != '/' && c != '*') {
        if (c == 0xA || c == 0xD)  // need to count a line break?
        {
          c = this->eat_line_break(ev, c);
          if (c == '/' || c == '*') break;  // end while loop
        }
      }

      if (c == '*')  // maybe end of a comment, if next char is '/'?
      {
        if ((c = s->Getc(ev)) == '/')  // end of comment?
        {
          --depth;            // depth of comments has decreased by one
          if (!depth)         // comments all done?
            c = s->Getc(ev);  // return the byte after end of comment
        } else if (c != EOF)  // need to put the char back?
          s->Ungetc(c);       // especially need to put back '*', 0xA, or 0xD
      } else if (c == '/')    // maybe nested comemnt, if next char is '*'?
      {
        if ((c = s->Getc(ev)) == '*')  // nested comment?
          ++depth;                     // depth of comments has increased by one
        else if (c != EOF)             // need to put the char back?
          s->Ungetc(c);  // especially need to put back '/', 0xA, or 0xD
      }

      if (ev->Bad()) c = EOF;
    }
    if (c == EOF && depth > 0) ev->NewWarning("EOF before end of comment");
  } else
    ev->NewWarning("expected / or *");

  return c;
}

int morkParser::eat_line_break(morkEnv* ev, int inLast) {
  morkStream* s = mParser_Stream;
  int c = s->Getc(ev);  // get next char after 0xA or 0xD
  this->CountLineBreak();
  if (c == 0xA || c == 0xD)  // another line break character?
  {
    if (c != inLast)    // not the same as the last one?
      c = s->Getc(ev);  // get next char after two-byte linebreak
  }
  return c;
}

int morkParser::eat_line_continue(morkEnv* ev)  // last char was '\'
{
  morkStream* s = mParser_Stream;
  int c = s->Getc(ev);
  if (c == 0xA || c == 0xD)  // linebreak follows \ as expected?
  {
    c = this->eat_line_break(ev, c);
  } else
    ev->NewWarning("expected linebreak");

  return c;
}

int morkParser::NextChar(morkEnv* ev)  // next non-white content
{
  morkStream* s = mParser_Stream;
  int c = s->Getc(ev);
  while (c > 0 && ev->Good()) {
    if (c == '/')
      c = this->eat_comment(ev);
    else if (c == 0xA || c == 0xD)
      c = this->eat_line_break(ev, c);
    else if (c == '\\')
      c = this->eat_line_continue(ev);
    else if (morkCh_IsWhite(c))
      c = s->Getc(ev);
    else
      break;  // end while loop when return c is acceptable
  }
  if (ev->Bad()) {
    mParser_State = morkParser_kBrokenState;
    mParser_DoMore = morkBool_kFalse;
    mParser_IsDone = morkBool_kTrue;
    mParser_IsBroken = morkBool_kTrue;
    c = EOF;
  } else if (c == EOF) {
    mParser_DoMore = morkBool_kFalse;
    mParser_IsDone = morkBool_kTrue;
  }
  return c;
}

void morkParser::OnCellState(morkEnv* ev) { ev->StubMethodOnlyError(); }

void morkParser::OnMetaState(morkEnv* ev) { ev->StubMethodOnlyError(); }

void morkParser::OnRowState(morkEnv* ev) { ev->StubMethodOnlyError(); }

void morkParser::OnTableState(morkEnv* ev) { ev->StubMethodOnlyError(); }

void morkParser::OnDictState(morkEnv* ev) { ev->StubMethodOnlyError(); }

morkBuf* morkParser::ReadName(morkEnv* ev, int c) {
  morkBuf* outBuf = 0;

  if (!morkCh_IsName(c)) ev->NewError("not a name char");

  morkCoil* coil = &mParser_ColumnCoil;
  coil->ClearBufFill();

  morkSpool* spool = &mParser_ColumnSpool;
  spool->Seek(ev, /*pos*/ 0);

  if (ev->Good()) {
    spool->Putc(ev, c);

    morkStream* s = mParser_Stream;
    while ((c = s->Getc(ev)) != EOF && morkCh_IsMore(c) && ev->Good())
      spool->Putc(ev, c);

    if (ev->Good()) {
      if (c != EOF) {
        s->Ungetc(c);
        spool->FlushSink(ev);  // update coil->mBuf_Fill
      } else
        this->UnexpectedEofError(ev);

      if (ev->Good()) outBuf = coil;
    }
  }
  return outBuf;
}

mork_bool morkParser::ReadMid(morkEnv* ev, morkMid* outMid) {
  outMid->ClearMid();

  morkStream* s = mParser_Stream;
  int next;
  outMid->mMid_Oid.mOid_Id = this->ReadHex(ev, &next);
  int c = next;
  if (c == ':') {
    if ((c = s->Getc(ev)) != EOF && ev->Good()) {
      if (c == '^') {
        outMid->mMid_Oid.mOid_Scope = this->ReadHex(ev, &next);
        if (ev->Good()) s->Ungetc(next);
      } else if (morkCh_IsName(c)) {
        outMid->mMid_Buf = this->ReadName(ev, c);
      } else
        ev->NewError("expected name or hex after ':' following ID");
    }

    if (c == EOF && ev->Good()) this->UnexpectedEofError(ev);
  } else
    s->Ungetc(c);

  return ev->Good();
}

void morkParser::ReadCell(morkEnv* ev) {
  mParser_CellMid.ClearMid();
  // this->StartSpanOnLastByte(ev, &mParser_CellSpan);
  morkMid* cellMid = 0;  // if mid syntax is used for column
  morkBuf* cellBuf = 0;  // if naked string is used for column

  morkStream* s = mParser_Stream;
  int c;
  if ((c = s->Getc(ev)) != EOF && ev->Good()) {
    // this->StartSpanOnLastByte(ev, &mParser_ColumnSpan);
    if (c == '^') {
      cellMid = &mParser_CellMid;
      this->ReadMid(ev, cellMid);
      // if ( !mParser_CellMid.mMid_Oid.mOid_Scope )
      //  mParser_CellMid.mMid_Oid.mOid_Scope = (mork_scope) 'c';
    } else {
      if (mParser_InMeta && c == morkStore_kFormColumn) {
        ReadCellForm(ev, c);
        return;
      } else
        cellBuf = this->ReadName(ev, c);
    }
    if (ev->Good()) {
      // this->EndSpanOnThisByte(ev, &mParser_ColumnSpan);

      mParser_InCell = morkBool_kTrue;
      this->OnNewCell(ev, *mParser_CellSpan.AsPlace(), cellMid,
                      cellBuf);  // , mParser_CellChange

      mParser_CellChange = morkChange_kNil;
      if ((c = this->NextChar(ev)) != EOF && ev->Good()) {
        // this->StartSpanOnLastByte(ev, &mParser_SlotSpan);
        if (c == '=') {
          morkBuf* buf = this->ReadValue(ev);
          if (buf) {
            // this->EndSpanOnThisByte(ev, &mParser_SlotSpan);
            this->OnValue(ev, mParser_SlotSpan, *buf);
          }
        } else if (c == '^') {
          if (this->ReadMid(ev, &mParser_Mid)) {
            // this->EndSpanOnThisByte(ev, &mParser_SlotSpan);
            if ((c = this->NextChar(ev)) != EOF && ev->Good()) {
              if (c != ')') ev->NewError("expected ')' after cell ^ID value");
            } else if (c == EOF)
              this->UnexpectedEofError(ev);

            if (ev->Good()) this->OnValueMid(ev, mParser_SlotSpan, mParser_Mid);
          }
        } else if (c == 'r' || c == 't' || c == '"' || c == '\'') {
          ev->NewError("cell syntax not yet supported");
        } else {
          ev->NewError("unknown cell syntax");
        }
      }

      // this->EndSpanOnThisByte(ev, &mParser_CellSpan);
      mParser_InCell = morkBool_kFalse;
      this->OnCellEnd(ev, mParser_CellSpan);
    }
  }
  mParser_CellChange = morkChange_kNil;

  if (c == EOF && ev->Good()) this->UnexpectedEofError(ev);
}

void morkParser::ReadRowPos(morkEnv* ev) {
  int c;  // next character
  mork_pos rowPos = this->ReadHex(ev, &c);

  if (ev->Good() && c != EOF)  // should put back byte after hex?
    mParser_Stream->Ungetc(c);

  this->OnRowPos(ev, rowPos);
}

void morkParser::ReadRow(morkEnv* ev, int c)
// zm:Row       ::= zm:S? '[' zm:S? zm:Id zm:RowItem* zm:S? ']'
// zm:RowItem   ::= zm:MetaRow | zm:Cell
// zm:MetaRow   ::= zm:S? '[' zm:S? zm:Cell* zm:S? ']' /* meta attributes */
// zm:Cell      ::= zm:S? '(' zm:Column zm:S? zm:Slot? ')'
{
  if (ev->Good()) {
    // this->StartSpanOnLastByte(ev, &mParser_RowSpan);
    if (mParser_Change) mParser_RowChange = mParser_Change;

    mork_bool cutAllRowCols = morkBool_kFalse;

    if (c == '[') {
      if ((c = this->NextChar(ev)) == '-')
        cutAllRowCols = morkBool_kTrue;
      else if (ev->Good() && c != EOF)
        mParser_Stream->Ungetc(c);

      if (this->ReadMid(ev, &mParser_RowMid)) {
        mParser_InRow = morkBool_kTrue;
        this->OnNewRow(ev, *mParser_RowSpan.AsPlace(), mParser_RowMid,
                       cutAllRowCols);

        mParser_Change = mParser_RowChange = morkChange_kNil;

        while ((c = this->NextChar(ev)) != EOF && ev->Good() && c != ']') {
          switch (c) {
            case '(':  // cell
              this->ReadCell(ev);
              break;

            case '[':  // meta
              this->ReadMeta(ev, ']');
              break;

              // case '+': // plus
              //   mParser_CellChange = morkChange_kAdd;
              //   break;

            case '-':  // minus
              // mParser_CellChange = morkChange_kCut;
              this->OnMinusCell(ev);
              break;

              // case '!': // bang
              //   mParser_CellChange = morkChange_kSet;
              //  break;

            default:
              ev->NewWarning("unexpected byte in row");
              break;
          }  // switch
        }    // while

        if (ev->Good()) {
          if ((c = this->NextChar(ev)) == '!')
            this->ReadRowPos(ev);
          else if (c != EOF && ev->Good())
            mParser_Stream->Ungetc(c);
        }

        // this->EndSpanOnThisByte(ev, &mParser_RowSpan);
        mParser_InRow = morkBool_kFalse;
        this->OnRowEnd(ev, mParser_RowSpan);

      }  // if ReadMid
    }    // if '['

    else  // c != '['
    {
      morkStream* s = mParser_Stream;
      s->Ungetc(c);
      if (this->ReadMid(ev, &mParser_RowMid)) {
        mParser_InRow = morkBool_kTrue;
        this->OnNewRow(ev, *mParser_RowSpan.AsPlace(), mParser_RowMid,
                       cutAllRowCols);

        mParser_Change = mParser_RowChange = morkChange_kNil;

        if (ev->Good()) {
          if ((c = this->NextChar(ev)) == '!')
            this->ReadRowPos(ev);
          else if (c != EOF && ev->Good())
            s->Ungetc(c);
        }

        // this->EndSpanOnThisByte(ev, &mParser_RowSpan);
        mParser_InRow = morkBool_kFalse;
        this->OnRowEnd(ev, mParser_RowSpan);
      }
    }
  }

  if (ev->Bad())
    mParser_State = morkParser_kBrokenState;
  else if (c == EOF)
    mParser_State = morkParser_kDoneState;
}

void morkParser::ReadTable(morkEnv* ev)
// zm:Table     ::= zm:S? '{' zm:S? zm:Id zm:TableItem* zm:S? '}'
// zm:TableItem ::= zm:MetaTable | zm:RowRef | zm:Row
// zm:MetaTable ::= zm:S? '{' zm:S? zm:Cell* zm:S? '}' /* meta attributes */
{
  // this->StartSpanOnLastByte(ev, &mParser_TableSpan);

  if (mParser_Change) mParser_TableChange = mParser_Change;

  mork_bool cutAllTableRows = morkBool_kFalse;

  int c = this->NextChar(ev);
  if (c == '-')
    cutAllTableRows = morkBool_kTrue;
  else if (ev->Good() && c != EOF)
    mParser_Stream->Ungetc(c);

  if (ev->Good() && this->ReadMid(ev, &mParser_TableMid)) {
    mParser_InTable = morkBool_kTrue;
    this->OnNewTable(ev, *mParser_TableSpan.AsPlace(), mParser_TableMid,
                     cutAllTableRows);

    mParser_Change = mParser_TableChange = morkChange_kNil;

    while ((c = this->NextChar(ev)) != EOF && ev->Good() && c != '}') {
      if (morkCh_IsHex(c)) {
        this->ReadRow(ev, c);
      } else {
        switch (c) {
          case '[':  // row
            this->ReadRow(ev, '[');
            break;

          case '{':  // meta
            this->ReadMeta(ev, '}');
            break;

            // case '+': // plus
            //   mParser_RowChange = morkChange_kAdd;
            //   break;

          case '-':  // minus
            // mParser_RowChange = morkChange_kCut;
            this->OnMinusRow(ev);
            break;

            // case '!': // bang
            //   mParser_RowChange = morkChange_kSet;
            //   break;

          default:
            ev->NewWarning("unexpected byte in table");
            break;
        }
      }
    }

    // this->EndSpanOnThisByte(ev, &mParser_TableSpan);
    mParser_InTable = morkBool_kFalse;
    this->OnTableEnd(ev, mParser_TableSpan);

    if (ev->Bad())
      mParser_State = morkParser_kBrokenState;
    else if (c == EOF)
      mParser_State = morkParser_kDoneState;
  }
}

mork_id morkParser::ReadHex(morkEnv* ev, int* outNextChar)
// zm:Hex   ::= [0-9a-fA-F] /* a single hex digit */
// zm:Hex+  ::= zm:Hex | zm:Hex zm:Hex+
{
  mork_id hex = 0;

  morkStream* s = mParser_Stream;
  int c = this->NextChar(ev);

  if (ev->Good()) {
    if (c != EOF) {
      if (morkCh_IsHex(c)) {
        do {
          if (morkCh_IsDigit(c))  // '0' through '9'?
            c -= '0';
          else if (morkCh_IsUpper(c))  // 'A' through 'F'?
            c -= ('A' - 10);           // c = (c - 'A') + 10;
          else                         // 'a' through 'f'?
            c -= ('a' - 10);           // c = (c - 'a') + 10;

          hex = (hex << 4) + c;
        } while ((c = s->Getc(ev)) != EOF && ev->Good() && morkCh_IsHex(c));
      } else
        this->ExpectedHexDigitError(ev, c);
    }
  }
  if (c == EOF) this->EofInsteadOfHexError(ev);

  *outNextChar = c;
  return hex;
}

/*static*/ void morkParser::EofInsteadOfHexError(morkEnv* ev) {
  ev->NewWarning("eof instead of hex");
}

/*static*/ void morkParser::ExpectedHexDigitError(morkEnv* ev, int c) {
  MORK_USED_1(c);
  ev->NewWarning("expected hex digit");
}

/*static*/ void morkParser::ExpectedEqualError(morkEnv* ev) {
  ev->NewWarning("expected '='");
}

/*static*/ void morkParser::UnexpectedEofError(morkEnv* ev) {
  ev->NewWarning("unexpected eof");
}

morkBuf* morkParser::ReadValue(morkEnv* ev) {
  morkBuf* outBuf = 0;

  morkCoil* coil = &mParser_ValueCoil;
  coil->ClearBufFill();

  morkSpool* spool = &mParser_ValueSpool;
  spool->Seek(ev, /*pos*/ 0);

  if (ev->Good()) {
    morkStream* s = mParser_Stream;
    int c;
    while ((c = s->Getc(ev)) != EOF && c != ')' && ev->Good()) {
      if (c == '\\')  // next char is escaped by '\'?
      {
        if ((c = s->Getc(ev)) == 0xA || c == 0xD)  // linebreak after \?
        {
          c = this->eat_line_break(ev, c);
          if (c == ')' || c == '\\' || c == '$') {
            s->Ungetc(c);  // just let while loop test read this again
            continue;      // goto next iteration of while loop
          }
        }
        if (c == EOF || ev->Bad()) break;  // end while loop
      } else if (c == '$')                 // "$" escapes next two hex digits?
      {
        if ((c = s->Getc(ev)) != EOF && ev->Good()) {
          mork_ch first = (mork_ch)c;  // first hex digit
          if ((c = s->Getc(ev)) != EOF && ev->Good()) {
            mork_ch second = (mork_ch)c;  // second hex digit
            c = ev->HexToByte(first, second);
          } else
            break;  // end while loop
        } else
          break;  // end while loop
      }
      spool->Putc(ev, c);
    }

    if (ev->Good()) {
      if (c != EOF)
        spool->FlushSink(ev);  // update coil->mBuf_Fill
      else
        this->UnexpectedEofError(ev);

      if (ev->Good()) outBuf = coil;
    }
  }
  return outBuf;
}

void morkParser::ReadDictForm(morkEnv* ev) {
  int nextChar;
  nextChar = this->NextChar(ev);
  if (nextChar == '(') {
    nextChar = this->NextChar(ev);
    if (nextChar == morkStore_kFormColumn) {
      int dictForm;

      nextChar = this->NextChar(ev);
      if (nextChar == '=') {
        dictForm = this->NextChar(ev);
        nextChar = this->NextChar(ev);
      } else if (nextChar == '^') {
        dictForm = this->ReadHex(ev, &nextChar);
      } else {
        ev->NewWarning("unexpected byte in dict form");
        return;
      }
      mParser_ValueCoil.mText_Form = dictForm;
      if (nextChar == ')') {
        nextChar = this->NextChar(ev);
        if (nextChar == '>') return;
      }
    }
  }
  ev->NewWarning("unexpected byte in dict form");
}

void morkParser::ReadCellForm(morkEnv* ev, int c) {
  MORK_ASSERT(c == morkStore_kFormColumn);
  int nextChar;
  nextChar = this->NextChar(ev);
  int cellForm;

  if (nextChar == '=') {
    cellForm = this->NextChar(ev);
    nextChar = this->NextChar(ev);
  } else if (nextChar == '^') {
    cellForm = this->ReadHex(ev, &nextChar);
  } else {
    ev->NewWarning("unexpected byte in cell form");
    return;
  }
  // ### not sure about this. Which form should we set?
  //    mBuilder_CellForm = mBuilder_RowForm = cellForm;
  if (nextChar == ')') {
    OnCellForm(ev, cellForm);
    return;
  }
  ev->NewWarning("unexpected byte in cell form");
}

void morkParser::ReadAlias(morkEnv* ev)
// zm:Alias     ::= zm:S? '(' ('#')? zm:Hex+ zm:S? zm:Value ')'
// zm:Value   ::= '=' ([^)$\] | '\' zm:NonCRLF | zm:Continue | zm:Dollar)*
{
  // this->StartSpanOnLastByte(ev, &mParser_AliasSpan);

  int nextChar;
  mork_id hex = this->ReadHex(ev, &nextChar);
  int c = nextChar;

  mParser_Mid.ClearMid();
  mParser_Mid.mMid_Oid.mOid_Id = hex;

  if (morkCh_IsWhite(c) && ev->Good()) c = this->NextChar(ev);

  if (ev->Good()) {
    if (c == '<') {
      ReadDictForm(ev);
      if (ev->Good()) c = this->NextChar(ev);
    }
    if (c == '=') {
      mParser_Mid.mMid_Buf = this->ReadValue(ev);
      if (mParser_Mid.mMid_Buf) {
        // this->EndSpanOnThisByte(ev, &mParser_AliasSpan);
        this->OnAlias(ev, mParser_AliasSpan, mParser_Mid);
        // need to reset this somewhere.
        mParser_ValueCoil.mText_Form = 0;
      }
    } else
      this->ExpectedEqualError(ev);
  }
}

void morkParser::ReadMeta(morkEnv* ev, int inEndMeta)
// zm:MetaDict  ::= zm:S? '<' zm:S? zm:Cell* zm:S? '>' /* meta attributes */
// zm:MetaTable ::= zm:S? '{' zm:S? zm:Cell* zm:S? '}' /* meta attributes */
// zm:MetaRow   ::= zm:S? '[' zm:S? zm:Cell* zm:S? ']' /* meta attributes */
{
  // this->StartSpanOnLastByte(ev, &mParser_MetaSpan);
  mParser_InMeta = morkBool_kTrue;
  this->OnNewMeta(ev, *mParser_MetaSpan.AsPlace());

  mork_bool more = morkBool_kTrue;  // until end meta
  int c;
  while (more && (c = this->NextChar(ev)) != EOF && ev->Good()) {
    switch (c) {
      case '(':  // cell
        this->ReadCell(ev);
        break;

      case '>':  // maybe end meta?
        if (inEndMeta == '>')
          more = morkBool_kFalse;  // stop reading meta
        else
          this->UnexpectedByteInMetaWarning(ev);
        break;

      case '}':  // maybe end meta?
        if (inEndMeta == '}')
          more = morkBool_kFalse;  // stop reading meta
        else
          this->UnexpectedByteInMetaWarning(ev);
        break;

      case ']':  // maybe end meta?
        if (inEndMeta == ']')
          more = morkBool_kFalse;  // stop reading meta
        else
          this->UnexpectedByteInMetaWarning(ev);
        break;

      case '[':  // maybe table meta row?
        if (mParser_InTable)
          this->ReadRow(ev, '[');
        else
          this->UnexpectedByteInMetaWarning(ev);
        break;

      default:
        if (mParser_InTable && morkCh_IsHex(c))
          this->ReadRow(ev, c);
        else
          this->UnexpectedByteInMetaWarning(ev);
        break;
    }
  }

  // this->EndSpanOnThisByte(ev, &mParser_MetaSpan);
  mParser_InMeta = morkBool_kFalse;
  this->OnMetaEnd(ev, mParser_MetaSpan);
}

/*static*/ void morkParser::UnexpectedByteInMetaWarning(morkEnv* ev) {
  ev->NewWarning("unexpected byte in meta");
}

/*static*/ void morkParser::NonParserTypeError(morkEnv* ev) {
  ev->NewError("non morkParser");
}

mork_bool morkParser::MatchPattern(morkEnv* ev, const char* inPattern) {
  // if an error occurs, we want original inPattern in the debugger:
  const char* pattern = inPattern;  // mutable copy of pointer
  morkStream* s = mParser_Stream;
  int c;
  while (*pattern && ev->Good()) {
    char byte = *pattern++;
    if ((c = s->Getc(ev)) != byte) {
      ev->NewError("byte not in expected pattern");
    }
  }
  return ev->Good();
}

mork_bool morkParser::FindGroupEnd(morkEnv* ev) {
  mork_bool foundEnd = morkBool_kFalse;

  // char gidBuf[ 64 ]; // to hold hex pattern we want
  // (void) ev->TokenAsHex(gidBuf, mParser_GroupId);

  morkStream* s = mParser_Stream;
  int c;

  while ((c = s->Getc(ev)) != EOF && ev->Good() && !foundEnd) {
    if (c == '@')  // maybe start of group ending?
    {
      // this->EndSpanOnThisByte(ev, &mParser_GroupSpan);
      if ((c = s->Getc(ev)) == '$')  // '$' follows '@' ?
      {
        if ((c = s->Getc(ev)) == '$')  // '$' follows "@$" ?
        {
          if ((c = s->Getc(ev)) == '}') {
            foundEnd = this->ReadEndGroupId(ev);
            // this->EndSpanOnThisByte(ev, &mParser_GroupSpan);

          } else
            ev->NewError("expected '}' after @$$");
        }
      }
      if (!foundEnd && c == '@') s->Ungetc(c);
    }
  }

  return foundEnd && ev->Good();
}

void morkParser::ReadGroup(morkEnv* mev) {
  nsIMdbEnv* ev = mev->AsMdbEnv();
  int next = 0;
  mParser_GroupId = this->ReadHex(mev, &next);
  if (next == '{') {
    morkStream* s = mParser_Stream;
    int c;
    if ((c = s->Getc(mev)) == '@') {
      // we really need the following span inside morkBuilder::OnNewGroup():
      this->StartSpanOnThisByte(mev, &mParser_GroupSpan);
      mork_pos startPos = mParser_GroupSpan.mSpan_Start.mPlace_Pos;

      // if ( !store->mStore_FirstCommitGroupPos )
      //   store->mStore_FirstCommitGroupPos = startPos;
      // else if ( !store->mStore_SecondCommitGroupPos )
      //   store->mStore_SecondCommitGroupPos = startPos;

      if (this->FindGroupEnd(mev)) {
        mork_pos outPos;
        s->Seek(ev, startPos, &outPos);
        if (mev->Good()) {
          this->OnNewGroup(mev, mParser_GroupSpan.mSpan_Start, mParser_GroupId);

          this->ReadContent(mev, /*inInsideGroup*/ morkBool_kTrue);

          this->OnGroupCommitEnd(mev, mParser_GroupSpan);
        }
      }
    } else
      mev->NewError("expected '@' after @$${id{");
  } else
    mev->NewError("expected '{' after @$$id");
}

mork_bool morkParser::ReadAt(morkEnv* ev, mork_bool inInsideGroup)
/* groups must be ignored until properly terminated */
// zm:Group       ::= zm:GroupStart zm:Content zm:GroupEnd /* transaction */
// zm:GroupStart  ::= zm:S? '@$${' zm:Hex+ '{@' /* xaction id has own space */
// zm:GroupEnd    ::= zm:GroupCommit | zm:GroupAbort
// zm:GroupCommit ::= zm:S? '@$$}' zm:Hex+ '}@'  /* id matches start id */
// zm:GroupAbort  ::= zm:S? '@$$}~~}@' /* id matches start id */
/* We must allow started transactions to be aborted in summary files. */
/* Note '$$' will never occur unescaped in values we will see in Mork. */
{
  if (this->MatchPattern(ev, "$$")) {
    morkStream* s = mParser_Stream;
    int c;
    if (((c = s->Getc(ev)) == '{' || c == '}') && ev->Good()) {
      if (c == '{')  // start of new group?
      {
        if (!inInsideGroup)
          this->ReadGroup(ev);
        else
          ev->NewError("nested @$${ inside another group");
      } else  // c == '}' // end of old group?
      {
        if (inInsideGroup) {
          this->ReadEndGroupId(ev);
          mParser_GroupId = 0;
        } else
          ev->NewError("unmatched @$$} outside any group");
      }
    } else
      ev->NewError("expected '{' or '}' after @$$");
  }
  return ev->Good();
}

mork_bool morkParser::ReadEndGroupId(morkEnv* ev) {
  mork_bool outSawGroupId = morkBool_kFalse;
  morkStream* s = mParser_Stream;
  int c;
  if ((c = s->Getc(ev)) != EOF && ev->Good()) {
    if (c == '~')  // transaction is aborted?
    {
      this->MatchPattern(ev, "~}@");  // finish rest of pattern
    } else  // push back byte and read expected trailing hex id
    {
      s->Ungetc(c);
      int next = 0;
      mork_gid endGroupId = this->ReadHex(ev, &next);
      if (ev->Good()) {
        if (endGroupId == mParser_GroupId)  // matches start?
        {
          if (next == '}')  // '}' after @$$}id ?
          {
            if ((c = s->Getc(ev)) == '@')  // '@' after @$$}id} ?
            {
              // looks good, so return with no error
              outSawGroupId = morkBool_kTrue;
              mParser_InGroup = false;
            } else
              ev->NewError("expected '@' after @$$}id}");
          } else
            ev->NewError("expected '}' after @$$}id");
        } else
          ev->NewError("end group id mismatch");
      }
    }
  }
  return (outSawGroupId && ev->Good());
}

void morkParser::ReadDict(morkEnv* ev)
// zm:Dict      ::= zm:S? '<' zm:DictItem* zm:S? '>'
// zm:DictItem  ::= zm:MetaDict | zm:Alias
// zm:MetaDict  ::= zm:S? '<' zm:S? zm:Cell* zm:S? '>' /* meta attributes */
// zm:Alias     ::= zm:S? '(' ('#')? zm:Hex+ zm:S? zm:Value ')'
{
  mParser_Change = morkChange_kNil;
  mParser_AtomChange = morkChange_kNil;

  // this->StartSpanOnLastByte(ev, &mParser_DictSpan);
  mParser_InDict = morkBool_kTrue;
  this->OnNewDict(ev, *mParser_DictSpan.AsPlace());

  int c;
  while ((c = this->NextChar(ev)) != EOF && ev->Good() && c != '>') {
    switch (c) {
      case '(':  // alias
        this->ReadAlias(ev);
        break;

      case '<':  // meta
        this->ReadMeta(ev, '>');
        break;

      default:
        ev->NewWarning("unexpected byte in dict");
        break;
    }
  }

  // this->EndSpanOnThisByte(ev, &mParser_DictSpan);
  mParser_InDict = morkBool_kFalse;
  this->OnDictEnd(ev, mParser_DictSpan);

  if (ev->Bad())
    mParser_State = morkParser_kBrokenState;
  else if (c == EOF)
    mParser_State = morkParser_kDoneState;
}

void morkParser::EndSpanOnThisByte(morkEnv* mev, morkSpan* ioSpan) {
  mork_pos here;
  nsIMdbEnv* ev = mev->AsMdbEnv();
  nsresult rv = mParser_Stream->Tell(ev, &here);
  if (NS_SUCCEEDED(rv) && mev->Good()) {
    this->SetHerePos(here);
    ioSpan->SetEndWithEnd(mParser_PortSpan);
  }
}

void morkParser::EndSpanOnLastByte(morkEnv* mev, morkSpan* ioSpan) {
  mork_pos here;
  nsIMdbEnv* ev = mev->AsMdbEnv();
  nsresult rv = mParser_Stream->Tell(ev, &here);
  if (NS_SUCCEEDED(rv) && mev->Good()) {
    if (here > 0)
      --here;
    else
      here = 0;

    this->SetHerePos(here);
    ioSpan->SetEndWithEnd(mParser_PortSpan);
  }
}

void morkParser::StartSpanOnLastByte(morkEnv* mev, morkSpan* ioSpan) {
  mork_pos here;
  nsIMdbEnv* ev = mev->AsMdbEnv();
  nsresult rv = mParser_Stream->Tell(ev, &here);
  if (NS_SUCCEEDED(rv) && mev->Good()) {
    if (here > 0)
      --here;
    else
      here = 0;

    this->SetHerePos(here);
    ioSpan->SetStartWithEnd(mParser_PortSpan);
    ioSpan->SetEndWithEnd(mParser_PortSpan);
  }
}

void morkParser::StartSpanOnThisByte(morkEnv* mev, morkSpan* ioSpan) {
  mork_pos here;
  nsIMdbEnv* ev = mev->AsMdbEnv();
  nsresult rv = mParser_Stream->Tell(ev, &here);
  if (NS_SUCCEEDED(rv) && mev->Good()) {
    this->SetHerePos(here);
    ioSpan->SetStartWithEnd(mParser_PortSpan);
    ioSpan->SetEndWithEnd(mParser_PortSpan);
  }
}

mork_bool morkParser::ReadContent(morkEnv* ev, mork_bool inInsideGroup) {
  int c;
  mork_bool keep_going = true;
  while (keep_going && (c = this->NextChar(ev)) != EOF && ev->Good()) {
    switch (c) {
      case '[':  // row
        this->ReadRow(ev, '[');
        keep_going = false;
        break;

      case '{':  // table
        this->ReadTable(ev);
        keep_going = false;
        break;

      case '<':  // dict
        this->ReadDict(ev);
        keep_going = false;
        break;

      case '@':  // group
        return this->ReadAt(ev, inInsideGroup);
        // break;

        // case '+': // plus
        //   mParser_Change = morkChange_kAdd;
        //   break;

        // case '-': // minus
        //   mParser_Change = morkChange_kCut;
        //   break;

        // case '!': // bang
        //   mParser_Change = morkChange_kSet;
        //   break;

      default:
        ev->NewWarning("unexpected byte in ReadContent()");
        break;
    }
  }
  if (ev->Bad())
    mParser_State = morkParser_kBrokenState;
  else if (c == EOF)
    mParser_State = morkParser_kDoneState;

  return (ev->Good() && c != EOF);
}

void morkParser::OnPortState(morkEnv* ev) {
  mork_bool firstTime = !mParser_InPort;
  mParser_InPort = morkBool_kTrue;
  if (firstTime) this->OnNewPort(ev, *mParser_PortSpan.AsPlace());

  mork_bool done = !this->ReadContent(ev, mParser_InGroup /*inInsideGroup*/);

  if (done) {
    mParser_InPort = morkBool_kFalse;
    this->OnPortEnd(ev, mParser_PortSpan);
  }

  if (ev->Bad()) mParser_State = morkParser_kBrokenState;
}

void morkParser::OnStartState(morkEnv* mev) {
  morkStream* s = mParser_Stream;
  nsIMdbEnv* ev = mev->AsMdbEnv();
  if (s && s->IsNode() && s->IsOpenNode()) {
    mork_pos outPos;
    nsresult rv = s->Seek(ev, 0, &outPos);
    if (NS_SUCCEEDED(rv) && mev->Good()) {
      this->StartParse(mev);
      mParser_State = morkParser_kPortState;
    }
  } else
    mev->NilPointerError();

  if (mev->Bad()) mParser_State = morkParser_kBrokenState;
}

/*protected non-poly*/ void morkParser::ParseChunk(morkEnv* ev) {
  mParser_Change = morkChange_kNil;
  mParser_DoMore = morkBool_kTrue;

  switch (mParser_State) {
    case morkParser_kCellState:  // 0
      this->OnCellState(ev);
      break;

    case morkParser_kMetaState:  // 1
      this->OnMetaState(ev);
      break;

    case morkParser_kRowState:  // 2
      this->OnRowState(ev);
      break;

    case morkParser_kTableState:  // 3
      this->OnTableState(ev);
      break;

    case morkParser_kDictState:  // 4
      this->OnDictState(ev);
      break;

    case morkParser_kPortState:  // 5
      this->OnPortState(ev);
      break;

    case morkParser_kStartState:  // 6
      this->OnStartState(ev);
      break;

    case morkParser_kDoneState:  // 7
      mParser_DoMore = morkBool_kFalse;
      mParser_IsDone = morkBool_kTrue;
      this->StopParse(ev);
      break;
    case morkParser_kBrokenState:  // 8
      mParser_DoMore = morkBool_kFalse;
      mParser_IsBroken = morkBool_kTrue;
      this->StopParse(ev);
      break;
    default:  // ?
      MORK_ASSERT(morkBool_kFalse);
      mParser_State = morkParser_kBrokenState;
      break;
  }
}

/*public non-poly*/ mdb_count
morkParser::ParseMore(    // return count of bytes consumed now
    morkEnv* ev,          // context
    mork_pos* outPos,     // current byte pos in the stream afterwards
    mork_bool* outDone,   // is parsing finished?
    mork_bool* outBroken  // is parsing irreparably dead and broken?
) {
  mdb_count outCount = 0;
  if (this->IsNode() && this->GoodParserTag() && this->IsOpenNode()) {
    mork_pos startPos = this->HerePos();

    if (!mParser_IsDone && !mParser_IsBroken) this->ParseChunk(ev);

    // HerePos is only updated for groups. I'd like it to be more accurate.

    mork_pos here;
    mParser_Stream->Tell(ev, &here);

    if (outDone) *outDone = mParser_IsDone;
    if (outBroken) *outBroken = mParser_IsBroken;
    if (outPos) *outPos = here;

    if (here > startPos) outCount = (mdb_count)(here - startPos);
  } else {
    this->NonUsableParserError(ev);
    if (outDone) *outDone = morkBool_kTrue;
    if (outBroken) *outBroken = morkBool_kTrue;
    if (outPos) *outPos = 0;
  }
  return outCount;
}

// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789