豆包写的LISP解释器，共200多行

JuncoJet

这才是真神

1. #include <iostream>
   
2. #include <vector>
   
3. #include <string>
   
4. #include <sstream>
   
5. #include <stdexcept>
   
6. 
   
7. // 定义 Token 类型
   
8. enum TokenType {
   
9.         LEFT_PAREN,
   
10.         RIGHT_PAREN,
    
11.         NUMBER,
    
12.         SYMBOL
    
13. };
    
14. 
    
15. // 定义 Token 结构体
    
16. struct Token {
    
17.         TokenType type;
    
18.         std::string value;
    
19. };
    
20. 
    
21. // 判断字符串是否全为数字的辅助函数
    
22. bool isAllDigits(const std::string& str) {
    
23.         for (std::string::size_type i = 0; i < str.length(); ++i) {
    
24.                 if (!isdigit(str[i])) {
    
25.                         return false;
    
26.                 }
    
27.         }
    
28.         return true;
    
29. }
    
30. 
    
31. // 词法分析函数，添加调试输出
    
32. std::vector<Token> tokenize(const std::string& input) {
    
33.         std::vector<Token> tokens;
    
34.         std::string tokenStr;
    
35.         std::cout << "Tokenizing input: " << input << std::endl;
    
36.         for (size_t i = 0; i < input.length(); ++i) {
    
37.                 char c = input[i];
    
38.                 if (c == ' ') {
    
39.                         if (!tokenStr.empty()) {
    
40.                                 Token token;
    
41.                                 if (isAllDigits(tokenStr)) {
    
42.                                         token.type = NUMBER;
    
43.                                         token.value = tokenStr;
    
44.                                 } else {
    
45.                                         token.type = SYMBOL;
    
46.                                         token.value = tokenStr;
    
47.                                 }
    
48.                                 tokens.push_back(token);
    
49.                                 std::cout << "Found token: type=";
    
50.                                 switch (token.type) {
    
51.                                 case LEFT_PAREN: std::cout << "LEFT_PAREN"; break;
    
52.                                 case RIGHT_PAREN: std::cout << "RIGHT_PAREN"; break;
    
53.                                 case NUMBER: std::cout << "NUMBER"; break;
    
54.                                 case SYMBOL: std::cout << "SYMBOL"; break;
    
55.                                 }
    
56.                                 std::cout << ", value=" << token.value << std::endl;
    
57.                                 tokenStr.clear();
    
58.                         }
    
59.                 } else if (c == '(') {
    
60.                         if (!tokenStr.empty()) {
    
61.                                 Token token;
    
62.                                 if (isAllDigits(tokenStr)) {
    
63.                                         token.type = NUMBER;
    
64.                                         token.value = tokenStr;
    
65.                                 } else {
    
66.                                         token.type = SYMBOL;
    
67.                                         token.value = tokenStr;
    
68.                                 }
    
69.                                 tokens.push_back(token);
    
70.                                 std::cout << "Found token: type=";
    
71.                                 switch (token.type) {
    
72.                                 case LEFT_PAREN: std::cout << "LEFT_PAREN"; break;
    
73.                                 case RIGHT_PAREN: std::cout << "RIGHT_PAREN"; break;
    
74.                                 case NUMBER: std::cout << "NUMBER"; break;
    
75.                                 case SYMBOL: std::cout << "SYMBOL"; break;
    
76.                                 }
    
77.                                 std::cout << ", value=" << token.value << std::endl;
    
78.                                 tokenStr.clear();
    
79.                         }
    
80.                         Token token;
    
81.                         token.type = LEFT_PAREN;
    
82.                         token.value = "(";
    
83.                         tokens.push_back(token);
    
84.                         std::cout << "Found token: type=LEFT_PAREN, value=(" << std::endl;
    
85.                 } else if (c == ')') {
    
86.                         if (!tokenStr.empty()) {
    
87.                                 Token token;
    
88.                                 if (isAllDigits(tokenStr)) {
    
89.                                         token.type = NUMBER;
    
90.                                         token.value = tokenStr;
    
91.                                 } else {
    
92.                                         token.type = SYMBOL;
    
93.                                         token.value = tokenStr;
    
94.                                 }
    
95.                                 tokens.push_back(token);
    
96.                                 std::cout << "Found token: type=";
    
97.                                 switch (token.type) {
    
98.                                 case LEFT_PAREN: std::cout << "LEFT_PAREN"; break;
    
99.                                 case RIGHT_PAREN: std::cout << "RIGHT_PAREN"; break;
    
100.                                 case NUMBER: std::cout << "NUMBER"; break;
     
101.                                 case SYMBOL: std::cout << "SYMBOL"; break;
     
102.                                 }
     
103.                                 std::cout << ", value=" << token.value << std::endl;
     
104.                                 tokenStr.clear();
     
105.                         }
     
106.                         Token token;
     
107.                         token.type = RIGHT_PAREN;
     
108.                         token.value = ")";
     
109.                         tokens.push_back(token);
     
110.                         std::cout << "Found token: type=RIGHT_PAREN, value=)" << std::endl;
     
111.                 } else {
     
112.                         tokenStr += c;
     
113.                 }
     
114.         }
     
115.         if (!tokenStr.empty()) {
     
116.                 Token token;
     
117.                 if (isAllDigits(tokenStr)) {
     
118.                         token.type = NUMBER;
     
119.                         token.value = tokenStr;
     
120.                 } else {
     
121.                         token.type = SYMBOL;
     
122.                         token.value = tokenStr;
     
123.                 }
     
124.                 tokens.push_back(token);
     
125.                 std::cout << "Found token: type=";
     
126.                 switch (token.type) {
     
127.                 case LEFT_PAREN: std::cout << "LEFT_PAREN"; break;
     
128.                 case RIGHT_PAREN: std::cout << "RIGHT_PAREN"; break;
     
129.                 case NUMBER: std::cout << "NUMBER"; break;
     
130.                 case SYMBOL: std::cout << "SYMBOL"; break;
     
131.                 }
     
132.                 std::cout << ", value=" << token.value << std::endl;
     
133.         }
     
134.         return tokens;
     
135. }
     
