首页 > 代码库 > 基于PLY的STL文件基本信息统计方法

基于PLY的STL文件基本信息统计方法

2024-07-02 20:16:58   225人阅读

1、摘要

　　STL文件是快速成型设备中常用的文件格式，随着3D打印技术的发展，STL格式文件的应用日益广泛。Python语言具有丰富和强大的类库，其语言简洁而清晰，因而Python语言越来越受欢迎。PLY是具名的LEX、YACC的Python版本，本文介绍了利用PLY模块对STL文件进行基本信息统计。

KeyWord：PLY、语法分析、词法分析、STL

2、简介

　　计算机语言是计算机软件的系统的基础，经过几十年的发展，实现了从低级语言到高级语言的转变。原始的机器语言，到低级的汇编语言，它们虽然可以运行，但是也存在很多问题，比如在程序移植的过程中，往往会出现不兼容的情况。高级语言的出现，使得计算机程序设计语言不再过度地依赖特定的机器或环境，从高级语言翻译成机器可执行的语言就显得相当重要。构造一个高级语言编译器，需要构造相应的此法及语法分析器，PLY模块可以帮助我们实现词法及语法的分析。

2.1 PLY简介

　　PLY是LEX与YACC的Python版，包含了LEX与YACC的大部分特性。PLY模块包含两个独立的模块：lex.py和yacc.py。lex.py模块用来将输入字符通过一系列的正则表达式分解成标记序列，yacc.py通过一些上下文无关的文法来识别编程语言语法。yacc.py使用LR解析法，并使用LALR(1)算法（默认）或者SLR算法生成分析表。

2.1.1 PLY.LEX基本原理与实践

Lex.py用来将输入字符串标记化。首先，将字符串分割成独立的标记(token)，这些token由不同的名称表示，然后将名称和值组合起来形成一个二元组。例如：

　　tokens = (

　　    ‘NAME‘,‘NUMBER‘,

　　    )

　　

　　literals = [‘=‘,‘+‘,‘-‘,‘*‘,‘/‘, ‘(‘,‘)‘]

　　

　　# Tokens

　　

　　t_NAME    = r‘[a-zA-Z_][a-zA-Z0-9_]*‘        #词法描述规则1

　　

　　def t_NUMBER(t):                                        #词法描述规则2

　　    r‘\d+‘

　　    t.value = http://www.mamicode.com/int(t.value)

　　    return t

　　

　　t_ignore = " \t"

　　

　　def t_newline(t):

　　    r‘\n+‘

　　    t.lexer.lineno += t.value.count("\n")

　　   

　　def t_error(t):                                                  #出错处理

　　    print("Illegal character ‘%s‘" % t.value[0])

　　    t.lexer.skip(1)

　　   

　　# Build the lexer

　　import ply.lex as lex

　　lex.lex()

　　其中tokens是强制词法单元类型列表的名称，强制描述词法规则的变量名格式为t_[TOKENNAME],在此例中有两种类型：NUMBER和NAME。NUMBER定义为\d+，匹配整数，NAME定义为a-zA-Z_][a-zA-Z0-9_]，匹配一般标识符。词法描述规则中，规则1不能自定义操作，规则2可以自定义操作，规则2中的参数列表必须为单个参数，并且只能返回t，若不返回则表示丢弃该token。最后调用lex()即可完成词法分析。

2.1.2 PLY.yacc 基本原理与实践

　　YACC用于对语言进行语法分析。语法通常用BNF范式表达，用的分析技术是LALR分析法，LALR分析法是LR分析法的一种改进分析法。LR(K)分析，是指从左至右扫描和自底向上的语法分析，且在分析的每一步，只须根据分析栈当前已移进和归约出的全部文法符号，并至多再向前查看K个输入符号，就能确定相对于某一产生式左部符号的句柄是否已在分析栈的顶部形成，从而也就可以确定当前所应采取的分析动作 (是移进还是按某一产生式进行归约等)。例如：

简单算术表达式文法：

E    : E + T

      | E - T

     | T

T  : T * F

      | T / F

      | F

F  : N

      | ( E )

　　每个文法规则被描述为一个函数，这个函数的文档字符串描述了对应的上下文无关文法的规则。函数体用来实现规则的语义动作。每个函数都会接受一个参数p，这个参数是一个序列（sequence），包含了组成这个规则的所有的语法符号，p[i]是规则中的第i个语法符号。比如：

 

