主页 / coding / 问题

问题[parsing](coding)

Martin Hope
Zzen
Asked: 2024-11-18 12:42:00 +0800 CST
  • 5

我正在开发 Racket 中一种简单语言的解释器，我需要实现类似于 JavaScript 的三元条件 (Expr ? Expr : Expr)。我的语言支持加法、减法和相等等基本运算，现在我要添加布尔值和这个三元运算。

这是我当前的解析代码；；解析：Expr -> AST；；将“自定义语言”Expr 解析为 AST

(define (parse expr)
  (match expr
    [(? number?) (num expr)]                      
    [(? string?) (str expr)]                      
    ['TRUE (bool #t)]                            
    ['FALSE (bool #f)]                           
    [`(+ ,x ,y) (add (parse x) (parse y))]        
    [`(- ,x ,y) (sub (parse x) (parse y))]       
    [`(=== ,x ,y) (equals (parse x) (parse y))]  
    [`(,test '? ,true ': ,false)                 
     (condt (parse test) (parse true) (parse false))]
    [_ (error "Invalid custom Lang expression")]))

我现在正在学习 racket，而且我以前只有 java 经验。我假设这就像 java 中的类，并且我定义可以解析什么？然后我会有一个运行 fn，它接受解析的输入和输出结果。

这是我的跑步

;; run: AST -> Result
;; Computes the result of running a customLang AST
(define (run ast)
  (match ast
    [(num n) n]
    [(str s) s]
    [(bool b) b]
    [(add x y) (cus+ (run x) (run y))]
    [(sub x y) (cus- (run x) (run y))]
    [(equals x y) (equal? (run x) (run y))]
    [(condt test true-branch false-branch)
     (if (truthy? (run test)) (run true-branch) (run false-branch))]
    [_ NaN]))

所以我理解这是如果 true 则先运行，如果 false 则再运行。而且我的解析似乎设置正确。但是当我尝试运行测试时

   ;; JS "truthy" true
   (check-equal? (evalcustom '(10 ? 100 : 200)) 100)

   ;; JS "truthy" false
   (check-equal? (evalcustom '((- 100 100) ? "a" : "b")) "b")))

它无法识别，只能输出我创建的错误消息。我不知道如何让这个结构和 AST 树一起工作，以及它们为什么应该工作。因此，我不知道如何调试我的问题。

谢谢您的帮助，我非常感激。

parsing
Martin Hope
Thermatix
Asked: 2024-09-23 21:40:34 +0800 CST
  • 5

假设您有一个想要解析的具体类型（您创建/拥有的），但该类型有一个通用字段，在这个例子中，我们会说可能的类型只有u8，u16& u32，并且我们只能说其他任何东西都是不正确的或太大。

假设以下情况：

  • 我已经简化了我实际使用的代码
  • 我不能直接转换为相同的类型，它们必须根据大小为 u8、u16 或 u32（粗略地模拟我实际想要的
  • 我这样展示是因为实际代码引入了太多内容，这是最小代码示例
  • 我已经尝试过对每个类型执行等操作impl FromStr for Test<u8> {}，但随后编译器会抱怨（测试需要泛型），然后当我添加时会抱怨实现冲突，impl<T> FromStr for Test<T> {}这是有道理的，因为 rust 还没有专业化
  • 实际代码不使用u8，u16或者u32，我正在尝试使我的示例代码更广泛地适用

我有以下代码：

use std::str::FromStr;

#[derive(Debug)]
struct Test<T = u8> {
    field: T
}

impl<T> FromStr for Test<T> {
    type Err = std::num::ParseIntError;
    
    fn from_str(buff: &str) -> Result<Test<T>, Self::Err> {
        let attempt: Result<u8, Self::Err> = buff.parse();
        if let Ok(field) = attempt { return Ok(Test::<u8> { field }) };
        
        let attempt: Result<u16, Self::Err> = buff.parse();
        if let Ok(field) = attempt { return Ok(Test::<u16> { field }) };
        
        let attempt: Result<u32, Self::Err> = buff.parse();
        
        match attempt {
            Ok(field) => Ok(Test::<u32> { field }),
            Err(err) => Err(err)
        }
    } 
}



fn main() -> Result<(), std::num::ParseIntError> {
    let u_8 = "128";
    let u_16 = "475";
    let u_32 = "70000";
    
    let test_8: Test = u_8.parse()?;
    let test_16: Test = u_16.parse()?;
    let test_32: Test = u_32.parse()?;
    
    println!("t8: {test_8:?}");
    println!("t16: {test_16:?}");
    println!("t32: {test_32:?}");
    
    Ok(())
 
}

我收到大量错误，例如：

= note: expected struct `Test<T>`
               found struct `Test<u16>`

这是有道理的。

我该如何让它工作？

奖励积分

为什么 Rust 要求我这样做Test::<u8>，因为我已经在每一行上方指定了类型，return为什么 Rust 不能直接推断出Tin Test<T>？

是因为Result<Self, Self::Err>和Self吗Test<T>？

parsing
Martin Hope
apache
Asked: 2024-09-20 17:25:15 +0800 CST
  • 5

我对 ANTLR 语法还不太熟悉。以下是我的 g4 文件中的内容：

tptp_file               : tptp_input* EOF;
tptp_input              : annotated_formula | include;

annotated_formula : fof_annotated  |  cnf_annotated;
fof_annotated : 'fof('name','formula_role','fof_formula annotations').';

name : atomic_word  |  integer;

atomic_word : lower_word  |  single_quoted;

lower_word : lower_alpha alpha_numeric'*';

lower_alpha : '[a-z]';
upper_alpha : '[A-Z]';
numeric : '[0-9]';

alpha_numeric : '('lower_alpha | upper_alpha | numeric | '[_])';

...

我尝试在这个包含以下内容的测试文件上使用 ANTLR 解析器：

fof(an,axiom,p).

但我收到一条错误消息：

line 1:4 token recognition error at: 'a'
line 1:5 token recognition error at: 'n'
line 1:7 token recognition error at: 'a'
line 1:8 token recognition error at: 'x'
line 1:9 token recognition error at: 'io'
line 1:11 token recognition error at: 'm'
line 1:13 token recognition error at: 'p'
line 1:6 mismatched input ',' expecting {'(', ''', '[1-9]', '[a-z]'}
line 1:12 mismatched input ',' expecting '[a-z]'
line 1:14 mismatched input ').' expecting {'(', '[', '[]', '!', '~', '?', '#', '["]', ''', '[1-9]', '[a-z]', '[A-Z]', '[$]'}

有人能帮我了解我做错了什么以及如何解决吗？谢谢。

我将 lower_alpha 声明为一个片段。

parsing
Martin Hope
Chris Geo
Asked: 2024-08-01 05:38:32 +0800 CST
  • 5

我正在尝试实现一个 LR1 解析器，使用这篇wikipedia 文章中的帮助。我已经为 LR0 项创建了一个闭包函数，当尝试为 LR1 项创建闭包时（关于向 LR0 项添加前瞻的部分），我需要计算 FIRST 和 FOLLOW 集，但是 wiki 提到了2 个 FOLLOW 集，一个接受 LR0 项，另一个只接受项集和非终结符。第二个很容易理解：

pub fn lr0_follow_in_item_set(
    rules: &[Rule],
    item_set: &[LR0Item],
    nt: &NonTerminal,
) -> BTreeSet<Terminal> {
    let mut res = BTreeSet::new();
    for item in item_set { // 
        if Some(TerminalOrNonTerminal::NonTerminal(*nt)) == item.next_symbol(rules) { // item in item set where dot is before the desired non terminal
            res.extend(lr0_follow(rules, item)); // union of the follow sets
        }
    }
    res
}

但是我找不到 LR0 项 ( lr0_follow(rules, item)) 的 FOLLOW 实现，它是否与 FOLLOW(nonterminal) 相同，其中 nonterminal 是项点后的非终端（如果有，否则返回空集）？

注意：我的 LR1 解析器不使用 epsilon。

我不知道该尝试什么，因为我找不到此特定 FOLLOW 集的任何资源。

parsing
Martin Hope
n0nsense
Asked: 2024-04-17 23:44:10 +0800 CST
  • 6

我正在尝试使用我自己在 Haskell 中手写的解析器组合库来解析表达式。我已经可以使用在 dhall 项目中找到的下面的代码来解析二进制表达式，但我没有正确理解它。

这就是我定义表达式的方式：

data Expression
  = BinaryOperation Expression Operator Expression
  | UnaryOperation Operator Expression
  deriving (Show, Eq)

这是我从 dhall 项目中获取的函数。你可以在这里阅读更多 dhall 代码

makeOperator :: Parser Operator -> Parser Expression -> Parser Expression
makeOperator parseOperator parseValue = do
  l0 <- parseValue
  fs <- many do
    operator <- do
      _ <- wsP
      parseOperator
    _ <- wsP
    r <- parseValue
    pure $ \l -> BinaryOperation l operator r
  pure $ foldl (\l f -> f l) l0 fs

我尝试通过编写下面的代码来解析一元表达式来复制 dhall 代码，但似乎此代码消耗了输入，并且不允许优先级较低的解析器完成其工作。例如+2 + 2将成为+2解析器+ 2的剩余字符串。

makeOperatorUnary :: Parser Operator -> Parser Expression -> Parser Expression
makeOperatorUnary parseOperator parseValue = do
  operator <- parseOperator
  value <- parseValue
  pure $ UnaryOperation operator value

如果有人确实解释了 dhall 代码的确切工作原理并引导我走向正确的方向，我会很高兴。

谢谢

parsing
Martin Hope
Dov
Asked: 2024-01-22 21:08:39 +0800 CST
  • 6

我编写了一个语法测试，在构造函数中是一个被执行两次的打印。我该如何解决？

首先，这是语法：

grammar simple_grail;

prog: tag_block ;

tag_block: tag*;

/* root definition of any tag in Grail */
tag:
    p | div | canvas | rect | button | txt | textlit;

p: '<' 'p' CLASS_NAME? '>' tag_block '<' '/' 'p' '>' ;
div: '<' 'div' CLASS_NAME? '>' tag_block '<' '/' 'div' '>' ;
canvas: '<' 'canvas' CLASS_NAME? '>' tag_block '<' '/' 'canvas' '>' ;
rect:
     '<' 'rect' CLASS_NAME?
     'x' ASSIGN_COORD 'y' ASSIGN_COORD 'w' ASSIGN_COORD 'h' ASSIGN_COORD
     '/>' ;
button:
    '<' 'button' CLASS_NAME? (NAME)? 'text' ASSIGN_TEXT '/>' ;
txt:
    '<' 'text' 'x' ASSIGN_COORD 'y' ASSIGN_COORD '/>' ;

textlit:
    TEXT
    ;

CLASS_NAME: [a-zA-Z_] [a-zA-Z_0-9]* ;

ASSIGN_COORD: '=' [0-9]+ ;

name: 'name' '=' NAME ;

NAME: [A-Za-z_][A-Za-z_0-9]* ;

ASSIGN_TEXT: '=' ('"' [^"]* '"' | '\'' [^']* '\'');

TEXT: ~[<]+ ;

SimpleGrailParser 的相关部分是：

public class simple_grailTagsImpl {
    @Override public void enterProg(simple_grailParser.ProgContext ctx) {
        numInstructions = 0;
        numInts = 0;
        numFloats = 0;
        numStrings = 0;
        System.out.println("Starting program size=0");
    }
}

加载它的主程序在这里。不知何故，它两次输入语法的主要规则

Starting program size=0
Starting program size=0

import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.tree.*;
public class SimpleGrailParser {
    public static void main(String[] args) {
        String text = "<p>text is here</p>";
        simple_grailLexer lexer = new simple_grailLexer(CharStreams.fromString(text));
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        simple_grailParser parser = new simple_grailParser(tokens);
        simple_grailTagsImpl listener= new simple_grailTagsImpl();
        parser.addParseListener(listener);
        ParseTree tree = parser.prog();
        ParseTreeWalker.DEFAULT.walk(listener, tree);
    }
}
parsing
Martin Hope
Dov
Asked: 2024-01-22 19:53:08 +0800 CST
  • 6

我编写了一个简单的解析器来尝试了解 ANTLR4 如何在具有匹配标签的 HTML 风格语言上工作。例如，如果有一个标签

<p> ... </p>

我认为它应该与一个规则相匹配：

p: '<' 'p' CLASS_NAME? '>' tag_block '<' '/' 'p' '>' ;

这看起来相当繁重，因为如果每个规则可以包含其他所有内容，我必须以这种方式手动编写每个规则。是否有一种通用的方法来编写规则，即对于可以包含其他标签的每种标签，前后的尖括号必须匹配？或者我只需为每一个都写一下：

p: '<' 'p' CLASS_NAME? '>' tag_block '<' '/' 'p' '>' ;
div: '<' 'div' CLASS_NAME? '>' tag_block '<' '/' 'div' '>' ;
canvas: '<' 'canvas' CLASS_NAME? '>' tag_block '<' '/' 'canvas' '>' ;

是否可以编写一个通用的复合标签，例如：

compoundtag: '<' ('p' | 'div' | 'canvas') CLASS_NAME? '>' tag_block '<' '/' ( MATCHING EARLIER NAME???) '>'

我确信我犯了更多错误，所以这里是完整的语法文件：

grammar simple_grail;

prog: tag_block ;

tag_block: (tag)*;

/* root definition of any tag in Grail */
tag:
    p | div | canvas | rect | button | txt | textlit;

p: '<' 'p' CLASS_NAME? '>' tag_block '<' '/' 'p' '>' ;
div: '<' 'div' CLASS_NAME? '>' tag_block '<' '/' 'div' '>' ;
canvas: '<' 'canvas' CLASS_NAME? '>' tag_block '<' '/' 'canvas' '>' ;
rect:
     '<' 'rect' CLASS_NAME?
     'x' ASSIGN_COORD 'y' ASSIGN_COORD 'w' ASSIGN_COORD 'h' ASSIGN_COORD
     '/>' ;
button:
    '<' 'button' (CLASS_NAME)? (NAME)? 'text' ASSIGN_TEXT '/>' ;
txt:
    '<' 'text' 'x' ASSIGN_COORD 'y' ASSIGN_COORD '/>' ;

textlit:
    TEXT?
    ;

CLASS_NAME: [a-zA-Z_] [a-zA-Z_0-9]* ;

ASSIGN_COORD: '=' [0-9]+ ;

name: 'name' '=' NAME ;

NAME: [A-Za-z_][A-Za-z_0-9]* ;

ASSIGN_TEXT: '=' ('"' [^"]* '"' | '\'' [^']* '\'');

TEXT: [^<]+ ;

我想解析第一个小程序：

<p>text goes here</p>

我希望 textlit 应该与文本匹配，对于像 p 这样的文本周围的标签，我应该覆盖 exitTextlit() 方法和 exitP() 来决定要做什么。如果我截取了 EnterP()，那么里面还没有文本。是对的吗？

有一个警告说我可以匹配空字符串，并且我知道如果我跳过空格会产生错误，但我不明白程序应该如何匹配：

<p></p>

如果textlit不能为空。

parsing
Martin Hope
learnlearnlearn
Asked: 2024-01-14 13:28:24 +0800 CST
  • 6

我在 Go 中有以下代码，我想用 Rust 重写：

func New(l *lexer.Lexer) *Parser {
    p := &Parser{l: l}
    // Read two tokens, so curToken and peekToken 
    // are both set
    p.nextToken()
    p.nextToken()
    return p
}
func (p *Parser) nextToken() {
    p.curToken = p.peekToken
    p.peekToken = p.l.NextToken()
}

在 Rust 中，我有如下内容：

struct Parser {
    l: lexer::Lexer,
    cur_token: lexer::Token,
    peek_token: lexer::Token,
}
impl Parser {
    fn new(l: lexer::Lexer, cur_token: lexer::Token, peek_token: lexer::Token) -> Self {
        Self {
            l: l,
            cur_token: cur_token,
            peek_token: peek_token,
        }
    }
    fn init(&mut self) {
        self.next_token();
        self.next_token();
    }
    fn next_token(&mut self) {
        self.cur_token = self.peek_token;
        self.peek_token = self.l.next_token();
    }
}

这是用 Rust 编写代码的最佳方式吗？

parsing
Martin Hope
librasteve
Asked: 2023-12-02 19:50:44 +0800 CST
  • 9

我有这个 raku 语法：

#!/usr/bin/env raku
use v6.d;

use Grammar::Tracer;

grammar Grammar {
    token TOP {
          <city>      \v
          <state-zip> \v?
    }
    token city {
        ^^ \V* $$
    }
    token state-zip {
        ^^ <state> <.ws>? <zipcode> $$    #<.ws> is [\h* | \v]
    }
    token state {
        \w \w
    }
    token zipcode {
        \d ** 5
    }
}

class Actions {
    method TOP($/) {
        #works
        say "city is ",    $_ with $<city>.made;
        say "state is ",   $_ with $<state-zip><state>.made;
        say "zipcode is ", $_ with $<state-zip><zipcode>.made;

        #doesn't work
        say "state2 is ",   $_ with $<state>.made;
        say "zipcode2 is ", $_ with $<zipcode>.made;
    }

    method city($/)     { make ~$/ }
    method state($/)    { make ~$/ }
    method zipcode($/)  { make ~$/ }
}

my $address = q:to/END/;
Springfield,
IL 62704
END

Grammar.parse($address, :actions(Actions));

效果很好：

TOP
|  city
|  * MATCH "Springfield,"
|  state-zip
|  |  state
|  |  * MATCH "IL"
|  |  zipcode
|  |  * MATCH "62704"
|  * MATCH "IL 62704"
city is Springfield,
state is IL
zipcode is 62704
* MATCH "Springfield,\nIL 62704\n"

token <state-zip>是让状态和邮政编码共存于一行还是跨越多行。请记住，这是一个 MRE，因此我正在寻找不会改变语法的答案，但会改变操作的 make / made 方面。

但是 - 为了简化我的代码，我希望能够从method TOP($/) {}我的示例 state2 和 zipcode2 的操作中访问顶层的州和邮政编码。我一直在尝试将状态和令牌的制作值“提升”到匹配树上 - 例如可能是这样的：

# doesn't work
method TOP($/) {
    make $<state>.made;
    make $<zip>.made;
    ...
}
method state-zip($/) {
    make $<state>.made;
    make $<zip>.made;
}

这可能吗？

parsing