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

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 = 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 importmath7

8 #小三角片数

9 c_facet=010

11 #表面积

12 s_all=013

14 #点数

15 c_vertex=016

17

18 #保存三个点

19 v_points=[]20

21 b_print_yacc=False22 b_print_lex=False23

24 #初始化

25 definit_countstl():26 globalc_facet,s_all,c_vertex,v_points27 c_facet=028 s_all=029 c_vertex=030 v_points=[]31

32 defdisplay(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 defcal_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 importstlcount as cn9

10 #------------------------------------------------------------------------------

11 #词法分析

12 #------------------------------------------------------------------------------

13

14

15

16 tokens =(17 'KEYWORD','RPARAM','LPARAM','NAME','NUMBER'

18 )19

20 #literals = ['=','+','-','*','/', '(',')']

21

22 #Tokens

23

24 deft_KEYWORD(t):25 r"normal | outer | vertex"

26 returnt27

28 deft_RPARAM(t):29 r"solid | facet | loop"

30 returnt31

32 deft_LPARAM(t):33 r"endsolid | endfacet | endloop"

34 returnt35

36 deft_NAME(t):37 r'[a-zA-Z_][a-zA-Z0-9_]*'

38 returnt39

40 deft_NUMBER(t):41 r'(-?\d+)(\.\d+)?(e-?\d+)?'

42 t.value =float(t.value)43 returnt44

45 t_ignore = "\t"

46

47 deft_newline(t):48 r'\n+'

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

51 deft_error(t):52 print("Illegal character '%s'" %t.value[0])53 t.lexer.skip(1)54

55 #Build the lexer

56 importply.lex as lex57 lexer=lex.lex()58

59 #======================================================================

60

61 defp_start(p):62 r'start : RPARAM NAME facet LPARAM NAME'

63 ifcn.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 defp_facet(p):68 r'facet : facet facet'

69 ifcn.b_print_yacc:70 print('facet : facet facet')71

72 defp_facet1(p):73 r'facet : RPARAM norm out LPARAM'

74 ifcn.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_single81 ifcn.b_print_yacc:82 print("area:",end='\t')83 print(cn.s_all)84 cn.v_points=[]85

86

87 defp_norm(p):88 r'norm : KEYWORD NUMBER NUMBER NUMBER'

89 ifcn.b_print_yacc:90 print("norm : KEYWORD NUMBER NUMBER NUMBER")91

92 defp_out(p):93 r'out : KEYWORD lp'

94 ifcn.b_print_yacc:95 print("out : KEYWORD lp")96

97 defp_lp(p):98 r'lp : RPARAM vertex LPARAM'

99 ifcn.b_print_yacc:100 print('lp : RPARAM vertex LPARAM')101

102 defp_vertex(p):103 r'vertex : point point point'

104 ifcn.b_print_yacc:105 print('vertex : point point point')106

107 defp_point(p):108 r'point : KEYWORD NUMBER NUMBER NUMBER'

109 ifcn.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 defp_error(p):116 ifp:117 print("Syntax error at '%s'" %p.value)118 else:119 print("Syntax error at EOF")120

121 importply.yacc as yacc122 yacc.yacc()123

124

125 def stl_exec(s,blex=False,byacc=False):126 cn.b_print_lex=blex127 cn.b_print_yacc=byacc128 cn.init_countstl()129 ifcn.b_print_lex:130 print("----------------------------------------------------------------------")131 print("\t\tlex")132 print("----------------------------------------------------------------------")133 lexer.input(s)134 for st inlexer:135 print(st)136 ifcn.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] =_y16 del_lr_action_items17

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] =_y25 del_lr_goto_items26 _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 Grammar4

5 Rule 0S' -> start6 Rule 1start -> RPARAM NAME facet LPARAM NAME7 Rule 2facet -> facet facet8 Rule 3facet -> RPARAM norm out LPARAM9 Rule 4norm -> KEYWORD NUMBER NUMBER NUMBER10 Rule 5out -> KEYWORD lp11 Rule 6lp -> RPARAM vertex LPARAM12 Rule 7vertex -> point point point13 Rule 8point -> KEYWORD NUMBER NUMBER NUMBER14

15 Terminals,with rules where they appear16

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 appear25

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: LALR35

36 state 0

37

38 (0) S' -> . start39 (1) start -> . RPARAM NAME facet LPARAM NAME40

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 NAME48

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 NAME61 (2) facet -> . facet facet62 (3) facet -> . RPARAM norm out LPARAM63

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 LPARAM71 (4) norm -> . KEYWORD NUMBER NUMBER NUMBER72

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 NAME80 (2) facet -> facet . facet81 (2) facet -> . facet facet82 (3) facet -> . RPARAM norm out LPARAM83

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 LPARAM92 (5) out -> . KEYWORD lp93

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 NUMBER101

102 NUMBER shift and go to state 12

103

104

105 state 8

106

107 (1) start -> RPARAM NAME facet LPARAM . NAME108

109 NAME shift and go to state 13

110

111

112 state 9

113

114 (2) facet -> facet facet .115 (2) facet -> facet . facet116 (2) facet -> . facet facet117 (3) facet -> . RPARAM norm out LPARAM118

119 ! shift/reduce conflict for RPARAM resolved as shift120 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 . LPARAM130

131 LPARAM shift and go to state 14

132

133

134 state 11

135

136 (5) out -> KEYWORD . lp137 (6) lp -> . RPARAM vertex LPARAM138

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 NUMBER146

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 LPARAM175 (7) vertex -> . point point point176 (8) point -> . KEYWORD NUMBER NUMBER NUMBER177

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 . NUMBER186

187 NUMBER shift and go to state 21

188

189

190 state 18

191

192 (6) lp -> RPARAM vertex . LPARAM193

194 LPARAM shift and go to state 22

195

196

197 state 19

198

199 (8) point -> KEYWORD . NUMBER NUMBER NUMBER200

201 NUMBER shift and go to state 23

202

203

204 state 20

205

206 (7) vertex -> point . point point207 (8) point -> . KEYWORD NUMBER NUMBER NUMBER208

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 NUMBER230

231 NUMBER shift and go to state 25

232

233

234 state 24

235

236 (7) vertex -> point point . point237 (8) point -> . KEYWORD NUMBER NUMBER NUMBER238

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 . NUMBER246

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 importsys2 largv=len(sys.argv)3 bLex=False4 bYacc=False5 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=True13 bYacc=False14 else:15 if sys.argv[2]=='Y':16 bLex=False17 bYacc=True18 else:19 if sys.argv[2]=='YL' or sys.argv[2]=='LY':20 bLex=True21 bYacc=True22 defrun():23 try:24 file=open(filename).read()25 importstl26 stl.stl_exec(file,bLex,bYacc)27 except:28 print('OPENFILE ERROR!')29 exit()30

31 run()

View Code