/*----------------------------------------------------------------------
Compiler Generator Coco/R,
Copyright (c) 1990, 2004 Hanspeter Moessenboeck, University of Linz
extended by M. Loeberbauer & A. Woess, Univ. of Linz
with improvements by Pat Terry, Rhodes University

This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.

This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

As an exception, it is allowed to write an extension of Coco/R that is
used as a plugin in non-free software.

If not otherwise stated, any source code generated by Coco/R (other than
Coco/R itself) does not fall under the GNU General Public License.
-----------------------------------------------------------------------*/
-->begin
/* This file (Scanner.cs) is generated from Dafny.atg by the Coco/R
 * parser generator. Do not edit this file directly. Instead, make
 * changes to Dafny.atg and then rebuild using the Makefile found
 * in the same directory as Dafny.atg.
 */

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics.Contracts;
using Microsoft.Boogie;
using static Microsoft.Dafny.ErrorRegistry;


-->namespace

//-----------------------------------------------------------------------------------
// Buffer
//-----------------------------------------------------------------------------------
public class Buffer {
  // This Buffer supports the following cases:
  // 1) seekable stream (file)
  //    a) whole stream in buffer
  //    b) part of stream in buffer
  // 2) non seekable stream (network, console)

  public const int EOF = 0x11_0000; // Maximum Unicode codepoint + 1;
  const int MIN_BUFFER_LENGTH = 1024; // 1KB
  const int MAX_BUFFER_LENGTH = MIN_BUFFER_LENGTH * 64; // 64KB
  byte[]/*!*/ buf;         // input buffer
  int bufStart;       // position of first byte in buffer relative to input stream
  int bufLen;         // length of buffer
  int fileLen;        // length of input stream (may change if the stream is no file)
  int bufPos;         // current position in buffer
  Stream/*!*/ stream;      // input stream (seekable)
  bool isUserStream;  // was the stream opened by the user?

  [ContractInvariantMethod]
  void ObjectInvariant(){
    Contract.Invariant(buf != null);
    Contract.Invariant(stream != null);
  }

//  [NotDelayed]
  public Buffer (Stream/*!*/ s, bool isUserStream) : base() {
    Contract.Requires(s != null);
    stream = s; this.isUserStream = isUserStream;

    int fl, bl;
    if (s.CanSeek) {
      fl = (int) s.Length;
      bl = fl < MAX_BUFFER_LENGTH ? fl : MAX_BUFFER_LENGTH; // Math.Min(fileLen, MAX_BUFFER_LENGTH);
      bufStart = Int32.MaxValue; // nothing in the buffer so far
    } else {
      fl = bl = bufStart = 0;
    }

    buf = new byte[(bl>0) ? bl : MIN_BUFFER_LENGTH];
    fileLen = fl;  bufLen = bl;

    if (fileLen > 0) Pos = 0; // setup buffer to position 0 (start)
    else bufPos = 0; // index 0 is already after the file, thus Pos = 0 is invalid
    if (bufLen == fileLen && s.CanSeek) Close();
  }

  protected Buffer(Buffer/*!*/ b) { // called in UTF8Buffer constructor
    Contract.Requires(b != null);
    buf = b.buf;
    bufStart = b.bufStart;
    bufLen = b.bufLen;
    fileLen = b.fileLen;
    bufPos = b.bufPos;
    stream = b.stream;
    // keep destructor from closing the stream
    //b.stream = null;
    isUserStream = b.isUserStream;
    // keep destructor from closing the stream
    b.isUserStream = true;
  }

  ~Buffer() { Close(); }

  protected void Close() {
    if (!isUserStream && stream != null) {
      stream.Close();
      //stream = null;
    }
  }

  public virtual int Read () {
    if (bufPos < bufLen) {
      return buf[bufPos++];
    } else if (Pos < fileLen) {
      Pos = Pos; // shift buffer start to Pos
      return buf[bufPos++];
    } else if (stream != null && !stream.CanSeek && ReadNextStreamChunk() > 0) {
      return buf[bufPos++];
    } else {
      return EOF;
    }
  }

  public int Peek () {
    int curPos = Pos;
    int ch = Read();
    Pos = curPos;
    return ch;
  }

  public string/*!*/ GetString (int beg, int end) {
    Contract.Ensures(Contract.Result<string>() != null);
    int len = 0;
    char[] buf = new char[end - beg];
    if(end != beg) {
      int oldPos = Pos;
      Pos = beg;
      while (Pos < end) buf[len++] = (char) Read();
      Pos = oldPos;
    }
    return new String(buf, 0, len);
  }

