source: EcnlProtoTool/trunk/asp3_dcre/tecsgen/tecslib/core/bnf.y.rb@ 321

Last change on this file since 321 was 321, checked in by coas-nagasima, 7 years ago

文字コードを設定
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-ruby;charset=UTF-8
File size: 62.3 KB
Line 
1# -*- coding: utf-8 -*-
2#
3# TECS Generator
4# Generator for TOPPERS Embedded Component System
5#
6# Copyright (C) 2008-2016 by TOPPERS Project
7#--
8# 上記著作権者は，以下の(1)～(4)の条件を満たす場合に限り，本ソフトウェ
9# ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
10# 変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
11# (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
12# 権表示，この利用条件および下記の無保証規定が，そのままの形でソー
13# スコード中に含まれていること．
14# (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
15# 用できる形で再配布する場合には，再配布に伴うドキュメント（利用
16# 者マニュアルなど）に，上記の著作権表示，この利用条件および下記
17# の無保証規定を掲載すること．
18# (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
19# 用できない形で再配布する場合には，次のいずれかの条件を満たすこ
20# と．
21# (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
22# 作権表示，この利用条件および下記の無保証規定を掲載すること．
23# (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
24# 報告すること．
25# (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
26# 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
27# また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
28# 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
29# 免責すること．
30#
31# 本ソフトウェアは，無保証で提供されているものである．上記著作権者お
32# よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
33# に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
34# アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
35# の責任を負わない．
36#
37# $Id$
38#++
39
40class Generator
41rule
42# トップレベルの構文要素はcomponent_description
43all: component_description
44
45# Expr
46########################## 式 ##########################
47# K&Rの文法(プログラミング言語C 第2版 付録)と一部異なる
48# argument_expression_list(関数引数), assignment_expression(代入)がない
49# 式の result は、すべて配列で第一要素が識別シンボル、第二要素以下が引数
50
51primary_expression
52 : namespace_identifier
53 { result = [ :IDENTIFIER, val[0] ] } #1ok
54 | TRUE
55 { result = [ :BOOL_CONSTANT, true ] }
56 | FALSE
57 { result = [ :BOOL_CONSTANT, false ] }
58 | INTEGER_CONSTANT
59 { result = [ :INTEGER_CONSTANT, val[0] ] }
60 | FLOATING_CONSTANT
61 { result = [ :FLOATING_CONSTANT, val[0] ] }
62 | OCTAL_CONSTANT
63 { result = [ :OCTAL_CONSTANT, val[0] ] }
64 | HEX_CONSTANT
65 { result = [ :HEX_CONSTANT, val[0] ] }
66 | CHARACTER_LITERAL
67 { result = [ :CHARACTER_LITERAL, val[0] ] }
68 | string_literal_list
69 { result = [ :STRING_LITERAL_LIST, val[0] ] }
70 | '(' expression ')'
71 { result = [ :PARENTHESES, val[1].get_elements ] }
72
73string_literal_list
74 : STRING_LITERAL
75 | string_literal_list STRING_LITERAL
76 {
77 # 連接した文字列を1つの文字列にまとめる
78 str = "\"" + val[0].val.gsub( /\"(.*)\"/, "\\1" ) + val[1].val.gsub( /\"(.*)\"/, "\\1" ) + "\""
79 result = Token.new( str, val[0].file, val[0].lineno, val[0].col )
80 }
81
82# 関数呼び出しと後置インクリメント、デクリメント演算子がない
83postfix_expression
84 : primary_expression
85 | postfix_expression '[' expression ']'
86 { result = [ :OP_SUBSC, val[0], val[2] ] }
87 | postfix_expression '.' IDENTIFIER
88 { result = [ :OP_DOT, val[0], val[2] ] }
89 | postfix_expression '->' IDENTIFIER
90 { result = [ :OP_REF, val[0], val[2] ] }
91
92# 前置インクリメント、デクリメント演算子がない
93unary_expression
94 : postfix_expression
95 | unary_operator cast_expression
96 { result = [ val[0], val[1] ] }
97 | SIZEOF unary_expression
98 { result = [ :OP_SIZEOF_EXPR, val[1] ] }
99 | SIZEOF '(' type_name ')'
100 { result = [ :OP_SIZEOF_TYPE, val[1] ] }
101
102unary_operator
103 : '&' { result = :OP_U_AMP }
104 | '*' { result = :OP_U_ASTER }
105 | '+' { result = :OP_U_PLUS }
106 | '-' { result = :OP_U_MINUS }
107 | '~' { result = :OP_U_TILDE }
108 | '!' { result = :OP_U_EXCLAM }
109
110cast_expression
111 : unary_expression
112 | '(' type_name ')' cast_expression
113 { result = [ :CAST, val[1], val[3] ] }
114
115multiplicative_expression
116 : cast_expression
117 | multiplicative_expression '*' cast_expression
118 { result = [ :OP_MULT, val[0], val[2] ] }
119 | multiplicative_expression '/' cast_expression
120 { result = [ :OP_DIV, val[0], val[2] ] }
121 | multiplicative_expression '%' cast_expression
122 { result = [ :OP_REMAIN, val[0], val[2] ] }
123
124additive_expression
125 : multiplicative_expression
126 | additive_expression '+' multiplicative_expression
127 { result = [ :OP_ADD, val[0], val[2] ] }
128 | additive_expression '-' multiplicative_expression
129 { result = [ :OP_SUB, val[0], val[2] ] }
130
131shift_expression
132 : additive_expression
133 | shift_expression '<<' additive_expression
134 { result = [ :OP_LSFT, val[0], val[2] ] }
135 | shift_expression '>>' additive_expression
136 { result = [ :OP_RSFT, val[0], val[2] ] }
137
138relational_expression
139 : shift_expression
140 | relational_expression '<' shift_expression
141 { result = [ :OP_LT, val[0], val[2] ] }
142 | relational_expression '>' shift_expression
143 { result = [ :OP_GT, val[0], val[2] ] }
144 | relational_expression '<=' shift_expression
145 { result = [ :OP_LE, val[0], val[2] ] }
146 | relational_expression '>=' shift_expression
147 { result = [ :OP_GE, val[0], val[2] ] }
148
149equality_expression
150 : relational_expression
151 | equality_expression '==' relational_expression
152 { result = [ :OP_EQ, val[0], val[2] ] }
153 | equality_expression '!=' relational_expression
154 { result = [ :OP_NE, val[0], val[2] ] }
155
156and_expression
157 : equality_expression
158 | and_expression '&' equality_expression
159 { result = [ :OP_AND, val[0], val[2] ] }
160
161exclusive_or_expression
162 : and_expression
163 | exclusive_or_expression '^' and_expression
164 { result = [ :OP_EOR, val[0], val[2] ] }
165
166inclusive_or_expression
167 : exclusive_or_expression
168 | inclusive_or_expression '|' exclusive_or_expression
169 { result = [ :OP_OR, val[0], val[2] ] }
170
171logical_and_expression
172 : inclusive_or_expression
173 | logical_and_expression '&&' inclusive_or_expression
174 { result = [ :OP_LAND, val[0], val[2] ] }
175
176logical_or_expression
177 : logical_and_expression
178 | logical_or_expression '||' logical_and_expression
179 { result = [ :OP_LOR, val[0], val[2] ] }
180
181conditional_expression
182 : logical_or_expression
183 | logical_or_expression '?' expression ':' conditional_expression
184 { result = [ :OP_CEX, val[0], val[2].get_elements, val[4] ] }
185
186
187# コンマ演算子が使えない
188expression
189 : conditional_expression
190 {
191 result = Expression.new( val[0] )
192 # result.print
193 }
194
195constant_expression
196 : conditional_expression
197 {
198 result = Expression.new( val[0] )
199 # result.print
200
201 # res = result.eval_const( nil )
202 # if res then
203 # puts "val: #{res}"
204 # else
205 # puts "val: nil"
206 # end
207 }
208
209
210
211# Types
212########################## 宣言 ##########################
213# 宣言もK&Rと一部異なる
214
215# declarationはセルの属性で使われる
216# K&Rとの違い: storage classが指定できない、型が省略できない
217declaration
218 : type_specifier_qualifier_list init_declarator_list ';'
219 {
220 val[1].each { |i| # i: Decl
221 i.set_type( val[0] )
222 }
223 result = val[1]
224 }
225
226# declaration_specifiersは関数のパラメータで使われるが、
227# type_specifier_qualifier_listで十分かもしれない
228# Oyama
229# const, volatile は単独で型にならないので変形
230# const と volatile が同居することはないので、繰返し指定できないようにした
231# type_specifier も繰返し指定できる必要はない (singed など単独で型にはならない)
232declaration_specifiers
233 : type_specifier
234 | type_qualifier type_specifier
235 {
236 val[1].set_qualifier( val[0] )
237 result = val[1]
238 }
239
240init_declarator_list
241 : init_declarator
242 { result = [val[0]] }
243 | init_declarator_list ',' init_declarator
244 { result << val[2] }
245
246init_declarator
247 : declarator
248 | declarator '=' initializer
249 { val[0].set_initializer( val[2] ) }
250
251# INT8から下はK&Rにない
252# Oyama
253# signed, unsigned は単独で型にならないので、構文要素として分離
254type_specifier
255 : VOID { result = VoidType.new }
256 | FLOAT32_T { result = FloatType.new(32) }
257 | DOUBLE64_T { result = FloatType.new(64) }
258 | struct_specifier
259 | enum_specifier
260 | TYPE_NAME { result = DefinedType.new( val[0].val ) }
261# | IDENTIFIER { result = DefinedType.new( val[0].val ) } # reduce/reduce conflict が起こってしまう
262 | sign_int_type
263 | char_type
264 | BOOL_T { result = BoolType.new }
265# | BOOL {
266# Generator.warning( "W5001 bool: obsolete type. use bool_t" )
267# result = BoolType.new
268# }
269 | FLOAT {
270 Generator.warning( "W5002 float: obsolete type. use float32_t" )
271 result = FloatType.new(32)
272 }
273 | DOUBLE {
274 Generator.warning( "W5003 double: obsolete type. use double64_t" )
275 result = FloatType.new(64)
276 }
277 | DESCRIPTOR '(' namespace_identifier ')' { # namespace_identifier: signature name
278 result = DescriptorType.new( val[2] )
279 }
280
281char_type
282 : CHAR_T { result = IntType.new( -1 ) }
283 | SCHAR_T
284 {
285 result = IntType.new( -1 )
286 result.set_sign( :SIGNED, true )
287 }
288 | UCHAR_T
289 {
290 result = IntType.new( -1 )
291 result.set_sign( :UNSIGNED, true )
292 }
293
294int_type
295 : CHAR {
296 # Generator.warning( "W5004 char: obsolete type. use char_t" )
297 result = IntType.new( -11 )
298 }
299 | SHORT { result = IntType.new( -2 ) }
300 | INT { result = IntType.new( -3 ) }
301 | LONG { result = IntType.new( -4 ) }
302# | INTPTR { result = IntType.new( -5 ) }
303# | INT8 {
304# Generator.warning( "W5005 int8: obsolete. use int8_t" )
305# result = IntType.new( 8 )
306# }
307# | INT16 {
308# Generator.warning( "W5006 int16: obsolete. use int16_t" )
309# result = IntType.new( 16 )
310# }
311# | INT32 {
312# Generator.warning( "W5007 int32: obsolete. use int32_t" )
313# result = IntType.new( 32 )
314# }
315# | INT64
316# {
317# Generator.warning( "W5008 int64: obsolete. use int64_t" )
318# result = IntType.new( 64 )
319# }
320# | INT128
321# {
322# Generator.warning( "W5009 int64: obsolete. use int64_t" )
323# result = IntType.new( 128 )
324# }
325 | INT8_T { result = IntType.new( 8 ) }
326 | INT16_T { result = IntType.new( 16 ) }
327 | INT32_T { result = IntType.new( 32 ) }
328 | INT64_T { result = IntType.new( 64 ) }
329 | INT128_T { result = IntType.new( 128 ) }
330 | UINT8_T
331 {
332 result = IntType.new( 8 )
333 result.set_sign( :UNSIGNED, true )
334 }
335 | UINT16_T
336 {
337 result = IntType.new( 16 )
338 result.set_sign( :UNSIGNED, true )
339 }
340 | UINT32_T
341 {
342 result = IntType.new( 32 )
343 result.set_sign( :UNSIGNED, true )
344 }
345 | UINT64_T
346 {
347 result = IntType.new( 64 )
348 result.set_sign( :UNSIGNED, true )
349 }
350 | UINT128_T
351 {
352 result = IntType.new( 128 )
353 result.set_sign( :UNSIGNED, true )
354 }
355
356sign # TECS では signed, unsigned 単独では型にできない
357 : SIGNED { result = :SIGNED }
358 | UNSIGNED { result = :UNSIGNED }
359
360# result[0] :CHAR などのトークン、result[1] :CONST, :VOLATILE など
361sign_int_type
362 : sign int_type
363 {
364 val[1].set_sign( val[0] )
365 result = val[1]
366 }
367 | int_type
368
369# K&Rのstruct_or_union_specifierに相当するが、unionは使えない
370struct_specifier # mikan
371 : STRUCT struct_tag '{'
372 { StructType.set_define( true ) }
373 struct_declaration_list '}'
374 {
375 StructType.end_of_parse
376 result = val[1]
377 }
378 | STRUCT
379 {
380 result = StructType.new()
381 StructType.set_define( true )
382 }
383 '{' struct_declaration_list '}'
384 {
385 StructType.end_of_parse
386 result = val[1]
387 }
388 | STRUCT struct_tag # mikan struct_tag は namespace 対応が必要
389 {
390 StructType.set_define( false )
391 StructType.end_of_parse
392 result = val[1]
393 }
394
395struct_declaration_list
396 : struct_declaration
397 | struct_declaration_list struct_declaration
398
399struct_tag:
400 IDENTIFIER
401 { result = StructType.new( val[0].val ) }
402
403# ポインタ修飾子を追加
404struct_declaration
405 : type_specifier_qualifier_list struct_declarator_list ';'
406 {
407 val[1].each { |i| # i: Decl
408 i.set_type( val[0] )
409 i.set_kind( :MEMBER )
410 i.check
411 StructType.new_member( i )
412 }
413 result = val[1]
414 }
415 | spec_L pointer_specifier_list spec_R type_specifier_qualifier_list struct_declarator_list ';'
416 {
417 val[4].each { |i| # i: Decl
418 i.set_type( val[3] )
419 i.set_kind( :MEMBER )
420 i.set_specifier_list val[1]
421 i.check
422 StructType.new_member( i )
423 }
424 result = val[4]
425 }
426
427pointer_specifier_list
428 : pointer_specifier { result = [ val[0] ] }
429 | pointer_specifier_list ',' pointer_specifier { result << val[2] }
430
431pointer_specifier
432 : STRING { result = [:STRING,-1] }
433 | STRING '(' expression ')' { result = [:STRING,val[2]] }
434 | SIZE_IS '(' expression ')' { result = [:SIZE_IS,val[2]] }
435 | COUNT_IS '(' expression ')' { result = [:COUNT_IS,val[2]] }
436
437
438# K&Rのspecifier_qualifier_listと同じ
439# 名前がまぎらわしかったのでtype_を付けた
440type_specifier_qualifier_list
441# Oyama type_specifier を繰り返して指定することはなくなった (sign_int_type としたため）
442# : type_specifier type_specifier_qualifier_list
443 : type_specifier
444 | type_qualifier type_specifier_qualifier_list
445 {
446 val[1].set_qualifier( val[0] )
447 result = val[1]
448 }
449# mikan Oyama type_qualifier だけでは型指定にならない : 構文エラーとするより、意味エラーとした方が親切
450# | type_qualifier
451
452
453struct_declarator_list
454 : struct_declarator
455 { result = [ val[0] ] }
456 | struct_declarator_list ',' struct_declarator
457 { result << val[2] }
458
459# ビットフィールドは使えない
460struct_declarator
461 : declarator
462
463# enumの種類を追加
464enum_specifier # mikan
465 : enum_type '{' enumerator_list '}'
466 | enum_type IDENTIFIER '{' enumerator_list '}'
467 | enum_type IDENTIFIER
468
469enum_type
470 : ENUM { result = EnumType.new( -1 ) }
471 | ENUM8 { result = EnumType.new( 8 ) }
472 | ENUM16 { result = EnumType.new( 16 ) }
473 | ENUM32 { result = EnumType.new( 32 ) }
474 | ENUM64 { result = EnumType.new( 64 ) }
475 | ENUM128 { result = EnumType.new( 128 ) }
476
477enumerator_list
478 : enumerator
479 | enumerator_list ',' enumerator
480
481enumerator
482 : IDENTIFIER
483 | IDENTIFIER '=' constant_expression
484
485type_qualifier
486 : CONST { result = :CONST }
487 | VOLATILE { result = :VOLATILE }
488
489declarator
490 : pointer direct_declarator
491 {
492 val[1].set_type( val[0] )
493 result = val[1]
494 }
495 | direct_declarator
496
497direct_declarator # mikan
498 : IDENTIFIER
499 { result = Decl.new( val[0].val ) }
500 | '(' declarator ')'
501 { result = val[1] }
502 | direct_declarator '[' constant_expression ']'
503 {
504 val[0].set_type( ArrayType.new( val[2] ) )
505 result = val[0]
506 }
507 | direct_declarator '[' ']'
508 {
509 val[0].set_type( ArrayType.new )
510 result = val[0]
511 }
512 | direct_declarator '(' parameter_type_list ')'
513 {
514 val[0].set_type( FuncType.new( val[2] ) )
515 result = val[0]
516 }
517# | direct_declarator '(' identifier_list ')' # これは何のために必要？ 060211
518 | direct_declarator '(' ')'
519 {
520 Generator.warning( "W5010 need 'void' for no parameter" )
521 val[0].set_type( FuncType.new )
522 result = val[0]
523 }
524
525pointer
526 : '*'
527 { result = PtrType.new }
528 | '*' type_qualifier
529 {
530 result = PtrType.new
531 result.set_qualifier( val[1] )
532 }
533 | '*' pointer
534 {
535 val[1].set_type(PtrType.new)
536 result = val[1]
537 }
538 | '*' type_qualifier pointer
539 {
540 ptrtype = PtrType.new
541 ptrtype.set_qualifier( val[1] )
542 val[2].set_type( ptrtype )
543 result = val[2]
544 }
545
546
547parameter_type_list
548 : parameter_list
549 | parameter_list ',' '...'
550 # mikan 可変長パラメータ
551
552parameter_list
553 : parameter_declaration
554 { result = ParamList.new( val[0] ) }
555 | parameter_list ',' parameter_declaration
556 {
557 val[0].add_param( val[2] )
558 # result = val[0] 不要
559 }
560
561
562# パラメータ修飾子を追加
563parameter_declaration
564# : spec_L parameter_specifier_list spec_R declaration_specifiers declarator
565 : parameter_specifier_list_bracket declaration_specifiers declarator
566 {
567 val[2].set_kind( :PARAMETER )
568 paramdecl = ParamDecl.new( val[2], val[1], val[0] )
569 val[2].check
570 result = paramdecl
571 }
572
573 # 以下はエラーとする
574 | declaration_specifiers declarator # parameter_specifier なしは扱わない
575 {
576 Generator.error( "G1001 need specifier for \'$1\'" , val[1].get_name )
577 result = nil
578 }
579 | declaration_specifiers # 仮引数なしは、とりあえず扱わない 060210
580 {
581 unless val[0].instance_of?( VoidType ) then
582 Generator.error( "G1002 need parameter name" )
583 end
584 result = nil
585 }
586# | '[' parameter_specifier_list ']' declaration_specifiers # 同 060210
587 | parameter_specifier_list_bracket declaration_specifiers # 同 060210
588 {
589 unless val[1].instance_of?( VoidType ) then
590 Generator.error( "G1003 need parameter name" )
591 end
592 result = nil
593 }
594
595parameter_specifier_list_bracket
596 : spec_L parameter_specifier_list spec_R { result = val[1] }
597# : '[' parameter_specifier_list ']' { result = val[1] }
598
599parameter_specifier_list
600 : parameter_specifier { result = val[0] }
601 | parameter_specifier_list ',' parameter_specifier
602 { result = result + val[2] }
603
604parameter_specifier
605 : IN { result = [ [:IN] ] }
606 | OUT { result = [ [:OUT] ] }
607 | INOUT { result = [ [:INOUT] ] }
608 | SEND '(' namespace_identifier ')' { result = [ [:SEND, val[2]] ] } #1ok allocator
609 | RECEIVE '(' namespace_identifier ')' { result = [ [:RECEIVE,val[2]] ] } #1ok allocator
610 | STRING { result = [ [:STRING,nil] ] }
611 | STRING '(' expression ')' { result = [ [:STRING, val[2]] ] }
612 | SIZE_IS '(' expression ')' { result = [ [:SIZE_IS, val[2]] ] }
613 | SIZE_IS '(' expression ',' constant_expression ')'
614 {
615 result = [ [:SIZE_IS,val[2]], [:MAX_IS, val[4]] ]
616 }
617 | COUNT_IS '(' expression ')' { result = [ [:COUNT_IS,val[2]] ] }
618 | NULLABLE { result = [ [:NULLABLE] ] }
619
620type_name
621 : type_specifier_qualifier_list
622 | type_specifier_qualifier_list abstract_declarator
623 {
624 if val[1] then
625 val[1].set_type( val[0] )
626 result = val[1]
627 else
628 # エラー：仮で val[0] を返す
629 result = val[0]
630 end
631 }
632 # mikan abstract_declarator が pointer 以外ではうまく動かない、とりあえず '*' CAST のみ救った
633
634abstract_declarator # mikan
635 : pointer
636 | direct_abstract_declarator
637 | pointer direct_abstract_declarator
638
639direct_abstract_declarator
640 : '(' abstract_declarator ')'
641 { result = val[1] } # 関数ポインタ型を救う
642 | '[' ']'
643 {
644 Generator.error( "G1004 impossible array type" )
645 result = nil
646 }
647 | '[' constant_expression ']'
648 {
649 Generator.error( "G1005 impossible array type" )
650 result = nil
651 }
652 | direct_abstract_declarator '[' ']'
653 {
654 Generator.error( "G1006 impossible array type" )
655 result = nil
656 }
657 | direct_abstract_declarator '[' constant_expression ']'
658 {
659 Generator.error( "G1007 impossible array type" )
660 result = nil
661 }
662 | '(' ')'
663 {
664 Generator.error( "G1008 impossible function type" )
665 result = nil
666 }
667 | '(' parameter_type_list ')'
668 | direct_abstract_declarator '(' ')'
669 {
670 Generator.warning( "W5011 need 'void' for no parameter" )
671 val[0].set_type( FuncType.new )
672 result = val[0]
673 }
674 | direct_abstract_declarator '(' parameter_type_list ')'
675 {
676 val[0].set_type( FuncType.new( val[2] ) )
677 result = val[0]
678 }
679
680# assignment_expressionをconstant_expressionに変更
681initializer # mikan
682 : constant_expression
683 { result = val[0] }
684 | '{' initializer_list '}'
685 { result = val[1] }
686 | '{' initializer_list ',' '}'
687 { result = val[1] }
688# | C_EXP '(' STRING_LITERAL ')'
689 | C_EXP '(' string_literal_list ')'
690 { result = C_EXP.new( val[2] ) }
691
692initializer_list
693 : initializer
694 {
695 result = [ val[0] ]
696 }
697 | initializer_list ',' initializer
698 {
699 val[0] << val[2]
700 result = val[0]
701 }
702
703
704########################## ここからはCDL独自 ##########################
705
706#トップレベルの構文規則
707#コンポーネント記述
708component_description
709 : component_description specified_statement
710 | component_description location_information
711 |
712
713specified_statement
714 : statement
715 | spec_L statement_specifier_list spec_R statement
716 {
717 obj = val[3]
718 if obj.kind_of?( Cell ) || obj.kind_of?( Signature ) || obj.kind_of?( Celltype ) || obj.kind_of?( CompositeCelltype )then
719 # cell, signature 以外は、指定子を置けない
720 else
721 Generator.get_statement_specifier # クリア
722 Generator.error( "G1009 unexpected specifier" )
723 end
724 }
725 # これと同じ記述が composite_celltype にもある
726
727statement
728 : typedef
729 | const_statement
730 | namespace
731 | signature
732 | celltype
733 | cell
734 | composite_celltype
735 | enum_specifier ';'
736 | struct_specifier ';'
737 | region
738 | import
739 | import_C
740 | signature_plugin
741 | error # エラー回復ポイント
742
743
744statement_specifier_list
745 : statement_specifier
746 { Generator.add_statement_specifier val[0] }
747 | statement_specifier_list ',' statement_specifier
748 { Generator.add_statement_specifier val[2] }
749
750statement_specifier
751 : ALLOCATOR '(' alloc_list ')' # cell
752 { result = [ :ALLOCATOR, val[2] ] }
753 | CALLBACK # signature
754 { result = [ :CALLBACK ] }
755 | CONTEXT '(' string_literal_list ')' # signature
756 { result = [ :CONTEXT, val[2].val ] }
757 | DEVIATE # signature
758 { result = [ :DEVIATE ] }
759 | ID '(' constant_expression ')' # cell
760 { result = [ :ID, val[2] ] }
761 | PROTOTYPE # cell
762 { result = [ :PROTOTYPE ] }
763 | RESTRICT '(' restrict_list ')' # cell
764 { result = [ :RESTRICT, val[2] ] }
765 | SINGLETON { result = [:SINGLETON] } # celltype, composite
766 | IDX_IS_ID { result = [:IDX_IS_ID] } # celltype, composite (composite: no-effective)
767 | ACTIVE { result = [:ACTIVE] } # celltype, composite
768 | GENERATE '(' plugin_name ',' plugin_arg ')' # celltype, cell
769 { result = [:GENERATE, val[2].val, val[4].val] }
770
771alloc_list
772 : alloc { result = [ val[0] ] }
773 | alloc_list ',' alloc { result << val[2] }
774
775alloc
776 : IDENTIFIER '.' IDENTIFIER '.' IDENTIFIER '=' initializer
777 { result = [ :NORMAL_ALLOC, val[0], nil, val[2], val[4], val[6] ] }
778 | IDENTIFIER '[' constant_expression ']' '.' IDENTIFIER '.' IDENTIFIER '=' initializer
779 { result = [ :NORMAL_ALLOC, val[0], val[2], val[5], val[7], val[9] ] }
780# mikan 将来的な拡張 ('*' でまとめて指定可能とする)
781# | IDENTIFIER '.' IDENTIFIER '.' '*' '=' initializer
782# { result = [ val[0], val[ ], val[ ], val[ ] ] }
783# | IDENTIFIER '.' '*' '.' '*' '=' initializer
784# { result = [ val[0], val[ ], val[ ], val[ ] ] }
785
786restrict_list
787 : restrict
788 { result = [val[0]] }
789 | restrict_list ',' restrict
790 { result << val[2] }
791
792restrict
793 : port_name '=' '{' region_name_list '}'
794 { result = [ val[0].val, nil, val[3] ] }
795 | port_name '.' IDENTIFIER '=' '{' region_name_list '}'
796 { result = [ val[0].val, val[2].val, val[5] ] }
797
798region_name_list
799 : IDENTIFIER
800 { result = [val[0].val] }
801 | region_name_list ',' IDENTIFIER
802 { result << val[2].val }
803
804const_statement
805 : declaration # 定数定義
806 {
807 val[0].each { |decl|
808 decl.set_kind( :CONSTANT )
809 Namespace.new_const_decl( decl )
810 decl.check
811 }
812 }
813
814import_C
815 : IMPORT_C '(' STRING_LITERAL ')' ';'
816 {
817 @@import_C = true
818 Import_C.new( val[2] )
819 @@import_C = false
820 }
821 | IMPORT_C '(' STRING_LITERAL ',' STRING_LITERAL ')' ';'
822 {
823 @@import_C = true
824 Import_C.new( val[2], val[4] )
825 @@import_C = false
826 }
827
828import
829 : IMPORT '(' STRING_LITERAL ')' ';'
830 { Import.new( val[2] ) }
831 | IMPORT '(' AB_STRING_LITERAL ')' ';'
832 { Import.new( val[2], true ) }
833
834signature_plugin
835# : GENERATE '(' plugin_name ',' namespace_identifier ',' STRING_LITERAL ')' ';' #1ok signature plugin
836 : GENERATE '(' plugin_name ',' namespace_identifier ',' plugin_arg ')' ';' #1ok signature plugin
837 { Generate.new( val[2].val, val[4], val[6] ) }
838
839typedef
840 : TYPEDEF type_specifier_qualifier_list declarator_list ';'
841 {
842 val[2].each{ |i| # i:Decl
843 i.set_kind( :TYPEDEF )
844 }
845 Typedef.new_decl_list( val[1], val[2] )
846 val[2].each{ |i| # i:Decl
847 i.check
848 }
849 }
850 | TYPEDEF '[' typedef_specifier ']' type_specifier_qualifier_list declarator_list ';'
851 {
852 val[5].each{ |i| # i:Decl
853 i.set_kind( :TYPEDEF )
854 }
855 Typedef.new_decl_list( val[4], val[5] )
856 val[5].each{ |i| # i:Decl
857 i.check
858 }
859 }
860 # mikan typedef_specifier 未処置
861
862
863typedef_specifier
864 : STRING
865 | STRING '(' expression ')'
866
867declarator_list
868 : declarator
869 { result = [ val[0] ] }
870 | declarator_list ',' declarator
871 { result << val[2] }
872
873namespace
874 : NAMESPACE namespace_name '{' statement_list '}' ';'
875 {val[1].end_of_parse}
876
877namespace_name
878 : IDENTIFIER
879 {result = Namespace.new(val[0].val)}
880 # namespace インスタンスに statement を記憶させるためここで生成
881
882statement_list
883 : specified_statement
884 | statement_list specified_statement
885
886namespace_identifier
887 : IDENTIFIER { result = NamespacePath.new( val[0].val, false ) }
888 | '::' IDENTIFIER { result = NamespacePath.new( val[1].val, true ) }
889 | namespace_identifier '::' IDENTIFIER
890 { result = val[0].append!( val[2].val ) }
891
892#シグニチャ
893signature
894 : SIGNATURE signature_name '{' function_head_list '}' ';'
895 { result = val[1].end_of_parse( val[3] ) }
896
897signature_name
898 : IDENTIFIER
899 {result = Signature.new( val[0].val ) }
900
901function_head_list # result: function_head の配列
902# : function_head
903# { result = NamedList.new( val[0], "function" ) }
904 :
905 { result = NamedList.new( nil, "function" ) }
906 | function_head_list function_head
907 { result = val[0].add_item( val[1] ) }
908
909function_head
910 : type_specifier_qualifier_list declarator ';'
911 {
912 # val[1]: Decl
913 if val[1].is_function? then
914 result = FuncHead.new( val[1], val[0], false )
915 val[1].set_kind :FUNCHEAD
916 val[1].check
917 else
918 # mikan 関数の配列も以下のメッセージになる
919 Generator.error( "G1010 Not function" )
920 result = nil
921 end
922 }
923 | spec_L ONEWAY spec_R type_specifier_qualifier_list declarator ';'
924 {
925 if val[4].is_function? then
926 result = FuncHead.new( val[4], val[3], true )
927 else
928 Generator.error( "G1011 Not function" )
929 result = nil
930 end
931 }
932
933
934#セルタイプ
935celltype
936 : CELLTYPE celltype_name '{' celltype_statement_list '}' ';'
937 {
938 val[1].end_of_parse
939 result = val[1]
940 }
941
942celltype_name
943 : IDENTIFIER
944 { result = Celltype.new(val[0].val) }
945
946celltype_statement_list
947 : specified_celltype_statement
948 | celltype_statement_list specified_celltype_statement
949
950specified_celltype_statement
951 : celltype_statement
952 {
953 if val[0].kind_of? Port then
954 Celltype.new_port( val[0] )
955 end
956 }
957 | spec_L celltype_statement_specifier_list spec_R celltype_statement
958 {
959 if val[3].kind_of? Port then
960 val[3].set_specifier val[1] # 設定順序あり
961 Celltype.new_port( val[3] )
962 else
963 # Port 以外では指定子はエラー
964 Generator.error( "G1012 $1 : cannot put specifier here" , val[1] )
965 end
966 }
967
968celltype_statement
969 : port
970 | attribute
971 | var
972 | require
973 | factory
974# | error # エラー回復ポイント (#513 無限ループに陥るケースがあるので、ここでのエラー回復は取りやめ)
975
976celltype_statement_specifier_list
977 : celltype_statement_specifier
978 { result = [ val[0] ] }
979 | celltype_statement_specifier_list ',' celltype_statement_specifier
980 { result << val[2] }
981
982celltype_statement_specifier
983 : INLINE { result = [ :INLINE ] }
984 | ALLOCATOR '(' alloc_list2 ')' { result = [ :ALLOCATOR, val[2] ] }
985 | OPTIONAL { result = [ :OPTIONAL ] }
986 | REF_DESC { result = [ :REF_DESC ] }
987 | DYNAMIC { result = [ :DYNAMIC ] }
988 | OMIT { result = [ :OMIT ] }
989
990alloc_list2
991 : alloc2 { result = [ val[0] ] } # 受け口のアロケータ指定
992 | alloc { result = [ val[0] ] } # 内部セルのアロケータ指定
993 | alloc_list2 ',' alloc2 { result << val[2] }
994 | alloc_list2 ',' alloc { result << val[2] }
995
996alloc2
997 : IDENTIFIER '.' IDENTIFIER '=' initializer # 内部アロケータ (デバドラ向きアロケータ)指定
998 { result = [ :INTERNAL_ALLOC, val[0].val, val[2].val, val[4] ] }
999 | IDENTIFIER '.' IDENTIFIER '<=' initializer # 多段リレーモデル向きアロケータ指定
1000 { result = [ :RELAY_ALLOC, val[0].val, val[2].val, val[4] ] }
1001
1002
1003#呼び口、受け口
1004port
1005 : port_type namespace_signature_name port_name ';'
1006 { result = Port.new( val[2].val, val[1], val[0] ) }
1007 | port_type namespace_signature_name port_name '[' ']' ';'
1008 { result = Port.new( val[2].val, val[1], val[0], "[]" ) }
1009 | port_type namespace_signature_name port_name '[' array_size ']' ';'
1010 { result = Port.new(val[2].val, val[1], val[0], val[4]) }
1011 | port_type namespace_signature_name port_name '<=' namespace_identifier '.' IDENTIFIER ';' #1ok reverse require
1012 { result = Port.new( val[2].val, val[1], val[0], nil, val[4], val[ 6 ].val ) }
1013
1014port_type
1015 : CALL { result = :CALL }
1016 | ENTRY { result = :ENTRY }
1017
1018namespace_signature_name
1019 : namespace_identifier #1ok
1020 { result = val[0] }
1021
1022port_name
1023 : IDENTIFIER
1024
1025array_size
1026 : constant_expression
1027
1028
1029#属性
1030attribute
1031 : ATTRIBUTE '{' attribute_declaration_list '}' ';'
1032 { result = nil }
1033
1034attribute_declaration_list
1035 : attribute_declaration
1036 { Celltype.new_attribute( val[0] ) }
1037 | attribute_declaration_list attribute_declaration
1038 { Celltype.new_attribute( val[1] ) }
1039
1040
1041attribute_declaration
1042 : declaration
1043 {
1044 val[0].each{ |i| # i:Decl
1045 i.set_kind( :ATTRIBUTE )
1046 i.check
1047 }
1048 result = val[0]
1049 }
1050 | spec_L attribute_specifier spec_R declaration
1051 {
1052 val[3].each{ |i| # i:Decl
1053 i.set_kind( :ATTRIBUTE ) # 設定順序あり
1054 i.set_specifier_list( [val[1]] )
1055 i.check
1056 }
1057 result = val[3]
1058 }
1059
1060attribute_specifier
1061 : OMIT { result = [:OMIT] }
1062 | SIZE_IS '(' expression ')' { result = [:SIZE_IS,val[2]] }
1063 | CHOICE '=' '{' choice_list '}' { result = [:CHOICE,val[3]] }
1064
1065choice_list
1066 : choice_list ',' choice_element { result << val[2] }
1067 | choice_element { result = [ val[0] ] }
1068
1069choice_element
1070 : STRING_LITERAL
1071
1072#内部変数
1073var
1074 : VAR '{' var_declaration_list '}' ';'
1075 { result = nil }
1076
1077var_declaration_list
1078 : var_declaration
1079 { Celltype.new_var( val[0] ) }
1080 | var_declaration_list var_declaration
1081 { Celltype.new_var( val[1] ) }
1082
1083var_declaration
1084 : declaration
1085 {
1086 val[0].each{ |i| # i:Decl
1087 i.set_kind( :VAR )
1088 i.check
1089 }
1090 }
1091 | spec_L var_specifier spec_R declaration
1092 {
1093 val[3].each{ |i| # i:Decl
1094 i.set_kind( :VAR ) # 設定順序あり
1095 i.set_specifier_list( [val[1]] )
1096 i.check
1097 }
1098 result = val[3]
1099 }
1100
1101var_specifier
1102 : SIZE_IS '(' expression ')' { result = [:SIZE_IS,val[2]] }
1103
1104# リクワイア
1105require
1106 : REQUIRE namespace_identifier '.' IDENTIFIER';' # mikan namespace #1
1107 {
1108 Celltype.new_require( val[1], val[3] )
1109 }
1110 | REQUIRE IDENTIFIER '=' namespace_identifier '.' IDENTIFIER';' #1
1111 {
1112 Celltype.new_require( val[3], val[5], val[1].val )
1113 }
1114
1115#ファクトリ
1116factory
1117 : factory_head '{' factory_function_list '}' ';'
1118
1119factory_head
1120 : FACTORY { Factory.set_f_celltype( false ) }
1121 | CTFACTORY { Factory.set_f_celltype( true ) }
1122
1123factory_function_list
1124 : # 空
1125 | factory_function_list factory_function
1126
1127factory_function
1128 : factory_function_name '(' constant_expression ',' constant_expression ')' ';'
1129 { Factory.new( val[0].val, val[2], val[4], nil ) }
1130 | factory_function_name '(' constant_expression ',' constant_expression ',' arg_list ')' ';'
1131 { Factory.new( val[0].val, val[2], val[4], val[6] ) }
1132
1133factory_function_name
1134 : IDENTIFIER
1135
1136arg_list # factory の write 関数の第三引数以降
1137 : IDENTIFIER
1138 { result = [ [ :IDENTIFIER, val[0].val ] ] }
1139 | arg_list ',' IDENTIFIER
1140 { result << [ :IDENTIFIER, val[2].val ] }
1141 | STRING_LITERAL
1142 { result = [ [ :STRING_LITERAL, val[0].val ] ] }
1143 | arg_list ',' STRING_LITERAL
1144 { result << [ :STRING_LITERAL, val[2].val ] }
1145
1146#セル生成
1147cell
1148 : CELL namespace_celltype_name cell_name '{'
1149 { Cell.new_def }
1150 join_list '}' ';'
1151 { result = Cell.end_of_parse true }
1152 | CELL namespace_celltype_name cell_name ';' # oyama プロトタイプ宣言
1153 { result = Cell.end_of_parse false }
1154
1155namespace_celltype_name
1156 : namespace_identifier
1157 { result = Cell.new(val[0]) }
1158
1159cell_name
1160 : IDENTIFIER
1161 { result = Cell.set_name(val[0].val) }
1162
1163join_list
1164 : # 空行 061007
1165 | join_list specified_join
1166 | join_list reverse_join
1167
1168specified_join
1169 : spec_L join_specifier_list spec_R join
1170 { val[3].set_specifier_list( val[1] ) }
1171 | join
1172 { val[0].set_specifier_list( [] ) }
1173
1174join_specifier_list
1175 : join_specifier_list ',' join_specifier
1176 { result << val[2] }
1177 | join_specifier
1178 { result = [val[0]] }
1179
1180join_specifier
1181 : THROUGH '(' plugin_name ',' plugin_arg ')'
1182 { result = [ :THROUGH, val[2], val[4] ] }
1183
1184plugin_name
1185 : IDENTIFIER { result = val[0] }
1186
1187plugin_arg
1188 : string_literal_list
1189
1190join
1191# : cae_name '=' expression ';'
1192# {
1193# result = Join.new( val[0].val, nil, val[2] )
1194# Cell.new_join( result, true )
1195# }
1196# | cae_name '[' ']' '=' expression ';'
1197 : cae_name '[' ']' '=' expression ';'
1198 {
1199 result = Join.new( val[0].val, -1, val[4] )
1200 Cell.new_join( result, true )
1201 }
1202 | cae_name '[' array_index ']' '=' expression ';'
1203 {
1204 result = Join.new( val[0].val, val[2], val[5] )
1205 Cell.new_join( result, true )
1206 }
1207 | cae_name '=' initializer ';' # 初期化子： '{', '}' も可
1208 {
1209 result = Join.new( val[0].val, nil, val[2] )
1210 Cell.new_join( result, true )
1211 }
1212 | cae_name '=' COMPOSITE '.' IDENTIFIER ';'
1213 {
1214 result = Join.new( val[0].val, nil, [ :COMPOSITE, val[4] ] )
1215 Cell.new_join( result, true )
1216 }
1217
1218cae_name # cae: callport, attribute, entryport
1219 : IDENTIFIER
1220
1221reverse_join
1222 # non-array <= non-array
1223 : cae_name '<=' namespace_identifier '.' IDENTIFIER ';'
1224 {
1225 rj = ReverseJoin.new( val[0].val, nil, val[2], val[4].val )
1226 Cell.new_reverse_join( rj )
1227 }
1228 # non-array <= array
1229 | cae_name '<=' namespace_identifier '.' IDENTIFIER '[' expression ']' ';'
1230 {
1231 rj = ReverseJoin.new( val[0].val, nil, val[2], val[4].val, val[6] )
1232 Cell.new_reverse_join( rj )
1233 }
1234 # array <= non-array
1235 | cae_name '[' array_index ']' '<=' namespace_identifier '.' IDENTIFIER ';'
1236 {
1237 rj = ReverseJoin.new( val[0].val, val[2], val[5], val[7].val )
1238 Cell.new_reverse_join( rj )
1239 }
1240 # array <= array
1241 | cae_name '[' array_index ']' '<=' namespace_identifier '.' IDENTIFIER '[' expression ']' ';'
1242 {
1243 rj = ReverseJoin.new( val[0].val, val[2], val[5], val[7].val, val[9] )
1244 Cell.new_reverse_join( rj )
1245 }
1246
1247
1248array_index
1249 : constant_expression
1250
1251#複合種
1252composite_celltype
1253 : COMPOSITE composite_celltype_name '{' composite_celltype_statement_list '}' ';'
1254 {
1255 CompositeCelltype.end_of_parse
1256 result = val[1]
1257 }
1258
1259composite_celltype_name
1260 : IDENTIFIER
1261 { result = CompositeCelltype.new(val[0].val) }
1262
1263composite_celltype_statement_list
1264 : specified_composite_celltype_statement
1265 | composite_celltype_statement_list specified_composite_celltype_statement
1266
1267specified_composite_celltype_statement
1268 : composite_celltype_statement
1269 {
1270 if val[0].kind_of?( Port ) then
1271 CompositeCelltype.new_port( val[0] ) # 遅延して登録
1272 end
1273 }
1274 | spec_L composite_celltype_statement_specifier_list spec_R composite_celltype_statement
1275 {
1276 if val[3].kind_of?( Port ) then
1277 # port 以外 val[3] に有効な値が入っていないので、以下のメソッドを適用できない
1278 # 現状 port, cell 以外は指定子を受け付けない
1279 # （しかし将来他の文も指定子を受け付ける可能性があるので、この位置に記述する）
1280 val[3].set_specifier( Generator.get_statement_specifier )
1281 CompositeCelltype.new_port( val[3] ) # 遅延して登録 (set_specifier 後)
1282 elsif val[3].kind_of?( Cell ) then
1283 # Cell.end_of_parse にて設定
1284 else
1285 Generator.get_statement_specifier # クリア
1286 Generator.error( "G1013 unexpected specifier" )
1287 end
1288 }
1289
1290composite_celltype_statement
1291 : composite_port
1292 | composite_attribute
1293 | internal_cell
1294 | export_join
1295# | error # エラー回復ポイント (#513 無限ループに陥るケースがあるので、ここでのエラー回復は取りやめ)
1296
1297composite_celltype_statement_specifier_list
1298 : composite_celltype_statement_specifier
1299 {
1300 Generator.add_statement_specifier val[0]
1301 result = [ val[0] ]
1302 }
1303
1304composite_celltype_statement_specifier
1305 : ALLOCATOR '(' alloc_list2 ')' { result = [ :ALLOCATOR, val[2] ] }
1306 | OMIT { result = [ :OMIT ] }
1307 | OPTIONAL { result = [ :OPTIONAL ] }
1308 | REF_DESC { result = [ :REF_DESC ] }
1309 | DYNAMIC { result = [ :DYNAMIC ] }
1310
1311composite_port
1312 : port
1313 {
1314 # CompositeCelltype.new_port( val[0] )
1315 result = val[0]
1316 }
1317
1318#属性
1319composite_attribute
1320 : ATTRIBUTE '{' composite_attribute_declaration_list '}' ';'
1321 { result = nil }
1322
1323composite_attribute_declaration_list
1324 : attribute_declaration
1325 { CompositeCelltype.new_attribute( val[0] ) }
1326 | composite_attribute_declaration_list attribute_declaration
1327 { CompositeCelltype.new_attribute( val[1] ) }
1328
1329internal_cell
1330 : CELL internal_namespace_celltype_name
1331 internal_cell_name '{'
1332 { Cell.new_def }
1333 internal_join_list '}' ';'
1334 { result = Cell.end_of_parse true }
1335 | CELL internal_namespace_celltype_name internal_cell_name ';'
1336 { result = Cell.end_of_parse false }
1337
1338
1339internal_namespace_celltype_name
1340 : namespace_identifier
1341 { Cell.new(val[0],true) }
1342
1343internal_cell_name
1344 : IDENTIFIER
1345 { Cell.set_name(val[0].val) }
1346
1347
1348internal_join_list
1349 : # 空行 061007
1350 | internal_join_list specified_join
1351 | internal_join_list external_join
1352
1353external_join # cell 内に記述する呼び口の外部結合
1354 : internal_cell_elem_name '=>' COMPOSITE '.' export_name ';'
1355 { Cell.external_join( val[0].val, val[4].val, true ) }
1356 | internal_cell_elem_name '=>' export_name ';'
1357 { Cell.external_join( val[0].val, val[2].val, false ) }
1358 # 以前の文法では、呼び口側も cell の外に記述していた
1359 # その時の実装を
1360
1361export_join # cell 外に記述する受け口の外部結合
1362 : export_name '=>' internal_ref_cell_name '.' internal_cell_elem_name ';'
1363 {
1364 CompositeCelltype.new_join( val[0].val,
1365 val[2].val, val[4].val, :ENTRY )
1366 }
1367 | COMPOSITE '.' export_name '=>' internal_ref_cell_name '.' internal_cell_elem_name ';'
1368 {
1369 CompositeCelltype.new_join( val[2].val,
1370 val[4].val, val[6].val, :ENTRY )
1371 }
1372
1373export_name
1374 : IDENTIFIER
1375
1376internal_ref_cell_name
1377 : IDENTIFIER
1378
1379internal_cell_elem_name
1380 : IDENTIFIER
1381
1382# リージョン
1383region
1384 : spec_L region_specifier_list spec_R REGION region_name '{' region_statement '}' ';'
1385 { Region.end_of_parse }
1386 | REGION region_name '{' region_statement '}' ';'
1387 { Region.end_of_parse }
1388
1389
1390region_specifier_list
1391 : region_specifier
1392 | region_specifier_list ',' region_specifier
1393
1394region_specifier
1395 : IN_THROUGH '(' plugin_name ',' plugin_arg ')'
1396 { Region.new_in_through( val[2].val, val[4].val ) }
1397 | IN_THROUGH '(' ')' # in 許可
1398 { Region.new_in_through }
1399 | OUT_THROUGH '(' plugin_name ',' plugin_arg ')'
1400 { Region.new_out_through( val[2].val, val[4].val ) }
1401 | OUT_THROUGH '(' ')' # out 許可
1402 { Region.new_out_through() }
1403 | TO_THROUGH '(' namespace_region_name ',' plugin_name ',' plugin_arg ')'
1404 { Region.new_to_through( val[2], val[4].val, val[6].val ) }
1405 | TO_THROUGH '('namespace_region_name ')' # to 許可
1406 { Region.new_to_through( val[2], nil, nil ) }
1407 | NODE
1408 { Region.set_type( :NODE ) }
1409 | LINKUNIT
1410 { Region.set_type( :LINKUNIT ) }
1411 | DOMAIN '(' IDENTIFIER ',' STRING_LITERAL ')'
1412 { Region.set_domain( val[2].val, val[4] ) }
1413 | CLASS '(' IDENTIFIER ')'
1414 { Region.set_type( :CLASS, val[2].val ) }
1415
1416region_name
1417 : IDENTIFIER
1418 { result = Region.new( val[0].val ) }
1419
1420region_statement
1421 :
1422 | region_statement region_cell
1423 | region_statement region
1424
1425region_cell
1426 : cell
1427 | spec_L statement_specifier_list spec_R cell
1428 {
1429 obj = val[3]
1430 if obj.kind_of?( Cell ) then
1431 else
1432 Generator.get_statement_specifier # クリア
1433 Generator.error( "G9999 unexpected specifier" )
1434 end
1435 }
1436# | spec_L region_cell_specifier_list spec_R cell
1437
1438# region_cell_specifier_list
1439# : region_cell_specifier
1440# { Generator.add_statement_specifier val[0] }
1441# | region_cell_specifier_list region_cell_specifier
1442# { Generator.add_statement_specifier val[2] }
1443
1444# region_cell_specifier
1445# : ALLOCATOR '(' alloc_list ')'
1446# { result = [ :ALLOCATOR, val[2] ] }
1447
1448
1449namespace_region_name
1450 : :IDENTIFIER
1451 { result = [ val[0].val ] } # mikan 配列である必要はない
1452# : namespace_identifier
1453
1454# 指定子の括弧 (in, out などのキーワード切り替えのため分離)
1455spec_L
1456 : '[' { set_in_specifier }
1457spec_R
1458 : ']' { unset_in_specifier }
1459
1460# location information
1461location_information
1462 : __LOCATION_INFORMATION__ '{' cell_location_join_location_list '}'
1463
1464cell_location_join_location_list
1465 : cell_location_join_location_list cell_location
1466 | cell_location_join_location_list join_location
1467 |
1468
1469cell_location
1470 : __CELL__ namespace_identifier '(' constant_expression ',' constant_expression ',' constant_expression ',' constant_expression ')' '{' port_location_list '}'
1471 {
1472 TECSGEN::Cell_location.new( val[1], val[3], val[5], val[7], val[9], val[12] )
1473 }
1474
1475port_location_list
1476 : port_location_list port_location
1477 {
1478 result = val[0] << val[1]
1479 }
1480 |
1481 { result = [] }
1482
1483port_location
1484 : IDENTIFIER '(' IDENTIFIER ',' constant_expression ')'
1485 { result = [ val[0], val[2], val[3] ] }
1486
1487join_location # mikan port array
1488 : __JOIN__ '(' namespace_identifier '.' IDENTIFIER '=>' namespace_identifier '.' IDENTIFIER ')' '{' bar_list '}'
1489 {
1490 TECSGEN::Join_location.new( val[2], val[4], val[6], val[8], val[11] )
1491 }
1492
1493bar_list
1494 : bar_list IDENTIFIER '(' constant_expression ')'
1495 {
1496 result = val[0] << [ val[1], val[3] ]
1497 }
1498 | { result = [] }
1499
1500
1501end
1502
1503---- inner
1504
1505 RESERVED = {
1506 # keyword
1507 'namespace' => :NAMESPACE,
1508 'signature' => :SIGNATURE,
1509 'celltype' => :CELLTYPE,
1510 'cell' => :CELL,
1511 'attr' => :ATTRIBUTE,
1512 'var' => :VAR,
1513 'call' => :CALL,
1514 'entry' => :ENTRY,
1515 'composite' => :COMPOSITE,
1516 'require' => :REQUIRE,
1517 'factory' => :FACTORY,
1518 'FACTORY' => :CTFACTORY,
1519 'typedef' => :TYPEDEF,
1520 'struct' => :STRUCT,
1521 'region' => :REGION,
1522 'import' => :IMPORT,
1523 'import_C' => :IMPORT_C,
1524 'generate' => :GENERATE,
1525
1526 # types
1527 'void' => :VOID,
1528
1529 'volatile'=> :VOLATILE,
1530 'const' => :CONST,
1531
1532 'signed' => :SIGNED,
1533 'unsigned'=> :UNSIGNED,
1534
1535 'int8_t' => :INT8_T,
1536 'int16_t' => :INT16_T,
1537 'int32_t' => :INT32_T,
1538 'int64_t' => :INT64_T,
1539 'int128_t' => :INT128_T,
1540 'uint8_t' => :UINT8_T,
1541 'uint16_t' => :UINT16_T,
1542 'uint32_t' => :UINT32_T,
1543 'uint64_t' => :UINT64_T,
1544 'uint128_t' => :UINT128_T,
1545
1546 'float32_t' => :FLOAT32_T,
1547 'double64_t' => :DOUBLE64_T,
1548 'bool_t' => :BOOL_T,
1549 'char_t' => :CHAR_T,
1550 'schar_t' => :SCHAR_T,
1551 'uchar_t' => :UCHAR_T,
1552
1553 # unrecommened types
1554 'int' => :INT,
1555# 'intptr' => :INTPTR,
1556 'short' => :SHORT,
1557 'long' => :LONG,
1558
1559 # obsolete types
1560 'char' => :CHAR,
1561# 'int8' => :INT8,
1562# 'int16' => :INT16,
1563# 'int32' => :INT32,
1564# 'int64' => :INT64,
1565# 'int128' => :INT128,
1566# 'float' => :FLOAT,
1567# 'double' => :DOUBLE,
1568# 'bool' => :BOOL,
1569
1570 'enum' => :ENUM,
1571 'enum8' => :ENUM8,
1572 'enum16' => :ENUM16,
1573 'enum32' => :ENUM32,
1574 'enum64' => :ENUM64,
1575
1576 'true' => :TRUE,
1577 'false' => :FALSE,
1578
1579 'C_EXP' => :C_EXP,
1580
1581 'Descriptor' => :DESCRIPTOR,
1582
1583 # location information for TECSCDE
1584 '__location_information__' => :__LOCATION_INFORMATION__,
1585 '__cell__' => :__CELL__,
1586 '__join__' => :__JOIN__,
1587 }
1588
1589 # 指定子 '[]' 内でのみ使用できるキーワード
1590 RESERVED2 = {
1591 # specifier
1592 'id' => :ID,
1593
1594 # signature
1595 'callback' => :CALLBACK,
1596 'context' => :CONTEXT,
1597 'deviate' => :DEVIATE,
1598
1599 # celltype
1600 'singleton' => :SINGLETON,
1601 'idx_is_id' => :IDX_IS_ID,
1602 'active' => :ACTIVE,
1603
1604 # port (entry)
1605 'inline' => :INLINE,
1606 'ref_desc' => :REF_DESC, # call も可
1607
1608 # port (call)
1609 'optional' => :OPTIONAL,
1610 'dynamic' => :DYNAMIC,
1611
1612 # port (call), attribute
1613 'omit' => :OMIT,
1614
1615 # attribute
1616 'choice' => :CHOICE,
1617
1618 # cell
1619 'allocator' => :ALLOCATOR,
1620 'prototype' => :PROTOTYPE,
1621 'restrict' => :RESTRICT,
1622
1623 # FuncType
1624 'oneway' => :ONEWAY,
1625
1626 # parameter (basic)
1627 'in' => :IN,
1628 'out' => :OUT,
1629 'inout' => :INOUT,
1630 'send' => :SEND,
1631 'receive' => :RECEIVE,
1632
1633 # parameter
1634 'size_is' => :SIZE_IS,
1635 'count_is' => :COUNT_IS,
1636 'string' => :STRING,
1637 'nullable' => :NULLABLE,
1638
1639 'through' => :THROUGH,
1640 'in_through' => :IN_THROUGH,
1641 'out_through' => :OUT_THROUGH,
1642 'to_through' => :TO_THROUGH,
1643
1644 'node' => :NODE,
1645 'linkunit' => :LINKUNIT ,
1646 'domain' => :DOMAIN,
1647 'class' => :CLASS,
1648 }
1649
1650 # 再帰的なパーサのためのスタック
1651 @@generator_nest = -1
1652 @@generator_stack = []
1653 @@current_locale = []
1654
1655 # import_C 中である
1656 @@import_C = false
1657
1658 # すべての構文解析が完了した
1659 @@b_end_all_parse = false
1660
1661 def self.parse( file_name, plugin = nil, b_reuse = false )
1662 # パーサインスタンスを生成(別パーサで読み込む)
1663 parser = Generator.new
1664
1665 # plugin から import されている場合の plugin 設定
1666 parser.set_plugin plugin
1667
1668 # reuse フラグを設定
1669 parser.set_reuse b_reuse
1670
1671 # cdl をパース
1672 parser.parse( [file_name] )
1673
1674 # 終期化　パーサスタックを戻す
1675 parser.finalize
1676 end
1677
1678 def finalize
1679
1680 # mikan Namespace.pop
1681 Namespace.pop
1682 Signature.pop
1683 Celltype.pop
1684 Cell.pop
1685 CompositeCelltype.pop
1686 end
1687
1688 def set_plugin( plugin )
1689 @plugin = plugin
1690 end
1691
1692 def self.get_plugin
1693 if @@generator_stack[@@generator_nest] then
1694 # tecsgen 引数の cdl が import される場合は nil
1695 return @@generator_stack[@@generator_nest].get_plugin
1696 else
1697 return nil
1698 end
1699 end
1700
1701 def get_plugin
1702 @plugin
1703 end
1704
1705 def set_reuse( b_reuse )
1706 @b_reuse = b_reuse
1707 end
1708
1709 def self.is_reuse?
1710 if @@generator_stack[@@generator_nest] then
1711 # tecsgen 引数の cdl が import される場合は nil
1712 return @@generator_stack[@@generator_nest].is_reuse?
1713 else
1714 return false
1715 end
1716 end
1717
1718 def is_reuse?
1719 @b_reuse
1720 end
1721
1722 def parse(files)
1723
1724 # mikan Namespace.push
1725 Namespace.push
1726 Signature.push
1727 Celltype.push
1728 Cell.push
1729 CompositeCelltype.push
1730
1731 @@generator_nest += 1
1732 @@generator_stack[@@generator_nest] = self
1733 @in_specifier = false
1734
1735 begin
1736
1737 @q = []
1738 b_in_comment = false
1739 b_in_string = false
1740
1741 # euc のコメントを utf8 として扱うと、コメントの終わりを誤る問題の対策
1742 TECS_LANG::set_kcode_binary
1743
1744 files.each {|file|
1745 lineno = 1
1746 begin
1747 string = ""
1748#2.0 IO.foreach(file) {|line|
1749 TECSIO.foreach(file) {|line|
1750 col = 1
1751# line.rstrip! 改行含む文字列を扱うようになったので、ここで空白を取り除けなくなった
1752
1753 until line.empty?
1754
1755 if b_in_comment
1756 case line
1757 # コメント終了
1758 when /\A\*\//
1759 b_in_comment = false
1760 when /\A./
1761 ;
1762 when /\s+/ # line.rstrip! を止めたため \n などの空白文字とまっちするルールが必要になった
1763 ;
1764 end
1765 elsif b_in_string
1766 if line =~ /\A(?:[^"\\]|\\.)*"/
1767 string = "#{string}#{$&}"
1768 @q << [:STRING_LITERAL, Token.new(string, file, lineno, col)]
1769 b_in_string = false
1770 elsif line =~ /\A.*\\\n/ # 改行 \n は '.' にマッチしない
1771 string += $&
1772 elsif line =~ /\A.*\n/ # 改行 \n は '.' にマッチしない
1773 string += line
1774 # この位置では error メソッドは使えない (token 読出し前)
1775 puts "error: #{file} line #{lineno}: string literal has newline without escape"
1776 @@n_error += 1
1777 end
1778 else
1779 case line
1780 # 空白、プリプロセスディレクティブ
1781 when /\A\s+/
1782 ;
1783 # 識別子
1784 when /\A[a-zA-Z_]\w*/
1785 word = $&
1786 @q << [RESERVED[word] || :IDENTIFIER, Token.new(word.intern, file, lineno, col)]
1787 # 16 進数定数
1788 when /\A0x[0-9A-Fa-f]+/
1789 @q << [:HEX_CONSTANT, Token.new($&, file, lineno, col)]
1790 # 8 進数定数
1791 when /\A0[0-7]+/
1792 @q << [:OCTAL_CONSTANT, Token.new($&, file, lineno, col)]
1793 # 浮動小数定数
1794 when /\A[0-9]+\.([0-9]*)?([Ee][+-]?[0-9]+)?/
1795 @q << [:FLOATING_CONSTANT, Token.new($&, file, lineno, col)]
1796 # 整数定数
1797 when /\A\d+/
1798 @q << [:INTEGER_CONSTANT, Token.new($&.to_i, file, lineno, col)]
1799 # 文字定数
1800 when /\A'(?:[^'\\]|\\.)'/
1801 @q << [:CHARACTER_LITERAL, Token.new($&, file, lineno, col)]
1802 # 文字列
1803# "#include #include #include \"../systask/logtask.cfg\" 最後の " 忘れ)で無限ループ
1804# when /\A"(?:[^"\\]+|\\.)*"/
1805 when /\A"(?:[^"\\]|\\.)*"/ # これはうまく行くようだ
1806 @q << [:STRING_LITERAL, Token.new($&, file, lineno, col)]
1807 # 文字列 (改行あり)
1808 when /\A"(?:[^"\\]|\\.)*\\\n$/
1809 string = $&
1810 b_in_string = true
1811 # 文字列 (改行あり, escape なし)
1812 when /\A("(?:[^"\\]|\e\.)*)\n$/
1813 string = $1 + "\\\n"
1814 b_in_string = true
1815 # この位置では error メソッドは使えない (token 読出し前) # mikan cdl_error ではない
1816 puts "error: #{file} line #{lineno}: string literal has newline without escape"
1817 @@n_error += 1
1818 # 山括弧で囲まれた文字列
1819 when /\A<[0-9A-Za-z_\. \/]+>/ # AB: angle bracke
1820 @q << [:AB_STRING_LITERAL, Token.new($&, file, lineno, col)]
1821 # 行コメント
1822 when /\A\/\/.*$/
1823 # 読み飛ばすだけ
1824 # コメント開始
1825 when /\A\/\*/
1826 b_in_comment = true
1827 # '>>', '<<' など
1828 when /\A>>/, /\A<</, /\A==/, /\A!=/, /\A\&\&/, /\A\|\|/
1829 @q << [$&, Token.new($&, file, lineno, col)]
1830 when /\A::/, /\A=>/, /\A<=/, /\A>=/
1831 @q << [$&, Token.new($&, file, lineno, col)]
1832 # '(', ')' など一文字の記号、または未知の記号
1833 when /\A./
1834 @q << [$&, Token.new($&, file, lineno, col)]
1835 else
1836 raise
1837 end
1838 end
1839
1840 line = $'
1841 col += $&.length
1842 end
1843
1844 lineno += 1
1845 }
1846
1847 rescue => evar
1848 Generator.error( "G1014 while open or reading \'$1\'" , file )
1849 if $debug then
1850 p puts( evar )
1851 pp $@
1852 end
1853 end
1854 }
1855
1856 # 終了の印
1857 @q << nil
1858
1859 @yydebug = true
1860 do_parse
1861
1862 ensure
1863 @@generator_nest -= 1
1864 TECS_LANG::reset_kcode
1865 end
1866
1867 end
1868
1869 def next_token
1870 token = @q.shift
1871
1872 if token then
1873 @@current_locale[@@generator_nest] = token[1].locale
1874
1875 if token[0] == :IDENTIFIER then
1876 # TYPE_NAME トークンへ置換え
1877 if Namespace.is_typename?( token[1].val ) then
1878 token[0] = :TYPE_NAME
1879 elsif @in_specifier && RESERVED2[ token[1].val.to_s ] then
1880 # 指定子キーワード（ '[', ']' 内でのみ有効)
1881 token[0] = RESERVED2[ token[1].val.to_s ]
1882 end
1883 end
1884
1885 if $debug then # 070107 token 無効時ここを通さないようした (through 対応 -d の時に例外発生)
1886 locale = @@current_locale[@@generator_nest]
1887 if token then
1888 print( "#{locale[0]}: line #{locale[1]} : #{token[0]} '#{token[1].val}'\n" )
1889 else
1890 print( "#{locale[0]}: line #{locale[1]} : EOF\n" )
1891 end
1892 end
1893 else
1894 token = [ false, false ]
1895 end
1896
1897 token
1898 end
1899
1900 def on_error(t, v, vstack)
1901 # p t, token_to_str(t), vstack
1902 if token_to_str(t) == "$end" then
1903 Generator.error( "G1015 Unexpected EOF" )
1904 else
1905 Generator.error( "G1016 syntax error near \'$1\'" , v.val )
1906 end
1907 end
1908
1909 def self.current_locale
1910 @@current_locale[ @@generator_nest ]
1911 end
1912
1913 @@n_error = 0
1914 @@n_warning = 0
1915
1916 # このメソッドは構文解析、意味解析からのみ呼出し可（コード生成でエラー発生は不適切）
1917 def self.error( msg, *arg )
1918 locale = nil
1919 self.error2( locale, msg, *arg )
1920 end
1921
1922 def self.error2( locale, msg, *arg )
1923 @@n_error += 1
1924
1925 msg = TECSMsg.get_error_message( msg )
1926 # $1, $2, ... を arg で置換
1927 count = 1
1928 arg.each{ |a|
1929 str = TECSIO.str_code_convert( msg, a.to_s )
1930 msg.sub!( /\$#{count}/, str )
1931 count += 1
1932 }
1933
1934 # import_C の中でのエラー？
1935 if @@import_C then
1936 C_parser.error( msg )
1937 else
1938
1939 # Node の記憶する 位置 (locale) を使用した場合、変更以前に比べ、
1940 # 問題発生箇所と異なる位置にエラーが出るため、構文解析中のエラー
1941 # は、解析中の位置を出力する．(new_XXX で owner が子要素のチェッ
1942 # クをすると owner の行番号が出てしまう点で、ずれが生じている)
1943
1944 if @@b_end_all_parse == false || locale == nil then
1945 locale = @@current_locale[ @@generator_nest ]
1946 end
1947 if locale then
1948 Console.puts "error: #{locale[0]}: line #{locale[1]} #{msg}"
1949 else
1950 Console.puts "error: #{msg}"
1951 end
1952 end
1953 end
1954
1955 # このメソッドは構文解析、意味解析からのみ呼出し可（コード生成でウォーニング発生は不適切）
1956 def self.warning( msg, *arg )
1957 locale = nil
1958 self.warning2( locale, msg, *arg )
1959 end
1960
1961 def self.warning2( locale, msg, *arg )
1962 @@n_warning += 1
1963
1964 msg = TECSMsg.get_warning_message( msg )
1965 # $1, $2, ... を arg で置換
1966 count = 1
1967 arg.each{ |a|
1968 str = TECSIO.str_code_convert( msg, a.to_s )
1969 msg.sub!( /\$#{count}/, str )
1970 count += 1
1971 }
1972
1973 # import_C の中でのウォーニング？
1974 if @@import_C then
1975 C_parser.warning( msg )
1976 else
1977 if @@b_end_all_parse == false || locale == nil then
1978 locale = @@current_locale[ @@generator_nest ]
1979 end
1980 if locale then
1981 Console.puts "warning: #{locale[0]}: line #{locale[1]} #{msg}"
1982 else
1983 Console.puts "warning: #{msg}"
1984 end
1985 end
1986 end
1987
1988 def self.get_n_error
1989 @@n_error
1990 end
1991
1992 def self.get_n_warning
1993 @@n_warning
1994 end
1995
1996 def self.get_nest
1997 @@generator_nest
1998 end
1999
2000 #=== '[' specifier 始め
2001 def set_in_specifier
2002 # p "set_in_specifier"
2003 @in_specifier = true
2004 end
2005
2006 #=== ']' specifier 終わり
2007 def unset_in_specifier
2008 # p "unset_in_specifier"
2009 @in_specifier = false
2010 end
2011
2012 # statement_specifier は構文解釈途中で参照したいため
2013 @@statement_specifier_stack = []
2014 def self.add_statement_specifier( ss )
2015 if( @@statement_specifier_stack[ @@generator_nest ] == nil )then
2016 @@statement_specifier_stack[ @@generator_nest ] = [ ss ]
2017 else
2018 @@statement_specifier_stack[ @@generator_nest ] << ss
2019 end
2020 end
2021
2022
2023 def self.get_statement_specifier
2024 spec_list = @@statement_specifier_stack[ @@generator_nest ]
2025 @@statement_specifier_stack[ @@generator_nest ] = nil
2026 return spec_list
2027 end
2028
2029 #=== すべての構文解析が完了したことを報告
2030 def self.end_all_parse
2031 @@b_end_all_parse = true
2032 end
2033
2034---- footer
2035
2036
2037# ファイル => INCLUDE("header")の配列
2038Include = Hash.new {|hash, key| hash[key] = []}
2039
2040
2041class Token
2042
2043 attr_accessor :val, :file, :lineno, :col
2044
2045 def initialize(val, file, lineno, col)
2046 @val = val
2047 @file = file
2048 @lineno = lineno
2049 @col = col
2050
2051 end
2052
2053 def to_s
2054 @val.to_s
2055 end
2056
2057 def to_sym
2058 @val.to_sym
2059 end
2060
2061 def get_name
2062 @val
2063 end
2064
2065 def locale
2066 [@file, @lineno, @col]
2067 end
2068
2069 def eql?(other)
2070 if other.is_a? Symbol
2071 @val == other
2072 elsif other.is_a? Token
2073 @val == other.val
2074 elsif other.is_a? String
2075 @val.to_s == other
2076 else
2077 raise ArgumentError
2078 end
2079 end
2080
2081 alias == eql?
2082
2083 def show_tree( indent )
2084 indent.times { print " " }
2085 print "#{@val}\n"
2086 end
2087
2088end
2089
2090#= TECSIO
2091# Ruby2.0(1.9) 対応に伴い導入したクラス
2092# SJIS 以外では、ASCII-8BIT として入力する
2093class TECSIO
2094 def self.foreach(file) # ブロック引数 { |line| }
2095 pr = Proc.new # このメソッドのブロック引数を pr に代入
2096 if $b_no_kcode then
2097 msg = "E".encode $Ruby19_File_Encode
2098 if( $Ruby19_File_Encode == "Shift_JIS" )
2099
2100 # Shift JIS は、いったん Windows-31J として読み込ませ、Shift_JIS に変換させる．
2101 # コメント等に含まれる SJIS に不適切な文字コードは '?' または REPLACEMENT CHARACTER に変換される．
2102 # EUC や UTF-8 で記述された CDL が混在していても、Ruby 例外が発生することなく処理を進めることができる．
2103 # 文字コード指定が SJIS であって、文字列リテラルの中に、文字コードがSJIS 以外の非 ASCII が含まれている場合、
2104 # Ruby 1.8 の tecsgen では文字コード指定に影響なく処理されたものが、Ruby 1.9 以降では '?' に置き換わる可能性がある．
2105
2106 mode = "r:Windows-31J"
2107 else
2108 mode = "r:#{$Ruby19_File_Encode}"
2109 end
2110 # mode = "r"
2111 else
2112 msg = "E"
2113 mode = "r"
2114 end
2115
2116 f = File.open( file, mode )
2117 begin
2118 f.each{ |line|
2119 # dbgPrint line
2120 line = str_code_convert( msg, line )
2121 pr.call( line )
2122 }
2123 ensure
2124 f.close
2125 end
2126 end
2127
2128 #=== 文字コードが相違する場合一致させる
2129 # msg と str の文字コードが相違する場合、str を msg の文字コードに変換する
2130 # 変換不可の文字コードは '?' (utf-8 の場合 U+FFFD (REPLACEMENT CHARACTER )) に変換
2131 #
2132 # このメソッドは、エラーメッセージ出力でも使用されていることに注意．
2133 #
2134 #msg_enc::Encode | String
2135 def self.str_code_convert( msg, str )
2136 if $b_no_kcode == false then
2137 return str # Ruby V1.8 まで
2138 end
2139 if msg.encoding != str.encoding then
2140 option = { :invalid => :replace, :undef => :replace } # 例外を発生させず、'?' に変換する(utf-8 は 0xfffd)
2141 # return str.encode( msg.encoding, option )
2142 str = str.encode( "utf-8", option )
2143 return str.encode( msg.encoding, option )
2144 else
2145 return str
2146 end
2147 end
2148end
Note: See TracBrowser for help on using the repository browser.