一门受 LLM 时代启发的、面向 AI 友好的编程语言+编程语言的IDE

源码资源网

一门受 LLM 时代启发的、面向 AI 友好的编程语言+编程语言的IDE

该项目实现了 Snow 语言的完整编译流程,包括词法分析,语法分析,语义分析,中间表示（IR）生成以及最终的虚拟机（VM）指令生成和执行器，提供从源码到字节码再到自研编程语言虚拟机 ( SnowVM) 的完整编译-执行链路。

通过 Snow 编译器,可以将 .snow 源文件编译为 .water虚拟机指令,并在 SnowVM 上直接运行。

从源码编译、构建管理、依赖管理、项目标准化、可视化调试面板到原生镜像发布，全部由 Snow 官方工具完成，降低学习与集成成本。

背景理念

Snow 语言受到 LLM 驱动代码生成趋势的启发,强调简单而清晰的语法和严格的类型系统,以帮助 LLM 更好地理解程序。

语言使用显式的 module 声明来组织代码,用 function,params,returns,body 等关键字分隔不同代码块,语法结构固定且易读。此外,Snow 实现了语义分析来检查变量作用域和类型一致性,在编译阶段捕获错误并确保生成的中间代码正确无误。这种自上而下的编译流程,使得代码设计和生成更加模块化,可解释,也有利于调试和优化。

功能特性[td]

类别	关键特性
语言层	module / import / function / loop / if–else / Pratt 表达式解析 静态类型检查 & 作用域分析
编译器前端	Lexer / Parser / Semantic Analyzer 全栈自研，生成 JSON-AST
IR & 后端	三地址式 IR ➜ 线性扫描寄存器分配 ➜ SnowVM 指令
虚拟机	栈 + 寄存器混合架构、GUI 局部变量监视
snow pkg	- .cloud DSL 描述项目、依赖与构建 - 预设 clean / compile / run / package / publish 任务 - 离线缓存与远程仓库解析
CLI	init, compile, run, clean, build, generate,debug

开发环境安装

• 开发环境准备（附件中包含以下软件）:
  
  
  • 安装集成开发环境 IntelliJ IDEA
  • 安装 Java 开发工具 Graalvm-jdk-24
    
• 获取源码: 将项目源码下载或克隆到本地目录。
• 运行项目
  使用IDEA配置好的运行配置 Demo1

  一门受 LLM 时代启发的、面向 AI 友好的编程语言+编程语言的IDE

  