  public int Pos {
    get { return bufPos + bufStart; }
    set {
      if (value >= fileLen && stream != null && !stream.CanSeek) {
        // Wanted position is after buffer and the stream
        // is not seek-able e.g. network or console,
        // thus we have to read the stream manually till
        // the wanted position is in sight.
        while (value >= fileLen && ReadNextStreamChunk() > 0);
      }

      if (value < 0 || value > fileLen) {
        throw new FatalError("buffer out of bounds access, position: " + value);
      }

      if (value >= bufStart && value < bufStart + bufLen) { // already in buffer
        bufPos = value - bufStart;
      } else if (stream != null) { // must be swapped in
        stream.Seek(value, SeekOrigin.Begin);
        bufLen = stream.Read(buf, 0, buf.Length);
        bufStart = value; bufPos = 0;
      } else {
        // set the position to the end of the file, Pos will return fileLen.
        bufPos = fileLen - bufStart;
      }
    }
  }

  // Read the next chunk of bytes from the stream, increases the buffer
  // if needed and updates the fields fileLen and bufLen.
  // Returns the number of bytes read.
  private int ReadNextStreamChunk() {
    int free = buf.Length - bufLen;
    if (free == 0) {
      // in the case of a growing input stream
      // we can neither seek in the stream, nor can we
      // foresee the maximum length, thus we must adapt
      // the buffer size on demand.
      byte[] newBuf = new byte[bufLen * 2];
      Array.Copy(buf, newBuf, bufLen);
      buf = newBuf;
      free = bufLen;
    }
    int read = stream.Read(buf, bufLen, free);
    if (read > 0) {
      fileLen = bufLen = (bufLen + read);
      return read;
    }
    // end of stream reached
    return 0;
  }
}

//-----------------------------------------------------------------------------------
// UTF8Buffer
//-----------------------------------------------------------------------------------
public class UTF8Buffer: Buffer {
  private int pendingLowSurrogate = -1;
  public UTF8Buffer(Buffer/*!*/ b): base(b) {Contract.Requires(b != null);}

  public override int Read() {
    int ch;
    if (pendingLowSurrogate != -1) {
      ch = pendingLowSurrogate;
      pendingLowSurrogate = -1;
      return ch;
    }
    do {
      ch = base.Read();
      // until we find a utf8 start (0xxxxxxx or 11xxxxxx)
    } while ((ch >= 128) && ((ch & 0xC0) != 0xC0) && (ch != EOF));
    if (ch < 128 || ch == EOF) {
      // nothing to do, first 127 chars are the same in ascii and utf8
      // 0xxxxxxx or end of file character
    } else if ((ch & 0xF0) == 0xF0) {
      // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
      int c1 = ch & 0x07; ch = base.Read();
      int c2 = ch & 0x3F; ch = base.Read();
      int c3 = ch & 0x3F; ch = base.Read();
      int c4 = ch & 0x3F;
      ch = (((((c1 << 6) | c2) << 6) | c3) << 6) | c4;
    } else if ((ch & 0xE0) == 0xE0) {
      // 1110xxxx 10xxxxxx 10xxxxxx
      int c1 = ch & 0x0F; ch = base.Read();
      int c2 = ch & 0x3F; ch = base.Read();
      int c3 = ch & 0x3F;
      ch = (((c1 << 6) | c2) << 6) | c3;
    } else if ((ch & 0xC0) == 0xC0) {
      // 110xxxxx 10xxxxxx
      int c1 = ch & 0x1F; ch = base.Read();
      int c2 = ch & 0x3F;
      ch = (c1 << 6) | c2;
    }
    if (0x10000 <= ch && ch < 0x11_0000) {
      ch = ch - 0x10000; 
      pendingLowSurrogate = 0xDC00 + (ch & 0x3FF);
      ch = 0xD800 + ((ch >> 10) & 0x3FF);
    }
    return ch;
  }
}

//-----------------------------------------------------------------------------------
// Scanner
//-----------------------------------------------------------------------------------
public class Scanner {
  const char EOL = '\n';
  const int eofSym = 0; /* pdt */
-->declarations

  [ContractInvariantMethod]
  void objectInvariant(){
    Contract.Invariant(this._buffer != null);
    Contract.Invariant(t != null);
    Contract.Invariant(start != null);
    Contract.Invariant(tokens != null);
    Contract.Invariant(pt != null);
    Contract.Invariant(tval != null);
    Contract.Invariant(Uri != null);
    Contract.Invariant(errorHandler != null);
  }

  private Buffer/*!*/ _buffer; // scanner buffer

  public Buffer/*!*/ buffer {
    get {
      Contract.Ensures(Contract.Result<Buffer>() != null);
      return this._buffer;
    }
    set {
      Contract.Requires(value != null);
      this._buffer = value;
    }
  }

  Token/*!*/ t;          // current token
  int ch;           // current input character
  int pos;          // byte position of current character
  int charPos;
  int col;          // column number of current character
  int line;         // line number of current character
  int oldEols;      // EOLs that appeared in a comment;
  static readonly Hashtable/*!*/ start; // maps first token character to start state