语法说明中的第一个为起始规则，也可以通过关键字参数传递给yacc以指定起始文法规则：

yacc.yacc(start = ‘rule_name‘) 

2.2 STL文件简介

       STL文件是在计算机图形应用系统中，用于表示三角形网格的一种文件格式。STL文件凭借其简单的格式，在许多领域得到应用，特别是在快速成型系统中的应用。STL文件有两种：一种为ASCII格式，另一种为二进制格式。在这里只介绍ASCII格式的STL文件。

       STL的文件结构如下：

              solid filename                                    //文件名

                    facet normal x y z                       //三角形法矢量

                         outer loop                           

                               vertex x y z                  //第一个点

                               vertex x y z                  //第二个点

                               vertex x y z                  //第三个点

                         endloop

                    endfacet

                     ……..

              endsolid filename

3、词法分析

分析STL文件的文件结构，将词法单元类型分成5类：KEYWORD、RPARAM、LPARAM、NAME、NUMBER。词法采用正则表达式描述，详细定义分别如下：

KEYWORD：normal | outer | vertex

RPARAM：solid | facet | loop

LPARAM：endsolid | endfacet | endloop

NAME：[a-zA-Z_][a-zA-Z0-9_]*

NUMBER：(-?\d+)(\.\d+)?(e-?\d+)?

词法分析结果如下：

LexToken(RPARAM,‘solid‘,1,0)

LexToken(NAME,‘OBJECT‘,1,6)

LexToken(RPARAM,‘facet‘,2,15)

LexToken(KEYWORD,‘normal‘,2,21)

LexToken(NUMBER,-0.0,2,28)

LexToken(NUMBER,-1.0,2,31)

LexToken(NUMBER,0.0,2,34)

LexToken(KEYWORD,‘outer‘,3,40)

LexToken(RPARAM,‘loop‘,3,46)

LexToken(KEYWORD,‘vertex‘,4,57)

LexToken(NUMBER,-24.721731185913086,4,64)

LexToken(NUMBER,-6.938085079193115,4,84)

LexToken(NUMBER,0.0,4,104)

LexToken(KEYWORD,‘vertex‘,5,112)

LexToken(NUMBER,-21.674671173095703,5,119)

LexToken(NUMBER,-6.938085079193115,5,139)

……..

              从词法分析结果中可以看出，扫描字符串的过程是从左至右依次进行。词法分析代码参见附录B

4、语法分析

STL文件格式比较简单，其文法也相应比较简单。采用BNF范式描述STL文件的文件结构：

Rule 0     S‘ -> start

Rule 1     start -> RPARAM NAME facet LPARAM NAME

Rule 2     facet -> facet facet

Rule 3     facet -> RPARAM norm out LPARAM

Rule 4     norm -> KEYWORD NUMBER NUMBER NUMBER

Rule 5     out -> KEYWORD lp

Rule 6     lp -> RPARAM vertex LPARAM

Rule 7     vertex -> point point point

Rule 8     point -> KEYWORD NUMBER NUMBER NUMBER

在采用LALR分析法时，出现移近规约冲突：

    (2) facet -> facet facet .

    (2) facet -> facet . facet

    (2) facet -> . facet facet

    (3) facet -> . RPARAM norm out LPARAM

 

  ! shift/reduce conflict for RPARAM resolved as shift

    LPARAM          reduce using rule 2 (facet -> facet facet .)

    RPARAM          shift and go to state 4

 

  ! RPARAM          [ reduce using rule 2 (facet -> facet facet .) ]

 

    facet                          shift and go to state 9

默认采用移进解决这种移进规约冲突。

具体实现参见附录B

语法分析结果如下;

norm  : KEYWORD NUMBER NUMBER NUMBER

point : KEYWORD NUMBER NUMBER NUMBER

point : KEYWORD NUMBER NUMBER NUMBER

point : KEYWORD NUMBER NUMBER NUMBER

vertex : point point point

lp : RPARAM vertex LPARAM

out : KEYWORD lp

facet : RPARAM norm out LPARAM

…….

facet : facet facet

facet : facet facet

facet : facet facet

…..

start : RPARAM NAME facet LPARAM NAME