136. 
     
137. // 定义 AST 节点类型
     
138. struct ASTNode {
     
139.         std::string value;
     
140.         std::vector<ASTNode> children;
     
141. };
     
142. 
     
143. // 语法分析函数，添加调试输出
     
144. ASTNode parse(const std::vector<Token>& tokens, size_t& pos, int depth = 0) {
     
145.         std::string indent(depth * 2, ' ');
     
146.         std::cout << indent << "Parsing at position " << pos << std::endl;
     
147.         ASTNode node;
     
148.         const Token& token = tokens[pos++];
     
149.         if (token.type == LEFT_PAREN) {
     
150.                 std::cout << indent << "Found left parenthesis, starting sub - expression" << std::endl;
     
151.                 while (tokens[pos].type != RIGHT_PAREN) {
     
152.                         node.children.push_back(parse(tokens, pos, depth + 1));
     
153.                 }
     
154.                 std::cout << indent << "Found right parenthesis, ending sub - expression" << std::endl;
     
155.                 pos++; // 跳过右括号
     
156.         } else if (token.type == NUMBER || token.type == SYMBOL) {
     
157.                 node.value = token.value;
     
158.                 std::cout << indent << "Found " << (token.type == NUMBER ? "number" : "symbol") << ": " << node.value << std::endl;
     
159.         }
     
160.         return node;
     
161. }
     
162. 
     
163. // 将字符串转换为整数的辅助函数
     
164. int stringToInt(const std::string& str) {
     
165.         int result = 0;
     
166.         std::istringstream iss(str);
     
167.         iss >> result;
     
168.         return result;
     
169. }
     
170. 
     
171. // 解释执行函数，添加调试输出
     
172. int evaluate(const ASTNode& node, int depth = 0) {
     
173.         std::string indent(depth * 2, ' ');
     
174.         std::cout << indent << "Evaluating node: ";
     
175.         if (node.children.empty()) {
     
176.                 std::cout << "Leaf node with value " << node.value << std::endl;
     
177.                 try {
     
178.                         int val = stringToInt(node.value);
     
179.                         std::cout << indent << "Value of leaf node: " << val << std::endl;
     
180.                         return val;
     
181.                 } catch (...) {
     
182.                         throw std::runtime_error("Invalid number: " + node.value);
     
183.                 }
     
184.         }
     
185. 
     
186.         std::string op = node.children[0].value;
     
187.         std::cout << "Operator node with op " << op << std::endl;
     
188.         if (op == "+") {
     
189.                 int result = 0;
     
190.                 std::cout << indent << "Performing addition" << std::endl;
     
191.                 for (size_t i = 1; i < node.children.size(); ++i) {
     
192.                         int childResult = evaluate(node.children[i], depth + 1);
     
193.                         result += childResult;
     
194.                         std::cout << indent << "Adding child result " << childResult << ", current sum: " << result << std::endl;
     
195.                 }
     
196.                 std::cout << indent << "Final result of addition: " << result << std::endl;
     
197.                 return result;
     
198.         } else if (op == "-") {
     
199.                 std::cout << indent << "Performing subtraction" << std::endl;
     
200.                 if (node.children.size() == 2) {
     
201.                         int childResult = evaluate(node.children[1], depth + 1);
     
202.                         std::cout << indent << "Result of subtraction: " << childResult << std::endl;
     
203.                         return childResult;
     
204.                 } else {
     
205.                         int result = evaluate(node.children[1], depth + 1);
     
206.                         std::cout << indent << "Initial value for subtraction: " << result << std::endl;
     
207.                         for (size_t i = 2; i < node.children.size(); ++i) {
     
208.                                 int childResult = evaluate(node.children[i], depth + 1);
     
209.                                 result -= childResult;
     
210.                                 std::cout << indent << "Subtracting child result " << childResult << ", current result: " << result << std::endl;
     
211.                         }
     
212.                         std::cout << indent << "Final result of subtraction: " << result << std::endl;
     
213.                         return result;
     
214.                 }
     
215.         } else {
     
216.                 throw std::runtime_error("Unsupported operator: " + op);
     
217.         }
     
218. }
     
