// -*- c-basic-offset: 2 -*-

/*

 *  This file is part of the KDE libraries

 *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)

 *  Copyright (C) 2006 Apple Computer, Inc.

 *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Library General Public

 *  License as published by the Free Software Foundation; either

 *  version 2 of the License, or (at your option) any later version.

 *

 *  This library 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

 *  Library General Public License for more details.

 *

 *  You should have received a copy of the GNU Library General Public License

 *  along with this library; see the file COPYING.LIB.  If not, write to

 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 *  Boston, MA 02110-1301, USA.

 *

 */

#include "config.h"

#include "lexer.h"

#include "dtoa.h"

#include <ctype.h>

#include <limits.h>

#include <string.h>

#include "function.h"

#include "interpreter.h"

#include "nodes.h"

#include <wtf/unicode/Unicode.h>

using namespace WTF;

using namespace Unicode;

// we can't specify the namespace in yacc's C output, so do it here

using namespace KJS;

#ifndef KDE_USE_FINAL

#include "grammar.h"

#endif

#include "lookup.h"

#include "lexer.lut.h"

extern YYLTYPE kjsyylloc; // global bison variable holding token info

// a bridge for yacc from the C world to C++

int kjsyylex()

{

  return Lexer::curr()->lex();

}

namespace KJS {

static Lexer* currLexer = 0;

static bool isDecimalDigit(int);

Lexer::Lexer()

  : yylineno(1),

    size8(128), size16(128), restrKeyword(false),

    eatNextIdentifier(false), stackToken(-1), lastToken(-1), pos(0),

    code(0), length(0),

#ifndef KJS_PURE_ECMA

    bol(true),

#endif

    current(0), next1(0), next2(0), next3(0),

    strings(0), numStrings(0), stringsCapacity(0),

