//设置package包名称以及导入依赖的类
import apdl.ApdlParserException
import apdl.parser.MainParsers
import org.scalatest.FlatSpec
import org.scalatest.prop.Checkers

import scala.util.parsing.input.CharSequenceReader

abstract class ApdlFlatSpec extends FlatSpec with Checkers {

  val parser = new MainParsers

  import parser._

  implicit override val generatorDrivenConfig = PropertyCheckConfiguration(
    minSize = 100,
    sizeRange = 50
  )

  protected def parse[A](code: String, astParser: Parser[A]): A = {
    parser.parse(astParser, new PackratReader[Char](new CharSequenceReader(code))) match {
      case Success(result, next) =>
        if (!dropWs(next).atEnd) throw new ApdlParserException(s"Unable to parse completely $code: $next")
        else result
      case n: NoSuccess =>
        if (code != "") throw new ApdlParserException(s"Unable to parse $code: $n")
        else throw new ApdlParserException(s"Unable to parse '': $n")
    }
  }

  private def dropWs(input: parser.Input): parser.Input = {
    if (input.atEnd)
      input
    else {
      if (parser.ws.pattern.matcher(input.first.toString).matches())
        dropWs(input.rest)
      else
        input
    }
  }
} 

//设置package包名称以及导入依赖的类
import scala.util.parsing.combinator._
import scala.util.parsing.input.CharSequenceReader
import scala.util.parsing.combinator.syntactical.StandardTokenParsers

object Main extends App {
  class OnesParser extends RegexParsers {    
    def ones: Parser[Any] = "1" ~ ones | "1"
  }

  class OnesPackratParser extends RegexParsers with PackratParsers {
    lazy val ones: PackratParser[Any] = ones ~ "1" | "1"
    def parseAll[T](p: Parser[T], input: String) =
      phrase(p)(new PackratReader(new CharSequenceReader(input)))
  }
  
  val parser = new OnesParser
  val input = "11111"
  println(parser.parseAll(parser.ones, input))

  val pparser = new OnesPackratParser
  println(pparser.parseAll(pparser.ones, input))
} 

//设置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 "" }
}