FParsecの数値の解析

私はFParsecの学習を始めました。それは数字を解析する非常に柔軟な方法を持っています。私は使用したい数値フォーマットのセットを提供することができます:

type Number =
    | Numeral of int
    | Decimal of float
    | Hexadecimal of int
    | Binary of int

let numberFormat = NumberLiteralOptions.AllowFraction
                   ||| NumberLiteralOptions.AllowHexadecimal
                   ||| NumberLiteralOptions.AllowBinary

let pnumber = 
    numberLiteral numberFormat "number"
    |>> fun num -> if num.IsHexadecimal then Hexadecimal (int num.String)
                   elif num.IsBinary then Binary (int num.String)
                   elif num.IsInteger then Numeral (int num.String)
                   else Decimal (float num.String)

しかし、私が解析しようとしている言語は少し奇妙です。数字は数字(非負 int )、小数点以下(非負 float )、16進数(接頭辞 #x )またはバイナリ(接頭辞 #b ):

numeral: 0, 2
decimal: 0.2, 2.0
hexadecimal: #xA04, #x611ff
binary: #b100, #b001

今すぐ 0 (必要に応じて)に置き換えて pnumber を使用して2回解析する必要があります。

let number: Parser<_, unit> =  
    let isDotOrDigit c = isDigit c || c = '.'
    let numOrDec = many1Satisfy2 isDigit isDotOrDigit 
    let hexOrBin = skipChar '#' >>. manyChars (letter <|> digit) |>> sprintf "0%s"
    let str = spaces >>. numOrDec <|> hexOrBin
    str |>> fun s -> match run pnumber s with
                     | Success(result, _, _)   -> result
                     | Failure(errorMsg, _, _) -> failwith errorMsg

この場合、解析の良い方法は何ですか?または、FParsecの CharStream を変更して、条件付き解析を容易にする方法はありますか?

7

1 答え

良好なエラーメッセージを生成し、オーバーフローを適切にチェックしたい場合は、解析番号をかなり乱雑にすることができます。

以下は、数値パーサーの単純なFParsec実装です:

let numeralOrDecimal : Parser<_, unit> =
   //note: doesn't parse a float exponent suffix
    numberLiteral NumberLiteralOptions.AllowFraction "number" 
    |>> fun num -> 
           //raises an exception on overflow
            if num.IsInteger then Numeral(int num.String)
            else Decimal(float num.String)

let hexNumber =    
    pstring "#x" >>. many1SatisfyL isHex "hex digit"
    |>> fun hexStr -> 
           //raises an exception on overflow
            Hexadecimal(System.Convert.ToInt32(hexStr, 16)) 

let binaryNumber =    
    pstring "#b" >>. many1SatisfyL (fun c -> c = '0' || c = '1') "binary digit"
    |>> fun hexStr -> 
           //raises an exception on overflow
            Binary(System.Convert.ToInt32(hexStr, 2))


let number =
    choiceL [numeralOrDecimal
             hexNumber
             binaryNumber]
            "number literal"

オーバーフローで良いエラーメッセージを生成すると、この実装は少し複雑になります。エラー後にバックトラックする必要がありますので、エラー位置は数値リテラルの先頭になります( numberLiteral ドキュメントを参照してください)。

考えられるオーバーフロー例外を適切に処理する簡単な方法は、以下のような小さな例外処理コンビネータを使用することです。

let mayThrow (p: Parser<'t,'u>) : Parser<'t,'u> =
    fun stream ->
        let state = stream.State        
        try 
            p stream
        with e ->//catching all exceptions is somewhat dangerous
            stream.BacktrackTo(state)
            Reply(FatalError, messageError e.Message)

次に、

let number = mayThrow (choiceL [...] "number literal")

条件付き解析を容易にするためにFParsecの CharStream を変更することで、あなたが何を言っているのか分かりませんが、次のサンプルでは、 CharStream メソッドを直接呼び出すことができます。

type NumberStyles = System.Globalization.NumberStyles
let invariantCulture = System.Globalization.CultureInfo.InvariantCulture

let number: Parser =
  let expectedNumber = expected "number"
  let inline isBinary c = c = '0' || c = '1'
  let inline hex2int c = (int c &&& 15) + (int c >>> 6)*9

  let hexStringToInt (str: string) =//does no argument or overflow checking        
      let mutable n = 0
      for c in str do
          n <- n*16 + hex2int c
      n    

  let binStringToInt (str: string) =//does no argument or overflow checking
      let mutable n = 0
      for c in str do
          n <- n*2 + (int c - int '0')
      n

  let findIndexOfFirstNonNull (str: string) =
      let mutable i = 0
      while i < str.Length && str.[i] = '0' do
          i <- i + 1
      i

  let isHexFun = id isHex//tricks the compiler into caching the function object
  let isDigitFun = id isDigit
  let isBinaryFun = id isBinary

  fun stream ->
    let start = stream.IndexToken
    let cs = stream.Peek2()        
    match cs.Char0, cs.Char1 with
    | '#', 'x' ->
        stream.Skip(2)
        let str = stream.ReadCharsOrNewlinesWhile(isHexFun, false)
        if str.Length <> 0 then
            let i = findIndexOfFirstNonNull str
            let length = str.Length - i
            if length < 8 || (length = 8 && str.[i] <= '7') then
                Reply(Hexadecimal(hexStringToInt str))
            else
                stream.Seek(start)
                Reply(Error, messageError "hex number literal is too large for 32-bit int")
        else 
            Reply(Error, expected "hex digit")

    | '#', 'b' ->
        stream.Skip(2)
        let str = stream.ReadCharsOrNewlinesWhile(isBinaryFun, false)
        if str.Length <> 0 then
            let i = findIndexOfFirstNonNull str
            let length = str.Length - i
            if length < 32 then 
                Reply(Binary(binStringToInt str))
            else
                stream.Seek(start)
                Reply(Error, messageError "binary number literal is too large for 32-bit int")
        else 
            Reply(Error, expected "binary digit")

    | c, _ ->
        if not (isDigit c) then Reply(Error, expectedNumber)
        else
            stream.SkipCharsOrNewlinesWhile(isDigitFun) |> ignore
            if stream.Skip('.') then
                let n2 = stream.SkipCharsOrNewlinesWhile(isDigitFun)
                if n2 <> 0 then
                   //we don't parse any exponent, as in the other example
                    let mutable result = 0.
                    if System.Double.TryParse(stream.ReadFrom(start), 
                                              NumberStyles.AllowDecimalPoint,
                                              invariantCulture, 
                                              &result)
                    then Reply(Decimal(result))
                    else 
                        stream.Seek(start)
                        Reply(Error, messageError "decimal literal is larger than System.Double.MaxValue")                    
                else 
                    Reply(Error, expected "digit")
            else
               let decimalString = stream.ReadFrom(start)
               let mutable result = 0
               if System.Int32.TryParse(stream.ReadFrom(start),
                                        NumberStyles.None,
                                        invariantCulture,
                                        &result)
               then Reply(Numeral(result))
               else 
                   stream.Seek(start)
                   Reply(Error, messageError "decimal number literal is too large for 32-bit int")

この実装では、システムメソッドの助けを借りずに16進数と2進数を解析しますが、最終的に10進数の解析をInt32.TryParseメソッドとDouble.TryParseメソッドに委譲します。

私が言ったように、それは面倒です。

10
追加された
+1、高速応答、Stephanに感謝します。 「FParsecのCharStreamを変更する」とは、 CharStream の低レベル操作を意味していました。私は最初のアプローチ、簡単で理解しやすいだろう。ところで、ラベルでコンビネータを使用するコストはいくらですか?パーサ内のどこにでもラベルを使用すれば、コストがかかりますか?
追加された 著者 pad,
詳細な答えをありがとう。この場合、 skipString pstring よりも優先されるはずです。
追加された 著者 pad,
私はちょうど最初のバージョンのオーバーフロー例外をどのように扱うことができるかについてコメントを追加しました。ラベルに関して:それは依存しています。個々のエラーメッセージを収集する必要がないため、 choiceL は実際には choice より高速です。一般的に、 <?> や類似のコンビネータのオーバーヘッドは、自明ではないアプリケーションではほとんど測定できません。 FParsecパーサーで実際にパフォーマンスの問題を発見した場合は、常に高速化する方法があります。
追加された 著者 Stephan Tolksdorf,
パフォーマンスの違いはありません。両方のパーサーが結果値を作成するための作業をしなくてはならない(どちらの場合も参照型定数)。したがって、それは味の唯一の質問です。
追加された 著者 Stephan Tolksdorf,