OSDN -- Desarrollar y descargar software de código abierto
Translation Status of Español translation status for es
  • R/O
  • HTTP
  • SSH
  • HTTPS
Fork

Commit

Tags
No Tags

Frequently used words (click to add to your profile)

javac++androidlinuxc#windowsobjective-ccocoa誰得qtpythonphprubygameguibathyscaphec計画中(planning stage)翻訳omegatframeworktwitterdomtestvb.netdirectxゲームエンジンbtronarduinopreviewer

programming language


Commit MetaInfo

Revisión786b9969fff222547f04dec2b8acec39f33e88f2 (tree)
Tiempo2023-02-18 22:49:47
Autordhrname <dhrname@joes...>
Commiterdhrname

Log Message

Move BNF array from parser.hpp to the phrase.hpp

Cambiar Resumen

Diferencia incremental

Binary files a/bin/obj/main.o and b/bin/obj/main.o differ
--- a/include/parser.hpp
+++ b/include/parser.hpp
@@ -139,7 +139,7 @@ namespace jstr
139139 , "=の後に識別子の名前が来るべき"
140140 , "*.の後に識別子の名前が来るべき"
141141 , "セミコロン (;) かコンマ (,) が無い"
142- , "クラスや変数宣言の後に不正な記号がある"
142+ , "クラスや変数や関手宣言の後に不正な記号がある"
143143 , "複合文があるはず"
144144 , "ブロック中の複合文の次に不正な記号がある"
145145 , "ピリオド (.)があるはず"
@@ -316,9 +316,6 @@ namespace jstr
316316
317317 using namespace jstr::parser::token;
318318 using namespace jstr::parser::nonterminal;
319- #define BNF_NONTERMINAL_LENGTH 43
320- #define BNF_SELECTION_LENGTH 11
321- #define BNF_CONCATNATION_LENGTH 10
322319
323320 /*Parser クラス
324321 * 構文解析を行うクラス
@@ -327,901 +324,6 @@ namespace jstr
327324 {
328325 private:
329326
330- /*bnf メンバ変数
331- * 左再帰除去したBNF文法の定義を三次元配列化しておく。例えば、
332- * <a1> := <b2> "hoge" <c3> <終止>
333- * <b2> := "hogehoge" <終止>| "pw" <終止>
334- * <c3> := "end" <終止>
335- * の場合、
336- * 0は連接の終止記号、<x>か大文字のアルファベットは非終端記号、文字列か小文字のアルファベットは終端記号を表すものとするとして、
337- * また、-1は空列<ε>とする
338- * パーサが終止記号を読み出すとパーサエラー（解析失敗）であるので、繰り返しには右再帰を使う
339- * bnf[非終端記号の数=3][選択肢の最大数=2][終止記号を含めた連接の最大数=4] = {
340- * {
341- * {2, "hoge", 3, 0}, {0, 0, 0, 0}
342- * },
343- * {
344- * {"hogehoge", 0, 0, 0}, {"pw", 0, 0, 0}
345- * },
346- * {
347- * {"end", 0, 0, 0}, {0, 0, 0, 0}
348- * }
349- * };
350- * である。
351- * 72年版「構造化プログラミング」第三部の「階層的プログラム構造」を参照
352- * また、左再帰除去については、
353- * A := A α | β
354- * ならば、
355- * A := β A'
356- * A' := α A' | <ε>
357- * 複数の選択肢の左再帰除去については、
358- * A := A α1 | A α2 | ... | A αm | β1 | β1 | ... | βn
359- * ならば、
360- * A := β1 A' | β2 A' | ... | βn A'
361- * A' := α1 A' | α2 A' | ... | αm A' | <ε>
362- * また、その他の左再帰については「コンパイラ　[第2版] - 原理・技法・ツール-」（エイホ他著、2011年）p.228を参照
363- *
364- * トラックバックが無制限に行われるのを防ぐための、
365- * すなわち、選択肢の先頭記号がそれぞれ異なるようにするための、
366- * ウィルトの左くくりだし（エイホの方法とは異なる）については、
367- * S := A | B
368- * A := xA | y
369- * B := xB | z
370- * ならば、
371- * S := C | xS
372- * C := y | z
373- * Aの先頭記号の集合をFIRST(A)とおくと、FIRST(A)とFIRST(A')は互いに素である
374- *
375- * また、Aの後続記号の集合をFOLLOW(A)とおくと、FIRST(A)とFOLLOW(A)は互いに素である
376- * 「アルゴリズム＋データ構造＝プログラム」（ウィルト著、昭和54年）p.326を参照*/
377- const int32_t bnf[BNF_NONTERMINAL_LENGTH][BNF_SELECTION_LENGTH][BNF_CONCATNATION_LENGTH] {
378- {
379- /*modules_statement:
380- CLASS
381- IDENTIFIER
382- prefix_class_list
383- class_body
384- modules_statement
385- | INCLUDE
386- IDENTIFIER
387- LINEEND
388- modules_statement
389- | MAIN
390- COLON
391- statement_list
392- BLOCKEND
393- modules_statement
394- | END
395- | <ε>*/
396- {CLASS
397- , IDENTIFIER
398- , prefix_class_list
399- , class_body
400- , modules_statement}
401- ,{INCLUDE
402- , IDENTIFIER
403- , LINEEND
404- , modules_statement}
405- ,{MAIN
406- , COLON
407- , statement_list
408- , BLOCKEND
409- , modules_statement}
410- ,{END, 0, 0, 0, 0, 0, 0, 0, 0, 0}
411- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
412- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
413- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
414- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
415- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
416- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
417- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
418- }
419- , {
420- /*prefix_class_list: RATIONALLEFT, IDENTIFIER, prefix_class_list
421- | COLON*/
422- {RATIONALLEFT, IDENTIFIER, prefix_class_list}
423- ,{COLON}
424- ,{}
425- ,{}
426- ,{}
427- ,{}
428- ,{}
429- ,{}
430- ,{}
431- ,{}
432- ,{}
433- }
434- , {
435- /*class_body: declaration_list
436- DEFINE
437- functor_list
438- BLOCKEND*/
439- {declaration_list, DEFINE, INDENT, functor_list, BLOCKEND}
440- ,{}
441- ,{}
442- ,{}
443- ,{}
444- ,{}
445- ,{}
446- ,{}
447- ,{}
448- ,{}
449- ,{}
450- }
451- , {
452- /*declaration_list:
453- INDENT
454- declaration
455- declaration_list
456- | <ε>*/
457- {INDENT
458- , declaration
459- , declaration_list}
460- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
461- ,{}
462- ,{}
463- ,{}
464- ,{}
465- ,{}
466- ,{}
467- ,{}
468- ,{}
469- ,{}
470- }
471- , {
472- /*functor_list:
473- FUNCTOR
474- IDENTIFIER
475- COLON
476- statement_list
477- functor_list
478- | <ε>*/
479- {FUNCTOR
480- , IDENTIFIER
481- , COLON
482- , statement_list
483- , functor_list}
484- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
485- ,{}
486- ,{}
487- ,{}
488- ,{}
489- ,{}
490- ,{}
491- ,{}
492- ,{}
493- ,{}
494- }
495- , {
496- /*statement_list :
497- | INDENT
498- statement_list
499- DEDENT
500- | statement
501- statement_list
502- | declaration
503- statement_list
504- | LINEEND
505- | <ε>*/
506- {INDENT
507- , statement_list, DEDENT}
508- ,{statement, statement_list}
509- ,{declaration, statement_list}
510- ,{LINEEND}
511- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
512- ,{}
513- ,{}
514- ,{}
515- ,{}
516- ,{}
517- ,{}
518- }
519- , {
520- /*statement : case_statement
521- | if_statement
522- | for_statement
523- | assignment_statement
524- | while_statement
525- | expression LINEEND
526- | MONAD expression LINEEND
527- | expect_statement
528- | CONTINUE LINEEND
529- | BREAK LINEEND
530- | do_while_statement*/
531- {case_statement}
532- ,{if_statement}
533- ,{for_statement}
534- ,{assignment_statement}
535- ,{while_statement}
536- ,{expression, LINEEND}
537- ,{MONAD, expression, LINEEND}
538- ,{expect_statement}
539- ,{CONTINUE, LINEEND}
540- ,{BREAK, LINEEND}
541- ,{do_while_statement}
542- }
543- , {
544- /*declaration : type_specifier
545- IDENTIFIER
546- name_list
547- bee_constant
548- LINEEND
549- | DETACH
550- LINEEND
551- | CALL
552- IDENTIFIER
553- LINEEND
554- | RESUME
555- IDENTIFIER
556- LINEEND
557- | JERROR
558- LINEEND*/
559- {type_specifier
560- , IDENTIFIER
561- , name_list
562- , bee_constant
563- , LINEEND}
564- ,{DETACH, LINEEND}
565- ,{CALL, IDENTIFIER, LINEEND}
566- ,{RESUME, IDENTIFIER, LINEEND}
567- ,{JERROR, LINEEND}
568- ,{}
569- ,{}
570- ,{}
571- ,{}
572- ,{}
573- ,{}
574- }
575- , {
576- /*bee_constant : assign_operator
577- expression
578- | <ε>*/
579- {assign_operator, expression}
580- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
581- ,{}
582- ,{}
583- ,{}
584- ,{}
585- ,{}
586- ,{}
587- ,{}
588- ,{}
589- ,{}
590- }
591- , {
592- /*assign_operator : ASSIGN
593- | ASSIGNMUL
594- | ASSIGNDIV
595- | ASSIGNREMAINDER
596- | ASSIGNADD
597- | ASSIGNSUB
598- | ASSIGNSHIFTLEFT
599- | ASSIGNSHIFTRIGHT*/
600- {ASSIGN}
601- ,{ASSIGNMUL}
602- ,{ASSIGNDIV}
603- ,{ASSIGNREMAINDER}
604- ,{ASSIGNADD}
605- ,{ASSIGNSUB}
606- ,{ASSIGNSHIFTLEFT}
607- ,{ASSIGNSHIFTRIGHT}
608- ,{}
609- ,{}
610- ,{}
611- }
612- , {
613- /*case_statement : CASE
614- expression
615- COLON
616- INDENT
617- case_type_list*/
618- {CASE
619- , expression
620- , COLON
621- , INDENT
622- , case_type_list}
623- ,{}
624- ,{}
625- ,{}
626- ,{}
627- ,{}
628- ,{}
629- ,{}
630- ,{}
631- ,{}
632- ,{}
633- }
634- , {
635- /*case_type_list:
636- TYPE
637- IDENTIFIER
638- COLON
639- statement_list
640- case_type_list
641- | <ε>*/
642- {TYPE
643- , IDENTIFIER
644- , COLON
645- , statement_list
646- , case_type_list}
647- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
648- ,{}
649- ,{}
650- ,{}
651- ,{}
652- ,{}
653- ,{}
654- ,{}
655- ,{}
656- ,{}
657- }
658- , {
659- /*while_statement : WHILE
660- expression
661- COLON
662- statement_list*/
663- {WHILE
664- , expression
665- , COLON
666- , statement_list}
667- ,{}
668- ,{}
669- ,{}
670- ,{}
671- ,{}
672- ,{}
673- ,{}
674- ,{}
675- ,{}
676- ,{}
677- }
678- , {
679- /*if_statement : IF
680- expression
681- COLON
682- statement_list
683- bee_else_part*/
684- {IF
685- , expression
686- , COLON
687- , statement_list
688- , bee_else_part}
689- ,{}
690- ,{}
691- ,{}
692- ,{}
693- ,{}
694- ,{}
695- ,{}
696- ,{}
697- ,{}
698- ,{}
699- }
700- , {
701- /*bee_else_part :
702- ELSE
703- statement_list
704- | ELSEIF
705- expression
706- COLON
707- statement_list
708- bee_else_part
709- | <ε>*/
710- {ELSE, statement_list}
711- ,{ELSEIF
712- , expression
713- , COLON
714- , statement_list
715- , bee_else_part}
716- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
717- ,{}
718- ,{}
719- ,{}
720- ,{}
721- ,{}
722- ,{}
723- ,{}
724- ,{}
725- }
726- , {
727- /*for_statement : FOR
728- declaration
729- LINEEND
730- expression
731- LINEEND
732- expression
733- COLON
734- statement_list*/
735- { FOR
736- , declaration
737- , LINEEND
738- , expression
739- , LINEEND
740- , expression
741- , COLON
742- , statement_list}
743- ,{}
744- ,{}
745- ,{}
746- ,{}
747- ,{}
748- ,{}
749- ,{}
750- ,{}
751- ,{}
752- ,{}
753- }
754- , {
755- /*assignment_statement: IDENTIFIER
756- name_list
757- bee_constant*/
758- {IDENTIFIER, name_list, bee_constant}
759- ,{}
760- ,{}
761- ,{}
762- ,{}
763- ,{}
764- ,{}
765- ,{}
766- ,{}
767- ,{}
768- ,{}
769- }
770- , {
771- /*name_list: ARGUMENTSEPARATOR
772- IDENTIFIER
773- name_list
774- | <ε>*/
775- {ARGUMENTSEPARATOR
776- , IDENTIFIER
777- , name_list}
778- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
779- ,{}
780- ,{}
781- ,{}
782- ,{}
783- ,{}
784- ,{}
785- ,{}
786- ,{}
787- ,{}
788- }
789- , {
790- /*expect_statement: EXPECT
791- expression
792- COLON
793- statement_list
794- | EXCEPT
795- expression
796- COLON
797- statement_list*/
798- {EXPECT, expression, COLON, statement_list}
799- ,{EXCEPT, expression, COLON, statement_list}
800- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
801- ,{}
802- ,{}
803- ,{}
804- ,{}
805- ,{}
806- ,{}
807- ,{}
808- ,{}
809- }
810- , {
811- /*type_specifier : VOID
812- | text_type
813- | BOOLEAN
814- | integer_type
815- | real_type
816- | OBJECT
817- | LAMBDA
818- | CONST type_specifier
819- | DIJKSTRA*/
820- {VOID}
821- ,{text_type}
822- ,{BOOLEAN}
823- ,{integer_type}
824- ,{real_type}
825- ,{OBJECT}
826- ,{LAMBDA}
827- ,{CONST, type_specifier}
828- ,{DIJKSTRA}
829- ,{}
830- ,{}
831- }
832- , {
833- /*text_type : CHARACTER8
834- | CHARACTER16
835- | CHARACTER32
836- | CHARACTER64*/
837- {CHARACTER8}
838- ,{CHARACTER16}
839- ,{CHARACTER32}
840- ,{CHARACTER64}
841- ,{}
842- ,{}
843- ,{}
844- ,{}
845- ,{}
846- ,{}
847- ,{}
848- }
849- , {
850- /*integer_type : INTEGER8
851- | INTEGER16
852- | INTEGER32
853- | INTEGER64
854- | UINTEGER8
855- | UINTEGER16
856- | UINTEGER32
857- | UINTEGER64*/
858- {INTEGER8}
859- ,{INTEGER16}
860- ,{INTEGER32}
861- ,{INTEGER64}
862- ,{UINTEGER8}
863- ,{UINTEGER16}
864- ,{UINTEGER32}
865- ,{UINTEGER64}
866- ,{}
867- ,{}
868- ,{}
869- }
870- , {
871- /*real_type : FLOAT
872- | DOUBLE*/
873- {FLOAT}
874- ,{DOUBLE}
875- ,{}
876- ,{}
877- ,{}
878- ,{}
879- ,{}
880- ,{}
881- ,{}
882- ,{}
883- ,{}
884- }
885- , {
886- /*primary_expression := IDENTIFIER
887- | UNSIGNEDINTEGER
888- | UNSIGNEDNUMBER
889- | THIS
890- | TEXT
891- | PARENBEGIN
892- expression
893- PARENEND*/
894- {IDENTIFIER}
895- ,{UNSIGNEDINTEGER}
896- ,{UNSIGNEDNUMBER}
897- ,{THIS}
898- ,{TEXT}
899- ,{PARENBEGIN, expression, PARENEND}
900- ,{}
901- ,{}
902- ,{}
903- ,{}
904- ,{}
905- }
906- , {
907- /*unary_expression:= <not_expression>
908- | <unary_plusplus_expression>
909- | <unary_minusminus_expression>
910- | <unary_plus_expression>
911- | <unary_minus_expression>
912- | <postfix_expression>
913- | <allocation_expression>
914- | <free_expression>
915- * 非終端記号で左再帰でないものについては、
916- * あらかじめ展開しておく*/
917- {NOT, unary_expression}
918- ,{UNARYPLUSPLUS, unary_expression}
919- ,{UNARYMINUSMINUS, unary_expression}
920- ,{ADD, unary_expression}
921- ,{SUB, unary_expression}
922- ,{postfix_expression}
923- ,{NEW, IDENTIFIER, PARENBEGIN, expression_body, PARENEND}
924- ,{DELETE, IDENTIFIER}
925- ,{}
926- ,{}
927- ,{}
928- }
929- , {
930- /*<postfix_expression> := primary_expression
931- | primary_expression arrow_expression postfix_expression_list
932- | primary_expression arrow_composition_expression postfix_expression_list
933- | primary_expression postfix_plusplus_expression postfix_expression_list
934- | primary_expression postfix_minusminus_expression postfix_expression_list*/
935- {primary_expression}
936- ,{primary_expression, arrow_expression, postfix_expression_list}
937- ,{primary_expression, arrow_composition_expression, postfix_expression_list}
938- ,{primary_expression, postfix_plusplus_expression, postfix_expression_list}
939- ,{primary_expression, postfix_minusminus_expression, postfix_expression_list}
940- ,{}
941- ,{}
942- ,{}
943- ,{}
944- ,{}
945- ,{}
946- }
947- , {
948- /*以下はpostfix_expressionを左再帰除去したもの
949- * <postfix_expression_list> := arrow_expression
950- postfix_expression_list
951- | arrow_composition_expression postfix_expression_list
952- | postfix_plusplus_expression postfix_expression_list
953- | postfix_minusminus_expression postfix_expression_list
954- | <ε>*/
955- {arrow_expression, postfix_expression_list}
956- ,{arrow_composition_expression, postfix_expression_list}
957- ,{postfix_plusplus_expression, postfix_expression_list}
958- ,{postfix_minusminus_expression, postfix_expression_list}
959- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
960- ,{}
961- ,{}
962- ,{}
963- ,{}
964- ,{}
965- ,{}
966- }
967- , {
968- /*arrow_expression: PARENBEGIN
969- expression_body
970- PARENEND*/
971- {PARENBEGIN, expression_body, PARENEND}
972- ,{}
973- ,{}
974- ,{}
975- ,{}
976- ,{}
977- ,{}
978- ,{}
979- ,{}
980- ,{}
981- ,{}
982- }
983- , {
984- /*arrow_composition_expression: DOT
985- IDENTIFIER*/
986- {DOT, IDENTIFIER}
987- ,{}
988- ,{}
989- ,{}
990- ,{}
991- ,{}
992- ,{}
993- ,{}
994- ,{}
995- ,{}
996- ,{}
997- }
998- , {
999- /*postfix_plusplus_expression: UNARYPLUSPLUS*/
1000- {UNARYPLUSPLUS}
1001- ,{}
1002- ,{}
1003- ,{}
1004- ,{}
1005- ,{}
1006- ,{}
1007- ,{}
1008- ,{}
1009- ,{}
1010- ,{}
1011- }
1012- , {
1013- /*postfix_minusminus_expression: UNARYMINUSMINUS*/
1014- {UNARYMINUSMINUS}
1015- ,{}
1016- ,{}
1017- ,{}
1018- ,{}
1019- ,{}
1020- ,{}
1021- ,{}
1022- ,{}
1023- ,{}
1024- ,{}
1025- }
1026- /*expression:= <unary_expression>
1027- <expression_simple_list>
1028- | <unary_expression> <conditional_expression>*/
1029- , {
1030- {unary_expression, expression_simple_list}
1031- ,{unary_expression, conditional_expression}
1032- ,{}
1033- ,{}
1034- ,{}
1035- ,{}
1036- ,{}
1037- ,{}
1038- ,{}
1039- ,{}
1040- ,{}
1041- }
1042- /*<conditional_expression>:= CONDITIONALQUESTION
1043- expression
1044- COLON
1045- expression*/
1046- , {
1047- {CONDITIONALQUESTION, expression, COLON, expression}
1048- ,{}
1049- ,{}
1050- ,{}
1051- ,{}
1052- ,{}
1053- ,{}
1054- ,{}
1055- ,{}
1056- ,{}
1057- ,{}
1058- }
1059- /*<expression_simple_list>:= <assign_operator>
1060- <expression_simple_list>
1061- | <multiplicative_operator> <expression_simple_list>
1062- | <ε>*/
1063- , {
1064- {assign_operator, expression_simple_list}
1065- ,{multiplicative_operator, expression_simple_list}
1066- ,{-1}
1067- ,{}
1068- ,{}
1069- ,{}
1070- ,{}
1071- ,{}
1072- ,{}
1073- ,{}
1074- ,{}
1075- }
1076- , {
1077- /*logical_operator: OR
1078- | AND*/
1079- {OR}
1080- ,{AND}
1081- ,{}
1082- ,{}
1083- ,{}
1084- ,{}
1085- ,{}
1086- ,{}
1087- ,{}
1088- ,{}
1089- ,{}
1090- }
1091- , {
1092- /*equality_operator: EQUALITY
1093- | NOTEQUALITY
1094- | <logical_operator>*/
1095- {EQUALITY}
1096- ,{NOTEQUALITY}
1097- ,{logical_operator}
1098- ,{}
1099- ,{}
1100- ,{}
1101- ,{}
1102- ,{}
1103- ,{}
1104- ,{}
1105- ,{}
1106- }
1107- , {
1108- /*rational_operator: RATIONALLEFT
1109- | RATIONALRIGHT
1110- | RATIONALLEFTEQUAL
1111- | RATIONALRIGHTEQUAL
1112- | <equality_operator>*/
1113- {RATIONALLEFT}
1114- ,{RATIONALRIGHT}
1115- ,{RATIONALLEFTEQUAL}
1116- ,{RATIONALRIGHTEQUAL}
1117- ,{equality_operator}
1118- ,{}
1119- ,{}
1120- ,{}
1121- ,{}
1122- ,{}
1123- ,{}
1124- }
1125- , {
1126- /*shift_operator: SHIFTLEFT
1127- | SHIFTRIGHT
1128- | <rational_operator>*/
1129- {SHIFTLEFT}
1130- ,{SHIFTRIGHT}
1131- ,{rational_operator}
1132- ,{}
1133- ,{}
1134- ,{}
1135- ,{}
1136- ,{}
1137- ,{}
1138- ,{}
1139- ,{}
1140- }
1141- , {
1142- /*additive_operator: ADD
1143- | SUB
1144- | <shift_operator>*/
1145- {ADD}
1146- ,{SUB}
1147- ,{shift_operator}
1148- ,{}
1149- ,{}
1150- ,{}
1151- ,{}
1152- ,{}
1153- ,{}
1154- ,{}
1155- ,{}
1156- }
1157- , {
1158- /*multiplicative_operator: MUL
1159- | DIV
1160- | REMAINDER
1161- | <additive_operator>*/
1162- {MUL}
1163- ,{DIV,}
1164- ,{REMAINDER}
1165- ,{additive_operator}
1166- ,{}
1167- ,{}
1168- ,{}
1169- ,{}
1170- ,{}
1171- ,{}
1172- ,{}
1173- }
1174- , {
1175- /*expression_body : IDENTIFIER
1176- COLON
1177- expression
1178- member_list
1179- | <ε>*/
1180- {IDENTIFIER, COLON, expression, member_list}
1181- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1182- ,{}
1183- ,{}
1184- ,{}
1185- ,{}
1186- ,{}
1187- ,{}
1188- ,{}
1189- ,{}
1190- ,{}
1191- }
1192- , {
1193- /*member_list : ARGUMENTSEPARATOR
1194- member_list
1195- | <ε>*/
1196- { ARGUMENTSEPARATOR, member_list}
1197- ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1198- ,{}
1199- ,{}
1200- ,{}
1201- ,{}
1202- ,{}
1203- ,{}
1204- ,{}
1205- ,{}
1206- ,{}
1207- }
1208- , {
1209- /*TODO: do_while_statement*/
1210- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1211- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1212- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1213- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1214- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1215- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1216- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1217- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1218- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1219- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1220- ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1221- }
1222- };
1223-
1224-
1225327 llvm::LLVMContext context;
1226328
1227329
--- a/include/phrase.hpp
+++ b/include/phrase.hpp
@@ -30,6 +30,7 @@
3030 #include <vector>
3131 #include <iterator>
3232 #include <unordered_map>
33+#include <unordered_set>
3334 #include <typeinfo>
3435 #include <type_traits>
3536 #include <stdexcept>
@@ -37,6 +38,11 @@
3738 #include <climits>
3839 #include "node.hpp"
3940
41+/*BNF定義の配列の長さマクロ*/
42+#define BNF_NONTERMINAL_LENGTH 43
43+#define BNF_SELECTION_LENGTH 11
44+#define BNF_CONCATNATION_LENGTH 10
45+
4046 namespace jstr
4147 {
4248 using namespace std;
@@ -198,6 +204,902 @@ namespace jstr
198204 };
199205 }
200206
207+ using namespace token;
208+ using namespace nonterminal;
209+ /*bnf メンバ変数
210+ * 左再帰除去したBNF文法の定義を三次元配列化しておく。例えば、
211+ * <a1> := <b2> "hoge" <c3> <終止>
212+ * <b2> := "hogehoge" <終止>| "pw" <終止>
213+ * <c3> := "end" <終止>
214+ * の場合、
215+ * 0は連接の終止記号、<x>か大文字のアルファベットは非終端記号、文字列か小文字のアルファベットは終端記号を表すものとするとして、
216+ * また、-1は空列<ε>とする
217+ * パーサが終止記号を読み出すとパーサエラー（解析失敗）であるので、繰り返しには右再帰を使う
218+ * bnf[非終端記号の数=3][選択肢の最大数=2][終止記号を含めた連接の最大数=4] = {
219+ * {
220+ * {2, "hoge", 3, 0}, {0, 0, 0, 0}
221+ * },
222+ * {
223+ * {"hogehoge", 0, 0, 0}, {"pw", 0, 0, 0}
224+ * },
225+ * {
226+ * {"end", 0, 0, 0}, {0, 0, 0, 0}
227+ * }
228+ * };
229+ * である。
230+ * 72年版「構造化プログラミング」第三部の「階層的プログラム構造」を参照
231+ * また、左再帰除去については、
232+ * A := A α | β
233+ * ならば、
234+ * A := β A'
235+ * A' := α A' | <ε>
236+ * 複数の選択肢の左再帰除去については、
237+ * A := A α1 | A α2 | ... | A αm | β1 | β1 | ... | βn
238+ * ならば、
239+ * A := β1 A' | β2 A' | ... | βn A'
240+ * A' := α1 A' | α2 A' | ... | αm A' | <ε>
241+ * また、その他の左再帰については「コンパイラ　[第2版] - 原理・技法・ツール-」（エイホ他著、2011年）p.228を参照
242+ *
243+ * トラックバックが無制限に行われるのを防ぐための、
244+ * すなわち、選択肢の先頭記号がそれぞれ異なるようにするための、
245+ * ウィルトの左くくりだし（エイホの方法とは異なる）については、
246+ * S := A | B
247+ * A := xA | y
248+ * B := xB | z
249+ * ならば、
250+ * S := C | xS
251+ * C := y | z
252+ * Aの先頭記号の集合をFIRST(A)とおくと、FIRST(A)とFIRST(A')は互いに素である
253+ *
254+ * また、Aの後続記号の集合をFOLLOW(A)とおくと、FIRST(A)とFOLLOW(A)は互いに素である
255+ * 「アルゴリズム＋データ構造＝プログラム」（ウィルト著、昭和54年）p.326を参照*/
256+ const int32_t BNF[BNF_NONTERMINAL_LENGTH][BNF_SELECTION_LENGTH][BNF_CONCATNATION_LENGTH] {
257+ {
258+ /*modules_statement:
259+ CLASS
260+ IDENTIFIER
261+ prefix_class_list
262+ class_body
263+ modules_statement
264+ | INCLUDE
265+ IDENTIFIER
266+ LINEEND
267+ modules_statement
268+ | MAIN
269+ COLON
270+ statement_list
271+ BLOCKEND
272+ modules_statement
273+ | END
274+ | <ε>*/
275+ {CLASS
276+ , IDENTIFIER
277+ , prefix_class_list
278+ , class_body
279+ , modules_statement}
280+ ,{INCLUDE
281+ , IDENTIFIER
282+ , LINEEND
283+ , modules_statement}
284+ ,{MAIN
285+ , COLON
286+ , statement_list
287+ , BLOCKEND
288+ , modules_statement}
289+ ,{END, 0, 0, 0, 0, 0, 0, 0, 0, 0}
290+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
291+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
292+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
293+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
294+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
295+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
296+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
297+ }
298+ , {
299+ /*prefix_class_list: RATIONALLEFT, IDENTIFIER, prefix_class_list
300+ | COLON*/
301+ {RATIONALLEFT, IDENTIFIER, prefix_class_list}
302+ ,{COLON}
303+ ,{}
304+ ,{}
305+ ,{}
306+ ,{}
307+ ,{}
308+ ,{}
309+ ,{}
310+ ,{}
311+ ,{}
312+ }
313+ , {
314+ /*class_body: declaration_list
315+ DEFINE
316+ functor_list
317+ BLOCKEND*/
318+ {declaration_list, DEFINE, INDENT, functor_list, BLOCKEND}
319+ ,{}
320+ ,{}
321+ ,{}
322+ ,{}
323+ ,{}
324+ ,{}
325+ ,{}
326+ ,{}
327+ ,{}
328+ ,{}
329+ }
330+ , {
331+ /*declaration_list:
332+ INDENT
333+ declaration
334+ declaration_list
335+ | <ε>*/
336+ {INDENT
337+ , declaration
338+ , declaration_list}
339+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
340+ ,{}
341+ ,{}
342+ ,{}
343+ ,{}
344+ ,{}
345+ ,{}
346+ ,{}
347+ ,{}
348+ ,{}
349+ }
350+ , {
351+ /*functor_list:
352+ FUNCTOR
353+ IDENTIFIER
354+ COLON
355+ statement_list
356+ functor_list
357+ | <ε>*/
358+ {FUNCTOR
359+ , IDENTIFIER
360+ , COLON
361+ , statement_list
362+ , functor_list}
363+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
364+ ,{}
365+ ,{}
366+ ,{}
367+ ,{}
368+ ,{}
369+ ,{}
370+ ,{}
371+ ,{}
372+ ,{}
373+ }
374+ , {
375+ /*statement_list :
376+ | INDENT
377+ statement_list
378+ DEDENT
379+ | statement
380+ statement_list
381+ | declaration
382+ statement_list
383+ | LINEEND
384+ | <ε>*/
385+ {INDENT
386+ , statement_list, DEDENT}
387+ ,{statement, statement_list}
388+ ,{declaration, statement_list}
389+ ,{LINEEND}
390+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
391+ ,{}
392+ ,{}
393+ ,{}
394+ ,{}
395+ ,{}
396+ ,{}
397+ }
398+ , {
399+ /*statement : case_statement
400+ | if_statement
401+ | for_statement
402+ | assignment_statement
403+ | while_statement
404+ | expression LINEEND
405+ | MONAD expression LINEEND
406+ | expect_statement
407+ | CONTINUE LINEEND
408+ | BREAK LINEEND
409+ | do_while_statement*/
410+ {case_statement}
411+ ,{if_statement}
412+ ,{for_statement}
413+ ,{assignment_statement}
414+ ,{while_statement}
415+ ,{expression, LINEEND}
416+ ,{MONAD, expression, LINEEND}
417+ ,{expect_statement}
418+ ,{CONTINUE, LINEEND}
419+ ,{BREAK, LINEEND}
420+ ,{do_while_statement}
421+ }
422+ , {
423+ /*declaration : type_specifier
424+ IDENTIFIER
425+ name_list
426+ bee_constant
427+ LINEEND
428+ | DETACH
429+ LINEEND
430+ | CALL
431+ IDENTIFIER
432+ LINEEND
433+ | RESUME
434+ IDENTIFIER
435+ LINEEND
436+ | JERROR
437+ LINEEND*/
438+ {type_specifier
439+ , IDENTIFIER
440+ , name_list
441+ , bee_constant
442+ , LINEEND}
443+ ,{DETACH, LINEEND}
444+ ,{CALL, IDENTIFIER, LINEEND}
445+ ,{RESUME, IDENTIFIER, LINEEND}
446+ ,{JERROR, LINEEND}
447+ ,{}
448+ ,{}
449+ ,{}
450+ ,{}
451+ ,{}
452+ ,{}
453+ }
454+ , {
455+ /*bee_constant : assign_operator
456+ expression
457+ | <ε>*/
458+ {assign_operator, expression}
459+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
460+ ,{}
461+ ,{}
462+ ,{}
463+ ,{}
464+ ,{}
465+ ,{}
466+ ,{}
467+ ,{}
468+ ,{}
469+ }
470+ , {
471+ /*assign_operator : ASSIGN
472+ | ASSIGNMUL
473+ | ASSIGNDIV
474+ | ASSIGNREMAINDER
475+ | ASSIGNADD
476+ | ASSIGNSUB
477+ | ASSIGNSHIFTLEFT
478+ | ASSIGNSHIFTRIGHT*/
479+ {ASSIGN}
480+ ,{ASSIGNMUL}
481+ ,{ASSIGNDIV}
482+ ,{ASSIGNREMAINDER}
483+ ,{ASSIGNADD}
484+ ,{ASSIGNSUB}
485+ ,{ASSIGNSHIFTLEFT}
486+ ,{ASSIGNSHIFTRIGHT}
487+ ,{}
488+ ,{}
489+ ,{}
490+ }
491+ , {
492+ /*case_statement : CASE
493+ expression
494+ COLON
495+ INDENT
496+ case_type_list*/
497+ {CASE
498+ , expression
499+ , COLON
500+ , INDENT
501+ , case_type_list}
502+ ,{}
503+ ,{}
504+ ,{}
505+ ,{}
506+ ,{}
507+ ,{}
508+ ,{}
509+ ,{}
510+ ,{}
511+ ,{}
512+ }
513+ , {
514+ /*case_type_list:
515+ TYPE
516+ IDENTIFIER
517+ COLON
518+ statement_list
519+ case_type_list
520+ | <ε>*/
521+ {TYPE
522+ , IDENTIFIER
523+ , COLON
524+ , statement_list
525+ , case_type_list}
526+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
527+ ,{}
528+ ,{}
529+ ,{}
530+ ,{}
531+ ,{}
532+ ,{}
533+ ,{}
534+ ,{}
535+ ,{}
536+ }
537+ , {
538+ /*while_statement : WHILE
539+ expression
540+ COLON
541+ statement_list*/
542+ {WHILE
543+ , expression
544+ , COLON
545+ , statement_list}
546+ ,{}
547+ ,{}
548+ ,{}
549+ ,{}
550+ ,{}
551+ ,{}
552+ ,{}
553+ ,{}
554+ ,{}
555+ ,{}
556+ }
557+ , {
558+ /*if_statement : IF
559+ expression
560+ COLON
561+ statement_list
562+ bee_else_part*/
563+ {IF
564+ , expression
565+ , COLON
566+ , statement_list
567+ , bee_else_part}
568+ ,{}
569+ ,{}
570+ ,{}
571+ ,{}
572+ ,{}
573+ ,{}
574+ ,{}
575+ ,{}
576+ ,{}
577+ ,{}
578+ }
579+ , {
580+ /*bee_else_part :
581+ ELSE
582+ statement_list
583+ | ELSEIF
584+ expression
585+ COLON
586+ statement_list
587+ bee_else_part
588+ | <ε>*/
589+ {ELSE, statement_list}
590+ ,{ELSEIF
591+ , expression
592+ , COLON
593+ , statement_list
594+ , bee_else_part}
595+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
596+ ,{}
597+ ,{}
598+ ,{}
599+ ,{}
600+ ,{}
601+ ,{}
602+ ,{}
603+ ,{}
604+ }
605+ , {
606+ /*for_statement : FOR
607+ declaration
608+ LINEEND
609+ expression
610+ LINEEND
611+ expression
612+ COLON
613+ statement_list*/
614+ { FOR
615+ , declaration
616+ , LINEEND
617+ , expression
618+ , LINEEND
619+ , expression
620+ , COLON
621+ , statement_list}
622+ ,{}
623+ ,{}
624+ ,{}
625+ ,{}
626+ ,{}
627+ ,{}
628+ ,{}
629+ ,{}
630+ ,{}
631+ ,{}
632+ }
633+ , {
634+ /*assignment_statement: IDENTIFIER
635+ name_list
636+ bee_constant*/
637+ {IDENTIFIER, name_list, bee_constant}
638+ ,{}
639+ ,{}
640+ ,{}
641+ ,{}
642+ ,{}
643+ ,{}
644+ ,{}
645+ ,{}
646+ ,{}
647+ ,{}
648+ }
649+ , {
650+ /*name_list: ARGUMENTSEPARATOR
651+ IDENTIFIER
652+ name_list
653+ | <ε>*/
654+ {ARGUMENTSEPARATOR
655+ , IDENTIFIER
656+ , name_list}
657+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
658+ ,{}
659+ ,{}
660+ ,{}
661+ ,{}
662+ ,{}
663+ ,{}
664+ ,{}
665+ ,{}
666+ ,{}
667+ }
668+ , {
669+ /*expect_statement: EXPECT
670+ expression
671+ COLON
672+ statement_list
673+ | EXCEPT
674+ expression
675+ COLON
676+ statement_list*/
677+ {EXPECT, expression, COLON, statement_list}
678+ ,{EXCEPT, expression, COLON, statement_list}
679+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
680+ ,{}
681+ ,{}
682+ ,{}
683+ ,{}
684+ ,{}
685+ ,{}
686+ ,{}
687+ ,{}
688+ }
689+ , {
690+ /*type_specifier : VOID
691+ | text_type
692+ | BOOLEAN
693+ | integer_type
694+ | real_type
695+ | OBJECT
696+ | LAMBDA
697+ | CONST type_specifier
698+ | DIJKSTRA*/
699+ {VOID}
700+ ,{text_type}
701+ ,{BOOLEAN}
702+ ,{integer_type}
703+ ,{real_type}
704+ ,{OBJECT}
705+ ,{LAMBDA}
706+ ,{CONST, type_specifier}
707+ ,{DIJKSTRA}
708+ ,{}
709+ ,{}
710+ }
711+ , {
712+ /*text_type : CHARACTER8
713+ | CHARACTER16
714+ | CHARACTER32
715+ | CHARACTER64*/
716+ {CHARACTER8}
717+ ,{CHARACTER16}
718+ ,{CHARACTER32}
719+ ,{CHARACTER64}
720+ ,{}
721+ ,{}
722+ ,{}
723+ ,{}
724+ ,{}
725+ ,{}
726+ ,{}
727+ }
728+ , {
729+ /*integer_type : INTEGER8
730+ | INTEGER16
731+ | INTEGER32
732+ | INTEGER64
733+ | UINTEGER8
734+ | UINTEGER16
735+ | UINTEGER32
736+ | UINTEGER64*/
737+ {INTEGER8}
738+ ,{INTEGER16}
739+ ,{INTEGER32}
740+ ,{INTEGER64}
741+ ,{UINTEGER8}
742+ ,{UINTEGER16}
743+ ,{UINTEGER32}
744+ ,{UINTEGER64}
745+ ,{}
746+ ,{}
747+ ,{}
748+ }
749+ , {
750+ /*real_type : FLOAT
751+ | DOUBLE*/
752+ {FLOAT}
753+ ,{DOUBLE}
754+ ,{}
755+ ,{}
756+ ,{}
757+ ,{}
758+ ,{}
759+ ,{}
760+ ,{}
761+ ,{}
762+ ,{}
763+ }
764+ , {
765+ /*primary_expression := IDENTIFIER
766+ | UNSIGNEDINTEGER
767+ | UNSIGNEDNUMBER
768+ | THIS
769+ | TEXT
770+ | PARENBEGIN
771+ expression
772+ PARENEND*/
773+ {IDENTIFIER}
774+ ,{UNSIGNEDINTEGER}
775+ ,{UNSIGNEDNUMBER}
776+ ,{THIS}
777+ ,{TEXT}
778+ ,{PARENBEGIN, expression, PARENEND}
779+ ,{}
780+ ,{}
781+ ,{}
782+ ,{}
783+ ,{}
784+ }
785+ , {
786+ /*unary_expression:= <not_expression>
787+ | <unary_plusplus_expression>
788+ | <unary_minusminus_expression>
789+ | <unary_plus_expression>
790+ | <unary_minus_expression>
791+ | <postfix_expression>
792+ | <allocation_expression>
793+ | <free_expression>
794+ * 非終端記号で左再帰でないものについては、
795+ * あらかじめ展開しておく*/
796+ {NOT, unary_expression}
797+ ,{UNARYPLUSPLUS, unary_expression}
798+ ,{UNARYMINUSMINUS, unary_expression}
799+ ,{ADD, unary_expression}
800+ ,{SUB, unary_expression}
801+ ,{postfix_expression}
802+ ,{NEW, IDENTIFIER, PARENBEGIN, expression_body, PARENEND}
803+ ,{DELETE, IDENTIFIER}
804+ ,{}
805+ ,{}
806+ ,{}
807+ }
808+ , {
809+ /*<postfix_expression> := primary_expression
810+ | primary_expression arrow_expression postfix_expression_list
811+ | primary_expression arrow_composition_expression postfix_expression_list
812+ | primary_expression postfix_plusplus_expression postfix_expression_list
813+ | primary_expression postfix_minusminus_expression postfix_expression_list*/
814+ {primary_expression}
815+ ,{primary_expression, arrow_expression, postfix_expression_list}
816+ ,{primary_expression, arrow_composition_expression, postfix_expression_list}
817+ ,{primary_expression, postfix_plusplus_expression, postfix_expression_list}
818+ ,{primary_expression, postfix_minusminus_expression, postfix_expression_list}
819+ ,{}
820+ ,{}
821+ ,{}
822+ ,{}
823+ ,{}
824+ ,{}
825+ }
826+ , {
827+ /*以下はpostfix_expressionを左再帰除去したもの
828+ * <postfix_expression_list> := arrow_expression
829+ postfix_expression_list
830+ | arrow_composition_expression postfix_expression_list
831+ | postfix_plusplus_expression postfix_expression_list
832+ | postfix_minusminus_expression postfix_expression_list
833+ | <ε>*/
834+ {arrow_expression, postfix_expression_list}
835+ ,{arrow_composition_expression, postfix_expression_list}
836+ ,{postfix_plusplus_expression, postfix_expression_list}
837+ ,{postfix_minusminus_expression, postfix_expression_list}
838+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
839+ ,{}
840+ ,{}
841+ ,{}
842+ ,{}
843+ ,{}
844+ ,{}
845+ }
846+ , {
847+ /*arrow_expression: PARENBEGIN
848+ expression_body
849+ PARENEND*/
850+ {PARENBEGIN, expression_body, PARENEND}
851+ ,{}
852+ ,{}
853+ ,{}
854+ ,{}
855+ ,{}
856+ ,{}
857+ ,{}
858+ ,{}
859+ ,{}
860+ ,{}
861+ }
862+ , {
863+ /*arrow_composition_expression: DOT
864+ IDENTIFIER*/
865+ {DOT, IDENTIFIER}
866+ ,{}
867+ ,{}
868+ ,{}
869+ ,{}
870+ ,{}
871+ ,{}
872+ ,{}
873+ ,{}
874+ ,{}
875+ ,{}
876+ }
877+ , {
878+ /*postfix_plusplus_expression: UNARYPLUSPLUS*/
879+ {UNARYPLUSPLUS}
880+ ,{}
881+ ,{}
882+ ,{}
883+ ,{}
884+ ,{}
885+ ,{}
886+ ,{}
887+ ,{}
888+ ,{}
889+ ,{}
890+ }
891+ , {
892+ /*postfix_minusminus_expression: UNARYMINUSMINUS*/
893+ {UNARYMINUSMINUS}
894+ ,{}
895+ ,{}
896+ ,{}
897+ ,{}
898+ ,{}
899+ ,{}
900+ ,{}
901+ ,{}
902+ ,{}
903+ ,{}
904+ }
905+ /*expression:= <unary_expression>
906+ <expression_simple_list>
907+ | <unary_expression> <conditional_expression>*/
908+ , {
909+ {unary_expression, expression_simple_list}
910+ ,{unary_expression, conditional_expression}
911+ ,{}
912+ ,{}
913+ ,{}
914+ ,{}
915+ ,{}
916+ ,{}
917+ ,{}
918+ ,{}
919+ ,{}
920+ }
921+ /*<conditional_expression>:= CONDITIONALQUESTION
922+ expression
923+ COLON
924+ expression*/
925+ , {
926+ {CONDITIONALQUESTION, expression, COLON, expression}
927+ ,{}
928+ ,{}
929+ ,{}
930+ ,{}
931+ ,{}
932+ ,{}
933+ ,{}
934+ ,{}
935+ ,{}
936+ ,{}
937+ }
938+ /*<expression_simple_list>:= <assign_operator>
939+ <expression_simple_list>
940+ | <multiplicative_operator> <expression_simple_list>
941+ | <ε>*/
942+ , {
943+ {assign_operator, expression_simple_list}
944+ ,{multiplicative_operator, expression_simple_list}
945+ ,{-1}
946+ ,{}
947+ ,{}
948+ ,{}
949+ ,{}
950+ ,{}
951+ ,{}
952+ ,{}
953+ ,{}
954+ }
955+ , {
956+ /*logical_operator: OR
957+ | AND*/
958+ {OR}
959+ ,{AND}
960+ ,{}
961+ ,{}
962+ ,{}
963+ ,{}
964+ ,{}
965+ ,{}
966+ ,{}
967+ ,{}
968+ ,{}
969+ }
970+ , {
971+ /*equality_operator: EQUALITY
972+ | NOTEQUALITY
973+ | <logical_operator>*/
974+ {EQUALITY}
975+ ,{NOTEQUALITY}
976+ ,{logical_operator}
977+ ,{}
978+ ,{}
979+ ,{}
980+ ,{}
981+ ,{}
982+ ,{}
983+ ,{}
984+ ,{}
985+ }
986+ , {
987+ /*rational_operator: RATIONALLEFT
988+ | RATIONALRIGHT
989+ | RATIONALLEFTEQUAL
990+ | RATIONALRIGHTEQUAL
991+ | <equality_operator>*/
992+ {RATIONALLEFT}
993+ ,{RATIONALRIGHT}
994+ ,{RATIONALLEFTEQUAL}
995+ ,{RATIONALRIGHTEQUAL}
996+ ,{equality_operator}
997+ ,{}
998+ ,{}
999+ ,{}
1000+ ,{}
1001+ ,{}
1002+ ,{}
1003+ }
1004+ , {
1005+ /*shift_operator: SHIFTLEFT
1006+ | SHIFTRIGHT
1007+ | <rational_operator>*/
1008+ {SHIFTLEFT}
1009+ ,{SHIFTRIGHT}
1010+ ,{rational_operator}
1011+ ,{}
1012+ ,{}
1013+ ,{}
1014+ ,{}
1015+ ,{}
1016+ ,{}
1017+ ,{}
1018+ ,{}
1019+ }
1020+ , {
1021+ /*additive_operator: ADD
1022+ | SUB
1023+ | <shift_operator>*/
1024+ {ADD}
1025+ ,{SUB}
1026+ ,{shift_operator}
1027+ ,{}
1028+ ,{}
1029+ ,{}
1030+ ,{}
1031+ ,{}
1032+ ,{}
1033+ ,{}
1034+ ,{}
1035+ }
1036+ , {
1037+ /*multiplicative_operator: MUL
1038+ | DIV
1039+ | REMAINDER
1040+ | <additive_operator>*/
1041+ {MUL}
1042+ ,{DIV,}
1043+ ,{REMAINDER}
1044+ ,{additive_operator}
1045+ ,{}
1046+ ,{}
1047+ ,{}
1048+ ,{}
1049+ ,{}
1050+ ,{}
1051+ ,{}
1052+ }
1053+ , {
1054+ /*expression_body : IDENTIFIER
1055+ COLON
1056+ expression
1057+ member_list
1058+ | <ε>*/
1059+ {IDENTIFIER, COLON, expression, member_list}
1060+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1061+ ,{}
1062+ ,{}
1063+ ,{}
1064+ ,{}
1065+ ,{}
1066+ ,{}
1067+ ,{}
1068+ ,{}
1069+ ,{}
1070+ }
1071+ , {
1072+ /*member_list : ARGUMENTSEPARATOR
1073+ member_list
1074+ | <ε>*/
1075+ { ARGUMENTSEPARATOR, member_list}
1076+ ,{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1077+ ,{}
1078+ ,{}
1079+ ,{}
1080+ ,{}
1081+ ,{}
1082+ ,{}
1083+ ,{}
1084+ ,{}
1085+ ,{}
1086+ }
1087+ , {
1088+ /*TODO: do_while_statement*/
1089+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1090+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1091+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1092+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1093+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1094+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1095+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1096+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1097+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1098+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1099+ ,{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1100+ }
1101+ };
1102+
2011103 }
2021104
2031105 class SemanticNetwork: public BaseNode
@@ -337,7 +1239,11 @@ namespace jstr
3371239 * */
3381240 class MetaPhrase: public Phrase
3391241 {
340- public:
1242+ private:
1243+ std::unordered_set<int64_t> firstSet;
1244+ std::unordered_set<int64_t> followSet;
1245+
1246+ public:
3411247 MetaPhrase()
3421248 {}
3431249
@@ -346,6 +1252,14 @@ namespace jstr
3461252 }
3471253
3481254 bool isMeta();
1255+
1256+ /*getFirstSet メンバ関数
1257+ * BNF定義を元にFIRST集合を求める*/
1258+ void getFirstSet();
1259+
1260+ /*getFollowSet メンバ関数
1261+ * BNF定義を元にFOLLOW集合を求める*/
1262+ void getFollowSet();
3491263 };
3501264
3511265 /*Arrow クラス
@@ -353,12 +1267,12 @@ namespace jstr
3531267 * ただし、実際にはhom集合を表す*/
3541268 class Arrow: public MetaPhrase
3551269 {
356- protected:
1270+ protected:
3571271 std::string id;
3581272 std::string domain;
3591273 std::string codomain;
3601274
361- public:
1275+ public:
3621276 Arrow(const std::string& name = "")
3631277 :id{name},
3641278 domain{"#empty"},