    identifiers(0), numIdentifiers(0), identifiersCapacity(0)

{

  // allocate space for read buffers

  buffer8 = new char[size8];

  buffer16 = new KJS::UChar[size16];

  currLexer = this;

}

Lexer::~Lexer()

{

  doneParsing();

  delete [] buffer8;

  delete [] buffer16;

}

Lexer *Lexer::curr()

{

  if (!currLexer) {

    // create singleton instance

    currLexer = new Lexer();

  }

  return currLexer;

}

#ifdef KJS_DEBUG_MEM

void Lexer::globalClear()

{

  delete currLexer;

  currLexer = 0L;

}

#endif

void Lexer::setCode(const UString &sourceURL, int startingLineNumber, const KJS::UChar *c, unsigned int len)

{

  yylineno = 1 + startingLineNumber;

  m_sourceURL = sourceURL;

  restrKeyword = false;

  delimited = false;

  eatNextIdentifier = false;

  stackToken = -1;

  lastToken = -1;

  pos = 0;

  code = c;

  length = len;

  skipLF = false;

  skipCR = false;

  error = false;

#ifndef KJS_PURE_ECMA

  bol = true;

#endif

  // read first characters

  current = (length > 0) ? code[0].uc : -1;

  next1 = (length > 1) ? code[1].uc : -1;

  next2 = (length > 2) ? code[2].uc : -1;

  next3 = (length > 3) ? code[3].uc : -1;

}

void Lexer::shift(unsigned int p)

{

  // Here would be a good place to strip Cf characters, but that has caused compatibility problems:

  // <http://bugs.webkit.org/show_bug.cgi?id=10183>.

  while (p--) {

    pos++;

    current = next1;

    next1 = next2;

    next2 = next3;

    next3 = (pos + 3 < length) ? code[pos + 3].uc : -1;

  }

}

// called on each new line

void Lexer::nextLine()

{

  yylineno++;

#ifndef KJS_PURE_ECMA

  bol = true;

#endif

}

void Lexer::setDone(State s)

{

  state = s;

  done = true;

}

int Lexer::lex()

{

  int token = 0;

  state = Start;

  unsigned short stringType = 0; // either single or double quotes

  pos8 = pos16 = 0;

  done = false;

  terminator = false;

  skipLF = false;

  skipCR = false;

  // did we push a token on the stack previously ?

  // (after an automatic semicolon insertion)

  if (stackToken >= 0) {

    setDone(Other);

    token = stackToken;

    stackToken = 0;

  }

  while (!done) {

    if (skipLF && current != '\n') // found \r but not \n afterwards

        skipLF = false;

    if (skipCR && current != '\r') // found \n but not \r afterwards

        skipCR = false;

    if (skipLF || skipCR) // found \r\n or \n\r -> eat the second one

    {

        skipLF = false;

        skipCR = false;

        shift(1);

    }

    switch (state) {

    case Start:

      if (isWhiteSpace()) {

        // do nothing

      } else if (current == '/' && next1 == '/') {

        shift(1);

        state = InSingleLineComment;

      } else if (current == '/' && next1 == '*') {

        shift(1);

        state = InMultiLineComment;

      } else if (current == -1) {

        if (!terminator && !delimited) {

          // automatic semicolon insertion if program incomplete

          token = ';';

          stackToken = 0;

          setDone(Other);

        } else

          setDone(Eof);

      } else if (isLineTerminator()) {

        nextLine();

        terminator = true;

        if (restrKeyword) {

          token = ';';

          setDone(Other);

        }

      } else if (current == '"' || current == '\'') {

        state = InString;

        stringType = static_cast<unsigned short>(current);

      } else if (isIdentStart(current)) {

        record16(current);

        state = InIdentifierOrKeyword;

      } else if (current == '\\') {

        state = InIdentifierUnicodeEscapeStart;

      } else if (current == '0') {

        record8(current);

        state = InNum0;

      } else if (isDecimalDigit(current)) {

        record8(current);

        state = InNum;

      } else if (current == '.' && isDecimalDigit(next1)) {

        record8(current);

        state = InDecimal;

#ifndef KJS_PURE_ECMA

        // <!-- marks the beginning of a line comment (for www usage)

      } else if (current == '<' && next1 == '!' &&

                 next2 == '-' && next3 == '-') {

        shift(3);

        state = InSingleLineComment;

        // same for -->

      } else if (bol && current == '-' && next1 == '-' &&  next2 == '>') {

        shift(2);

        state = InSingleLineComment;

#endif

      } else {

        token = matchPunctuator(current, next1, next2, next3);

        if (token != -1) {

          setDone(Other);

        } else {

          //      cerr << "encountered unknown character" << endl;

          setDone(Bad);

        }

      }

      break;

    case InString:

      if (current == stringType) {

        shift(1);

        setDone(String);

      } else if (isLineTerminator() || current == -1) {

        setDone(Bad);

      } else if (current == '\\') {

        state = InEscapeSequence;

      } else {

        record16(current);

      }

      break;

    // Escape Sequences inside of strings

    case InEscapeSequence:

      if (isOctalDigit(current)) {

        if (current >= '0' && current <= '3' &&

            isOctalDigit(next1) && isOctalDigit(next2)) {

          record16(convertOctal(current, next1, next2));

          shift(2);

          state = InString;

        } else if (isOctalDigit(current) && isOctalDigit(next1)) {

          record16(convertOctal('0', current, next1));

          shift(1);

          state = InString;

        } else if (isOctalDigit(current)) {

          record16(convertOctal('0', '0', current));

          state = InString;

        } else {

          setDone(Bad);

        }

      } else if (current == 'x')

        state = InHexEscape;

      else if (current == 'u')

        state = InUnicodeEscape;

      else if (isLineTerminator()) {

        nextLine();

        state = InString;

      } else {

        record16(singleEscape(static_cast<unsigned short>(current)));

        state = InString;

      }

      break;

    case InHexEscape:

      if (isHexDigit(current) && isHexDigit(next1)) {

        state = InString;

        record16(convertHex(current, next1));

        shift(1);

      } else if (current == stringType) {

        record16('x');

        shift(1);

        setDone(String);

      } else {

        record16('x');

        record16(current);

        state = InString;

      }

      break;

    case InUnicodeEscape:

      if (isHexDigit(current) && isHexDigit(next1) && isHexDigit(next2) && isHexDigit(next3)) {

        record16(convertUnicode(current, next1, next2, next3));

        shift(3);

        state = InString;

      } else if (current == stringType) {

        record16('u');

        shift(1);

        setDone(String);

      } else {

        setDone(Bad);

      }

      break;

    case InSingleLineComment:

      if (isLineTerminator()) {

        nextLine();

        terminator = true;

        if (restrKeyword) {

          token = ';';

          setDone(Other);

        } else

          state = Start;

      } else if (current == -1) {

        setDone(Eof);

      }

      break;

    case InMultiLineComment:

      if (current == -1) {

        setDone(Bad);

      } else if (isLineTerminator()) {

        nextLine();

      } else if (current == '*' && next1 == '/') {

        state = Start;

        shift(1);

      }

      break;

    case InIdentifierOrKeyword:

    case InIdentifier:

      if (isIdentPart(current))

        record16(current);

      else if (current == '\\')

        state = InIdentifierUnicodeEscapeStart;

      else

        setDone(state == InIdentifierOrKeyword ? IdentifierOrKeyword : Identifier);

      break;

    case InNum0:

      if (current == 'x' || current == 'X') {

        record8(current);

        state = InHex;

      } else if (current == '.') {

        record8(current);

        state = InDecimal;

      } else if (current == 'e' || current == 'E') {

        record8(current);

        state = InExponentIndicator;

      } else if (isOctalDigit(current)) {

        record8(current);

        state = InOctal;

      } else if (isDecimalDigit(current)) {

        record8(current);

        state = InDecimal;

      } else {

        setDone(Number);

      }

      break;

    case InHex:

      if (isHexDigit(current)) {

        record8(current);

      } else {

        setDone(Hex);

      }

      break;

    case InOctal:

      if (isOctalDigit(current)) {

        record8(current);

      }

      else if (isDecimalDigit(current)) {

        record8(current);

        state = InDecimal;

      } else

        setDone(Octal);

      break;

    case InNum:

      if (isDecimalDigit(current)) {

        record8(current);

      } else if (current == '.') {

        record8(current);

        state = InDecimal;

      } else if (current == 'e' || current == 'E') {

        record8(current);

        state = InExponentIndicator;

      } else

        setDone(Number);

      break;

    case InDecimal:

      if (isDecimalDigit(current)) {

        record8(current);

      } else if (current == 'e' || current == 'E') {

        record8(current);

        state = InExponentIndicator;

      } else

        setDone(Number);

      break;

    case InExponentIndicator:

      if (current == '+' || current == '-') {

        record8(current);

      } else if (isDecimalDigit(current)) {

        record8(current);

        state = InExponent;

      } else

        setDone(Bad);

      break;

    case InExponent:

      if (isDecimalDigit(current)) {

        record8(current);

      } else

        setDone(Number);

      break;

    case InIdentifierUnicodeEscapeStart:

      if (current == 'u')

        state = InIdentifierUnicodeEscape;

      else

        setDone(Bad);

      break;

    case InIdentifierUnicodeEscape:

      if (isHexDigit(current) && isHexDigit(next1) && isHexDigit(next2) && isHexDigit(next3)) {

        record16(convertUnicode(current, next1, next2, next3));

        shift(3);

        state = InIdentifier;

      } else {

        setDone(Bad);

      }

      break;

    default:

      assert(!"Unhandled state in switch statement");

    }

    // move on to the next character

    if (!done)

      shift(1);

#ifndef KJS_PURE_ECMA

    if (state != Start && state != InSingleLineComment)

      bol = false;

#endif

  }

  // no identifiers allowed directly after numeric literal, e.g. "3in" is bad

  if ((state == Number || state == Octal || state == Hex) && isIdentStart(current))

    state = Bad;

  // terminate string

  buffer8[pos8] = '\0';

#ifdef KJS_DEBUG_LEX

  fprintf(stderr, "line: %d ", lineNo());

  fprintf(stderr, "yytext (%x): ", buffer8[0]);

  fprintf(stderr, "%s ", buffer8);

#endif

  double dval = 0;

  if (state == Number) {

    dval = kjs_strtod(buffer8, 0L);

  } else if (state == Hex) { // scan hex numbers

    const char *p = buffer8 + 2;

    while (char c = *p++) {

      dval *= 16;

      dval += convertHex(c);

    }

    if (dval >= mantissaOverflowLowerBound)

      dval = parseIntOverflow(buffer8 + 2, p - (buffer8 + 3), 16);

    state = Number;

  } else if (state == Octal) {   // scan octal number

    const char *p = buffer8 + 1;

    while (char c = *p++) {

      dval *= 8;

      dval += c - '0';

    }

    if (dval >= mantissaOverflowLowerBound)

      dval = parseIntOverflow(buffer8 + 1, p - (buffer8 + 2), 8);

    state = Number;

  }

#ifdef KJS_DEBUG_LEX

  switch (state) {

  case Eof:

    printf("(EOF)\n");

    break;

  case Other:

    printf("(Other)\n");

    break;

  case Identifier:

    printf("(Identifier)/(Keyword)\n");

    break;

  case String:

    printf("(String)\n");

    break;

  case Number:

    printf("(Number)\n");

    break;

  default:

    printf("(unknown)");

  }

#endif

  if (state != Identifier && eatNextIdentifier)

    eatNextIdentifier = false;