　　从分析结果中可以看出语法分析中各规则归约顺序：首先是Rule 4，接着是3个Rule 8，然后Rule 7-> Rule 6-> Rule 5,跟着是Rule 3。如此分析完成一个三角形块。所有块分析完成后，应用Rule 2，最终应用Rule 1完成整个文件的分析。具体分析表参见附录C，分析过程参见附录D

5、信息统计

　　在这里我们统计网格中的三角形个数和三角形的顶点数以及网格的表面积，虽然三角形顶点数可由三角形个数乘3得到，但是这里提供了语法分析时统计的手段。在每次对Rule 8进行规约时，顶点数加1，同时保存顶点用于表面积的计算；对Rule 3进行规约时，三角形个数加1，同时计算出三角形的面积，并对三角形面积进行累加。

由三角形的三个顶点A(x0,y0,z0),B(x1,y1,z1),C(x2,y2,z2)计算三角形的面积Ｓ。首先计算出三条边的长度：

 

 

令，由海伦公式可得：

 

 

6、测试及分析

       用计算机图形系统软件绘制一些三维文件，然后导出ASCII的STL格式文件作为测试用例。测试结果如下：

Cube.stl

---------------------------------------------------------------------------------------

object informatioin:

       vertex: 84       facet: 28  surface area: 146.5441114077912

---------------------------------------------------------------------------------------

cy.stl

---------------------------------------------------------------------------------------

object informatioin:

       vertex: 4740   facet: 1580     surface area: 1841.906043447056

---------------------------------------------------------------------------------------

shouji.stl

---------------------------------------------------------------------------------------

object informatioin:

       vertex: 34542  facet: 11514    surface area: 1971.3863130454672

---------------------------------------------------------------------------------------

       这三个测试用例都通过了测试。第一个、及第二个测试用例，内容较少，用于分析统计的时间可以忽略不计。第三个测试用例的容量较大，运行时有少许延时，若通过编译转换成C语言代码运行，可改善延时问题。

7、参考文献：

[1] 姚泽勤, 柏又青. 利用 LEX 及 YACC 实现嵌入式 SQL 分析器[J]. 航空计算技术, 2002, 32(1): 55-58.

[2] 肖任贤、张军舰、冯浩、潘海鹏, STL文件读取显示与操作, 陶瓷学报.2011(2)

[3]  Lesk M E, Schmidt E. lex: A lexical analyzer generator[M]. Bell Laboratories, 1987.

[4]  Johnson S C. Yacc: Yet another compiler-compiler[M]. Murray Hill, NJ: Bell Laboratories, 1975.

[5]  Beazley D M. Ply, python lex-yacc (2001)[J]. UR L http://www. dabeaz. com/ply.

[6]  Amiguet M. Teaching compilers with python[J]. 2010.

8、附录：（代码）

8.1 附录A——stlcount.py

 1 #-------------------------------------------------------------
 2 #stlcount.py
 3 #
 4 # STL文件信息统计
 5 #-------------------------------------------------------------
 6 import math
 7 
 8 #小三角片数
 9 c_facet=0
10 
11 #表面积
12 s_all=0
13 
14 #点数
15 c_vertex=0
16 
17 
18 #保存三个点
19 v_points=[]
20 
21 b_print_yacc=False
22 b_print_lex=False
23 
24 #初始化
25 def init_countstl():
26     global c_facet,s_all,c_vertex,v_points
27     c_facet=0
28     s_all=0
29     c_vertex=0
30     v_points=[]
31 
32 def display(a,b,c):
33     print("--------------------------------------------------------------------------")
34     print("object informatioin:")
35     print("\tvertex: "+str(a)+"\tfacet: "+str(b)+"\tsurface area: "+str(c))
36     print("--------------------------------------------------------------------------")
37 
38 def cal_area(p0,p1,p2):
39     A=[0,0,0]
40     B=[0,0,0]
41     C=[0,0,0]
42     A[0]=p1[0]-p0[0]
43     B[0]=p2[0]-p0[0]
44     C[0]=p2[0]-p1[0]
45     A[1]=p1[1]-p0[1]
46     B[1]=p2[1]-p0[1]
47     C[1]=p2[1]-p1[1]
48     A[2]=p1[2]-p0[2]
49     B[2]=p2[2]-p0[2]
50     C[2]=p2[2]-p1[2]
51     a=math.sqrt(A[0]**2+A[1]**2+A[2]**2)
52     b=math.sqrt(B[0]**2+B[1]**2+B[2]**2)
53     c=math.sqrt(C[0]**2+C[1]**2+C[2]**2)
54     p=(a+b+c)/2.0
55     return math.sqrt(p*(p-a)*(p-b)*(p-c))
56
View Code