• 运行成功
  
  1. ## 编译器输出
     
  2. ### Snow 源代码
     
  3. #### Main.snow
     
  4. module: Main
     
  5.     import:Math
     
  6.     function: main
     
  7.         returns: int
     
  8.         body:
     
  9.             Math.add(6,1)
     
  10.             return 0
      
  11.         end body
      
  12.     end function
      
  13. end module
      
  14. line   col    type             lexeme
      
  15. ----------------------------------------------------
      
  16. 1      1      KEYWORD          module
      
  17. 1      7      COLON            :
      
  18. 1      9      IDENTIFIER       Main
      
  19. 1      13     NEWLINE          \n
      
  20. 
      
  21. 2      5      KEYWORD          import
      
  22. 2      11     COLON            :
      
  23. 2      12     IDENTIFIER       Math
      
  24. 2      16     NEWLINE          \n
      
  25. 
      
  26. 3      5      KEYWORD          function
      
  27. 3      13     COLON            :
      
  28. 3      15     IDENTIFIER       main
      
  29. 3      19     NEWLINE          \n
      
  30. 
      
  31. 4      9      KEYWORD          returns
      
  32. 4      20     COLON            :
      
  33. 4      22     TYPE             int
      
  34. 4      25     NEWLINE          \n
      
  35. 
      
  36. 5      9      KEYWORD          body
      
  37. 5      13     COLON            :
      
  38. 5      14     NEWLINE          \n
      
  39. 
      
  40. 6      13     IDENTIFIER       Math
      
  41. 6      17     DOT              .
      
  42. 6      18     IDENTIFIER       add
      
  43. 6      21     LPAREN           (
      
  44. 6      22     NUMBER_LITERAL   6
      
  45. 6      23     COMMA            ,
      
  46. 6      24     NUMBER_LITERAL   1
      
  47. 6      25     RPAREN           )
      
  48. 6      26     NEWLINE          \n
      
  49. 
      
  50. 7      13     KEYWORD          return
      
  51. 7      20     NUMBER_LITERAL   0
      
  52. 7      21     NEWLINE          \n
      
  53. 
      
  54. 8      9      KEYWORD          end
      
  55. 8      13     KEYWORD          body
      
  56. 8      17     NEWLINE          \n
      
  57. 
      
  58. 9      5      KEYWORD          end
      
  59. 9      9      KEYWORD          function
      
  60. 9      17     NEWLINE          \n
      
  61. 
      
  62. 10     1      KEYWORD          end
      
  63. 10     5      KEYWORD          module
      
  64. 10     1      EOF              
      
  65. ## 词法分析通过，没有发现错误
      
  66. 
      
  67. #### Math.snow
      
  68. module: Math
      
  69.     function: add
      
  70.         params:
      
  71.             declare n1: int
      
  72.             declare n2: int
      
  73.         returns: int
      
  74.         body:
      
  75.            return n1 + n2
      
  76.         end body
      
  77.     end function
      
  78. end module
      
  79. line   col    type             lexeme
      
  80. ----------------------------------------------------
      
  81. 1      1      KEYWORD          module
      
  82. 1      7      COLON            :
      
  83. 1      9      IDENTIFIER       Math
      
  84. 1      13     NEWLINE          \n
      
  85. 
      
  86. 2      5      KEYWORD          function
      
  87. 2      13     COLON            :
      
  88. 2      15     IDENTIFIER       add
      
  89. 2      18     NEWLINE          \n
      
  90. 
      
  91. 3      9      KEYWORD          params
      
  92. 3      18     COLON            :
      
  93. 3      19     NEWLINE          \n
      
  94. 
      
  95. 4      13     KEYWORD          declare
      
  96. 4      21     IDENTIFIER       n1
      
  97. 4      23     COLON            :
      
  98. 4      25     TYPE             int
      
  99. 4      28     NEWLINE          \n
      
  100. 
       
  101. 5      13     KEYWORD          declare
       
  102. 5      21     IDENTIFIER       n2
       
  103. 5      23     COLON            :
       
  104. 5      25     TYPE             int
       
  105. 5      28     NEWLINE          \n
       
  106. 
       
  107. 6      9      KEYWORD          returns
       
  108. 6      20     COLON            :
       
  109. 6      22     TYPE             int
       
  110. 6      25     NEWLINE          \n
       
  111. 
       
  112. 7      9      KEYWORD          body
       
  113. 7      13     COLON            :
       
  114. 7      14     NEWLINE          \n
       
  115. 
       
  116. 8      12     KEYWORD          return
       
  117. 8      19     IDENTIFIER       n1
       
  118. 8      22     PLUS             +
       
  119. 8      24     IDENTIFIER       n2
       
  120. 8      26     NEWLINE          \n
       
  121. 
       
  122. 9      9      KEYWORD          end
       
  123. 9      13     KEYWORD          body
       
  124. 9      17     NEWLINE          \n
       
  125. 
       
  126. 10     5      KEYWORD          end
       
  127. 10     9      KEYWORD          function
       
  128. 10     17     NEWLINE          \n
       
  129. 
       
  130. 11     1      KEYWORD          end
       
  131. 11     5      KEYWORD          module
       
  132. 11     1      EOF        
       
  133. 
       
  134. ## 词法分析通过，没有发现错误
       
  135. 
       
  136. ## 语义分析通过，没有发现错误
       
  137. 
       
  138. ### AST
       
  139. [
       
  140.   {
       
  141.     "type": "Module",
       
  142.     "name": "Main",
       
  143.     "imports": [
       
  144.       {
       
  145.         "type": "Import",
       
  146.         "module": "Math"
       
  147.       }
       
  148.     ],
       
  149.     "functions": [
       
  150.       {
       
  151.         "type": "Function",
       
  152.         "name": "main",
       
  153.         "parameters": [
       
  154.          
       
  155.         ],
       
  156.         "returnType": "int",
       
  157.         "body": [
       
  158.           {
       
  159.             "type": "ExpressionStatement",
       
  160.             "expression": {
       
  161.               "type": "CallExpression",
       
  162.               "callee": {
       
  163.                 "type": "MemberExpression",
       
  164.                 "object": {
       
  165.                   "type": "Identifier",
       
  166.                   "name": "Math"
       
  167.                 },
       
  168.                 "member": "add"
       
  169.               },
       
  170.               "arguments": [
       
  171.                 {
       
  172.                   "type": "NumberLiteral",
       
  173.                   "value": "6"
       
  174.                 },
       
  175.                 {
       
  176.                   "type": "NumberLiteral",
       
  177.                   "value": "1"
       
  178.                 }
       
  179.               ]
       
  180.             }
       
  181.           },
       
  182.           {
       
  183.             "type": "Return",
       
  184.             "value": {
       
  185.               "type": "NumberLiteral",
       
  186.               "value": "0"
       
  187.             }
       
  188.           }
       
  189.         ]
       
  190.       }
       
  191.     ]
       
  192.   },
       
  193.   {
       
  194.     "type": "Module",
       
  195.     "name": "Math",
       
  196.     "imports": [
       
  197.       
       
  198.     ],
       
  199.     "functions": [
       
  200.       {
       
  201.         "type": "Function",
       
  202.         "name": "add",
       
  203.         "parameters": [
       
  204.           {
       
  205.             "name": "n1",
       
  206.             "type": "int"
       
  207.           },
       
  208.           {
       
  209.             "name": "n2",
       
  210.             "type": "int"
       
  211.           }
       
  212.         ],
       
  213.         "returnType": "int",
       
  214.         "body": [
       
  215.           {
       
  216.             "type": "Return",
       
  217.             "value": {
       
  218.               "type": "BinaryExpression",
       
  219.               "left": {
       
  220.                 "type": "Identifier",
       
  221.                 "name": "n1"
       
  222.               },
       
  223.               "operator": "+",
       
  224.               "right": {
       
  225.                 "type": "Identifier",
       
  226.                 "name": "n2"
       
  227.               }
       
  228.             }
       
  229.           }
       
  230.         ]
       
  231.       }
       
  232.     ]
       
  233.   }
       
  234. ]
       
  235. ### IR
       
  236. func main() {
       
  237.   %0 = CONST 6
       
  238.   %1 = CONST 1
       
  239.   %2 = CALL Math.add, %0, %1
       
  240.   %3 = CONST 0
       
  241.   RET %3
       
  242. }
       
  243. func add(%0, %1) {
       
  244.   %2 = ADD_I32 %0, %1
       
  245.   RET %2
       
  246. }
       
  247. 
       
  248. ### VM code
       
  249. 0000: I_PUSH     6
       
  250. 0001: I_STORE    0
       
  251. 0002: I_PUSH     1
       
  252. 0003: I_STORE    1
       
  253. 0004: I_LOAD     0
       
  254. 0005: I_LOAD     1
       
  255. 0006: CALL       13 2
       
  256. 0007: I_STORE    2
       
  257. 0008: I_PUSH     0
       
  258. 0009: I_STORE    3
       
  259. 0010: I_LOAD     3
       
  260. 0011: HALT      
       
  261. 0012: HALT      
       
  262. 0013: I_LOAD     0
       
  263. 0014: I_LOAD     1
       
  264. 0015: I_ADD      
       
  265. 0016: I_STORE    2
       
  266. 0017: I_LOAD     2
       
  267. 0018: RET        
       
  268. 0019: RET        
       
  269. Written to D:\Devs\IdeaProjects\Snow\target\Demo1.water
       
  270. 
       
  271. === Launching VM ===
       
  272. 
       
  273. Calling function at address: 13
       
  274. 
       
  275. Return 7
       
  276. 
       
  277. Process has ended
       
  278. 
       
  279. Operand Stack state:[0]
       
  280. 
       
  281. --- Call Stack State ---
       
  282. 
       
  283. ### VM Local Variable Table:
       
  284. 0: 6
       
  285. 1: 1
       
  286. 2: 7
       
  287. 3: 0
       
  288. 
       
  289. === VM exited ===

  复制代码
  
  
  

