• Home
  • Categories
  • WIKI
  • LANGUAGE: en
    • 正在开发一门简单的脚本语言
    Experiences and Insight 1312 views · 11 replies ·
    Tofloor
    poster avatar
    ldmpscript
    deepin
    2012-12-06 17:52
    Author
    这个脚本很简单，不需要模拟CPU。
    最终状态的是可以通过远程传输脚本TEST.LDMP. [主要是为了解决WEBKIT与GTK互通的麻烦.现在又需要一个轻量的,可定制的东西]
    然后我写的客户端,
    词法分析,语法分析脚本,语义分析,
    最后进行渲染,
    现在的元素比较少,
    只有entry, button, line, vbox, hbox.
    本地也可以编写脚本,然后F5可以刷新脚本渲染界面.
    语法分析,语义分析, 远程的正在编写中.

    大家感觉这种脚本对于 小型的渲染是不是很方便. 远程只要更新一下, 客户端刷新一下就显示出来.
    比如: 只想简单的显示一些东西.

    比如:
    像这样的东西,你就想简单的搜索一下,然后显示出你想要的列表东西.
    选区_009.png
    选区_010.png
    选区_011.png
    最终的效果是这样.简单的编写脚本,就可以进行渲染,远程修改一下,就可以显示出来,是轻量的.快速的.
    QQ截图20121206100736.png

    会自动生成一棵 控件树. 用来表示 包含关系或父子关系.
    3. '版本号
    4. ' '事件集合
    6.    
    7.         
    8.          
    9.          
    10.         
    11.                
    13. ' 这是以后的设想!!现在未了满足需求,只能将事件暂时固定起来.
    14. ' import event
    15. ' btn1.connect("clicked", event.btn1_clicked)
    Copy the Code

    我定义的东西.
    2. '''
    3. ----------------------
    4. 运算符 |  ID  | 单词
    5.          10     =
    6. ----------------------     
    7. 界符号 |  ID  | 单词
    8.          05     <
    9.          06     >
    10.          07     /
    11. ----------------------
    12. 关键字 |  ID  |   单词
    13.          30    version
    14.          31    ldmp
    15.          32    name
    16.          33    value
    17.          34    event
    18.          35    callback
    19.          36    vbox
    20.          37    hbox         
    21.          38    entry
    22. ----------------------
    23.          
    24. '''
    25. 用于词法分析.
    Copy the Code
    语法就几条.
    <....>

    基于表格驱动的词法分析算法。
    用PYTHON。
    2. # /* 用于搜索关键字. */
    3. keyword_dict = {'a':[],
    4.            'b':["button"],
    5.            'c':["callback"],
    6.            'd':[],
    7.            'e':["event"],
    8.            'f':[],
    9.            'g':[],
    10.            'h':["hbox"],
    11.            'i':[],
    12.            'j':[],
    13.            'k':[],
    14.            'l':["ldmp"],
    15.            'm':[],
    16.            'n':["name"],
    17.            'o':[],
    18.            'p':[],
    19.            'q':[],
    20.            'r':[],
    21.            's':[],
    22.            't':[],
    23.            'u':[],
    24.            'v':["vbox", "value", "version"],
    25.            'w':[],
    26.            'x':[],
    27.            'y':[],
    28.            'z':[]
    29.            }
    31. '''
    32. 标识符    ID 03
    33. 字符串常量 ID 02
    34. ----------------------
    35. 运算符 |  ID  | 单词
    36.          10     =
    37. ----------------------     
    38. 界符号 |  ID  | 单词
    39.          05     <
    40.          06     >
    41.          07     /
    42. ----------------------
    43. 关键字 |  ID  |   单词
    44.          30    version
    45.          31    ldmp
    46.          32    name
    47.          33    value
    48.          34    event
    49.          35    callback
    50.          36    vbox
    51.          37    hbox      
    52.          38    entry
    53.          39    button
    54. ----------------------
    55. '''
    57. '''(回车,空格)----------
    58.              |--------
    59.              |--------
    60.              |--------
    61.              |--------
    62.    标识符(字母)|---字母,数字循环---(05)---其它---((-03)) # 最后会查询关键字表，看是否为关键字.
    63.             <|--------(06)---全部---((-05))
    64.             >|--------(07)---全部---((-06))
    65.             /|--------(08)---全部---((-07))
    66.             "|--------(09)--- " ---((-02))
    67.                           |--回车---((-100))
    68.             '|--------(10)---回车---((-40))
    69. '''   
    70. lex_table = []
    72. def init_lex_table():        
    73.     # init lex_table.
    74.     for i in range(0, 11):
    75.         lex_table.append([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    76.                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    77.                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    78.                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])        
    79.     # create lex table.   
    80.     for i in range(0, 129): # 0-127, 128(其它:比如[中文])
    81.         lex_table[0][i]   = -100   # 出错状态.
    82.         lex_table[0][ord("<")] = -5
    83.         lex_table[0][ord(">")] = -6
    84.         lex_table[0][ord('/')] = -7
    85.         lex_table[0][ord('=')] = -10
    86.         lex_table[0][ord("'")] = 10
    87.         lex_table[0][ord('"')] = 9
    88.         if (ord('a') <= i <= ord('z')) or (ord('A') <= i <= ord('Z')):
    89.             lex_table[0][i] = 5
    90.         # 标识符.
    91.         if (ord('a') <= i <= ord('z')) or (ord('A') <= i <= ord('Z')) or (ord('0') <= i <= ord('9')):
    92.             lex_table[5][i] = 5
    93.         else:   
    94.             lex_table[5][i] = -3
    95.         # 界符号.
    96.         lex_table[6][i] = -5
    97.         lex_table[7][i] = -6
    98.         lex_table[8][i] = -7  
    99.         # 字符串.
    100.         lex_table[9][i]         = 9      # 其它,中文,除了回车..->>跳转
    101.         lex_table[9][ord('"')]  = -2     # 字符串.
    102.         lex_table[9][ord('\n')] = -100   # 字符串没有"结尾--->出错状态.
    103.         # 注释.
    104.         lex_table[10][i]         = 10     # 注释跳转.
    105.         lex_table[10][ord('\n')] = -40    # 注释.
    106.         
    107. if __name__ == "__main__":
    108.     init_lex_table()
    109.     # import random
    110.     text = 'abcd123="我来看看看吧fjsdklfsdjkf"abc\n'.decode("utf-8")
    111.     row = 0
    112.     text_index = 0
    113.     index = ord(text[0])
    114.     token = ""
    115.     while text_index < len(text):
    116.        if text[text_index] != " " and text[text_index] != "\n":
    117.         if ord(text[text_index]) < 128:
    118.             index = ord(text[text_index])
    119.         else:   
    120.             index = 128
    121.         # print "index:", index
    122.         row = lex_table[row][index]        
    123.         # print "row:", row
    124.         token += text[text_index]
    125.         if row < 0:
    126.             if row == -40:
    127.                 print "[注释]", token, "(id:", -row
    128.             elif row == -2:   
    129.                 print "[字符串]", token, "(id:", -row
    130.             elif row == -100:
    131.                 print "[错误]-->>", token, "行号:", 0
    132.             elif row == -5:   
    133.                 print "[界符号]", token, "(id:", -row
    134.             elif row == -6:   
    135.                 print "[界符号]", token, "(id:", -row
    136.             elif row == -7:   
    137.                 print "[界符号]", token, "(id:", -row
    138.             elif row == -3:   # 超前搜索一个，所以必须回退一位.
    139.                 print "[标识符]", token[:-1], "(id:", -row  # 进行查询关键字就知道了，不是关键字就是标识符了.
    140.                 text_index -=1
    141.             elif row == -10:   
    142.                 print "[运算符]", token, "(id:", -row
    143.             row = 0
    144.             token = ""            
    145.        text_index += 1
    Copy the Code
    因为以前做过一个 智能小车模拟软件.
    一个用于显示小车运作的动画.
    一个用于编写智能小车代码的环境.
    然后运行,小车运作动画的前端解释脚本,然后自己运行起来,有红灯,绿灯,转弯,遇到障碍自己转.
    没办法,看见软件班的同学玩的很过瘾,只能听他们说,心里不爽啊` 所以自己就开发一个模拟软件,来模拟小车运动,来感受一下编写代码让小车运动起来的快感.
    编写代码,编译过后生成脚本,然后动画前端读取脚本的指令,足条解释,如果没有遇到跳转指令的话,没事.
    Reply Favorite View the author
    All Replies
    左心房的痛
    deepin
    2012-12-06 18:32
    #1
    脚本语言？？网页的？？那浏览器得支持才行啊，你要修改webkit?
    Reply View the author
    ldmpscript
    deepin
    2012-12-06 19:03
    #2
    脚本语言？？网页的？？那浏览器得支持才行啊，你要修改webkit?

    没有，WEBKIT 那么庞大，我没有能力去修改。   ops:  :  

    我现在只是写一个简单的脚本而已。

    没什么技术含量。主要为了解决WEBKIT和GTK 交互问题。
    比如 在WEBKIT在单击或者双击了，又或者移动了鼠标了，GTK该如何知道，这个一个非常麻烦的时候。
    反正我现在需要的东西也不多，所以就这样吧，满足需求，简单的写一个，。 :  :  :
    Reply View the author
    cxbii
    deepin
    2012-12-06 19:36
    #3
    妈呀……牛人辈出
    Reply View the author
    ldmpscript
    deepin
    2012-12-06 22:59
    #4
    妈呀……牛人辈出
    这个是简单的东西，没有你想的那么牛B，
    Reply View the author
    cxbii
    deepin
    2012-12-06 23:12
    #5
    [quote]妈呀……牛人辈出
    这个是简单的东西，没有你想的那么牛B，[/quote]没事，总比我厉害啦
    Reply View the author
    pdlenovo
    deepin
    2012-12-06 23:33
    #6
    妈呀……牛人辈出
    是啊 真的很牛
    Reply View the author
    ldmpscript
    deepin
    2012-12-06 23:40
    #7
    [quote]妈呀……牛人辈出
    是啊 真的很牛[/quote]

    没有你写操作系统 牛，
    我就一个水B，
    这个东西很简单的，哎，你们都唔会了。连你这样写操作系统牛人都这样说，让我无地自容了。
    Reply View the author
    vala2012
    deepin
    2012-12-07 00:29
    #8
    保存的单词流信息:
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 0
    id: 1 token: version row: 0
    id: 10 token: = type: TOKEN_TYPE_OPERATOR row: 0
    id: 2 token: 0.1 type: TOKEN_TYPE_STRING row: 0
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 0
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 0
    id: 7 token: / type: TOKEN_TYPE_SCOPE_SYMBOL row: 0
    id: 1 token: version row: 0
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 0
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 2
    id: 1 token: ldmp row: 2
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 2
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 3
    id: 1 token: vbox row: 3
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 3
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 4
    id: 1 token: vbox row: 4
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 4
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 5
    id: 1 token: button row: 5
    id: 1 token: name row: 5
    id: 10 token: = type: TOKEN_TYPE_OPERATOR row: 5
    id: 2 token: btn1 type: TOKEN_TYPE_STRING row: 5
    id: 1 token: value row: 5
    id: 10 token: = type: TOKEN_TYPE_OPERATOR row: 5
    id: 2 token: 确定 type: TOKEN_TYPE_STRING row: 5
    id: 1 token: event row: 5
    id: 10 token: = type: TOKEN_TYPE_OPERATOR row: 5
    id: 2 token: clicked type: TOKEN_TYPE_STRING row: 5
    id: 1 token: callback row: 5
    id: 10 token: = type: TOKEN_TYPE_OPERATOR row: 5
    id: 2 token: btn1_clicked type: TOKEN_TYPE_STRING row: 5
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 5
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 5
    id: 7 token: / type: TOKEN_TYPE_SCOPE_SYMBOL row: 5
    id: 1 token: button row: 5
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 5
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 6
    id: 1 token: name row: 6
    id: 10 token: = type: TOKEN_TYPE_OPERATOR row: 6
    id: 2 token: text1 type: TOKEN_TYPE_STRING row: 6
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 6
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 6
    id: 7 token: / type: TOKEN_TYPE_SCOPE_SYMBOL row: 6
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 6
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 7
    id: 7 token: / type: TOKEN_TYPE_SCOPE_SYMBOL row: 7
    id: 1 token: vbox row: 7
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 7
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 8
    id: 7 token: / type: TOKEN_TYPE_SCOPE_SYMBOL row: 8
    id: 1 token: vbox row: 8
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 8
    id: 5 token: < type: TOKEN_TYPE_SCOPE_SYMBOL row: 9
    id: 7 token: / type: TOKEN_TYPE_SCOPE_SYMBOL row: 9
    id: 1 token: ldmp row: 9
    id: 6 token: > type: TOKEN_TYPE_SCOPE_SYMBOL row: 9
    Reply View the author
    pdlenovo
    deepin
    2012-12-07 00:49
    #9
    [quote][quote]妈呀……牛人辈出
    是啊 真的很牛[/quote]

    没有你写操作系统 牛，
    我就一个水B，
    这个东西很简单的，哎，你们都唔会了。连你这样写操作系统牛人都这样说，让我无地自容了。[/quote]
    其实我们只是专注的方向不同而已，要我来干这个，我肯定干不了，我曾经想为我的操作系统写个C编译器，
    后来我却胆怯了，呵呵
    Reply View the author
    ldmpscript
    deepin
    2012-12-07 02:00
    #10
    [quote]是啊 真的很牛

    没有你写操作系统 牛，
    我就一个水B，
    这个东西很简单的，哎，你们都唔会了。连你这样写操作系统牛人都这样说，让我无地自容了。[/quote]
    其实我们只是专注的方向不同而已，要我来干这个，我肯定干不了，我曾经想为我的操作系统写个C编译器，
    后来我却胆怯了，呵呵[/quote]
    我的能力也不足与开发一个编译器，做人是有量度的，知道自己有几斤几两。 :
    Reply View the author
    ldmpscript
    deepin
    2012-12-08 00:00
    #11
    其实我们只是专注的方向不同而已，要我来干这个，我肯定干不了，我曾经想为我的操作系统写个C编译器，
    后来我却胆怯了，呵呵

    好吧，牛人，
    给你看个例子，就知道词法分析多么简答了，不需要什么高深的 确定性/非确定自动机理论。
    我已经很详细的描述了。
    2. #! /usr/bin/env python
    3. # -*- coding: utf-8 -*-
    5. # /* 用于搜索关键字. */
    6. keyword_dict = {'a':[],
    7.            'b':["button"],
    8.            'c':["callback"],
    9.            'd':[],
    10.            'e':["event"],
    11.            'f':[],
    12.            'g':[],
    13.            'h':["hbox"],
    14.            'i':[],
    15.            'j':[],
    16.            'k':[],
    17.            'l':["ldmp"],
    18.            'm':[],
    19.            'n':["name"],
    20.            'o':[],
    21.            'p':[],
    22.            'q':[],
    23.            'r':[],
    24.            's':[],
    25.            't':[],
    26.            'u':[],
    27.            'v':["vbox", "value", "version"],
    28.            'w':[],
    29.            'x':[],
    30.            'y':[],
    31.            'z':[]
    32.            }
    34. '''
    35. 标识符    ID 03
    36. 字符串常量 ID 02
    37. ----------------------
    38. 运算符 |  ID  | 单词
    39.          10     =
    40. ----------------------     
    41. 界符号 |  ID  | 单词
    42.          05     <
    43.          06     >
    44.          07     /
    45. ----------------------
    46. 关键字 |  ID  |   单词
    47.          30    version
    48.          31    ldmp
    49.          32    name
    50.          33    value
    51.          34    event
    52.          35    callback
    53.          36    vbox
    54.          37    hbox      
    55.          38    entry
    56.          39    button
    57. ----------------------
    58. '''
    60. '''(回车,空格)----------
    61.              |--------
    62.              |--------
    63.              |--------
    64.              |--------
    65.    标识符(字母)|---字母,数字循环---(05)---其它---((-03)) # 最后会查询关键字表，看是否为关键字.
    66.             <|--------(06)---全部---((-05))
    67.             >|--------(07)---全部---((-06))
    68.             /|--------(08)---全部---((-07))
    69.             "|--------(09)--- " ---(11) -- 全部 --((-02))
    70.                           |--回车---((-100))
    71.             '|--------(10)---回车---((-40))
    72. '''   
    73. lex_table = []
    75. def init_lex_table():        
    76.     # init lex_table.
    77.     for i in range(0, 12):
    78.         lex_table.append([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    79.                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    80.                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    81.                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])        
    82.     # create lex table.   
    83.     for i in range(0, 129): # 0-127, 128(其它:比如[中文])
    84.         lex_table[0][i]   = 0   # 出错状态.
    85.         lex_table[0][ord("<")] = 6
    86.         lex_table[0][ord(">")] = 7
    87.         lex_table[0][ord('/')] = 8
    88.         lex_table[0][ord('=')] = 4
    89.         lex_table[0][ord("'")] = 10
    90.         lex_table[0][ord('"')] = 9
    91.         if (ord('a') <= i <= ord('z')) or (ord('A') <= i <= ord('Z')):
    92.             lex_table[0][i] = 5
    93.         # 标识符.
    94.         if (ord('a') <= i <= ord('z')) or (ord('A') <= i <= ord('Z')) or (ord('0') <= i <= ord('9')):
    95.             lex_table[5][i] = 5
    96.         else:   
    97.             lex_table[5][i] = -3
    98.         # 运算符.   
    99.         lex_table[4][i] = -10
    100.         # 界符号.
    101.         lex_table[6][i] = -5
    102.         lex_table[7][i] = -6
    103.         lex_table[8][i] = -7  
    104.         # 字符串.
    105.         lex_table[9][i]         = 9      # 其它,中文,除了回车..->>跳转
    106.         lex_table[11][i]        = -2
    107.         lex_table[9][ord('"')]  = 11    # 字符串.
    108.         lex_table[9][ord('\n')] = -100   # 字符串没有"结尾--->出错状态.
    109.         # 注释.
    110.         lex_table[10][i]         = 10     # 注释跳转.
    111.         lex_table[10][ord('\n')] = -40    # 注释.
    112.         
    114. if __name__ == "__main__":
    115.     init_lex_table()
    116.     # import random
    117.     text = '"我来   看看看吧fjsdklfsdjkf"\n'.decode("utf-8")
    118.     row = 0
    119.     text_index = 0
    120.     token = ""
    121.     while text_index < len(text):        
    122.         
    123.         if ord(text[text_index]) < 128:
    124.             index = ord(text[text_index]) # <
    125.         else:   
    126.             index = 128
    127.             
    128.         row = lex_table[row][index]
    129.         token += text[text_index]
    130.         
    131.         if row < 0:
    132.             text_index -= 1# 超前搜索一个，所以必须回退一位.
    133.             if row == -40:
    134.                 print "[注释]", token[:-1], "(id:", -row
    135.             elif row == -2:   
    136.                 print "[字符串]", token[:-1], "(id:", -row
    137.             elif row == -100:
    138.                 print "[错误]-->>", token[:-1], "行号:", 0
    139.                 break
    140.             elif row == -5:   
    141.                 print "[界符号]", token[:-1], "(id:", -row
    142.             elif row == -6:   
    143.                 print "[界符号]", token[:-1], "(id:", -row
    144.             elif row == -7:   
    145.                 print "[界符号]", token[:-1], "(id:", -row               
    146.             elif row == -3:   
    147.                 print "[标识符]", token[:-1], "(id:", -row                           
    148.             elif row == -10:   
    149.                 print "[运算符]", token[:-1], "(id:", -row
    150.             row = 0
    151.             token = ""            
    152.             
    153.       
    154.         text_index += 1
    Copy the Code

    将这些单词流保存到TOKENINFO中去.
    /*
    class TokenInfo(object):
        def __init__(self):
            self.id   = None
            self.type = None # token type.
            self.row  = None # token row.
            
    class Stack(object):
        '''
        LL(1) 语法分析.
        '''
        def __init__(self):
            self.save_values = []
       
        def pop(self):
            value = self.save_values.pop()
            return value
       
        def push(self, value):
            self.save_values.append(value)   

    */
    他们已经不再是单词了,是TOKEN,是终结符,他们已经是不可再分割的拉.
    等我写玩语法分析，我再给你看。
    手动构造FIRST FLLOW集也非常简单，只要在纸上画画。没有什么语法错误就OK了，不需要程序写出来。
    LL（1），这种是基于栈的，也比较号理解。
    LL(1) 就是通过终结符和非终结符来确定另一个产生式的.
            self.parsing_table = [] # 语法分析表.
            self.product_list = [] # 产生式表.
    Reply View the author