8.2 附录B——stl.py

  1 # -----------------------------------------------------------------------------
  2 # stl.py
  3 #
  4 # A simple calculator with variables.   This is from O‘Reilly‘s
  5 # "Lex and Yacc", p. 63.
  6 # -----------------------------------------------------------------------------
  7 
  8 import stlcount as cn
  9 
 10 #------------------------------------------------------------------------------
 11 #词法分析
 12 #------------------------------------------------------------------------------
 13 
 14 
 15 
 16 tokens = (
 17     ‘KEYWORD‘,‘RPARAM‘,‘LPARAM‘,‘NAME‘,‘NUMBER‘
 18     )
 19 
 20 #literals = [‘=‘,‘+‘,‘-‘,‘*‘,‘/‘, ‘(‘,‘)‘]
 21 
 22 # Tokens
 23 
 24 def t_KEYWORD(t):
 25     r"normal | outer | vertex"
 26     return t
 27 
 28 def t_RPARAM(t):
 29     r"solid | facet | loop"
 30     return t
 31 
 32 def t_LPARAM(t):
 33     r"endsolid | endfacet | endloop"
 34     return t
 35 
 36 def t_NAME(t):
 37     r‘[a-zA-Z_][a-zA-Z0-9_]*‘
 38     return t
 39 
 40 def t_NUMBER(t):
 41     r‘(-?\d+)(\.\d+)?(e-?\d+)?‘
 42     t.value =http://www.mamicode.com/ float(t.value)
 43     return t
 44 
 45 t_ignore = " \t"
 46 
 47 def t_newline(t):
 48     r‘\n+‘
 49     t.lexer.lineno += t.value.count("\n")
 50     
 51 def t_error(t):
 52     print("Illegal character ‘%s‘" % t.value[0])
 53     t.lexer.skip(1)
 54     
 55 # Build the lexer
 56 import ply.lex as lex
 57 lexer=lex.lex()
 58 
 59 #======================================================================
 60 
 61 def p_start(p):
 62     r‘start : RPARAM NAME facet LPARAM NAME‘
 63     if cn.b_print_yacc:
 64         print("start : RPARAM NAME facet LPARAM NAME")
 65     cn.display(cn.c_vertex,cn.c_facet,cn.s_all)
 66 
 67 def p_facet(p):
 68     r‘facet : facet facet‘
 69     if cn.b_print_yacc:
 70         print(‘facet : facet facet‘)
 71 
 72 def p_facet1(p):
 73     r‘facet : RPARAM norm out LPARAM‘
 74     if cn.b_print_yacc:
 75         print(‘facet : RPARAM norm out LPARAM‘)
 76     cn.c_facet=cn.c_facet+1
 77     s_single=cn.cal_area(cn.v_points[0],cn.v_points[1],cn.v_points[2])
 78     if s_single<0:
 79         print("****************************ERROR*******************************")
 80     cn.s_all=cn.s_all+s_single
 81     if cn.b_print_yacc:
 82         print("area:",end=‘\t‘)
 83         print(cn.s_all)
 84     cn.v_points=[]
 85 
 86     
 87 def p_norm(p):
 88     r‘norm : KEYWORD NUMBER NUMBER NUMBER‘
 89     if cn.b_print_yacc:
 90         print("norm  : KEYWORD NUMBER NUMBER NUMBER")
 91 
 92 def p_out(p):
 93     r‘out : KEYWORD lp‘
 94     if cn.b_print_yacc:
 95         print("out : KEYWORD lp")
 96 
 97 def p_lp(p):
 98     r‘lp : RPARAM vertex LPARAM‘
 99     if cn.b_print_yacc:
