是“解析”吗？ “编译”的子集？

发布于 2024-10-05 05:50:46 字数 291 浏览 0 评论 0原文

当我想到“编译”时，我想到的是将 C++ 代码转换为二进制文件。或者也许将 C# 转换为 CLR 字节代码。但“解析”可能类似于解析 Python 或 Web 模板语言，它不需要生成任何二进制文件，但可以立即逐条语句执行代码，或直接输出 HTML。

在这两种情况下你基本上都会做同样的任务吗？忽略语言语法，编译 C++ 是否与解析网站模板文件（Django、Smarty 等）或 Python 一样困难？

我想暗示的是，如果我学习“编译”或阅读一本有关“编译”的书，我一定会掌握解析非编译语言的技能吗？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

倾｀听者〃 2024-10-12 05:50:46

简短回答：解析不是编译的子集。

长答案：一般来说，将源代码转换为另一种格式有 3 个步骤：

Lexin，它将某种形式的输入转换为令牌流。
解析，将令牌流转换为抽象语法树（AST）。
编译，将 AST 转换为一组可执行指令（本机代码、字节代码等）。

（对于非常简单的语言，您甚至可能不需要解析器，您可能能够直接编译令牌流，或者您的解析器可以直接输出本机代码。）

因此从像这样的原始字符串开始：

let x = 0
while x < 10
    print x
    x := x + 1

词法分析器将转换将其转换为令牌流，可能是这样的：

[LET; String("x"); EQ; Int(0); NEWLINE; WHILE; String("x");
 LT; VAL(10); ... ]

解析器会将流转换为更有意义的数据结构，即你的抽象语法树：

// AST definition
type expr =
    | Block of expr list
    | Assign of string * expr
    | While of expr * expr
    | Call of string * expr list
    | Add of expr * expr
    | Var of string
    | Int of int

// AST instance created from token stream
Block
    [
        Assign("x", Int(10));
        While
        (
            LessThan(Var("x"), Int(10)),
            Block
                [
                    Call("print", [Var("x")]);
                    Assign("x", Add(Var("x"), Int(1)));
                ]
        );
    ]

一旦你有了 AST，你就可以用它做任何它想做的事情：

你将 AST 转换为原生代码（编译）。
或者您可以即时解释 AST，这可以使用动态编程语言或模板引擎来完成。
或者你可以迭代 AST 来制作语法荧光笔。
或者您可以遍历 AST 并以另一种语言输出等效代码。
或者您可以查找 Var("x") 的所有实例，并将它们替换为 Var("y")（类似于代码重构工具）。

因此，虽然您通常在编译之前解析输入，但这并不等同于说解析是编译的子集。

Short answer: parsing is not a subset of compiling.

Long answer: generally, there are a 3 steps to converting source to another format:

Lexing, which converts some form of input to a token stream.
Parsing, which converts the token stream into an abstract syntax tree (AST).
Compiling, which converts the AST into a set of executable instructions (native code, byte code, etc).

(For very simple languages, you may not even need a parser, you might be able to compile the token stream directly, or your parser could output native code directly.)

So start with a raw string like this:

let x = 0
while x < 10
    print x
    x := x + 1

A lexer is going to convert it into a token stream, probably something like this:

[LET; String("x"); EQ; Int(0); NEWLINE; WHILE; String("x");
 LT; VAL(10); ... ]

The parser will convert the stream into a more meaningful data structure, your abstract syntax tree:

// AST definition
type expr =
    | Block of expr list
    | Assign of string * expr
    | While of expr * expr
    | Call of string * expr list
    | Add of expr * expr
    | Var of string
    | Int of int

// AST instance created from token stream
Block
    [
        Assign("x", Int(10));
        While
        (
            LessThan(Var("x"), Int(10)),
            Block
                [
                    Call("print", [Var("x")]);
                    Assign("x", Add(Var("x"), Int(1)));
                ]
        );
    ]

Once you have an AST, you can do whatever it wants with it:

You convert the AST to native code (compiling).
or you could interpret the AST on the fly, which you might do with a dynamic programming language or a templating engine.
or you could iterate the AST to make a syntax highlighter.
or you could walk the AST and output equivalent code in another language.
or you could look for all instances of Var("x") and replace them with Var("y") similar to a code refactor tool).

So, while you usually parse input before compiling, that's not the same as saying that parsing is a subset of compiling.

回复收藏 0 原文