  Token/*!*/ tokens;     // list of tokens already peeked (first token is a dummy)
  Token/*!*/ pt;         // current peek token

  char[]/*!*/ tval = new char[128]; // text of current token
  int tlen;         // length of current token
  
  // Trivia are whitespaces before and after tokens.
  int posTrailingStart = -1;     // Position where a trailing trivia starts
  int posTrailingEndLeadingStart = -1; // Position where a leading trivia starts
  bool parsingTrivia = false;    // set to true when we are parsing trivia
  bool triviaTrailing = false;   // The first trivia is always leading
  int triviaNewlines = 0;        // How many newlines in the trivia so far
  bool lastWasCr = false;        // if the last newline character was \r
  public Token FirstToken { get; }
      
  private Errors/*!*/ errorHandler;

  internal Uri/*!*/ Uri { get; private set; }

  static Scanner() {
    start = new Hashtable(128);
-->initialization
  }

//  [NotDelayed]
  public Scanner (Uri/*!*/ uri, Errors/*!*/ errorHandler, bool useBaseName = false, Token firstToken = null) : base() {
    Contract.Requires(uri != null);
    Contract.Requires(errorHandler != null);
    this.errorHandler = errorHandler;
    if(firstToken.Uri == null) {
      firstToken.Uri = uri;
    }
    this.FirstToken = firstToken;
    pt = tokens = firstToken ?? new Token();  // first token is a dummy
    t = firstToken ?? new Token(); // dummy because t is a non-null field
    try {
      Stream stream = new FileStream(uri.LocalPath, FileMode.Open, FileAccess.Read, FileShare.Read);
      this._buffer = new Buffer(stream, false);
      this.Uri = uri;
      Init(1);
    } catch (IOException) {
      throw new FatalError("Cannot open file " + uri);
    }
  }

//  [NotDelayed]
  public Scanner (Stream/*!*/ s, Errors/*!*/ errorHandler, Uri/*!*/ uri, int lineNumber = 1, bool useBaseName = false, Token firstToken = null) : base() {
    Contract.Requires(s != null);
    Contract.Requires(errorHandler != null);
    Contract.Requires(uri != null);
    if(firstToken.Uri == null) {
      firstToken.Uri = uri;
    }
    this.FirstToken = firstToken;
    pt = tokens = firstToken ?? new Token();  // first token is a dummy
    t = firstToken ?? new Token(); // dummy because t is a non-null field
    this._buffer = new Buffer(s, true);
    this.errorHandler = errorHandler;
    this.Uri = uri;
    Init(lineNumber);
  }

  string GetBaseName(string fileName) {
    return System.IO.Path.GetFileName(fileName); // Return basename
  }

  void Init(int lineNumber) {
    pos = -1; line = lineNumber; col = 0;
    oldEols = 0;
    NextCh();
    if (ch == 0xEF) { // check optional byte order mark for UTF-8
      NextCh(); int ch1 = ch;
      NextCh(); int ch2 = ch;
      if (ch1 != 0xBB || ch2 != 0xBF) {
        throw new FatalError(String.Format("illegal byte order mark: EF {0,2:X} {1,2:X}", ch1, ch2));
      }
      buffer = new UTF8Buffer(buffer); col = 0;
      NextCh();
    } else {
      // We consider all files to be UTF-8 by default 
      buffer = new UTF8Buffer(buffer);
    }
    pt = tokens = new Token();  // first token is a dummy
  }

  string/*!*/ ReadToEOL(){
  Contract.Ensures(Contract.Result<string>() != null);
    int p = buffer.Pos;
    int ch = buffer.Read();
    // replace isolated '\r' by '\n' in order to make
    // eol handling uniform across Windows, Unix and Mac
    if (ch == '\r' && buffer.Peek() != '\n') ch = EOL;
    while (ch != EOL && ch != Buffer.EOF){
    ch = buffer.Read();
    // replace isolated '\r' by '\n' in order to make
    // eol handling uniform across Windows, Unix and Mac
    if (ch == '\r' && buffer.Peek() != '\n') ch = EOL;
    }
    string/*!*/ s = buffer.GetString(p, buffer.Pos);
    Contract.Assert(s!=null);
    return s;
  }

  void NextCh() {
    if (oldEols > 0) { ch = EOL; oldEols--; }
    else {
//      pos = buffer.Pos;
//      ch = buffer.Read(); col++;
//      // replace isolated '\r' by '\n' in order to make
//      // eol handling uniform across Windows, Unix and Mac
//      if (ch == '\r' && buffer.Peek() != '\n') ch = EOL;
//      if (ch == EOL) { line++; col = 0; }

      while (true) {
        pos = buffer.Pos;
        ch = buffer.Read(); col++;
        // replace isolated '\r' by '\n' in order to make
        // eol handling uniform across Windows, Unix and Mac
        if (ch == '\r' && buffer.Peek() != '\n') ch = EOL;
        if (ch == EOL) {
          line++; col = 0;
        }
        return;
        }


    }
-->casing1
  }
  