编译 Snow 源代码1. 独立编译 (Standalone Compilation)

独立编译不依赖 .cloud 文件，而是直接使用 Snow 编译器进行 .snow 文件的编译和执行。

独立编译步骤:

• 运行编译器: 你可以通过以下命令来编译单个或多个 .snow 文件，或者递归编译一个目录中的所有 .snow 源文件为.water虚拟机指令。
  
  
  • 单个文件编译:
    Snow complete [SnowCode].snow
  • 多个文件编译:
    Snow complete [SnowCode1].snow [SnowCode2].snow [SnowCode3].snow -o [Name]
  • 目录递归编译:
    Snow -d path/to/source_dir
    
• 查看编译输出: 编译过程会输出源代码、抽象语法树（AST）、中间表示（IR）以及虚拟机指令等内容。你可以看到如下几个分段输出:
  
  
  • AST（抽象语法树）部分以 JSON 格式输出。
  • IR（中间表示）部分会列出逐行的中间代码。
  • VM code（虚拟机指令）会展示虚拟机的字节码指令。
    
• 默认执行模式: 编译器会在 RUN 模式 下运行，DEBUG 模式显示详细的执行过程和状态，并且在虚拟机中执行编译后的代码，最后会打印出所有局部变量的值。
  
  

---

2. 集成编译 (Integrated Compilation)

集成编译需要使用 .cloud 文件来指定项目的配置和结构，适用于项目标准化、依赖管理、构建管理和项目分发等场景。

集成编译命令:

• 基本用法:
    snow [OPTIONS] <command>
