//设置package包名称以及导入依赖的类
package examples.parsing

import scala.util.parsing.combinator.Parsers
import scala.util.parsing.input.CharArrayReader

object listParser {
  abstract class Tree
  case class Id(s: String)          extends Tree
  case class Num(n: Int)            extends Tree
  case class Lst(elems: List[Tree]) extends Tree

  import Character.{isLetter, isLetterOrDigit, isDigit}
  def mkString(cs: List[Any]) = cs.mkString("")

  class ListParsers extends Parsers {
    type Elem = Char
    
    lazy val ident = rep1(elem("letter", isLetter), elem("letter or digit", isLetterOrDigit)) ^^ {cs => Id(mkString(cs))}
    lazy val number = chainl1(elem("digit", isDigit) ^^ (_ - '0'), success{(accum: Int, d: Int) => accum * 10 + d}) ^^ Num
    lazy val list = '(' ~> repsep(expr, ',') <~ ')' ^^ Lst
    lazy val expr: Parser[Tree] = list | ident | number
  }

  def main(args: Array[String]) {
    println(
      if (args.length == 0) "usage: scala examples.parsing.listParser <list-string>"
      else (new ListParsers).expr(new CharArrayReader(args.mkString(" ").toCharArray()))
    )
  }
} 

//设置package包名称以及导入依赖的类
package se.dimovski.rencode.internal

import scala.util.parsing.combinator.Parsers



trait ParserGenerator extends Parsers {
  override def repN[T](n: Int, p: => Parser[T]): Parser[List[T]] = Parser {
    in0 =>
      val xs = new scala.collection.mutable.ListBuffer[T]
      var in = in0
      var i = n

      if (n == 0) {
        return success(List())
      }
      var res = p(in)
      while (res.successful && i > 0) {
        i -= 1
        xs += res.get
        in = res.next
        res = p(in)
      }

      res match {
        case e: Error => e
        case _ =>
          if (!xs.isEmpty) {
            Success(xs.toList, in)
          }
          else {
            Failure(res.asInstanceOf[NoSuccess].msg, in0)
          }
      }
  }
} 

//设置package包名称以及导入依赖的类
package com.github.kczulko.isc.dhcp

import com.github.kczulko.isc.dhcp.parsers.RegexMatchedParser

import scala.util.matching.Regex
import scala.util.parsing.combinator.Parsers

private[dhcp] trait Tokens extends Parsers with RegexMatchedParser {
  def DATE_LITERAL_REGEX: Parser[String] = """\d{4}/\d{2}/\d{2}""".r
  def HOUR_LITERAL_REGEX: Parser[String] = """\d{2}:\d{2}:\d{2}""".r
  def MAC_ADDRESS_REGEX: Parser[String] =
    """([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})""".r
  def IP_ADDRESS_REGEX: Parser[String] = """(?:[0-9]{1,3}\.){3}[0-9]{1,3}""".r
  def WHATEVER_REGEX: Parser[String] =
    regexMatchedParser(new Regex(s"""(.*)?(;)""", "content", "semicolon")) ^^
      (_.group("content"))
} 

//设置package包名称以及导入依赖的类
package sbt.impl

import scala.util.parsing.combinator.Parsers
import scala.util.parsing.input.CharSequenceReader
import scala.util.parsing.input.CharArrayReader.EofCh


private[sbt] object CommandParser extends Parsers
{
	type Elem = Char
	def parse(commandString: String): Either[String, (String, List[String])] =
	{
		command(new CharSequenceReader(commandString.trim, 0)) match
		{
			case Success(id ~ args, next) => Right((id, args))
			case err: NoSuccess =>
			{
				val pos = err.next.pos
				Left("Could not parse command: (" + pos.line + "," + pos.column + "): " + err.msg)
			}
		}
	}
	def command = phrase(identifier ~! (argument*))
	def identifier = unquoted | err("Expected identifier")
	def argument = ( (whitespaceChar+) ~> (unquoted | quoted) )
	
	def unquoted: Parser[String] = ((unquotedChar ~! (unquotedMainChar*)) ^^ { case a ~ tail => (a :: tail).mkString("") })
	def quoted: Parser[String] = quote ~> quotedChars <~ (quote | err("Missing closing quote character"))

	def quotedChars: Parser[String] = (escape | nonescapeChar)*
	def escape: Parser[Char] = backslash ~> (escapeChar | err("Illegal escape"))
	def escapeChar: Parser[Char] = quote | backslash
	def nonescapeChar: Parser[Char] = elem("", ch => !isEscapeChar(ch) && ch != EofCh)
	def unquotedChar: Parser[Char] = elem("", ch => !isEscapeChar(ch) && !Character.isWhitespace(ch) && ch != EofCh)
	def unquotedMainChar: Parser[Char] = unquotedChar | (errorIfEscape ~> failure(""))

	private def errorIfEscape = (not(quote) | err("Unexpected quote character")) ~>
		(not(backslash) | err("Escape sequences can only occur in a quoted argument"))

	private def isEscapeChar(ch: Char) = ch == '\\' || ch == '"'
	
	def quote: Parser[Char] = '"'
	def backslash: Parser[Char] = '\\'
	def whitespaceChar: Parser[Char] = elem("whitespace", ch => Character.isWhitespace(ch))

	private implicit def toString(p: Parser[List[Char]]): Parser[String] = p ^^ {_ mkString "" }
} 

//设置package包名称以及导入依赖的类
package io.github.writeonly.resentiment.teapot.phases.analyzers

import io.github.writeonly.resentiment.teapot.core.Command

import scala.util.parsing.combinator.{JavaTokenParsers, PackratParsers, Parsers}

trait Analyzer extends Parsers {
  def parse(code : String) : ParseResult[Command]
  def apply(code : String) : Command = parse(code) match {
    case Success(r, n) => r
//    case NoSuccess(msg, n) => throw new IllegalArgumentException(msg + "|" + n)
    case f:Failure => throw new IllegalArgumentException(f.toString())
    case e:Error => throw new IllegalArgumentException(e.toString())
  }
}

trait AnalyzerLL extends Analyzer with JavaTokenParsers {}

trait AnalyzerLR extends AnalyzerLL with PackratParsers {}