219. 
     
220. int main() {
     
221.         std::string input;
     
222.         std::cout << "Enter a LISP expression: ";
     
223.         std::getline(std::cin, input);
     
224. 
     
225.         try {
     
226.                 std::vector<Token> tokens = tokenize(input);
     
227.                 size_t pos = 0;
     
228.                 std::cout << "Starting parsing..." << std::endl;
     
229.                 ASTNode ast = parse(tokens, pos);
     
230.                 std::cout << "Starting evaluation..." << std::endl;
     
231.                 int result = evaluate(ast);
     
232.                 std::cout << "Result: " << result << std::endl;
     
233.         } catch (const std::exception& e) {
     
234.                 std::cerr << "Error: " << e.what() << std::endl;
     
235.         }
     
236. 
     
237.         return 0;
     
238. }

复制代码

代码生成/调试过程
https://www.doubao.com/thread/wcd00bbdbbc68a282

bigluo

不大长的代码，用AI的确是OK了，我昨天把协议给DS，人家就给出代码，直接就成功了：
------------------------------------------------------------
TCP通讯协议：
字节位 0、 ASCII 字符’V’，整数 86。
字节位 1、 ASCII 字符’Z’，整数 90.
字节位 2、 Data 数据类型
0X00 数据包。
0X01 心跳包，数据长度为 0， DATA 为空
字节位 3、 包序号，包序列号为递增的数值，用于对应请求命令与返回命
令；例如发送一个请求命令到服务器端，服务器端在返回结果时，会将请求命令中
的包序列号填充到返回数据包的包序列号中，便于客户端这边将返回结果与请求命
令进行对应。如果不存在对应问题，则设置为 0 即可。如果编号到 255，则从 0 开
始重新编号。
字节位 4 – 7、一共四位，代表接下来的数据长度。这个数据是网络字节序，
在接收的时候务必调用 htol 这样的函数将网络字节序转换成主机字节序。数据的长
度不要大于 1024 * 1024 = 1MB。服务器将不会接收超过 1MB 大小的数据，同样服务
器也不会发送超过 1MB 大小的数据包。理论上，除了心跳包之外，其它所有数据的
长度都不会是 0。
字节位 8 以后是数据包
数据包,就发送这个:
{"cmd": "getsn","id":"123456"}
麻烦用python写一段代码, 发送上面的一段指令给 192.168.1.100:8131
----------------------------------------
import socket
import struct
import json

# 目标地址和端口
HOST = '192.168.1.100'
PORT = 8131

# 构造协议头
header = bytearray()
# 字节位0-1：固定头
header.append(ord('V'))  # 0x56
header.append(ord('Z'))  # 0x5A

# 字节位2：数据类型（0x00数据包）
header.append(0x00)

# 字节位3：包序号（设为0）
header.append(0x00)

# 构造数据部分
data = json.dumps({"cmd": "getsn", "id": "123456"}).encode('utf-8')

# 字节位4-7：数据长度（网络字节序）
data_length = struct.pack('>I', len(data))  # 大端无符号整型
header.extend(data_length)

# 组合完整数据包
packet = header + data

# 创建socket并发送
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    s.sendall(packet)
    print("数据已发送")

    # 可选：接收响应（根据实际情况处理）
    # response = s.recv(1024)
    # print("收到响应:", response)

JuncoJet

bigluo 发表于 2025-3-6 15:40
不大长的代码，用AI的确是OK了，我昨天把协议给DS，人家就给出代码，直接就成功了：
-------------------- ...

现在AI太强，严重加速了历史进程，嗅探到了危险的气息

girlexplorer

能将Fortran77源代码转换成python代码吗？

JuncoJet

girlexplorer 发表于 2025-3-6 23:36
能将Fortran77源代码转换成python代码吗？

肯定可以，这难度不高

scoopydoo

俺提个意见，啊不，建议啊。

现在写代码一般都不用 8 个字符的缩进了，普遍用 4 个字符甚至 2 个字符。

JuncoJet

scoopydoo 发表于 2025-3-7 00:12
俺提个意见，啊不，建议啊。

现在写代码一般都不用 8 个字符的缩进了，普遍用 4 个字符甚至 2 个字符。

原文内容是4个空格缩进，论坛自动转了码

koei

我想找一款LISP解释器，怀念一下约30多年前上人工智能课，在DOS下使用lisp做符号处理的感觉。LISP语言编程，给人另外一种思维，这是我当时的感觉。