100         print(‘lp : RPARAM vertex LPARAM‘)
101 
102 def p_vertex(p):
103     r‘vertex : point point point‘
104     if cn.b_print_yacc:
105         print(‘vertex : point point point‘)
106 
107 def p_point(p):
108     r‘point : KEYWORD NUMBER NUMBER NUMBER‘
109     if cn.b_print_yacc:
110         print(‘point : KEYWORD NUMBER NUMBER NUMBER‘)
111     cn.c_vertex=cn.c_vertex+1
112     cn.v_points.append([p[2],p[3],p[4]])
113 
114 
115 def p_error(p):
116     if p:
117         print("Syntax error at ‘%s‘" % p.value)
118     else:
119         print("Syntax error at EOF")
120 
121 import ply.yacc as yacc
122 yacc.yacc()
123 
124 
125 def stl_exec(s,blex=False,byacc=False):
126     cn.b_print_lex=blex
127     cn.b_print_yacc=byacc
128     cn.init_countstl()
129     if cn.b_print_lex:
130         print("----------------------------------------------------------------------")
131         print("\t\tlex")
132         print("----------------------------------------------------------------------")
133         lexer.input(s)
134         for st in lexer:
135             print(st)
136     if cn.b_print_yacc:
137         print("----------------------------------------------------------------------")
138         print("\t\tyacc")
139         print("----------------------------------------------------------------------")
140     yacc.parse(s)
View Code