  void AddCh() {
    if (tlen >= tval.Length) {
      char[] newBuf = new char[2 * tval.Length];
      Array.Copy(tval, 0, newBuf, 0, tval.Length);
      tval = newBuf;
    }
    if (ch != Buffer.EOF) {
-->casing2
      NextCh();
    }
  }


-->comments

  public void CheckLiteral() {
-->literals
  }

  Token/*!*/ NextToken() {
    while(true) { // To avoid recursion
      Contract.Ensures(Contract.Result<Token>() != null);
      if(!parsingTrivia) {
        posTrailingStart = pos;
        posTrailingEndLeadingStart = pos;
        parsingTrivia = true;
        triviaTrailing = pos > 0;
        triviaNewlines = 0;
        lastWasCr = false;
      } else {
        // We just skipped a comment. Any newline coming after the comment doesn't count for the splitting of the trivia
        if(triviaTrailing && (ch == '\r' || (ch == '\n' && !lastWasCr)) && oldEols == 0) {
          triviaNewlines = 0;
          lastWasCr = (ch == '\r');
        }
      }
      while (ch == ' ' ||
-->scan1
      ) {
        if(triviaTrailing && (ch == '\r' || ch == '\n') && oldEols == 0) {
          if(ch == '\r' || (ch == '\n' && !lastWasCr)) { // Don't count \r\n as two newlines.
            triviaNewlines++;
          }
          lastWasCr = (ch == '\r');
        }
        NextCh();
        if(triviaTrailing && triviaNewlines == 2 && (ch != '\n' || !lastWasCr)) {
          triviaTrailing = false;
          posTrailingEndLeadingStart = pos;
        }
      }
      if (ch == '/' && Comment0() ||ch == '/' && Comment1()) { // From COCO's scan2
        continue; // Avoid recursive calls to NextToken() that crashes MAC devices
      }
      break;/*
      // Default Coco frame
-->scan2
      */
    }
    int apx = 0; // From Coco
    parsingTrivia = false;
    if(t == null) { // There is no trailing trivia before the first token
      posTrailingEndLeadingStart = 0;
    } else {
      if(triviaTrailing) {
        triviaTrailing = false;
        posTrailingEndLeadingStart = pos;
      }
      // Extract the trivia from the buffers
      t.TrailingTrivia = buffer.GetString(posTrailingStart, posTrailingEndLeadingStart);
    }
    
    int recKind = noSym;
    int recEnd = pos;
    var prevT = t;
    t = new Token();
    if(prevT != null) {
      prevT.Next = t;
      t.Prev = prevT;
    }
    t.LeadingTrivia = buffer.GetString(posTrailingEndLeadingStart, pos);
    
    t.pos = pos; t.col = col; t.line = line;
    t.Uri = this.Uri;
    int state;
    if (start.ContainsKey(ch)) {
      Contract.Assert(start[ch] != null);
      state = (int) start[ch];
    }
    else { state = 0; }
    tlen = 0; AddCh();

    switch (state) {
      case -1: { t.kind = eofSym; break; } // NextCh already done
      case 0: {
        if (recKind != noSym) {
          tlen = recEnd - t.pos;
          SetScannerBehindT();
        }
        t.kind = recKind; break;
      } // NextCh already done
-->scan3
    }
    t.val = new String(tval, 0, tlen);
    return t;
  }

  private void SetScannerBehindT() {
    buffer.Pos = t.pos;
    NextCh();
    line = t.line; col = t.col;
    for (int i = 0; i < tlen; i++) NextCh();
  }

  // get the next token (possibly a token already seen during peeking)
  public Token/*!*/ Scan () {
   Contract.Ensures(Contract.Result<Token>() != null);
    if (tokens.peekedTokens == null) {
      return NextToken();
    } else {
      pt = tokens = tokens.peekedTokens;
      return tokens;
    }
  }

  // peek for the next token, ignore pragmas
  public Token/*!*/ Peek () {
    Contract.Ensures(Contract.Result<Token>() != null);
    do {
      if (pt.peekedTokens == null) {
        pt.peekedTokens = NextToken();
      }
      pt = pt.peekedTokens;
    } while (pt.kind > maxT); // skip pragmas

    return pt;
  }

  // make sure that peeking starts at the current scan position
  public void ResetPeek () { pt = tokens; }

} // end Scanner

public delegate void ErrorProc(int n, string filename, int line, int col);