• 命令选项:
  
  
  • -h, --help: 显示帮助信息并退出。
  • -v, --version: 打印 Snow 编程语言的版本并退出。
    
• 可用命令:
  
  
  • compile: 将 .snow 源文件编译成虚拟机字节码文件（.water）。此命令会使用 .cloud 文件来指导编译过程。
  • clean: 清理构建输出和本地缓存，移除中间产物，释放磁盘空间。
  • version: 打印 Snow 的版本。
  • run: 运行已编译的虚拟机字节码文件（.water）。
  • init: 初始化一个新项目，生成 project.cloud 文件。
  • generate: 根据 project.cloud 生成项目目录结构。
  • build: 构建当前项目，按顺序解析依赖、编译和打包。
    
• 例如，执行集成编译命令:
  snow compile [SnowCode].snow
  
  • 此命令会使用 .cloud 文件中的配置信息来指导编译过程，并生成 .water。
    
• 使用帮助: 如果你需要了解某个命令的详细选项，可以使用:
  snow <command> --help
  
  
  例如，查看 compile 命令的具体选项:
  snow compile --help
  

---

示例代码片段

以下是一个简单的 Snow 代码示例,演示模块定义,导入和函数声明的基本语法:

1. module: Math
   
2.     function: main
   
3.         returns: int
   
4.         body:
   
5.             Math.factorial(6)
   
6.             return 0
   
7.         end body
   
8.     end function
   
9. 
   
10.     function: factorial
    
11.         params:
    
12.             declare n:int
    
13.         returns: int
    
14.         body:
    
15.             declare num1:int = 1
    
16.             loop:
    
17.                 init:
    
18.                     declare counter:int = 1
    
19.                 cond:
    
20.                     counter <= n
    
21.                 step:
    
22.                     counter = counter + 1
    
23.                 body:
    
24.                     num1 = num1 * counter
    
25.                 end body
    
26.             end loop
    
27.             return num1
    
28.         end body
    
29.     end function
    
30. end module

复制代码

上述代码定义了一个名为 Math 的模块，其中包含两个函数:

• main: 不接收任何参数，返回类型为 int。在函数体内调用了 Math.factorial(6)，然后返回 0。
• factorial: 接收一个 int 类型的参数 n，返回类型为 int。函数体内先声明并初始化局部变量 num1 为 1，然后通过一个 loop 循环（从 counter = 1 到 counter <= n）依次将 num1 乘以 counter，循环结束后返回 num1，即 n 的阶乘值。
  

更多示例代码见 playground 目录

项目结构说明

• compiler/: Snow 编译器源代码目录
  
  
  • lexer/: 词法分析模块，负责将源码切分为 Token
  • parser/: 语法分析模块，将 Token 流解析为 AST（含模块/函数/语句解析）
  • semantic/: 语义分析模块，负责符号表管理、类型检查等
  • ir/: 中间表示（IR）模块，生成并管理三地址码形式的中间代码
  • backend/: 编译器后端模块，将 IR 翻译为虚拟机指令，包含寄存器分配和指令生成器
    
• vm/: 虚拟机相关源代码目录
  
  
  • commands/: 定义 SnowVM 指令集的具体实现
  • engine/: 核心执行引擎，提供指令执行和寄存器/栈管理
  • execution/: 执行流程控制（按指令顺序执行、分支跳转等）
  • io/: 输入输出辅助类（加载指令、文件解析等）
  • gui/: Swing 可视化调试面板，实时展示局部变量表
  • factories/、utils/: 指令创建、日志调试等公共工具
    
• pkg/: 内置构建与包管理器 snow pkg
  
  
  • dsl/: .cloud 描述文件解析器
  • tasks/: 预设任务实现（clean · compile · run · package · publish 等）
  • resolver/: 本地/远程仓库解析与缓存
  • lifecycle/: 任务生命周期钩子（pre/post 脚本等）
  • model/: 项目、依赖、版本等模型
  • utils/: 文件、日志、校验和等通用工具
  • doc/: 开发者文档与示例 .cloud 配置
    
• cli/: 独立的命令行前端
  
  
  • commands/: compile / run / pkg 等子命令实现
  • api/: 公共选项解析、终端交互抽象
  • utils/: 终端颜色、进度条、异常格式化等
  • SnowCLI.java: CLI 主入口
    
  
  

链接: https://pan.baidu.com/s/182ooWVwRHFRbUcA-iX3iHw
提取码下载：

文件名称:提取码下载.txt 
下载次数:0  文件大小:16 Bytes  售价:199金钱 [记录]
下载权限: 不限 [购买VIP]   [充值]   [在线充值]   【VIP会员6折；永久VIP4折】

安全检测，请放心下载