8.3 附录C——parsetab.py

 1 # parsetab.py
 2 # This file is automatically generated. Do not edit.
 3 _tabversion = ‘3.2‘
 4 
 5 _lr_method = ‘LALR‘
 6 
 7 _lr_signature = b‘|:{\xf5@\x08\xce\xd8d\x055eAN\xff\x13‘
 8     
 9 _lr_action_items = {‘NAME‘:([1,8,],[3,13,]),‘KEYWORD‘:([4,7,15,18,21,24,27,],[6,11,19,-4,19,19,-8,]),‘NUMBER‘:([6,10,14,19,22,25,],[10,14,18,22,25,27,]),‘LPARAM‘:([5,9,12,16,17,20,23,26,27,],[8,-2,17,-5,-3,23,-6,-7,-8,]),‘$end‘:([2,13,],[0,-1,]),‘RPARAM‘:([0,3,5,9,11,17,],[1,4,4,4,15,-3,]),}
10 
11 _lr_action = { }
12 for _k, _v in _lr_action_items.items():
13    for _x,_y in zip(_v[0],_v[1]):
14       if not _x in _lr_action:  _lr_action[_x] = { }
15       _lr_action[_x][_k] = _y
16 del _lr_action_items
17 
18 _lr_goto_items = {‘norm‘:([4,],[7,]),‘start‘:([0,],[2,]),‘vertex‘:([15,],[20,]),‘point‘:([15,21,24,],[21,24,26,]),‘facet‘:([3,5,9,],[5,9,9,]),‘lp‘:([11,],[16,]),‘out‘:([7,],[12,]),}
19 
20 _lr_goto = { }
21 for _k, _v in _lr_goto_items.items():
22    for _x,_y in zip(_v[0],_v[1]):
23        if not _x in _lr_goto: _lr_goto[_x] = { }
24        _lr_goto[_x][_k] = _y
25 del _lr_goto_items
26 _lr_productions = [
27   ("S‘ -> start","S‘",1,None,None,None),
28   (‘start -> RPARAM NAME facet LPARAM NAME‘,‘start‘,5,‘p_start‘,‘E:\\PY\\stl.py‘,65),
29   (‘facet -> facet facet‘,‘facet‘,2,‘p_facet‘,‘E:\\PY\\stl.py‘,71),
30   (‘facet -> RPARAM norm out LPARAM‘,‘facet‘,4,‘p_facet1‘,‘E:\\PY\\stl.py‘,76),
31   (‘norm -> KEYWORD NUMBER NUMBER NUMBER‘,‘norm‘,4,‘p_norm‘,‘E:\\PY\\stl.py‘,91),
32   (‘out -> KEYWORD lp‘,‘out‘,2,‘p_out‘,‘E:\\PY\\stl.py‘,96),
33   (‘lp -> RPARAM vertex LPARAM‘,‘lp‘,3,‘p_lp‘,‘E:\\PY\\stl.py‘,101),
34   (‘vertex -> point point point‘,‘vertex‘,3,‘p_vertex‘,‘E:\\PY\\stl.py‘,106),
35   (‘point -> KEYWORD NUMBER NUMBER NUMBER‘,‘point‘,4,‘p_point‘,‘E:\\PY\\stl.py‘,111),
36 ]
View Code

8.4 附录D——parser.out

  1 Created by PLY version 3.4 (http://www.dabeaz.com/ply)
  2 
  3 Grammar
  4 
  5 Rule 0     S‘ -> start
  6 Rule 1     start -> RPARAM NAME facet LPARAM NAME
  7 Rule 2     facet -> facet facet
  8 Rule 3     facet -> RPARAM norm out LPARAM
  9 Rule 4     norm -> KEYWORD NUMBER NUMBER NUMBER
 10 Rule 5     out -> KEYWORD lp
 11 Rule 6     lp -> RPARAM vertex LPARAM
 12 Rule 7     vertex -> point point point
 13 Rule 8     point -> KEYWORD NUMBER NUMBER NUMBER
 14 
 15 Terminals, with rules where they appear
 16 
 17 KEYWORD              : 4 5 8
 18 LPARAM               : 1 3 6
 19 NAME                 : 1 1
 20 NUMBER               : 4 4 4 8 8 8
 21 RPARAM               : 1 3 6
 22 error                : 
 23 
 24 Nonterminals, with rules where they appear
 25 
 26 facet                : 1 2 2
 27 lp                   : 5
 28 norm                 : 3
 29 out                  : 3
 30 point                : 7 7 7
 31 start                : 0
 32 vertex               : 6
 33 
 34 Parsing method: LALR
 35 
 36 state 0
 37 
 38     (0) S‘ -> . start
 39     (1) start -> . RPARAM NAME facet LPARAM NAME
 40 
 41     RPARAM          shift and go to state 1
 42 
 43     start                          shift and go to state 2
 44 
 45 state 1
 46 
 47     (1) start -> RPARAM . NAME facet LPARAM NAME
 48 
 49     NAME            shift and go to state 3
 50 
 51 
 52 state 2
 53 
 54     (0) S‘ -> start .
 55 
 56 
 57 
 58 state 3
 59 
 60     (1) start -> RPARAM NAME . facet LPARAM NAME
 61     (2) facet -> . facet facet
 62     (3) facet -> . RPARAM norm out LPARAM
 63 
 64     RPARAM          shift and go to state 4
 65 
 66     facet                          shift and go to state 5
 67 
 68 state 4
 69 
 70     (3) facet -> RPARAM . norm out LPARAM
 71     (4) norm -> . KEYWORD NUMBER NUMBER NUMBER
 72 
 73     KEYWORD         shift and go to state 7
 74 
 75     norm                           shift and go to state 6
 76 
 77 state 5
 78 
 79     (1) start -> RPARAM NAME facet . LPARAM NAME
 80     (2) facet -> facet . facet
 81     (2) facet -> . facet facet
 82     (3) facet -> . RPARAM norm out LPARAM
 83 
 84     LPARAM          shift and go to state 8
 85     RPARAM          shift and go to state 4
 86 
 87     facet                          shift and go to state 9
 88 
 89 state 6
 90 
 91     (3) facet -> RPARAM norm . out LPARAM
 92     (5) out -> . KEYWORD lp
 93 
 94     KEYWORD         shift and go to state 11
 95 
 96     out                            shift and go to state 10
 97 
 98 state 7
 99 
100     (4) norm -> KEYWORD . NUMBER NUMBER NUMBER
101 
102     NUMBER          shift and go to state 12
103 
104 
105 state 8
106 
107     (1) start -> RPARAM NAME facet LPARAM . NAME
108 
109     NAME            shift and go to state 13
110 
111 
112 state 9
113 
114     (2) facet -> facet facet .
115     (2) facet -> facet . facet
116     (2) facet -> . facet facet
117     (3) facet -> . RPARAM norm out LPARAM
118 
119   ! shift/reduce conflict for RPARAM resolved as shift
120     LPARAM          reduce using rule 2 (facet -> facet facet .)
121     RPARAM          shift and go to state 4
122 
123   ! RPARAM          [ reduce using rule 2 (facet -> facet facet .) ]
124 
125     facet                          shift and go to state 9
126 
127 state 10
128 
129     (3) facet -> RPARAM norm out . LPARAM
130 
131     LPARAM          shift and go to state 14
132 
133 
134 state 11
135 
136     (5) out -> KEYWORD . lp
137     (6) lp -> . RPARAM vertex LPARAM
138 
139     RPARAM          shift and go to state 16
140 
141     lp                             shift and go to state 15
142 
143 state 12
144 
145     (4) norm -> KEYWORD NUMBER . NUMBER NUMBER
146 
147     NUMBER          shift and go to state 17
148 
149 
150 state 13
151 
152     (1) start -> RPARAM NAME facet LPARAM NAME .
153 
154     $end            reduce using rule 1 (start -> RPARAM NAME facet LPARAM NAME .)
155 
156 
157 state 14
158 
159     (3) facet -> RPARAM norm out LPARAM .
160 
161     RPARAM          reduce using rule 3 (facet -> RPARAM norm out LPARAM .)
162     LPARAM          reduce using rule 3 (facet -> RPARAM norm out LPARAM .)
163 
164 
165 state 15
166 
167     (5) out -> KEYWORD lp .
168 
169     LPARAM          reduce using rule 5 (out -> KEYWORD lp .)
170 
171 
172 state 16
173 
174     (6) lp -> RPARAM . vertex LPARAM
175     (7) vertex -> . point point point
176     (8) point -> . KEYWORD NUMBER NUMBER NUMBER
177 
178     KEYWORD         shift and go to state 19
179 
180     vertex                         shift and go to state 18
181     point                          shift and go to state 20
182 
183 state 17
184 
185     (4) norm -> KEYWORD NUMBER NUMBER . NUMBER
186 
187     NUMBER          shift and go to state 21
188 
189 
190 state 18
191 
192     (6) lp -> RPARAM vertex . LPARAM
193 
194     LPARAM          shift and go to state 22
195 
196 
197 state 19
198 
199     (8) point -> KEYWORD . NUMBER NUMBER NUMBER
200 
201     NUMBER          shift and go to state 23
202 
203 
204 state 20
205 
206     (7) vertex -> point . point point
207     (8) point -> . KEYWORD NUMBER NUMBER NUMBER
208 
209     KEYWORD         shift and go to state 19
210 
211     point                          shift and go to state 24
212 
213 state 21
214 
215     (4) norm -> KEYWORD NUMBER NUMBER NUMBER .
216 
217     KEYWORD         reduce using rule 4 (norm -> KEYWORD NUMBER NUMBER NUMBER .)
218 
219 
220 state 22
221 
222     (6) lp -> RPARAM vertex LPARAM .
223 
224     LPARAM          reduce using rule 6 (lp -> RPARAM vertex LPARAM .)
225 
226 
227 state 23
228 
229     (8) point -> KEYWORD NUMBER . NUMBER NUMBER
230 
231     NUMBER          shift and go to state 25
232 
233 
234 state 24
235 
236     (7) vertex -> point point . point
237     (8) point -> . KEYWORD NUMBER NUMBER NUMBER
238 
239     KEYWORD         shift and go to state 19
240 
241     point                          shift and go to state 26
242 
243 state 25
244 
245     (8) point -> KEYWORD NUMBER NUMBER . NUMBER
246 
247     NUMBER          shift and go to state 27
248 
249 
250 state 26
251 
252     (7) vertex -> point point point .
253 
254     LPARAM          reduce using rule 7 (vertex -> point point point .)
255 
256 
257 state 27
258 
259     (8) point -> KEYWORD NUMBER NUMBER NUMBER .
260 
261     KEYWORD         reduce using rule 8 (point -> KEYWORD NUMBER NUMBER NUMBER .)
262     LPARAM          reduce using rule 8 (point -> KEYWORD NUMBER NUMBER NUMBER .)
263 
264 WARNING: 
265 WARNING: Conflicts:
266 WARNING: 
267 WARNING: shift/re
View Code

8.5 附录E——cstl.py

 1 import sys
 2 largv=len(sys.argv)
 3 bLex=False
 4 bYacc=False
 5 if largv==1:
 6     filename=input(‘please input the name of file\n>>>‘)
 7 else:
 8     if largv>1:
 9         filename=sys.argv[1]
10         if largv>2:
11             if sys.argv[2]==‘L‘:
12                 bLex=True
13                 bYacc=False
14             else:
15                 if sys.argv[2]==‘Y‘:
16                     bLex=False
17                     bYacc=True
18                 else:
19                     if sys.argv[2]==‘YL‘ or sys.argv[2]==‘LY‘:
20                         bLex=True
21                         bYacc=True
22 def run():
23     try:
24         file=open(filename).read()
25         import stl
26         stl.stl_exec(file,bLex,bYacc)
27     except:
28         print(‘OPENFILE ERROR!‘)
29         exit()
30         
31 run()
View Code

 


联系
我们