parsing - OperatorPrecedenceParser が Optional (opt) 式を解析するようにする

Question

私のプロジェクト用に特定のドメイン固有言語を実装するパーサーを実装しています。

私が苦労している側面の 1 つは、式全体がオプションになるような式 (FParsec の OperatorPrecedenceParser を使用して実装される) を作成することです。

ネット上の多くの例とほぼ同じ方法で、パーサー OPP を実装しました。また、行末コメントの空白が消費される場所をずらしてみました。ただし、ボットの場合、私の試みはどれも機能しないようです（式と行末コメントの両方がオプションです）

具体的には（以下の例で実装されているように）、以下を正常に解析できるようにしようとしています。

KeyValue: expression  # comment
KeyValue:
KeyValue:  # comment

ここで、式はオプションであり、式の後にオプションのコメントがあります。「KeyValue:」はこの例ではハードコードされていますが、私が持っているメインのパーサーコードでは、これは識別子です。

注: 以下のサンプルについて。2 つの float の単純な中置加算を解析する最小限の式を実装しました。完全なパーサーはさらに多くの機能を実装しています。

NB2。式には、: と式の間に少なくとも 1 つの空白が必要です。# コメント文字は、式にはまったく表示されません。

「オプション」という表現をどのようにすればよいですか。以下の eKeyValue FParsec パーサータイプを参照してください。

以下の例には、6 つの事例が含まれています。すべてのケースが機能するはずです。wsBeforeEOL を用語の最後に追加して、オプション (opt) という式を追加しようとしましたが、何も機能しないようです。OPP は常に消費され、失敗することはないようです。

以下のサンプルプログラムの出力は次のようになります。

Test1 - Failure:
Error in Test1 - No Expression but comment: Ln: 1 Col: 15
  KeyName:    # No Expression but comment
              ^
Expecting: floating-point number or '('

Test2 - Success: Key (Some (Arithmetic (Number 2.0,Plus,Number 2.0)))
Test3 - Success: Key (Some (Arithmetic (Number 3.0,Plus,Number 3.0)))
Test4 - Success: Key (Some (Arithmetic (Number 3.0,Plus,Number 4.0)))
Test5 - Success: Key (Some (Arithmetic (Number 4.0,Plus,Number 4.0)))
Test6 - Success: Key null
Press any key to continue . . .

サンプルプログラムは次のとおりです (上記のテストケースは Main() 関数にあります。

open FParsec


    // Placeholder for state...
    type UserState = 
        {
            dummy: int            
        }
        with
            static member Create() = {dummy = -1}


    type Operator =
        | Plus

    type Expression =
        | Number of float
        | Arithmetic of Expression * Operator * Expression   // Composes 2 primatives

    type Statement =
        | Key of Expression option // Optional expression name


// very simple parsers which handles a simple string on one line.
// White space handling
let isBlank = fun c -> c = ' ' || c = '\t'
let ws1 = skipMany1SatisfyL isBlank "whitespace"
let ws = skipManySatisfy isBlank
let comment = pstring "#" >>. skipRestOfLine false
let wsBeforeEOL = skipManySatisfy isBlank >>. optional comment

// Parse a number
let sNumber = pfloat .>> wsBeforeEOL |>> Number // Test wsExpression ending

// The expression reference
let expression, expressionRef = createParserForwardedToRef()

let expressionFragment = choice [sNumber] //;sBool;sNull;sString;sIdentifier]
let bracketedExpressionFragment = between (pstring "(" .>> ws) (pstring ")" .>> ws) expression

// The parser for addition only
let oppa = new OperatorPrecedenceParser<Expression, unit, UserState>()

let parithmetic = oppa.ExpressionParser

//oppa.TermParser <- (expressionFragment .>> wsBeforeEOL)   <|> (bracketedExpressionFragment .>> wsBeforeEOL)
oppa.TermParser <- choice[expressionFragment;bracketedExpressionFragment]
oppa.AddOperator(InfixOperator("+", ws, 1, Associativity.Left, fun x y -> Arithmetic(x, Plus, y)))
expressionRef := oppa.ExpressionParser


// *** HERE: Define the Key, with optional expression, which must have at lease 1 WS,, then followed by wsBeforeEOL, which is multiple blanks and optional comment.
let eKeyValue = pstringCI "KeyName:" >>. (opt (ws1 >>. expression)) .>> wsBeforeEOL |>> Key

// Define the parser for the whole string...in this case a single line
let htmlProgramParser = spaces >>. eKeyValue .>> spaces .>> eof

// test harnes on a string
let parseHtmlProgramString programName str =
    runParserOnString htmlProgramParser (UserState.Create()) programName str //with

[<EntryPoint>]
let main argv = 
    printfn "%A" argv

    let test1 =
        "  KeyName:    # No Expression but comment"
        |> parseHtmlProgramString "Test1 - No Expression but comment"
        |> printfn "Test1 - %A"

    let test2 =
        "  KeyName:  2+2  # Expression and Comment"
        |> parseHtmlProgramString "Test2 - 2+2 # Expression and Comment"
        |> printfn "Test2 - %A"

    let test3 =
        "  KeyName:  3 + 3  # # Expression and Comment2"
        |> parseHtmlProgramString "Test3 - 3 + 3 # Expression and Comment2 (Spaces)"
        |> printfn "Test3 - %A"

    let test4 =
        "  KeyName:  (3 + 4)  # Bracketed Expression and Comment"
        |> parseHtmlProgramString "Test4 - (3 + 4) # Bracketed Expression and Comment"
        |> printfn "Test4 - %A"

    let test5 =
        "  KeyName:  (4 + 4)  "
        |> parseHtmlProgramString "Test5 - (4 + 4) # Expression + <no comment>"
        |> printfn "Test5 - %A"

    let test6 =
        "  KeyName:"
        |> parseHtmlProgramString "Test6 - <no expression> <no comment>"
        |> printfn "Test6 - %A"

    0 // return an integer exit code

parsing - OperatorPrecedenceParser が Optional (opt) 式を解析するようにする

1 に答える 1

Related

Reference